Zum Inhalt springen

Wordle 6: Die Wortliste

Bisher wählt unser Spiel aus drei fest eingetragenen Wörtern – und nimmt als Versuch jede beliebige Buchstabenfolge an, auch XYZQW. Ein echtes Wordle braucht ein Wörterbuch: Das gesuchte Wort wird zufällig daraus gezogen, und geraten werden darf nur, was darin steht.

  • eine Wortliste als eigene Klasse bauen, die den Vertrag Wortquelle erfüllt
  • in einem sortierten Array mit Arrays.binarySearch suchen
  • eine Klasse erweitern, ohne bestehenden Code zu brechen

Ausgangsstand für wordle

⤓ wordle-6.zip herunterladen

Wer die letzte Stufe nicht fertig hat, startet hiermit: Rechtsklick auf das Projektwordle → Import… → General → Archive File → die ZIP-Datei wählen →Finish. Vorhandene Dateien werden dabei – nach Rückfrage – überschrieben.

Enthält: Wordle.java, Feld.java, Status.java, Bewertung.java, Spiel.java, Wortquelle.java, FesteWortquelle.java, ZufallsWortquelle.java, SpielStand.java, SpielDienst.java, LokalerSpielDienst.java, WordleKonsole.java, WordleStart.java, DeutscheWoerter.java, WordleTest.java, BewertungTest.java, SpielTest.java, LokalerSpielDienstTest.java

Der Starter enthält die Lösung von Teil 5 und die Klasse DeutscheWoerter – 1650 Wörter, die niemand abtippen soll.

DeutscheWoerter.java (Anfang)
package de.drv.wordle;
/**
* 1650 deutsche Wörter mit fünf Buchstaben.
* …
*/
final class DeutscheWoerter {
static final String[] WOERTER = {
"AALEN", "ABBAU", "ABEND", "ABGAS", …
  • Die Liste ist bereinigt: alle Wörter in Großbuchstaben, ohne Duplikate, alphabetisch sortiert. Sie wurde aus einer Textdatei erzeugt – deshalb steht im Kommentar „nicht von Hand bearbeiten“.
  • Die Klasse hat keine Sichtbarkeitsangabe: Sie ist nur im Package de.drv.wordle sichtbar. Benutzen soll sie nur die Wortliste.
  • Der Konstruktor ist private – von dieser Klasse soll niemand ein Objekt erzeugen. Sie ist nur ein Behälter für das Array.
public class Wortliste implements Wortquelle {
public static final Wortliste DEUTSCH = new Wortliste(DeutscheWoerter.WOERTER);
public Wortliste(String[] woerter) // normalisiert, prüft, sortiert
public int getAnzahl()
public boolean enthaelt(String wort) // egal ob groß oder klein geschrieben
public String naechstesWort() // ein zufälliges Wort
}

Die Anforderungen:

  1. Der Konstruktor legt eine eigene Kopie der Wörter an, wandelt jedes in Großbuchstaben um und prüft, ob es genau 5 Buchstaben hat. Ein ungültiges Wort führt zu einer IllegalArgumentException. Zum Schluss wird die Kopie sortiert.
  2. enthaelt findet ein Wort unabhängig von Groß- und Kleinschreibung und Leerzeichen am Rand. null ist nie enthalten.
  3. naechstesWort liefert ein zufälliges Wort der Liste. Damit erfüllt die Wortliste den Vertrag Wortquelle – und kann überall eingesetzt werden, wo bisher die FesteWortquelle stand.
  4. DEUTSCH ist eine fertige Wortliste mit den Wörtern aus DeutscheWoerter.

Ob ein Wort in der Liste steht, ließe sich mit einer Schleife über alle 1650 Wörter prüfen. Weil die Liste sortiert ist, geht es viel schneller – so, wie man in einem Wörterbuch sucht: in der Mitte aufschlagen, nachsehen, ob das Wort davor oder dahinter steht, und mit der passenden Hälfte weitermachen.

int position = Arrays.binarySearch(woerter, "FEUER");

binarySearch liefert die Position des Worts – oder eine negative Zahl, wenn es nicht vorkommt. Bei 1650 Wörtern braucht es höchstens 11 Vergleiche, denn nach elfmal Halbieren bleibt nur noch ein Wort übrig.

Lösung

normalisiere macht aus null einen leeren Text – so braucht enthaelt keine Sonderbehandlung, und ein leerer Text steht ohnehin nie in der Liste.

Wortliste.java
package de.drv.wordle;
import java.util.Arrays;
import java.util.Random;
public class Wortliste implements Wortquelle {
/** Die deutsche Wortliste der Schulung. */
public static final Wortliste DEUTSCH = new Wortliste(DeutscheWoerter.WOERTER);
private final String[] woerter;
private final Random zufall = new Random();
public Wortliste(String[] woerter) {
if (woerter == null || woerter.length == 0) {
throw new IllegalArgumentException("Eine Wortliste braucht mindestens ein Wort.");
}
this.woerter = new String[woerter.length];
for (int i = 0; i < woerter.length; i++) {
String wort = normalisiere(woerter[i]);
if (wort.length() != Spiel.WORTLAENGE || !nurBuchstaben(wort)) {
throw new IllegalArgumentException("Ungültiges Wort in der Liste: " + woerter[i]);
}
this.woerter[i] = wort;
}
Arrays.sort(this.woerter);
}
public int getAnzahl() {
return woerter.length;
}
public boolean enthaelt(String wort) {
if (wort == null) {
return false;
}
return Arrays.binarySearch(woerter, normalisiere(wort)) >= 0;
}
@Override
public String naechstesWort() {
return woerter[zufall.nextInt(woerter.length)];
}
private static String normalisiere(String wort) {
return wort == null ? "" : wort.strip().toUpperCase();
}
private static boolean nurBuchstaben(String wort) {
for (int i = 0; i < wort.length(); i++) {
if (!Character.isLetter(wort.charAt(i))) {
return false;
}
}
return true;
}
}

Wo wird geprüft, ob ein Versuch ein echtes Wort ist? Im Spiel – dort stehen alle Regeln für Eingaben. Das Spiel bekommt dafür einen zweiten Konstruktor:

Spiel.java (Ausschnitt)
/** Ein Spiel, das jedes Wort mit fünf Buchstaben als Versuch annimmt. */
public Spiel(String loesung) {
this(loesung, null);
}
/** Ein Spiel, das nur Wörter aus der Wortliste als Versuch annimmt. */
public Spiel(String loesung, Wortliste erlaubteWoerter) {
// … wie bisher prüfen
if (erlaubteWoerter != null && !erlaubteWoerter.enthaelt(loesung)) {
throw new IllegalArgumentException("Die Lösung steht nicht in der Wortliste: " + loesung);
}
this.loesung = loesung.toUpperCase();
this.erlaubteWoerter = erlaubteWoerter;
// …
}

Und in der Prüfung der Versuche kommt eine Regel dazu:

Spiel.java (Ausschnitt)
if (erlaubteWoerter != null && !erlaubteWoerter.enthaelt(wort)) {
throw new IllegalArgumentException("Dieses Wort kenne ich nicht: " + wort);
}
  • Der alte Konstruktor bleibt und ruft den neuen mit null auf: „keine Wortliste – jedes Wort erlaubt“. Deshalb laufen alle bisherigen Tests unverändert weiter, auch der mit AAAAA.
  • Steht eine Wortliste fest, muss auch die Lösung darin stehen – sonst wäre das Spiel nicht zu gewinnen.
  • Ein unbekanntes Wort zählt nicht als Versuch – wie jede andere ungültige Eingabe.

Der LokalerSpielDienst bekommt genauso einen zweiten Konstruktor und reicht die Wortliste an jedes neue Spiel weiter:

LokalerSpielDienst.java (Ausschnitt)
public LokalerSpielDienst(Wortquelle wortquelle, Wortliste erlaubteWoerter) {
// …
}
@Override
public String neuesSpiel() {
String id = UUID.randomUUID().toString();
spiele.put(id, new Spiel(wortquelle.naechstesWort(), erlaubteWoerter));
return id;
}
Lösung
Spiel.java
package de.drv.wordle;
public class Spiel {
public static final int WORTLAENGE = 5;
public static final int MAX_VERSUCHE = 6;
private final String loesung;
private final Wortliste erlaubteWoerter;
private int anzahlVersuche;
private Status status;
/** Ein Spiel, das jedes Wort mit fünf Buchstaben als Versuch annimmt. */
public Spiel(String loesung) {
this(loesung, null);
}
/** Ein Spiel, das nur Wörter aus der Wortliste als Versuch annimmt. */
public Spiel(String loesung, Wortliste erlaubteWoerter) {
if (loesung == null || loesung.length() != WORTLAENGE) {
throw new IllegalArgumentException("Die Lösung muss " + WORTLAENGE + " Buchstaben haben.");
}
if (erlaubteWoerter != null && !erlaubteWoerter.enthaelt(loesung)) {
throw new IllegalArgumentException("Die Lösung steht nicht in der Wortliste: " + loesung);
}
this.loesung = loesung.toUpperCase();
this.erlaubteWoerter = erlaubteWoerter;
this.anzahlVersuche = 0;
this.status = Status.LAEUFT;
}
public Bewertung rate(String versuch) {
if (status != Status.LAEUFT) {
throw new IllegalStateException("Das Spiel ist bereits vorbei.");
}
String wort = pruefeVersuch(versuch);
Bewertung bewertung = new Bewertung(wort, Wordle.bewerte(wort, loesung));
anzahlVersuche++;
if (bewertung.istGeloest()) {
status = Status.GEWONNEN;
} else if (anzahlVersuche == MAX_VERSUCHE) {
status = Status.VERLOREN;
}
return bewertung;
}
private String pruefeVersuch(String versuch) {
if (versuch == null) {
throw new IllegalArgumentException("Bitte ein Wort eingeben.");
}
String wort = versuch.strip().toUpperCase();
if (wort.length() != WORTLAENGE) {
throw new IllegalArgumentException("Bitte genau " + WORTLAENGE + " Buchstaben eingeben.");
}
for (int i = 0; i < wort.length(); i++) {
if (!Character.isLetter(wort.charAt(i))) {
throw new IllegalArgumentException("Bitte nur Buchstaben eingeben.");
}
}
if (erlaubteWoerter != null && !erlaubteWoerter.enthaelt(wort)) {
throw new IllegalArgumentException("Dieses Wort kenne ich nicht: " + wort);
}
return wort;
}
public Status getStatus() {
return status;
}
public int getAnzahlVersuche() {
return anzahlVersuche;
}
public String getAufloesung() {
if (status == Status.LAEUFT) {
throw new IllegalStateException("Die Lösung wird erst nach Spielende verraten.");
}
return loesung;
}
}
Lösung
LokalerSpielDienst.java
package de.drv.wordle;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class LokalerSpielDienst implements SpielDienst {
private final Wortquelle wortquelle;
private final Wortliste erlaubteWoerter;
private final Map<String, Spiel> spiele = new HashMap<>();
/** Ein Dienst, dessen Spiele jedes Wort mit fünf Buchstaben als Versuch annehmen. */
public LokalerSpielDienst(Wortquelle wortquelle) {
this(wortquelle, null);
}
/** Ein Dienst, dessen Spiele nur Wörter aus der Wortliste als Versuch annehmen. */
public LokalerSpielDienst(Wortquelle wortquelle, Wortliste erlaubteWoerter) {
if (wortquelle == null) {
throw new IllegalArgumentException("Ohne Wortquelle kein Spiel.");
}
this.wortquelle = wortquelle;
this.erlaubteWoerter = erlaubteWoerter;
}
@Override
public String neuesSpiel() {
String id = UUID.randomUUID().toString();
spiele.put(id, new Spiel(wortquelle.naechstesWort(), erlaubteWoerter));
return id;
}
@Override
public Bewertung rate(String spielId, String versuch) {
return spiel(spielId).rate(versuch);
}
@Override
public SpielStand stand(String spielId) {
Spiel spiel = spiel(spielId);
String aufloesung = spiel.getStatus() == Status.LAEUFT ? null : spiel.getAufloesung();
return new SpielStand(spiel.getAnzahlVersuche(), Spiel.MAX_VERSUCHE, spiel.getStatus(), aufloesung);
}
private Spiel spiel(String spielId) {
Spiel spiel = spiele.get(spielId);
if (spiel == null) {
throw new IllegalArgumentException("Unbekanntes Spiel: " + spielId);
}
return spiel;
}
}

In WordleStart ändern sich zwei Zeilen:

WordleStart.java (Ausschnitt)
Wortliste woerter = Wortliste.DEUTSCH;
SpielDienst dienst = new LokalerSpielDienst(woerter, woerter);

Die Wortliste ist hier zweimal im Einsatz: als Wortquelle für das Lösungswort und als erlaubte Wörter für die Versuche.

Und WordleKonsole? Keine einzige Zeile ändert sich. Die neue Meldung „Dieses Wort kenne ich nicht“ kommt als IllegalArgumentException aus dem Spiel – und die zeigt die Konsole seit Teil 5 einfach an.

Terminal-Fenster
Versuch 1/6: xyzqw
Dieses Wort kenne ich nicht: XYZQW
Versuch 1/6: adieu
A D I E U
WortlisteTest.java
WortlisteTest.java
package de.drv.wordle;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class WortlisteTest {
@Test
@DisplayName("Die deutsche Wortliste enthält 1650 Wörter")
void anzahl() {
assertEquals(1650, Wortliste.DEUTSCH.getAnzahl());
}
@Test
@DisplayName("Bekannte Wörter werden gefunden – unabhängig von der Schreibweise")
void enthaelt() {
assertTrue(Wortliste.DEUTSCH.enthaelt("FEUER"));
assertTrue(Wortliste.DEUTSCH.enthaelt("feuer"));
assertTrue(Wortliste.DEUTSCH.enthaelt(" Feuer "));
assertFalse(Wortliste.DEUTSCH.enthaelt("XYZQW"));
assertFalse(Wortliste.DEUTSCH.enthaelt(null));
}
@Test
@DisplayName("Jedes zufällige Wort stammt aus der Liste")
void zufall() {
for (int i = 0; i < 100; i++) {
assertTrue(Wortliste.DEUTSCH.enthaelt(Wortliste.DEUTSCH.naechstesWort()));
}
}
@Test
@DisplayName("Eine eigene Wortliste wird normalisiert")
void eigeneListe() {
Wortliste liste = new Wortliste(new String[] {"feuer", " Blaue "});
assertTrue(liste.enthaelt("FEUER"));
assertTrue(liste.enthaelt("BLAUE"));
assertEquals(2, liste.getAnzahl());
}
@Test
@DisplayName("Spätere Änderungen am übergebenen Array ändern die Liste nicht")
void kopie() {
String[] woerter = {"FEUER", "BLAUE"};
Wortliste liste = new Wortliste(woerter);
woerter[0] = "XXXXX";
assertTrue(liste.enthaelt("FEUER"));
}
@Test
@DisplayName("Ungültige Wörter in der Liste werden abgelehnt")
void ungueltig() {
assertThrows(IllegalArgumentException.class, () -> new Wortliste(new String[] {"FEUER", "HAL"}));
assertThrows(IllegalArgumentException.class, () -> new Wortliste(new String[] {"FEU3R"}));
assertThrows(IllegalArgumentException.class, () -> new Wortliste(new String[0]));
}
}

Dazu kommen zwei Tests in SpielTest („Mit Wortliste werden nur bekannte Wörter angenommen“, „Mit Wortliste muss auch die Lösung in der Liste stehen“) und einer in LokalerSpielDienstTest („Ein Dienst mit Wortliste nimmt nur bekannte Wörter an“).

Lösung
SpielTest.java
package de.drv.wordle;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class SpielTest {
@Test
@DisplayName("Ein neues Spiel läuft und hat noch keine Versuche")
void neuesSpiel() {
Spiel spiel = new Spiel("FEUER");
assertEquals(Status.LAEUFT, spiel.getStatus());
assertEquals(0, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Ein Versuch liefert seine Bewertung und wird gezählt")
void versuch() {
Spiel spiel = new Spiel("FEUER");
assertEquals(new Bewertung("ADIEU", "---+?"), spiel.rate("ADIEU"));
assertEquals(1, spiel.getAnzahlVersuche());
assertEquals(Status.LAEUFT, spiel.getStatus());
}
@Test
@DisplayName("Wer das Wort errät, gewinnt")
void gewonnen() {
Spiel spiel = new Spiel("FEUER");
spiel.rate("ADIEU");
spiel.rate("FEUER");
assertEquals(Status.GEWONNEN, spiel.getStatus());
assertEquals(2, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Nach sechs Fehlversuchen ist das Spiel verloren")
void verloren() {
Spiel spiel = new Spiel("FEUER");
for (int i = 0; i < Spiel.MAX_VERSUCHE; i++) {
spiel.rate("ADIEU");
}
assertEquals(Status.VERLOREN, spiel.getStatus());
}
@Test
@DisplayName("Ein Treffer im letzten Versuch gewinnt noch")
void gewonnenImLetztenVersuch() {
Spiel spiel = new Spiel("FEUER");
for (int i = 0; i < Spiel.MAX_VERSUCHE - 1; i++) {
spiel.rate("ADIEU");
}
spiel.rate("FEUER");
assertEquals(Status.GEWONNEN, spiel.getStatus());
}
@Test
@DisplayName("Nach Spielende kann nicht weiter geraten werden")
void keinVersuchNachSpielende() {
Spiel spiel = new Spiel("FEUER");
spiel.rate("FEUER");
assertThrows(IllegalStateException.class, () -> spiel.rate("ADIEU"));
assertEquals(1, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Die Lösung wird erst nach Spielende verraten")
void aufloesung() {
Spiel spiel = new Spiel("FEUER");
assertThrows(IllegalStateException.class, () -> spiel.getAufloesung());
for (int i = 0; i < Spiel.MAX_VERSUCHE; i++) {
spiel.rate("ADIEU");
}
assertEquals("FEUER", spiel.getAufloesung());
}
@Test
@DisplayName("Eine Lösung mit falscher Länge wird abgelehnt")
void falscheLoesung() {
assertThrows(IllegalArgumentException.class, () -> new Spiel("HALLOO"));
}
@Test
@DisplayName("Eingaben werden bereinigt und großgeschrieben")
void eingabeBereinigt() {
Spiel spiel = new Spiel("FEUER");
assertEquals(new Bewertung("ADIEU", "---+?"), spiel.rate(" adieu "));
spiel.rate("feuer");
assertEquals(Status.GEWONNEN, spiel.getStatus());
}
@Test
@DisplayName("Ein Versuch mit falscher Länge wird abgelehnt und nicht gezählt")
void falscheLaenge() {
Spiel spiel = new Spiel("FEUER");
assertThrows(IllegalArgumentException.class, () -> spiel.rate("HAL"));
assertEquals(0, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Ein Versuch mit anderen Zeichen als Buchstaben wird abgelehnt")
void keineBuchstaben() {
Spiel spiel = new Spiel("FEUER");
assertThrows(IllegalArgumentException.class, () -> spiel.rate("FEU3R"));
assertThrows(IllegalArgumentException.class, () -> spiel.rate("FE ER"));
assertEquals(0, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Mit Wortliste werden nur bekannte Wörter angenommen")
void nurBekannteWoerter() {
Spiel spiel = new Spiel("FEUER", Wortliste.DEUTSCH);
assertThrows(IllegalArgumentException.class, () -> spiel.rate("XYZQW"));
assertEquals(0, spiel.getAnzahlVersuche());
assertEquals(new Bewertung("ADIEU", "---+?"), spiel.rate("adieu"));
assertEquals(1, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Mit Wortliste muss auch die Lösung in der Liste stehen")
void loesungInDerListe() {
assertThrows(IllegalArgumentException.class, () -> new Spiel("XYZQW", Wortliste.DEUTSCH));
}
}
  1. Das beste Startwort: Zähle, wie oft jeder Buchstabe in allen 1650 Wörtern vorkommt – mit einem int[26], so wie bei der Würfelstatistik im Kapitel Arrays. Gib für jedes Wort eine Punktzahl: die Summe der Häufigkeiten seiner verschiedenen Buchstaben. Welches Wort hat die meisten Punkte?

    Lösung

    Der häufigste Buchstabe ist mit großem Abstand das E (1465-mal), danach T, A, R und N. Die meisten Punkte haben gleichauf ARTEN und RATEN (3923) – das Programm nennt das erste, das es findet.

    Der Trick für „verschiedene Buchstaben“: wort.indexOf(buchstabe) == i ist nur beim ersten Vorkommen eines Buchstabens wahr. Und buchstabe - 'A' macht aus einem Buchstaben einen Index von 0 bis 25.

    Startwort.java
    package de.drv.wordle;
    public class Startwort {
    public static void main(String[] args) {
    String[] woerter = DeutscheWoerter.WOERTER;
    int[] haeufigkeit = new int[26];
    for (String wort : woerter) {
    for (int i = 0; i < wort.length(); i++) {
    haeufigkeit[wort.charAt(i) - 'A']++;
    }
    }
    for (char buchstabe = 'A'; buchstabe <= 'Z'; buchstabe++) {
    System.out.printf("%c %4d%n", buchstabe, haeufigkeit[buchstabe - 'A']);
    }
    String bestes = null;
    int bestePunkte = -1;
    for (String wort : woerter) {
    int punkte = 0;
    for (int i = 0; i < wort.length(); i++) {
    char buchstabe = wort.charAt(i);
    if (wort.indexOf(buchstabe) == i) {
    punkte += haeufigkeit[buchstabe - 'A'];
    }
    }
    if (punkte > bestePunkte) {
    bestePunkte = punkte;
    bestes = wort;
    }
    }
    System.out.println("Bestes Startwort: " + bestes + " (" + bestePunkte + " Punkte)");
    }
    }
  2. Wie viele Vergleiche bräuchte eine einfache Schleife im schlimmsten Fall, um festzustellen, dass XYZQW nicht in der Liste steht? Und binarySearch?

    Lösung

    Die Schleife muss alle 1650 Wörter ansehen. binarySearch halbiert bei jedem Schritt: 1650, 825, 413, 207, 104, 52, 26, 13, 7, 4, 2, 1 – nach höchstens 11 Vergleichen steht das Ergebnis fest.