ich hoffe mal ich hab hier das richtige Unterforum erwischt

Ich habe aus langeweile mal probiert einen Zufallsgenerator zu schreiben. Ich bin kein Profi, dass was ich kann sind bisher if Bedingungen, Schleifen und Arrays ..

Ich will die Zahlen 1-32 auf vier Parts (Arrays) aufteilen.
z. B. Part 1: 2, 7, 9, 14, 15, 22, 29, 32
und die restlichen Parts enthalten dann die ÜBRIGEN Zahlen, also es kommen keine Zahlen doppelt vor.

Es funktioniert auch alles einwandfrei, jedoch möchte ich jetzt von euch wissen, wie "gut" das Ergebnis ist.
Dazu habe ich ein Programm geschrieben, das nach jeder Vergabe der Zahlen den Durchschnitt berechnet. Z. B. wäre das bei dem Beispiel oben:
(2+7+9+14+15+22+29+32)/8 = 16.25

So .. das habe ich in eine Schleife gepackt und dann für jeden Part 50.000 mal laufen lassen. Die errechneten Durchschnitte addiert und durch 50.000 geteilt, so dass ich eine gesamten Durchschnitt bekomme.

Die Ergebnisse:
Part1 / Part2 / Part3 / Part4
17,6710 | 12,1430 | 16,7531 | 19,3615
13,7755 | 18,3095 | 16,6470 | 17,2680
14,3745 | 19,5665 | 16,3165 | 15,7426
18,0250 | 14,8750 | 15,9750 | 17,1250
14,7227 | 15,5889 | 16,7052 | 18,9832
17,4058 | 19,1730 | 14,8612 | 14,5601
16,9427 | 16,4717 | 16,6864 | 15,8992

So .. und jetzt zur eigentlichen Frage, sind das gute Werte??

Ich habe z. B. mal so lange rechnen lassen, bis in Part 1 acht Werte unter 15 sind. Nach 6.000.000 hatte ich noch kein Ergebnis.

Noch was zum Code:
Ich berechne erst ein Array mit 32 Elementen - die Funktion Richtigkeit überprüft dabei, das keine doppelten Werte vorkommen.

Nachdem das Array gesetzt ist soll sich Spieler1, Spieler2, Spieler3 und Spieler4 je 8 Werte per Zufall holen. Die Funktion Richtigkeit überprüft dabei, das ein Wert nicht schon in einem anderen Spielerx Array steht!

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

using namespace std;

//Array mit 32 Elemente auf gleiche Werte untersuchen
bool Richtigkeit(int Array[], int x)
{
    int n=0;
    for(int i=0; i<32; i++)
    {
        if(Array[i]==x)         //Wenn ein gleicher Wert gefunden wird, dann wird +1 addiert
            n++;
    }
    if(n>0)
        return false;           //==> n gleiche Werte gefunden
    else
        return true;            //Wert noch nicht vorhanden
}

//Spieler Arrays auf doppelte Werte untersuchen
bool Richtigkeit2(int Spieler1[], int Spieler2[], int Spieler3[], int Spieler4[], int x)
{
    int n=0;
    for(int i=0; i<8; i++)
    {
        if(Spieler1[i]==x || Spieler2[i]==x || Spieler3[i]==x || Spieler4[i]==x)
            n++;
    }
    if(n>0)
        return false;
    else
        return true;
}

int main(int argc, char *argv[])
{
    srand(time(0));
    int x;
    int Array[32]={0,0};
    int Spieler1[8]={0,0};
    int Spieler2[8]={0,0};
    int Spieler3[8]={0,0};
    int Spieler4[8]={0,0};

    //Array mit 32 Elementen per Zufall einlesen
    for(int i=0; i<32; i++)
    {
        x=1+rand()%(32-1+1);
        while(Richtigkeit(Array, x)==false)
            x=1+rand()%(32-1+1);
        Array[i]=x;
    }

    //Je 8 Werte aus 32-wertigen Array per Zufall ermitteln
    //Spieler 1
    for(int i=0; i<8; i++)
    {
        x=1+rand()%(32-1+1);
        while(Richtigkeit2(Spieler1,Spieler2,Spieler3,Spieler4,x)==false)
            x=1+rand()%(32-1+1);
        Spieler1[i]=x;
    }
    //Spieler 2
    for(int i=0; i<8; i++)
    {
        x=1+rand()%(32-1+1);
        while(Richtigkeit2(Spieler1,Spieler2,Spieler3,Spieler4,x)==false)
            x=1+rand()%(32-1+1);
        Spieler2[i]=x;
    }
    //Spieler 3
    for(int i=0; i<8; i++)
    {
        x=1+rand()%(32-1+1);
        while(Richtigkeit2(Spieler1,Spieler2,Spieler3,Spieler4,x)==false)
            x=1+rand()%(32-1+1);
        Spieler3[i]=x;
    }
    //Spieler 4
    for(int i=0; i<8; i++)
    {
        x=1+rand()%(32-1+1);
        while(Richtigkeit2(Spieler1,Spieler2,Spieler3,Spieler4,x)==false)
            x=1+rand()%(32-1+1);
        Spieler4[i]=x;
    }

    //Ausgabeschleife
    for(int i=0; i<8; i++)
        cout<<Spieler1[i]<<"\t"<<Spieler2[i]<<"\t"<<Spieler3[i]<<"\t"<<Spieler4[i]<<endl;

    cout<<endl<<endl;

system("PAUSE");
return 0;
}

Also das soll praktisch eine Kartenverteilung darstellen.
Hinter jeder Zahl steckt eine Karte.

Nach der Kartenverteilung wollte ich dann rumprobieren, wie oft man neu verteilen muss um eine bestimmte Kombination zu bekommen.

Ein erster Ansatzpunkt für dich: Wenn die Zahlen 1 bis 32 bereits in zufälliger Reihenfolge in Array stehen, kannst du die ersten 8 Zahlen Spieler 1, die zweiten 8 Zahlen Spieler 2 etc. zuweisen. Die Kartenverteilung wird nicht "zufälliger" dadurch, dass du jedem Spieler zufällige Positionen zuweist. Du bleibst bei einer Gleichverteilung.

Wo finde ich den solche Algorithmen ??

Ich hab mir nochmal selber was ausgedacht. Ist der Zufallsgenerator jetzt "besser" ??

Meine Idee:
Ich lese in einem Array 32 Werte ein .. von 1-32 (inkl.)
Dann lasse ich per rand() eine Zahl generieren, die die Tauschvorgänge im Array angibt.
In einer for-Schleife berechne ich dann nochmal per rand() zwei Zahlen zwischen 0 und 31 (inkl.). Jetzt werden die Werte im 32-wertigen Array an den beiden rand() Werten getauscht.

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

using namespace std;

int main(int argc, char *argv[])
{
    srand(time(0));
    int Array[32];
    int m=0;            //Zähler für Sx[8] einlesen

    //Array Werte einlesen
    for(int i=0; i<32; i++)
        Array[i]=i+1;

    //Tauschvorgänge
    int n=rand();

    //Tauschvorgang
    for(int i=0; i<n; i++)
    {
        int x=rand()%32;
        int y=rand()%32;
        int platz1=Array[x];
        int platz2=Array[y];
        Array[x]=platz2;
        Array[y]=platz1;
    }

    //Auf 4 aufteilen
    int S1[8], S2[8], S3[8], S4[8];

    //Werte für Sx[8] einlesen
    //S1
    for(int i=0; i<8; i++)
        S1[i]=Array[i];

    //S2
    for(int i=8; i<16; i++)
    {
        S2[m]=Array[i];
        m++;
    }
    m=0;

    //S3
    for(int i=16; i<24; i++)
    {
        S3[m]=Array[i];
        m++;
    }
    m=0;

    //S4
    for(int i=24; i<32; i++)
    {
        S4[m]=Array[i];
        m++;
    }

    //Ausgabeschleife
    for(int i=0; i<8; i++)
        cout<<S1[i]<<"\t"<<S2[i]<<"\t"<<S3[i]<<"\t"<<S4[i]<<endl;

    cout<<endl<<endl;

    system("PAUSE");
    return 0;
}

Wenn ich öfters zufällig tausche, warum nähere ich mich dann da an??

Übrigens danke für die schnelle Hilfe

Warum du dich dieser Verteilung mit großem n annäherst: Da fällt mir auf die Schnelle auch kein formales Argument ein. Das war mehr eine intuitive Aussage.

Ich näher mich der Gleichverteilung nur an .. aber ich erreiche sie nicht .. okay

Das kann ich mir irgendwie nicht vorstellen ..

Schau dir vector an und vergiss c Arrays, die brauchst du nur noch sehr selten
(in c++).

Schau dir vector an und vergiss c Arrays, die brauchst du nur noch sehr selten
(in c++).

stimmt. arrays sind hier ja äußerst fehl am platz. weil die länge des arrays ja erst zur laufzeit bekannt ist. oh... wait !

stimmt. arrays sind hier ja äußerst fehl am platz. weil die länge des arrays ja erst zur laufzeit bekannt ist. oh... wait !

Bei bekannter Größe gibt es dennoch sinnvolle Alternative (wie array).

Ich raff es noch nicht: Was spricht dagegen, std::random_shuffle einfach zu benutzen?

Ich bin Anfänger und hab nur aus einer Idee heraus einen Zufallsgenerator schreiben wollen.

unskilled schrieb:

stimmt. arrays sind hier ja äußerst fehl am platz. weil die länge des arrays ja erst zur laufzeit bekannt ist. oh... wait !

Bei bekannter Größe gibt es dennoch sinnvolle Alternative (wie array).

mal ehrlich: wie oft verwendest du array?
ich verwende nur array, wo ich es wirklich brauche (damit ich nicht extra die größe irgendwo erfragen muss), aber selbst das halte ich weder für fehlerunanfälliger noch wartbarer oder ähnliches. also nie.
damals hat mich immer der header tr1/array vs array und der namespace std::tr1 vs std und die fallunterscheidungen davon abgehalten (also nen eigenen header zu schreiben, der das kapselt und dann halt nur teilweise portabel ist), in der zwischenzeit einfach die frage nach dem sinn.

bb