ganzganz vielen dank schonmal!!!!

also...
ich möchte eine matrix erstellen, mit dimension no x c. die werte dafür werden vom user eingegeben
die spalten und zeilengroeße soll sich nachher noch aendern das mache ich ueber MAX
ich kann die zahlen in matrix b verwenden um die matrix die ich will zu fuellen

dabei habe ich folgende bedingungen:
der index der zeile darf nicht als zahl in der jeweiligen zeile auftreten
keine zahl darf mehrmals in einer zeile auftreten
wenn ich in der n-ten zeile die zahl 2 verwende muss in der zeile 2 die zahl n erscheinen
jeder eintrag der matrix b muss genau 1 mal verwendet werden

so hab ich angefangen..

#include <iostream>
#include<vector>
#include<cmath>
#include <stdio.h>
#include<cstdlib>
#include <time.h>
#include<errno.h>

#define MAX 10000

using namespace std;

int no;
int c;

int i,j;
int A[MAX][MAX];

int n,m;
int B[MAX][MAX];

int f,g;
int C[MAX][MAX];

int leftOnes[MAX];
int l;

int main()
{

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

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

//Matrix die zu füllen ist
for (i=0;i<no;i++)
{
for(j=0;j<c;j++)

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

//Matrix mit verfügbaren zahlen
for(i=0;i<no;i++)
{
for(j=0;j<c;j++)
{
B[i][j]=i;
printf("%d\t",B[i][j]);
}
printf("\n");
}
cout<<endl;

//Füllen der Matrix
for(i=0;i<no;i++)
{
for(j=0;j<c;j++)
{
if(B[i][j]!=i)
//{

A[i][j]=B[i][j];
//A[n][j]=i;
//}
else

A[i][j]=B[i][j+1];
//8;
//{
//A[i][j]=B[i][j+1];
//n=leftOnes[l];
//continue;
//}
printf("%d\t",A[i][j]);
}
printf("\n");
}
cout<<endl;

}

aaahh...

#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 ^^

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.

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.

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 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

bb

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

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.

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

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...

bb

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

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

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