Step 1: introduction

Following-on from 'Wordle 1: implementing the Wordle puzzle logic', in this worksheet your challenge is to implement a reverse game: where you choose the target word, and the computer is given up to six attempts to identify the word, with you marking the letters of each attempt as 'grey', 'yellow', or 'green' - using the 0, 1, and 2 keys, respectively. As in Wordle 1, you will start off with some working code that implements the presentation and user-interaction needed for the task.

Before we start, you need to understand the following points, which apply both to this implementation and also to the official online Wordle puzzle:

• This list of words that are accepted as valid attempt words, has over 15,000 words. Some of them are very obscure words that most people would not encounter in everyday usage.
• The list of words that may be set as target words is much shorter, and the words more widely known. Moreover, the list of target words specifically excludes well-known words that end in S or D where the first four letters would be a word in its own right, for example BEANS, CHEWS, or LOVED. These rules are worth knowing as a players, and are important to the program we are going to write.
• The official online Wordle puzzle offers a 'hard mode' (specified via the 'settings' button, which looks like a gear wheel). In hard mode, all your attempt words must be consistent with the marks awarded to previous attempts. Paradoxically, although hard mode can be harder for human players, it is slightly easier to write an automated solver that works in this way.

• Load the starting code and then immediately file > auto save the code to your local file storage, because you will be making changes and want to ensure that your changes are saved.
• We need to pick a word for the computer to solve and we'll start by picking STAGE.
• run the program. Note that the computer's first attempt is ARISE. For the target word (STAGE), the computer's first attempt should be marked: Yellow, Grey, Grey, Yellow, Green.
• To record those marks, type in 10012 - the same encoding that you used in the Wordle 1 project - remembering that you can use Backspace to correct a mistake. When you have all five letters coloured correctly, press Enter, at which point the computer will display its second attempt.

  What word has the computer picked for its second attempt?

• Similar to the Wordle 1 worksheet, the initial code correctly implements the presentation and user-interation for the reverse game, but lacks the core logic needed to pick the next attempt word - so it always guesses the same word!
• Look at the procedure playReverseGame, which starts at instruction 56. In instruction 58 a variable named attempt is initialised to the constant value "ARISE", but this variable is never thereafter set to a a different word. Given that the target word must of one of 2315 possible target, the computer has a chance of solving the puzzle within six attempts of just 1/2315.
• The first thing we will do is change the word with each attempt, to a random choice from all the possible target words. This still won't be a sensible strategy, and it will only marginally improve the chances of getting the target within six attempts, but it is just to gain some familiarity with the code. So...
• stop the program and insert a new instruction within the while loop in playReverseGame just before the end if. The new instruction should set attempt to a new word, randomly selected from possible - which is a List containing all 2,315 valid target words.

When you have implemented this change, run the program and check that it is using a different attempt word each time (though, as the attempt word is chosen at random, there is a small chance of repeating the same word). However, the likelihood that the computer gets to the target within the maximum six attempt is still very low. For the next step we need to implement a viable strategy.

Notes

Step 2: Start to implement a simple viable strategy

Human players use many different strategies to choose their next attempt word, based on the marks given for previous attempts. However, one of the simplest is to pick any new word that would be consistent with the marks given. In other words: if the word we choose as our next attempt were the target word, then our previous attempts would still have received the marks they did receive.

We could make that choice from any of the 15,000+ words in the list allValidAttemptWords, but we are going to select our next attempt from just the 2,315 allValidTargetWords as this should increase the chances of identifying the target. (Incidentally, by adopting this strategy we are actually playing Wordle in 'hard' mode.)

• To implement this strategy, after each attempt has been marked, we will filter the list held in the variable possible down to only those words that would still be consistent with the mark just given - so with each attempt the list will get smaller. This means that each new attempt will have an increased chance of bring the target word.
• At the bottom of the code you will see a 'ghosted' test named possibleTargetsAfterAttempt. Unghost this test - which will cause a compile error because there is not yet a function named possibleTargetsAfterAttempt.
• Write a 'stub' implementation of that new function, such that everything compiles.

Having written the stub implementaton of possibleTargetsAfterAttempt the tests will run. Each assert instruction defines a different 'test case'.

How many of the test cases are now passing, and what do they have in common?

Notes

Step 3: Completing the implementation

The next task is to implement possibleTargetsAfterAttempt such that all the associated test cases pass.

If you have learned about 'higher order functions', you can apply those techniques here and implement the function as a single instruction. However, the Hints below assume that that you will be implementing the code more conventionally, using a loop.

Before marking this step as completed, make sure that all the test cases are now passing.

Notes

Step 4: Making use of the filtered list of possible target words

Now that we have the ability to filter the list of possible target words based on each new marked attempt we can make use of that with the playReverseGame procedure.

Insert a new instruction immediately after instruction 69 i.e. just above the instruction that you added into the procedure earlier. This new instruction should set the list named possible to the new, filtered, list that results from evaluating the possibleTargetsAfterAttempt function, passing in suitable arguments.

Once you have implemented this change, you should be able to run the program. For the first run, mark the computer's attempts against the same target word that we used at the start of this worksheet: STAGE.

Does the computer get to the word within six attempts?

Now run the puzzle three more times - choosing a different target word in each case. Important: you can pick any well-known five letter word - provided that it is not a shorter word to which S or D has been appended (the official Wordle puzzle never sets such words as the target, either).

Record below the three target words that you selected and, in each case write down the number of attempts the computer took to solve the puzzle, or 'failed' if it did not solve it within six attempts.

QURSH is a real word, and may be used as an attempt word but it is not well-known and is never going to be set as a target word in the official game. If you pick this word (or one of many other disallowed target words), then this 'reverse player' will not be able to solve the puzzle. Try it.

What actually happens?

Notes

Step 5: Two small refinements

We will make these two small refinements in one go:

• Safely guard against an unsolvable puzzle - instead of it resulting in a run-time error as you saw.
• Instead of selecting the next attempt from possible randomly, just select the first possible word - so that the algorithm is 'deterministic' (repeatable).

So...

• Delete the following instruction (we'll replace it with something else, lower down): set attemptvariableName? to possible[randomInt(0, possible.length() - 1)]value or expression?0
• Within the playReverseGame procedure, after end if but before end while add a conditional instruction that tests whether there is at least one word in the latest filtered version of possible. If there is then set attempt to the first word in that list; if not then print the message "No possible target matches marks so far" and set attemptNo to 6 - the easiest way to end the program.

When you have completed these changes, run the program and test it: three times against different valid target words and once against QURSH or another very obscure 5-letter word.

Note that you might also the the message "No possible target matches marks so far" if you mark any attempts incorrectly.

Notes