Wordle

import random as r
import pandas as pd
import numpy as np
from collections import Counter
from itertools import chain
pd.options.mode.chained_assignment = None  # default='warn'

threshold = 0.1 # word probability at which robot will guess actual answers instead of information seek

#words = ['forms', 'moist', 'proxy', 'witch', 'point', 'bikes', 'lemon', 'piked', 'spike', 'wipes', 'swipe', 'frank', 'clown']
words = []
with open("wordle_library.txt", "r") as f:
    for line in f:
        words.append(line.strip())

answers = []
with open("wordle_answers.txt", "r") as g:
    for line in g:
        answers.append(line.strip())

library = pd.DataFrame(words, columns=['word'])

def score_table():
    i = library
    i["guess_value"] = ""
    i["answer_prob"] = ""
    return i

def guesses_table():
    i = pd.DataFrame(columns=['guess', '1', '2', '3', '4', '5'])
    return i

def pick_word(a = answers):
    i = r.randint(0, len(a)-1)
    return a

def guess_word(guess, comparison):
    output = [guess]

    for l in range(0, 5):
        if guess
 == comparison
:
            output.append('rp')
        elif guess
 in comparison:
            output.append('r')
        else:
            output.append('n')
    return output

def update_letter_weights(word_list):

    letter_counts = pd.DataFrame.from_dict(Counter(chain.from_iterable(word_list['word'])), orient='index').reset_index()
    letter_counts = letter_counts.rename(columns={'index': 'letter', 0: 'count'})
    letter_counts['weight'] = letter_counts.apply(lambda x: x['count']/letter_counts['count'].sum(), axis=1)

    return letter_counts

def guess_value(word, letters):
    w = 0
    unique_letters = list(set(word))
    for i in unique_letters:
        w += letters['weight'].loc[letters[letters['letter'] == i].index[0]]
    return w


def update_probabilities(word_list, last_guess):

    n_letters = []
    r_letters = []
    rp_letters = []
    all_letters = last_guess[0]

    for l in last_guess[0]:
        letter = last_guess[last_guess[0].find(l) + 1]
        if letter == 'n':
            n_letters.append(l)
        elif letter == 'r':
            r_letters.append(l)
        elif letter == 'rp':
            rp_letters.append(l)


    for i in range(0, len(word_list)):
        word = word_list['word']
        k = 0
        #for j in all_letters:
        #    if j in word:
        #        k += 1

        y = 0
        for j in n_letters: # Check if word contains known non-letters
            if j in word:
                k += 1
        for u in r_letters: # Check that word contains known letters
            if u not in word:
                y += 1
            elif word.find(u) == last_guess[0].find(u):
                k += 1
        for m in rp_letters:
            pos = answer.find(m) # Check that word contains known letters in the right place
            if word[pos] != m:
                y += 1
        
        if k > 0 or y > 0:
            word_list['answer_prob'] = 0
        if k > 0:
            word_list['guess_value'] = 0

    #Calculate Answer Probabilities
    word_list['answer_prob'] = np.where(word_list.answer_prob != 0, 1 / len(word_list[word_list['answer_prob'] != 0]), word_list.answer_prob)

    #set probability of remaining words
    word_list = update_guess_value(word_list)
    return word_list


def update_guess_value(word_list):
    letter_weights = update_letter_weights(word_list[word_list['guess_value'] != 0])
    word_list['guess_value'] = word_list.apply(lambda row: guess_value(row['word'], letter_weights) if row['guess_value'] != 0 else 0, axis=1)
    return word_list

def generate_guess(word_list, x = threshold):

    max_prob = word_list['answer_prob'].max()
    #print(max_prob)

    if max_prob == '':
        max_prob = 0

    if max_prob >= x:
        guess = word_list['word'].loc[word_list[word_list['answer_prob'] == max_prob].index[0]]
    if max_prob < x:
        #print(word_list.sort_values('guess_value', ascending=False).head(10))
        guess = word_list['word'].loc[word_list[word_list['guess_value'] == word_list['guess_value'].max()].index[0]]

    return guess

def check_win(guess,answer):
    if guess == answer:
        return True
    else:
        return False


#Simulate
wins = 0
total_guesses = 0
rounds = 1
for i in range(0,rounds):
    scores = score_table()
    guesses = guesses_table()
    answer = pick_word()
    answer = 'bench'
    scores = update_guess_value(scores)
    #print(scores.sort_values('guess_value', ascending=True).head(10)) # worst words
    print("Target Word: " + answer)
    k = 1
    while k <= 6:
        win = 0
        guesses.loc[len(guesses)] = guess_word(generate_guess(scores), answer)
        scores = update_probabilities(scores, guesses.iloc[-1].tolist())
        print(guesses.iloc[-1].tolist())
        if check_win(guesses.iloc[-1].tolist()[0],answer):
            win = 1
            break
        k += 1

    wins += win
    total_guesses += k

print("Guesses  per Round: " + str(round(total_guesses/rounds,2)))
print("Win Rate: " + str(round(wins/rounds,2)))