# Arrays Lottozahlen



## chk1102 (1. Mrz 2011)

Hallo,

ich verstehe nicht wie ich eine Aufgabe im Bezug auf Arrays umsetzen soll/kann.
Die Aufgabe besagt, Programm mit 6 Lottozahlen erstellen + Zusatzzahl, aus Zufallszahlen.
Ok, krieg ich hin!

Dann steht weiter in der Aufgabe:
Das einer bestimmten Kugel zugeordnete Array-Element soll den Wert 0 tragen, solange die Kugel noch nicht gezogen wurde und sich folglich noch in der "Lostrommel" befindet.
Sie soll 1 tragen, wenn die betreffende Kugel als eine der 6 Lottozahlen gezogen wurde und den Wert 2, wenn sie eine Zusatzzahl ist.
Am Ende ausgeben.

Ich gebe mal hier mein bisheriges Ergebnis an:


```
import java.util.Arrays;

public class A15 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] lotto = new int[7];
		int zz = (int) (Math.random() * 49 + 1);

		// Lottozufallszahlen generieren
		for (int i = 1; i < lotto.length; i++) {
			lotto[i] = (int) (Math.random() * 49 + 1);

			// wenn Zahl gleich der Zfz is, noch mal zufällig wählen
			for (int j = 1; j < i; j++) {
				if (lotto[i] == lotto[j])
					j--;
			}
		}

		// Array sortieren
		Arrays.sort(lotto);

		// Zufallszahlen ausgeben
		for (int k = 1; k < lotto.length; k++) {
			System.out.print(lotto[k] + ", ");
			
		}

		for (int l = 1; l < lotto.length; l++) {
			for (int m = 1; m < l; m++) {
				if (lotto[l] != lotto[m]) {
					lotto[l] = 0;
					if (lotto[l] == lotto[m]) {
						lotto[l] = 1;
					}
				}
				System.out.println();
				System.out.print("Lottozahlen: " + lotto[l] + ",");
			}

		}
	}
}
```

Ich hab echt ne denkblockade.
Ich verstehs einfach nicht.
Oder ich habe massiv Probleme nach wie vor mit Schleifen.
Könnte es mir jemand erklären?:rtfm:

Ich verzweifle...


----------



## Final_Striker (1. Mrz 2011)

Du musst mit deinem Array alle Kugeln abbilden nicht nur die gezogenen. D.h. du braucht ein Array der Größe 49.

Das mit den Zusatzzahlen keine Ahnung, ich weiß nicht wie sie gezogen werden. Spiele kein Lotto. :-D


----------



## Simon_Flagg (1. Mrz 2011)

außerdem lässt du die 1. zahl weg, wenn du die erste schleife von 1 bis length-1 durchlaufen lässt --> die arrays sind 0 basiert --> 1. leer

lg


----------



## chk1102 (1. Mrz 2011)

Ok, habe die For-Schleifen auf i = 0 gesetzt und das Array auf 49 erhöht...
:bahnhof: u nu??

jetzt macht die ausgabe nix ;( mehr 


```
import java.util.Arrays;

public class A15 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] lotto = new int[49];
		int zz = (int) (Math.random() * 49 + 1);

		// Lottozufallszahlen generieren
		for (int i = 0; i < lotto.length; i++) {
			lotto[i] = (int) (Math.random() * 49 + 1);

			// wenn Zahl gleich der Zfz is, noch mal zufällig wählen
			for (int j = 0; j < i; j++) {
				if (lotto[i] == lotto[j])
					j--;
			}
		}
		// Array sortieren
		Arrays.sort(lotto);
		// Zufallszahlen ausgeben
		for (int k = 0; k < lotto.length; k++) {
			System.out.print(lotto[k] + ", ");
			
		}

		for (int l = 0; l < lotto.length; l++) {
			for (int m = 0; m < l; m++) {
				if (lotto[l] != lotto[m]) {
					lotto[l] = 0;
					if (lotto[l] == lotto[m]) {
						lotto[l] = 1;
					}
				}
				System.out.println();
				System.out.print("Lottozahlen: " + lotto[l] + ",");
			}

		}
	}
}
```


----------



## Blakh (1. Mrz 2011)

```
// wenn Zahl gleich der Zfz is, noch mal zufällig wählen
            for (int j = 1; j < i; j++) {
                if (lotto[i] == lotto[j])
                    j--;
            }
```

Endlosschleife?! Da musst du dir was anderes einfallen lassen. Z.b. eine HashMap: HashMap<Integer, Boolean> numbers; Welche du für alle 49 Werte mit false initialisierst. Key = 1-49 und Value = true/false, je nachdem ob vergeben oder nicht.

verschachtelte For-Scheife brauchst du dann auch nicht, sondern einfach nur:


```
while ( numbers.get(X) ) {
wähle neue Zufallszahl
}
```
Das ist aber auch nicht optimal, da es mit Anzahl der vergebener Zahlen immer länger dauert, bis du eine passende Zahl gefunden hast. Ich würde eine Liste mit den zu vergebenen Zahlen machen und per Zufall eine dieser Zahlen wegnehmen. 

Pseudocode:
Zufallszahl(0 -1) * List-Länge = Index der gezogenen Zahl


----------



## chk1102 (1. Mrz 2011)

Endlosschleife?
Wirklich?

An meiner Reaktion zeigt sich leider deutlich, dass ich noch ziemlich am Anfang stehe...

Ich verstehe nicht warum das eine Endlosschleife sein soll, zumal die Ausgabe mit den Array von 7 funktioniert hat.
Danke auf jedenfall für deine Antwort, nur ist die Aufgabe mit einem Int-Array zu lösen.
Und die Verkürzung werde ich später sicherlich anwenden, aber aktuell kann ich nicht einmal was damit anfangen.


Mir fehlt das wissen, wie ich die Inhalte vergleichen kann und die Vorstellungskraft...
Als Beispiel:
Wie kann ich auf i der ersten For-Schleife zugreifen (also inhaltlich die Zufallszahlen) und diese dann mit den geworfenen Zufallszahlen vergleichen, um anschließend einen Wert auszugeben (1, 2, 0) und die entsprechende Zufallszahl?!

Es ist so schwierig für mich zu verstehen, dass wenn eine for-schleife abgeschlossen ist:
for ( int i= 0; i<lotto.length; i++) {
} 
wieder auf den Inhalt zugreifen zu können....
Und wenn ich mehrere For-Schleifen einbaue, wird der Inhalt nicht überschrieben?
Oder muss ich für diese Aufgabe 2 Arrays[49] erstellen? Den Inhalt des einen Arrays ins andere überschreiben?

Überall wo ich Definitionen und Anwendungen nachlese zu Arrays ( Java ist auch nur eine Insel, Java von Kopf bis Fuß oder Java als erste Programmiersprache ) ist der Inhalt kurz gehalten.

Mein Problem ist:
wie komme ich an zuvor durch eine For-Schleife hinein geschriebenen Daten eines Arrays wieder ran um zu wieder zu verändern? Und trotzdem die Werte beider Veränderungen zu behalten?

Also vll so:
Zufallszahl: 5, 18, 20, 21, 45, 48
gezogen?    0,  1,   0,   1,  0,  1

So stell ich mir das irgendwie vor.
Aber ich kann aktuell noch nichts anderes als die Schleifen und versuche mich in die Arrays reinzudenken...  Bitte daher noch nicht (für mich aktuell) hochkomplexen Ideen 

Ich hoffe mir kann jemand die Augen öffnen..


----------



## chk1102 (1. Mrz 2011)

Es tut mir leid, dass ich so viel Unterstützung benötige,...und schwerfällig bin..
Aber ich weiß nicht mehr wen ich noch fragen soll..:autsch:


----------



## SlaterB (1. Mrz 2011)

ein Array kann von selber gar nichts, es speichert n Werte,
Abfragen und Ändern kannst du einzeln mit array[index], über alle Indexe mit einer Schleife iterieren, dann Einzelzugriff
das wars schon!

alles andere ist jetzt deine Arbeit, mit diesen einfachen Zugriffsmöglichkeiten abzubilden

> wie komme ich an zuvor durch eine For-Schleife hinein geschriebenen Daten eines Arrays wieder ran
in einem Array ist nicht irgendwann etwas drin was vorher nicht drin war, jedenfalls nicht auf irgendeine ominöse Weise

wenn du an Arrayposition 3 etwas schreibst, [c]array[3] = 5;[/c], ok, dann ist da eben was, das kannst du aber ganz normal mit array[3] abfragen oder auch mit einem erneuten Schreib-Befehl überschreiben, alles ganz normale Vorgänge,
was genau könnte dabei ein Problem sein?

edit:
zur Ausgabe hast du ja bereits eine Schleife a la

```
for (int k = 0; k < lotto.length; k++) {
            System.out.print(lotto[k] + ", ");
        }
```
die aus diesen einfachen Vorgängen sinnvoll etwas größeres zusammenbaut,
was brauchst du mehr?


----------



## Blakh (1. Mrz 2011)

Kann es sein, dass du was durcheinander bringst mit der For-Schleife und dem Array? i der For-Schleife ist deine Laufvariable und mit diesem i greifst du pro Durchlauf auf einen Index des Arrays zu. 

Also z.B. hast du ein int-Array gefüllt mit Zahlen 0 - 9 (gleich wie der Index des Arrays an der Stelle). Die Länge des Arrays ist 10!


```
for (int i = 0; i< array.length; i++) {
            System.out.printl(array[i])
}
```

Würde ergeben:
	
	
	
	





```
0
1
2
3
4
5
6
7
8
9
```

Wieso du eine Endlosschleife erhälst bei deinem Code?

Du machst folgendes:

```
// wenn Zahl gleich der Zfz is, noch mal zufällig wählen
            for (int j = 1; j < i; j++) {
                if (lotto[i] == lotto[j])
                    j--;
            }
```

Beispiel: lotto[0] ist 5, lotto[1] ist 123, lotto[2] ist 123, i ist gerade 2.

Erster Durchlauf: j = 0: lotto[0] == lotto[2]? nein -> For-Schleife erhöht j um 1
Zweiter Durchlauf: j = 1:  lotto[1] == lotto[2]? ja -> j um 1 verkleinern --> For-Schleife erhöht j um 1
Dritter Durchlauf: J = 1:  lotto[1] == lotto[2]? ja -> j um 1 verkleinern --> For-Schleife erhöht j um 1
....... endlos

jetzt schau mal wie du das ändern musst .


----------



## chk1102 (2. Mrz 2011)

Ja irgendwas bringe ich durcheinander..

@Slater:
> wie komme ich an zuvor durch eine For-Schleife hinein geschriebenen Daten eines Arrays wieder ran
in einem Array ist nicht irgendwann etwas drin was vorher nicht drin war, jedenfalls nicht auf irgendeine ominöse Weise

d.h. also mit jeder For-Schleife greife ich drauf zu und kann dann zwischen diesen Klammern {} der Schleife sagen, was das Array tun soll oder natürlich auch andere Dinge??
Das hätte dann doch zur Folge, dass ich für jede neue Aufgabenstellung eine neue For-Schleife benötige?
Also sprich: Aufg. 1) Zufallszahlen generieren => 1. For-Schleife
Aufg. 2) wenn ZUfallszahl nicht gezogen wurde, ins Array ne 0 eintragen usw...

Für jede Aufgabe eine neue Schleife?

Ok, dann hab ich trotzdem noch etwas nicht verstanden.
Wenn ich zwei For-Schleifen eingebaut u so wie eben beschrieben gefüllt habe, überschreibe ich dann nicht das Array mi den Zufallszahlen? Wie kann ich die Werte jeweils abspeichern? Oder tut das Array das bereits??

vg
christin


----------



## SlaterB (2. Mrz 2011)

wieviele Schleifen du brauchst ist nicht festgelegt,
jede Schleife die etwas sinnvolles tut, ist in deinem Programm gut aufgehoben, ob 0, 1, 2, oder 1000,
je nach Geschicklichkeit kann man auch in einer Schleife mehrere Dinge auf einmal tun

manchmal braucht es auch gar keine, was der Stand der Aufgabe und deiner Lösung ist habe ich überhaupt nicht mehr im Überblick, 
wenn der Stand ist, dass es ein Array der Länge 49 bis 50 gibt, und darin 0, 1 oder 2 stehen soll, dann ist das Anlegen des Arrays
vielleicht bereits der erste Schritt, ganz ohne Schleife, ohne irgendetwas einzutragen wird einfach implizit festgelegt,
dass jede Array-Position für die zugehörige Zahl im Lotto steht (*),
weder muss etwas eingetragen werden, noch hat das was mit Zufall zu tun,


> Wenn ich zwei For-Schleifen eingebaut u so wie eben beschrieben gefüllt habe, überschreibe ich dann nicht das Array mi den Zufallszahlen? Wie kann ich die Werte jeweils abspeichern? Oder tut das Array das bereits??

wie gesagt ist es zumindest mir unklar was aktuell die Aufgabe ist, welche Arrays es gibt, was du darin alles speichern und vielleicht überschreiben willst/ musst/ kannst,
dir geht es sicher genauso, aber dafür kann ich ja nix,
bedenke die oben markierte Stelle (*), vielleicht ist das ein dir fehlender gedanklicher Schritt,

fange ansonsten doch einfach an, poste mal wieder etwas Code,
was soll das Programm leisten, was kann es schon?
du musst nicht alles auf einmal lösen, wie weit kommst du?
wo sind welche Daten warum gespeichert, wann kommst du an eine Überschreiben-Situation?
was stand vorher drin, was danach und warum?

man kann auch mehrere Arrays verwenden wenn man erstmal das Gefühl hat sie zu brauchen,
später schlauer zu sein und überflüssiges zu korrigieren ist kein Beinbruch,
alles direkt im Kopf lösen muss man als Anfänger nicht, ausprobieren!


----------



## Andi_CH (2. Mrz 2011)

Die Aufgabe etwas klarer formuliert:
(@TO: Warum lernt ihr nicht zuerst ein Problem zu analysieren bevor ihr mit Programmieren beginnt? Frag das mal den Lehrer)

Array mit 49 Plätzen instanzieren (Hinweis: Vermutlich ist es einfacher einen Array von 0..50 zu instanzieren und den Platz 0 zu vergessen - gezogen werden ja Zahlen von 1 - 49)

Nacheinander (ZAUNPFAHL -> loop) 6 Zahlen ziehen wobei bei jeder Zahl überprüft werden muss ob sie schon einmal gezogen wurde.

Das Ziehen so lange widerholen(ZAUNPFAHL -> loop) bis eine Zahl gefunden wird die bisher noch nie gezogen wurde.

Sobald eine Zahl gefunden wurde - 1 an entsprechender Stelle in den Array schreiben

Danach Zusatzzahl ziehen
(auch da überpüfen und eventuell widerholen wie oben beschrieben)

Wann ist der Abgabetermin - danach oder für 10 € gibts den fertigen Code


----------



## chk1102 (2. Mrz 2011)

Hehe 10€? 
Ich möchte es selbst lernen und nicht den fertigen Code 

Hier die Aufgabe:

Erstellen eines Programms, das 6 versch. Lottozahlen sowie eine Zusatzzahl zieht und diese anschließend in aufsteigender Reihenfolge zur Anzeige bringt.
Benutzen Sie nur Int-Array zur Abbildung von 49 Kugeln.
Das einer bestimmten Kugel zugeordnete array-Element soll den Wert 0 tragen, solange die Kugel noch nicht gezogen wurde und folglich sich noch in der Lostrommel befindet.
Den Wert 1, wenn die betreffende Kugel als eine der 6 Lottozahlen gezogen wurde und 2, wenn die betreffende Kugel als Zusatzzahl gezogen wurde.


Das ist die Aufgabe.
Ich hatte die Aufgabe wie folgt schon angefangen.


```
import java.util.Arrays;
 
public class A15 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        int[] lotto = new int[7];
        int zz = (int) (Math.random() * 49 + 1);
 
        // Lottozufallszahlen generieren
        for (int i = 1; i < lotto.length; i++) {
            lotto[i] = (int) (Math.random() * 49 + 1);
 
            // wenn Zahl gleich der Zfz is, noch mal zufällig wählen
            for (int j = 1; j < i; j++) {
                if (lotto[i] == lotto[j])
                    j--;
            }
        }
 
        // Array sortieren
        Arrays.sort(lotto);
 
        // Zufallszahlen ausgeben
        for (int k = 1; k < lotto.length; k++) {
            System.out.print(lotto[k] + ", ");
            
        }
 
        for (int l = 1; l < lotto.length; l++) {
            for (int m = 1; m < l; m++) {
                if (lotto[l] != lotto[m]) {
                    lotto[l] = 0;
                    if (lotto[l] == lotto[m]) {
                        lotto[l] = 1;
                    }
                }
                System.out.println();
                System.out.print("Lottozahlen: " + lotto[l] + ",");
            }
 
        }
    }
}
```

Problem analysieren ist ein guter Ansatz...:toll:
Ich fang das Ding jez noch einmal an und versuch es wieder zu programmieren...


----------



## SlaterB (2. Mrz 2011)

wie nun schon hinlänglich gesagt wurde, aber nochmal kurz zur Betonung:
du sollst kein kurzes Array verwenden wo hohe Zahlen bis zu 49 drinstehen, sondern ein langes Array in denen nur 0, 1, 2 drinsteht


----------



## Andi_CH (2. Mrz 2011)

```
for (int i = 1; i < lotto.length; i++)
```

Das stimmt schon mal überhaupt nicht - wirf den Code weg - schreib auf ein Papier WAS der Code machen soll (etwas detaillierter als ich) und danach beginnst du am Besten neu mit Codieren.

Das meine ich wirklich ernst, denn oft blockierst du dich mit dem was schon da steht!

Ich habe einen Zaunpfahl vergessen:

Die Suche nach einer Randomzahl die noch nicht gezogen wurde kommt zwei mal vor - das schreit förmlich danach das in einer eigenen Routine zu implementieren.

Mein Hauptprogramm hat 9 Zeilen (inklusive Ausgaben)

Die Suche nach einer neuen Random Zahl hat 7 Zeilen

Und ich habe eine eigene Ausgabroutine weil mein Array von 0-49 geht, aber nur 1 bis 49 interessant sind. Das sind nochmals einige Zeilen obwohl das vermutlich sogar als Einzeiler gehen würde.


----------



## Landei (2. Mrz 2011)

Mal aus'm Hut:


```
import java.util.Random;

...
Random random = new Random();
int[] array = new int[49];
for(int i=0;i < 49; i++) array[i] = i+1;
for(int swaps = 0; swaps < 5*49; swaps++) {
   int index1 = random.nextInt(49);
   int index2 = random.nextInt(49);
   int temp = array[index1];
   array[index1] = array[index2];
   array[index2] = temp; 
}
```

Danach ist array gemischt, und man könnte z.B. die ersten 6 Zahlen als Lotto-Ziehung verwenden.

Den Hinweis, dass man in der Praxis Collections.shuffle nehmen würde, gab es sicher schon (bin zu faul zum Suchen).


----------



## chk1102 (2. Mrz 2011)

Also ich hab mir nun das Programm in Einzelteile zerlegt.

1. 7 Zufallszahlen, aufsteigend sortieren und ausgeben (7 Zufalsszahlen deshalb, weil 6 Lotto und 1 Zusatzzahl)

2. die Zahlen von 1-49 in ein Array mit INTEGER packen

3. Abgleich machen: D.h.
wenn eine Zufallszahl (1.) == dem Arrays mit 49 (2.) ist
dann trage in das Arrays eine 1 ein

wenn eine Zufallszahl (1.) != dem Arrays mit 49 (2.) ist
dann trage in das Arrays eine 0 ein

wenn die Letzte Zufallszahl  (1.: das wäre dann ja die 7. Zufallszahl) == dem Arrays mit 49 (2.) ist
dann trage in das Arrays eine 2 ein


4. Ausgeben des Arrays mit 49 Zahlen mit den neuen Inhalten:
1,2 und 0

5. wenn in dem Arrays mit 49 Zahlen der Inhalt 1 (für richtig gezogene Lottozahl) geschrieben steht, dann gib die Anzahl der richtig getippten Lottozahlen aus.


Ist das so erst einmal richtig analysiert?
Bis jemand antwortet fange ich schon mal an weiterzuprogrammieren.


----------



## Andi_CH (2. Mrz 2011)

Ja - kannst du so machen, aber vergiss nicht, dass du bei der 7. Zahl eine 2 hineinschreibst wo du sonst eine 1 hineinschreibst

Ich habe 6 gezogen und dann noch eine, aber das ist Geschmackssache


----------



## tuttle64 (2. Mrz 2011)

mit einer collection set könnte das problem "6 zahlen aus 49" mit drei zeilen gelöst werden:


```
while (sset.size() < 6) {
				int num = (int) (Math.random() * 49) + 1;
				sset.add(num);
			}
```

da set keine duplikate akzeptiert, kann dem TreeSet keine Zahl hinzugefügt werden, die schon in der collection ist und es wird solange gezogen, bis 6 Zahlen vorhanden sind.


----------



## SlaterB (2. Mrz 2011)

> 2. die Zahlen von 1-49 in ein Array mit INTEGER packen

man kann es nicht oft genug wiederholen:
im ganzen Programm darf es nach der Aufgabenstellung kein Array-Platz oder sonst eine längerfristige Variable geben, in der hohe Zahlen wie 49 stehen!
das Programm von Landei ist da kontraproduktiv zur Aufgabenstellung! 

als Abbildung dient ein langes Array, anfangs 
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,usw.

wenn die Zahl 15 gezogen wird, dann an entsprechender Array-Position eine 1 eintragen:
0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,usw. oder ähnlich

nirgendwo steht der int-Wert 15 direkt, sämliche Information ist allein durch 0, 1 und 2 ausgedrückt 
sowie durch die Länge des Arrays und die Positionen der Zahlen 0, 1 und 2 darin

das nun bitte verstehen wenn die Aufgabe ganz korrekt gelöst werden soll


----------



## Tommy78 (2. Mrz 2011)

Blakh hat gesagt.:


> Endlosschleife?! Da musst du dir was anderes einfallen lassen. Z.b. eine HashMap: HashMap<Integer, Boolean> numbers; Welche du für alle 49 Werte mit false initialisierst. Key = 1-49 und Value = true/false, je nachdem ob vergeben oder nicht.



Bring Christin doch nicht gleich mit solchen "hohen" Sachen - wie HashMap durcheinander. Die Aufgabenstellung hört sich nach Grundlagen der Informatik o.ä. an. Da fängt man mit Arrays und Schleifen etc. an. Deshalb darf man da auch mal nicht "effizient" programmieren. 

@ Christin:

Versuche deinen Code ganz "stupide" mit folgenden Hinweisen *neu* auszubauen:

1. Ein int[]-array mit 49 Einträgen // keine Sorge, bei einem int-Array sind alle Einträge mit "0" vorinitialisiert
2. Nutze eine for-Schleife, die 6 Zahlen zieht. (Für das zufällige Ziehen, kann man auch eine kleine Methode schreiben)
2a) Bei jedem Ziehen prüfen, ob die Zahl bereits gezogen wurde und so lange wiederholen, bis das nicht mehr der Fall ist (Stichwort: do-while --> das solltet ihr schon kennen)
2b) trage die "1" entsprechend ein
3.Zusatzzahl: analog zu dem bisherigen (es wird eine Schleife benötigt aber welche ???:L)

Gruß
Tommy


----------



## Andi_CH (2. Mrz 2011)

tuttle64 hat gesagt.:


> mit einer collection set könnte das problem "6 zahlen aus 49" mit drei zeilen gelöst werden:
> 
> 
> ```
> ...



Aber da gibt es keine Array in dem 0 1 oder 2 drin steht und das ist bestandteil der Aufgabe - ...


----------



## Andi_CH (2. Mrz 2011)

Tja - mal dem TO den Mund wässrig machen 


```
Als 1. Zahl wurde 27 gezogen
Als 2. Zahl wurde 10 gezogen
Als 3. Zahl wurde 7 gezogen
Als 4. Zahl wurde 23 gezogen
Als 5. Zahl wurde 11 gezogen
Als 6. Zahl wurde 25 gezogen
Als Zusatzzahl wurde 32 gezogen
[0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
```


----------



## chk1102 (2. Mrz 2011)

So, ich hab die Lösung :autsch:;noe:


```
package Prüfung_teil_2;

import java.util.Arrays;

public class A15 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] lotto = new int[50];
		int zz = 0;
		int ziehung = 0;

		// ----------------------------

		for (int i = 1; i <= 7; i++) {
				ziehung = (int) (Math.random() * 49 + 1);
				if (lotto[ziehung] == 0) {
					lotto[ziehung] = 1;
				} else {
					i--;
				}

			}

		lotto[ziehung] = 2;
		//zusatzzahl
		System.out.print("Lottozahlen: ");
		for (int k = 1; k <= 49; k++) {
			if (lotto[k] == 1) {
				System.out.print(k + " ");
				
			}
		}
				
		//zusatzzahl
		System.out.print("\nZusatzzahl: ");
		for (int k = 1; k <= 49; k++) {
			if (lotto[k] == 2) {
				System.out.println(k + " ");
				
				
				
			}
		}
	}
}
```

Ausgabe:

Lottozahlen: 20 25 30 36 41 42 
Zusatzzahl: 38 


Aber nur mit Hilfe


----------



## Samuel72 (2. Mrz 2011)

Landei hat gesagt.:


> Mal aus'm Hut:
> 
> 
> ```
> ...


Das ist jetzt natürlich völlig OT, aber woher weißt du, dass 5*49 swaps ausreichen, um eine perfekte Mischung zu erzeugen?
Wenn man deinen Code ein klein wenig verändert, müsste eine völlig zufällige Mischung herauskommen:


```
import java.util.Random;

...
Random random = new Random();
int[] array = new int[49];
for(int i=0;i < 49; i++) array[i] = i+1;
for(int index1 = 0; index1 < 48; index1++) {
   int index2 = random.nextInt(49-index1) + index1;
   int temp = array[index1];
   array[index1] = array[index2];
   array[index2] = temp; 
}
```


----------



## SlaterB (2. Mrz 2011)

wieso index2 so eingeschränkt? wenn du dort die kompletten 49 nimmst, ist das schon ziemlich genau die Collections.shuffle()-Implementierung,
die geht zwar rückwärts durch die Liste/ durch das Array, aber das macht wohl keinen Unterschied


```
// Shuffle array
            for (int i=size; i>1; i--)
                swap(arr, i-1, rnd.nextInt(i));
```

edit: oh, da wird ja auch der Random-Wert immer verkleinert, dann ist das so ja schon perfekt nach shuffle()-Art


----------



## Samuel72 (2. Mrz 2011)

Rückwärts ist natürlich eleganter.
Letztlich geht es halt darum, sicherzustellen, dass jede der 49! Möglichkeiten mit gleicher Wahrscheinlichkeit auftritt.


----------



## Andi_CH (3. Mrz 2011)

Auch eine mögliche Lösung:


```
public class Lotto {
	//Aus reiner Bequemlichkeit verwende ich die Postionen 1 - 49
	private static int[] intArr = new int[49+1];
	
	//Diese Methode druckt 1..49 - geht sicher auch einfacher
	public static void printArr(int[] arr) {
		System.out.print("[");
		boolean firstTime = true;
		for(int i=1; i<arr.length; i++) {
			if (!firstTime) {
				System.out.print(", ");
			} else {
				firstTime = false;
			}
			System.out.print(arr[i]);
		}
		System.out.println("]");
	}

	// sucht eine bisher noch nicht gezogene Zufallszahl
	private static int getNewRandom() {
		int versuch;
		do {
			versuch = (int)((Math.random() * 48)+1);
		} while (intArr[versuch]!=0);
		return versuch;
	}

	public static void main (String[] args) {
		// Ziehe 6 Zahlen
		for(int anzahlGezogene=1; anzahlGezogene <= 6; anzahlGezogene++) {
			int zahl = getNewRandom();
			intArr[zahl] = 1;
			System.out.println("Als " + anzahlGezogene + ". Zahl wurde " + zahl + " gezogen");
		}
		int zusatzZahl = getNewRandom();
		intArr[zusatzZahl] = 2;
		System.out.println("Als Zusatzzahl wurde " + zusatzZahl + " gezogen");
		printArr(intArr);
	}
}
```


----------



## Smartys (13. Okt 2011)

Hallo Andi_CH, ich versuche gerade eine APP zu erstellen welche auch zufällige Lotto Zahlen generiert und bin auf dein Code aufmerksam geworden. Dürfe ich es nutzen? Es ist nichts für die Uni oder sowas, ich spiele nur mit der Idee sowas ähnliches auf meiner Seite einzubinden. Danke für eine kurze Rückmeldung!!
LG 
Sami


----------



## Gast2 (13. Okt 2011)

So eine Lottoziehung würde ich etwas anders machen, im worst-case läuft die obige Methode (unendlich) lange.

Folgende Implementierung ist eigentlich sehr simpel und erfüllt ihren Zweck ganz gut:

```
public class Lottery {
	public List<Integer> getLotteryDraw(final int k, final int n) {
		List<Integer> draw = new ArrayList<Integer>(n);

		// add all numbers
		for (int i = 1; i <= n; i++) {
			draw.add(i);
		}

		// shuffle
		Collections.shuffle(draw);

		// return sublist
		return draw.subList(0, k);
	}

	public List<Integer> getLotteryDraw() {
		return getLotteryDraw(6, 49);
	}
}
```


----------

