Zufalsszahl soll sich nicht wiederholen

[Kenan]

Liebe Forummitglieder,

ich implementiere ein Spiel. Hierbei geht es darum die gestellte Frage richtig zu bentworten. Der User darf ein Hinweis bekommen als Buchstaben. Hier mal ein Fallbeispiel:
Die Frage lautet: "angenehmer, feiner Geruch.
Die Antwort lautet: "Duft"

Der Spieler bekommt auf Wunsch einen Hinweis in form von Buchstaben. z.B. "D" oder"f"
Diese buchstaben werden vom Antwort-Wort zufällig ausgewählt. Manchmal kommt aber der gleiche Buchstabe wieder.

Ich benötige etwas womit ich es verhindern kann, das die eine Zufallszahl sich wiederholt und somit sich auch der Buchstabe sich wiederholt.

Der Konkrete Fall mit der Zufallszahl ist in der Klasse Aktionen in der Methode buchstabenNehmen()

Ich bitte um eure Hilfe und Unterstützung. Wäre super wenn jemand mir einen Ansatz geben könnte.

VG Kenan

Ich habe drei Klassen: Daten, Aktionen und TestAktionen

Hier die Klasse Daten.

public class Daten {

    private String[] fragen = new String[14];
    private String[] antworten = new String[14];

    public Daten(String[] fragen, String[] antworten) {
        this.fragen = fragen;
        this.antworten = antworten;

        fragen[0] = "Kleinste, aus einem oder mehreren Lauten gebildete Einheit innerhalb einer Wortform";
        antworten[0] = "Silbe";
        fragen[1] = "angenehmer, feiner Geruch";
        antworten[1] = "Duft";
        fragen[2] = "nach innen gewölbt";
        antworten[2] = "Konkav";
        fragen[3] = " Dünner Mensch";
        antworten[3] = "Abgemagert";
        fragen[4] = "pikante, dickflüssige Soße zum Würzen";
        antworten[4] = "Ketchup";
        fragen[5] = "mit freudiger Bereitwilligkeit, Vergnügen";
        antworten[5] = "Gerne";
        fragen[6] = "den Intellekt betreffend; verstandesmäßig, geistig";
        antworten[6] = "Intellektuell";
        fragen[7] = " Person, die einen Mord begangen hat";
        antworten[7] = "Mörder";
        fragen[8] = "über das gewohnte Maß hinausgehend";
        antworten[8] = "Außergewöhnlich";
        fragen[9] = "sich (in einer bestimmten Weise) verhalten, betragen";
        antworten[9] = "benehmen";
        fragen[10] = "philosophische Disziplin oder Lehre, die das hinter der sinnlich erfahrbaren, natürlichen Welt Liegende, die letzten Gründe und Zusammenhänge des Seins behandelt";
        antworten[10] = "metaphysik";
        fragen[11] = "Einrichtungsgegenstand, mit dem ein Raum ausgestattet ist";
        antworten[11] = "Möbel";
        fragen[12] = "für ein Individuum spezifische, relativ konstante Weise des Fühlens, Erlebens, Handelns und Reagierens";
        antworten[12] = "Temperament";
        fragen[13] = " weder Lust noch Unlust empfindend oder erkennen lassend";
        antworten[13] = "gleichgültig";
    }

    public String[] getFragen() {
        return fragen;
    }

    public void setFragen(String[] fragen) {
        this.fragen = fragen;
    }

    public String[] getAntworten() {
        return antworten;
    }

    public void setAntworten(String[] antworten) {
        this.antworten = antworten;
    }
}

Hier die Klasse Aktionen, wo die Methoden implementiert sind.

import java.util.*;
import java.util.ArrayList;

public class Aktionen extends Daten {

    Scanner in = new Scanner(System.in);
    int i;
    // Nehme die gleiche Länge für das Temporäre Array wie das AntwortArray
    String[] temp = new String[getAntworten()[i].length()];
    int[] sammleZZ = new int[getAntworten()[i].length()];

    public Aktionen(String[] fragen, String[] antworten) {
        super(fragen, antworten);

    }

    // Methode: Zeigt Frage von der Stelle i an.
    public void frageAnzeigen(int i) {
        System.out.println(getFragen()[i]);
    }

    // Zeige zufälligen Buchstaben vom AntwortenArray.
    public int buchstabenNehmen(int i) {

       
        // Nehme die gleiche Länge für das Temporäre Array wie die Länge des Wortes im jeweiligen AntwortArray
        String[] temp = new String[getAntworten()[i].length()];

       
        // Zufallszahl
        int z;
        z = ((int) (Math.random() * getAntworten()[i].length()));

        // Packe den char an die gleiche Stelle ins tempArray wie das AntwortArray
        temp[z] = String.valueOf(getAntworten()[i].charAt(z));

        // Zeige Inhalt vom Array
        for (int j = 0; j < temp.length; j++) {

            System.out.println(temp[j]);
        }

       

        System.out.println("Geben Sie b für einen neuen Buchstaben ein oder l wenn Sie auflösen möchten.");
        String entscheidung = in.nextLine();
        if (entscheidung.equals("b")) {
            buchstabenNehmen(i);

        } else if (entscheidung.equals("l")) {
            System.out.println("Fertig mit Buchstaben nehmen.");
        }

        return i;
    }

    public void aufloesen(int i) {

        System.out.println("Geben Sie die Antwort ein.");
        String antwort = in.next();

        if (antwort.equals(getAntworten()[i])) {
            System.out.println("Die Lösung ist korrekt: " + getAntworten()[i]);

        } else {
            System.out.println("Die Lösung ist falsch. Versuchen Sie es erneut.");
        }

    }

}

Hier die Klasse mit der Main-Methode. Hier habe ich ein Menü drinnen womit ich die jeweiligen Methoden aufrufe.

import java.io.ObjectInputStream.GetField;
import java.util.ArrayList;
import java.util.Scanner;

public class TestAktionen {

    public static void main(String[] args) {
       
   
       
        String[] fragen = new String[14];
        String[] antworten = new String[14];
       
        Aktionen ob1 = new Aktionen(fragen, antworten);
        Scanner in = new Scanner(System.in);
       
        boolean helper = false;
        while (!helper) {
            System.out.println("Bitte wählen Sie aus!\n");
            System.out.println("1. Spiel beginnen");
            System.out.println("2. BuchstabenNehmen");
            System.out.println("3. Auflösen");
            System.out.println("4. Spiel beenden");
           
            int i = 0;
            int menu = in.nextInt();

            switch (menu) {

            case 1:
                if(i <= 13) {
               
                ob1.frageAnzeigen(i);
               
                i++;
                }
                break;
            case 2:
                ob1.buchstabenNehmen(i);
                break;

            case 3:
                ob1.aufloesen(i);
                break;
               
            case 4: // Bei Auswahl 4, wird das Program beendet.
                helper = true;
                System.out.println("Das Spiel wurde beendet. ");
                break;

            default:
                // Falls der User eine Zahl außerhalb der Spanne 1-3 eingibt, wird eine
                // Fehlermeldung ausgegeben.
                System.out.println("Falsche Eingabe! Zahlen nur im Bereich 1-3 möglich");
                break;
            }

        }

    }
}

 

[Flown]

Die einfachste Variante wäre du nimmst dein Wort, machst ein char array daraus, ein shuffle auf das array und gibst dann einfach buchstabe für buchstabe zurück.

 

[Code-Mode]

Nur kurz überflogen und auch nicht viel Zeit.
Aber wenn Antwort = "Baum" könntest du ein Array oder Liste oder etc.. haben mit jedem einzelnen Buchstaben
[B,a,u,m] und dann einen zufälligen index rausnehmen.
z.B. 1
dann löscht du diesen Buchstaben und hälst nur noch [B,u,m]
und von diesen könnte dann wieder ein zufälliges Element genommen werden.

List<String> myList = new ArrayList<String>(Arrays.asList("Baum".split("")));
System.out.println(myList); // [B, a, u, m]
System.out.println(myList.remove(1)); // a
System.out.println(myList); // [B, u, m]

 

[Kenan]

Die einfachste Variante wäre du nimmst dein Wort, machst ein char array daraus, ein shuffle auf das array und gibst dann einfach buchstabe für buchstabe zurück.

Nur kurz überflogen und auch nicht viel Zeit.
Aber wenn Antwort = "Baum" könntest du ein Array oder Liste oder etc.. haben mit jedem einzelnen Buchstaben
[B,a,u,m] und dann einen zufälligen index rausnehmen.
z.B. 1
dann löscht du diesen Buchstaben und hälst nur noch [B,u,m]
und von diesen könnte dann wieder ein zufälliges Element genommen werden.

List<String> myList = new ArrayList<String>(Arrays.asList("Baum".split("")));
System.out.println(myList); // [B, a, u, m]
System.out.println(myList.remove(1)); // a
System.out.println(myList); // [B, u, m]

Hi Flown und Code-Mode

danke für den Tipp. Ich habe vergessen zu erwähnen, das ich dem Spieler die Buchstabenhinweise wie folgt geben will. Ich habe versucht meinen Beitrag nochmal zu bearbeiten. Dieses wird anscheinend nicht angeboten. Ich erkläre es nun hier. Also weiter zum Beispiel:

Beispielantwort: "Duft"

Auf Wunsch bekommt der Spieler einen Hinweis.
Erster Hinweis: _ _ f _

Der User Wünscht sich einen weiteren hinweis usw.
Zweiter Hinweis: D _ f _
Dritter Hinweis: D _ f t

Das heißt ich darf das Array nicht mischen.

 

[mihe7]

Das heißt ich darf das Array nicht mischen

Dann mischst Du halt nur die Indizes.

 

[Kenan]

Dann mischst Du halt nur die Indizes.

Hey mihe7,
danke, nur ist mir neu, das man bei einem array die Indizes mischen kann. Gibt es da eine interne Methode? Ansonsten fällt mir keine Lösung dafür ein wie man es manuelle mit einer eigenen Methode machen könnte.

 

[Flown]

Zum Beispiel so:

String word = "Duft";
int[] indices = shuffle(IntStream.range(0, word.length()).toArray());
System.out.println(Arrays.toString(indices));
System.out.println(Arrays.stream(indices).map(word::charAt).collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append));

und mit shuffle:

public static int[] shuffle(int[] arr) {
  Objects.requireNonNull(arr);
  Random rand = ThreadLocalRandom.current();
  for (int i = arr.length - 1; i > 0; i--) {
    int idx = rand.nextInt(i);
    int t = arr[i];
    arr[i] = arr[idx];
    arr[idx] = t;
  }
  return arr;
}

 

[mihe7]

Oder so:

public class Test {
    private int[] pos;
    private int remaining;

    public Test(int len) {
        pos = new int[len];
        for (int i = 0; i < len; i++) {
            pos[i] = i;
        }
        remaining = len;
    }

    public boolean hasNext() {
        return remaining > 0;
    }

    public int next() {
        int ix = (int)(Math.random() * remaining);
        int result = pos[ix];
        remaining--;
        pos[ix] = pos[remaining];
        return result;
    }

    public static void main(String[] args) {
        String antwort = "Duft";
        Test test = new Test(antwort.length());
        int i = 0;
        while (test.hasNext()) {
            int ix = test.next();
            System.out.printf("%d. Tipp: %c an Position %d\n",
                    ++i, antwort.charAt(ix), ix);
        }
    }
}

 

[Kenan]

Danke euch beiden. In euren Code-Beispielen ist ne Menge die für mich neu sind. Deshlab verstehe ich euren Quelltext noch nicht. Ich möchte die Sachen auch nicht einfach copy und paste einsetzen. Ich möchte verstehen was ich implementiere. Den Instream habe ich schonmal gegoogelt und verstanden. Die anderen Sachen muss ich mir noch anschauen und ggf. aneignen.

 

[mihe7]

Ich möchte verstehen was ich implementiere.

Die Algorithmen haben in beiden Fällen die gleiche Grundidee: man nimmt ein Array, in das die Indizes gepackt werden und wendet Fisher-Yates-Shuffle (Google ist Dein Freund) an.