stats.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pickle \n",
    "import os \n",
    "import re \n",
    "import time as tm\n",
    "import pandas\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_obj(obj, filename): \n",
    "    with open('data/' + filename + '.pkl', 'wb+') as f: \n",
    "        pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)\n",
    "def load_obj(filename): \n",
    "    with open('data/' + filename + '.pkl', 'rb') as f: \n",
    "        return pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class hangman: \n",
    "    \n",
    "    # Constructor \n",
    "    # Instance variables = [word, length, regex pattern, dictionary of characters, \n",
    "    #                       list of characters, number of wrong guesses]\n",
    "    def __init__(self, word): \n",
    "        self.word = word # secret word \n",
    "        self.length = len(word) #length of word \n",
    "        self.pattern = r'^(.{' + re.escape(str(self.length)) + '})$' # regex pattern of game\n",
    "        self.charDict = {} # dictionary of all attempted characters\n",
    "        self.charList = [] # list of successful characters \n",
    "        for x in range(self.length):\n",
    "            self.charList.append('.') \n",
    "        self.wrong_guesses = 0 # number of wrong guesses \n",
    "        self.correct = 0 \n",
    "    \n",
    "    # attempt a character \n",
    "    # increment wrong guess by 1 if incorrect \n",
    "    # do not let the same letter be tried twice \n",
    "    # returns boolean if char is present/absent \n",
    "    def attempt(self, char): \n",
    "        x = self.charDict.get(char, 0)\n",
    "        if x == 0: \n",
    "            self.charDict[char] = True \n",
    "            indexList = self.find(char)\n",
    "            self.correct += len(indexList)\n",
    "            if len(indexList) == 0: \n",
    "                self.wrong_guesses += 1 \n",
    "                # print('bad guess')\n",
    "            for index in indexList:\n",
    "                self.charList[index] = self.word[index]\n",
    "            self.pattern = self.arrToRegex(self.charList)\n",
    "            return len(indexList) != 0  \n",
    "\n",
    "        else:\n",
    "            print(\"you've already tried this letter\")\n",
    "    \n",
    "    \n",
    "    # find the indices at which character ch appears \n",
    "    def find(self, ch):\n",
    "        return [i for i, ltr in enumerate(self.word) if ltr == ch]\n",
    "\n",
    "    # convert a list of characters to regex \n",
    "    def arrToRegex(self, list_of_characters):\n",
    "        reg = r'^('\n",
    "        for item in list_of_characters: \n",
    "            reg = reg + item \n",
    "        reg = reg + ')$' \n",
    "        return reg \n",
    "            \n",
    "    # return the regex pattern \n",
    "    def regex(self): \n",
    "        return self.pattern\n",
    "    \n",
    "    # remove all words that do not have a particular character \n",
    "    def remove(self, list_of_words, char):\n",
    "        list_of_matches = []\n",
    "        pattern = r'(.*' + char + '.*)'\n",
    "        for item in list_of_words:\n",
    "            x = re.match(pattern, item)\n",
    "            if x == None:\n",
    "                list_of_matches.append(item)\n",
    "        return list_of_matches\n",
    "\n",
    "    # return all regex matches from a list of words \n",
    "    def match(self, list_of_words, pattern):\n",
    "        list_of_matches = []\n",
    "        for item in list_of_words: \n",
    "            x = re.search(pattern, item)\n",
    "            if x != None:\n",
    "                list_of_matches.append(item)\n",
    "        return list_of_matches \n",
    "\n",
    "    # frequency of characters given a list of words \n",
    "    def charFrequency(self, list_of_words): \n",
    "        dict_of_characters = {}\n",
    "        for item in list_of_words: \n",
    "            arr_char = list(item)\n",
    "            for x in arr_char: \n",
    "                dict_of_characters[x] = dict_of_characters.get(x, 0) + 1\n",
    "        return dict_of_characters \n",
    "\n",
    "    # guess the next words \n",
    "    def greedy_guess(self, list_of_words):\n",
    "        freq_char = self.charFrequency(list_of_words)\n",
    "        temp_freq_char = self.charFrequency(list_of_words)\n",
    "        for item in temp_freq_char:\n",
    "            x = self.charDict.get(item, 0)\n",
    "            if x != 0: \n",
    "                del freq_char[item]\n",
    "        freq_char_keys = list(freq_char.keys())\n",
    "        freq_char_values = list(freq_char.values())\n",
    "        maxIndex = np.where(freq_char_values == np.amax(freq_char_values))[0]\n",
    "        return freq_char_keys[np.random.choice(maxIndex)]\n",
    "    \n",
    "    def charSet(self, list_of_words):\n",
    "        dict_of_characters = {}\n",
    "        for item in list_of_words:\n",
    "            arr_char = dict(zip(list(item), list(item))).keys()\n",
    "            for x in arr_char:\n",
    "                dict_of_characters[x] = dict_of_characters.get(x, 0) + 1\n",
    "        return dict_of_characters \n",
    "    \n",
    "    # guess the next words \n",
    "    def greedy_set(self, list_of_words):\n",
    "        freq_char = self.charSet(list_of_words)\n",
    "        temp_freq_char = self.charSet(list_of_words)\n",
    "        for item in temp_freq_char:\n",
    "            x = self.charDict.get(item, 0)\n",
    "            if x != 0: \n",
    "                del freq_char[item]\n",
    "        freq_char_keys = list(freq_char.keys())\n",
    "        freq_char_values = list(freq_char.values())\n",
    "        maxIndex = np.where(freq_char_values == np.amax(freq_char_values))[0]\n",
    "        return freq_char_keys[maxIndex[0]]\n",
    "    \n",
    "    def game(self):\n",
    "        word = self.word\n",
    "        low = length_word[len(word)]\n",
    "        while self.correct != len(word): \n",
    "            a = self.greedy_guess(low)\n",
    "            if (self.attempt(a)): \n",
    "                low = self.match(low, self.regex())\n",
    "        \n",
    "    def game_set(self):\n",
    "        word = self.word\n",
    "        low = length_word[len(word)]\n",
    "        while self.correct != len(word): \n",
    "            a = self.greedy_set(low)\n",
    "            if (self.attempt(a)): \n",
    "                low = self.match(low, self.regex())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_words = load_obj('english_words')\n",
    "word_length = load_obj('word_length_english')\n",
    "length_word = load_obj('length_word_english')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns N random words from dictionary \n",
    "def randomWord(N): \n",
    "    return [english_words[i] for i in np.random.choice(len(english_words), N)]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sort dictionary by keys\n",
    "# keys are assumed to be real numbers \n",
    "def sort_dict(mydict1): \n",
    "    x = list(mydict1.keys())\n",
    "    y = np.argsort(x)\n",
    "    x = np.sort(x)\n",
    "    z = list(mydict1.values())\n",
    "    k = []\n",
    "    for i in range(len(z)): \n",
    "        k.append(z[i])\n",
    "    mydict2 = dict(zip(x, k))\n",
    "    return mydict2\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_frequency(a):\n",
    "    letter_counts = Counter(a)\n",
    "    letter_counts = sort_dict(letter_counts)\n",
    "    df = pandas.DataFrame.from_dict(letter_counts, orient='index')\n",
    "    df.plot(kind='bar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # create a dataset of 10k words \n",
    "# words = randomWord(10000)\n",
    "# save_obj(words, '10k_words')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = load_obj('10k_words')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2105.5402266979218\n"
     ]
    }
   ],
   "source": [
    "# test the greedy heuristic \n",
    "# 2105.54 seconds \n",
    "timeline = tm.time()\n",
    "wrong_guesses = []\n",
    "for item in words: \n",
    "    h1 = hangman(item)\n",
    "    h1.game()\n",
    "    wrong_guesses.append(h1.wrong_guesses)\n",
    "\n",
    "print(tm.time() - timeline)\n",
    "save_obj(wrong_guesses, '10k_greedy_stats')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_frequency(wrong_guesses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.04378628730774\n"
     ]
    }
   ],
   "source": [
    "# test the greedy no repetition heuristic  \n",
    "timeline = tm.time()\n",
    "wrong_guesses = []\n",
    "words = words[:100]\n",
    "for item in words: \n",
    "    h1 = hangman(item)\n",
    "    h1.game_set()\n",
    "    wrong_guesses.append(h1.wrong_guesses)\n",
    "\n",
    "print(tm.time() - timeline)\n",
    "save_obj(wrong_guesses, '10k_greedy_set_stats')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_frequency(wrong_guesses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}