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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- eine Wortliste als eigene Klasse bauen, die den Vertrag
Wortquelleerfüllt - in einem sortierten Array mit
Arrays.binarySearchsuchen - eine Klasse erweitern, ohne bestehenden Code zu brechen
Ausgangsstand für wordle
⤓ wordle-6.zip herunterladenWer 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.
Die Wörter
Abschnitt betitelt „Die Wörter“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.wordlesichtbar. Benutzen soll sie nur dieWortliste. - Der Konstruktor ist
private– von dieser Klasse soll niemand ein Objekt erzeugen. Sie ist nur ein Behälter für das Array.
Die Klasse Wortliste
Abschnitt betitelt „Die Klasse Wortliste“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:
- 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. enthaeltfindet ein Wort unabhängig von Groß- und Kleinschreibung und Leerzeichen am Rand.nullist nie enthalten.naechstesWortliefert ein zufälliges Wort der Liste. Damit erfüllt die Wortliste den VertragWortquelle– und kann überall eingesetzt werden, wo bisher dieFesteWortquellestand.DEUTSCHist eine fertige Wortliste mit den Wörtern ausDeutscheWoerter.
Schnell suchen: Arrays.binarySearch
Abschnitt betitelt „Schnell suchen: Arrays.binarySearch“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.
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; }
}Nur bekannte Wörter raten
Abschnitt betitelt „Nur bekannte Wörter raten“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:
/** 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:
if (erlaubteWoerter != null && !erlaubteWoerter.enthaelt(wort)) { throw new IllegalArgumentException("Dieses Wort kenne ich nicht: " + wort);}- Der alte Konstruktor bleibt und ruft den neuen mit
nullauf: „keine Wortliste – jedes Wort erlaubt“. Deshalb laufen alle bisherigen Tests unverändert weiter, auch der mitAAAAA. - 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:
public LokalerSpielDienst(Wortquelle wortquelle, Wortliste erlaubteWoerter) { // …}
@Overridepublic String neuesSpiel() { String id = UUID.randomUUID().toString(); spiele.put(id, new Spiel(wortquelle.naechstesWort(), erlaubteWoerter)); return id;}Lösung
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
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; }
}Und die Konsole?
Abschnitt betitelt „Und die Konsole?“In WordleStart ändern sich zwei Zeilen:
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.
Versuch 1/6: xyzqwDieses Wort kenne ich nicht: XYZQWVersuch 1/6: adieu A D I E UDie Tests
Abschnitt betitelt „Die Tests“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
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)); }
}Übungen
Abschnitt betitelt „Übungen“-
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) == iist nur beim ersten Vorkommen eines Buchstabens wahr. Undbuchstabe - '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)");}} -
Wie viele Vergleiche bräuchte eine einfache Schleife im schlimmsten Fall, um festzustellen, dass
XYZQWnicht in der Liste steht? UndbinarySearch?Lösung
Die Schleife muss alle 1650 Wörter ansehen.
binarySearchhalbiert bei jedem Schritt: 1650, 825, 413, 207, 104, 52, 26, 13, 7, 4, 2, 1 – nach höchstens 11 Vergleichen steht das Ergebnis fest.