# 6 int variablen vergleichen



## 786Newbie (18. Jun 2014)

Hi, mein Ziel ist dass ich 6 int variablen 

```
int i1=(int) (Math.random()*6);//zufallszahl
int i2=(int) (Math.random()*6);//zufallszahl
int i3=(int) (Math.random()*6);//zufallszahl
int i4=(int) (Math.random()*6);//zufallszahl
int i5=(int) (Math.random()*6);//zufallszahl
int i6=(int) (Math.random()*6);//zufallszahl
```

in einem if  ()vergleichen soll und wenn mindestens 3 den gleichen wert haben,
es was bestimmtes ausdruckt.

hab schon einpaar sachen ausprobiert aber hat leider nicht funktioniert und google find ich auch nichts brauchbares.
das einzige idee, die ich habe ist jede einzelne möglichkeit aufzuschreiben 
hoff jemand kann mir weiter helfen :roll:


----------



## Gucky (18. Jun 2014)

Du könntest die 6 Variablen als Array oder als List darstellen und diese/s sortieren.


----------



## Ruzmanz (18. Jun 2014)

```
HashSet<Double> set = new HashSet<>(6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
if(set.size() >= 3) {
	System.out.println("Glück gehabt.");
}
```

Ich hätte es spontan mit einem Set<E> gemacht. Evtl. findet noch jemand eine bessere Lösung.


----------



## Androbin (18. Jun 2014)

Wie wäre es damit *8*

Du fügst in einer for-Schleife die int's einer ArrayList, etc. hinzu und
prüfst (innerhalb der for-Schleife) mit der contains-Methode, ob dieser bereits vorhanden war/ist.


```
ArrayList<Integer> list = new ArrayList<Integer>();

boolean bool = false;

for ( int i = 0; i < 6M i++ ) {
	
	int integer = (int) ( Math.random() * 6 );
	
	if ( !list.contains( integer ) )
		  list.add( integer );
	else {
		bool = true;
		break;
	}
	
}

String s = null;

if ( bool ) s = "Doppelt !!!";
else        s = "Nicht Doppelt !!!";

System.out.printl( s );
```


----------



## 786Newbie (18. Jun 2014)

@Gucky
sry komme nicht drauf was du meinst
wenn die zahlen sortiert sind hab ich sie halt in einer anderen "reihenfolge" wie soll daraus den programm rausfinde lasse ob mindestens 3 variablen den selben wert haben?

@Ruzmanz 
kenne mich leider mit Hashset nicht aus, bin noch ein totaler neuling ^^
muss ich dafür etwas besonderes noch dazu schreibe? denn es zeigt bei mir fehler an und ich komme nicht drauf was, und kann ich dazu die variablen einfügen? brauche die nämlich für mein programm

@Androbin
korrigier mich falls falsch liege, aber dieser code reagiert ja AUCH wenn es NUR doppelt ist oder?
vlt hab ich meine frage falsch formuliert. ich brauch die 6 variablen für ein kleines spiel
dabei werden 6 bilder angezeigt die jede sekunde zufällige bild anzeigt, falls 3 bilder die selben sind, muss der spieler enter rechtzeitig drücken. wenn du möchtest kann ich mein momentanen Code hier mal posten


----------



## Ruzmanz (18. Jun 2014)

Du hast wahrscheinlich 
	
	
	
	





```
import java.util.HashSet;
```
 vergessen. Ein Set ist ein Datenstruktur (wie zum Beispiel Listen, Bäume, Stacks, etc.), dass keine doppelten Inhalte speichert. Wenn du den gleichen Wert mehrmals hinzufügst, wird es nur einmal gespeichert. Solange du dort keine eigenen Objekte reinpacken willst, sollte das keine Probleme geben.


```
double a1 = 23.2;
double a2 = 10;

HashSet<Double> set = new HashSet<>(6);
set.add(a1);
set.add(a2);

if(set.size() >= 3) {
   System.out.println("Glück gehabt.");
}
```


----------



## Androbin (18. Jun 2014)

Basierend auf Ruzmanz Variante mit dem HashSet *8*

```
ArrayList<Double> set = new ArrayList<Double>();

for ( int i = 0; i < 6; i++ )
	set.add ( Math.random() * 6 );

if ( set.size() >= 3 )
	 System.out.println( "Mehr als 3 Gleiche" );
else System.out.println( "Weniger als 3 Gleiche" );
```


----------



## Gucky (18. Jun 2014)

Ich meinte damit, dass du die 6 Variablen sortierst und somit nicht mehr per BruteForce alle Zahlen mit allen anderen vergleichen musst.
Sind sie sortiert, musst du nur ein mal über das Array iterieren und damit gucken, ob drei gleiche zu finden sind, weil diese nebeneinander wären.

Aber das HashSet geht natürlich auch (funktioniert sogar ähnlich, nur dass es die Werte vorher prüft und doppelte erst gar nicht rein lässt).


----------



## 786Newbie (18. Jun 2014)

```
HashSet<Integer> set = new HashSet<>(6);
	set.add(i1);
	set.add(i2);
	set.add(i3);
	set.add(i4);
	set.add(i5);
	set.add(i6);
	   if(set.size() >= 3) {
}
```

also wenn ich es richtig verstande habe ist Hashset sowas wie ein array wobei es keinen wert doppelt nimmt, dadurch würden also im set nur noch 4 sein, und da es größer als 3 ist erfüllt es die bedingung?
falls ich es richtig verstande habe heißt es doch dass wenn es 5 oder 6 gleiche werte sind dass es gar nicht aufgeht mit "mindestens 3 gleiche werte" ?


----------



## Gucky (19. Jun 2014)

Bei fünf gleichen Werten ist das HashSet nur noch zwei Indizes groß.
Bei vier gleichen Werten ist das HashSet nur noch drei Indizes groß.
...

Vergleichen kann man das HashSet IMHO besser mit einer List.


----------



## Natac (19. Jun 2014)

786Newbie hat gesagt.:


> also wenn ich es richtig verstande habe ist Hashset sowas wie ein array wobei es keinen wert doppelt nimmt, dadurch würden also im set nur noch 4 sein, und da es größer als 3 ist erfüllt es die bedingung?


Eher nein. Ein Hash*Set* (Set = Menge), ist eine Menge von Werten ("Hash" sagt nur etwas über die Art der Implementierung aus).

Und genau wie bei einer Menge, gilt für jedes Set (nicht nur HashSet):
- Jeder Wert kommt nur einmal vor (deswegen gibt es keine Dopplungen)
- Die Werte haben keine bestimmte Ordnung (also gar nicht wie ein Array)

Aber natürlich sind beides Container, die mehrere Daten aufnehmen.


----------



## dogmi (19. Jun 2014)

Versuch mal sowas in der Art: Schreib grad nur Pseudo, kann also Syntaktisch falsch sein.
Vorteil ist man hat nur eine Schleife, zumindest im Code.


//setzen der Werte
ArrayList<Long> set = new ArrayList();
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);
set.add(Math.random()*6);

set.sort();   //irgend eine Klasse hat die sort FunKtion schon, kann man aber auch selber überschreiben


int matches = 0;  //wieviel treffer man bei einer Zahl hat
for(int i = 0; i < set.size(); i++) {

   if (matches != 3)  // prüfen, ob wir es geschafft haben, beim ersten durch lauf nicht, logisch
   {
      matches = 1;   //erste Zahl ist immer ein Treffer, und überschreiben der Durchläufe von vorher
      int a = i;
      for( a < set.size(); a++)
      {
          if ( set.get(i) == set.get(a) )
          {   //gleiche Zahlen stehen hintereinander
               matches++
           }
           else
           {
                   i = a; //i gleich auf a setzen sind wir eh schon durch
                   break;
            }
      }

   }
   else
   {   // eventuell mit boolean arbeiten
        System.out.println("Glück gehabt.");
    }
}


----------



## 786Newbie (19. Jun 2014)

Mit anderen worten 
statt:

```
if(set.size() >= 3) {
```
einfach das schreiben :

```
if(set.size() <= 3) {
```

dann aktivierts sich jedes mal wenn es mindestens 3 gleiche gibt, da dann nur noch 3 oder weniger im set drinnen sind?


----------



## Gucky (19. Jun 2014)

Genau so ist es. Aber ich glaube, es müsste 
	
	
	
	





```
if (set.size() <= 4)
```
 sein.
Denn: 
	
	
	
	





```
1 2 3 3 3 4
```
 wird im Set zu 
	
	
	
	





```
(1 2 3 4).size() == 4
```
.

[EDIT]
Was passiert eigentlich, wenn 
	
	
	
	





```
1 1 2 2 3 3
```
 ins Set geschrieben werden soll? Dann ist die Größe auch 3 oder hab ich da einen Denkfehler drin?
[/EDIT]


----------



## stg (19. Jun 2014)

@Gucky Nö, kein Denkfehler. Über die Größe eines Sets funktioniert das Spielchen nicht.


----------



## 786Newbie (19. Jun 2014)

@Gucky :
daran hab ich gar nicht gedacht 
dann kann ich set nicht benutzen da ich nach dem hier eine if-abfrage brauche mit " falls nicht mindestens 3 gleich sind"


----------



## Gucky (19. Jun 2014)

Da der Bereich, in dem sich die Zufallszahlen bewegen sehr klein ist, halte ich den folgenden Vorschlag für den Besten.


```
int[] zahlen = new int[6];
for (int tempInt : zufallszahlenList) {
  zahlen[temp]++;
}

for (int tempInt : zahlen) {
  if (temp >=3) tuWas();
  else tuWasAnderes();
}
```

Die beiden Schleifen sind kombinierbar aber der besseren Lesbarkeit wegen habe ich sie getrennt.
Falls es noch bessere Möglichkeiten gibt, bin ich offen für diese.


----------



## 786Newbie (19. Jun 2014)

sry ich denk mal ich zu blöd um zu verstehen was genau der code macht ^^
könntest du vlt zeile für zeile erklären?


----------



## Gucky (20. Jun 2014)

Das sind sog. for-each Schleifen. Mehr dazu bei Google.

Es wird ein mal das Array durchlaufen und dabei die einzelnen Vorkommen der Zahlen gezählt. Dann wird über das andere Array iteriert und geguckt, ob eine Zahl häufiger als drei Mal vorhanden ist.


----------



## turtle (22. Jun 2014)

```
@Test
	public void test() {
		Set<Integer> set = new HashSet<>();
		int multiple = 1;
		if (!set.add(1)) multiple++;
		if (!set.add(2)) multiple++;
		if (!set.add(3)) multiple++;
		if (!set.add(3)) multiple++;
		if (!set.add(3)) multiple++;
		if (!set.add(4)) multiple++;
		// Mindestens drei gleiche
		assertTrue("Doppelt sind nur " + multiple, multiple >= 3);
	}
```


----------



## turtle (22. Jun 2014)

Oops, mein Test war leider falsch;-(

Das fehlerhafte Ding zählte ALLE unterschiedlichen zahlen!

Also bei 1,2,2,3,3,4 werden 3 Unterschiede gefunden, obwohl nur zwei unterschiedliche Zahlen vorhanden sind. Asche auf mein Haupt.

Meine Korrektur merkt sich nun für jede Zahl (in einer Hashmap) wie oft diese Zahl vorkommt. 

Beim ersten Mal ist eine Zahl nicht vorhanden, also speichere ich die Zahl mit Vorkommen=0. Anschließend erhöhe ich das Vorkommen um eins. Zum Schluss muss ich nur über die Hashmap laufen und den Eintrag mit dem höchsten Vorkommen suchen und dieser muss mindestens drei sein. Diese Zahl wird an die Methode multipleValues übergeben, damit ich das schön per jUnit testen kann.


```
@Test
	public void test1() {
		int i1 = 1;
		int i2 = 2;
		int i3 = 2;
		int i4 = 3;
		int i5 = 3;
		int i6 = 3;
		multipleValues(3, i1, i2, i3, i4, i5, i6);
	}

	@Test
	public void test2() {
		int i1 = 1;
		int i2 = 2;
		int i3 = 2;
		int i4 = 3;
		int i5 = 3;
		int i6 = 4;
		multipleValues(2, i1, i2, i3, i4, i5, i6);
	}

	@Test
	public void test3() {
		int i1 = 3;
		int i2 = 3;
		int i3 = 3;
		int i4 = 3;
		int i5 = 3;
		int i6 = 3;
		multipleValues(6, i1, i2, i3, i4, i5, i6);
	}

	private void multipleValues(int expectMultiple, int i1, int i2, int i3, int i4, int i5, int i6) {
		Map<Integer, Integer> map = new HashMap<>();
		putAndIncrement(i1, map);
		putAndIncrement(i2, map);
		putAndIncrement(i3, map);
		putAndIncrement(i4, map);
		putAndIncrement(i5, map);
		putAndIncrement(i6, map);
		Set<Entry<Integer, Integer>> keySet = map.entrySet();
		int multiple = -1;
		for (Entry<Integer, Integer> entry : keySet) {
			if (entry.getValue() > multiple) {
				multiple = entry.getValue();
			}
		}
		assertTrue("Doppelt sind nur " + multiple, multiple == expectMultiple);
	}

	private void putAndIncrement(int x, Map<Integer, Integer> map) {
		Integer integer = map.get(x);
		if (integer == null) {
			map.put(x, 0);
		}
		map.put(x, map.get(x) + 1);
	}
```


----------



## 786Newbie (24. Jun 2014)

@Gucky danke, wusst gar nicht was for-each schleifen sind bzw wie sie funktionieren 

irgendwie gefühl dass es ziehmlich peinlich ist,dass ich das nicht verstehe ^^
naja hab versucht jetzt schritt für schritt mit dein Programm zu gehen, damit du siehst wo ich was falsch verstanden hab, und mich Zusammmen scheisen kannst 


Bsp die 6 Zufalls zahlen sind : 1 ,1,2,2,3,3:

-- array Zahlen  mit 6 Speicherplätzen reserviert
-- die 6 variablen werden in Zufallszahlenlist hinzugefügt , wobei es alles doppelte nicht hinzufügt
-- in der schleife hat dann tempInt jeweils den wert 1,2,3:
-- und dabei wird temp immer um eins erhöht
      zahlen[1]
      zahlen[2]
      zahlen[3]

2te forschleife:
-- tempInt wird jeweils zum wert von array Zahlen 
-- temp = 3 wegen vorherige schleife
--tempInt=1        if(temp>=3)         
-- tempInt=2       if(temp>=3)
-- tempInt=3       if(temp>=3)


----------



## Gucky (25. Jun 2014)

Eigentlich nicht 

Mein Programm speichert zuerst die Zufallszahlen in einer List. Und zwar alle.
Dann läuft es ein mal über die List und erhöht immer an dem Index eines Arrays, der durch die aktuelle Zahl in der List beschrieben wird, den Wert um eins. Da habe ich mich verschrieben. temp müsste tempInt heißen. Asche auf mein Haupt.

In der nächsten Schleife wird das Array, in welchem zuvor die Zahlen gezählt wurden, abgelaufen und es wird geguckt, ob einer der Werte 3 oder größer ist.


Jetzt wissen wir auch, warum du es so schwer hattest das zu verstehen. Das war mein Fehler. Tut mir leid.


----------



## 786Newbie (26. Jun 2014)

//Falls mindestens 3 gleich sind
	 ArrayList<Integer> zufallszahlenList = new ArrayList<>(6);
	 zufallszahlenList.add(i1);
	 zufallszahlenList.add(i2);
	 zufallszahlenList.add(i3);
	 zufallszahlenList.add(i4);
	 zufallszahlenList.add(i5);
	 zufallszahlenList.add(i6);

    	int[] zahlen = new int[6];
    	for (int tempInt : zufallszahlenList) {
    	  zahlen[tempInt]++;
    	}
    	for (int tempInt : zahlen) {
    		if (tempInt >=3) { tuWas();}
                else {tu was anderes }

habs so gemacht jetzt aber hab da wieder was falsch ;( 
würde das ding nicht wie ne arbeit zählen hätt ich glaub schon längst aufgegeben xD


----------



## Gucky (26. Jun 2014)

"hab da wieder was falsch"

Was ist falsch?
Welche Meldungen bekommst du?

Und es muss 
	
	
	
	





```
zahlen[tempInt - 1]++;
```
 sein.  Ich hatte wieder einen Fehler drin. Der Fehlerteufel meint es nicht gut mit mir.

Ferner musst du die Methoden 
	
	
	
	





```
tuWas()
```


```
tuWasAnderes()
```
 natürlich noch implementieren. Außerdem hast du die Klammern der zweiten Methode vergessen.

UND: Java Code in Java-Tags! So, wie es über jedem Beitragseditierenfeld dick und fett in rot steht!


----------



## 786Newbie (26. Jun 2014)

sry! :O tags vergessen :bloed:

alsooo: 
wenn ich 
	
	
	
	





```
zahlen[tempInt - 1]++;
```
 mache kommt jedes mal fehler wenn ich key drücke xD
wenn ich  
	
	
	
	





```
zahlen[tempInt ]++;
```
 mache, startet es IMMER 
	
	
	
	





```
tuwasanderes()
```
ändere ich 
	
	
	
	





```
f (tempInt >=3)
```
 zu 
	
	
	
	





```
f (tempInt <=3)
```
 startet es IMMER 
	
	
	
	





```
tuwas()
```

ich hab das alles dann mit system.out.println gekuckt was das jetzt wirklcih macht
also halt geschaut bei welche variablen es welche methode starten würde
und nach meinen kleinen wissen kommt da wirres zeug raus :toll:

ja ich weis hab des frei geschriebe im beim posten, da ich in echt an dieser stelle langer code da hab, was ich noch nicht als methode implementiert habe und zu faul war des zu kopieren =D


----------



## Gucky (26. Jun 2014)

Kannst du noch einmal den betreffenden Code posten, der den Fehler verursacht? Also die beiden Schleifen?

Die Wahrscheinlichkeit, dass es wirklich drei gleiche Zahlen im Array sind, ist relativ klein. Lass dir mal mit einem Sysout zusätzlich die List und das Array ausgeben.

Schreib mal zu Testzwecken manuell drei gleiche Zahlen in die List.


----------



## 786Newbie (26. Jun 2014)

```
ArrayList<Integer> zufallszahlenList = new ArrayList<>(6);
	 zufallszahlenList.add(i1);
	 zufallszahlenList.add(i2);
	 zufallszahlenList.add(i3);
	 zufallszahlenList.add(i4);
	 zufallszahlenList.add(i5);
	 zufallszahlenList.add(i6);
    	
    	int[] zahlen = new int[6];
    	for (int tempInt : zufallszahlenList) {
    	  zahlen[tempInt ]++;
    	}
    	for (int tempInt : zahlen) {
    		if (tempInt >=3) {
                    System.out.prinltn(i1+""+i2...........+""+tempInt +"mind 3 gleiche")
                  }
               else {System.out.prinltn(i1+""+i2...........+""+tempInt +"keine 3 gleiche")
               }
```
hab ja system.out.println gemacht umzu sehen was es überhaupt macht aber da kam iwie wirres zeug :bahnhof:


----------



## Gucky (26. Jun 2014)

Es muss 
	
	
	
	





```
zahlen[tempInt - 1]++;
```
 heißen, wie ich oben schon geschrieben habe.

Was für wirres Zeug? Poste das mal.


----------



## 786Newbie (26. Jun 2014)

wenn ich 
	
	
	
	





```
zahlen[tempInt - 1]++;
```
 bei diesem code mache, und dann irgendwann enter drücke, kommt in eclipse in der konsole gaaanz viele fehler, deswege hatt ich wieder raus gemacht
wirres zeug wie:


```
000004mindestens 3gleiche
000004keine 3gleiche
000004keine 3gleiche
000004keine 3gleiche
000004keine 3gleiche
000004keine 3gleiche
```


```
/Falls mindestens 3 gleich sind
	 ArrayList<Integer> zufallszahlenList = new ArrayList<>(6);
	 zufallszahlenList.add(i1);
	 zufallszahlenList.add(i2);
	 zufallszahlenList.add(i3);
	 zufallszahlenList.add(i4);
	 zufallszahlenList.add(i5);
	 zufallszahlenList.add(i6);
    	
    	int[] zahlen = new int[6];
    	for (int tempInt : zufallszahlenList) {
    	  zahlen[tempInt ]++;
    	}
    	for (int tempInt : zahlen) {
    		if (tempInt >=3) {
    			System.out.println(i1+""+i2+""+i3+""+i4+""+i5+""+i6+""+"mindestens 3gleiche");
    	  
    			if (e.getKeyCode() == KeyEvent.VK_ENTER) {
    				if (alreadyPressed == false) {
    					versuch.setPunkte1(punkte);
    					versuch.setMittelfeldinfo("Spieler1 war schneller!");
    					versuch.setNewround("Drücke die taste S für eine weitere Runde");
    					repaint();
    					stopAnimation();
    				}
    				alreadyPressed = true;
    			}
    			if (e.getKeyCode() == KeyEvent.VK_SPACE) {
    				if (alreadyPressed == false) {
    					versuch.setPunkte2(punkte);
    					versuch.setMittelfeldinfo("Spieler2 war schneller!");
    					versuch.setNewround("Drücke die taste S für eine weitere Runde");
    					repaint();
    					stopAnimation();
    				}
    				alreadyPressed= true;
    			}
    		}
    		// falls NICHT mindestens 3 gleich sind
    		else {
    			System.out.println(i1+""+i2+""+i3+""+i4+""+i5+""+i6+""+"keine 3gleiche");
    			if (e.getKeyCode() == KeyEvent.VK_ENTER) {
    				if (alreadyPressed == false) {
    					versuch.machwenigerPunkte1(punkte);
    					stopAnimation();
    					versuch.setMittelfeldinfo("Das war schlecht Spieler1! Versuchs nochmal!");
    					versuch.setNewround("Drücke die taste S für eine weitere Runde");
    					repaint();
    				}
    				alreadyPressed= true;
    			}
    			if (e.getKeyCode() == KeyEvent.VK_SPACE) {
    				if (alreadyPressed == false) {
    					versuch.machwenigerPunkte2(punkte);
    					stopAnimation();
						versuch.setMittelfeldinfo("Das war schlecht Spieler2! Versuchs nochmal!");
						versuch.setNewround("Drücke die taste S für eine weitere Runde");
						repaint();
    				}
    				alreadyPressed= true;
    			}
    		}
    	}
	}
```


----------



## Gucky (26. Jun 2014)

Von wo bis wo gehen die Zufallszahlen? Gehen die von 0 - 6 oder von 1 - 6?

Poste auch mal die Erstellung der Zufallszahlen.

Willst du nach dem Finden einer Zahl, die häufiger als drei mal vorhanden ist, aufhören oder willst du dann weitersuchen?


----------



## 786Newbie (26. Jun 2014)

```
public void run(){
		while (true) {
			//Zufalls zahlen der 6 kästen			
			 i1=(int) (Math.random()*6);//zufallszahl
			 i2=(int) (Math.random()*6);//zufallszahl
			 i3=(int) (Math.random()*6);//zufallszahl
			 i4=(int) (Math.random()*6);//zufallszahl
			 i5=(int) (Math.random()*6);//zufallszahl
			 i6=(int) (Math.random()*6);//zufallszahl	
			repaint();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				}
		}
	}
```
die zufallszahlen ändern sich jede sekunde 

jede jede zahl steht für ein bild , und es gibt 6 "kästchen" worin sich 6 bilder jede 6sekunde ändern,
denk mal daher dass es immer wieder neu suche soll


----------



## Gucky (26. Jun 2014)

Du hast die Schleifen falsch aufgebaut. Die Reaktion auf keine drei gleichen Zahlen darf erst nach dem Durchlauf der Schleife, in der die Anzahlen der einzelnen Zahlen analysiert werden, stehen. Und dann willst du aufhören, nachdem du eine Zahl gefunden hast, die häufiger als drei Mal vorkommt. Soll heißen: danach musst du aus der Methode mit return rausspringen.

Zudem muss das Array doch keine 6 Elemente lang sein, sondern 7.


----------



## Harry Kane (26. Jun 2014)

So jetzt mal ein paar Basics:
1. Math.random() liefert eine Zahl >= 0 und < 1. Beim casten nach int werden die Nachkommastellen einfach abgeschnitten. (int)(Math.random()*anInteger) liefert deshalb einen Wert zwischen 0 und anInteger - 1. Wenn die Nummer der zahlen in einem Array gezählt werden soll, ist deshalb die Deklaration int[anInteger - 1] richtig.
2. @Gucky: Dein Ansatz ist zwar richtig, dein Code hat aber zwei massive Bugs. Hast du das jermals getestet?
Mit

```
int[] zahlen = new int[6];
    for (int tempInt : zufallszahlenList) {
      zahlen[tempInt]++;
    }
     
    for (int tempInt : zahlen) {
      if (temp >=3) tuWas();
      else tuWasAnderes();
    }
```
fragst du zwar Werte aus dem Array ab und erhöhst sie um eins, sie werden aber nicht in das Array zurückgeschrieben! Ausserdem müssen die Werte erst erhöht und dann zurückgegeben werden, also so:

```
int[] zahlen = new int[6];
    for (int tempInt : zufallszahlenList) {
      zahlen[tempInt] = ++zahlen[tempInt];
    }
     
    for (int tempInt : zahlen) {
      if (temp >=3) tuWas();
      else tuWasAnderes();
    }
```
Es ist auch nicht nötig, die Zufallszahlen zuerst in einer separaten Datenstruktur abzulegen, sondern der entsprechende Index in einem Array mit der Anzahl der "Treffer" kann direkt erhöht werden:
Das hier funktioniert bei mir wie erwartet:

```
public class Zufallszahlenerzeugung {

        public static void main(String[] args){
            int max = 6;
            int loops = 6;
            int[] counts = new int[max];
            for(int i = 0; i < loops; i++){
                int index = (int)(Math.random()*max);
                System.out.println("Loop " + i+ ", value " + index);
                counts[index] = ++counts[index];
            }
            System.out.println(Arrays.toString(counts));
        }
}
```


----------



## Harry Kane (27. Jun 2014)

Harry Kane hat gesagt.:


> So jetzt mal ein paar Basics:
> 1. Math.random() liefert eine Zahl >= 0 und < 1. Beim casten nach int werden die Nachkommastellen einfach abgeschnitten. (int)(Math.random()*anInteger) liefert deshalb einen Wert zwischen 0 und anInteger - 1. Wenn die Nummer der zahlen in einem Array gezählt werden soll, ist deshalb die Deklaration int[anInteger - 1] richtig.


Uff. Richtig müsste es natürlich int[anInteger] heissen. Aber zumindest in dem Codebeispiel ist es richtig.


----------

