✔ Array nach bestimmtem Wert durchsuchen lassen

[cyberc]

Hi,

ich programmiere gerade eine abgewandelte Form des Kartenspiels "Leben und Tod" Dabei hat der Computer und der Mensch jeweils zwei Kartenstapel und es wird immer nur die oberste Karte von einem Stapel entfernt und mit der des Gegners verglichen.

Um zum Punkt zu kommen, das Programm ist fast fertig, nur beim Mischen hakt es noch. Und zwar habe ich die ganzen 32 Karten erst mal per Hand erstellt und zwar als Array.

Dieses Array würde ich jetzt gerne auf einen Stack legen, und zwar in willkürlicher Reihenfolge.

Meine Überlegung dazu:

//Karteninitialisierung
Karte karte[0] = new Karte (1, 7); //und das für insgesamt 32 Karten!
.
.
.

Nun habe ich mir überlegt mittels einer for-Schleife die Karten auf einen Stack zu legen, und dabei einen Wert zwischen 0 und 31 zu generieren. Das generieren macht keine Schwierigkeiten, sondern eher dass jeder Wert nur ein einziges Mal vorkommt. Dafür war meine Überlegung um es kurz auszudrücken, dass ich so etwas in der for-Schleife mache:

int j = 0;
int[ ] f = new int [32];
for (int i=0; i<karte.length; i++)
{
j = rnd.nextInt(32)
// Nun würde ich die Zahl j mit dem ganzen Array f abgleichen, ob der Wert darin schon vorhanden ist. Wenn nicht, dann würde der Wert ins Array gespeichert werden, und die Karte käme auf den Stapel. Wenn der Wert von j schon im Array f steht, wird eine neue Zahl generiert.

Eine Idee von mir war gewesen, das Array mit Hilfe einer if-else Abfrage zu durchsuchen, aber das geht leider nicht so einfach, musste ich leider feststellen.

Ich hoffe dass ich euch das einigermaßen erklärt habe, was ich machen möchte, und ihr mir helfen könnt.

Gruß cyberc

PS: Ich bin noch ein ziemlicher Anfänger (habe dieses Semester angefangen zu programmieren.

 

[Kai008]

Warum setzt du nach dem du dir eine Karte aus dem Array geschnappt hast die Referenz im Array nicht auf null und testest einfach danach?

Ein anderer Weg wäre es die Karten in eine ArrayList zu laden. In dem Fall suchst du dir 2 Pseudozufallszahlen zwischen -1 und size raus, und falls sie nicht gleich sind schnappst du dir eine Karte, speicherst sie zwischen und ersetzt die beiden Karten per set. Dann hohlst du dir einfach die erste Karte per get(0). Weiß aber nicht wie das Performancemäßig aussieht.

Nur so ne Idee, dein Ansatz sollte eigendlich auch problemlos hinhauen.

 

[cyberc]

Hi,

ich hab es jetzt endlich hinbekommen, zwar nicht mit Hilfe der Vorschläge von dir Kai008, aber ich danke dir trotzdem sehr für die Hilfe.

So hab ich jetzt das Problem gelöst:

- Jede Karte im Array hat einen eindeutigen Wert zwischen 0 und 31(eingeschlossen)
- Als erstes habe ich mir ein zweites Array mit 32 Plätzen erstellt.
- In einer Schleife habe ich dann Zahlen zwischen 0 und 31(eingeschlossen) mit nextInt erzeugen lassen und in eine Variable a gespeichert.
- Nun kommt das entscheidende Element: Ich habe das Array mit der Methode binarySearch nach a durchsucht, dabei wird ein Integer-Wert zurückgegeben, der positiv ist, wenn die Variable vorhanden ist, und negativ wenn sie nicht vorhanden ist. Die Methode befindet sich in der Klasse java.util.Arrays (sie ist eigentlich dafür gedacht, um anzuzeigen, an welcher Position sich ein bestimmter Wert in einem Array befindet). Den zurückgegebenen Wert habe ich in eine Variable b gespeichert.
- Nun kann ich die Variable mit Hilfe einer if-else Anweisung überprüfen lassen, ob der Wert positiv oder negativ ist.

- Wenn er positiv ist, lasse ich die Schleife den einen schritt nochmal wiederholen:

          for (int i = 0; i<karte.length; i++)
          {
                a = generator.nextInt(32);
                b = Arrays.binarySearch(speicher, b);
              if (b>=0)
              {
                  i--;
              }
              else
               {
                      speicher[i]=a;
                      //im folgenden Schritt lasse ich noch die entsprechende Karte aus meinem Array auf den Stack legen, und schon mischt er mir nach dem Zufallsprinzip, und ich kann ausschließen, dass eine Karte doppelt vergeben wird.

Ich danke dir trotzdem sehr, dass du versucht hast, mir zu helfen.

Gruß cyberc

 

[Adrian_Broher]

Du solltest von Arrays auf die Collections umsteigen. Fuer das List Interface gibt es schon eine fertige "mischen" Implementierung in der Form von Collections.shuffle.

List cards = new ArrayList<Cards>(32);
for(Card.Suit suit : Card.Suit.values()) {
    for(Card.Rank rank : Card.Rank.values()) {
        cards.add(new Card(suit, rank));
    }
}
Collections.shuffle(cards);

 

[cyberc]

@ Adrian Broher

Danke, aber irgendwie komme ich nicht mit deinem Code nicht klar, es wird mir vermutlich noch an Programmierwissen mangeln, um den Code zu verstehen.

Meine Lösung die ich oben angegeben habe, mit binarySearch hat leider nicht geklappt, da er mir immer wieder doppelte Karten generiert hat, und das obwohl ich immer wieder das Array abgefragt habe. Daher meine Frage, gibt es noch weitere Möglichkeiten Karten zu mischen? Am besten ohne dass ich am Anfang etwas importieren muss, denn das haben wir noch gar nicht gelernt. Ich würde mich freuen. Das Programm an sich ist aber schon lauffähig, aber wie vermutet, bekommt jeder immer die selben Karten, und das finde ich doch sehr langweilig.

Gruß cyberc

 

[Alvine]

Du hast also am Start ein simples Array mit 32 Karten --> [Karte1, Karte2, Karte3,...,Karte32]
Es gibt in der Klasse Math die Funktion random(). Kennst du diese?

Du könntest also ein zweites Array mit 32 Plätzen anlegen ("kartenGemischt").
Dann machst du eine while-Schleife, die solange läuft, bis ein Zähler die bescheinigt, dass su alle 32 Plätze belegt hast.

int counter=0;
//Karte karte [] = new Karte[32]; --> hier sind deine 32 Karten drin
Karte kartenGemischt [] = new Karte[32];
while(counter<32) {

	int randomNumber=(int)(Math.random()*32); //liefert eine Zahl zwischen 0 und 31 --> glaub ich, dass solltest du besser überprüfen
	if (kartenGemischt[randomNumber]==null) { // Abfrage ob du an dieser Stelle schon eine Karte abgelegt hast, oder dieser Platz noch frei ist
		kartenGemischt[randomNumber]=karte[counter]; //du nimmst also immer die nächste Karte aus deinem Ur-Stapel und legst sie zufällig in deinen gemischten Stapel ab
		counter++; // du hast einen Platz mehr belegt
	}
}

Die Methode von Adrian Broher ist natürlich besser, aber wenn du wirklich nur die einfachen Arrays zur Verfügung hast und nichts weiter importien sollst, dann könnte dich das weiterbringen.

Achtung! Prinzipiell kann dich das in eine Endlos-Schleife bringen, da nicht garantiert ist, dass du wirklich alle Zahlen zwischen 0 und 32 jemals triffst (ist ja schließlich Zufall ). Aber aus Erfahrung weiß ich, dass es bei 32 noch machbar ist dieses Risiko einzugehen.

 

[cyberc]

@ Alvine

Danke, ich hab es jetzt geschafft, es läuft jetzt super gut.

Gruß cyberc