✔ Zufallszahlen

S

Soul-ya

Grünschnabel
Da ich im Netz auf nichts Ähnliches gestoßen bin stelle ich mein kürzlich erstelltes Programm allen zur Verfügung. Hier werden 6 Pseudozufallszahlen
generiert, die jeweils nur einmal vorkommen.

Da ich selbst oft die Hilfe von anderen benötige dachte ich mir mein Programm auch veranschaulichen zu können. MfG Soul-ya( Mustapha Merabti)
zu stolz auf mein Progrämmchen um's namenlos auszusetzen :-(

Code: 
#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <time.h>

void main()
{
system("title 6er Lotto");

int zahl[6];

srand(time(NULL)); // ab jetzt können pseudozufallszahlen generiert werden

 for(int x=0;x<6;x++)
    {
	zahl[x]=rand()%49; // generieren einer pseudozufallszahl
	}

/* ab hier werden die arrays solange sie ungleich sind miteinander verglichen,
sollten sie gleich werden wird anstelle des zahl[x]-arrays ein neuer wert generiert*/ 

int ok=0;
while(ok==0)
     {
      for(int y=0;y<5;y++)
	     {
          for(x=0;x<6;x++)
		     {
		      if(y==x)
	             y++;
              if(zahl[y]!=zahl[x])
	             ok=1; // hier wird die bedingung der while-schleife verändert
			  else
			  {
			   zahl[x]=rand()%49;
               ok=0;
			  }
             }
         }
     }
//hier fängt die ausgabe an

 for(x=0;x<6;x++)
    {
	printf("%i",zahl[x]+1);
	}

system("pause");
}
 
Soul-ya hat gesagt.:
meiner ist dennoch besser. ohne großes täräää ein einfach verständliches programm.
Zum Vergrößern anklicken....

Dein Ansatz ist nichteinmal gut, geschweige denn "besser". Genaugenommen funktioniert er nicht einmal.

Logikfehler 1: Wenn Du zwei gleiche Zahlen findest setzt du OK = 0, testest aber weiter anstatt die Schleife abzubrechen. Ist der folgende Test dann wieder ungleich setzt Du ok = 1. Fazit: Dein Algo kann gleiche Zahlen nur erkennen wenn diese im letzten Eintrag des Arrays sind.

Logikfehler 2: Die äußere Schleife ist sinnlos, praktisch läuft nur die innere Schleife einmal durch von 0 - 5. Warum? Naja, schau mal hier:
if(y==x) y++;

Dadurch passiert folgendes in der inneren Schleife.

1. Durchlauf: x = 0, y = 0. Gleich, also y++;
2. Durchlauf x = 1, y = 1 (durch y++). Gleich, also y++;
3. Durchlauf x = 2, y = 2 (durch y++). Gleich, also y++;
4. Durchlauf x = 3, y = 3 (durch y++). Gleich, also y++;
5. Durchlauf x = 4, y = 4 (durch y++). Gleich, also y++;
6. Durchlauf x = 5, y = 5 (durch y++). Gleich, also y++;

So, jetzt ist die innere Schleife genau einmal durchlaufen und y hat den Wert 6, also bricht die äußere Schleife ab.

Btw, Beim letzten Durchlauf der inneren Schleife hat Y den Wert 6, greift also auf undefinierten Speicher zu. (array ist 0 - 5)

Fazit: Der Algo funktioniert nicht, er vergleicht lediglich die benachbarten Zahlen auf Gleichheit.

Beweis: Gibt mal folgendes Array vor:

int zahl[6] = { 1, 2, 1, 2, 1, 2 };

Und lass das durch deinen Algo laufen. Du wirst sehen das am Ende immer noch 1,2,1,2,1,2 im Array steht...
 
Hallo,

wie wäre es hiermit?

C: 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void) {
  int zahlen[6];         // Die Lottozahlen
  bool zahl_benutzt[49]; // Gibt für jede Zahl 0-48 an, ob sie bereits in zahlen gespeichert ist
  int zahl;              // Zum Speichern einer Zufallszahl
  int i;                 // Zählvariable

  // Initialisierung von zahl_benutzt
  for (i = 0; i < 49; ++i) {
    zahl_benutzt[i] = false;
  }

  // Initialisierung des PRNG
  srand(time(NULL));
  
  // Ziehung der Zahlen
  i = 0;
  while (i < 6) {
    zahl = rand() % 49; // Zufallszahl 0-48 erzeugen
    if (!zahl_benutzt[zahl]) {   // Wenn die Zahl noch nicht in zahlen gespeichert ist:
      zahlen[i] = zahl;          // Die Zahl speichern und...
      zahl_benutzt[zahl] = true; // ...als bereits benutzt markieren.
      i++;
    }
  }

  // Ausgabe
  for (i = 0; i < 6; ++i) {
    printf("%i ", zahlen[i] + 1);
  }

  return 0;
}

Grüße, Matthias
 
das teil ist natürlich sahnig :D ohne logische fehler:-(

Matthias Reitinger hat gesagt.:
Hallo,

wie wäre es hiermit?

C: 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void) {
  int zahlen[6];         // Die Lottozahlen
  bool zahl_benutzt[49]; // Gibt für jede Zahl 0-48 an, ob sie bereits in zahlen gespeichert ist
  int zahl;              // Zum Speichern einer Zufallszahl
  int i;                 // Zählvariable

  // Initialisierung von zahl_benutzt
  for (i = 0; i < 49; ++i) {
    zahl_benutzt[i] = false;
  }

  // Initialisierung des PRNG
  srand(time(NULL));
  
  // Ziehung der Zahlen
  i = 0;
  while (i < 6) {
    zahl = rand() % 49; // Zufallszahl 0-48 erzeugen
    if (!zahl_benutzt[zahl]) {   // Wenn die Zahl noch nicht in zahlen gespeichert ist:
      zahlen[i] = zahl;          // Die Zahl speichern und...
      zahl_benutzt[zahl] = true; // ...als bereits benutzt markieren.
      i++;
    }
  }

  // Ausgabe
  for (i = 0; i < 6; ++i) {
    printf("%i ", zahlen[i] + 1);
  }

  return 0;
}

Grüße, Matthias
Zum Vergrößern anklicken....
 
dir danke ich auch für die aufklärung dann muss ich mir mein progrämmchen nochmal anschauen

jsendrow hat gesagt.:
Dein Ansatz ist nichteinmal gut, geschweige denn "besser". Genaugenommen funktioniert er nicht einmal.

Logikfehler 1: Wenn Du zwei gleiche Zahlen findest setzt du OK = 0, testest aber weiter anstatt die Schleife abzubrechen. Ist der folgende Test dann wieder ungleich setzt Du ok = 1. Fazit: Dein Algo kann gleiche Zahlen nur erkennen wenn diese im letzten Eintrag des Arrays sind.

Logikfehler 2: Die äußere Schleife ist sinnlos, praktisch läuft nur die innere Schleife einmal durch von 0 - 5. Warum? Naja, schau mal hier:
if(y==x) y++;

Dadurch passiert folgendes in der inneren Schleife.

1. Durchlauf: x = 0, y = 0. Gleich, also y++;
2. Durchlauf x = 1, y = 1 (durch y++). Gleich, also y++;
3. Durchlauf x = 2, y = 2 (durch y++). Gleich, also y++;
4. Durchlauf x = 3, y = 3 (durch y++). Gleich, also y++;
5. Durchlauf x = 4, y = 4 (durch y++). Gleich, also y++;
6. Durchlauf x = 5, y = 5 (durch y++). Gleich, also y++;

So, jetzt ist die innere Schleife genau einmal durchlaufen und y hat den Wert 6, also bricht die äußere Schleife ab.

Btw, Beim letzten Durchlauf der inneren Schleife hat Y den Wert 6, greift also auf undefinierten Speicher zu. (array ist 0 - 5)

Fazit: Der Algo funktioniert nicht, er vergleicht lediglich die benachbarten Zahlen auf Gleichheit.

Beweis: Gibt mal folgendes Array vor:

int zahl[6] = { 1, 2, 1, 2, 1, 2 };

Und lass das durch deinen Algo laufen. Du wirst sehen das am Ende immer noch 1,2,1,2,1,2 im Array steht...
Zum Vergrößern anklicken....
 
jsendrow hat gesagt.:
Dadurch passiert folgendes in der inneren Schleife.

1. Durchlauf: x = 0, y = 0. Gleich, also y++;
2. Durchlauf x = 1, y = 1 (durch y++). Gleich, also y++;
3. Durchlauf x = 2, y = 2 (durch y++). Gleich, also y++;
4. Durchlauf x = 3, y = 3 (durch y++). Gleich, also y++;
5. Durchlauf x = 4, y = 4 (durch y++). Gleich, also y++;
6. Durchlauf x = 5, y = 5 (durch y++). Gleich, also y++;

So, jetzt ist die innere Schleife genau einmal durchlaufen und y hat den Wert 6, also bricht die äußere Schleife ab.

Btw, Beim letzten Durchlauf der inneren Schleife hat Y den Wert 6, greift also auf undefinierten Speicher zu. (array ist 0 - 5)

F
Zum Vergrößern anklicken....

nicht ganz, muss ich noch hinzufügen. y kann nur bis 4 ansteigen, denn y<5 ist die bedingung der äußeren schleife. deine ausführung sind verständlich und hilfreich, aber den durchblick hast du auch noch nicht ;)

ich verneige mich demütig... ich habe den fehler jetzt verstanden.
 
Zuletzt bearbeitet:
(!) jetzt habe ich durch eure kritik mein programm vervollständigen können. ich nehme äußert ungern programme anderer und noch viel weniger mag ich boolsche variablen. wobei das andere programm mir echt gut gefällt!

Code: 
#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <time.h>

void main()
{
system("title 6er Lotto");

int zahl[6]/*={1,2,1,2,1,2}*//*die probe*/,x,ok=0;

srand(time(NULL));

for(x=0;x<6;x++)
   {
	zahl[x]=rand()%49;// die anweisung muss mann zur probe ausklammern
   }

while(ok==0)
     {
      for(int y=0;y<6;y++)
	     {
          for(x=0;x<5;x++)
		     {
		      if(y==x)
	             x++;
              if(zahl[y]!=zahl[x])
	             ok=1;
			  else
			  {
			   zahl[x]=rand()%49;
               ok=0;
			   break;
			  }
             }
		  if(ok==0)
			 break;
         }
     }

 for(x=0;x<6;x++)
    {
	printf("%i ",zahl[x]+1);
	}

system("pause");
}
 
Zuletzt bearbeitet:
Soul-ya hat gesagt.:
nicht ganz, muss ich noch hinzufügen. y kann nur bis 4 ansteigen, denn y<5 ist die bedingung der äußeren schleife. deine ausführung sind verständlich und hilfreich, aber den durchblick hast du auch noch nicht ;)

ich verneige mich demütig... ich habe den fehler jetzt verstanden.
Zum Vergrößern anklicken....

Soso. Dann überprüf es doch mal ;) y hat nach dem Durchlauf der inneren Schleife den Wert 6. Erst dann wird die Abbruchbedingung der äußeren Schleife überprüft und da 6 > 4 ist bricht die äußere Schleife dann ab.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück