Step 1: introduction

We are going to create a working implementation of the Wordle puzzle. If you have never previously solved a Wordle puzzle, you should visit the official Wordle site and solve today's puzzle, so you know how it works.

• 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.
• run the program. On the Display you will see a facsimile of the puzzle, and if you enter your first attempt (five letters - using Backspace if you make a mistake - then Enter) each letter will be marked green, yellow, or grey. But if you continue with further attempts you will quickly discover that it marks every attempt word with the same result! Though this program has correctly implemented the presentation, and the user interactions, of the official puzzle, it hasn't implemented the core logic of how attempts are marked.
• stop the program
• In the code, look at instruction number 12 - the markAttempt function. Comments within the function body state that the current implementation is just a 'stub' - the minimum code needed to allow the program to compile and run. It returns a five-character string, as expected: 2 for an 'in-place' match (green), 1 for an 'out-of-place' match (yellow), or 0 for no match (grey). But it always returns the same mark, paying no attention to the attempt word (your attempt) or the target word (selected by the computer but hidden from the user).
• Immediately following the markAttempt function you will see a test which has been 'ghosted'. Select the test and unghost (via the context menu). The tests will then run automatically.

  How many of the assert instructions within the test have failed?

In the markAttempt function, change the 'default' value to which the mark string is set, so that it returns a string of five zeros. Which, if any, of the assert instructions within the tests now pass?

Notes

Step 2: mark green matches correctly

• The function will need to set individual characters within the five-character mark string.
• You can access an individual character within a string by 'indexing'. Indexes start from 0. For example, you can access just the first character of a string held by the named value a with a[0].
• Given that you need to check each of the five character positions in turn, this suggests a loop. Think about which kind of loop is most suitable.
• Within the loop you will need a condition for testing whether there is a green match between the character in the attempt word and the target word.
• When there is a match you will need to change the mark (for just that character position) from a 0 to a 2. This is the trickiest part of this step, because String is an 'immutable' type in Elan (as it is in most programming languages): so you can't change its contents directly. Instead, you must build a new string out of parts of the original with necessary changes incorporated.
• Use 'index ranges' to help build this new string from parts of the original. If you are not familiar with 'index ranges': look them up in show in Help

Notes

Step 3: start on the yellow matches

• Underneath the for loop that you just created, create a second loop using the same values. (It might be tempting to try to process the greens and yellows within the same loop, but you would find that to be much more difficult in the end.) The new loop can use the same name for the counter, because the previous loop will already have finished using it.
• Within the new loop add an if instruction as before. For our first stab at this, use the condition that the target word contains the character of interest.
• If it does then set the corresponding character in mark using the same expression as in the previous (greens) loop, but setting the character to 1 instead of 2.
• This first stab should get most (but not all) of the 'Only yellows' cases passing. However, it will also have caused an unwanted consequence, which we will ask you to describe at the end of this step.

What is that unwanted consequence and why do you think this has happened? (Look at the individual cases in the tests).

We will fix this issue in the next step.

Notes

Step 4: mark the yellows without over-writing greens'

The problem is: letters that were marked green in the first loop are being 'overwritten' by a yellow. In the second loop we need to exclude any characters that have already been marked green. Attempt it now by modifying the if condition within the second loop. You should get all the 'Green only' cases passing again, and all except one of the 'Yellow only' cases.

Why is one of the 'Only yellows' cases still failing? (Look at what is different about that specific case)

We will address that failing test shortly, but first we are going to do a little bit of 'refactoring' - a hugely important practice when writing good code.

Notes

Step 5: factor-out common code into a separate function

Before moving on to dealing with the one remaining failure of the 'Only yellows' test cases, we going to deal with what professional developers call a 'code smell'! The two expressions that are used to update the mark are very similar: set markvariableName? to mark[..i] + "2" + mark[i + 1..]value or expression?0 set markvariableName? to mark[..i] + "1" + mark[i + 1..]value or expression?0 Applying the 'DRY' principle (Don't Repeat Yourself) we should extract this common code into a separate function. The two expressions aren't identical so we need to 'parameterise' the expression - passing just the part that differs as a parameter into the function.

• Create a new function named setChar that will set a specified character number, on a specified string, to a new specified character. As before, it won't actually modify the original string: it will return a new string, built from the original but with the specified differences. The function should define three parameters in the following order, using these names:
  • str - the string that you need to update
  • i - the character number (counting from zero) that you want to change
  • ch - the new character (a String that contains just one character) to put in place of the existing character
  Start by creating the function, defining the name, parameters, and return type. In the body of the function, provide a 'stub' implementation - by returning an empty string.
• Find the ghosted test setChar at the bottom of the file, and unghost it (via the context menu). Provided that your signature for the setChar function correct, your code should compile but all the newly-added test cases should fail.
• Your task is to implement setChar such that these tests all pass, and then to replace the two original expressions within markAttempt with evaluations of setChar, providing the correct arguments in each case.

We have now completed this refactoring and can return to further refining the markAttempt function to get more of the test cases passing.

Notes

Step 6: fix the remaining 'Only yellows' test

The 'Only yellows' test is still failing because the three Ps in the attempt word are all being matched against the single P in the target word, which is incorrect - just the first one should be marked as a yellow match. To fix this we need to ensure that the loop managing the yellow matches does not use a letter from the target word more than once.

• At the top of the function, just after the definition of the variable mark, define a new variable named unused initialised to the value of target.
• In the second loop (looking for yellow matches) change the condition so that instead of checking whether target contains the character of interest, it checks unused instead
• If a yellow match is found then, after updating mark, also update unused - replacing the just-used character with an empty space. (This part is slightly tricky: you need to find the location of the matching character within unused).

If you have implemented this step correctly, you should see that the last failing 'Only yellows' test case is now passing.

How many of the 'Mixed' test cases are now still failing? Can you figure out from the tests what they have in common?

You might wonder why we didn't also change target to unused in the first condition. It wouldn't matter if you made that change - try it.

Can you explain why that change - within the greens loop - doesn't make any difference, when it did make a difference within the yellows loop?

Notes

Step 7: Fix the remaining 'Mixed' test cases

Several of the 'Mixed' test cases are now passing as a result of fixing up the 'Greens only' and 'Yellows only' cases. If you look carefully you will see that for the remaining failures the function is wrongly re-using a character that has been marked green to match a different character as yellow. All we should need to do to fix this, is to ensure that whenever a green match is identified, that same character is also blanked out from unused.

Within the first loop, underneath the instruction that sets the mark, add a new instruction to set the same character number in unused to a single empty space. (The instruction to do this is slightly simpler than the one you have just added in the second loop.)

When you have completed this change, all the test cases for markAttempt should now be passing.

So if you now run the program again, it should work correctly. Each time you run it the computer picks a different target work - selected at random from the 2,315 valid target words.

Notes