# Hilfe: Lotto: die 6 häufigsten generierten zahlen ausgeben



## Michi_himself (6. Jan 2006)

Hallo liebe Leute,

habe ein Problem. Bin gerade dabei, ein Lottoprog zu schreiben, bei dem als letzte
Funktion n Lotto-Tipps (6 aus 49) ausgeben soll, und dann in einer Statistik die 6 meist gezogenen Zahlen ausgegen werden sollen.

die n Tipps kann ich schon generieren lassen, und auch eine Statistik ausgeben, jedoch nur wie oft jede einzelne Zahl vorkommt.


Auf welche Weise kann ich die 6 meist gezogenen ausgeben? mit Array und TreeMap bin ich nicht weitgekommen.

Hab ihr vielleicht eine Idee??

mfg, danke im vorraus.


----------



## bygones (6. Jan 2006)

wie nicht weitgekommen.

einfachster weg -> array mit 49 elementen. Inhalt eines Elements gibt an wie oft die Zahle gezogen wurde, respektiv Zahl -1


```
lotterie[0] = 2;
lotterie[10] = 4;
```

würde heißen Zahl 1 (im array stelle 0) wurde 2 mal gezogen, die Zahl 11 4mal


----------



## Michi_himself (6. Jan 2006)

1. meine Java-version 1.5

2. code:

der code mit dem ich versucht hab, die ausgabe der 6 meist gezogenen Zahlen zu realisieren 
(hab die Schritte im Kommentiert


```
import java.util.*;
class Test {

//Lottozahlengenerator
public static void fillArrayList(List<Integer> list)
{

int [] zahlen = new int [6]; //Array für zufallszahlen
int zufall;
Random generator = new Random();

for (int i=0;i<=5;i++ ) {   //for-schleife zum auffüllen des array mit zufallszahlen
zufall = 1 + Math.abs(generator.nextInt(50));  

if (zufall == 0) {   
i--;
continue;
}
zahlen[i] = zufall;


for (int j=0;j<i;j++) {
if ( zahlen[j] == zufall ) {

i--;
break;
}
}
}

for (int k=0;k<=5;k++)         //fügt die Zahlen in eine ArrayList, die aus der main-Funktion übergeben wurde
{

list.add(new Integer(zahlen[k]));

}
  }
//Hauptprogramm
public static void main(String[] args) {

String lottokugel=" ";

List<Integer> list1 = new ArrayList<Integer>();
Map<String,Integer> map = new TreeMap<String,Integer>();

for (int z=1;z<=30;z++)           //die gewünschten kombinationen werden erstellt.
{
fillArrayList(list1);
}
System.out.println("\nLotto-Tipp(s):");

for (int y=0;y<=(list1.size()-1);y++)  //die kombinationen werden ausgegeben
{
if ( y % 6 == 0)
{
System.out.println("\n");
}

Object ausgabe =list1.get( y );
System.out.print( ausgabe + "\t");
}

int [] lottoZahlen = new int [51];                   

for(int x=0;x<=(list1.size()-1);x++) {      // hier werden die kombinationen aus der ArrayList gelesen, und geprüft, 
                                                             //wie oft diese auftreten, dazu werden die diese in ein array abgelegt
Integer vergleich = list1.get( x );

lottoZahlen[vergleich] += 1;
}
System.out.print("\n\n\n\n");
System.out.println("Lottozahlen:\t\tHäufigkeit:\n");


for (int u=0;u<=(lottoZahlen.length-2);u++)         //die zahlen werden in eine TreeMap eingefügt
{
lottokugel = String.valueOf(lottoZahlen[u]);
map.put(new String(lottokugel),u);
}
for( String key : map.keySet() ) {               //der inhalt der der map wird ausgegeben
System.out.println( key + " -> " +
map.get(key) );
}


}
}
```

verzeiht die schreibfehler, es ist schon ziemlich früh


----------



## Guest (6. Jan 2006)

Erstelle eine Klasse LottoZahl, die die Zahl selbst und die Anzahl der Ziehungen beschreibt
und das Comparable-Interface implementiert. Erstelle ein Array mit 49 Instanzen dieser 
Klasse und verwende diese bei den Ziehungen. Am Ende kannst Du mit Arrays.sort(...) die 
LottoZahl-Instanzen auf-/absteigend sortieren, je nach dem wie du das Comparable Interface 
implementiert hast.


----------



## Michi_himself (6. Jan 2006)

deathbyaclown hat gesagt.:
			
		

> wie nicht weitgekommen.
> 
> einfachster weg -> array mit 49 elementen. Inhalt eines Elements gibt an wie oft die Zahle gezogen wurde, respektiv Zahl -1



so hab ich das gemacht. ist auch im quelltext zu sehen, den ich noch nach deinem beitrag gepostet hab.
nur kann ich dann ja nicht nach den meist gezogenen sortieren. mit arrays.sort z.b. wäre dann der index des Arrays nicht passend zu dem Wert. 

Bei TreeMap wird ja nach dem Schlüssel sortiert, aber das dumme ist, dass dazu als Schlüssel die Häufigkeit einfügen muss, und der Schlüssel wird ja bei Gleichem Wert bekannterweise überschrieben... 

@ Gast:

Hmm, klingt gut, nur wie sehe das denn in Form eines Quellcodes aus


----------



## Roar (6. Jan 2006)

```
class Lottozahl implements Comparable<LottoZahl> {

public LottoZahl(int zahl) {
this.zahl = zahl;
}

public void gezogen() {
this.gezogen++;
}

public int compareTo(LottoZahl z) {
int i1 = gezogen, i2 = z.gezogen;
return (i1 < i2 ? -1 : (i1 == i2 ? 0 : 1));
}
}

...
LottoZahl[49] zahlen = ...
...
Arrays.sort(zahlen);
...
```

so ungefähr irgendwie etwa


----------



## Michi_himself (6. Jan 2006)

die neue klasse müsste ich ja in der Main Funktion per z.B.

LottoZahl lotto = new LottoZahl();

einbinden?!?!?!


... 
LottoZahl[49] zahlen = ...  
... 
Arrays.sort(zahlen); 
...

wo kommt das hin???


----------



## Gast (6. Jan 2006)

Ihr wisst aber schon das Lotto (6 aus 49 ohne zurücklegen) statistisch gleichverteilt ist . Auf kurz oder lang gibts keine häufigsten, bzw. ein Unterscheid ist infitissimal klein.

Wozu um Himmels Willen brauchst du bzw. für was schreibst du ein Lottoprogramm? Ich hoffe nicht um dir die am häufigsten gezogenen Zahlen ausgeben zu lassen, in der Meinung dein Gewinn sei dann wahrscheinlicher.


----------



## Michi_himself (6. Jan 2006)

hehe :wink: die millionen locken...

 Nein, es hat mal wieder etwas mit Schule zu tun.

Aber ich habe so langsam die Lösung.

(TreeMap)
Ich habe mit Hilfe des folgenden Codes der Häufigkeit der gezogenen Zahlen 
die Nummer der dazugehörigen "Kugel" einfach als Nachkommastelle angehängt.
Somit kann der Schlüssel im TreeMap nicht überschrieben werden, was, wie im vorigen thread beschrieben, mein prob war.



```
for (int u=1;u<=(lottoZahlen.length-2);u++)
{
haufigkeit = Double.valueOf(lottoZahlen[u]);
if (u <=9)
{
 lottoKugel = (Double.valueOf(u)/10);
}
else {
  lottoKugel = (Double.valueOf(u)/100);
}

map.put(new Double((haufigkeit+lottoKugel)),new Integer(u));
}
```

Darauf habe ich einfach die automatisch in der TreeMap sortierten Werte aus der TreeMap in eine ArrayList übertragen, um dem Element einen Index zu verpassen.
Die Arraylist habe ich mit einem Array ausgelesen. 

Jetzt bin ich dabei, die Ausgabe einzugrenzen, damit die 6 meistgezogen nur ausgegen werden.
Also die Array-Indexs mit dem höchsten Ínhalt.

Nebenbei: Weiss jemand, wie ich Double Werte in Integer umwandeln kann???? 


```
double kommazahl =33.0;

int beispiel = Integer.valueOf(kommazahl)
```

liefert nur folgende Fehlermeldung:
_*
Test.java:119: cannot find symbol
symbol  : method valueOf(double)
location: class java.lang.Integer
ausleseParsed=Integer.valueOf(auslese[se]);
                     ^
1 error
*_[/i]


----------



## SlaterB (6. Jan 2006)

double y = 7.3;
int x = (int)  y;

rundet glaube ich immer ab, ansonsten gibts noch Math.round() und ähnlich Spezialitäten,

das mit der Map klingt ziemlich kompliziert,
wen du schon den Trick mit dem Kommazahlen anwenden willst tut es vielleicht auch ein double-Array?


in der Art von


```
int[] lottozahlen = {3, 0, 0, 7, 4, 0, 0, 9, 9, 12, 3444};
double[] m = new double[lottozahlen.length];
for (int i=0; i<lottozahlen.length; i++) {
   m[i] = lottozahlen[i]+ (0.01 * i);
}
Arrays.sort(m);
	
for (int i=0; i<6; i++) {
	int k = lottozahlen.length-1-i;
	System.out.println((i+1)+". häufigste Zahl ist "+((int) ((m[k] * 100) % 100))+
		", Anzahl: "+(int) m[k]);
}
```


----------



## Michi_himself (6. Jan 2006)

oO

oha!! auf so was wäre ich ja nie gekommen!! [schild=9 fontcolor=000000 shadowcolor=C0C0C0 shieldshadow=1]dankee![/schild]

probier ich gleich mal , denn der versuch, dies per map zu lösen, funktioniert zwar, aber nicht so ganz,
wie ich es mir vorstelle.

Alle Werte werden korrekt eingelesen und auch ausgegeben; das Problem ist, dass, wenn ich dann mit einer for schleife durch die in die ArrayList übertragene  Treemap laufe und den Inhalt ausgebe, variiert die Indexgröße zwischen 46 und 49....?!!??

was könnte da nicht stimmen?

hier der code.... was ist da falsch?

```
for (int u=0;u<(lottoZahlen.length);u++)
{
haufigkeit = Double.valueOf(lottoZahlen[u]);
if (u <=9)
{
 lottoKugel = (Double.valueOf(u)/10);
}
else {
  lottoKugel = (Double.valueOf(u)/100);

}

map.put(new Double((haufigkeit+lottoKugel)),new Integer(u));
}
//lottoKugelInt = Integer.valueOf(map.size());
double [] lottoStat = new double [map.size()];
System.out.println(map.size()+"\n\n\n\n");


for( Double key : map.keySet() ) {

//  lottoKugelInt =Integer.ValueOf(map.get(key));

list2.add(map.get(key));

System.out.println(key+ "\t"+ map.get(key));
   }
System.out.println("\2\2\2\2\2");

   double [] auslese = new double [51];

for(int se=0;se<(list2.size());se++) {

double ernte = list2.get( se );

auslese[se] = ernte;

System.out.println(se+ "\t" +auslese[se]);

//ausleseParsed=(int) auslese[se];

//System.out.println(ausleseParsed);

}
System.out.println("\n\n\n\n\n\n\n\n\n\n");
for (int ausgabeMax=(auslese.length-7);ausgabeMax<(auslese.length);ausgabeMax++)
{
ausleseParsed=(int) auslese[ausgabeMax];

System.out.println(ausleseParsed);
}
```


----------



## Michi_himself (6. Jan 2006)

Hallo!

Habe mir nochmal die Ausgabe der Werte angeschaut:

*
..........................
3.26    26
3.3     3
3.32    32
3.34    34
3.36    36
3.4699999999999998      47  <------------- 
3.49    49
3.6     6
3.9     9
4.1     10
................
*

die stelle, die mir spanisch vorkommt, habe ich mit dem Pfeil markiert
Immer wenn so eine eigenartige Zahl auftritt, verändert sich immer die Feldgröße

Diese double werte werden mit folgenden code stück  bewerkstelligt

```
for (int u=0;u<(lottoZahlen.length);u++)
{
haufigkeit = Double.valueOf(lottoZahlen[u]);
if (u <=9)
{
 lottoKugel = (Double.valueOf(u)/10);
}
else {
  lottoKugel = (Double.valueOf(u)/100);

}
```

Wie kommt es zu dieser verkorksten Ausgabe, die mein Code zunichte macht??? :autsch:


----------



## SlaterB (6. Jan 2006)

double ist nun mal double,
solche Kommazahlen lassen sich schwer mit Bits und Bytes darstellen,
da muss man dann an der Ausgabe selber feilen,

es gibt bestimmte Klassen für sowas (NumberFormat oder so)
ansonsten kann man sich auch per Hans ne Funktion schreiben,
für 2 Stellen nach dem Komma z.B. mit 100 mal nehmen, runden und dann im String das Komma manuell weiter links einordnen

----------

zu den Indexen: 
deine Rechnung ist etwas komisch
1 bis 9 teilst du durch 10 -> 0.1 bis 0.9
10 bis 49 teilst du durch 100 -> 0.10 bis 0.49

0.1, 0.2 0.3 usw. werden also sowohl für 1, 2, 3 als auch für 10, 20, 30 errechnet!
teil doch einfach immer durch 100, dann hast du 0.01 bis 0.49 durchgängig

---------

Double.valueOf(int) macht übrigens keinen Sinn?, 
du kannst direkt double haufigkeit = u; schreiben


----------



## Michi_himself (6. Jan 2006)

Hi Slater!

das double Problem hab ich mithilfe von Math.round() gelöst

Aber der Knackpunkt war wirklich  der fehler mit dem Index!!  :applaus: 

ich habs jetzt durch 100 geteilt, wie du sagtest, und siehe da, es läuft wie geschmiert.


[schild=6 fontcolor=000000 shadowcolor=C0C0C0 shieldshadow=1]Dankeschööön![/schild]


----------

