Game — Wordle-Lite · Part 2 (Feedback Logic)

By the end of this lesson you can:

• Write a feedback(secret, guess) function that returns a list of "G" / "Y" / "." codes.
• Handle the duplicate-letter trap correctly — guessing llama against balls should only flag one 'l'.
• Pretty-print the feedback under each guess using brackets and dots.
• Wire it into a six-guess game loop using your Part-1 word bank loader.

Let's nail down the rules with concrete examples. Secret = peach.

Guess: place
   p  → G  (peach starts with p too)
   l  → .  (not in peach)
   a  → G  (peach[2] is 'a' too)
   c  → G  (peach[3] is 'c' too)
   e  → Y  (e IS in peach — at index 1, not 4)

Three greens, one yellow, one grey. So far so good.

Now the trap. Secret = balls. Guess = llama.

Naive logic (wrong!)
   l → Y   (l is in balls)
   l → Y   (l is in balls — count it again!)
   a → Y   (a is in balls)
   m → .
   a → Y   (a is in balls — count it again!)

Correct logic
   l → Y   (one yellow l)
   l → .   (second l — balls only has TWO l's, but we already marked one)
            Actually balls has 2 l's, so this is also Y? No — the
            two l's in the guess match the two l's in the secret, but
            neither is in the right *position*, so it depends on order.

   The rule: every secret letter can only be "consumed" once.

The fix is a two-pass algorithm: first mark all the greens (and consume those secret letters), then go back and mark yellows from the leftovers. Let's write it.

The result codes

G   green   — right letter, right place
Y   yellow  — right letter, wrong place
.   grey    — not in the word (or already accounted for)

The function returns a list of five codes — one per guess letter — so the calling code can colour-print or score.

Pass 1 — Greens

Walk both strings position by position. If guess[i] == secret[i], mark G. Remember to cross off that secret letter so a future yellow can't match it again. We'll keep a list of "leftover" letters from the secret to track that.

def feedback(secret, guess):
    result    = ["."] * 5             # start as all grey
    remaining = list(secret)           # leftover letters from the secret

    # Pass 1 — mark greens
    for i in range(5):
        if guess[i] == secret[i]:
            result[i]    = "G"
            remaining[i] = None        # crossed off
    return result, remaining           # we'll keep going below

The remaining[i] = None step is the trick. We don't just remove from the list (positions matter); we replace with None so the index still aligns.

Pass 2 — Yellows

Walk the guess again. For each non-green letter, check if it appears anywhere in the still-uncrossed leftovers. If yes, mark Y and cross that letter off.

    # Pass 2 — mark yellows
    for i in range(5):
        if result[i] == "G":
            continue                   # already done
        if guess[i] in remaining:
            result[i] = "Y"
            remaining[remaining.index(guess[i])] = None    # cross off ONE copy
    return result

remaining.index(x) returns the index of the first match. We replace just that one with None — so each secret letter can only be consumed once.

The full function

def feedback(secret, guess):
    if len(guess) != 5:
        return None                    # signal "invalid guess"

    result    = ["."] * 5
    remaining = list(secret)

    for i in range(5):
        if guess[i] == secret[i]:
            result[i]    = "G"
            remaining[i] = None

    for i in range(5):
        if result[i] == "G":
            continue
        if guess[i] in remaining:
            result[i] = "Y"
            remaining[remaining.index(guess[i])] = None

    return result

Quick sanity tests

print(feedback("peach", "place"))
# → ['G', '.', 'G', 'G', 'Y']

print(feedback("balls", "llama"))
# → ['Y', 'Y', '.', '.', '.']
#       ^  ^
#       both 'l's score against balls' two l's. The 'a' is also
#       eaten by the green-pass-not-applicable / yellow-pass rule.

print(feedback("peach", "peach"))
# → ['G', 'G', 'G', 'G', 'G']

Save as wordle_part2.py. Pair the new feedback function with Part 1's loader to play one round.

Code

# wordle_part2.py — load + feedback + guess loop

import random

def load_word_bank(path):
    with open(path, encoding="utf-8") as f:
        return [line.strip().lower() for line in f if line.strip()]

def validate(bank):
    return [w for w in bank if len(w) != 5 or not w.isalpha()]

def feedback(secret, guess):
    if len(guess) != 5:
        return None
    result    = ["."] * 5
    remaining = list(secret)
    for i in range(5):
        if guess[i] == secret[i]:
            result[i] = "G"
            remaining[i] = None
    for i in range(5):
        if result[i] == "G":
            continue
        if guess[i] in remaining:
            result[i] = "Y"
            remaining[remaining.index(guess[i])] = None
    return result

def show(guess, result):
    # Print each letter inside [ ] for greens, ( ) for yellows, plain dot for misses
    line = []
    for letter, mark in zip(guess, result):
        if mark == "G":
            line.append(f"[{letter.upper()}]")
        elif mark == "Y":
            line.append(f"({letter})")
        else:
            line.append(" . ")
    print(" ".join(line))

# --- main game ---

bank = load_word_bank("wordbank.txt")
if validate(bank):
    print("Word bank has invalid entries — fix wordbank.txt first.")
    raise SystemExit

secret = random.choice(bank)
print("Welcome to Wordle-Lite. Six guesses. Good luck!\n")

for turn in range(1, 7):
    guess = input(f"Guess #{turn}: ").strip().lower()

    if len(guess) != 5 or not guess.isalpha():
        print("  ! Must be 5 letters, alphabetical.")
        continue

    if guess not in bank:
        print("  ! Not in word bank.")
        continue

    result = feedback(secret, guess)
    show(guess, result)

    if result == ["G"] * 5:
        print(f"\n🎉  Solved in {turn} guess(es)!")
        break
else:
    print(f"\n🪦  Out of guesses. Secret was: {secret.upper()}")

Sample play (secret was "peach")

Welcome to Wordle-Lite. Six guesses. Good luck!

Guess #1: place
[P]  .  [A] [C] (e)

Guess #2: peach
[P] [E] [A] [C] [H]

🎉  Solved in 2 guess(es)!

Read the diff

Three little design choices to spot. (1) show uses brackets and parens to colour without real terminal colours — works everywhere. (2) Invalid guesses (wrong length or not in the bank) don't consume a turn — we continue instead. (3) The for/else on the main loop fires only if the loop didn't break — the cleanest way to handle "out of guesses". We met for/else in PY-L1-12.

Wordle's feedback is a two-pass algorithm — greens first, then yellows from what's left. The duplicate-letter trap is handled by crossing off secret letters as we use them (replace with None in a leftover list, then check in and .index()). Wrap that single function in your Part-1 loader plus a six-turn loop and you have a complete word game. Tomorrow we polish the board with real colours, stats and a play-again loop.