{
 "metadata": {
  "name": "",
  "signature": "sha256:07f366ec645d178071697c25c43d438fd80cf3a676ad9bd8d7613f5bfa36adf5"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import re\n",
      "import random\n",
      "import string\n",
      "import collections"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "WORDS = [w.strip() for w in open('/usr/share/dict/british-english').readlines() \n",
      "         if re.match(r'^[a-z]*$', w.strip())]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "LETTER_COUNTS = collections.Counter(l.lower() for l in open('sherlock-holmes.txt').read() if l in string.ascii_letters)\n",
      "LETTERS_IN_ORDER = [p[0] for p in LETTER_COUNTS.most_common()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "STARTING_LIVES = 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Game:\n",
      "    def __init__(self, target, player=None, lives=STARTING_LIVES):\n",
      "        self.lives = lives\n",
      "        self.player = player\n",
      "        self.target = target\n",
      "        self.discovered = list('_' * len(target))\n",
      "        self.wrong_letters = []\n",
      "        self.game_finished = False\n",
      "        self.game_won = False\n",
      "        self.game_lost = False\n",
      "    \n",
      "    def find_all(self, letter):\n",
      "        locations = []\n",
      "        starting=0\n",
      "        location = self.target.find(letter)\n",
      "        while location > -1:\n",
      "            locations += [location]\n",
      "            starting = location + 1\n",
      "            location = self.target.find(letter, starting)\n",
      "        return locations\n",
      "    \n",
      "    def update_discovered_word(self, guessed_letter):\n",
      "        locations = self.find_all(guessed_letter)\n",
      "        for location in locations:\n",
      "            self.discovered[location] = guessed_letter\n",
      "        return self.discovered\n",
      "    \n",
      "    def do_turn(self):\n",
      "        if self.player:\n",
      "            guess = self.player.guess(self.discovered, self.wrong_letters, self.lives)\n",
      "        else:\n",
      "            guess = self.ask_for_guess()\n",
      "        if guess in self.target:\n",
      "            self.update_discovered_word(guess)\n",
      "        else:\n",
      "            self.lives -= 1\n",
      "            if guess not in self.wrong_letters:\n",
      "                self.wrong_letters += [guess]\n",
      "        if self.lives == 0:\n",
      "            self.game_finished = True\n",
      "            self.game_lost = True\n",
      "        if '_' not in self.discovered:\n",
      "            self.game_finished = True\n",
      "            self.game_won = True\n",
      "            \n",
      "    def ask_for_guess(self):\n",
      "        print('Word:', ' '.join(self.discovered), \n",
      "              ' : Lives =', self.lives, \n",
      "              ', wrong guesses:', ' '.join(sorted(self.wrong_letters)))\n",
      "        guess = input('Enter letter: ').strip().lower()[0]\n",
      "        return guess\n",
      "    \n",
      "    def play_game(self):\n",
      "        while not self.game_finished:\n",
      "            self.do_turn()\n",
      "        if not self.player:\n",
      "            self.report_on_game()\n",
      "        return self.game_won\n",
      "    \n",
      "    def report_on_game(self):\n",
      "        if self.game_won:\n",
      "            print('You won! The word was', self.target)\n",
      "        else:\n",
      "            print('You lost. The word was', self.target)\n",
      "        return self.game_won"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerFixedOrder:\n",
      "    def __init__(self, ordered_letters):\n",
      "        self.ordered_letters = ordered_letters\n",
      "        \n",
      "    def guess(self, discovered, missed, lives):\n",
      "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
      "        self.ordered_subtract(guessed_letters)\n",
      "        return self.ordered_letters[0]\n",
      "\n",
      "    def ordered_subtract(self, to_remove):\n",
      "        for r in to_remove:\n",
      "            if r in self.ordered_letters:\n",
      "                ri = self.ordered_letters.index(r)\n",
      "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAlphabetical(PlayerFixedOrder):\n",
      "    def __init__(self):\n",
      "        super().__init__(string.ascii_lowercase)\n",
      "\n",
      "class PlayerFreqOrdered(PlayerFixedOrder):\n",
      "    def __init__(self):\n",
      "        super().__init__(LETTERS_IN_ORDER)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAlphabetical())\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "43\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerFreqOrdered())\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "316\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerFixedOrder(list(reversed(string.ascii_lowercase))))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "DICT_COUNTS = collections.Counter(l.lower() for l in open('/usr/share/dict/british-english').read() if l in string.ascii_letters)\n",
      "DICT_LETTERS_IN_ORDER = [p[0] for p in DICT_COUNTS.most_common()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "DICT_COUNTS"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "Counter({'s': 91332, 'e': 88692, 'i': 66900, 'a': 64468, 'r': 57460, 'n': 57128, 't': 52949, 'o': 49121, 'l': 40995, 'c': 31854, 'd': 28505, 'u': 26372, 'g': 22693, 'm': 22549, 'p': 22249, 'h': 19337, 'b': 15540, 'y': 12652, 'f': 10679, 'k': 8386, 'v': 8000, 'w': 7505, 'x': 2125, 'z': 2058, 'j': 1950, 'q': 1536})"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(DICT_LETTERS_IN_ORDER)\n",
      "print(LETTERS_IN_ORDER)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['s', 'e', 'i', 'a', 'r', 'n', 't', 'o', 'l', 'c', 'd', 'u', 'g', 'm', 'p', 'h', 'b', 'y', 'f', 'k', 'v', 'w', 'x', 'z', 'j', 'q']\n",
        "['e', 't', 'a', 'o', 'i', 'h', 'n', 's', 'r', 'd', 'l', 'u', 'm', 'w', 'c', 'y', 'f', 'g', 'p', 'b', 'v', 'k', 'x', 'j', 'q', 'z']\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerFixedOrder(DICT_LETTERS_IN_ORDER))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "473\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptiveLength:\n",
      "    def __init__(self, words):\n",
      "        self.all_words = words\n",
      "        self.candidate_words = None\n",
      "        \n",
      "    def guess(self, discovered, missed, lives):\n",
      "        if not self.candidate_words:\n",
      "            self.set_ordered_letters(len(discovered))\n",
      "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
      "        self.ordered_subtract(guessed_letters)\n",
      "        return self.ordered_letters[0]\n",
      "\n",
      "    def ordered_subtract(self, to_remove):\n",
      "        for r in to_remove:\n",
      "            if r in self.ordered_letters:\n",
      "                ri = self.ordered_letters.index(r)\n",
      "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
      "    \n",
      "    def set_ordered_letters(self, word_len):\n",
      "        self.candidate_words = [w for w in self.all_words if len(w) == word_len]\n",
      "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
      "        self.ordered_letters = [p[0] for p in counts.most_common()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptiveLength(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "489\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptiveIncludedLetters:\n",
      "    def __init__(self, words):\n",
      "        self.candidate_words = words\n",
      "        \n",
      "    def guess(self, discovered, missed, lives):\n",
      "        self.filter_candidate_words(discovered)\n",
      "        self.set_ordered_letters()\n",
      "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
      "        self.ordered_subtract(guessed_letters)\n",
      "        return self.ordered_letters[0]\n",
      "\n",
      "    def ordered_subtract(self, to_remove):\n",
      "        for r in to_remove:\n",
      "            if r in self.ordered_letters:\n",
      "                ri = self.ordered_letters.index(r)\n",
      "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
      "    \n",
      "    def filter_candidate_words(self, discovered):\n",
      "        exp = re.compile('^' + ''.join(discovered).replace('_', '.') + '$')\n",
      "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]\n",
      "        \n",
      "    def set_ordered_letters(self):\n",
      "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
      "        self.ordered_letters = [p[0] for p in counts.most_common()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptiveIncludedLetters(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "979\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "re.match('^[^xaz]*$', 'happy')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptiveExcludedLetters:\n",
      "    def __init__(self, words):\n",
      "        self.candidate_words = words\n",
      "        \n",
      "    def guess(self, discovered, missed, lives):\n",
      "        self.filter_candidate_words(missed)\n",
      "        self.set_ordered_letters()\n",
      "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
      "        self.ordered_subtract(guessed_letters)\n",
      "        return self.ordered_letters[0]\n",
      "\n",
      "    def ordered_subtract(self, to_remove):\n",
      "        for r in to_remove:\n",
      "            if r in self.ordered_letters:\n",
      "                ri = self.ordered_letters.index(r)\n",
      "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
      "    \n",
      "    def filter_candidate_words(self, missed):\n",
      "        if missed:\n",
      "            exp = re.compile('^[^' + ''.join(missed) + ']*$')\n",
      "            self.candidate_words = [w for w in self.candidate_words if exp.match(w)]\n",
      "        \n",
      "    def set_ordered_letters(self):\n",
      "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
      "        self.ordered_letters = [p[0] for p in counts.most_common()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptiveExcludedLetters(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "512\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptivePattern:\n",
      "    def __init__(self, words):\n",
      "        self.candidate_words = words\n",
      "        \n",
      "    def guess(self, discovered, missed, lives):\n",
      "        self.filter_candidate_words(discovered, missed)\n",
      "        self.set_ordered_letters()\n",
      "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
      "        self.ordered_subtract(guessed_letters)\n",
      "        return self.ordered_letters[0]\n",
      "\n",
      "    def ordered_subtract(self, to_remove):\n",
      "        for r in to_remove:\n",
      "            if r in self.ordered_letters:\n",
      "                ri = self.ordered_letters.index(r)\n",
      "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
      "    \n",
      "    def filter_candidate_words(self, discovered, missed):\n",
      "        attempted_letters = list(set(l.lower() for l in discovered + missed if l in string.ascii_letters))\n",
      "        if attempted_letters:\n",
      "            exclusion_pattern = '[^' + ''.join(attempted_letters) + ']'\n",
      "        else:\n",
      "            exclusion_pattern = '.'\n",
      "        exp = re.compile('^' + ''.join(discovered).replace('_', exclusion_pattern) + '$')\n",
      "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]\n",
      "        \n",
      "    def set_ordered_letters(self):\n",
      "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
      "        self.ordered_letters = [p[0] for p in counts.most_common()]\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "990\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "\n",
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "986\n",
        "996"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "991"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "990"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1 loops, best of 3: 57.2 s per loop\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptive:\n",
      "    def __init__(self, words):\n",
      "        self.candidate_words = words\n",
      "        \n",
      "    def guess(self, discovered, missed, lives):\n",
      "        self.filter_candidate_words(discovered, missed)\n",
      "        self.set_ordered_letters()\n",
      "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
      "        self.ordered_subtract(guessed_letters)\n",
      "        return self.ordered_letters[0]\n",
      "\n",
      "    def ordered_subtract(self, to_remove):\n",
      "        for r in to_remove:\n",
      "            if r in self.ordered_letters:\n",
      "                ri = self.ordered_letters.index(r)\n",
      "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
      "    \n",
      "    def filter_candidate_words(self, discovered, missed):\n",
      "        pass\n",
      "        \n",
      "    def set_ordered_letters(self):\n",
      "        counts = collections.Counter(l.lower() \n",
      "                                     for l in ''.join(self.candidate_words) + string.ascii_lowercase \n",
      "                                     if l in string.ascii_letters)\n",
      "        self.ordered_letters = [p[0] for p in counts.most_common()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptiveLength(PlayerAdaptive):\n",
      "    def __init__(self, words):\n",
      "        super().__init__(words)\n",
      "        self.word_len = None\n",
      "        self.ordered_letters = None\n",
      "        \n",
      "    def filter_candidate_words(self, discovered, missed):\n",
      "        if not self.word_len:\n",
      "            self.word_len = len(discovered)\n",
      "            self.candidate_words = [w for w in self.candidate_words if len(w) == self.word_len]\n",
      "    \n",
      "    def set_ordered_letters(self):\n",
      "        if not self.ordered_letters:\n",
      "            super().set_ordered_letters()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptiveIncludedLetters(PlayerAdaptive):\n",
      "    def filter_candidate_words(self, discovered, missed):\n",
      "        exp = re.compile('^' + ''.join(discovered).replace('_', '.') + '$')\n",
      "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptiveExcludedLetters(PlayerAdaptive):\n",
      "    def filter_candidate_words(self, discovered, missed):\n",
      "        if missed:\n",
      "            exp = re.compile('^[^' + ''.join(missed) + ']*$')\n",
      "            self.candidate_words = [w for w in self.candidate_words if exp.match(w)]        "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PlayerAdaptivePattern(PlayerAdaptive):\n",
      "    def filter_candidate_words(self, discovered, missed):\n",
      "        attempted_letters = [l for l in discovered if l != '_'] + missed\n",
      "        if attempted_letters:\n",
      "            exclusion_pattern = '[^' + ''.join(attempted_letters) + ']'\n",
      "        else:\n",
      "            exclusion_pattern = '.'\n",
      "        exp = re.compile('^' + ''.join(discovered).replace('_', exclusion_pattern) + '$')\n",
      "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "\n",
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptiveLength(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "463\n",
        "492"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "451"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "448"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1 loops, best of 3: 30.9 s per loop\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "\n",
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptiveIncludedLetters(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "985\n",
        "972"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "976"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "986"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1 loops, best of 3: 1min 8s per loop\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "\n",
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptiveExcludedLetters(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "502\n",
        "491"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "537"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "524"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1 loops, best of 3: 13min 6s per loop\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%timeit\n",
      "\n",
      "wins = 0\n",
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "993\n",
        "991"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "994"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "989"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "1 loops, best of 3: 56.6 s per loop\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for _ in range(1000):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
      "    g.play_game()\n",
      "    if not g.game_won:\n",
      "        print(g.target, g.discovered, g.wrong_letters)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "jutting ['_', 'u', 't', 't', 'i', 'n', 'g'] ['e', 'a', 'o', 'l', 's', 'f', 'p', 'b', 'c', 'r']\n",
        "faze"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ['_', 'a', '_', 'e'] ['r', 'l', 'm', 'p', 's', 'g', 'b', 'd', 'v', 'k']\n",
        "fate"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ['_', 'a', '_', 'e'] ['r', 'l', 'm', 'p', 's', 'g', 'b', 'd', 'v', 'k']\n",
        "dunk"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ['_', 'u', 'n', 'k'] ['e', 's', 'o', 'a', 'i', 'l', 'f', 'r', 'j', 'p']\n",
        "loons"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ['_', 'o', 'o', 'n', 's'] ['e', 't', 'k', 'm', 'p', 'd', 'f', 'c', 'b', 'g']\n",
        "lab"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ['_', 'a', 'b'] ['t', 'p', 'g', 'w', 'm', 'd', 'y', 'r', 'c', 'n']\n",
        "joked"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ['_', 'o', 'k', 'e', 'd'] ['s', 'a', 'w', 'p', 't', 'r', 'h', 'b', 'y', 'c']\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "iterations = 10000\n",
      "wins = 0\n",
      "for _ in range(iterations):\n",
      "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
      "    g.play_game()\n",
      "    if g.game_won:\n",
      "        wins += 1\n",
      "print(wins / iterations)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0.9923\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}