Lotto 3, 4, 5, 6 Richtige nach x Ziehungen ermittelt..

[cookiedough]

Hallo zusammen,

Ich habe ein kleines Programm in Java geschrieben, das herausfindet, nach wie vielen Verlosungen 6 richtige Zahlen gezogen wurden und wie oft dabei 3, 4 und 5 richtige Zahlen gezogen wurden.

[CODE lang="java" highlight="86-89"]import java.util.Arrays;
import java.util.Scanner;

public class Lottoziehung {

// Lotto spielen

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);


// Lotto von x aus X
// Tipp erstellen per Eingabe

int tipp[] = new int[6];
int i = 0;
do {
System.out.println("Wie ist dein " + (i + 1) + " .Tipp?");
int tippzwischenspeicher = scan.nextInt();
tipp = tippzwischenspeicher;

boolean zahldoppelt = false;

for (int j = 0; j < i; j++) {
if (tippzwischenspeicher == tipp[j]) {
zahldoppelt = true;
}
}

if (!zahldoppelt && tippzwischenspeicher >= 1 && tippzwischenspeicher <= 49) {
tipp = tippzwischenspeicher;
i++;
}
} while (i < 6);

System.out.println("hier sind deine tipps:");
Arrays.sort(tipp);

for (int k = 0; k < tipp.length; k++) {
System.out.println(tipp[k]);
}


// Lotto 49 Zahlen erzeugen
int aus49[] = new int[49];
for (int l = 0; l < aus49.length; l++) {
aus49[l] = l + 1;
l++;
}

// 3 Tipps, 4 Tipps, 5 Tipps
int einsKorrekte = 0;
int zweiKorrekte = 0;
int dreiKorrekte = 0;
int vierKorrekte = 0;
int funfKorrekte = 0;
int sechsKorrekte = 0;
int haha = 0;


// Schleife für Ziehung
int ziehung[] = new int[6];
int counter = 0;
do {

// Ziehung
for (int m = 0; m < ziehung.length; m++) {
int r = (m + (int) ((Math.random() * aus49.length) - m));
ziehung[m] = r;

boolean randomzahldoppelt = false;

for (int n = 0; n < m; n++) {
if (r == ziehung[n]) {
randomzahldoppelt = true;
m--;
// Ansatz überprüfen, evtl falsch
}
}
}

Arrays.sort(ziehung);

int anzahlRichtige = 0;
for (int o = 0; o < tipp.length; o++) {
for (int p = 0; p < tipp.length; p++) {
if (tipp[o] == ziehung[p]) {
anzahlRichtige++;
}
}
}

switch (anzahlRichtige) {
case 1:
einsKorrekte++;
break;
case 2:
zweiKorrekte++;
break;
case 3:
dreiKorrekte++;
break;
case 4:
vierKorrekte++;
break;
case 5:
funfKorrekte++;
break;
case 6:
sechsKorrekte++;
break;
default:
haha++;
}

counter++;

if (Arrays.equals(tipp, ziehung)) {
System.out.println("einsKorrekte gab es " + einsKorrekte + " !");
System.out.println("zweiKorrekte gab es " + zweiKorrekte + " !");
System.out.println("dreiKorrekte gab es " + dreiKorrekte + " !");
System.out.println("vierKorrekte gab es " + vierKorrekte + " !");
System.out.println("funfKorrekte gab es " + funfKorrekte + " !");
System.out.println("sechsKorrekte gab es " + sechsKorrekte + " !");
System.out.println("Sechs Richtige gab es " + counter + " Ziehungen!");
}

} while (!Arrays.equals(tipp, ziehung));
}
}
[/CODE]

Nach vielen Durchläufen bemerkte ich einen Fehler in der Ausgabe. Das Programm stellte fest, dass nach 1.502 Ziehungen 6 richtige Zahlen gezogen wurden, nicht jedoch 5 richtige Zahlen. Hier ist der Screenshot:

Übersetzt bedeutet das:
Sechs Richtige gab es nach 1502 Ziehungen!
dabei gab es:
- 686x ein Richtige
- 242x zwei Richtige
- 44x drei Richtige
- 3x vier Richtige
- 0x fünf Richtige
- 1x sechs Richtige

Der Fehler ist schwer zu reproduzieren, normalerweise werden nach 3,5 Millionen Ziehungen 6 richtige Zahlen ausgewählt.

Es war ein Zufall, dass ich bereits nach 1.502 Ziehungen 6 richtige Zahlen bekam. Nur so bemerkte ich den Fehler, dass keine fünf richtigen Zahlen ausgewählt wurden.


Ich vermute, der Fehler liegt in den Zeilen 86-89. Weiß jemand wo der Fehler versteckt ist?

 

[LimDul]

Ursache ist simpel, all deine Zahlen bis auf die 6 richtigen sind falsch.

Du zählst die Anzahl der richtigen pro Ziehung. Wenn es zwei Richtige gab, gibt es auch immer einen richtigen. Aber die Variable anzahlRichtige enthält halt eine 2 daher wird auch nur zweiKorrekte hochgezählt. Das Case Statement müsste (mit FallThrough) so aussehen:

            switch (anzahlRichtige) {
                case 6:
                    sechsKorrekte++;
                case 5:
                    funfKorrekte++;
                case 4:
                    vierKorrekte++;
                case 3:
                    dreiKorrekte++;
                case 2:
                    zweiKorrekte++;
                case 1:
                    einsKorrekte++;
                    break;
                default:
                    haha++;
            }

 

[stg]

Nur so bemerkte ich den Fehler, dass keine fünf richtigen Zahlen ausgewählt wurden.

Wieso sollte das ein Fehler sein?

 

[fhoffmann]

Ergänzend zu dem, was LimDul geschrieben hat: Meinst du mit "3 Richtige" eigentlich "genau 3 Richtige" oder "mindestens 3 Richtige".

Außerdem ist folgender Code falsch:

        for (int l = 0; l < aus49.length; l++) {
            aus49[l] = l + 1;
            l++;
        }

Du rufst hier zweimal l++ auf!

 

[BestGoalkeeper]

6 Richtige nach nur 651 Ziehungen

    public static int[] pull_6_out_of_49_sorted(Random r) {
        TreeSet<Integer> tsi = new TreeSet<>();
        while (tsi.size() < 6)
            tsi.add(r.nextInt(49) + 1);
        return tsi.stream().mapToInt(Integer::intValue).toArray();
    }

    public static void main(String[] args) {
        int i = 6608;
        Random r = new Random(i);
        int[] a = pull_6_out_of_49_sorted(r);
        for (int j = 0; j < 1000; j++) {
            int[] b = pull_6_out_of_49_sorted(r);
            if (Arrays.equals(a, b)) {
                System.out.println(i);
                System.out.println(j);
                System.out.println(Arrays.toString(a));
                System.out.println(Arrays.toString(b));
                return;
            }
        }
    }

Und weiter hab ich noch gar nicht gesucht

 

[BestGoalkeeper]

6 Richtige nach 41 Ziehungen

558751
41
[7, 27, 29, 41, 46, 48]
[7, 27, 29, 41, 46, 48]

 

[cookiedough]

Ursache ist simpel, all deine Zahlen bis auf die 6 richtigen sind falsch.

Du zählst die Anzahl der richtigen pro Ziehung. Wenn es zwei Richtige gab, gibt es auch immer einen richtigen. Aber die Variable anzahlRichtige enthält halt eine 2 daher wird auch nur zweiKorrekte hochgezählt. Das Case Statement müsste (mit FallThrough) so aussehen:

            switch (anzahlRichtige) {
                case 6:
                    sechsKorrekte++;
                case 5:
                    funfKorrekte++;
                case 4:
                    vierKorrekte++;
                case 3:
                    dreiKorrekte++;
                case 2:
                    zweiKorrekte++;
                case 1:
                    einsKorrekte++;
                    break;
                default:
                    haha++;
            }

Ich verstehe: Wenn zufällig bei der ersten Ziehung bereits 6 Richtige gezogen werden, dann wären es jeweils auch ein 5 Richtige und 4, 3, 2, 1 Richtige geben. Und das wird erreicht mit der Switch-Anweisung ohne break.

 

[BestGoalkeeper]

Nochmal, das kommt darauf an, wie du zählst... Ob es genau x richtige gibt oder ob es mindestens x richtige gibt...

    public static TreeSet<Integer> pull_6_out_of_49_sorted(Random r) {
        TreeSet<Integer> tsi = new TreeSet<>();
        while (tsi.size() < 6)
            tsi.add(r.nextInt(49) + 1);
        return tsi;
    }

    public static int count_hits(TreeSet<Integer> a, TreeSet<Integer> b) {
        return (int) a.stream().filter(i -> b.contains(i)).count();
    }

    public static List<Integer> sum_hits(TreeSet<Integer> a, TreeSet<Integer> b) {
        int h = count_hits(a, b);
        return IntStream.rangeClosed(1, 6).boxed().collect(Collectors.groupingBy(i -> i <= h ? true : false))
                .getOrDefault(true, new LinkedList<>());
    }

    public static void main(String[] args) {
        Random r = new Random(0);
        TreeSet<Integer> a = pull_6_out_of_49_sorted(r);
        for (int j = 0; j < 1_000; j++) {
            TreeSet<Integer> b = pull_6_out_of_49_sorted(r);
            List<Integer> sum_hits = sum_hits(a, b);
            if (sum_hits.size() >= 3) {
                System.out.println(j + " " + a + " " + b + " " + sum_hits);
            }
        }
    }