# Würfel



## akeszeg (24. Apr 2014)

Hallo!

Ich soll folgendes Beispiel lösen:
“Würﬂe” in einer while-Schleife mit einem “virtuellen” 6-seitigen
Würfel, bis exakt 3-mal hintereinander die Augenzahl 6 geworfen wird. Wiederhole dieses
“Experiment” 100-mal mittels einer äußeren for-Schleife und gib jeweils die Anzahl der
dafür notwendigen Würfe aus.

Ich habe angefangen und eine for-Schleife erstellt, ich bringe die while-Schleife aber nicht zusammen.

```
public class Wuerfel {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Random wuerfel = new Random ();
        int Augenzahl;
     for(int i=0;i<100;i++){
         Augenzahl= 1+ wuerfel.nextInt(6);
         System.out.println(Augenzahl);
         
     }
     
        
    }
    
}
```
Ich bin so weit gekommen. Kann mir jemand bitte helfen?

Danke im Voraus!


----------



## unavailable (24. Apr 2014)

Syntax einer while-Schleife:


```
while(Bedingung)
{
//Hier der Code, der ausgeführt wird, solange die Bedingung wahr ist
}
```


----------



## akeszeg (24. Apr 2014)

Hallo,

mein Problem ist, dass ich das Beispiel leider trotz der Hilfe nicht zusammenbringe.
Könntest du mir irgendwie weiterhelfen?


----------



## njans (24. Apr 2014)

Nunja, du brauchst einen counter, der zählt, wie oft ein die selbe Zahl hintereinander vorkommt und du musst dir den letzten gewürfelten Wert speichern, damit du siehst, ob du wieder das selbe geworfen hast.


----------



## strußi (24. Apr 2014)

was du brauchst ist ungefär so was

```
int[] countThrows =new countThrows[ 100];
byte countSix =0;
for( int i =0; i<100; i++){
    while( countSix <=3){
           int throws =throw(); // würfel - Wert kann auch ein byte wert sein 
           countThorws[ i] +=1;
           if( throws ==6){
                countSix++;
           } else{
                countSix =0;
           }
     }
}
```


----------



## main() (25. Apr 2014)

Meinst du so was:


```
public class Wurfel {

    public static void main(String[] args) {
	// Generator der Zeilen;
	Random wuerfel = new Random();

	// ist dir schon mal bekannt
	int Augenzahl;

	// Erlaubter Anzahl der "Wurfversuchen"
	int versuche = 100;

	// Zähler der Wurfversuchen
	int i = 0;

	// Name sagt schon mal aus
	int wiederholungsZahl = 0;

	// Zählt nur Zahlen die sich wiederholen nach einander
	int temp = 0;

	// deine while-Schleife. Es wird verglichen ob inktement weniger als
	// Erlaubter Anzahl der "Wurfversuchen" ist
	// UND ob die Zahlen sich nicht 3mal wiederholt haben.
	while (i < versuche && temp < 4) {
	    Augenzahl = 1 + wuerfel.nextInt(6);

	    // Erster Wurf: Werte werden zugewiesen
	    if (i == 0) {
		wiederholungsZahl = Augenzahl;
		temp = 1;

		// Falls der Nächster Wurf sich wiederholt: wird temp um 1
		// Erhöht
	    } else if (Augenzahl == wiederholungsZahl) {
		temp++;

		// Sonnst wieder zurück gesetzt
	    } else {
		temp = 1;
	    }

	    // Jeder Versuch wird gezählt
	    i++;
	    System.out.println(Augenzahl);
	}
	System.out.println("Wurfversuche: " + i);
    }
}
```


----------



## strußi (25. Apr 2014)

die info dass die augenzahl auf die getest wird eine vorgabewert sein soll hat mir gefehlt aber sonst nett ;-)  
funktioniert das so mit der whileschleife und den zwei bedingung? So wie es aussieht hast du nur 100 würfe in denen du drei mal die gleiche zahl hintereinander haben musst


für die methode throws() hatte ich an so was gedacht


```
public int wuerfeln() {
 return (int)(Math.random()*6+1);
}
```

im gesammten würde das so aus sehen


```
public double[] versuchreihe(){
    int augenzahl =6; //deine vorgabe eine Zahl die getestet werden soll
    double[] countThrows =new countThrows[ 100]; //Array in dem die anzahl der Würfe pro //versuchsrunde aufgezeichnet werden,  bis drei mal augenzahl gekommen ist
    byte throwsInRow =0; //anzahl der gleichen Augenzahl in folge
    for( int i =0; i<100; i++){ //hundert versuchsreihen
        while( countSix <=3){ //so oft bis drei mal hintereinander die gleiche, festgelegte augenzahl
                                      //gekommen ist
               countThorws[ i] +=1; Wurfzähler für die aktuelle versuchsrunde  um eins erhöhen
               if( augenzahl ==((int)(Math.random()*6+1))){ würfeln und testen
                    throwsInRow++; //augenzahl entspricht gewürfeltem Wert, zähler erhöhen 
               } else{
                    throwsInRow=0; //zähler auf null spiel von vorne
               }
         }
    }
    return countThrows;
}
```

wenn du den test erweitern willst, ob irgendeine Augenzahl dreimal hintereinander kommt dann überschreib einfach nach jedem wurf die augenzahl mit dem gewürfelten wert, in dem du noch eine hilfsvariable einführst

gn8^^


----------



## Zet (25. Apr 2014)

Ich hab mir das grade mal zusammengefriemelt, bin allerdings auf ein Problem gestoßen:
ich lasse mir die Durchschnittliche Anzahl der Würfe ausgeben, bis 3-6en aufeinanderfolgend aufgetaucht sind.

Nun wollte ich spaßeshalber mal sehen wielange es dauert bis man es unter 100 würfe schafft.
bei 200 Funktioniert das ganze noch so weit, bei der prüfung unter 100 würfen erhalte ich allerdings recht schnell(1-3 Sekunden) einen SO.



```
Exception in thread "main" java.lang.StackOverflowError
	at sun.nio.cs.UTF_8.updatePositions(Unknown Source)
	at sun.nio.cs.UTF_8$Encoder.encodeArrayLoop(Unknown Source)
	at sun.nio.cs.UTF_8$Encoder.encodeLoop(Unknown Source)
	at java.nio.charset.CharsetEncoder.encode(Unknown Source)
	at sun.nio.cs.StreamEncoder.implWrite(Unknown Source)
	at sun.nio.cs.StreamEncoder.write(Unknown Source)
	at java.io.OutputStreamWriter.write(Unknown Source)
	at java.io.BufferedWriter.flushBuffer(Unknown Source)
	at java.io.PrintStream.write(Unknown Source)
	at java.io.PrintStream.print(Unknown Source)
	at java.io.PrintStream.println(Unknown Source)
	at wuerfeln.getdurchschnitt(wuerfeln.java:79)
```

in der Zeile
	
	
	
	





```
System.out.println("Durchschnittlich: "+summe/100+" Wuerfe");
```


Wie kann ich so einen SO vermeiden/verhindern?


Grüße
Zet





Spoiler



Nicht schön und auch nicht selten:

```
public class wuerfeln 
{
	int treffer = 0;
	int anzahlwuerfe = 0;
	
	
	public static void main(String[] args) 
	{
		wuerfeln otest = new wuerfeln();
		otest.wuerfel();
	}
	
	
	public void wuerfel() 
	{
		int durchgang = 0;
		// Arrayzum speichern der Anzahl der geworfenen Würfel bis 666 rauskommt
		int[] Array = new int[100];
		System.out.println("100x Anzahl der Würfelversuche für 3 aufeinanderfolgende 6en:");
		// 100 mal das ganze durchführen
		for (int i = 0; i < 100; i++) 
		{
			durchgang++;
			// Solange nicht 3 mal eine 6 gewuerfelt wurde
			while (treffer != 3) 
			{
				// Würfel
				if (wurf() == 6) 
				{
					// Treffer, 6 gefunden
					treffer++;
				} 
				else 
				{
					// Keine 6 ? dann wieder bei 0 anfangen
					treffer = 0;
				}
				// Wurf ist durchgeführt, also um 1 erhöhen
				anzahlwuerfe++;
			}
			// 3Aufeinander folgende 6en gefunden, Array befüllen, kontrollzähler und anzahl auf 0 setzen
			// Anzahl der benötigten Würfe im Array speichern
			Array[i] = anzahlwuerfe;
			//System.out.println(anzahlwuerfe);
			anzahlwuerfe = 0;
			treffer = 0;
		}
		if (getdurchschnitt(Array) > 105)
		{
			wuerfel();
		}
	}
	
	public int wurf()
	{
		int wurf =(int) (Math.random()*6+1); 
		return 	wurf;
	}
	
	public int getdurchschnitt(int[] zahlenArray)
	{
		int summe = 0;
		for (int i = 0; i < zahlenArray.length; i++)
		{
			summe = summe + zahlenArray[i];
		}
		System.out.println("Durchschnittlich: "+summe/100+" Wurfe");
		return summe/100;
	}
	
}
```


----------



## Flown (25. Apr 2014)

So ich hab mir mal den Code für dich angeschaut. Du bekommst einen StackOverflow aufgrund das du wuerfeln() immer rekursiv aufrufst und dadurch läuft der Stack irgendwann über, wenn das sehr lange dauert. Du kannst es mit einer while-Schleife schöner lösen:



Spoiler





```
import java.util.Arrays;

public class Wuerfeln {

	public static void main(String[] args) {
		Wuerfeln otest = new Wuerfeln();
		otest.wuerfel();
	}

	public void wuerfel() {
		int treffer = 0;
		int anzahlwuerfe = 0;
		int[] arr = new int[100];
		do {
			for (int i = 0; i < arr.length; i++) {
				while (treffer != 3) {
					if (wurf() == 6) {
						treffer++;
					} else {
						treffer = 0;
					}
					anzahlwuerfe++;
				}
				arr[i] = anzahlwuerfe;
				anzahlwuerfe = 0;
				treffer = 0;
			}
			System.out.println(getLambdaAverage(arr));
			System.out.println(getAverage(arr));
		}
		while(getLambdaAverage(arr) > 105);
	}

	public int wurf() {
		return (int) (Math.random() * 6 + 1);
	}

	public double getLambdaAverage(int[] zahlenArray) {
		return Arrays.stream(zahlenArray).average().getAsDouble();
	}
	
	public double getAverage(int[] zahlenArray) {
		int sum = 0;
		for(int z : zahlenArray) {
			sum += z;
		}
		return (double) sum / (double) zahlenArray.length;
	}
}
```




Hab auch schon Lambdaexpressions eingefügt, da es kürzer und schöner ist.


----------

