solving function updated

wordle_functions.py

@@ -301,14 +301,13 @@ def get_word_distribution(word_list: list, sort: str = "descending"):
 ############################################################################################################################################################
     
 def wordle_wizard(word_list: list, max_guesses: int = None, 
-                  guess: str = None, target: str = None, bias: bool = True, 
+                  guess: str = None, target: str = None,
                   random_guess: bool = False, random_target: bool = False, 
                   verbose: bool = False, drama: float = None, 
                   return_stats: bool = False, record: bool = False, hf_mod: bool = True):
     """
     Mimicking the popular web game, this function matches a current word to a target word automatically, in the most statistically optimal way possible.
 
-    ------
     Parameters:
     ------
     `word_list`: list
@@ -317,15 +316,6 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
         a string -- must be the same length as `target_word`
     `target`: str
         a string -- must be the same length as `opening_word`
-    `bias`: str ['entropy', 'common', 'rare', None]
-        'entropy' biases next word guesses to be the ones with the highest impact on the range of next possible guesses. Entropy values associated with each word are normalized across the list.
-
-        'common' biases next word guesses to be words that are more commonly used
-
-        'rare' biases next word guesses to be words that are more rarely used
-
-        'no_bias' chooses a next guess at random of all available guesses
-
     `max_guesses`: int
         the maximum number of attempts allowed to solve the Wordle
     `random_guess`: bool
@@ -341,13 +331,15 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
     `record`: bool
         if True, creates a .txt file with the same information printed according to the indicated verbosity
 
-    ------
     Returns:
     ------
     `stats_dict`: dict
         dictionary containing various statistics about the function's performance trying to solve the puzzle
     """
 
+    guess = guess.lower()
+    target = target.lower()
+
     sugg_words = []
 
     for i in range(0, 20):
@@ -658,100 +650,55 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
 
         else:
 
-            if bias == "entropy":
-                
-                best_next_guesses = list(potential_next_guesses)                
-                # print (best_next_guesses)
-                word_ratings = get_word_entropy(best_next_guesses, word_list, normalized = True, ascending = False) # "internal" ratings
-
-                # Get max rated word
-                max_rating = -np.inf
-                for word, rating in word_ratings:
-                    if rating > max_rating:
-                        max_rating = rating
-
-                for word, rating in word_ratings:
-                    if rating == max_rating:
-                        guess = word
-                
-                guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])
-
-                if return_stats == False:
-                    if verbose == True:
-                        if len(word_ratings) <= 40:
-                            print(f"All potential next guesses:\n\t{word_ratings}\n")
-                            print(f"Words guessed so far:\n\t{guessed_words}.\n")
-                            record_list.append(f"Potential next guesses: {word_ratings}\n")
-                            record_list.append(f"Words guessed so far: {guessed_words}.\n")
-                        else:
-                            print(f"The top 40 potential next guesses are:\n\t{word_ratings[:40]}\n")
-                            print(f"Words guessed so far:\n\t{guessed_words}.\n")
-                            record_list.append(f"The top 40 potential next guesses are: {word_ratings[:40]}\n")
-                            record_list.append(f"Words guessed so far: {guessed_words}.\n")
-
-            if bias == "no_bias":
-                best_next_guesses = set()
-                for word in potential_next_guesses:
-                    for letter, freq in word_list_sorted_counts:
-                        if letter not in dont_guess_again:
-                            if len(next_letters) > 0:
-                                if letter in next_letters:
-                                    if letter in word:
-                                        best_next_guesses.add(word)
-                                        break
-                            else:
-                                if letter in word:
-                                    best_next_guesses.add(word)
-                                    break
-                                
-                if return_stats == False:
-                    if verbose == True:
-                        if len(best_next_guesses) <= 40:
-                            print(f"Potential next guesses:\n\t{best_next_guesses}\n")
-                            print(f"Words guessed so far:\n\t{guessed_words}.\n") 
-                            record_list.append(f"Potential next guesses: {best_next_guesses}\n")
-                            record_list.append(f"Words guessed so far: {guessed_words}.\n") 
-
-            if bias == ("common" or "rare"):
-                found_words = []
-                for word in word_list:
-                    if word in nltk_counts.keys():
-                        found_words.append(word)
-
-                found_words_sorted = sorted(found_words, key = operator.itemgetter(1), reverse = True) # sorted descending
-
-                rated_words = []
-                for word in potential_next_guesses:
-                    for tup in found_words_sorted:
-                        if tup[0] == word:
-                            rated_words.append(tup)
-
-                rated_words = sorted(rated_words, key = operator.itemgetter(1), reverse = True) # sorted descending
-                
-                if bias == "common":
-                    guess = rated_words[0][0] # word in first position // most frequent word
-                    
-                    if return_stats == False:
-                        if verbose == True:
-                            if len(potential_next_guesses) <= 40:
-                                print(f"Potential next guesses:\n\t{rated_words}\n")
-                                print(f"Words guessed so far:\n\t{guessed_words}.\n") 
-                                record_list.append(f"Potential next guesses: {potential_next_guesses}\n")
-                                record_list.append(f"Words guessed so far: {guessed_words}.\n") 
-                
-                if bias == "rare":
-                    guess = rated_words[-1][0] # word in last position // least frequent word
-                
-                    if return_stats == False:
-                        if verbose == True:
-                            if len(potential_next_guesses) <= 40:
-                                print(f"Potential next guesses:\n\t{rated_words}\n")
-                                print(f"Words guessed so far:\n\t{guessed_words}.\n") 
-                                record_list.append(f"Potential next guesses: {potential_next_guesses}\n")
-                                record_list.append(f"Words guessed so far: {guessed_words}.\n") 
-                    
-                # guess = list(best_next_guesses)[0]
-                guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])
+            best_next_guesses = list(potential_next_guesses)                
+            # print (best_next_guesses)
+            word_ratings = get_word_entropy(best_next_guesses, word_list, normalized = True, ascending = False) # "internal" ratings
+            
+            # Get max rating of all words
+            max_rating = -np.inf
+            for word, rating in word_ratings:
+                if rating > max_rating:
+                    max_rating = rating
+
+            # add best rated words (all equally best entropy in next guess list) to set
+            best_of_the_best_1 = []
+            for word, rating in word_ratings:
+                if rating == max_rating:
+                    best_of_the_best_1.append(word)
+
+            # only using top ten most frequent prefixes suffixes to bias. After that it the impact is especially negligible
+            test_starts = get_gram_freq(word_list = word_list, letters_length = 2, position = "start", search = None)[:10]
+            test_ends = get_gram_freq(word_list = word_list, letters_length = 2, position = "end", search = None)[:10]
+
+            # list of the best words that also have the best suffixes and prefixes
+            best_of_the_best_2 = []
+            for start_gram, start_count in test_starts:
+                for end_gram, end_count in test_ends:
+                    for word in best_of_the_best_1:
+                        if word[:2] == start_gram and word[-2:] == end_gram:
+                            best_of_the_best_2.append(word)
+
+            if len(best_of_the_best_2) > 0:
+                guess = best_of_the_best_2[0]
+            else:
+                guess = best_of_the_best_1[0] # they're all equally the best of the best possible guesses so just pick the first
+            
+            # guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])
+
+            if return_stats == False:
+                if verbose == True:
+                    if len(word_ratings) <= 40:
+                        print(f"All potential next guesses:\n\t{word_ratings}\n")
+                        print(f"Words guessed so far:\n\t{guessed_words}.\n")
+                        record_list.append(f"Potential next guesses: {word_ratings}\n")
+                        record_list.append(f"Words guessed so far: {guessed_words}.\n")
+                    else:
+                        print(f"The top 40 potential next guesses are:\n\t{word_ratings[:40]}\n")
+                        print(f"Words guessed so far:\n\t{guessed_words}.\n")
+                        record_list.append(f"The top 40 potential next guesses are: {word_ratings[:40]}\n")
+                        record_list.append(f"Words guessed so far: {guessed_words}.\n")
+
+            guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])
 
         #### Guess has now been made -- what to do next
         if guess_num == max_guesses: # if at max guesses allowed
@@ -850,9 +797,6 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
     # average_entropy = 95
     luck = round(1 - ((((guess_num / expected_guesses) * (stats_dict['avg_intermediate_guess_entropy'] / 100)) / max_guesses) * 5), 2)
     stats_dict['luck'] = luck
-    
-    stats_dict['bias'] = bias
-
 
     if record == True:
         if verbose == True:
@@ -864,7 +808,6 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
                 for line in record_list:
                     fout.write(line + "\n") # write
 
-
     # if guess_num <= len(guess):
     if guess_num <= 6:
         stats_dict['valid_success'] = True
@@ -877,11 +820,64 @@ def wordle_wizard(word_list: list, max_guesses: int = None,
     #     return stats_dict
     if hf_mod == True:
         return record_list
-
+    
 ############################################################################################################################################################
 ############################################################################################################################################################
 ############################################################################################################################################################
 ############################################################################################################################################################
+    
+def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = "start", search: any = None):
+    """
+    Given a word list, a selected number of letter, a selected word position to start from ("start" or "end"),
+    and an optional gram to search within the list, this function will get a frequency distribution of all n-grams
+    from the passed word list and returned a frequency distribution in descending order.
+
+    Parameters:
+    ------
+    `word_list`: list
+        list of words of the same 
+    `letters_length`: int
+        number of letters in succession. Size/length of "gram". Must be between 1 and length of words in word list
+    `position`: bool
+        Whether to start the gram from the start of the word (like a prefix) or the end of the word (like a suffix)
+    `search`: str
+        If != None, string of characters to search for within the generated list. If string not found in list, function will print an error message.
+
+    Returns:
+    ------
+    `tup`: tuple
+        If search != None, will return a tuple with the passed search criteria, and its count
+    `sorted_gram_list`: list
+        List of tuples in the form of (gram, count) for each combination of the gram size in the pass word_list
+    """
+
+    gram_freq_dist = {}
+
+    for word in word_list:
+        if position == "start":
+            gram = word[:letters_length] # first 2 letters
+        if position == "end":
+            gram = word[-(letters_length):] # first 2 letters
+
+        if gram not in gram_freq_dist:
+            gram_freq_dist[gram] = 1
+        else:
+            gram_freq_dist[gram] += 1
+
+    sorted_gram_dist = sorted(gram_freq_dist.items(), key = operator.itemgetter(1), reverse = True)
+
+    if search:
+        nos = []
+        for tup in sorted_gram_dist:
+            if tup[0] == search:
+                return tup
+            else:
+                nos.append("not here")
+        
+        if len(nos) == len(sorted_gram_dist):
+            print ("Search criteria not found in list. Please enter a gram from within the list.")
+    else:
+        return sorted_gram_dist
 
 def compare_wordle(word_list: list, max_guesses: int = None, guess_list: list = None,
                   player: str = None, target: str = None,

wordle_testing.ipynb

@@ -0,0 +1,1654 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import random\n",
+    "import operator\n",
+    "import time\n",
+    "import pandas as pd\n",
+    "from wordle_functions import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Importing datasets"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### official words\n",
+    "- official wordle word list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2310\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "['wince', 'thyme', 'mower', 'horde', 'heard']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "### Official list\n",
+    "official_words = []\n",
+    "\n",
+    "with open(\"data/official_words_processed.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for word in f.read().split(\"\\n\"):\n",
+    "        official_words.append(word)\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(official_words))\n",
+    "official_words[:5]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### alternative list 1\n",
+    "- an alternate list of 5-letter words found on the web"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: 'data/alt_words_1.txt'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[1;32m/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb Cell 7\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m### Official list\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m alt_words_1 \u001b[39m=\u001b[39m []\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39;49m(\u001b[39m\"\u001b[39;49m\u001b[39mdata/alt_words_1.txt\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39mr\u001b[39;49m\u001b[39m\"\u001b[39;49m, encoding \u001b[39m=\u001b[39;49m \u001b[39m\"\u001b[39;49m\u001b[39mutf-8\u001b[39;49m\u001b[39m\"\u001b[39;49m) \u001b[39mas\u001b[39;00m f:\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m     \u001b[39mfor\u001b[39;00m word \u001b[39min\u001b[39;00m f\u001b[39m.\u001b[39mread()\u001b[39m.\u001b[39msplit(\u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\"\u001b[39m):\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m         alt_words_1\u001b[39m.\u001b[39mappend(word)\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'data/alt_words_1.txt'"
+     ]
+    }
+   ],
+   "source": [
+    "### Official list\n",
+    "alt_words_1 = []\n",
+    "\n",
+    "with open(\"data/alt_words_1.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for word in f.read().split(\"\\n\"):\n",
+    "        alt_words_1.append(word)\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(alt_words_1))\n",
+    "alt_words_1[:5]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### nltk grand corpus\n",
+    "- Amalgamation of all words in various NLTK corpora to have as big a dataset as possible\n",
+    "- Developed manually"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### grand corpus tokens\n",
+    "nltk_tokens = []\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_tokens_5.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for word in f.read().split(\"\\n\"):\n",
+    "        nltk_tokens.append(word)\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(nltk_tokens))\n",
+    "nltk_tokens[:5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### nltk grand corpus types and counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### grand corpus types and counts\n",
+    "nltk_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_5.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        if len(line.split(\"\\t\")) == 2:\n",
+    "            word = line.split(\"\\t\")[0]\n",
+    "            count = line.split(\"\\t\")[1]\n",
+    "            nltk_counts[word] = count\n",
+    "        else:\n",
+    "            continue\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(nltk_counts))\n",
+    "nltk_counts['which']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Official list\n",
+    "official_words = []\n",
+    "\n",
+    "with open(\"data/official_words_processed.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for word in f.read().split(\"\\n\"):\n",
+    "        if len(word) > 0: # there's one blank entry at the start\n",
+    "            official_words.append(word)\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(official_words))\n",
+    "official_words[:10]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Wordle functions + Testing"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing `wordle_wizard()`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-----------------------------\n",
+      "\n",
+      "Guess 1: 'poesy'\n",
+      "Letters in correct positions:\n",
+      "\t[]\n",
+      "\n",
+      "Letters in incorrect positions:\n",
+      "\t[('e', 2)]\n",
+      "\n",
+      "Letters to guess again:\n",
+      "\t['e']\n",
+      "\n",
+      "Letters to not guess again:\n",
+      "\t['o', 'p', 's', 'y']\n",
+      "\n",
+      "At this point:\n",
+      "\t1905, 82.47% of total words have been eliminated, and\n",
+      "\t405, 17.53% of total words remain possible.\n",
+      "\n",
+      "The top 40 potential next guesses are:\n",
+      "\t[('alter', 100.0), ('later', 100.0), ('irate', 98.33), ('renal', 94.34), ('learn', 94.34), ('react', 91.3), ('crate', 91.3), ('trace', 91.3), ('cater', 91.3), ('trade', 88.34), ('leant', 88.3), ('heart', 88.13), ('earth', 88.13), ('hater', 88.13), ('aider', 86.22), ('alien', 86.18), ('crane', 85.68), ('tamer', 85.55), ('grate', 85.35), ('realm', 85.1), ('regal', 84.89), ('glare', 84.89), ('lager', 84.89), ('large', 84.89), ('eclat', 84.76), ('blare', 83.81), ('baler', 83.81), ('inter', 83.81), ('liner', 83.35), ('after', 82.43), ('flare', 81.93), ('feral', 81.93), ('delta', 81.81), ('dealt', 81.81), ('taker', 81.72), ('lathe', 81.6), ('water', 81.14), ('trice', 80.31), ('afire', 80.31), ('ramen', 79.93)]\n",
+      "\n",
+      "Words guessed so far:\n",
+      "\t['poesy'].\n",
+      "\n",
+      "Next guess:\n",
+      "\t'alter'\n",
+      "\n",
+      "-----------------------------\n",
+      "\n",
+      "Guess 2: 'alter'\n",
+      "Letters in correct positions:\n",
+      "\t[]\n",
+      "\n",
+      "Letters in incorrect positions:\n",
+      "\t[('a', 0), ('e', 2), ('t', 2), ('e', 3), ('r', 4)]\n",
+      "\n",
+      "Letters to guess again:\n",
+      "\t['a', 'e', 'r', 't']\n",
+      "\n",
+      "Letters to not guess again:\n",
+      "\t['l', 'o', 'p', 's', 'y']\n",
+      "\n",
+      "At this point:\n",
+      "\t2301, 99.61% of total words have been eliminated, and\n",
+      "\t9, 0.39% of total words remain possible.\n",
+      "\n",
+      "All potential next guesses:\n",
+      "\t[('irate', 100.0), ('crate', 70.91), ('trace', 70.91), ('react', 70.91), ('trade', 58.69), ('heart', 57.83), ('earth', 57.83), ('grate', 46.3), ('terra', 0.0)]\n",
+      "\n",
+      "Words guessed so far:\n",
+      "\t['poesy', 'alter'].\n",
+      "\n",
+      "Next guess:\n",
+      "\t'irate'\n",
+      "\n",
+      "-----------------------------\n",
+      "\n",
+      "Guess 3: 'irate'\n",
+      "Letters in correct positions:\n",
+      "\t[('r', 1), ('a', 2), ('t', 3), ('e', 4)]\n",
+      "\n",
+      "Letters in incorrect positions:\n",
+      "\t[('a', 0), ('e', 2), ('t', 2), ('e', 3), ('r', 4)]\n",
+      "\n",
+      "Letters to guess again:\n",
+      "\t['a', 'e', 'r', 't']\n",
+      "\n",
+      "Letters to not guess again:\n",
+      "\t['i', 'l', 'o', 'p', 's', 'y']\n",
+      "\n",
+      "At this point:\n",
+      "\t2308, 99.91% of total words have been eliminated, and\n",
+      "\t2, 0.09% of total words remain possible.\n",
+      "\n",
+      "All potential next guesses:\n",
+      "\t[('crate', 100.0), ('grate', 0.0)]\n",
+      "\n",
+      "Words guessed so far:\n",
+      "\t['poesy', 'alter', 'irate'].\n",
+      "\n",
+      "Next guess:\n",
+      "\t'crate'\n",
+      "\n",
+      "-----------------------------\n",
+      "\n",
+      "Guess 4: 'crate'\n",
+      "Letters in correct positions:\n",
+      "\t[('r', 1), ('a', 2), ('t', 3), ('e', 4)]\n",
+      "\n",
+      "Letters in incorrect positions:\n",
+      "\t[('a', 0), ('e', 2), ('t', 2), ('e', 3), ('r', 4)]\n",
+      "\n",
+      "Letters to guess again:\n",
+      "\t['a', 'e', 'r', 't']\n",
+      "\n",
+      "Letters to not guess again:\n",
+      "\t['c', 'i', 'l', 'o', 'p', 's', 'y']\n",
+      "\n",
+      "At this point:\n",
+      "\t2309, 99.96% of total words have been eliminated, and\n",
+      "\t1, 0.04% of total words remain possible.\n",
+      "\n",
+      "The only remaining possible word is:\n",
+      "\t'grate'\n",
+      "\n",
+      "Next guess:\n",
+      "\t'grate'\n",
+      "\n",
+      "-----------------------------\n",
+      "\n",
+      "Guess 5: 'grate'\n",
+      "\n",
+      "Congratulations! The Wordle has been solved in 5 guesses!\n",
+      "There were still 1 guesses remaining.\n",
+      "\n",
+      "The target word was 'grate'.\n",
+      "\n",
+      "-----------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_1 = wordle_wizard(word_list = official_words, max_guesses = 6, \n",
+    "                guess = \"paint\", target = \"force\",\n",
+    "                random_guess = True, random_target = True, \n",
+    "                verbose = True, drama = 0, return_stats = False, record = False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = official_words, max_guesses = 6, \n",
+    "                guess = \"arose\", target = \"syrup\", bias = 'entropy', \n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 3-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 3 letters\n",
+    "words_3_letters = []\n",
+    "words_3_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_3.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_3_letters.append(word)\n",
+    "                words_3_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_3_letters))\n",
+    "print(words_3_letters[:5])\n",
+    "words_3_types_counts['the']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_3_letters, max_guesses = 6, \n",
+    "                guess = \"the\", target = \"his\", bias = 'entropy', \n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 4-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 3 letters\n",
+    "words_4_letters = []\n",
+    "words_4_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_4.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_4_letters.append(word)\n",
+    "                words_4_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_4_letters))\n",
+    "print(words_4_letters[:5])\n",
+    "words_4_types_counts['that']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_4_letters, max_guesses = 6, \n",
+    "                guess = \"have\", target = \"this\", bias = 'entropy', \n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 6-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 6 letters\n",
+    "words_6_letters = []\n",
+    "words_6_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_6.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_6_letters.append(word)\n",
+    "                words_6_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_6_letters))\n",
+    "print(words_6_letters[:5])\n",
+    "words_6_types_counts[words_6_letters[0]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_6_letters, max_guesses = 6, \n",
+    "                guess = \"little\", target = \"before\", bias = 'entropy', \n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 7-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 7 letters\n",
+    "words_7_letters = []\n",
+    "words_7_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_7.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_7_letters.append(word)\n",
+    "                words_7_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_7_letters))\n",
+    "print(words_7_letters[:5])\n",
+    "words_7_types_counts[words_7_letters[0]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_7_letters, max_guesses = 6, \n",
+    "                guess = \"because\", target = \"through\", bias = 'entropy', \n",
+    "                random_guess = True, random_target = True, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 8-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 8 letters\n",
+    "words_8_letters = []\n",
+    "words_8_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_8.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_8_letters.append(word)\n",
+    "                words_8_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_8_letters))\n",
+    "print(words_8_letters[:5])\n",
+    "words_8_types_counts[words_8_letters[0]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_8_letters, max_guesses = 6, \n",
+    "                guess = \"trinidad\", target = \"together\", bias = 'entropy', \n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 9-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 9 letters\n",
+    "words_9_letters = []\n",
+    "words_9_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_9.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_9_letters.append(word)\n",
+    "                words_9_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_9_letters))\n",
+    "print(words_9_letters[:5])\n",
+    "words_9_types_counts[words_9_letters[0]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_9_letters, max_guesses = 6, \n",
+    "                guess = \"something\", target = \"character\", bias = 'entropy', \n",
+    "                random_guess = True, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing on 10-letter words"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 10 letters\n",
+    "words_10_letters = []\n",
+    "words_10_types_counts = {}\n",
+    "\n",
+    "with open(\"data/nltk_grand_corpus_types_and_counts_10.txt\", \"r\", encoding = \"utf-8\") as f:\n",
+    "    for line in f.read().split(\"\\n\"):\n",
+    "        word_freq = line.split(\"\\t\")\n",
+    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
+    "            word = word_freq[0]\n",
+    "            freq = word_freq[1]\n",
+    "            if word.isascii() == True:\n",
+    "                words_10_letters.append(word)\n",
+    "                words_10_types_counts[word] = freq\n",
+    "\n",
+    "f.close() # closes connection to file\n",
+    "\n",
+    "print(len(words_10_letters))\n",
+    "print(words_10_letters[:5])\n",
+    "words_10_types_counts[words_10_letters[0]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for val in [False, True]:\n",
+    "        wordle_wizard(word_list = words_10_letters, max_guesses = 6, \n",
+    "                guess = \"characters\", target = \"theologies\", bias = 'entropy', \n",
+    "                random_guess = True, random_target = False, \n",
+    "                verbose = val, drama = 0, return_stats = False, record = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wordle_wizard(word_list = official_words, max_guesses = 5, \n",
+    "                guess = \"quote\", target = \"silly\", bias = 'entropy', \n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = True, drama = 0, return_stats = False, record = False)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `compare_wordle()` testing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
+    "print(df.shape)\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
+    "df\n",
+    "convert_row(df, 37)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### TESTING DF INTERPRETATION\n",
+    "\n",
+    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
+    "\n",
+    "row = 37\n",
+    "\n",
+    "print(convert_row(df, row))\n",
+    "player = convert_row(df, row)[0]\n",
+    "target_word = convert_row(df, row)[1]\n",
+    "guess_list = convert_row(df, row)[2]\n",
+    "\n",
+    "compare_wordle(word_list = official_words, max_guesses = 6, \n",
+    "                    guess_list = guess_list, player = player, target = target_word,\n",
+    "                    verbose = False, return_stats = True, record = False)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Comparing player solutions against wizard solutions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_compared_df(player_df, to_csv: bool = False, show_shapes: bool = False):\n",
+    "    \"\"\"\n",
+    "    Creates master df of player wordle scores compared to how wordle_wizard would perform on the same puzzles\n",
+    "\n",
+    "    Parameters:\n",
+    "    -----\n",
+    "    `player_df`: Pandas dataFrame object\n",
+    "        df of player scores of wordle puzzles\n",
+    "    `to_csv`: bool\n",
+    "        If True, writes returned df to csv\n",
+    "    `show_shapes`: bool\n",
+    "        If True, prints shape of new df before and after deleting duplicate rows (created by wordle_wizard running the same puzzles multiple times)\n",
+    "    \n",
+    "    Returns:\n",
+    "    -----\n",
+    "    `df_master`: Pandas dataFrame object\n",
+    "        df of player scores and wordle_wizard scores of wordle puzzles\n",
+    "    \"\"\"\n",
+    "\n",
+    "    stats_master = {}\n",
+    "    excepts = []\n",
+    "    for row in player_df.index:\n",
+    "        player = convert_row(player_df, row)[0]\n",
+    "        target_word = convert_row(player_df, row)[1]\n",
+    "        guess_list = convert_row(player_df, row)[2]\n",
+    "        try:\n",
+    "            complete = compare_wordle(word_list = official_words, max_guesses = 6, \n",
+    "                        guess_list = guess_list, player = player, target = target_word,\n",
+    "                        verbose = True, return_stats = True, record = False)\n",
+    "            for metric, results in complete.items():\n",
+    "                if metric in stats_master:\n",
+    "                    for result in results:\n",
+    "                        stats_master[metric].append(result)\n",
+    "                else:\n",
+    "                    stats_master[metric] = []\n",
+    "                    for result in results:\n",
+    "                        stats_master[metric].append(result)\n",
+    "        except:\n",
+    "            AttributeError\n",
+    "            excepts.append(guess_list)\n",
+    "\n",
+    "    df_master = pd.DataFrame(stats_master)\n",
+    "    print(df_master.columns.tolist())\n",
+    "\n",
+    "    # Re-organizing columns to a more logical order (for viewing)\n",
+    "    df_master = df_master[['first_guess', 'target_word', 'player', 'num_guesses', 'expected_guesses', 'luck', 'first_guess_vowels', 'first_guess_consonants',\n",
+    "                        'target_vowels', 'target_consonants', 'first_guess_entropy', 'target_entropy',\n",
+    "                        'target_guessed', 'mid_guesses_avg_vows', 'mid_guesses_avg_cons', 'avg_perf_letters',\n",
+    "                        'avg_wrong_pos_letters', 'avg_wrong_letters', 'avg_remaining', 'avg_intermediate_guess_entropy',\n",
+    "                        'valid_success']]\n",
+    "\n",
+    "    # print(excepts)\n",
+    "    if show_shapes == True:\n",
+    "        print(df_master.shape) # check shape before deleting dups\n",
+    "\n",
+    "    # Delete duplicate rows (some created by process)\n",
+    "    df_master.drop_duplicates(inplace = True)\n",
+    "    \n",
+    "    if to_csv == True:\n",
+    "        df_master.to_csv('compared_data/players_compared.csv') # write new data to csv\n",
+    "    \n",
+    "    if show_shapes == True:\n",
+    "        print(df_master.shape) # check shape after deleting dups\n",
+    "    \n",
+    "    return df_master.reset_index().drop(columns = \"index\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_word = \"test 1 \"\n",
+    "test_word.strip().lower()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
+    "\n",
+    "df_master = create_compared_df(df, to_csv = True, show_shapes = True)\n",
+    "df_master"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(df_master.query(\"player == 'aidan'\")['num_guesses'].mean())\n",
+    "print(df_master.query(\"player == 'aidan'\").shape)\n",
+    "df_master.query(\"player == 'aidan'\").head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(df_master.query(\"player == 'dad'\")['num_guesses'].mean())\n",
+    "print(df_master.query(\"player == 'dad'\").shape)\n",
+    "df_master.query(\"player == 'dad'\").head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(df_master.query(\"player == 'diane'\")['num_guesses'].mean())\n",
+    "print(df_master.query(\"player == 'diane'\").shape)\n",
+    "df_master.query(\"player == 'diane'\").head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(df_master.query(\"player == 'wizard'\")['num_guesses'].mean())\n",
+    "print(df_master.query(\"player == 'wizard'\").shape)\n",
+    "df_master.query(\"player == 'wizard'\").head(40)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prefix/Suffix bias"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = \"start\", search: any = None):\n",
+    "    \"\"\"\n",
+    "    Given a word list, a selected number of letter, a selected word position to start from (\"start\" or \"end\"),\n",
+    "    and an optional gram to search within the list, this function will get a frequency distribution of all n-grams\n",
+    "    from the passed word list and returned a frequency distribution in descending order.\n",
+    "\n",
+    "    Parameters:\n",
+    "    ------\n",
+    "    `word_list`: list\n",
+    "        list of words of the same \n",
+    "    `letters_length`: int\n",
+    "        number of letters in succession. Size/length of \"gram\". Must be between 1 and length of words in word list\n",
+    "    `position`: bool\n",
+    "        Whether to start the gram from the start of the word (like a prefix) or the end of the word (like a suffix)\n",
+    "    `search`: str\n",
+    "        If != None, string of characters to search for within the generated list. If string not found in list, function will print an error message.\n",
+    "\n",
+    "    Returns:\n",
+    "    ------\n",
+    "    `tup`: tuple\n",
+    "        If search != None, will return a tuple with the passed search criteria, and its count\n",
+    "    `sorted_gram_list`: list\n",
+    "        List of tuples in the form of (gram, count) for each combination of the gram size in the pass word_list\n",
+    "    \"\"\"\n",
+    "\n",
+    "    gram_freq_dist = {}\n",
+    "\n",
+    "    for word in word_list:\n",
+    "        if position == \"start\":\n",
+    "            gram = word[:letters_length] # first 2 letters\n",
+    "        if position == \"end\":\n",
+    "            gram = word[-(letters_length):] # first 2 letters\n",
+    "\n",
+    "        if gram not in gram_freq_dist:\n",
+    "            gram_freq_dist[gram] = 1\n",
+    "        else:\n",
+    "            gram_freq_dist[gram] += 1\n",
+    "\n",
+    "    sorted_gram_dist = sorted(gram_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
+    "\n",
+    "    if search:\n",
+    "        nos = []\n",
+    "        for tup in sorted_gram_dist:\n",
+    "            if tup[0] == search:\n",
+    "                return tup\n",
+    "            else:\n",
+    "                nos.append(\"not here\")\n",
+    "        \n",
+    "        if len(nos) == len(sorted_gram_dist):\n",
+    "            print (\"Search criteria not found in list. Please enter a gram from within the list.\")\n",
+    "    else:\n",
+    "        return sorted_gram_dist\n",
+    "\n",
+    "get_gram_freq(word_list = official_words, letters_length = 2, position = \"start\", search = None)[:10]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_starts = get_gram_freq(word_list = official_words, letters_length = 2, position = \"start\", search = None)[:10]\n",
+    "test_ends = get_gram_freq(word_list = official_words, letters_length = 2, position = \"end\", search = None)[:10]\n",
+    "\n",
+    "test_words = official_words\n",
+    "\n",
+    "for start_gram, start_count in test_starts:\n",
+    "    for end_gram, end_count in test_ends:\n",
+    "        for word in [\"natal\", 'fatal']:\n",
+    "        # for word in test_words:\n",
+    "            if word[:2] == start_gram and word[-2:] == end_gram:\n",
+    "                print (word, start_gram, end_gram)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def wordle_wizard(word_list: list, max_guesses: int = None, \n",
+    "                  guess: str = None, target: str = None,\n",
+    "                  random_guess: bool = False, random_target: bool = False, \n",
+    "                  verbose: bool = False, drama: float = None, \n",
+    "                  return_stats: bool = False, record: bool = False, hf_mod: bool = True):\n",
+    "    \"\"\"\n",
+    "    Mimicking the popular web game, this function matches a current word to a target word automatically, in the most statistically optimal way possible.\n",
+    "\n",
+    "    Parameters:\n",
+    "    ------\n",
+    "    `word_list`: list\n",
+    "        list of valid words to be considered\n",
+    "    `guess`: str\n",
+    "        a string -- must be the same length as `target_word`\n",
+    "    `target`: str\n",
+    "        a string -- must be the same length as `opening_word`\n",
+    "    `max_guesses`: int\n",
+    "        the maximum number of attempts allowed to solve the Wordle\n",
+    "    `random_guess`: bool\n",
+    "        if True, randomly chooses a starting word from all words within `word_list`. If False, passed starting word must be used instead\n",
+    "    `random_target`: bool\n",
+    "        if True, randomly chooses a target word from all words within `word_list`. If False, passed target word must be used instead\n",
+    "    `verbose`: bool\n",
+    "        if True, prints progress and explanation of how function solves the puzzle. If False, prints only the guessed word at each guess.\n",
+    "    `drama`: float or int\n",
+    "        if int provided, each guess' output is delayed by that number of seconds, else each output is shown as quickly as possible. For ~dRaMaTiC eFfEcT~\n",
+    "    `return_stats`: bool\n",
+    "        if True, prints nothing and returns a dictionary of various statistics about the function's performance trying to solve the puzzle\n",
+    "    `record`: bool\n",
+    "        if True, creates a .txt file with the same information printed according to the indicated verbosity\n",
+    "\n",
+    "    Returns:\n",
+    "    ------\n",
+    "    `stats_dict`: dict\n",
+    "        dictionary containing various statistics about the function's performance trying to solve the puzzle\n",
+    "    \"\"\"\n",
+    "\n",
+    "    guess = guess.lower()\n",
+    "    target = target.lower()\n",
+    "\n",
+    "    sugg_words = []\n",
+    "\n",
+    "    for i in range(0, 20):\n",
+    "        ran_int = random.randint(0, len(word_list) - 1)\n",
+    "        word = word_list[ran_int]\n",
+    "        sugg_words.append(word)\n",
+    "\n",
+    "    if guess not in word_list:\n",
+    "        print (\"Guess word not in passed word list.\\nOnly words within the given word list are valid.\")\n",
+    "        print (f\"Here are some examples of valid words from the passed word list.\\n\\t{sugg_words[:10]}\")\n",
+    "        return None\n",
+    "    \n",
+    "    if target not in word_list:\n",
+    "        print (\"Target word not in passed word list.\\nOnly words within the given word list are valid.\")\n",
+    "        print (f\"Here are some examples of valid words from the passed word list.\\n\\t{sugg_words[-10:]}\")\n",
+    "        return None\n",
+    "\n",
+    "    if random_guess == True:\n",
+    "        randomint_guess = random.randint(0, len(word_list) - 1)\n",
+    "        guess = word_list[randomint_guess]\n",
+    "\n",
+    "    if random_target == True:\n",
+    "        randomint_target = random.randint(0, len(word_list) - 1)\n",
+    "        target = word_list[randomint_target]\n",
+    "\n",
+    "    stats_dict = {}\n",
+    "    stats_dict['first_guess'] = guess\n",
+    "    stats_dict['target_word'] = target\n",
+    "    stats_dict['first_guess_vowels'] = float(count_vows_cons(guess, y_vow = True)['vows'])\n",
+    "    stats_dict['first_guess_consonants'] = float(count_vows_cons(guess, y_vow = True)['cons'])\n",
+    "    stats_dict['target_vowels'] = float(count_vows_cons(target, y_vow = True)['vows'])\n",
+    "    stats_dict['target_consonants'] = float(count_vows_cons(target, y_vow = True)['cons'])\n",
+    "    \n",
+    "    # get entropy of the first guess word and target word in the entire word_list\n",
+    "    for tup in get_word_entropy(word_list, word_list, normalized = True):\n",
+    "        if tup[0] == guess:\n",
+    "            stats_dict['first_guess_entropy'] = tup[1]\n",
+    "        if tup[0] == target:\n",
+    "            stats_dict['target_entropy'] = tup[1]\n",
+    "\n",
+    "    guess_entropies = []\n",
+    "    guess_entropies.append(stats_dict['first_guess_entropy'])\n",
+    "\n",
+    "    # luck_guess_1 = round(1 - ((1 / len(word_list)) * guess_entropies[0] / 100), 2) * 100\n",
+    "\n",
+    "    english_alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
+    "\n",
+    "    word_list_sorted_counts = get_letter_counts(english_alphabet, word_list, sort = \"descending\")\n",
+    "    \n",
+    "    wordlen = len(guess)\n",
+    "    letter_positions = set(i for i in range(0, wordlen))\n",
+    "\n",
+    "    guess_set = set()\n",
+    "    perfect_dict = {}\n",
+    "    wrong_pos_dict = {}\n",
+    "    wrong_pos_set = set()\n",
+    "    dont_guess_again = set()\n",
+    "\n",
+    "    guessed_words = [] # running set of guessed words\n",
+    "    guess_num = 0 # baseline for variable\n",
+    "    dont_guess_words = set()\n",
+    "    incorrect_positions = []\n",
+    "    reduction_per_guess = []\n",
+    "\n",
+    "    if max_guesses == None: # if no value is passed, default is len(guess)\n",
+    "        max_guesses = wordlen\n",
+    "    else: # else it is the value passed\n",
+    "        max_guesses = max_guesses\n",
+    "\n",
+    "    perfect_letts_per_guess = []\n",
+    "    wrong_pos_per_guess = []\n",
+    "    wrong_letts_per_guess = []\n",
+    "\n",
+    "    record_list = []\n",
+    "\n",
+    "    while guess: # while there is any guess -- there are conditions to break it at the bottom\n",
+    "\n",
+    "        guess_num += 1\n",
+    "\n",
+    "        guessed_words.append(guess)\n",
+    "\n",
+    "        if drama:\n",
+    "            time.sleep(drama)\n",
+    "\n",
+    "        # guess_num += 1 # each time the guess is processed\n",
+    "        if return_stats == False:\n",
+    "            if guess_num == 1:\n",
+    "                print(\"-----------------------------\\n\")\n",
+    "                record_list.append(\"-----------------------------\\n\")\n",
+    "    \n",
+    "        if return_stats == False:\n",
+    "            print(f\"Guess {guess_num}: '{guess}'\")\n",
+    "            record_list.append(f\"Guess {guess_num}: '{guess}'\")\n",
+    "\n",
+    "        if guess == target:\n",
+    "            stats_dict['target_guessed'] = True\n",
+    "            if return_stats == False:\n",
+    "                if guess_num == 1:\n",
+    "                    print(f\"Congratulations! The Wordle has been solved in {guess_num} guess, that's amazingly lucky!\")\n",
+    "                    print(f\"The target word was {target}\")\n",
+    "                    record_list.append(f\"Congratulations! The Wordle has been solved in {guess_num} guess, that's amazingly lucky!\")\n",
+    "                    record_list.append(f\"The target word was '{target}'.\")\n",
+    "                    perfect_letts_per_guess.append(5)\n",
+    "                    wrong_pos_per_guess.append(0)\n",
+    "                    wrong_letts_per_guess.append(0)\n",
+    "            break\n",
+    "\n",
+    "        guess_set = set()\n",
+    "        wrong_pos_set = set()\n",
+    "\n",
+    "        #### Step 2 -- ALL PERFECT\n",
+    "        for i in letter_positions: # number of letters in each word (current word and target word)\n",
+    "            guess_set.add(guess[i])\n",
+    "\n",
+    "            if guess[i] not in perfect_dict:\n",
+    "                perfect_dict[guess[i]] = set()\n",
+    "            if guess[i] not in wrong_pos_dict:\n",
+    "                wrong_pos_dict[guess[i]] = set()\n",
+    "\n",
+    "            ### EVALUATE CURRENT GUESS\n",
+    "            if guess[i] == target[i]: # letter == correct and position == correct\n",
+    "                perfect_dict[guess[i]].add(i)\n",
+    "\n",
+    "            if (guess[i] != target[i] and  guess[i] in target): # letter == correct and position != correct\n",
+    "                wrong_pos_dict[guess[i]].add(i)\n",
+    "                wrong_pos_set.add(guess[i])\n",
+    "\n",
+    "            if guess[i] not in target: # if letter is not relevant at all\n",
+    "                dont_guess_again.add(guess[i])\n",
+    "\n",
+    "        #### Step 3 -- ALL PERFECT\n",
+    "        next_letters = set()\n",
+    "        for letter, positions in perfect_dict.items():\n",
+    "            if len(positions) > 0:\n",
+    "                next_letters.add(letter)\n",
+    "\n",
+    "        for letter, positions in wrong_pos_dict.items():\n",
+    "            if len(positions) > 0:\n",
+    "                next_letters.add(letter)\n",
+    "\n",
+    "        #### List of tuples of correct letter positions in new valid words. Eg: [('e', 2), ('a', 3)]\n",
+    "        perfect_letters = []\n",
+    "        for letter, positions in perfect_dict.items():\n",
+    "            for pos in positions:\n",
+    "                if len(positions) > 0:\n",
+    "                    perfect_letters.append((letter, pos))\n",
+    "\n",
+    "        #### all words that have correct letters in same spots\n",
+    "        words_matching_correct_all = []\n",
+    "        for word in word_list:\n",
+    "            word_set = set()\n",
+    "            for letter, pos in perfect_letters:\n",
+    "                if pos < len(word):\n",
+    "                    if word[pos] == letter:\n",
+    "                        words_matching_correct_all.append(word)\n",
+    "\n",
+    "        #### excluding words with letters in known incorrect positions\n",
+    "        for letter, positions in wrong_pos_dict.items():\n",
+    "            for pos in positions:\n",
+    "                if len(positions) > 0:\n",
+    "                    if (letter, pos) not in incorrect_positions:\n",
+    "                        incorrect_positions.append((letter, pos))\n",
+    "\n",
+    "        # sorting lists of tuples just to make them look nice in the printout\n",
+    "        incorrect_positions = sorted(incorrect_positions, key = operator.itemgetter(1), reverse = False)\n",
+    "        perfect_letters = sorted(perfect_letters, key = operator.itemgetter(1), reverse = False)\n",
+    "\n",
+    "        #### all words that have correct letters in incorrect spots -- so they can be excluded efficiently\n",
+    "        \n",
+    "        # print(incorrect_positions)\n",
+    "        \n",
+    "        for word in word_list:\n",
+    "            word_set = set()\n",
+    "            for letter, pos in incorrect_positions:\n",
+    "                if pos < len(word):\n",
+    "                    if word[pos] == letter:\n",
+    "                        dont_guess_words.add(word)\n",
+    "        for word in word_list:\n",
+    "            word_set = set()\n",
+    "            for letter, pos in incorrect_positions:\n",
+    "                if pos < len(word):\n",
+    "                    if word[pos] == letter:\n",
+    "                        dont_guess_words.add(word)\n",
+    "\n",
+    "        for bad_letter in dont_guess_again:\n",
+    "            for word in word_list:\n",
+    "                if (bad_letter in word and word not in dont_guess_words):\n",
+    "                    dont_guess_words.add(word)\n",
+    "\n",
+    "        if return_stats == False:\n",
+    "            if verbose == True:\n",
+    "                print(f\"Letters in correct positions:\\n\\t{perfect_letters}\\n\")\n",
+    "                print(f\"Letters in incorrect positions:\\n\\t{incorrect_positions}\\n\")\n",
+    "                print (f\"Letters to guess again:\\n\\t{sorted(list(next_letters), reverse = False)}\\n\")\n",
+    "                print(f\"Letters to not guess again:\\n\\t{sorted(list(dont_guess_again), reverse = False)}\\n\") # works\n",
+    "                \n",
+    "                if len(perfect_letters) == 0:\n",
+    "                    record_list.append(f\"Letters in correct positions: None\\n\")\n",
+    "                else:\n",
+    "                    record_list.append(f\"Letters in correct positions: {perfect_letters}\\n\")\n",
+    "                \n",
+    "                if len(incorrect_positions) == 0:\n",
+    "                    record_list.append(f\"Letters in incorrect positions: None\\n\")\n",
+    "                else:\n",
+    "                    record_list.append(f\"Letters in incorrect positions: {incorrect_positions}\\n\")\n",
+    "                \n",
+    "                if len(next_letters) == 0:\n",
+    "                    record_list.append(f\"Letters to guess again: None\\n\")\n",
+    "                else:\n",
+    "                    record_list.append(f\"Letters to guess again: {sorted(list(next_letters), reverse = False)}\\n\")\n",
+    "                # if\n",
+    "                #     record_list.append(f\"Letters to not guess again: {sorted(list(dont_guess_again), reverse = False)}\\n\") # works\n",
+    "\n",
+    "        # Returns True\n",
+    "        # print(A.issubset(B)) # \"if everything in A is in B\", returns Bool\n",
+    "\n",
+    "        perfect_letts_per_guess.append(len(perfect_letters))\n",
+    "        wrong_pos_per_guess.append(len(incorrect_positions))\n",
+    "        wrong_letts_per_guess.append(len(dont_guess_again))\n",
+    "\n",
+    "        potential_next_guesses = set()\n",
+    "        middle_set = set()\n",
+    "\n",
+    "        if len(perfect_letters) == 0 and len(incorrect_positions) == 0: # if there are NEITHER perfect letters, NOR incorrect positions, ....\n",
+    "            for word in word_list:\n",
+    "                if word not in dont_guess_words:\n",
+    "                    if word not in guessed_words:\n",
+    "                        potential_next_guesses.add(word)\n",
+    "                                        \n",
+    "            # print(f\"GUESS {guess_num} : TEST 1-1\")\n",
+    "\n",
+    "        if len(perfect_letters) == 0 and len(incorrect_positions) != 0: # if there are no perfect letters whatsoever, but there ARE incorrect positions ....\n",
+    "            for word in word_list:\n",
+    "                for incor_letter, incor_pos in incorrect_positions:\n",
+    "                    if incor_pos < len(word):\n",
+    "                        if word[incor_pos] != incor_letter:\n",
+    "                            if word not in dont_guess_words: # just in case\n",
+    "                                word_set = set()\n",
+    "                                for letter in word:\n",
+    "                                    word_set.add(letter)\n",
+    "    \n",
+    "                                    if next_letters.issubset(word_set):\n",
+    "                                        if word not in guessed_words:\n",
+    "                                            if len(dont_guess_again) > 0:\n",
+    "                                                for bad_letter in dont_guess_again:\n",
+    "                                                    if bad_letter not in word:\n",
+    "                                                        # potential_next_guesses.append(word)\n",
+    "                                                        potential_next_guesses.add(word)\n",
+    "                                            else:\n",
+    "                                                potential_next_guesses.add(word)\n",
+    "            \n",
+    "            # print(f\"GUESS {guess_num} : TEST 2-1\")\n",
+    "\n",
+    "        else:\n",
+    "            for word in word_list:\n",
+    "                if word not in dont_guess_words: # just in case\n",
+    "                    word_set = set()\n",
+    "                    for letter in word:\n",
+    "                        word_set.add(letter)\n",
+    "                        if next_letters.issubset(word_set):\n",
+    "                            if word not in guessed_words:\n",
+    "                                # print (\"TEST 3-2\")\n",
+    "\n",
+    "                                if len(dont_guess_again) > 0:\n",
+    "                                    for bad_letter in dont_guess_again:\n",
+    "                                        if bad_letter not in word:\n",
+    "                                            middle_set.add(word)\n",
+    "                                else:\n",
+    "                                    middle_set.add(word)\n",
+    "            for word in middle_set:\n",
+    "                dummy_list = []\n",
+    "                for good_lett, good_pos in perfect_letters:\n",
+    "                    if word[good_pos] == good_lett:\n",
+    "                        dummy_list.append(1)\n",
+    "                        if len(dummy_list) == len(perfect_letters):\n",
+    "                            potential_next_guesses.add(word)\n",
+    "            for word in middle_set:\n",
+    "                dummy_list = []\n",
+    "                for bad_lett, bad_pos in incorrect_positions:\n",
+    "                    if bad_pos < len(word):\n",
+    "                        if word[bad_pos] == bad_lett:\n",
+    "                            dummy_list.append(1)\n",
+    "                            if len(dummy_list) > 0:\n",
+    "                                potential_next_guesses.remove(word)\n",
+    "                                        \n",
+    "            # print(f\"GUESS {guess_num} : TEST 3-1\")\n",
+    "\n",
+    "        if return_stats == False:\n",
+    "            if verbose == True:\n",
+    "                print(f\"At this point:\")\n",
+    "                print(f\"\\t{len(word_list) - len(potential_next_guesses)}, {round((len(word_list) - len(potential_next_guesses)) / len(word_list) * 100, 2)}% of total words have been eliminated, and\")\n",
+    "                print(f\"\\t{len(potential_next_guesses)}, {round(len(potential_next_guesses) / len(word_list) * 100, 2)}% of total words remain possible.\\n\")\n",
+    "                # record_list.append(f\"At this point:\")\n",
+    "                record_list.append(f\"{len(word_list) - len(potential_next_guesses)} ({round((len(word_list) - len(potential_next_guesses)) / len(word_list) * 100, 2)}% of all) words have been eliminated, and {len(potential_next_guesses)} ({round(len(potential_next_guesses) / len(word_list) * 100, 2)}% of all) words are still possible.\\n\")\n",
+    "        \n",
+    "        reduction_per_guess.append(len(potential_next_guesses))\n",
+    "                \n",
+    "        #### Guessing next word\n",
+    "        if len(potential_next_guesses) == 1:\n",
+    "\n",
+    "            if return_stats == False:\n",
+    "                if verbose == True:\n",
+    "                    print(f\"The only remaining possible word is:\\n\\t'{list(potential_next_guesses)[0]}'\\n\")\n",
+    "                    record_list.append(f\"The only remaining possible word is: '{list(potential_next_guesses)[0]}'\\n\")\n",
+    "                \n",
+    "            guess = list(potential_next_guesses)[0]\n",
+    "            guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])\n",
+    "\n",
+    "        else:\n",
+    "\n",
+    "            best_next_guesses = list(potential_next_guesses)                \n",
+    "            # print (best_next_guesses)\n",
+    "            word_ratings = get_word_entropy(best_next_guesses, word_list, normalized = True, ascending = False) # \"internal\" ratings\n",
+    "            \n",
+    "            # Get max rating of all words\n",
+    "            max_rating = -np.inf\n",
+    "            for word, rating in word_ratings:\n",
+    "                if rating > max_rating:\n",
+    "                    max_rating = rating\n",
+    "\n",
+    "            # add best rated words (all equally best entropy in next guess list) to set\n",
+    "            best_of_the_best_1 = []\n",
+    "            for word, rating in word_ratings:\n",
+    "                if rating == max_rating:\n",
+    "                    best_of_the_best_1.append(word)\n",
+    "\n",
+    "            # only using top ten most frequent prefixes suffixes to bias. After that it the impact is especially negligible\n",
+    "            test_starts = get_gram_freq(word_list = word_list, letters_length = 2, position = \"start\", search = None)[:10]\n",
+    "            test_ends = get_gram_freq(word_list = word_list, letters_length = 2, position = \"end\", search = None)[:10]\n",
+    "\n",
+    "            # list of the best words that also have the best suffixes and prefixes\n",
+    "            best_of_the_best_2 = []\n",
+    "            for start_gram, start_count in test_starts:\n",
+    "                for end_gram, end_count in test_ends:\n",
+    "                    for word in test_words:\n",
+    "                        if word[:2] == start_gram and word[-2:] == end_gram:\n",
+    "                            best_of_the_best_2.append(word)\n",
+    "\n",
+    "            if len(best_of_the_best_2) > 0:\n",
+    "                guess = best_of_the_best_1[0]\n",
+    "            else:\n",
+    "                guess = best_of_the_best_2[0] # they're all equally the best of the best possible guesses so just pick the first\n",
+    "            \n",
+    "            # guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])\n",
+    "\n",
+    "            if return_stats == False:\n",
+    "                if verbose == True:\n",
+    "                    if len(word_ratings) <= 40:\n",
+    "                        print(f\"All potential next guesses:\\n\\t{word_ratings}\\n\")\n",
+    "                        print(f\"Words guessed so far:\\n\\t{guessed_words}.\\n\")\n",
+    "                        record_list.append(f\"Potential next guesses: {word_ratings}\\n\")\n",
+    "                        record_list.append(f\"Words guessed so far: {guessed_words}.\\n\")\n",
+    "                    else:\n",
+    "                        print(f\"The top 40 potential next guesses are:\\n\\t{word_ratings[:40]}\\n\")\n",
+    "                        print(f\"Words guessed so far:\\n\\t{guessed_words}.\\n\")\n",
+    "                        record_list.append(f\"The top 40 potential next guesses are: {word_ratings[:40]}\\n\")\n",
+    "                        record_list.append(f\"Words guessed so far: {guessed_words}.\\n\")\n",
+    "\n",
+    "            guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])\n",
+    "\n",
+    "        #### Guess has now been made -- what to do next\n",
+    "        if guess_num == max_guesses: # if at max guesses allowed\n",
+    "            guessed_words.append(guess)\n",
+    "            stats_dict['target_guessed'] = False\n",
+    "            if return_stats == False:\n",
+    "                if verbose == True:\n",
+    "                    # print(\"-----------------------------\\n\")\n",
+    "                    print(f\"Unfortunately, the Wordle could not be solved in {max_guesses} guesses.\\n\")\n",
+    "                    print(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
+    "                    print(\"-----------------------------\\n\")\n",
+    "                    record_list.append(f\"Unfortunately, the Wordle could not be solved in {max_guesses} guesses.\\n\")\n",
+    "                    record_list.append(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
+    "                    record_list.append(\"-----------------------------\\n\")\n",
+    "                else:\n",
+    "                    print(f\"\\nUnfortunately, the Wordle could not be solved in {max_guesses} guesses.\")\n",
+    "                    print(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
+    "                    record_list.append(f\"Unfortunately, the Wordle could not be solved in {max_guesses} guesses.\")\n",
+    "                    record_list.append(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
+    "            break\n",
+    "        else: # if not at max guesses yet allowed\n",
+    "            # stats_dict['target_guessed'] = False\n",
+    "            if return_stats == False:\n",
+    "                if verbose == True:\n",
+    "                    print(f\"Next guess:\\n\\t'{guess}'\")\n",
+    "                    print(\"\\n-----------------------------\\n\")\n",
+    "                    record_list.append(f\"Next guess: '{guess}'\")\n",
+    "                    record_list.append(\"-----------------------------\\n\")\n",
+    "\n",
+    "        if guess == target:\n",
+    "            guess_num += 1\n",
+    "            guessed_words.append(guess)\n",
+    "            stats_dict['target_guessed'] = True\n",
+    "\n",
+    "            if return_stats == False:\n",
+    "                print(f\"Guess {guess_num}: '{guess}'\\n\")\n",
+    "                print(f\"Congratulations! The Wordle has been solved in {guess_num} guesses!\")\n",
+    "                record_list.append(f\"Guess {guess_num}: '{guess}'\\n\")\n",
+    "                record_list.append(f\"Congratulations! The Wordle has been solved in {guess_num} guesses!\")\n",
+    "\n",
+    "                if max_guesses - guess_num == 0:\n",
+    "                    print(f\"Lucky! It was the last guess.\")\n",
+    "                    record_list.append(f\"Lucky! It was the last guess.\")\n",
+    "                else:\n",
+    "                    print(f\"There were still {max_guesses - guess_num} guesses remaining.\")\n",
+    "                    record_list.append(f\"There were still {max_guesses - guess_num} guesses remaining.\")\n",
+    "\n",
+    "            if return_stats == False:   \n",
+    "                # stats_dict['target_guessed'] = True                 \n",
+    "                print(f\"\\nThe target word was '{target}'.\")\n",
+    "                print(\"\\n-----------------------------\")\n",
+    "                record_list.append(f\"The target word was '{target}'.\")\n",
+    "                record_list.append(\"-----------------------------\")\n",
+    "            break\n",
+    "\n",
+    "    #### STATS STUFF    \n",
+    "    mid_guesses_vows = 0\n",
+    "    mid_guesses_cons = 0\n",
+    "    avg_perf_letters = 0\n",
+    "    avg_wrong_pos_letters = 0\n",
+    "    avg_wrong_letters = 0\n",
+    "\n",
+    "    for i, word in enumerate(guessed_words):\n",
+    "        mid_guesses_vows += count_vows_cons(word, y_vow = True)['vows']\n",
+    "        mid_guesses_cons += count_vows_cons(word, y_vow = True)['cons']\n",
+    "        \n",
+    "    for i in range(0, len(guessed_words) - 1):\n",
+    "        avg_perf_letters += perfect_letts_per_guess[i]\n",
+    "        avg_wrong_pos_letters += wrong_pos_per_guess[i]\n",
+    "        avg_wrong_letters += wrong_letts_per_guess[i]\n",
+    "\n",
+    "    stats_dict['mid_guesses_avg_vows'] = float(round(mid_guesses_vows / len(guessed_words), 2))\n",
+    "    stats_dict['mid_guesses_avg_cons'] = float(round(mid_guesses_cons / len(guessed_words), 2))\n",
+    "\n",
+    "    stats_dict['avg_perf_letters'] = float(round(np.mean(avg_perf_letters), 2))\n",
+    "    stats_dict['avg_wrong_pos_letters'] = float(round(np.mean(avg_wrong_pos_letters), 2))\n",
+    "    stats_dict['avg_wrong_letters'] = float(round(np.mean(avg_wrong_letters), 2))\n",
+    "    \n",
+    "    # average number of words remaining after each guess -- the higher this is, the luckier the person got (the lower, the more guesses it took)\n",
+    "    stats_dict['avg_remaining'] = float(round(np.mean(reduction_per_guess), 2))\n",
+    "\n",
+    "    # avg entropy of each guessed word relative to all other words possible at that moment -- this should consistently be 100 for the algorithm, but will be different for user\n",
+    "    if len(guess_entropies) > 1: # in case of guessing it correctly on the first try\n",
+    "        sum_entropies = 0\n",
+    "        for entropy in guess_entropies:\n",
+    "            sum_entropies += entropy\n",
+    "\n",
+    "        average_entropy = float(round(sum_entropies / len(guess_entropies), 2))\n",
+    "        stats_dict['avg_intermediate_guess_entropy'] = average_entropy\n",
+    "    else:\n",
+    "        stats_dict['avg_intermediate_guess_entropy'] = float(100)\n",
+    "\n",
+    "    expected_guesses = 3.85\n",
+    "\n",
+    "    # guess_num = 3\n",
+    "    # average_entropy = 95\n",
+    "    luck = round(1 - ((((guess_num / expected_guesses) * (stats_dict['avg_intermediate_guess_entropy'] / 100)) / max_guesses) * 5), 2)\n",
+    "    stats_dict['luck'] = luck\n",
+    "\n",
+    "    if record == True:\n",
+    "        if verbose == True:\n",
+    "            with open(f\"solutions/{guessed_words[0]}_{target}_wizard_detailed.txt\", \"w\") as fout:\n",
+    "                for line in record_list:\n",
+    "                    fout.write(line + \"\\n\") # write each line of list of printed text to .txt file\n",
+    "        else:\n",
+    "            with open(f\"solutions/{guessed_words[0]}_{target}_wizard_summary.txt\", \"w\") as fout:\n",
+    "                for line in record_list:\n",
+    "                    fout.write(line + \"\\n\") # write\n",
+    "\n",
+    "    # if guess_num <= len(guess):\n",
+    "    if guess_num <= 6:\n",
+    "        stats_dict['valid_success'] = True\n",
+    "    else:\n",
+    "        stats_dict['valid_success'] = False\n",
+    "\n",
+    "    stats_dict['num_guesses'] = float(guess_num)\n",
+    "\n",
+    "    # if return_stats == True:\n",
+    "    #     return stats_dict\n",
+    "    if hf_mod == True:\n",
+    "        return record_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_1 = wordle_wizard(word_list = official_words, max_guesses = 6, \n",
+    "                guess = \"quota\", target = \"fatAl\",\n",
+    "                random_guess = False, random_target = False, \n",
+    "                verbose = True, drama = 0, return_stats = False, record = False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "suffix_freq_dist = {}\n",
+    "prefix_freq_dist = {}\n",
+    "\n",
+    "for word in official_words:\n",
+    "    prefix = word[:2] # first 2 letters\n",
+    "    suffix = word[-2:] # last 2 letters\n",
+    "    if prefix not in prefix_freq_dist:\n",
+    "        prefix_freq_dist[prefix] = 1\n",
+    "    else:\n",
+    "        prefix_freq_dist[prefix] += 1\n",
+    "\n",
+    "    if suffix not in suffix_freq_dist:\n",
+    "        suffix_freq_dist[suffix] = 1\n",
+    "    else:\n",
+    "        suffix_freq_dist[suffix] += 1\n",
+    "\n",
+    "suffix_types = [key for key in suffix_freq_dist.keys()]\n",
+    "prefix_types = [key for key in prefix_freq_dist.keys()]\n",
+    "\n",
+    "sorted_prefix_dist = sorted(prefix_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
+    "sorted_suffix_dist = sorted(suffix_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
+    "\n",
+    "print(\"Prefixes:\")\n",
+    "print(len(sorted_prefix_dist))\n",
+    "print(sorted_prefix_dist[:10])\n",
+    "print(\"-----\")\n",
+    "print(\"Suffixes:\")\n",
+    "print(len(sorted_suffix_dist))\n",
+    "print(sorted_suffix_dist[:10])\n",
+    "\n",
+    "for tup in sorted_prefix_dist:\n",
+    "    if tup[0] in [\"ho\", 'jo', 'go']:\n",
+    "        print (tup)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grams_freq_dist = {}\n",
+    "gram_len = 3\n",
+    "\n",
+    "for word in official_words:\n",
+    "    for i in range(0, len(word) - (gram_len - 1)): # so it doesn't index out of range\n",
+    "        gram = word[i:i + gram_len]\n",
+    "\n",
+    "        if gram not in grams_freq_dist:\n",
+    "            grams_freq_dist[gram] = 1\n",
+    "        else:\n",
+    "            grams_freq_dist[gram] += 1\n",
+    "\n",
+    "print(len(grams_freq_dist))\n",
+    "sorted_gram_dist = sorted(grams_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
+    "sorted_gram_dist[:15]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "3d597f4c481aa0f25dceb95d2a0067e73c0966dcbd003d741d821a7208527ecf"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}