wordle4.py

"""
Computer plays wordle (semi-strategic guessing).

:author:  Terry Sergeant
:version: 4

In this version the computer picks its first word: "lares" based on
pre-processing.  This will typically leave less than 300 possible words
remaining. Words having the form: _a__s or ___es are especially troublesome and
tend to result in lots of guesses when guesses are selected randomly.  So, the
pre-computed word "compt" was found to be a reasonably optimal second guess for
these difficult words. NOTE: compt was optimal for words matching _a_es

For other situations if the number of remaining words is more than 100 then we
make a random selection. Otherwise we perform an optimal calculation.
"""

import random
import re
from colorama import Fore, Back, Style

def is_possible(word, result):
    """
    Determine whether a word is possible based on guesses made so far
    and the partial word provided by the user.

    :param word: The word we are considering as a possible match.
    :param result: A dictionary that stores the guess and the grade.
    :returns: True if the word is a possible match; False otherwise.
    """
    guesslist = list(result['guess'])
    gradelist = list(result['grade'])
    wordlist = list(word)

    # if perfect match letters don't line up then its not a match
    for i in range(len(word)):
        if gradelist[i] == '2':
            if guesslist[i] != word[i]:
                return False
            else:
                # remove letters that are a perfect match
                wordlist[i] = '!'
                guesslist[i] = '@'

    for i in range(len(word)):
        if gradelist[i] == '1':
            # right letter, wrong position -> if its there mark it out, if not
            # return False. If it is in the same spot return False.
            if guesslist[i] == wordlist[i]:
                return False
            if not (guesslist[i] in wordlist):
                return False

            for j in range(len(word)):
                if guesslist[i] == wordlist[j]:
                    guesslist[i] = '@'
                    wordlist[j] = '!'
                    break
        elif gradelist[i] != '*':
            # we guessed wrong letter completely so it shouldn't be left in the word
            if guesslist[i] in wordlist:
                return False

    return word != guess  # true unless the word matches our guessed word



def reduce_word_list(wordlist, result):
    """
    Narrow down list of possible choices.

    :param wordlist: List of words that are still considered possibilities.
    :param result: A dictionary that stores the guess and the grade.
    :returns: Modified and shortened word_list.
    """
    newwordlist = [w for w in wordlist if is_possible(w, result)]
    #print("My mega-intelligence has reduced the options to " + str(len(newwordlist)) + " words.")
    return newwordlist


def load_dictionary(filename):
    """
    Read the dictionary from the file and return the words as a list and
    as a hash of boolean values.

    :param filename: The file containing the official dictionary.
    :returns: wordlist, wordhash

    NOTE: The wordhash isn't really necessary in this version of the code, but will
    be useful when dealing with a user who might guess a word not in the dictionary.
    """
    wordlist = []
    wordhash = {}
    with open(filename) as f:
        for word in f:
            wordlist.append(word.rstrip())
            wordhash[word.rstrip()] = True

    print("Dictionary contains "+str(len(wordlist))+" words.")
    return wordlist, wordhash




def get_random_guess(wordlist):
    """
    Randomly select a word from the list of words.

    :param wordlist: The list of words currently being considered.
    :returns: A randomly selected word from the list.
    """
    return wordlist[random.randint(0,len(wordlist)-1)]


def grade_word(answer, guess, wordhash, possible_letters):
    """
    Grades the guess by comparing it to the correct answer.

    :param answer: The answer word the computer is trying to guess.
    :param guess: The guessed word to be graded.
    :param wordhash: A hash of the original dictionary words in order to verify
        that the guess is valid.
    :returns: False if guess is not in the dictionary; otherwise returns a dictionary
        containing the original guess and the grade string.

    NOTE: The grade string contains 5 characters as follows:
     * there is a 2 if the correct letter is used in the correct place
     * there is a 1 if the correct letter is used in the wrong place
     * the original guessed letter is used if the letter does not occur in the answer
    """
    if not (guess in wordhash):
        print("The word '" + guess + "' is not in the dictionary file")
        return false

    answerlist= list(answer)
    guesslist= list(guess)

    for i in range(len(answer)):
        if answerlist[i] == guesslist[i]:
            guesslist[i] = '2'
            answerlist[i] = 0

    for i in range(len(answer)):
        for j in range(len(answer)):
            if answerlist[i] == guesslist[j]:
                guesslist[j] = '1'
                answerlist[i] = 0

    for i in range(len(guess)):
        if guesslist[j] > '2':
            possible_letters[ord(guesslist[j])-97] = False

    return {
        "guess": guess,
        "grade": "".join(guesslist),
        "possible" : possible_letters
    }



def show_grade(result):
    """
    Displays a graded guess using traditional color coding.

    :param result: A dictionary that stores the guess and the grade.

    Colors are:
     * text is white
     * green background if the correct letter is used in the correct place
     * yellow background if the correct letter is used in the wrong place
     * black background if the letter does not occur in the answer
    """
    print(Fore.WHITE)
    for i in range(len(result['guess'])):
        if result['grade'][i] == '2':
            print(Back.GREEN + result['guess'][i], end='')
        elif result['grade'][i] == '1':
            print(Back.YELLOW+ result['guess'][i], end='')
        else:
            print(Back.BLACK + result['guess'][i], end='')
    print(Style.RESET_ALL)



def get_best_guess(allwords, possiblewords, wordhash, orig_possible_letters, is_hard_word):
    """
    Select a word from allwords that will on average reduce the number of
    possiblewords the most. We don't allow repeated letters to improve a score.

    :param allwords: The complete list of dictionary words.
    :param possiblewords: The words that have not yet been eliminated based
        one previous guesses.
    :param wordhash: A hash of possible words.
    :orig_possible_letters: A list of letters that are possible based on previous guesses.
    :is_hard_word: This value is true if the guess count is 1 and the grade was: .2.22

    :returns: The "best" next guess.
    """
    if len(possiblewords) < 3:
        return possiblewords[0]
    if is_hard_word:
        return "compt"
    if len(possiblewords) > 100:
        return get_random_guess(possiblewords)
    bestword = "false"
    bestscore = 20000000
    print(possiblewords)
    for guess in allwords:
        total = 0
        for answer in possiblewords:
            possible_letters = orig_possible_letters.copy()
            result = grade_word(answer, guess, wordhash, possible_letters)
            lst = reduce_word_list(wordlist, result)
            total += len(lst)

        if total < bestscore:
            bestword = guess
            bestscore = total

    print(bestword + " is best word to guess with score of " +
            str(bestscore / len(possiblewords)))

    return bestword




#-------------------------------------------------------------------------------------

random.seed()
possible_letters = [True] * 26

origlist, wordhash = load_dictionary("dictionary.txt")
wordlist, wordhash = load_dictionary("dictionary.txt")

# We use the precalculated "optimal" guess lares as first guess
answer = get_random_guess(wordlist)
#answer = "bibes"
guess = "lares"
result = grade_word(answer, guess, wordhash, possible_letters)
possible_letters = result["possible"]
show_grade(result)
count = 1


while result['grade'] != '22222':
    wordlist = reduce_word_list(wordlist, result)
    print("List reduced to: " + str(len(wordlist)))
    is_hard_word = count == 1 and ((result["grade"][1]=='2' and
            result["grade"][4]=='2') or (result["grade"][3] == '2'
            and result["grade"][4] == '2'))
    guess = get_best_guess(origlist, wordlist, wordhash, possible_letters, is_hard_word)
    result = grade_word(answer, guess, wordhash, possible_letters)
    possible_letters = result["possible"]
    show_grade(result)
    count += 1

print(answer + " solved in " + str(count) + " guesses")