# Arrays prüfen und über if Bedingung ausgeben



## Jura2k5 (13. Nov 2012)

Moin,
erstmal zu sagen : Super Forum! Habt mir schon viel geholfen nun muss ich jedoch was fragen.
Bin dabei in einem Pokerspiel die Ränge zu ermittel.
Sprich Straight Flush usw.

Ich bekomme ein zufälliges Deck über ein Array ! (main Methode)

```
public static void main(String[] args) {
		
		Deck stapel = new Deck();
		Card[] karte = new Card[7];
		
		for (int i = 0; i < karte.length; i++) {
			karte[i] = stapel.deal();
		}
		ausgabeDerGespieltenKarten(karte);
		sortierenNachRang(karte);
		findRangs(karte);
```


Hier sind die Karten nach dem rang ermittelbar sprich . TWO,THREE, ... KING,  ACE 
Ich habe jetzt versuch über eine für und if schleife einen Straight zu ermittel wie folgt! 

```
public static void findRangs(Card[] karte) {
		for(int i=0; i<karte.length; i++){	
if (karte[i].getRank().equals(ACE) & karte[i].getRank().equals(KING) & karte[i].getRank().equals(QUEEN) & karte[i].getRank().equals(JACK) & karte[i].getRank().equals(TEN)){
	
 System.out.println("Straight_Flush AKQJT");		  
			  }
```


Hierbei gibt er mir jedoch keine Ausgabe über die gefundenen Straßen.
Ich vermute es liegt an dem Operator : & / && (haben beide nicht zum erfolg geführt)
Bzw das ich evtl etwas mit dem Index falsch mache!
Ich habe pro Deck immer 7 Karten.
Habe ich evtl etwas mit der For schelife falsch gemacht!
Ich möchte das er über den Index die Straßen finden mit.getRank().equals().
Wenn ich nur nach einem element suche klappt die ausgabe problemlos.
Könntet ihr mir evtl helfen?


----------



## Volvagia (13. Nov 2012)

Du prüfst ja jeden Schleifendurchgang, ob die jeweilige Karte jeden dieser Ränge hat. Die müsstest prüfen ob jeder dieser Ränge bei den Cards jeweils 1x vor gekommen ist.

Sehr einfach wäre das vielleicht mit einen HashSet in dem du bereits gezogene Ränge speicherst.


----------



## Jura2k5 (13. Nov 2012)

Das Problem ist ich hatte noch keine HashSeds in der Uni und das wird den Prof nicht freuen wenn ich die nutze =)
Gibt es nicht eine möglichkeit das ich in der SChleife das komplette Array durchlaufe und alle gefundenen elemente mit meiner equals Methode abgleiche?


----------



## nillehammer (13. Nov 2012)

- Wenn du hoch oder runteriterierst, dann muss das Array sortiert sein, sonst findest Du die Straße nicht
- es macht keinen Sinn, alle Bedingungen für das selbe Element zu prüfen (karte_). Da Du denselben index in allen Bedingungen verwendest, kann das nie wahr werden.
- Du wolltest sicher '&&' (logisches UND) und nicht '&' (binäre UND-Verknüpfung) verwenden.
Dann bist Du zwar noch nicht fertig..._


----------



## TryToHelp (13. Nov 2012)

Jura2k5 hat gesagt.:


> ...
> 
> ```
> if (karte[i].getRank().equals(ACE) & karte[i].getRank().equals(KING) & karte[i].getRank().equals(QUEEN) & karte[i].getRank().equals(JACK) & karte[i].getRank().equals(TEN)){
> ...


zum einen müsste es wenn dann 
	
	
	
	





```
&&
```
 heißen, aber vorallem testest du, ob eine Karte das Ass und der König und die Dame und der Bube und die 10 ost, jedoch ist eine Karte für gewöhnlich nur genau eins davon.

Also ich würde dein Deck erst sortieren und dann kannst du so schauen ob es passt


```
if (karte[0].getRank().equals(ACE) && karte[1].getRank().equals(KING) && karte[2].getRank().equals(QUEEN) && karte[3].getRank().equals(JACK) && karte[4].getRank().equals(TEN)){
```

[EDIT]Mhh zu langsam[/EDIT]


----------



## Jura2k5 (13. Nov 2012)

Ich hab auch einen Sort.alg. "geschrieben" 


```
public static void ausgabeDerGespieltenKarten(Card[] karte) {
public static void sortierenNachRang(Card[] karte) {
		Arrays.sort(karte, Collections.reverseOrder()); 
			for (int i = 0; i < karte.length; i++) {
					System.out.println(karte[i].getRank().value());	
		Card.printCardArray(karte);
				}
```


----------



## nillehammer (13. Nov 2012)

TryToHelp hat gesagt.:
			
		

> [EDIT]Mhh zu langsam[/EDIT]


Passiert Dir öfter, ne? Telepathische Fähigkeiten sind nur gut, wenn man schnell genug tippen kann...


----------



## nillehammer (13. Nov 2012)

> Ich hab auch einen Sort.alg. "geschrieben"


Ok, unter der Voraussetzung, dass die Sortierung tatsächlich die Karte mit dem größten Rank an den Anfang stellt, ist es eigentlich relativ einfach ohne Schleife zu lösen:

```
boolean isStraightFlush = karte[0].getRank().equals(ACE) && karte[1].getRank().equals(KING) && ...
```


----------



## TryToHelp (13. Nov 2012)

TryToHelp hat gesagt.:


> ...
> 
> ```
> if (karte[[B]6[/B]].getRank().equals(ACE) && karte[[B]0[/B]].getRank().equals(KING) && karte[[B]1[/B]].getRank().equals(QUEEN) && karte[[B]2[/B]].getRank().equals(JACK) && karte[[B]3[/B]].getRank().equals(TEN)){
> ...


Wenn ich es richtig gesehen habe, ist deine sortierung dann so ;-) da dein Ass den niedrigsten rang hat ;-)
[EDIT]Ja scheint so :-([/EDIT]


----------



## Jura2k5 (13. Nov 2012)

Also ich hab den Quellcode mal angepasst so dass ich nach dem index prüfe sprich [0] dann [1] usw...


```
if (karte[0].getRank().equals(KING) && karte[1].getRank().equals(QUEEN) && karte[2].getRank().equals(JACK) && karte[3].getRank().equals(TEN) && karte[4].getRank().equals(NINE)){
				  System.out.println("Straight_Flush KQJT9");		  
			  }
```

Damit habe ich nun auch einen Flush ermitteln können, jedoch frag ich mich wie es denn aussieht wenn ich im 
Der Index wird bei mir so aufgebaut über die Arrays.sort.Collections Methode!
Index[0] 14(ass)
Index[1]14(ass)
Index[2]13(könig)
Index[3]12(dame)
Index[4]11(dame)
Index[5]10(bube)
Index[6]9(10)

stehen habe ... ( Das Deck hat ja 7 Karten)

Mit der oben genannten Methode prüfe ich ja nur auf einen Flush wenn keine Karten doppelt vorkommen ! Sehe ich doch richtig oder ?
Wie kann ich dieses Problem umgehen ?


----------



## Jura2k5 (13. Nov 2012)

TryToHelp hat gesagt.:


> Wenn ich es richtig gesehen habe, ist deine sortierung dann so ;-) da dein Ass den niedrigsten rang hat ;-)
> [EDIT]Ja scheint so :-([/EDIT]



Ne das ASS hat den Rang 14!


----------



## nillehammer (13. Nov 2012)

> Mit der oben genannten Methode prüfe ich ja nur auf einen Flush wenn keine Karten doppelt vorkommen ! Sehe ich doch richtig oder ?
> Wie kann ich dieses Problem umgehen ?


Das ist jetzt eine Frage nach dem Alghoritmus. Dazu zwei Ideen:
- Prüfe nicht die absteigenden Indizes, sondern schreibe eine contains-Methode, mit der du nach und nach prüfst, ob alle Ranks enthalten sind
- Oder bleib der dem absteigen über die Indizes und baue ein, dass bei gleichem Rank die nächste Karte geprüft wird, sofern noch genügend übrig, um eine Straße zu bekommen. (Ok, dann wird's wohl doch was mit Schleife...)


----------



## Jura2k5 (13. Nov 2012)

Was haltet irh davon ?
Ich setzte die doppelten Elemente auf 0. Diese werden durch den Suchalgo. nach unten plaziert auf die letzten Indexwerte!
Wenn die Zahl drei oder vierfach vorkommte wird meine Bedinung nicht erfüllt und es sollte immer funktionieren mit der Straße


```
public static void eliminate(Card[]karte) {
	        for (int i = 0; i < karte.length; i++) { 
	            for (int j = i + 1; j < karte.length; j++) {   
	                if (karte[i] == karte[j]) {
	                    karte[j] = null;

	                }
	            } 
	                    System.out.println(karte[i].getRank());
	        } 
	    }
```

Leider liefert mir dieser Algorithmus nicht die arrays als 0 ? Was mach ich nun wieder falsch ?


----------



## bobbsen (13. Nov 2012)

Hab den Thread jetzt nur überflogen, aber bau dir doch ein int-Array für die möglichen Werte der Karten, lauf durch deine 7 Karten durch, zähle die Werte der Karten in dem int-array.

Dann kannst du dein Array prüfen, ob Ass, König, Dame und so weiter jeweils mindestens 1x vorkamen. Ausserdem kannst du Paare usw. auch schnell erkennen. Nur die Farben gehen bei dieser Ansicht verloren.

HTH, Bobbsen


----------



## Jura2k5 (13. Nov 2012)

Ich muss leider sagen das ich das nicht so gewuppt bekomme die schon vorhandenen arrays zu streichen und die dann zu verschieben in ihrer rheienfolge!

```
if (karte[0].getRank().equals(ACE) && karte[1].getRank().equals(KING) && karte[2].getRank().equals(QUEEN) && karte[3].getRank().equals(JACK) && karte[4].getRank().equals(TEN)){
				  System.out.println("Straight_Flush AKQJT");		  
			  }
			  if (karte[0].getRank().equals(KING) && karte[1].getRank().equals(QUEEN) && karte[2].getRank().equals(JACK) && karte[3].getRank().equals(TEN) && karte[4].getRank().equals(NINE)){
				  System.out.println("Straight_Flush KQJT9");		  
			  }
			  if (karte[0].getRank().equals(QUEEN) && karte[1].getRank().equals(JACK) && karte[2].getRank().equals(TEN) && karte[3].getRank().equals(NINE) && karte[4].getRank().equals(EIGHT)){
				  System.out.println("Straight_Flush QJT98");		  
			  }
			  if (karte[0].getRank().equals(JACK) && karte[1].getRank().equals(TEN) && karte[2].getRank().equals(NINE) && karte[3].getRank().equals(EIGHT) && karte[4].getRank().equals(SEVEN)){
				  System.out.println("Straight_Flush JT987");		  
			  }
			  if (karte[0].getRank().equals(TEN) && karte[1].getRank().equals(NINE) && karte[2].getRank().equals(EIGHT) && karte[3].getRank().equals(SEVEN) && karte[4].getRank().equals(SIX)){
				  System.out.println("Straight_Flush T9876");		  
			  }
			  if (karte[0].getRank().equals(NINE) && karte[1].getRank().equals(EIGHT) && karte[2].getRank().equals(SEVEN) && karte[3].getRank().equals(SIX) && karte[4].getRank().equals(FIVE)){
				  System.out.println("Straight_Flush 98765");		  
			  }
			  if (karte[0].getRank().equals(EIGHT) && karte[1].getRank().equals(SEVEN) && karte[2].getRank().equals(SIX) && karte[3].getRank().equals(FIVE) && karte[4].getRank().equals(FOUR)){
				  System.out.println("Straight_Flush 87654");		  
			  }
			  if (karte[0].getRank().equals(SEVEN) && karte[1].getRank().equals(SIX) && karte[2].getRank().equals(FIVE) && karte[3].getRank().equals(FOUR) && karte[4].getRank().equals(THREE)){
				  System.out.println("Straight_Flush 76543");		  
			  }
			  if (karte[0].getRank().equals(SIX) && karte[1].getRank().equals(FIVE) && karte[2].getRank().equals(FOUR) && karte[3].getRank().equals(THREE) && karte[4].getRank().equals(TWO)){
				  System.out.println("Straight_Flush 65432");		  
			  }
			  if (karte[0].getRank().equals(ACE) && karte[1].getRank().equals(FIVE) && karte[i].getRank().equals(FOUR) && karte[3].getRank().equals(THREE) && karte[4].getRank().equals(TWO)){
				  System.out.println("Straight_Flush 5432A It is a Wheel");		  
			  }
```

Könntet ihr mir evtl bisschen helfen wie ich das schaffe das in meinem Array die doppelten Positionen gestrichen werden.
Ich hab schon versuch ein neues arrays zu erstellen und dann über eine for if schleife nur die nicht doppelten werte zu übernehmen, leider klappt es nicht!


----------



## bobbsen (13. Nov 2012)

geht wahrscheinlich noch besser, aber hab grad noch anderes zu tun:


```
public class Test {
	static enum Value {
		ACE,
		KING,  
		QUEEN, 
		JACK,
		TEN,   
		NINE,  
		EIGTH, 
		SEVEN, 
		SIX,   
		FIVE,  
		FOUR, 
		THREE,
		TWO  
	}
	
	public static void main(String[] args) {
		Value[] cards = {Value.ACE, Value.KING, Value.KING, Value.QUEEN, Value.JACK, Value.NINE, Value.TEN};
	
		p(cards);		
	}
	
	private static void p(Value[] cards) {
		// Array zum Zählen
		int[] a = new int[Value.values().length]; 
		
		// Karten zählen
		for (Value v: cards) {
			a[v.ordinal()]++;
		}
		
		// Ergebnis ausgeben
		for (Value v: Value.values()) {
			System.out.printf("%s - %d\n", v, a[v.ordinal()]);
		}
		
		// Aufeinander folgende 5 Karten finden
		int start = 0;
		int count = 0;
		for(int i = Value.ACE.ordinal(); i <= Value.TWO.ordinal(); ++i) {
			if (a[i] > 0) {
				count++;
				if (count == 1) {
					start = i;
				} else if (count >= 5) {
					break;
				}
			} else {
				count = 0;
			}
		}
		
		// Wenn gefunden: ausgeben
		if (count >= 5) {
			System.out.println("Straight Flush: ");
			for (int i = 0; i < 5; ++i) {
				System.out.println(Value.values()[start + i]);
			}
		} else {
			System.out.println("Kein Straight Flush gefunden, was anderes suchen ;)");
		}
	}
}
```

HTH, bobbsen


----------

