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 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 attemptes 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 attemptes 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 automatically run a couple of seconds later.

  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 zeroes.

Which, if any, of the assert instructions within the tests now pass?

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

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, but 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 'Yellow only' 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.

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 exlude any characters that have already been marked green. Attempt it now by modifying the if condition within in 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 'Yellow only' cases still failing? (Look at what is different about the 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.

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 provding the correct arguments in each case.

Step 6: keep track of which letters in the target have been 'used' as greens

• To fix this we need to keep a tally of which letters in the target word have already been 'used'. The easiest way to do this would be to blank out a character in the target word as it is used. However target is a parameter, and Elan (deliberately) does not allow you to set a parameter within in a function - as this would be a 'side effect', which proper functions do not permit. Instead, at the top of the function - just below the existing definition of mark, define another variable named mark and initialise it to the value of target - because at the start of the function none of the letters has been used.
• Find the two places where target is currently referenced within the markAttempt function and edit them to refer to unused instead. You can make further use of the setChar that you wrote in the previous step.
• 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.

Has this fixed the failing 'Only yellows' test?

Has it fixed any other failing tests?

Step 7: get all remaining tests passing

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

If so, what else do you notice about the test results?