Problem mit Zufallszahlenfolge



  • Sehr verehrte Damen und Herren,

    ich habe mir einen Lottogenerator programmiert. Es ist aber so, dass nicht immer
    unterschiedliche Zahlenfolge generiert werden, Beispiel: 36 7 7 30 2 17.

    Hierbei tauchen zwei mal die Sieben auf und wäre somit unrealistisch.

    Frage an euch: Wie biege ich die rand() Funktion so hin, dass immer unterschiedliche Zahlen generiert werden?

    Mein Quellcode in gekürzter Form sieht so aus:

    #include <cstdlib>
    #include <iostream>
    #include <ctime>
    using namespace std;
    
    int main()
    {
    
      srand((unsigned) time(NULL));
      cout << endl << endl;
      cout << "Generiere 6 aus 49: " << endl << endl;
    
    for (int ziehung = 1; ziehung <= 6; ziehung++)
     {
        int lottozahlen = (rand() %49) + 1;		
        cout << lottozahlen << " ";
     }
     cout << endl;
     char pause;
     cin >> pause;
    }
    

  • Mod

    Sandor++ schrieb:

    Frage an euch: Wie biege ich die rand() Funktion so hin, dass immer unterschiedliche Zahlen generiert werden?

    Falscher Ansatz. Die rand()-Funktion macht schon genau das, was sie soll, nämlich Zufallszahlen generieren. Dazu gehört eben auch eine gewisse Wahrscheinlichkeit, mehrmals die gleiche Zahl zu erzeugen.
    Besserer: Du denkst dir etwas aus, damit trotzdem Zahlen nach deinen Anforderungen heraus kommen. Zwei ganz allgemeine Ansätze dazu sind, dass man bei der Ziehung so clever vorgeht, dass der Fall gar nicht erst auftreten kann; oder dass man den Fall irgendwie abfangt und entsprechend reagiert.

    Denk mal über das Problem nach, gerade der zweite Ansatz ist eigentlich nicht sehr schwer.



  • Es gibt den Trick, dass du dir ein Array/Vector/Liste mit den möglichen Zahlen erstellst (in dem Fall die 1 bis 7) und dieses Feld dann einfach mischst(shuffelst). Aber das ist nur die Idee und äquivalent zu SeppJ's erstem Vorschlag.



  • Skym0sh0 schrieb:

    Es gibt den Trick, dass du dir ein Array/Vector/Liste mit den möglichen Zahlen erstellst (in dem Fall die 1 bis 7) und dieses Feld dann einfach mischst(shuffelst). Aber das ist nur die Idee und äquivalent zu SeppJ's erstem Vorschlag.

    Soweit bin ich leider noch nicht. Dann muss ich wohl noch im Buch wälzen.



  • Ok, dann gibts noch die zweite Möglichkeit: Du suchst solange nach eienr Zufallszahl bis du eine gefunden hast, die dir passt (vereinfacht ausgedrückt).



  • Skym0sh0 schrieb:

    Ok, dann gibts noch die zweite Möglichkeit: Du suchst solange nach eienr Zufallszahl bis du eine gefunden hast, die dir passt (vereinfacht ausgedrückt).

    Ja schon aber die im Fernsehen machen das ja auch nicht so. Da werden die Bälle
    einmal gezogen und so muss das auch virtuell funktionieren.



  • Sandor++ schrieb:

    Skym0sh0 schrieb:

    Ok, dann gibts noch die zweite Möglichkeit: Du suchst solange nach eienr Zufallszahl bis du eine gefunden hast, die dir passt (vereinfacht ausgedrückt).

    Ja schon aber die im Fernsehen machen das ja auch nicht so. Da werden die Bälle
    einmal gezogen und so muss das auch virtuell funktionieren.

    Muss es? Tust ja auch nicht echtes Quantenrauschen in deinen Zufall, sondern nur so ein simulierten rand().

    Naja, ich weiß, was Du meinst. Aber ohne Array, wo man Zahlen einträgt oder sie umhervertauscht, wird's nicht gehen. Der Lottoautomat tut ja auch im Prinzip ein Array 1 2 3 ... 49 durcheinander machen, und dann die erste Zahl vom Array anzeigen und aus dem Array wegnehmen. Dazu bräuchte man eine Merkliste von 49 Zahlen und einen Blick nach "Fischer Yates Shuffle", damit's nicht schief wird. Aber das Andere Vorgehen ist auch nicht merklich schlechter oder besser, wo man einfach nochmal würfelt, wenn man die Zahl schon hatte, denn daß man nochmal würfeln muss, ist ja unwahrscheinlich genug.


  • Mod

    Oder noch die dritte Methode, die auch der Originalballmethode nachempfunden ist: Ein Array mit allen Zahlen nehmen, einen zufälligen Eintrag wählen, Eintrag entfernen. Auch sehr effizient. Ganz besonders, wenn man mal verallgemeinert und nicht nur "6 aus 49", sondern auch "5 aus 6" oder "7 aus 84495840984" spielen möchte. Die immer-wieder-neu-ziehen-bis-es-passt-Methode funktioniert nämlich nicht so gut im ersten Fall, die alles-mischen-und-die-ersten-X-nehmen-Methode funktioniert nicht so gut im zweiten Fall. Diese Methode funktioniert in allen Fällen ganz ok.



  • In Anlehnung an SeppJs Vorschlag (ich hoffe ich habe ihn richtig verstasnden), werfe ich mal folgendes Minimalbeispiel in den Raum:

    #include <iostream>
    #include <random>
    #include <vector>
    
    class zufallszahlengenerator
    {
    	public:
    		zufallszahlengenerator(unsigned int max):
    			_engine( 4711 ), _rng( 1 , max )  {}
    
    		unsigned int operator()(){ return _rng( _engine ); }
    
    	private:
    		std::mt19937 _engine;
    		std::uniform_int_distribution<unsigned int> _rng;
    };
    
    int main()
    {
    	std::vector<unsigned int> zahlen_zum_ziehen;
    
    	for(unsigned int i = 1; i <= 49; ++i)
    		zahlen_zum_ziehen.push_back( i );
    
    	for(unsigned int i = 1; i <= 6; ++i)
    	{
    		zufallszahlengenerator zufall( zahlen_zum_ziehen.size() );
    
    		unsigned int zufallszahl = zufall();
    
    		std::cout << "gezogene Zufallszahl: " << zahlen_zum_ziehen[ i ] << std::endl;
    
    		auto it = zahlen_zum_ziehen.begin() + zufallszahl - 1;
    
    		zahlen_zum_ziehen.erase( it );
    	}
    
    	return 0;
    }
    

    Gruß,
    -- Klaus.



  • Klaus82 schrieb:

    In Anlehnung an SeppJs Vorschlag (ich hoffe ich habe ihn richtig verstasnden), werfe ich mal folgendes Minimalbeispiel in den Raum:

    #include <iostream>
    #include <random>
    #include <vector>
    
    class zufallszahlengenerator
    {
    	public:
    		zufallszahlengenerator(unsigned int max):
    			_engine( 4711 ), _rng( 1 , max )  {}
    
    		unsigned int operator()(){ return _rng( _engine ); }
    
    	private:
    		std::mt19937 _engine;
    		std::uniform_int_distribution<unsigned int> _rng;
    };
    
    int main()
    {
    	std::vector<unsigned int> zahlen_zum_ziehen;
    
    	for(unsigned int i = 1; i <= 49; ++i)
    		zahlen_zum_ziehen.push_back( i );
    
    	for(unsigned int i = 1; i <= 6; ++i)
    	{
    		zufallszahlengenerator zufall( zahlen_zum_ziehen.size() );
    
    		unsigned int zufallszahl = zufall();
    
    		std::cout << "gezogene Zufallszahl: " << zahlen_zum_ziehen[ i ] << std::endl;
    	
    		auto it = zahlen_zum_ziehen.begin() + zufallszahl - 1;
    
    		zahlen_zum_ziehen.erase( it );
    	}
    
    	return 0;
    }
    

    Gruß,
    -- Klaus.

    Ich verstehe den Code nicht.
    Und ich wundere mich über die immer gleiche Ausgabe.



  • volkard schrieb:

    Und ich wundere mich über die immer gleiche Ausgabe.

    Also ich kriege

    gezogene Zufallszahl: 2
    gezogene Zufallszahl: 3
    gezogene Zufallszahl: 4
    gezogene Zufallszahl: 8
    gezogene Zufallszahl: 10
    gezogene Zufallszahl: 12
    

    Gruß,
    -- Klaus.


  • Mod

    @ Klaus82: Ich würde die Zahl nach hinten tauschen, vor dem Löschen. Die Reihenfolge ist schließlich nicht wichtig. Mit einem erase in der Mitte geht sonst nämlich auch der Fall "6 aus 43743847249" schief.



  • SeppJ schrieb:

    @ Klaus82: Ich würde die Zahl nach hinten tauschen, vor dem Löschen. Die Reihenfolge ist schließlich nicht wichtig. Mit einem erase in der Mitte geht sonst nämlich auch der Fall "6 aus 43743847249" schief.

    Wie meinen?

    Ich sage dem Zufallszahlengenerator, dass er mir Zufallszahlen von 1 bis 'Länge-der-zu-ziehenden-Zahlen' geben soll.

    Die Zufallszahl gibt den Eintrag des Arrays an.

    Diesen Eintrag lösche ich, dass diese Zahl nicht wieder gezogen werden kann.

    Dann geht das Spiel von vorne los, d.h. die maximale Zahl des Generators ist um eins kleiner.

    Ich initialisiere den Generator immer wieder neu, mag vielleicht ein Problem sein.

    Aber warum soll ich was tauschen? 😕

    Gruß,
    -- Klaus.



  • Vorschlag für kleine Ämderungen

    #include <iostream>
    #include <random>
    #include <vector>
    
    int main()
    {
        std::mt19937 engine;//nicht den fricken mt in einer innere Schleife für je eine Zahl 
    		//konstruieren lassen. 
    
    	std::vector<unsigned int> zahlen_zum_ziehen;
    
        for(unsigned int i = 1; i <= 49; ++i)
            zahlen_zum_ziehen.push_back( i );
    
        for(unsigned int i = 1; i <= 6; ++i)
        {
            unsigned int zufallsindex = std::uniform_int_distribution<unsigned int>(1,zahlen_zum_ziehen.size())(engine);
    
            std::cout << "gezogene Zufallszahl: " << zahlen_zum_ziehen[ zufallsindex ] << std::endl;
    
    		/*
            auto it = zahlen_zum_ziehen.begin() + zufallsindex;//hier kein -1
            zahlen_zum_ziehen.erase( it );
            */
            std::swap(zahlen_zum_ziehen[zufallsindex],zahlen_zum_ziehen[zahlen_zum_ziehen.size()-1]);
            zahlen_zum_ziehen.pop_back();
        }
    
        return 0;
    }
    


  • Klaus82 schrieb:

    volkard schrieb:

    Und ich wundere mich über die immer gleiche Ausgabe.

    Also ich kriege

    gezogene Zufallszahl: 2
    gezogene Zufallszahl: 3
    gezogene Zufallszahl: 4
    gezogene Zufallszahl: 8
    gezogene Zufallszahl: 10
    gezogene Zufallszahl: 12
    

    Gruß,
    -- Klaus.

    Ich auch, und zwar JEDES mal. Hast aus Versehen [i] ausgegeben.


  • Mod

    Klaus82 schrieb:

    Aber warum soll ich was tauschen? 😕

    Weil erase auf die Mitte eines vectors furchtbar langsam ist! Da ist doch gerade der ganze Vorteil der Methode (nämlich dass sie in keinem Fall große Nachteile hat) futsch.

    Ich sehe gerade, volkard hat das soeben gut vorgemacht.



  • Klaus82 schrieb:

    Ich sage dem Zufallszahlengenerator, dass er mir Zufallszahlen von 1 bis 'Länge-der-zu-ziehenden-Zahlen' geben soll.

    Oh, die 0 vergessen. Da steht ja die 1, auch eine mögliche Zieh-Zahl.



  • Klaus82 schrieb:

    Ich initialisiere den Generator immer wieder neu, mag vielleicht ein Problem sein.

    Jo. Aber die distribution hat vermutlich das gleiche Problem, daß sie nur Gleichverteilung über eine große Anzahl von Ziehungen garantiert.



  • volkard schrieb:

    Klaus82 schrieb:

    Ich sage dem Zufallszahlengenerator, dass er mir Zufallszahlen von 1 bis 'Länge-der-zu-ziehenden-Zahlen' geben soll.

    Oh, die 0 vergessen. Da steht ja die 1, auch eine mögliche Zieh-Zahl.

    Kann sein, spiele kein Lotto. 😉

    Okay, dann verstehe ich das mit dem Swap. Ich war auf der 'stochastischen Ebene' und hatte mich gefragt, wo das Problem sei.

    Also bei dem Vektor ist es das Problem, dass Indexzugriff vorliegt, d.h. sobald ich ein Element irgendwo lösche, muss der Indexzugriff neu sortiert werden - das kostet Zeit.

    Also das Argument ist, zwei Elemente zu tauschen ist kein großer Aufwand, weil der Indexzugriff dadurch nicht gestört wird.

    Und ein Element am Ende (oder am Beginn) zu löschen hält sich vom Aufwand ebenfalls in Grenzen - ja?

    Ich hatte auch überlegt das ganze mit einer Liste zu machen, weil dann der Löschvorgang nicht aufwendig ist. Allerdings dann das Anzeigen der gezogenen Zahl, weil ich die Liste entlanglaufen muss:

    std::list<int> zahlen_zum_ziehen;
    // stuff
    auto it = zahlen_zum_ziehen.begin() + zufallsindex -1;
    std::cout << "Zufallszahl ist: " << *it << std::endl;
    

    Gruß,
    -- Klaus.



  • Klaus82 schrieb:

    volkard schrieb:

    Klaus82 schrieb:

    Ich sage dem Zufallszahlengenerator, dass er mir Zufallszahlen von 1 bis 'Länge-der-zu-ziehenden-Zahlen' geben soll.

    Oh, die 0 vergessen. Da steht ja die 1, auch eine mögliche Zieh-Zahl.

    Kann sein, spiele kein Lotto. 😉

    Den Index 0 haste vergessen, da steht die Lottozahl 1 drin.


Log in to reply