Remove the RxJava dependency, unused instructions file & Update tests

thibault2705 · thibault2705 · commit bad3db325f72 · 2026-04-28T12:50:19.000-06:00
diff --git a/exercises/practice/hangman/.docs/instructions.append.md b/exercises/practice/hangman/.docs/instructions.append.md
diff --git a/exercises/practice/hangman/.meta/src/reference/java/Hangman.java b/exercises/practice/hangman/.meta/src/reference/java/Hangman.java
@@ -1,37 +1,29 @@
-import io.reactivex.Observable;
-
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
 class Hangman {
 
-    Observable<Output> guess(
-            String word,
-            Observable<String> letters) {
-        return letters
-                .startWith("")
-                .scan(Output.empty(), (state, letter) -> {
-                    if (state == null || state.state == null) {
-                        return createNewGame(word);
-                    }
-
-                    if (letter.isEmpty()) {
-                        return state;
-                    }
-
-                    if (state.state == Status.WIN) {
-                        throw new IllegalStateException("cannot guess after the game is won");
-                    }
-
-                    if (state.state == Status.LOSE) {
-                        throw new IllegalStateException("cannot guess after the game is lost");
-                    }
-
-                    return processNewLetter(state, letter);
-                })
-                .skip(1);
+    Output guess(
+        String word,
+        List<String> letters) {
+
+        Output state = createNewGame(word);
+
+        for (String letter : letters) {
+            if (state.state == Status.WIN) {
+                throw new IllegalStateException("cannot guess after the game is won");
+            }
+
+            if (state.state == Status.LOSE) {
+                throw new IllegalStateException("cannot guess after the game is lost");
+            }
+
+            state = processNewLetter(state, letter);
+        }
+
+        return state;
     }
 
     private static Output createNewGame(String word) {
@@ -58,12 +50,12 @@ private static Output processCorrectGuess(Output state, String letter) {
         Status newStatus = Output.isWin(state.word, newGuesses) ? Status.WIN : Status.ON_GOING;
 
         return new Output(
-                state.word,
-                discovered,
-                newGuesses,
-                state.misses,
-                state.parts,
-                newStatus);
+            state.word,
+            discovered,
+            newGuesses,
+            state.misses,
+            state.parts,
+            newStatus);
     }
 
     private static Output processIncorrectGuess(Output state, String letter) {
@@ -78,12 +70,12 @@ private static Output processIncorrectGuess(Output state, String letter) {
         Status newStatus = newParts.size() >= order.length ? Status.LOSE : Status.ON_GOING;
 
         return new Output(
-                state.word,
-                state.maskedWord,
-                state.guesses,
-                newMisses,
-                newParts,
-                newStatus);
+            state.word,
+            state.maskedWord,
+            state.guesses,
+            newMisses,
+            newParts,
+            newStatus);
     }
 
     static Part[] order = Part.values();
diff --git a/exercises/practice/hangman/.meta/src/reference/java/Output.java b/exercises/practice/hangman/.meta/src/reference/java/Output.java
@@ -19,12 +19,12 @@ class Output {
     public final int remainingFailures;
 
     Output(
-            final String word,
-            final String maskedWord,
-            final Set<String> guesses,
-            final Set<String> misses,
-            final List<Part> parts,
-            final Status state) {
+        final String word,
+        final String maskedWord,
+        final Set<String> guesses,
+        final Set<String> misses,
+        final List<Part> parts,
+        final Status state) {
         this.word = word;
         this.maskedWord = maskedWord;
         this.guesses = Set.copyOf(guesses);
@@ -36,22 +36,22 @@ class Output {
 
     static Output empty() {
         return new Output(
-                null,
-                null,
-                Collections.emptySet(),
-                Collections.emptySet(),
-                Collections.emptyList(),
-                null);
+            null,
+            null,
+            Collections.emptySet(),
+            Collections.emptySet(),
+            Collections.emptyList(),
+            null);
     }
 
     static Output initialState(final String secret) {
         return new Output(
-                secret,
-                getGuessedWord(secret, Collections.emptySet()),
-                new LinkedHashSet<>(),
-                new LinkedHashSet<>(),
-                new ArrayList<>(),
-                Status.ON_GOING);
+            secret,
+            getGuessedWord(secret, Collections.emptySet()),
+            new LinkedHashSet<>(),
+            new LinkedHashSet<>(),
+            new ArrayList<>(),
+            Status.ON_GOING);
     }
 
     boolean isLetterAlreadyPlayed(final String letter) {
@@ -64,15 +64,15 @@ boolean isLetterInSecret(final String letter) {
 
     static String getGuessedWord(String secret, Set<String> letters) {
         return secret.chars()
-                .mapToObj(i -> String.valueOf((char) i))
-                .map(c -> letters.contains(c) ? c : "_")
-                .collect(joining());
+            .mapToObj(i -> String.valueOf((char) i))
+            .map(c -> letters.contains(c) ? c : "_")
+            .collect(joining());
     }
 
     static boolean isWin(String secret, Set<String> guessedLetters) {
         return secret.chars()
-                .mapToObj(i -> String.valueOf((char) i))
-                .allMatch(guessedLetters::contains);
+            .mapToObj(i -> String.valueOf((char) i))
+            .allMatch(guessedLetters::contains);
     }
 
     static boolean isLoss(List<Part> parts) {
@@ -82,13 +82,13 @@ static boolean isLoss(List<Part> parts) {
     @Override
     public String toString() {
         return "Output{" +
-                "secret='" + word + '\'' +
-                ", discovered='" + maskedWord + '\'' +
-                ", guess=" + guesses +
-                ", misses=" + misses +
-                ", parts=" + parts +
-                ", status=" + state +
-                ", remainingFailures=" + remainingFailures +
-                '}';
+            "secret='" + word + '\'' +
+            ", discovered='" + maskedWord + '\'' +
+            ", guess=" + guesses +
+            ", misses=" + misses +
+            ", parts=" + parts +
+            ", status=" + state +
+            ", remainingFailures=" + remainingFailures +
+            '}';
     }
 }
diff --git a/exercises/practice/hangman/src/main/java/Hangman.java b/exercises/practice/hangman/src/main/java/Hangman.java
@@ -1,8 +1,8 @@
-import io.reactivex.Observable;
+import java.util.List;
 
 class Hangman {
 
-    Observable<Output> guess(String word, Observable<String> letters) {
+    Output guess(String word, List<String> letters) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
diff --git a/exercises/practice/hangman/src/test/java/HangmanTest.java b/exercises/practice/hangman/src/test/java/HangmanTest.java
@@ -1,10 +1,10 @@
-import io.reactivex.Observable;
-
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -20,9 +20,7 @@ public void init() {
     @Test
     @DisplayName("Initially 9 failures are allowed and no letters are guessed")
     void initially9FailuresAreAllowedAndNoLettersAreGuessed() {
-        Output result = hangman
-                .guess("loot", Observable.empty())
-                .blockingLast();
+        Output result = hangman.guess("loot", List.of());
 
         assertEquals(Status.ON_GOING, result.state);
         assertEquals("____", result.maskedWord);
@@ -33,9 +31,10 @@ void initially9FailuresAreAllowedAndNoLettersAreGuessed() {
     @Test
     @DisplayName("After 10 failures the game is over")
     void after10FailuresTheGameIsOver() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"))
-                .blockingLast();
+        Output result = hangman.guess(
+            "loot",
+            List.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j")
+        );
 
         assertEquals(Status.LOSE, result.state);
         assertEquals("____", result.maskedWord);
@@ -46,9 +45,10 @@ void after10FailuresTheGameIsOver() {
     @Test
     @DisplayName("Losing with several correct guesses")
     void losingWithSeveralCorrectGuesses() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("t", "o", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j"))
-                .blockingLast();
+        Output result = hangman.guess(
+            "loot",
+            List.of("t", "o", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j")
+        );
 
         assertEquals(Status.LOSE, result.state);
         assertEquals("_oot", result.maskedWord);
@@ -59,9 +59,7 @@ void losingWithSeveralCorrectGuesses() {
     @Test
     @DisplayName("Feeding a correct letter removes underscores")
     void feedingCorrectLetterRemovesUnderscores() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("t"))
-                .blockingLast();
+        Output result = hangman.guess("loot", List.of("t"));
 
         assertEquals(Status.ON_GOING, result.state);
         assertEquals("___t", result.maskedWord);
@@ -72,9 +70,7 @@ void feedingCorrectLetterRemovesUnderscores() {
     @Test
     @DisplayName("Feeding a correct letter twice counts as a failure")
     void feedingCorrectLetterTwiceCountAsASuccess() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("t", "t"))
-                .blockingLast();
+        Output result = hangman.guess("loot", List.of("t", "t"));
 
         assertEquals(Status.ON_GOING, result.state);
         assertEquals("___t", result.maskedWord);
@@ -85,9 +81,7 @@ void feedingCorrectLetterTwiceCountAsASuccess() {
     @Test
     @DisplayName("Guessing a repeated letter reveals all instances")
     void guessingARepeatedLetterRevealsAllInstances() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("t", "t", "o"))
-                .blockingLast();
+        Output result = hangman.guess("loot", List.of("t", "t", "o"));
 
         assertEquals(Status.ON_GOING, result.state);
         assertEquals("_oot", result.maskedWord);
@@ -98,9 +92,7 @@ void guessingARepeatedLetterRevealsAllInstances() {
     @Test
     @DisplayName("Getting all the letters right makes for a win")
     void gettingAllTheLettersRightMakesForASuccess() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("t", "t", "o", "l"))
-                .blockingLast();
+        Output result = hangman.guess("loot", List.of("t", "t", "o", "l"));
 
         assertEquals(Status.WIN, result.state);
         assertEquals("loot", result.maskedWord);
@@ -111,9 +103,10 @@ void gettingAllTheLettersRightMakesForASuccess() {
     @Test
     @DisplayName("Winning on the last guess is still a win")
     void winningOnTheLastGuessIsStillAWin() {
-        Output result = hangman
-                .guess("loot", Observable.fromArray("a", "b", "c", "d", "e", "f", "g", "h", "i", "t", "o", "l"))
-                .blockingLast();
+        Output result = hangman.guess(
+            "loot",
+            List.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "t", "o", "l")
+        );
 
         assertEquals(Status.WIN, result.state);
         assertEquals("loot", result.maskedWord);
@@ -125,10 +118,11 @@ void winningOnTheLastGuessIsStillAWin() {
     @DisplayName("Guessing after a lose is error")
     void guessingAfterALoseIsError() {
         IllegalStateException ex = assertThrows(
-                IllegalStateException.class,
-                () -> hangman
-                        .guess("loot", Observable.fromArray("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"))
-                        .blockingLast()
+            IllegalStateException.class,
+            () -> hangman.guess(
+                "loot",
+                List.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k")
+            )
         );
 
         assertEquals("cannot guess after the game is lost", ex.getMessage());
@@ -139,12 +133,10 @@ void guessingAfterALoseIsError() {
     @DisplayName("Guessing after a win is error")
     void guessingAfterAWinIsError() {
         IllegalStateException ex = assertThrows(
-                IllegalStateException.class,
-                () -> hangman
-                        .guess("loot", Observable.fromArray("t", "o", "l", "l"))
-                        .blockingLast()
+            IllegalStateException.class,
+            () -> hangman.guess("loot", List.of("t", "o", "l", "l"))
         );
 
         assertEquals("cannot guess after the game is won", ex.getMessage());
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`		`-import io.reactivex.Observable;`
	`1`	`+import java.util.List;`
`2`	`2`
`3`	`3`	`class Hangman {`
`4`	`4`
`5`		`- Observable<Output> guess(String word, Observable<String> letters) {`
	`5`	`+ Output guess(String word, List<String> letters) {`
`6`	`6`	`throw new UnsupportedOperationException("Delete this statement and write your own implementation.");`
`7`	`7`	`}`
`8`	`8`