# Augensummen



## chillerStudent (15. Jan 2012)

Hallo,

wie vergleiche ich eine Augensumme von zwei Zufallszahlen (2 würfel) mit allen möglichen Augensummen von den Zahlen 1 bis 9 ? 


```
void vergleich(){
 int w1 = (int) ((Math.random() * 6) + 1);
 int w2 = (int) ((Math.random() * 6) + 1);

if((w1+w2) == ?? ){

}

}
```

Es gibt ja 81 mögliche Augensummen von den Zahlen 1 bis 9. Ich habe mir gedacht ich muss ein Array mit der Größe 81 erstellen und in jedem "Behälter" eine Summe abspeichere. Aber wie berechne ich die Augensummen?


----------



## Helgon (15. Jan 2012)

Könntest du kurz erklären warum du das bräuchtest?


```
for(int i = 1; i < 7; i++){
for(int n = 1; n < 7; n++){
i*n;
}
}
```


----------



## Final_Striker (15. Jan 2012)

Und was soll dabei dann rauskommen?

Das z.b 4+6 == 10 ist oder wie?


----------



## HimBromBeere (15. Jan 2012)

Haben deine Würfel denn nun 6 oder 9Augen?


----------



## chillerStudent (15. Jan 2012)

Helgon hat gesagt.:


> Könntest du kurz erklären warum du das bräuchtest?
> 
> 
> ```
> ...



wird hier nicht das produkt von zwei Augenzahlen eines Würfels berechnet? Ich muss ein Spiel prog.



> Und was soll dabei dann rauskommen?
> Das z.b 4+6 == 10 ist oder wie?



Ungefähr. Ich muss jetzt gucken wie ich die 10 mit den Zahlen von 1 bis 9 summieren kann. Aber nur mit zwei zahlen.


----------



## Helgon (15. Jan 2012)

> Ich habe mir gedacht ich muss ein Array mit der Größe 81 erstellen und in jedem "Behälter" eine Summe abspeichere


So hast du alle möglichen Summen

Dann kannste den Array durchlaufen und gucken wo die array == 10 und anhand des indexes kannste irgendwie herausfinden wie man auf die 10 kam


----------



## chillerStudent (15. Jan 2012)

Ok, hier ein Beispiel:

man würfelt eine 3 und eine 5. Man kann dann aus den Zahlen von 1 bis 9 zwei Zahlen oder eine Zahl aussuchen, die in Summe eine 8 ergeben. In dem Fall gibt es diese Möglichkeiten: 

1 und 7
2 und 6
3 und 5
oder nur 8

Ich muss diese möglichkeiten finden. Eine der Möglichkeiten kann ich mir dann aussuchen und mit der weitermachen...


----------



## Final_Striker (15. Jan 2012)

Erstell dir eine Map mit der Summe als Key und einer Liste mit Augenpaaren als Value.

Damit bekommst du immer dann einfach zu einer Summer die passende Liste möglichen an Augenpaaren.


----------



## HimBromBeere (15. Jan 2012)

Ich glaub, jetzt hab ich kapiert, was du willst: du möchtest mit 2Würfeln (je 9Augen) je zweimal werfen und die Gesamtanzahl pro "Doppelwurf" mit der Anzahl beim anderen Doppelwurf vergleichen, richtig?
D.h. du hast im 1.Wurf bis zu 9 Möglichkeiten, im 2. ebenso, macht 81 zusammen. 
wie wäre es, wenn du die Gesamtaugenzahl je Doppelwurf in ein 2-Elemente-Array schreibst, also gesamt[erster wurf], gesamt[zweiter wurf]. Anschließend machst du nur noch 

```
if (gesamt[0] == gesamt[1] {// do something}
```


----------



## Helgon (15. Jan 2012)

```
for(int i = 1; i < 10; i++){
			for(int n = 1; n < 10; n++){
				if(i+n == 10)
					System.out.println("Auge 1: "+i+", Auge 2: "+n);
				}
			}
```

?


----------



## chillerStudent (15. Jan 2012)

HimBromBeere hat gesagt.:


> Ich glaub, jetzt hab ich kapiert, was du willst: du möchtest mit 2Würfeln (je 9Augen) je zweimal werfen und die Gesamtanzahl pro "Doppelwurf" mit der Anzahl beim anderen Doppelwurf vergleichen, richtig?
> D.h. du hast im 1.Wurf bis zu 9 Möglichkeiten, im 2. ebenso, macht 81 zusammen.
> wie wäre es, wenn du die Gesamtaugenzahl je Doppelwurf in ein 2-Elemente-Array schreibst, also gesamt[erster wurf], gesamt[zweiter wurf]. Anschließend machst du nur noch
> 
> ...



Du hast es leider nicht verstanden.
ich möchte mit zwei würfeln(*je 6 Augen*) einmal werfen. Zum beispiel 3 und 5. Das ergibt 8.

Jetzt muss ich die Augensummen von den Zahlen 1 bis 9 mit dem Ergebnis 8 vergleichen. Wenn diese Augensumme existiert dann möchte ich z.b. die zahlen 1 und 7 löschen. Dann sind es nur noch folgende Zahlen vorhanden mit denen ich vergleichen kann: 2,3,4,5,6,8,9

dann wird nochmal gewürfelt...


----------



## Helgon (15. Jan 2012)

Hast du meine Antwort einfach ignoriert?..

```
Ausgabe für 8

Auge 1: 1, Auge 2: 7
Auge 1: 2, Auge 2: 6
Auge 1: 3, Auge 2: 5
Auge 1: 4, Auge 2: 4
Auge 1: 5, Auge 2: 3
Auge 1: 6, Auge 2: 2
Auge 1: 7, Auge 2: 1
```


----------



## chillerStudent (15. Jan 2012)

Helgon hat gesagt.:


> Hast du meine Antwort einfach ignoriert?..
> 
> ```
> Ausgabe für 8
> ...



Sry, dass ich so spät antworte. Ich habe deine schleifen durchgerechnet. Es ist richtig was du geschrieben hat. Nur wenn man für 8 einmal die Möglichkeit 1 und 7 gefunden hat, dann zählt die Möglichkeit 7 und 1 nicht, weil diese zahlen 1 und 7 gelöscht werden. 

Und sry nochmal.


----------



## Helgon (15. Jan 2012)

kann man doch easy peasy irgendwie reinfrimmeln 

zweites array wo alle zahlen drin stehen die nicht mehr erlaubt sind (bspw).

dann eben ne methode


```
boolean check(int i, int n){
for(int j = 0; i < verbrannt.length; j++)
 if(i+n == 10 && verbrant[j] == i || verbrant[j] == n) return false;

return true;
}
```

oder irgendwie sowas, grad einfach nur hingeschmiert


----------



## bERt0r (16. Jan 2012)

Was hat das ganze mit Augensummen zu tun? So wie ich das aufgefast habe: Du würfelst mit zwei 6-seitigen Würfeln. Jetzt möchtest du Wissen, wie dieses Ergebnis mittels zwei 9-seitigen Würfeln zustande kommen hätte können.
Du möchtest dir alle Möglichkeiten irgendwo abspeichern und dann eine zufällige davon löschen/als bereits gewürfelt markieren.
Dazu erstmal dein Wertebereich: 2-12.
Mittels zwei for-schleifen die jeweils von 1-9 gehen sollte man alle Kombinationen durchgehen können, und diejenigen, bei denen ein Ergebnis kleiner gleich 12 rauskommt in eine Collection speichern lassen. Am besten so: Map<Integer,List<Wertepaar>> (ich hoffe Wertepaar ist selbsterklärend). Die key der Map ist natürlich das ergebnis des Wurfs.
Wenn du jetzt mit deinen zwei 6-seitigen Würfeln z.B 8 würfelst, schaust du in deiner map mit map.get(8) nach. Du erhältst eine Liste Wertepaare, von denen kannst du dann eines löschen oder bei einem z.B setWurdeGewürfelt(true) ausführen.


----------



## Zeeu (16. Jan 2012)

Erklär uns doch noch einmal genau, welche Rolle die Würfel in deinem Spiel spielen sollen.


----------



## Marco13 (16. Jan 2012)

Vielleicht könnte auch http://www.java-forum.org/codeschnipsel-u-projekte/81973-combinatorics.html helfen - aber mir ist auch nicht ganz klar, was du vorhast...


----------



## ARadauer (16. Jan 2012)

Generell ist die Frage falsch:


chillerStudent hat gesagt.:


> Hallo,
> wie vergleiche ich eine Augensumme von zwei Zufallszahlen (2 würfel) mit allen möglichen Augensummen von den Zahlen 1 bis 9 ?


Die möglichen Augensummen von zwei Würfeln gehen von 2 bis 12


----------



## Spacerat (16. Jan 2012)

1. Man kann mit einem 6-Seitigem Würfel keine 7+ würfeln.
2. Mal sehen, ob ich das richtig verstanden habe.

```
import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;


public final class Dices
{
	private static final Map<Integer, Map<Integer, Integer>> possibilities;

	static {
		Map<Integer, Map<Integer, Integer>> tmp1 = new TreeMap<Integer, Map<Integer,Integer>>();
		Map<Integer, Integer> tmp2 = new TreeMap<Integer, Integer>();
		for(int hit = 2; hit <= 9; hit++) {
			for(int dice1 = 1; dice1 <= 6; dice1++) {
				for(int dice2 = 1; dice2 <= 6; dice2++) {
					if(dice1 + dice2 == hit) {
						tmp2.put(dice1, dice2);
					}
				}
			}
			tmp1.put(hit, Collections.unmodifiableMap(new TreeMap<Integer, Integer>(tmp2)));
			tmp2.clear();
		}
		possibilities = Collections.unmodifiableMap(tmp1);
	}

	public static void main(String[] args)
	{
		int hit = (int) ((Math.random() * 8.0) + 2.0);
		Map<Integer, Integer> rolls = new TreeMap<Integer, Integer>(possibilities.get(hit));
		System.out.println("HIT -> " + hit);
		while(!rolls.isEmpty()) {
			int dice1 = (int) ((Math.random() * 6.0) + 1.0);
			int dice2 = (int) ((Math.random() * 6.0) + 1.0);
			if(hit == dice1 + dice2 && rolls.containsKey(dice1)) {
				rolls.remove(dice1);
				System.out.println("HIT : " + dice1 + "|" + dice2);
			} else {
				System.out.println("MISS: " + dice1 + "|" + dice2);
			}
		}
	}
}
```


----------



## chillerStudent (16. Jan 2012)

bERt0r hat gesagt.:


> Was hat das ganze mit Augensummen zu tun? So wie ich das aufgefast habe: Du würfelst mit zwei 6-seitigen Würfeln. Jetzt möchtest du Wissen, wie dieses Ergebnis mittels zwei 9-seitigen Würfeln zustande kommen hätte können.
> Du möchtest dir alle Möglichkeiten irgendwo abspeichern und dann eine zufällige davon löschen/als bereits gewürfelt markieren.
> Dazu erstmal dein Wertebereich: 2-12.
> Mittels zwei for-schleifen die jeweils von 1-9 gehen sollte man alle Kombinationen durchgehen können, und diejenigen, bei denen ein Ergebnis kleiner gleich 12 rauskommt in eine Collection speichern lassen. Am besten so: Map<Integer,List<Wertepaar>> (ich hoffe Wertepaar ist selbsterklärend). Die key der Map ist natürlich das ergebnis des Wurfs.
> Wenn du jetzt mit deinen zwei 6-seitigen Würfeln z.B 8 würfelst, schaust du in deiner map mit map.get(8) nach. Du erhältst eine Liste Wertepaare, von denen kannst du dann eines löschen oder bei einem z.B setWurdeGewürfelt(true) ausführen.



Dankeschön für diese ausführliche Erklärung. Puh war das schwer zu formulieren. 
Aber ich darf nicht mit map oder listen arbeiten. Würde das Abspeichern mit StringBuffer oder mit einem Array funktionieren?


----------



## HimBromBeere (16. Jan 2012)

> aber mir ist auch nicht ganz klar, was du vorhast...



Und ich hatte schon Angst, ich bin einfach nur dämlich, weil ich´s noch immer nicht geblickt hab...



> Du hast es leider nicht verstanden.
> ich möchte mit zwei würfeln(je 6 Augen) einmal werfen. Zum beispiel 3 und 5. Das ergibt 8.
> 
> Jetzt muss ich die Augensummen von den Zahlen 1 bis 9 mit dem Ergebnis 8 vergleichen.



Warum 1 - 9... geht doch nur von 1 bis 6, max. Augensumme ist dann doch 7... ich weiß, du widerholst dich, wenn du das versuchst zu erklären, aber mir scheint, ich bin nicht der einizge, der dein Problem immer noch nicht verstanden hat...


----------



## chillerStudent (16. Jan 2012)

HimBromBeere hat gesagt.:


> Warum 1 - 9... geht doch nur von 1 bis 6, max. Augensumme ist dann doch 7... ich weiß, du widerholst dich, wenn du das versuchst zu erklären, aber mir scheint, ich bin nicht der einizge, der dein Problem immer noch nicht verstanden hat...



ich würfele eine 3 und eine 5, das ergibt 8. Dann hab ich noch einen dritten Würfel, der neun Seiten hat, beschriftet von 1 bis 9. Ich muss gucken ob es im dritten würfel irgendwelche 2 zahlen oder eine zahl gibt, die in summe 8 ergeben.
Die Antwort ist, ja es gibt welche zahlen oder Terme die als summe 8 ergeben. Das sind diese:

1 + 7 oder
2 + 6 oder
3 + 5 oder
nur 8

Von den o.g. Termen kann ich dann einen aussuchen und die zahlen die im Term vorkommen, die muss ich vom würfel löschen.
Zum Beispiel wähle ich die zahl 8. Acht lösche ich dann aus dem würfel. Beim nächsten Würfeln ist die 8 nicht mehr vorhanden.

Oder ich nehme den Term 2+6. Dann muss ich die Zahlen 2 und 6 aus dem 9-er Würfel löschen.


----------



## HimBromBeere (16. Jan 2012)

Schön, dass du uns 20Beiträge lang verschwiegen hast, dass es einen dritten 9-seitigen Würfel gibt... das verändert ein bisschen...


----------



## chillerStudent (16. Jan 2012)

HimBromBeere hat gesagt.:


> Schön, dass du uns 20Beiträge lang verschwiegen hast, dass es einen dritten 9-seitigen Würfel gibt... das verändert ein bisschen...



Verschwiegen habe ich es nicht, ich konnte es nicht so gut erklären. 
Außerdem hat es bERt0r verstanden.


----------



## HimBromBeere (16. Jan 2012)

Und nachdem du die Kombination gelsöcht hast, würfelst du mit dem 9er Würfel, um zu sehen, ob du eine (noch vorhandene) Kombi gewürfelt hast?


----------



## chillerStudent (16. Jan 2012)

HimBromBeere hat gesagt.:


> Und nachdem du die Kombination gelsöcht hast, würfelst du mit dem 9er Würfel, um zu sehen, ob du eine (noch vorhandene) Kombi gewürfelt hast?



Nein. 
Nachdem ich die Kombinationen gelöscht habe, würfele ich nochmal mit den zwei 6-er Würfeln. 
Gucke dann wieder in den 9-er Würfel, ob welche Kombinationen gibt.

Ich fahre das beispiel von oben mal fort: also die 8 ist nun gelöscht
Nun würfele ich eine 1 und 3, das ergibt 4.
Dann gucke ich, wieviele kombinationen es mit den zahlen im dritten würfel gibt. Es sind jetzt aber nur noch diese zahlen vorhanden: 1,2,3,4,5,6,7,9  und diese kombis gibt es: (1+3) und (4)

ich wähle jetzt die kombination (1+3) und lösche aus dem dritten würfel 1 und 3. Es soll zufällig gewählt werden welche kombination man herauspickt.


----------



## HimBromBeere (16. Jan 2012)

Und das ganze ist vorbei, wenn es keine Kombination für den dritten Würfel mehr gibt, mit der man das Ergebnis der ersten beiden Würfel reproduzieren kann, oder wie?


----------



## chillerStudent (16. Jan 2012)

HimBromBeere hat gesagt.:


> Und das ganze ist vorbei, wenn es keine Kombination für den dritten Würfel mehr gibt, mit der man das Ergebnis der ersten beiden Würfel reproduzieren kann, oder wie?



richtig:toll:


----------



## HimBromBeere (16. Jan 2012)

Ich habs kapiert, juchu, ich habs kapiert.... :applaus::applaus: moment, ich muss diesen Moment erstmal auskosten:applaus:

So, jetzt bin ich wieder da... also lass mal überlegen

Um alle zulässigen Kombinationen zu erhalten, musst du doch eigtl. nur die Augensumme (z.B. 8) durch zwei teilen. Anschließend machst du die Addition in einer Schleife etwa so:


```
int[] kombinationen = new int[augensumme / 2];
for (int i = 0; i < augensumme / 2; i++) {
    // ensure that none of the numbers is greater the 9
    if ((augensumme - i) <= 9) kombinationen[i] = augensumme - i;
    // else: set a default-value different to 0
    else kombination[i] = -1;
}
```

Nun hast du ein relativ kleines Array, bei dem der Index die erste und der Feldwert der zweite Wurf ist.


----------



## chillerStudent (16. Jan 2012)

Wozu soll die schleife gut sein?
wenn man mit 8 als augensumme rechnet ist in jedem k[0 bis 3] 8,7,6,5 gespeichert.

Was mach ich mit dem k?


----------



## HimBromBeere (16. Jan 2012)

Na ich dachte, du brauchst erstmal alle Kombinationen für die aktuelle Augensumme?
das sieht dann so aus:
kombination[0] = 8;
k[1] = 7
k[2] = 6
k[3] = 5
k[4] = 4 // sofern das in deiner Logik möglich ist...

und von diesen vier Möglichkeiten haust du eine raus...


----------



## chillerStudent (16. Jan 2012)

HimBromBeere hat gesagt.:


> Nun hast du ein relativ kleines Array, bei dem der Index die erste und der Feldwert der zweite Wurf ist.


dieser satz kam bissl zu spät.

klick klick klick hats gemacht in meinem schädel. 

Jetzt muss ich diese Möglichkeiten doch irgendwo speichern damit zufällig gelöscht werden kann.
Wenn der nutzer das eingibt, dann hat der nutzer viel zu tun. 
Jetzt häng ich wieder...


----------



## HimBromBeere (16. Jan 2012)

naja, du kannst doch eine Zufallszahl erzeugen zwischen 0 und kombinationen.length - 1. Diese Kombination wird dann gelöscht.


----------



## chillerStudent (16. Jan 2012)

Wie lösche ich einen wert aus einem Array?

so?


```
int[] kombinationen = new int[augensumme / 2];
for (int i = 0; i < augensumme / 2; i++) {
    // ensure that none of the numbers is greater the 9
    if ((augensumme - i) <= 9) kombinationen[i] = augensumme - i;
int zufall = (int) (Math.random()*kombi.length-1) ;
				kombi[zufall]=-1;
    // else: set a default-value different to 0
    else kombination[i] = -1;
}
```

Edit: ich korrigiere mich 

ich brauche ja zuerst einen würfel der 9 seiten hat. 


```
int[] summe = new int[9];
		for(int r=1; r<=summe.length; r++){
			summe[r-1]=r; // zahlen von 1 bis 9
		}
```

Und wie lösche ich aus summe einen wert?


----------



## chillerStudent (16. Jan 2012)

Ich hoffe ich bin auf den richtigen weg:


```
int[] summe = new int[9];
        for(int r=1; r<=summe.length; r++){
            summe[r-1]=r; // zahlen von 1 bis 9
        }
int[] kombinationen = new int[augensumme / 2];
for (int i = 0; i < augensumme / 2; i++) {
    // ensure that none of the numbers is greater the 9
    if ((augensumme - i) <= 9) kombinationen[i] = augensumme - i;
int zufall = (int) (Math.random()*kombi.length-1) ;
                if(summe[i]==zufall){
					System.out.println(summe[i]+" wurde gelöscht.");
					summe[i]=0;
				}
    // else: set a default-value different to 0
    else kombination[i] = -1;
}
```


----------



## HimBromBeere (16. Jan 2012)

> ```
> Math.random()*kombi.length-1
> ```



Das sollter schonmal nicht gehen, damit erzeugst du eine Zahl zwischen -1 und length - 1, denn:
math.random = 0..1
int(0 * kombi.length - 1) = -1
int(1 * kombi.length - 1) = kombi.length - 1


----------



## chillerStudent (16. Jan 2012)

Meinst du dass die klammern fehlen?


```
int zufall = (int) ((Math.random()*kombi.length-1) + 1);
```


----------



## HimBromBeere (16. Jan 2012)

mach doch einfach ein Debug... dann wirste schon sehen, wie groß Zufall wird...


zum nächsten Problem:
du sollst natürlich nicht aus dem Kombiarray löschen. Am besten, du erstellst ein zweites Array (das dann, wie du ganz am Anfang mal festgestellt hast, tatsächlich etwas größer ist...), in welches du alle bereits verwendeten Kombinationen hineinschreibst (diesmal aber wirklich zwei-dimensional). Also, wenn du 8 gewürfelt hast (3 + 5 soll als "verwendet" gekennzeichnet werden), schreibst 
	
	
	
	





```
arr[3][5] = 1
```
.
Nun musst du innerhalb der bereits erwähnten Schleife nur noch testen, ob die Kombi, die du gerade versuchst zu löschen (mit Zufall), genau diese Bedingung erfüllt (arr[x][y] = 1). Ist dem so, musst du dir ´ne andere Kombi per Zufall raussuchen, bis du endlich eine gültige hast. Scheint mir persönlich zwar enorm umständlich zu sein, aber da du ja eine zufällige Kombi eliminieren möchtest, fällt mir nix besseres dafür ein...


----------



## chillerStudent (16. Jan 2012)

Wieso wird abgefragt, ob augensumme - i < 9 ist?


----------



## HimBromBeere (16. Jan 2012)

weil die größt mögliche Augenzahl des dritten Würfels 9 ist?
Das verhindert, dass auf [0, 11] bzw [1, 10] geprüft wird, wenn die Augensumme 11 ist...


----------



## Zeeu (16. Jan 2012)

Hab grad mal nen bisschen rum gedoktort, hoffe das entspircht dem:


```
import java.util.Scanner;

public class RollYourDice{
	public static void main(String[] args) {

		int wurf1, wurf2, wurferg, kombipos = 0, kombiwahl = 0;
		boolean ende = false;
		Scanner scanner = new Scanner(System.in);
		BigDice bd = new BigDice();
		
		do{
			wurf1 = (int) ((Math.random() * 6) + 1);
			wurf2 = (int) ((Math.random() * 6) + 1);
			wurferg = wurf1 + wurf2;

			System.out.println(
					"Wurf: " + wurferg + "\t(" + wurf1 + " & " + wurf2 + ")");

			ende = bd.getKombis(wurferg) ;

			System.out.println("Welche kombi möchten Sie löschen: ");
			kombiwahl = scanner.nextInt();
			
			bd.delKombiOnDice(kombiwahl);
		}while(!ende);

	}
}
```


```
public class BigDice {
	private int[] augen = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[][] kombi = new int[augen.length][2];
	
	public BigDice(){
		clearKombi();
	}
	
	public boolean getKombis(int erg){
		int kombipos = 0;
		
		for(int i = 1; i <= (erg/2) && i <= 6;i++ ) 
			for(int j = 1; j <= erg && j <= 6; j++)
				if((i+j) == erg && isOnDice(i) && isOnDice(j)){
					if(i == 0) {
						kombi[kombipos][0] = j;
						kombi[kombipos][1] = 0;
					}
					if(j == 0){
						kombi[kombipos][0] = i;
						kombi[kombipos][1] = 0;
					}
					if(i != 0 && j != 0) {
						kombi[kombipos][0] = i;
						kombi[kombipos][1] = j;
					}
					kombipos++;
				}				
		if(kombipos > 0){
			printKombis();
			return false;
		}
		else {
			System.out.println("Keine Mögliche Kombi mehr vorhanden !");
			return true;
		}
	
	}
	
	public void printKombis(){
		for(int i = 0; kombi[i][0]!= 0;i++)			
			System.out.println("Kombi " + (i+1) + ": " + kombi[i][0] + " und " + kombi[i][1]);
	}
	
	public void delKombiOnDice(int kombiwahl){
		int zahl1,zahl2;
		zahl1 = kombi[kombiwahl-1][0];
		zahl2 = kombi[kombiwahl-1][1];
		
		for(int i = 0; i < augen.length;i++){
			if(augen[i] == zahl1 || augen[i] == zahl2) augen[i] = -1;
		}
		clearKombi();		
	}
	
	public boolean isOnDice(int value){
		for(int i = 0; i < augen.length; i++)
			if(value == augen[i])		
				return true;
		return false;
	}
	public void clearKombi(){
		for(int i = 0; i < kombi.length; i++){
			kombi[i][0] = 0;
			kombi[i][1] = 0;
		}
	}	
}
```

Edit: Kombi wird ja vom 9er dice gewählt, nicht vom 6er, also 

```
for(int i = 1; i <= Math.ceil((double)(erg/2))-1 && i <= augen.length;i++ ) 
			for(int j = 1; j <= erg && j <= augen.length; j++)
```


----------



## chillerStudent (16. Jan 2012)

Ich hätte da einen anderen Vorschlag:

man kann doch in einem StringBuffer die zahlen 1 bis 9 reinschreiben und überprüfen ob i und kombi_ im StringBuffer enthalten sind. Wenn ja, dann löschen, ansonsten aufhören.

Ist das möglich?_


----------



## HimBromBeere (16. Jan 2012)

Wäre eine einfache Idee... hab ich noch gar nicht dran gedacht. Aber du willst doch nicht gleich aufhören, wenn die Kombi schon im Buffer ist, sondern dann einfach die nächste gültige Kombi suchen, oder?


----------



## Zeeu (16. Jan 2012)

chillerStudent hat gesagt.:


> Ich hätte da einen anderen Vorschlag:
> 
> man kann doch in einem StringBuffer die zahlen 1 bis 9 reinschreiben und überprüfen ob i und kombi_ im StringBuffer enthalten sind. Wenn ja, dann löschen, ansonsten aufhören.
> 
> Ist das möglich?_


_



		Java:In die Zwischenablage kopieren


String dice = "1 2 3 4 5 6 7 8 9";
		if(dice.contains(Integer.toString(1))){
			System.out.println("JAAAA");
		}


das klappt wie es aussieht ^^

Edit: 
bevor ich das über nen String mache, würd ich doch lieber ne Liste verwenden oder eine contains() für ein Array schreiben, so wie ich es oben schon in meinem Programm getan habe .



		Java:In die Zwischenablage kopieren


public boolean isOnDice(int value){
		for(int i = 0; i < augen.length; i++)
			if(value == augen[i])		
				return true;
		return false;
	}

_


----------



## chillerStudent (16. Jan 2012)

Zeeu hat gesagt.:


> ```
> String dice = "1 2 3 4 5 6 7 8 9";
> if(dice.contains(Integer.toString(1))){
> System.out.println("JAAAA");
> ...



Und wie kann man diese 1 im dice löschen?


----------



## Zeeu (16. Jan 2012)

jetzt darfst du den String char für char durchgehen, und überprüfen denke ich


----------



## HimBromBeere (16. Jan 2012)

jo, String in char[] umwandeln, jeden char einzeln durchgehen, den betreffenfenden index löschen, array bis zu der Stelle verschieben, wieder in ein String umrechnen... Sau umständlich

Besser, du nutzt die Funktionen, die dir String bzw. StringBuffer bereitstellen, kenne mich grade mit den jeweiligen Klassen nicht aus, aber sowas wie left() oder indexOf() gibt´s in nahezu jeder Programmiersprache...

EDIT: OK, left() hab ich noch nicht gefunden, dafür aber getChars(). Damit kannst du alle chars VON - BIS extrahieren, genau, was du brauchst. Dieses Array musst du dann allerdings wieder in einen String umwandeln...


----------



## Zeeu (16. Jan 2012)

Die Methode replace der Klasse String dürfte dir die 1 auch rausknallen oder ?


```
String dice = "1 2 3 4 5 6 7 8 9";
		System.out.println(dice);
		dice = dice.replaceAll("1", " ");
		System.out.println(dice);
```

Bin jetzt kein experte, die String lösung mag klappen, halte ich aber für unsauber.


----------



## HimBromBeere (16. Jan 2012)

wenn man dami sowas machen kann wie 
	
	
	
	





```
replace("1","");
```
 dann ja. Ist sogar noch viel einfacher^^


----------



## Zeeu (16. Jan 2012)

ach mist, in meinem poste sollte es natürlich durch -> "" ersetzt werden, nicht durch " "


----------



## chillerStudent (16. Jan 2012)

@Zeeu

wow, dein programm hab ja gar nicht gesehen. respekt. guck ich mir später an, wenn ich den überblick verliere. thx

wie lösche ich aus chararray ein i??
das ganze ist in einer forschleife


```
if(dice.contains(Integer.toString(kombi[i]))) {
	char[] c = dice.toCharArray();
	//mit welcher funktion löschen?
						
}
```


----------



## Zeeu (16. Jan 2012)

lies weiter oben und nutze die "replaceAll()" Methode ^^


----------



## HimBromBeere (16. Jan 2012)

ich galub, du kommst am einfachsten mit einer Liste vom Typ Integer. In der kannst du nach Huddünken hinzufügen oder löschen...

Also das hier:

```
List<Integer> usableNumbers = new ArrayList<Integer>();
// add all numbers from 0 to 9
for (int i = 0; i < 10; i++) usableNumbers.add(i);

...

// delete number
if (usableNumbers.contains(i)) usableNumbers.remove(i)
else System.out.println("diese Zahl ist nicht verfügbar");
```

Hab ich jetzt noch nicht probiert, v.a. könnte das mit den Indizes noch falsch sein, aber der Ansatz ist glaub schinmal besser als über die Strings.


----------



## chillerStudent (16. Jan 2012)

Ich habe ein problem mit der forschleife
mein sieht so aus


```
for(int i=0; i < augensumme/2; i++) {
```

augensumme/2 gefällt mir nicht. Der kern meiner forschleife sieht so aus


```
if(dice.contains(Integer.toString(kombi[i]))) {
						dice.replaceAll(String.valueOf(kombi[i]), "");
						System.out.println(kombi[i]+" gelöscht");
					}
				} else {
					//System.out.println(i+" + "+kombi[i]);
					if(dice.contains(Integer.toString(kombi[i])) && dice.contains(Integer.toString(i))) {
						dice.replaceAll(String.valueOf(kombi[i]), "");
						dice.replaceAll(String.valueOf(i), "");
						System.out.println(kombi[i]+" und "+i+" gelöscht");
					}
				}
```


----------



## HimBromBeere (16. Jan 2012)

das mit dem augensumme/2 hat den Grund, dass du dadurch nicht nach Umkehrungen eines bereits erhaltenen Paares suchst (sprich bei Augensumme 8 suchst du nur nach [3, 5] und nicht zusätzlich noch nach [5, 3], da die größte (erste) Zahl genau 4 (8 durch 2) ist)


----------



## chillerStudent (16. Jan 2012)

wieso wird damit nicht ersetzt??


```
dice.replaceAll(String.valueOf(kombi[i]), "");
	dice.replaceAll(String.valueOf(i), "");
```

dice bleibt genau so.


----------



## Zeeu (16. Jan 2012)

weil replace den veränderten String als return statement liefert


----------



## HimBromBeere (16. Jan 2012)

Strings sind imutables (so heißen die glaub ich), also unveränderbare Objekte. Du kannst also einen einmal erzeugten String nicht verändern. Das machen die String-Funktionen übrigens auch nicht, sondern, wie Zeeu bereits sagte, sie geben einen neuen String zurück.


EDIT: Hast du meinen Beitrag mitbekommen!?


----------



## chillerStudent (16. Jan 2012)

Zeeu hat gesagt.:


> weil replace den veränderten String als return statement liefert



mhh.. verstehe ich nicht ganz. Was bedeutet das für mein programm? Wie kann ich ich i löschen bzw ersetzen?


----------



## Zeeu (16. Jan 2012)

ok das ist jetzt schon 1, vorlesung  ^^
des weiteren hab ich die lösung oben schon gepostet.

dice = dice.replaceAll...etc


----------



## chillerStudent (16. Jan 2012)

HimBromBeere hat gesagt.:


> EDIT: Hast du meinen Beitrag mitbekommen!?



den hier?



> das mit dem augensumme/2 hat den Grund, dass du dadurch nicht nach Umkehrungen eines bereits erhaltenen Paares suchst (sprich bei Augensumme 8 suchst du nur nach [3, 5] und nicht zusätzlich noch nach [5, 3], da die größte (erste) Zahl genau 4 (8 durch 2) ist)



ja, danke!


----------



## chillerStudent (16. Jan 2012)

Zeeu hat gesagt.:


> ok das ist jetzt schon 1, vorlesung  ^^
> des weiteren hab ich die lösung oben schon gepostet.
> 
> dice = dice.replaceAll...etc



cool. danke.

das nächste problem ist, dass bei jedem aufruf der methode in dice immer die zahlen von 1 bis 9 drin stehen. Es gelöschte soll ja beim nächsten aufruf auch gelöscht bleiben. dice ist auch außerhalb der methode deklariert. Was mache ich falsch?


----------



## Zeeu (16. Jan 2012)

wenn beide lokal deklariert sind, sind diese unabhängig von einander.


----------



## chillerStudent (16. Jan 2012)

Zeeu hat gesagt.:


> wenn beide lokal deklariert sind, sind diese unabhängig von einander.



welche variablen meinst du mit beide? ich habe dice nur außerhalb deklariert.


----------



## Zeeu (16. Jan 2012)

vielleicht postest du mal deine zeilen.


----------



## chillerStudent (16. Jan 2012)

die antwort ist, die methode muss man static setzen

edit: ich geh pennen. morgen mach ich weiter. thx an zeeu und himbrombeere:toll::applaus:
hoffe und wünsche dass du morgen wieder zu meinen helfern gehörst.


----------



## Schrubber (16. Jan 2012)

//Edit: Falsch gelesen :>


----------



## bERt0r (17. Jan 2012)

Um gottes willen, was macht ihr hier? Zahlen in Stringbuffern speichern?? Hast du meinen Vorschlag einer Klasse Wertepaar schon verworfen?
Mach eine Klasse Wertepaar: int wertVonWürfel1, int wertVonWürfel2, boolean wurdeGewürfelt
Mach dir ein Array vom Typ Wertepaar und wenn du ein Paar gewürfelt hast, setzt du wurdeGewürfelt auf true.


----------



## Zeeu (17. Jan 2012)

wir haben ihm nur bei seinem Lösungsweg geholfen 
Dass es eine unsaubere Lösung ist haben wir ihm auch gesagt :bahnhof:


----------



## JohannisderKaeufer (17. Jan 2012)

Junge, mak es dok venünfdig

Statt dem StringBuffer einfach ein array von Booleans


```
boolean[] theDice = new boolean[9];//Soll ja anfangs neun Werte haben.
for(int i = 0;i<theDice.length;i++){
  theDice[i] = true;//Anfangs soll ja alles vorhanden sein, daher mit true initialisieren
}
```
Nun kannst du überprüfen ob eine Zahl x = 5 vorhanden ist mit

```
int x = 5; //Als beispiel 5
if(theDice[x-1]){
  System.out.println(x+" ist vorhanden");
}else{
  System.out.println(x+" ist nicht mehr vorhanden");
}
```
Und das "löschen" läuft dann so ab, wenn man nun y = 4 entfernen möchte

```
int y = 4;
theDice[y-1] = false;
```


----------



## bERt0r (17. Jan 2012)

erm, was passiert wenn 12 gewürfelt wird?


----------



## Zeeu (17. Jan 2012)

Ich denke, da die Kombination aus dem 9er würfel gebildet wird, stehen bei 12 die Kombinationen:
9,3
8,4
7,5
zur verfügung


----------



## bERt0r (17. Jan 2012)

Ich bezog mich auf:


> ```
> int x = 12; //Als beispiel 12
> if(theDice[x-1]){
> System.out.println(x+" ist vorhanden");
> ...


IndexOutOfBoundsException


----------



## schanne (17. Jan 2012)

Ich habe diesen Thread hier jetzt ein wenig überflogen, aber ich bin echt dankbar, dass hier so viele mitmachen und Codes her zeigen. Ich finde das wirklich total hilfreich und nachvollziehbar. Super! Auch wenn ihr meint dass der Lösungsweg etwas unsauber ist, finde ich es doch besser als zu gar keinem Ergebnis zu kommen haha*


----------



## HimBromBeere (17. Jan 2012)

> erm, was passiert wenn 12 gewürfelt wird?


Schonmal mit einem neun-Seiter eine zwölf gewürfelt?
Es geht in dem neunfeld-grßen Array nicht darum, welche SUMME gewürfelt wurde, sondern lediglich, welche Ziffern gewürfelt wurden (also die Ergebnisse eines einzelnen Wurfes). Folglich stehen da auch nur die Ziffern von 1-9 drin.

Es solle eigtl. zu keiner IndexOutOfBoundException kommen können, da das Array ja auf die halbe Größe der Augensumme allokiert wurde.



> Ich denke, da die Kombination aus dem 9er würfel gebildet wird, stehen bei 12 die Kombinationen:
> 9,3
> 8,4
> 7,5
> zur verfügung


Nicht ganz, es müsste heißen {3, 9}, {4, 8}, {5, 7}
Dann ist das Array nämlich genau [Augensumme/2] = 6 Felder groß -->die ersten drei bleiben {0,0} (an den Extremfall haben wir ja noch gar nicht gedacht...), die hinteren drei werden belegt.


----------



## chillerStudent (17. Jan 2012)

nee... ich denke ich lasse den code von johannisderkäufer mal weg. Bevor ich noch den überblick verliere, bleibe ich bei meinem code.

mein nächstes problem:

ich habe jetzt in der main 3 objekte erstellt. jedes objekt soll seinen nachfolger kennen. das heißt das erste objekt hat den nachfolger 2, das hat den nachfolger 3. Wenn ich die jetzt methode für jedes dieser drei objekte aufrufe, dann hört er nach dem 3. objekt auf. Er soll nach dem 3. objekt wieder das 1. objekt würfeln lasse, sodass irgendeine zahl im term nicht mehr vorkommt. Das hat das ojbekt verloren.

ich habe einen konstruktor der zwei parameter hat, einmal den eigenen namen und einmal den nachfolger, damit jedes objekt weis wer sein nachfolger ist.

ich muss jetzt den code so schreiben, dass er nach dem 3.objekt nicht aufhört. wie geht das?


----------



## HimBromBeere (17. Jan 2012)

sowas nennt man verkettete Listen. Dafür musst du nur das next() vom letzten Element auf das erste Element zeigen lassen...


----------



## chillerStudent (17. Jan 2012)

HimBromBeere hat gesagt.:


> sowas nennt man verkettete Listen. Dafür musst du nur das next() vom letzten Element auf das erste Element zeigen lassen...



mhh.. versteh nicht so richtig. Ist das mit dem konstruktor richtig?


----------



## HimBromBeere (17. Jan 2012)

Welchen Konstruktor meinst du?


----------



## chillerStudent (17. Jan 2012)

also ich habe einen kontruktor der dem objekt einen namen gibt und festlegt wer der nachfolger ist


```
myClassName(String name, String nachfolger){
 this.name=name;
 this.nachfolger=nachfolger;
}
```


----------



## HimBromBeere (17. Jan 2012)

Du solltest eigtl. eine Referenz auf das Objekt selbst übergeben, keinen String. Sprich, das müsste etwa so aussehen:

```
class MyClass{
    private MyClass next = null;
    private String name;
    public MyClass(String name, MyClass next) {
        this.name = name; 
        this.next = next;
    }
    
    public MyClass next() {return this.next;}
}
```


----------



## chillerStudent (17. Jan 2012)

was kann ich dann für next im parameter eingeben? String geht ja nicht.


----------



## HimBromBeere (17. Jan 2012)

Na dein Vorgänger-Element.

Wie erstellst du denn die drei Objekte in deiner Main-Methode?


----------



## chillerStudent (17. Jan 2012)

so:


```
myClass obj1 = new myClass("obj1","???");
```

Edit:
Was ist denn der vorgänger-element? ich versteh nichts mehr. die klasse als datentyp irritiert mich.


----------



## HimBromBeere (17. Jan 2012)

Hast Recht, da ist ein logischer Fehler dran...

Schreib nach dem Mittagessen weiter


----------



## HimBromBeere (17. Jan 2012)

So, wieder da...


Wie wär´s, wenn du für die Instanzvariable next einfach einen Getter und einen Setter schreibst. Dann instanziierst du einfach ein Objekt der Klasse 

```
MyClass m1 = MyClass(name, null)
```
Wenn du das zweite Objekt erstellt hast, kannst du dann das next-Attribut des ersten Objektes setzen: 

```
m1.setNext(m2);
```

Bisschen unüblich, aber was besseres fällt mir grade nicht ein...

EDIT: da fällt mir ein, dass der Konstruktor mit Angabe des Nachfolgers ja völliger Blödsinn ist, wenn man da eh andauernd nur null reinscheibt. Also weg mit dem Parameter...


----------



## chillerStudent (17. Jan 2012)

oh oh. setter und getter ist der falsche weg. Darf ich nicht benutzen


----------



## HimBromBeere (17. Jan 2012)

bitte was!? Du darfst keine getter und setter verwenden? Was habt ihr für ienen Lehrer, das ist elementare und essentielle Funktionsweise von OOP... Alles andere ist unpraktisch, unsauber und schwer zu pflegenn... wie dem auch sei, dann musst du halt next als Instanzvariable public machen (igitt, igitt)


----------



## chillerStudent (17. Jan 2012)

Wie schaffe ich es, dass eine methode nur soviel mal in der main ausgeführt wird, bis ein String mit "" ersetzt worden ist?
Bestimmte Elemente des Strings werden bei jedem aufruf der Methode in der main immer durch "" ersetzt.


----------



## Zeeu (17. Jan 2012)

String.length == 0 ;


----------



## chillerStudent (17. Jan 2012)

Zeeu hat gesagt.:


> String.length == 0 ;



String.length wird ja nie 0. Ich ersetze die zeichen ja durch "".


----------



## Zeeu (17. Jan 2012)

warum sagst du, dass es nicht geht, ohne es getestet zu hab ?
Durchs ausprobieren lernt man.


```
public abstract class test {

	public static void main(String[] args) {
		String str = " Hallo welt";
		System.out.println(str.length());
		str = str.replaceAll("Hallo", "");
		System.out.println(str.length());
	}

}
```

ausgabe:
[DUKE]11
6
[/DUKE]


----------



## HimBromBeere (17. Jan 2012)

Da bin ich wieder...

dass die Länge nicht 0 wird, liegt daran, dass lediglich Ziffern aus dem String durch "" ersetzt werden. Zwischen den Ziffern ist jedoch ein Trennzeichen (" "), welches auch mitersetzt werden muss. Also entweder du initialisierst deinen String als "123456789" (ohne Leerzeichen), oder du musst (Ziffer + " ") durch "" ersetzen.

EDIT: Musste vorhin weg, konnte deinen Code nicht weiter durchschauen...


----------



## chillerStudent (17. Jan 2012)

bin back.

Es funktioniert jetzt etwas besser, aber wenn ich jetzt z.b. 5 objekte angelegt habe und schon beim 3. objekt die zahlen nicht vorhanden sind, wie verhindere ich dann dass das 4. und das 5. objekt auch die methode aufrufen?

Edit:

mit diesem if überprüfe ich es, ob die zahlen noch enthalten sind oder nicht:


```
if(!dice.contains(Integer.toString(kombi[i])) || !dice.contains(Integer.toString(i))){
							System.out.println("Du verloren");
							break;
						}
```

Aber die methode wird ja trotzdem ausgeführt wenn man sie aufruft.


----------



## Zeeu (17. Jan 2012)

sagmal machst du das für die Schule oder sonstiges ? 
wenn ja, müsstest du vom Lernstoff her wissen, dass du deine Null Pointer Exception bekommen hast.


----------



## chillerStudent (17. Jan 2012)

wo bekomme ich einen nullpointerexception?


----------



## Zeeu (17. Jan 2012)

schreib dir methoden für deine klasse, um dir werte zurück zu liefern, die dir bei abfragen helfen


----------



## chillerStudent (17. Jan 2012)

mein frage war nicht was ein nullpointerexception ist, sondern wo habe ich im programm einen ?! bzw wo bekommst du einen?


----------



## Zeeu (17. Jan 2012)

ich bekomme keine, hab ja auch nicht dein Programm.
Hab mich bei deinem Post auch verlesen, die Objekte sind schon initialisier, es fehlt die Kombi.

public boolean hasKombi(int index){
...
}


----------



## chillerStudent (17. Jan 2012)

Zeeu hat gesagt.:


> public boolean hasKombi(int index){
> ...
> }



soll diese methode überprüfen, ob es noch welche kombinationen gibt? wenn ja, dann glaube ich, dass ich diese nicht brauche, weil mein programm findet alle kombinationen 

mhh.. ich glaub ich häng grad


----------



## Zeeu (17. Jan 2012)

die methode soll prüfen, ob dein Objekt eine Kombi hat


----------



## chillerStudent (17. Jan 2012)

ui ui fällt mir grad schwer. Kannst du mir bitte einen ansatz geben? 
Soll ich die methode in der klasse schreiben wo die main drin ist? und wo bekomme ich das index her im parameter?


----------



## Zeeu (17. Jan 2012)

mit bisschen nachdenken kommst schon drauf


----------



## HimBromBeere (17. Jan 2012)

Hab dir mal eine Methode zum Auffinden aller denkbaren Kombinationen geschrieben, damit das Ganze hier mal übersichtlicher wird:


```
/**
 * returns all possible combinations that are possible to the given number
 */
public int[] getCombinations(int sum) {
    	int[] result = new int[Math.round(sum / 2)];
    	for(int i=0; i < sum/2; i++) {
            if((sum - i) <= 9) {
                result [i] = sum - i;
            }
        }
    	return result;
    }
```


----------



## hdi (17. Jan 2012)

@HimBromBeere was genau soll das Array enthalten? Ich muss zugeben ich weiß nicht mehr genau worum es hier inzwischen geht. Aber die Methodenlogik scheibt mir strange. Alleine schon weil du zB die ersten paar Fächer im Array u.U. leer lässt.


----------



## HimBromBeere (17. Jan 2012)

Ja, dass die leer bleiben, wenn eine Summe > 9 gewürfelt wurde, war mir schon klar. Daher würde ich am ehesten wohl eine Map<Integer, Integer> für dieses Problem vorschlagen... das ist mir aber selbst aus dem Blickfeld geraten,.. danke für´s dran Erinnern


----------



## Zeeu (17. Jan 2012)

wenn ihr weiter "Probleme" löst, die schon gelöst wurden, dreht unser chiller student noch durch 

Edit: ich würds ja in nem AVL baum speichern xD


----------



## chillerStudent (17. Jan 2012)

Zeeu hat gesagt.:


> wenn ihr weiter "Probleme" löst, die schon gelöst wurden, dreht unser chiller student noch durch



hast recht. ich glaub ich werfe hier das Handtuch, außer jemand möchte mich zur lösung gerne begleiten, damit ich weiß, dass ich die nacht dann nicht sinnlos vergäude. 

???:L???:L???:L


----------



## Zeeu (17. Jan 2012)

das Programm, was ich ganz am Anfang schon gepostet hatte, war glaub ich funktionstüchtig, auch wenn nicht besonders schön


----------



## chillerStudent (17. Jan 2012)

Zeeu hat gesagt.:


> das Programm, was ich ganz am Anfang schon gepostet hatte, war glaub ich funktionstüchtig, auch wenn nicht besonders schön



nein. Ich nehme dein Programm nicht, weil ich mein Programm nicht weggschmeisen wollte. Außerdem versteh ich mein prog besser als ein anderes und meins kann ich auch leichter (ver)ändern, sodass ich es auch sehr schnell verstehe. 

Hast du dein prog schon ausprobiert oder war das nur auf papier gemalt?


----------



## Zeeu (17. Jan 2012)

hatte es getestet, und so wie ich die aufgabe verstanden hatte, hats das gemacht, was es sollte


----------



## chillerStudent (17. Jan 2012)

mhh... dann ist ja dein prog bei mir gut aufgehoben  
oder du verratest mir wie sich die objekte immer wiederholt nacheinander die methode ausführen
oder [dein vorschlag]


----------



## Zeeu (17. Jan 2012)

das problem ist, ich kann von hier aus deinen bildschirm nicht sehen :-(


----------



## bERt0r (18. Jan 2012)

Ich glaub nicht dass du mit 18 Kombinationen auskommst, so wie ich es verstanden habe sollte es so aussehen:

```
Summe  2 Werte: [null, 1  1, null, null, null, null, null, null, null, null]
Summe  3 Werte: [null, 1  2, 2  1, null, null, null, null, null, null, null]
Summe  4 Werte: [null, 1  3, 2  2, 3  1, null, null, null, null, null, null]
Summe  5 Werte: [null, 1  4, 2  3, 3  2, 4  1, null, null, null, null, null]
Summe  6 Werte: [null, 1  5, 2  4, 3  3, 4  2, 5  1, null, null, null, null]
Summe  7 Werte: [null, 1  6, 2  5, 3  4, 4  3, 5  2, 6  1, null, null, null]
Summe  8 Werte: [null, 1  7, 2  6, 3  5, 4  4, 5  3, 6  2, 7  1, null, null]
Summe  9 Werte: [null, 1  8, 2  7, 3  6, 4  5, 5  4, 6  3, 7  2, 8  1, null]
Summe 10 Werte: [null, 1  9, 2  8, 3  7, 4  6, 5  5, 6  4, 7  3, 8  2, 9  1]
Summe 11 Werte: [null, null, 2  9, 3  8, 4  7, 5  6, 6  5, 7  4, 8  3, 9  2]
Summe 12 Werte: [null, null, null, 3  9, 4  8, 5  7, 6  6, 7  5, 8  4, 9  3]
Zahl eingeben (2-12): 12
Kombi gefunden!
Summe  2 Werte: [null, 1  1, null, null, null, null, null, null, null, null]
Summe  3 Werte: [null, 1  2, 2  1, null, null, null, null, null, null, null]
Summe  4 Werte: [null, 1  3, 2  2, 3  1, null, null, null, null, null, null]
Summe  5 Werte: [null, 1  4, 2  3, 3  2, 4  1, null, null, null, null, null]
Summe  6 Werte: [null, 1  5, 2  4, 3  3, 4  2, 5  1, null, null, null, null]
Summe  7 Werte: [null, 1  6, 2  5, 3  4, 4  3, 5  2, 6  1, null, null, null]
Summe  8 Werte: [null, 1  7, 2  6, 3  5, 4  4, 5  3, 6  2, 7  1, null, null]
Summe  9 Werte: [null, 1  8, 2  7, 3  6, 4  5, 5  4, 6  3, 7  2, 8  1, null]
Summe 10 Werte: [null, 1  9, 2  8, 3  7, 4  6, 5  5, 6  4, 7  3, 8  2, 9  1]
Summe 11 Werte: [null, null, 2  9, 3  8, 4  7, 5  6, 6  5, 7  4, 8  3, 9  2]
Summe 12 Werte: [null, null, null, null, 4  8, 5  7, 6  6, 7  5, 8  4, 9  3]
Zahl eingeben (2-12):
```


----------



## HimBromBeere (18. Jan 2012)

Wenn du das gerade alles selbst hingeschrieben hast, alle Achtung, falls du jedoch - wie ich hoffe - eine Schleife dafür verwendest hast, wäre es super, sie dem Ersteller zukommen zu lassen...

Btw.: ich glaube, die Permutation der Ergebnisse ist nicht zulässig...
Außerdem ist die Kombination [0, n] auch möglich, technisch zwar nicht (man kann keine 0 würfeln), aber faktisch kommt das auf´s selbe heraus. D.h. die Augensumme wird bereits durch Einmaliges Werfen des neun-seitigen Würfels erreicht.


----------



## chillerStudent (18. Jan 2012)

will jemand es mit mir mit verweisen probieren?


----------



## HimBromBeere (18. Jan 2012)

DAS hab ich dir mal noch schnell gemacht:


```
public class Main {

	public static void main(String[] args) {
	
		Player[] players = new Player[] {
				new Player("Susi"), 
				new Player("Hugo"), 
				new Player("Hans")
		};
		
		// set the last pointer to the first element (circular list)
		players[players.length - 1].next = players[0];
		for (int i = 0; i < players.length - 1; i++) players[i].next = players[i + 1];	
	
	}

}
```


```
public class Player {
    
	public String name;
	public Player next;
    
    
	static String dice = "1 2 3 4 5 6 7 8 9";
	static StringBuffer sb = new StringBuffer();
    
    
	Player(String name){
		this.name = name;
        
		System.out.println("Spieler "+ name +" nimmt teil.");
	}
    ...
}
```

Da du ja nicht mit gettern und settern arbeiten darfst :autsch:, war ich leider gewzungen, die Variablen next und name public zu machen... tut mir leid, ich weiß, dass es hässlich aussieht;(


----------



## chillerStudent (18. Jan 2012)

Vielen Dank!! 
Wie kann ich jetzt mein methode ausführen?


----------



## HimBromBeere (18. Jan 2012)

```
players[i].wuerfeln()
```
Wie wäre der?
Das einzig Komplizierte scheint mir im Moment die Abbruchbedingung zu sein, sprich wer wann verloren hat oder anders ausgedrückt: wie lange die Spieler würfeln können, bevor das Spiel vorbei ist... das muss ja berechnet werden über die noch zur Verfügung stehenden Kombinationen.


----------

