wordle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wordle Solver in Python\n",
    "\n",
    "#### By Yicheng Shen & Linxuan Wang\n",
    "\n",
    "Our function works in a way that it accepts a `wordle.puzzle()` object, automatically guesses up to 6 times, and breaks once it guesses correctly. \n",
    "\n",
    "We choose \"plaid\" as the initial guess based on our domain knowledge. There are many potentially well-performing first guesses, such as \"react\", \"salet\", \"other\", etc. The rule of thumb is to have words with common letters and vowels. \n",
    "\n",
    "For each round, we store the positions at which \"🟩\"/\"🟨\"/\"⬜\" appears in the guess result as well as the corresponding letters. We also record and update letters that were guesses correctly and incorrectly. Bascially, our funtion looks up the list of possible words (starting from the full word bank). It would select words that have the correct letters in the \"🟩\" positions, have letters indicated in by \"🟨\" but not in those positions, and don't have letters that are ruled out by \"⬜\". After these three rounds of filtering, the possbile guesses left should all fit the criterion from previous results. \n",
    "\n",
    "After each guess we narrow down the list of possible answers based on information we stored. We pick a word among the highest commonality to be the next guess. The commonality is determined based on the frequency of each letter at each position among the remaining possible guesses. The intuition is to choose a common word whose letters appear \"frequently\" and is likely to be the answer. \n",
    "\n",
    "We also notice that most common failures of solving the wordle puzzles usually happen when the solver has confirmed four or three \"🟩\" letters and positions, but is stuck by a long list of possible guesses to fill the remaining \"⬜\" positions. In response to this situation, we add a mechanism that would make a different guess to eliminate several letters at a time. The guess should be a word containing letters that did not appear in previous guesses. \n",
    "\n",
    "Overall, our solver is able to solve random wordle puzzles approximately 90% of the time with an average number of guess being about 4.57. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import wordle\n",
    "import collections\n",
    "from collections import Counter\n",
    "from itertools import chain\n",
    "import operator\n",
    "    \n",
    "def puzzle_solver(p):\n",
    "    \"\"\" This function is built as a wordle solver using python. \\n It should be used in accompany with the `wordle.py` and `wordle.txt` files. \\n The input should be a world puzzle object. \\n The output will return the status of the puzzle.\n",
    "    \"\"\"\n",
    "    \n",
    "    our_guess = \"plaid\" # chosen based on domain knowledge\n",
    "    all_words = wordle.words.copy()\n",
    "    possible_guess = wordle.words.copy()\n",
    "    green_letter_all = set() # store all correctly guessed letters \n",
    "#    yellow_letter_all = set()\n",
    "    wrong_letter_all = set() # store all incorrectly guessed letters \n",
    "    \n",
    "    def calculate_word_commonality(word): # calcualte the commonality of a given word based on frequency of each letter\n",
    "        score = 0.0\n",
    "        for i in range(5):\n",
    "            score += Letter_Frequency[i][word[i]]\n",
    "        return score / (5 - len(set(word)) + 1)\n",
    "\n",
    "    def sort_by_word_commonality(words): # calculate and sort the commonality of a given list of words\n",
    "        sort_by = operator.itemgetter(1)\n",
    "        return sorted(\n",
    "            [(word, calculate_word_commonality(word)) for word in words],\n",
    "            key=sort_by,\n",
    "            reverse=True,\n",
    "        )\n",
    "    \n",
    "    def sort_by_num_difference(words): # count and sort the number of unguessed of a given list of words\n",
    "        sort_by = operator.itemgetter(1)\n",
    "        return sorted(\n",
    "            list(zip(all_words,num_differ)),\n",
    "            key=sort_by,\n",
    "            reverse=True,\n",
    "        )\n",
    "    \n",
    "    \n",
    "    for trial in range(1,7):\n",
    "        \n",
    "        guest_result = p.guess(our_guess)      \n",
    "        \n",
    "        # Below counts the number of appearance of letter at each position of the 5-letter word\n",
    "        Letter_Counter = [Counter(chain.from_iterable([word[x] for word in possible_guess])) for x in range(5)]  \n",
    "        \n",
    "        # Below calculates the frequency of letter at each position of the 5-letter word\n",
    "        Letter_Frequency = [{character: value / Letter_Counter[x].total() for character, value in Letter_Counter[x].items()} for x in range(5)] \n",
    "\n",
    "            \n",
    "        if p.is_solved(): \n",
    "            break\n",
    "        else: \n",
    "            green_pois = [x for x in range(5) if guest_result[x] == \"🟩\"]\n",
    "            yellow_pois = [x for x in range(5) if guest_result[x] == \"🟨\"]\n",
    "            gray_pois = [x for x in range(5) if guest_result[x] == \"⬜\"]\n",
    "            \n",
    "            green_letter = set([our_guess[i] for i in range(5) if i in set(green_pois)])\n",
    "            green_letter_all.update((green_letter))\n",
    "            \n",
    "            yellow_letter = set([our_guess[i] for i in range(5) if i in set(yellow_pois)])\n",
    "            gray_letter = set([our_guess[i] for i in range(5) if i in set(gray_pois)])\n",
    "            \n",
    "            wrong_letter = gray_letter - yellow_letter\n",
    "            wrong_letter_all.update((wrong_letter))\n",
    "\n",
    "            for i in green_pois: # filter possible_guess on green letters\n",
    "                possible_guess = [x for x in possible_guess if \n",
    "                                  our_guess[i] == x[i]]  \n",
    "                \n",
    "            for j in gray_pois: # filter possible_guess on wrong letters\n",
    "                possible_guess = [x for x in possible_guess if \n",
    "                                   x[j] not in wrong_letter]\n",
    "                                \n",
    "            for k in yellow_pois: # filter possible_guess on yellow letters\n",
    "                possible_guess = [x for x in possible_guess if \n",
    "                                  our_guess[k] != x[k] and \n",
    "                                  our_guess[k] in set([x[j] for j in range(len(list(x))) if j not in set(green_pois)])]\n",
    "\n",
    "#            if trial == 1:\n",
    "#                our_guess = \"other\" alternative\n",
    "            if \"🟨\" not in guest_result and trial in [1,2,3] and len(possible_guess) >= 3:\n",
    "        \n",
    "                # Chunk below sorts out the words that have the maximum number of unguessed letters, and use it as the next guess\n",
    "                num_differ = [len(set(x).difference(wrong_letter_all,green_letter_all)) for x in all_words]\n",
    "                max_diff = sort_by_num_difference(all_words)[0][1]\n",
    "                eliminate_guess = [x for (x,y) in sort_by_num_difference(all_words) if y == max_diff][:1]\n",
    "                our_guess = random.choice(eliminate_guess)              \n",
    "            else: \n",
    "                narrow_guess = sort_by_word_commonality(possible_guess)[:4]\n",
    "                our_guess = random.choice([x for (x,y) in narrow_guess])\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " This function is built as a wordle solver using python. \n",
      " It should be used in accompany with the `wordle.py` and `wordle.txt` files. \n",
      " The input should be a world puzzle object. \n",
      " The output will return the status of the puzzle.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(puzzle_solver.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assessment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solved 96 of 100 puzzles attempted.\n",
      "Average # of guesses required: 4.5\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "#random.seed(1234)\n",
    "n = 100  # can change to a large number if needed\n",
    "\n",
    "# Change both the seed value and `n` of puzzles to get \n",
    "# a more accurate view of your solver's performance.\n",
    "\n",
    "puzzles  = [wordle.puzzle() for i in range(n)]\n",
    "attempts = [puzzle_solver(p) for p in puzzles]\n",
    "solved   = [p for p in puzzles if p.is_solved()]\n",
    "n_guess  = [p.n_guesses() for p in solved]\n",
    "\n",
    "print(f\"Solved {len(solved)} of {len(puzzles)} puzzles attempted.\")\n",
    "if (len(solved) != 0):\n",
    "    print(f\"Average # of guesses required: {sum(n_guess)/len(n_guess)}\")                         "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}