3. matrix mit gegebenen zahlen fuellen (und noch ein paar bedingungen beruecksichtigen)

matrix mit gegebenen zahlen fuellen (und noch ein paar bedingungen beruecksichtigen)

  • U

    C++ - Tags! ([ cpp] <code> [ /cpp])

    #include <stdio.h> 
#include <cstdlib> 
#include <time.h>

    mal C und mal C++ - Header?!

    printf("%d\t",A[i][j]); 
} 
printf("\n"); 
} 
cout<<endl;

    entscheide dich zwischen C und C++ - und dann post es noch mal ordentlich...

    btw: deine Main-Funktion ist viel zu lang - mach paar Funktionen und ruf die dann dort auf und mach die Variablen nicht alle global - oder wozu brauchst du das? Oo

    in etwa so sollte es vll am ende aussehen:

    #include <iostream> 
#include <vector> //nutzt du ja leider nicht :/
#include <cmath> //scheinst du auch nicht wirklich zu benutzen
#include <stdio.h> //-> <cstdio>
#include <cstdlib> 
#include <time.h> //-> <ctime>
#include <errno.h> //-> <cerrno>

#define MAX 10000
//besser:
const size_t max (10000);

#include "my_matrix"
/*würd ich in etwa so machen:
namespace matrix
{
  void fuellen (/*...* /)
    {
      /*...* /
    }
}
*/
int main() 
  { 
    int A[MAX][MAX]; //etc

    int no (-1), c (-1);

    cout<<"type in number of nodes"<<endl; 
    cin>>no; 

    cout<<"type in number of connections"<<endl; 
    cin>>c; 

    if ((no == -1) || (c == -1))
      {
        //fehler
      }
    //die beiden dinge könnte man auch in ner extra funktion abfragen und die fehlerbehandlung mit da rein tun

    matrix::fuellen (/**/);
  }

    bb

    edit: habs noch fein eingerückt ^^

    0
  • A

    unskilled schrieb:

    in etwa so sollte es vll am ende aussehen:

    Das gilt zwar auch für den OP, aber wenn du ihn schon korrigierst, bitte auch sinnvoll einrücken, so tuen sich die wenigsten den Code an.

    Es empfinden zwar viele als Gängelung, nur wenn jemand will das man seinen Code auch wirklich anschaut, sollte er diesen so schreiben, das andere damit nicht unnötig viel Zeit für das Lesen verschwenden.

    cu André
    P.S: Wenn ich gleich Zeit finde werde ich mir den OP-Code mal anschauen, anpassen und mit sinnvollen Einrückungen posten.

    0
  • D

    P.S: Wenn ich gleich Zeit finde werde ich mir den OP-Code mal anschauen, anpassen und mit sinnvollen Einrückungen posten.

    Glaub mir. Das macht keinen Sinn. Schreib lieber eine eigene Implementierung. Sein Code ist so verwirrend. Da bist du mit was eigenem selber schneller.

    0
  • U

    asc schrieb:

    unskilled schrieb:

    in etwa so sollte es vll am ende aussehen:

    Das gilt zwar auch für den OP, aber wenn du ihn schon korrigierst, bitte auch sinnvoll einrücken, so tuen sich die wenigsten den Code an.

    Also ich habe genau an einer einzigen stelle nicht eingerückt - und dort ist es ja nun wirklich offensichtlich... aber na ok - ich korrigier das...

    bb

    0
  • B

    unskilled schrieb:

    asc schrieb:

    unskilled schrieb:

    in etwa so sollte es vll am ende aussehen:

    Das gilt zwar auch für den OP, aber wenn du ihn schon korrigierst, bitte auch sinnvoll einrücken, so tuen sich die wenigsten den Code an.

    Also ich habe genau an einer einzigen stelle nicht eingerückt - und dort ist es ja nun wirklich offensichtlich... aber na ok - ich korrigier das...

    bb

    asc meinte wohl den ganzen Inhalt des Main-Blocks 😉

    0
  • U

    joar - also ein einziges mal, wo ich nich eingerückt hab ^^
    und das ist meines erachtens das offensichtlichste - aber ich habs ja scho verbessert *keks will* ^^

    bb

    0
  • B

    unskilled schrieb:

    joar - also ein einziges mal, wo ich nich eingerückt hab ^^
    und das ist meines erachtens das offensichtlichste - aber ich habs ja scho verbessert *keks will* ^^

    bb

    Hast du FAST brav gemacht, denn wenn du "int main()" schreibst, dann solltest du auch an den Rückgabewert denken und zumindest ein "return 0;" anhängen 😉

    0
  • D

    dann solltest du auch an den Rückgabewert denken und zumindest ein "return 0;" anhängen

    Muss nicht sein. Ist völlig korrekt, wenn er es weglässt. Hatten wir hier schon mindestens 1000 mal.

    0
  • B

    drakon schrieb:

    dann solltest du auch an den Rückgabewert denken und zumindest ein "return 0;" anhängen

    Muss nicht sein. Ist völlig korrekt, wenn er es weglässt. Hatten wir hier schon mindestens 1000 mal.

    Gut, der Kompiler hängt das nun an, wenn man keine Rückgabe angibt. Es ist dann wohl eine Frage des persönlichen Geschmacks. Meiner geht dahin, int main() mit einem return 0; zu beenden 😉

    0
  • N

    Berufspenner schrieb:

    dann solltest du auch an den Rückgabewert denken und zumindest ein "return 0;" anhängen

    Das ist etwa gleich unnötig wie void in leeren Parameterlisten 😉
    Aber eben, Geschmackssache...

    0
  • U

    Wenn er eh schon die cstdlib included hat, dann würd ich eh (wenn überhaupt) nen return EXIT_SUCCESS; nehmen... In meinen eigenen Programmen bin ich auch eher dafür, das return explizit mit hinzuschreiben - aber hier isses 1. nur nen bsp und au so völlig legal und 2. sieht man ja, dass da unten eh noch ganz viel fehlt...

    bb

    0
  • L

    ja ich hatte in dem code schon ne ganze menge drin deshalb all die bibliotheken...
    und die kommentare hatte ich drin weil ich dachte dann versteht man vielleicht besser was ich vorhatte..

    also vielen dank fuer die bearbeitung des codes,
    jetzt sieht er wenigstens schon mal besser aus... 😉

    0
  • L

    ok und dann zu meiner erklaerung...

    ich moechte eine matrix deren dimension vom user eingegeben wird.
    es werden am ende sehr grosse also vlt 10.000 x 100 matritzen werden..
    aber sagen wir es wird eiene 4x5 matrix vorgegeben...
    dann soll diese matrix mit 5 mal den zahlen 0,1,2,3 gefuellt werden.
    aber halt so, dass keine zahl pro zeile zweimal vorkommt.
    ausserdem darf der index derjeweiligen zeile nicht vorkommen.
    und jedes mal wenn ich eine zahl in eine zeile schreibe muss der index dieser zeile als zahl in der zeile mitdem index der ersten zahl stehen.
    also wenn ich die 4 in die 1. zeile schreibe muss die 1 in der 4. zeile stehen.
    (egal wo)
    trotzdem kann ich die matrix so mit 5 mal den zahlen 0,1,2,3 genau fuellen.

    war das besser??

    wer super wenn ihr was wuesstet wie gesagt bin echt am ende...

    lg
    LOUb

    0
  • U

    LOUb schrieb:

    ok und dann zu meiner erklaerung...

    ok, dann wollen wir das mal auseinander nehmen... oder versuchen ^^

    LOUb schrieb:

    ich moechte eine matrix deren dimension vom user eingegeben wird.

    Hier hast du sehr viele Möglichkeiten, dieses zu realisieren...

    /* gilt immer als global in dem bsp. */

const size_t cols (100);
const size_t rows (100);

/* 1 */
template <class T>
  struct types
    {
      typedef typename std::vector <T> row;
      typedef std::vector <row> matrix;
    };

int main ()
  {
    types <int>::matrix matrix;
    for (size_t i (0); i != rows; ++i)
      {
        types <int>::row topushback;
        for (size_t j (0); i != cols; ++j)
          {
            j.push_back (0);
          }
        matrix.push_back (topushback);
      }
  }

/* 2 */
template <class T>
  struct types
    {
      typedef T*  row;
      typedef row* matrix;
    };

int main ()
  {
    types <int>::matrix matrix = new types <int>::row [rows];
    for (size_t i (0); i != rows; ++i)
      {
        matrix[i] = new int [cols];
      }
//benutzen
    for (size_t i (0); i != cols; ++i)
      {
        delete []matrix[i];
      }
    delete []matrix;
  }

/* 3 und eigtl noch 4 */
/*aus den jeweiligen 2d-arrays nen 1d-array machen...
 also so was in der art:*/
std::vector <int> matrix (x*y); //oder std::vector <int> matrix; und dann alles einzeln mit push_back anfügen
//bzw.
int *matrix = new int[x*y];

    Die Eingabe des Benutzers von wegen x und y (cols / rows) und Fehlerbehandlung bekommst du sicherlich hin, oder?

    LOUb schrieb:

    dann soll diese matrix mit 5 mal den zahlen 0,1,2,3 gefuellt werden.
    aber halt so, dass keine zahl pro zeile zweimal vorkommt.
    ausserdem darf der index derjeweiligen zeile nicht vorkommen.

    sollte ja nicht sooo schwer sein?! (ich hab das bsp mal für die variante mit den beiden vectoren genommen)

    template <class T>
void fill_matrix (std::vector < std::vector < T > > &matrix, const size_t row)
  {
    const size_t cols (matrix[row].size ());
    std::vector <T> fill_with;
    for (size_t i (0); i < row; ++i)
      {
        fill_with.push_back (i);
      }
    for (size_t i (row+1); i < cols; ++i)
      {
        fill_with.push_back (i);
      }
/*falls du zufällig meinst:*/ std::random_shuffle (fill_with.begin (), fill_with.end ());
    for (size_t i (0); i != cols; ++i)
      {
        matrix[row][i] = fill_with[i];
      }
  }

    LOUb schrieb:

    und jedes mal wenn ich eine zahl in eine zeile schreibe muss der index dieser zeile als zahl in der zeile mitdem index der ersten zahl stehen.
    also wenn ich die 4 in die 1. zeile schreibe muss die 1 in der 4. zeile stehen.

    Wie kommt man denn auf so eine Idee? Was soll das bewirken, was du hier machst? Und willst du jedes mal erst gucken, ob du die Zahl in die Zeile schreiben darfst? Ich meine, was ist, wenn du ne Matrix x*y hast und aber irgendwo x+1 oder so reinschreibst? oder in die zeile 1 ne 1 schreibst? darfst du das oder nicht?
    versuch einfach erst mal mit dem oben da zurechtzukommen...

    bb

    0
Anmelden zum Antworten