Lotto-Programm Wieso klappt das?

[Zitrus]

Hallo,
Ich habe mir mal schnell ein Lotto Programm zusammengebastelt:

public class lotto {

	public static void main(String[] args) {
		int[] lotto = new int[6];

		for (int i = 0; i < lotto.length; i++) {
			Random r = new Random();
			int zufall = r.nextInt(49) + 1;

			for (int j = 0; j < i; j++) {
				if (lotto[j] == zufall) {
					zufall = r.nextInt(49) + 1;
				}
			}

			lotto[i] = zufall;
			System.out.println(lotto[i]);
		}

	}
}

Meine Frage nun zur inneren Schleife. Nehmen wir an, dass i = 1 ist. Dann wird ja für lotto[0] geprüft ob der Wert gleich zufall ist. Wenn ja dann soll er dem Zufall eine neue Zufallszahl zuweisen.

Sagen wir bei lotto[0] ist der zufallswert 30.Im nächsten Durchgang wird geprüft ob zufall == lotto[0] ist. Sagen wir im zweiten Durchgang ist der zufallswert wieder 30 und die if-Abfrage wird betreten. Soweit sogut. Was ist wenn aber bei der Zeile zufall = r.nextInt(49) + 1; nochmal 30 rauskommen würde? Dann würde der Wert ja einfach in lotto[1] gespeichert werden oder?

Vielen Dank schonmal im Vorraus!

Nochmal vllt. verständlicher 🙂

lotto[0] = 30;
int zufall = 30;

if(lotto[0] == zufall) {
    zufall = r.nextInt(49) +1; <-- Was ist wenn hier auch 30 rauskommt?
}

Mfg, Zitrus

 

[benruzzer]

Also vlt. Hab ich ja deine Frage falsch verstanden, aber wenn bei r.nextInt... 30 ras kommt, ist der neue Wert für Zufall einfach 30

EDIT:
Ach jetzt hab verstanden, um was es geht: Eine Zahl soll in einer Ziehung nicht öfters auftauchen. Dann mach aus der if-Abfrage eine while-Schleife, die solange arbeitet, bis eine Zufallszahl geniert wird, die noch nicht vorkommt

 

[Gucky]

Eine andere Möglichkeit, ohne while und theoretischen unendlich Durchläufen wäre es, alle Zahlen in eine List zu schreiben und die Gezogenen aus dieser Liste zu löschen.

 

[Zitrus]

[EDIT]
Müsste auch so funktionieren 🙂
[/EDIT]

package lotto;

import java.util.Random;
import java.util.Scanner;

public class lotto {

	public static void main(String[] args) {
		int[] lotto = new int[6];

		for (int i = 0; i < lotto.length; i++) {
			Random r = new Random();
			int zufall = r.nextInt(49) + 1;

			for (int j = 0; j < i; j++) {
				while (lotto[j] == zufall) {
					zufall = r.nextInt(49) + 1;
				}
			}

			lotto[i] = zufall;
			System.out.println(lotto[i]);
		
		}

	}
}

 

[Flown]

Also dein Programm ist nicht korrekt.

Angenommen du hast bereits: [1, 2, 3, x, x, x] und deine neue Ziehung ist 1.

Dann wird bei deinem Programm eine neue Ziehung durchgeführt. Angenommen es kommt jetzt 3 raus.

Dann läuft es bis zu der Stelle lotto[2] und stellt fest, dass es schon im Array vorhanden ist. Danach wird eine neue Ziehung durchgeführt und es kommt wieder eine 1 (oder sogar eine 2).

Dann wird die Zahl zweimal in dein lotto-Array eingefügt.

Jedes mal wenn du eine neue Ziehung durchführst musst du bei dem ersten Element zum Überprüfen beginnen, nicht bei dem aktuellen.

Sowas in der Art:

public static int[] pickNOutOfK(int n, int k) {
  if (n < 0 || k < n) {
    throw new IllegalArgumentException();
  }
  int[] numbers = new int[n];
  for (int i = 0; i < numbers.length; i++) {
    boolean found;
    int next;
    do {
      found = false;
      next = (int) (Math.random() * k + 1);
      for (int j = 0; j < i; j++) {
        if (numbers[j] == next) {
          found = true;
          break;
        }
      }
    } while (found);
    numbers[i] = next;
  }
  Arrays.sort(numbers);
  return numbers;
}

 

[Zitrus]

Hi Flown,
Danke erstmal für deine Antwort.

for (int j = 0; j < i; j++) {
				while (lotto[j] == zufall) {
					zufall = r.nextInt(49) + 1;
				}
			}

Du sagst ja,dass ich beim ersten Element anfangen soll zu zählen. Das mache ich doch mit der zweiten for-Schleife oder nicht? Ich wiederhole mit der while Schleife in der for-Schleife ja solange die intialisierung des zufallswerts bis lotto[0] z.B nicht mehr sogroß ist wie zufall. Dann wird bei lotto[1],lotto[2],lotto[x] usw. dasselbe ausgeführt.

Auch nach ca. 100maligem ausprobieren habe ich nie doppelte Zahlen bekommen.

Mfg, Zitrus

 

[Flown]

Dein Code (ein wenig verändert):

private static final int N = 6;

public static int[] lotto() {
  int[] lotto = new int[N];
  for (int i = 0; i < lotto.length; i++) {
    Random r = new Random();
    int zufall = r.nextInt(N) + 1;
    
    for (int j = 0; j < i; j++) {
      while (lotto[j] == zufall) {
        zufall = r.nextInt(N) + 1;
      }
    }
    lotto[i] = zufall;
  }
  return lotto;
}

Ich hab dein Code umgestaltet, dass er 6 aus 6 ziehen soll und das Ergebnis ist:

2
6
3
5
2
1
[2, 6, 3, 5, 2, 1]

Erklärung: siehe meinen letzten Post!
Lösung: siehe ebenfalls meinen letzten Post!

 

[Zitrus]

Aha okay habe jetzt deine Erklärung verstanden. Kannst du mir noch eine Erlärung zu deinem Lösungsweg bzw. zur do-while Schleife geben komme da bisschen durcheinander 🙂

 

[Flown]

Die do-while ist genau dazu da dein Problem zu lösen.
Sie startet die innere for-Schleife von neuen, sobald ein Duplikat und eine neue Zahl gezogen worden ist (Könnte man nur mit der inneren for-Schleife machen, aber ich bin der Meinung Laufvariablen ändern/zurückzusetzen im Body ist ein schlechter Stil).