Mehrdimensionale Vektoren

[MrTonnu (Gast)]

Hallo,

ich bin zufällig auf diese Seite gestoßen und hoffe ihr könnt mir bei 
einer Aufgabe helfen.

Und zwar muss ich ein Programm schreiben, welches Zufallszahlen 
generiert, diese in einem Vektor speichert und ausgibt.

Die Zahlen sollen in einem zweidimensionalem Vektor abgelegt werden (zum 
Beispiel so):
int puffer[5][2]={{1, 9},{2, 30},{3, 22},{4, 54},{5, 7}}

Und dann soll das Programm dies ausgeben.

Zufallszahlen generieren mach ich so:

int main(void)
{
  int i, j;

  j = 5;                     //5 Zahlen werden ausgegeben

    srand (time(NULL));
    for (i=0 ; i< j ; i++)
    {
        printf("Zufallszahl: %d\n", rand()%1000);
    }
    return 0;

}

Leider komm ich bei dieser Aufgabe nicht weiter und hoffe auf einen 
kleinen Denkanstoß.

Liebe Grüße

[Dussel (Gast)]

Anscheinend ist die Anzahl der Zahlen vorher klar.
Einer Variable kann man den Zufallswert mit

int a=rand()%1000;

zuweisen.
Einem Element in einem Array, deinem 'Vektor' kann man mit

Puffer[x][y]=var;

einen Wert zuweisen.
Der Zugriff auf die einzelnen Elemente geht über zwei verschachtelte 
Schleifen oder indem direkt in einem Schleifendurchlauf beide Felder in 
der 'Zeile' des Vektors zugewiesen werde.

[MrTonnu (Gast)]

Bei dem Beispiel habe ich vorher nur getestet, wie man Zahlen zufällig 
generiert (in dem Fall Zahlen bis 1000).
Leider komm ich trotzdem nicht weiter. Habe aber noch im Internet etwas 
über malloc gefunden.

[Dussel (Gast)]

Dann schreib mal, wo du nicht weiterkommst. Wie Schleifen funktionieren, 
man Zufallszahlen erzeugt und wie man ein Array anlegt, weißt du 
anscheinend, wie man dann auf die Arrayelemente zugreift, habe ich 
geschrieben. Das ist alles, was man für die Aufgabe braucht.

[Lehrerin (Gast)]

MrTonnu schrieb:
> Die Zahlen sollen in einem zweidimensionalem Vektor abgelegt werden (zum
> Beispiel so):
> int puffer[5][2]={{1, 9},{2, 30},{3, 22},{4, 54},{5, 7}}

Das ist kein zweidimensionaler Vektor. Ein zweidimensionaler Vektor hat 
genau 2 Komponenten.

> Leider komm ich bei dieser Aufgabe nicht weiter und hoffe auf einen
> kleinen Denkanstoß.

Ein Denkanstoß wäre, die Klasse zu wieder holen. Oder zwei. Oder ein 
paar mehr.

[Dirk B. (dirkb2)]

Lehrerin schrieb:
> Das ist kein zweidimensionaler Vektor.
Was ist es dann?

[Troll (Gast)]

Hör nicht auf den Troll - es ist sehr wohl ein zweidimensionales Array 
(du studierst sicher an einer Hochschule oder? Denn Vektor nennt das 
sonst eigentlich niemand :))

[MrTonnu (Gast)]

Genau, wiederholen wird ebenso schwer, wenn man Informatik zum ersten 
Mal macht.

Ein Array wäre doch:

int arr[5][2];

Der Zugriff erfolgt damit:

Puffer[x][y]=var;

Meinen Zufallswert bekomme ich durch:

int a=rand()% 1000

Ebenso muss ich for-Schleifen verwenden, damit mein Array die Werte 
bekommt:

for (i = 0, i = j, i++);

Irgendwie bin ich so durcheinander, dass ich keine sinnvolle Funktion 
aufstellen kann.

[MrTonnu (Gast)]

Jetzt hab ich schonmal einen kleinen Ansatz, jedoch falsch..

int main(void)
{
  int i,j;
  int arr[2][5];

  for(i = 0; i < 2; i++) //
    for(i = 0; i < 5; i++)
        printf("Index[%d]: Zufallszahl %d\n", i, arr[2]); // Array anzeigen

      return 0;
}

Die Ausgabe ist diese:
Index[0]: Zufallszahl 2673692
Index[1]: Zufallszahl 2673692
Index[2]: Zufallszahl 2673692
Index[3]: Zufallszahl 2673692
Index[4]: Zufallszahl 2673692

Wie füge ich das jetzt mit meiner Zufallszahl hinzu?

[Dussel (Gast)]

Ich würde das erstmal 'eindimensional' machen. Was musst du tun?

Mehrmals (in einer Schleife)
1. Zufallszahl erzeugen
2. An der richtigen Stelle ins Array einfügen

Danach, wieder mit einer Schleife
4. Die Zahlen nacheinander ausgeben.


In deinem Beispiel greifst du immer auf das gleiche Arrayelement zu und 
hast in beiden Schleifen die gleiche Variable.

[MrTonnu (Gast)]

Wenn ich mein Programm so schreibe:

int main(void)
{
  int i,j;
  int arr[2];

  srand(time(NULL));
  for(i = 0; i < j; i++)
  {
    printf("Index: %d\n", rand()%1000);
  }

      return 0;
}

komme ich in eine Endlos-Schleife

[Gerd (Gast)]

Geh das Programm mal Schritt Für Schritt durch
und schreibe für jeden Schritt alle Variablen und
deren Werte auf und was passieren soll:

Start:
i = []
j = []
arr = [][]

Zuweisung
j = 5

for-Schleife betreten, Zuweisung
i = 0

prüfen i < j ?
0 < 5

Bedingung erfüllt, Schleifenrumpf betreten
[Was muss hier jetzt passieren?]

i um eins erhöhen
i=1;

prüfen i < j ?
1 < 5

Schleifenrumpf erneut betreten
[...]

[Dussel (Gast)]

Teilaufgaben:
1. Wie erstellt man eine Schleife mit einer bestimmten Anzahl an 
Durchläufen? (Ist ja oben schon teilweise gelöst)
2. Wie weist man in der Schleife jedem Feld eines Arrays einen Wert zu?
3. Wie macht man das gleiche bei einem mehrdimensionalen Feld?

Probier das mal nacheinander aus und berichte. Davon abgesehen ist j 
nicht initialisiert.

[Dirk B. (dirkb2)]

Troll schrieb:
> Denn Vektor nennt das
> sonst eigentlich niemand :))

Das heißt so in der ersten Auflage vom K&R. Zumindest im deutschen.

[Dirk B. (dirkb2)]

MrTonnu schrieb:
> Jetzt hab ich schonmal einen kleinen Ansatz, jedoch falsch..
>
>

int main(void)
> {
>   int i,j;
>   int arr[2][5];
> 
>   for(i = 0; i < 2; i++) //
>     for(i = 0; i < 5; i++)
>         printf("Index[%d]: Zufallszahl %d\n", i, arr[2]); // Array 
> anzeigen
> 
>       return 0;
> }

>
> Die Ausgabe ist diese:
> Index[0]: Zufallszahl 2673692
> Index[1]: Zufallszahl 2673692
> Index[2]: Zufallszahl 2673692
> Index[3]: Zufallszahl 2673692
> Index[4]: Zufallszahl 2673692
>
> Wie füge ich das jetzt mit meiner Zufallszahl hinzu?

Du hast zwei inneinander verschachtelte Schleifen mit derselben 
Laufvariable.
Du greifst auf ein Zweidimensionales Array nur mit einer Dimension zu.
Du achtest nicht auf Warnungen vom Compiler.

Du hast Arrays (auch eindiminsonale) nicht verstanden.

#define ANZAHL 5
int main(void)
{
  int arr[ANZAHL];

  for(int i = 0; i < ANZAHL; i++) //
    arr[i] = rand();  // Array mit zufallszahlen füllen


  for(int i = 0; i < ANZAHL; i++) //
    printf("Index[%d]: Zufallszahl %d\n", i, arr[i]); // Array anzeigen

  return 0;
}

[MrTonnu (Gast)]

#define Puffergroesse 128
#define spalte1 0
#define spalte2 1

void qs(int num[][dim2], int unten, int oben) {
  int i, j;
  long int mitte, puffer[Puffergroesse][dim2] = { { 0 } };

  i = unten;
  j = oben;
  mitte = num[(unten + oben) / 2][spalte2]; // mittleres Element

  do {
    while (num[i][spalte2] < mitte && i < oben)
      i++; // such Element f¸r "grofle Klasse"
    while (mitte < num[j][spalte2] && j > unten)
      j--;     // such Element f¸r "kleine Klasse"

    if (i <= j) {
      puffer[0][spalte2] = num[i][spalte2];
      puffer[0][spalte1] = num[i][spalte1];
      num[i][spalte2] = num[j][spalte2];
      num[i][spalte1] = num[j][spalte1];
      num[j][spalte2] = puffer[0][spalte2];     // vertausche Elemente
      num[j][spalte1] = puffer[0][spalte1];
      i++;
      j--;
    }
  } while (i <= j);

  if (unten < j)
    qs(num, unten, j);            // Aufruf f¸r "kleine Klasse"
  if (i < oben)
    qs(num, i, oben);  // Aufruf f¸r "grofle Klasse"
}

int main(void) {
  int i, x, j;
  int num[dim1][dim2];
  time_t t;

  srand((unsigned) time(&t));
//Array zuweisen
  for (i = 0; i < dim1; i++) {
    for (j = 0; j < dim2; j++) {
      if (j == 0) {
        num[i][j] = i + 1;
      } else {
        x = rand() % 1000;
        num[i][j] = x;
      }
    }
  }

  qs(num, 0, dim1 - 1);

//Ausgabe
  printf("\tIndex\tZufallszahlen\n");
  for (i = 0; i < dim1; i++) {
    for (j = 0; j < dim2; j++) {
      printf("\t%d", num[i][j]);
    }
    printf("\n");
  }
}

Ich hab es tatsächlich geschafft diese Aufgabe zu lösen. Danke für die 
super Hilfe. Nun wollte ich noch fragen, da ich die zweite Spalte 
sortieren muss, muss ich dafür eine Quicksort Funktion hinzufügen (diese 
habe ich so bekommen). Leider komme ich nicht ganz dahinter was ab 'do' 
passiert. Ich versuche es mal:

do {
    while (num[i][spalte2] < mitte && i < oben)
      i++; // such Element f¸r "grofle Klasse"

Tue dies solange die 'Num[i]' kleiner ist als 'Mitte' und 'i' kleiner 
'oben. Zähle zu 'i' einen "dazu" ('i++').

while (mitte < num[j][spalte2] && j > unten)
      j--;     // such Element f¸r "kleine Klasse"

Tue dies solange 'Mitte' kleiner als 'Num[j] und 'j' größer als 'unten'. 
Zieh von 'j' ab ('j--').

if (i <= j) {
      puffer[0][spalte2] = num[i][spalte2];
      puffer[0][spalte1] = num[i][spalte1];
      num[i][spalte2] = num[j][spalte2];
      num[i][spalte1] = num[j][spalte1];
      num[j][spalte2] = puffer[0][spalte2];     // vertausche Elemente

Das hier kann ich mir nicht erklären..

Und noch was: Wie kann ich das verstehen? Hatte das so leider aus dem 
Internet

srand((unsigned) time(&t));

Vielen Dank an alle.
LG MrTonnu

[Dussel (Gast)]

Ehrlich gesagt, bin ich positiv überrascht. Ich hatte erst den Eindruck, 
dass du nur einen Dummen suchst, der dir die Hausaufgaben macht.

Ich kann jetzt nicht durch den ganzen Code durchsteigen, aber mal eine 
kurze Hilfe, wie Quicksort funktioniert und es anscheinend hier 
umgesetzt wurde:

Man sucht sich ein beliebiges Element und sortiert alle Elemente, die 
kleiner sind nach links und alle die größer sind, nach rechts. Das 
'Trennelement' (Pivotelement) setzt man dazwischen. Dann hat man
{Kleinere Elemente},Pivot,{Größere Elemente}
Das gleiche kann man für {Kleinere Elemente} und {Größere Elemente} 
wieder machen und bekommt so immer kleinere sortierte Einzelarrays.
Das ganze wird hier rekursiv gemacht, also so, dass man die 
Sortierfunktion für die vorsortierten Einzelarray wieder aufruft.

Das Umsortieren kann man machen, indem man von links so lange durch das 
Array geht, bis man ein größeres Element gefunden hat und von recht so 
lange, bis man ein kleineres Element gefunden hat. Die beiden vertauscht 
man dann. Damit ist sichergestellt, dass sich amlinken Rand nur kleinere 
Elemente und am rechten Rand nur größere Elemente befinden.

[MrTonnu (Gast)]

Vielen Dank für deine Antwort. Nein, hatte wie gesagt einen Aussetzer 
und kam einfach nicht auf die Lösung. Jetzt, nach intensivem Lernen und 
probieren, stellt man fest wie einfach das doch eigentlich war. Wohl 
typisches Programmier-Anfänger-Problem :D

Also nochmal Danke für die Erklärung!

[JB (Gast)]

>Wohl typisches Programmier-Anfänger-Problem :D

Vor allen wirst du das nie wieder vergessen, du hast das GELERNT. Als 
guter Programmierer muss man sich seinem Unwissen und Unvermögen 
stellen, den Kampf gewonnen lacht man nur über neue Syntaxen / 
Programmierparadigmen...
Sehr gut gemacht!

Gruß J