hangman-better.ipynb

   1 {
   2  "metadata": {
   3   "name": "",
   4   "signature": "sha256:07f366ec645d178071697c25c43d438fd80cf3a676ad9bd8d7613f5bfa36adf5"
   5  },
   6  "nbformat": 3,
   7  "nbformat_minor": 0,
   8  "worksheets": [
   9   {
  10    "cells": [
  11     {
  12      "cell_type": "code",
  13      "collapsed": false,
  14      "input": [
  15       "import re\n",
  16       "import random\n",
  17       "import string\n",
  18       "import collections"
  19      ],
  20      "language": "python",
  21      "metadata": {},
  22      "outputs": [],
  23      "prompt_number": 1
  24     },
  25     {
  26      "cell_type": "code",
  27      "collapsed": false,
  28      "input": [
  29       "WORDS = [w.strip() for w in open('/usr/share/dict/british-english').readlines() \n",
  30       "         if re.match(r'^[a-z]*$', w.strip())]"
  31      ],
  32      "language": "python",
  33      "metadata": {},
  34      "outputs": [],
  35      "prompt_number": 2
  36     },
  37     {
  38      "cell_type": "code",
  39      "collapsed": false,
  40      "input": [
  41       "LETTER_COUNTS = collections.Counter(l.lower() for l in open('sherlock-holmes.txt').read() if l in string.ascii_letters)\n",
  42       "LETTERS_IN_ORDER = [p[0] for p in LETTER_COUNTS.most_common()]"
  43      ],
  44      "language": "python",
  45      "metadata": {},
  46      "outputs": [],
  47      "prompt_number": 3
  48     },
  49     {
  50      "cell_type": "code",
  51      "collapsed": false,
  52      "input": [
  53       "STARTING_LIVES = 10"
  54      ],
  55      "language": "python",
  56      "metadata": {},
  57      "outputs": [],
  58      "prompt_number": 4
  59     },
  60     {
  61      "cell_type": "code",
  62      "collapsed": false,
  63      "input": [
  64       "class Game:\n",
  65       "    def __init__(self, target, player=None, lives=STARTING_LIVES):\n",
  66       "        self.lives = lives\n",
  67       "        self.player = player\n",
  68       "        self.target = target\n",
  69       "        self.discovered = list('_' * len(target))\n",
  70       "        self.wrong_letters = []\n",
  71       "        self.game_finished = False\n",
  72       "        self.game_won = False\n",
  73       "        self.game_lost = False\n",
  74       "    \n",
  75       "    def find_all(self, letter):\n",
  76       "        locations = []\n",
  77       "        starting=0\n",
  78       "        location = self.target.find(letter)\n",
  79       "        while location > -1:\n",
  80       "            locations += [location]\n",
  81       "            starting = location + 1\n",
  82       "            location = self.target.find(letter, starting)\n",
  83       "        return locations\n",
  84       "    \n",
  85       "    def update_discovered_word(self, guessed_letter):\n",
  86       "        locations = self.find_all(guessed_letter)\n",
  87       "        for location in locations:\n",
  88       "            self.discovered[location] = guessed_letter\n",
  89       "        return self.discovered\n",
  90       "    \n",
  91       "    def do_turn(self):\n",
  92       "        if self.player:\n",
  93       "            guess = self.player.guess(self.discovered, self.wrong_letters, self.lives)\n",
  94       "        else:\n",
  95       "            guess = self.ask_for_guess()\n",
  96       "        if guess in self.target:\n",
  97       "            self.update_discovered_word(guess)\n",
  98       "        else:\n",
  99       "            self.lives -= 1\n",
 100       "            if guess not in self.wrong_letters:\n",
 101       "                self.wrong_letters += [guess]\n",
 102       "        if self.lives == 0:\n",
 103       "            self.game_finished = True\n",
 104       "            self.game_lost = True\n",
 105       "        if '_' not in self.discovered:\n",
 106       "            self.game_finished = True\n",
 107       "            self.game_won = True\n",
 108       "            \n",
 109       "    def ask_for_guess(self):\n",
 110       "        print('Word:', ' '.join(self.discovered), \n",
 111       "              ' : Lives =', self.lives, \n",
 112       "              ', wrong guesses:', ' '.join(sorted(self.wrong_letters)))\n",
 113       "        guess = input('Enter letter: ').strip().lower()[0]\n",
 114       "        return guess\n",
 115       "    \n",
 116       "    def play_game(self):\n",
 117       "        while not self.game_finished:\n",
 118       "            self.do_turn()\n",
 119       "        if not self.player:\n",
 120       "            self.report_on_game()\n",
 121       "        return self.game_won\n",
 122       "    \n",
 123       "    def report_on_game(self):\n",
 124       "        if self.game_won:\n",
 125       "            print('You won! The word was', self.target)\n",
 126       "        else:\n",
 127       "            print('You lost. The word was', self.target)\n",
 128       "        return self.game_won"
 129      ],
 130      "language": "python",
 131      "metadata": {},
 132      "outputs": [],
 133      "prompt_number": 5
 134     },
 135     {
 136      "cell_type": "code",
 137      "collapsed": false,
 138      "input": [
 139       "class PlayerFixedOrder:\n",
 140       "    def __init__(self, ordered_letters):\n",
 141       "        self.ordered_letters = ordered_letters\n",
 142       "        \n",
 143       "    def guess(self, discovered, missed, lives):\n",
 144       "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
 145       "        self.ordered_subtract(guessed_letters)\n",
 146       "        return self.ordered_letters[0]\n",
 147       "\n",
 148       "    def ordered_subtract(self, to_remove):\n",
 149       "        for r in to_remove:\n",
 150       "            if r in self.ordered_letters:\n",
 151       "                ri = self.ordered_letters.index(r)\n",
 152       "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]"
 153      ],
 154      "language": "python",
 155      "metadata": {},
 156      "outputs": [],
 157      "prompt_number": 6
 158     },
 159     {
 160      "cell_type": "code",
 161      "collapsed": false,
 162      "input": [
 163       "class PlayerAlphabetical(PlayerFixedOrder):\n",
 164       "    def __init__(self):\n",
 165       "        super().__init__(string.ascii_lowercase)\n",
 166       "\n",
 167       "class PlayerFreqOrdered(PlayerFixedOrder):\n",
 168       "    def __init__(self):\n",
 169       "        super().__init__(LETTERS_IN_ORDER)\n"
 170      ],
 171      "language": "python",
 172      "metadata": {},
 173      "outputs": [],
 174      "prompt_number": 7
 175     },
 176     {
 177      "cell_type": "code",
 178      "collapsed": false,
 179      "input": [
 180       "wins = 0\n",
 181       "for _ in range(1000):\n",
 182       "    g = Game(random.choice(WORDS), player=PlayerAlphabetical())\n",
 183       "    g.play_game()\n",
 184       "    if g.game_won:\n",
 185       "        wins += 1\n",
 186       "print(wins)"
 187      ],
 188      "language": "python",
 189      "metadata": {},
 190      "outputs": [
 191       {
 192        "output_type": "stream",
 193        "stream": "stdout",
 194        "text": [
 195         "43\n"
 196        ]
 197       }
 198      ],
 199      "prompt_number": 8
 200     },
 201     {
 202      "cell_type": "code",
 203      "collapsed": false,
 204      "input": [
 205       "wins = 0\n",
 206       "for _ in range(1000):\n",
 207       "    g = Game(random.choice(WORDS), player=PlayerFreqOrdered())\n",
 208       "    g.play_game()\n",
 209       "    if g.game_won:\n",
 210       "        wins += 1\n",
 211       "print(wins)"
 212      ],
 213      "language": "python",
 214      "metadata": {},
 215      "outputs": [
 216       {
 217        "output_type": "stream",
 218        "stream": "stdout",
 219        "text": [
 220         "316\n"
 221        ]
 222       }
 223      ],
 224      "prompt_number": 9
 225     },
 226     {
 227      "cell_type": "code",
 228      "collapsed": false,
 229      "input": [
 230       "wins = 0\n",
 231       "for _ in range(1000):\n",
 232       "    g = Game(random.choice(WORDS), player=PlayerFixedOrder(list(reversed(string.ascii_lowercase))))\n",
 233       "    g.play_game()\n",
 234       "    if g.game_won:\n",
 235       "        wins += 1\n",
 236       "print(wins)"
 237      ],
 238      "language": "python",
 239      "metadata": {},
 240      "outputs": [
 241       {
 242        "output_type": "stream",
 243        "stream": "stdout",
 244        "text": [
 245         "5\n"
 246        ]
 247       }
 248      ],
 249      "prompt_number": 10
 250     },
 251     {
 252      "cell_type": "code",
 253      "collapsed": false,
 254      "input": [
 255       "DICT_COUNTS = collections.Counter(l.lower() for l in open('/usr/share/dict/british-english').read() if l in string.ascii_letters)\n",
 256       "DICT_LETTERS_IN_ORDER = [p[0] for p in DICT_COUNTS.most_common()]"
 257      ],
 258      "language": "python",
 259      "metadata": {},
 260      "outputs": [],
 261      "prompt_number": 11
 262     },
 263     {
 264      "cell_type": "code",
 265      "collapsed": false,
 266      "input": [
 267       "DICT_COUNTS"
 268      ],
 269      "language": "python",
 270      "metadata": {},
 271      "outputs": [
 272       {
 273        "metadata": {},
 274        "output_type": "pyout",
 275        "prompt_number": 12,
 276        "text": [
 277         "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})"
 278        ]
 279       }
 280      ],
 281      "prompt_number": 12
 282     },
 283     {
 284      "cell_type": "code",
 285      "collapsed": false,
 286      "input": [
 287       "print(DICT_LETTERS_IN_ORDER)\n",
 288       "print(LETTERS_IN_ORDER)"
 289      ],
 290      "language": "python",
 291      "metadata": {},
 292      "outputs": [
 293       {
 294        "output_type": "stream",
 295        "stream": "stdout",
 296        "text": [
 297         "['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",
 298         "['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"
 299        ]
 300       }
 301      ],
 302      "prompt_number": 13
 303     },
 304     {
 305      "cell_type": "code",
 306      "collapsed": false,
 307      "input": [
 308       "wins = 0\n",
 309       "for _ in range(1000):\n",
 310       "    g = Game(random.choice(WORDS), player=PlayerFixedOrder(DICT_LETTERS_IN_ORDER))\n",
 311       "    g.play_game()\n",
 312       "    if g.game_won:\n",
 313       "        wins += 1\n",
 314       "print(wins)"
 315      ],
 316      "language": "python",
 317      "metadata": {},
 318      "outputs": [
 319       {
 320        "output_type": "stream",
 321        "stream": "stdout",
 322        "text": [
 323         "473\n"
 324        ]
 325       }
 326      ],
 327      "prompt_number": 14
 328     },
 329     {
 330      "cell_type": "code",
 331      "collapsed": false,
 332      "input": [
 333       "class PlayerAdaptiveLength:\n",
 334       "    def __init__(self, words):\n",
 335       "        self.all_words = words\n",
 336       "        self.candidate_words = None\n",
 337       "        \n",
 338       "    def guess(self, discovered, missed, lives):\n",
 339       "        if not self.candidate_words:\n",
 340       "            self.set_ordered_letters(len(discovered))\n",
 341       "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
 342       "        self.ordered_subtract(guessed_letters)\n",
 343       "        return self.ordered_letters[0]\n",
 344       "\n",
 345       "    def ordered_subtract(self, to_remove):\n",
 346       "        for r in to_remove:\n",
 347       "            if r in self.ordered_letters:\n",
 348       "                ri = self.ordered_letters.index(r)\n",
 349       "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
 350       "    \n",
 351       "    def set_ordered_letters(self, word_len):\n",
 352       "        self.candidate_words = [w for w in self.all_words if len(w) == word_len]\n",
 353       "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
 354       "        self.ordered_letters = [p[0] for p in counts.most_common()]"
 355      ],
 356      "language": "python",
 357      "metadata": {},
 358      "outputs": [],
 359      "prompt_number": 15
 360     },
 361     {
 362      "cell_type": "code",
 363      "collapsed": false,
 364      "input": [
 365       "wins = 0\n",
 366       "for _ in range(1000):\n",
 367       "    g = Game(random.choice(WORDS), player=PlayerAdaptiveLength(WORDS))\n",
 368       "    g.play_game()\n",
 369       "    if g.game_won:\n",
 370       "        wins += 1\n",
 371       "print(wins)"
 372      ],
 373      "language": "python",
 374      "metadata": {},
 375      "outputs": [
 376       {
 377        "output_type": "stream",
 378        "stream": "stdout",
 379        "text": [
 380         "489\n"
 381        ]
 382       }
 383      ],
 384      "prompt_number": 16
 385     },
 386     {
 387      "cell_type": "code",
 388      "collapsed": false,
 389      "input": [
 390       "class PlayerAdaptiveIncludedLetters:\n",
 391       "    def __init__(self, words):\n",
 392       "        self.candidate_words = words\n",
 393       "        \n",
 394       "    def guess(self, discovered, missed, lives):\n",
 395       "        self.filter_candidate_words(discovered)\n",
 396       "        self.set_ordered_letters()\n",
 397       "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
 398       "        self.ordered_subtract(guessed_letters)\n",
 399       "        return self.ordered_letters[0]\n",
 400       "\n",
 401       "    def ordered_subtract(self, to_remove):\n",
 402       "        for r in to_remove:\n",
 403       "            if r in self.ordered_letters:\n",
 404       "                ri = self.ordered_letters.index(r)\n",
 405       "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
 406       "    \n",
 407       "    def filter_candidate_words(self, discovered):\n",
 408       "        exp = re.compile('^' + ''.join(discovered).replace('_', '.') + '$')\n",
 409       "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]\n",
 410       "        \n",
 411       "    def set_ordered_letters(self):\n",
 412       "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
 413       "        self.ordered_letters = [p[0] for p in counts.most_common()]"
 414      ],
 415      "language": "python",
 416      "metadata": {},
 417      "outputs": [],
 418      "prompt_number": 17
 419     },
 420     {
 421      "cell_type": "code",
 422      "collapsed": false,
 423      "input": [
 424       "wins = 0\n",
 425       "for _ in range(1000):\n",
 426       "    g = Game(random.choice(WORDS), player=PlayerAdaptiveIncludedLetters(WORDS))\n",
 427       "    g.play_game()\n",
 428       "    if g.game_won:\n",
 429       "        wins += 1\n",
 430       "print(wins)"
 431      ],
 432      "language": "python",
 433      "metadata": {},
 434      "outputs": [
 435       {
 436        "output_type": "stream",
 437        "stream": "stdout",
 438        "text": [
 439         "979\n"
 440        ]
 441       }
 442      ],
 443      "prompt_number": 18
 444     },
 445     {
 446      "cell_type": "code",
 447      "collapsed": false,
 448      "input": [
 449       "re.match('^[^xaz]*$', 'happy')"
 450      ],
 451      "language": "python",
 452      "metadata": {},
 453      "outputs": [],
 454      "prompt_number": 19
 455     },
 456     {
 457      "cell_type": "code",
 458      "collapsed": false,
 459      "input": [
 460       "class PlayerAdaptiveExcludedLetters:\n",
 461       "    def __init__(self, words):\n",
 462       "        self.candidate_words = words\n",
 463       "        \n",
 464       "    def guess(self, discovered, missed, lives):\n",
 465       "        self.filter_candidate_words(missed)\n",
 466       "        self.set_ordered_letters()\n",
 467       "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
 468       "        self.ordered_subtract(guessed_letters)\n",
 469       "        return self.ordered_letters[0]\n",
 470       "\n",
 471       "    def ordered_subtract(self, to_remove):\n",
 472       "        for r in to_remove:\n",
 473       "            if r in self.ordered_letters:\n",
 474       "                ri = self.ordered_letters.index(r)\n",
 475       "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
 476       "    \n",
 477       "    def filter_candidate_words(self, missed):\n",
 478       "        if missed:\n",
 479       "            exp = re.compile('^[^' + ''.join(missed) + ']*$')\n",
 480       "            self.candidate_words = [w for w in self.candidate_words if exp.match(w)]\n",
 481       "        \n",
 482       "    def set_ordered_letters(self):\n",
 483       "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
 484       "        self.ordered_letters = [p[0] for p in counts.most_common()]"
 485      ],
 486      "language": "python",
 487      "metadata": {},
 488      "outputs": [],
 489      "prompt_number": 20
 490     },
 491     {
 492      "cell_type": "code",
 493      "collapsed": false,
 494      "input": [
 495       "wins = 0\n",
 496       "for _ in range(1000):\n",
 497       "    g = Game(random.choice(WORDS), player=PlayerAdaptiveExcludedLetters(WORDS))\n",
 498       "    g.play_game()\n",
 499       "    if g.game_won:\n",
 500       "        wins += 1\n",
 501       "print(wins)"
 502      ],
 503      "language": "python",
 504      "metadata": {},
 505      "outputs": [
 506       {
 507        "output_type": "stream",
 508        "stream": "stdout",
 509        "text": [
 510         "512\n"
 511        ]
 512       }
 513      ],
 514      "prompt_number": 21
 515     },
 516     {
 517      "cell_type": "code",
 518      "collapsed": false,
 519      "input": [
 520       "class PlayerAdaptivePattern:\n",
 521       "    def __init__(self, words):\n",
 522       "        self.candidate_words = words\n",
 523       "        \n",
 524       "    def guess(self, discovered, missed, lives):\n",
 525       "        self.filter_candidate_words(discovered, missed)\n",
 526       "        self.set_ordered_letters()\n",
 527       "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
 528       "        self.ordered_subtract(guessed_letters)\n",
 529       "        return self.ordered_letters[0]\n",
 530       "\n",
 531       "    def ordered_subtract(self, to_remove):\n",
 532       "        for r in to_remove:\n",
 533       "            if r in self.ordered_letters:\n",
 534       "                ri = self.ordered_letters.index(r)\n",
 535       "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
 536       "    \n",
 537       "    def filter_candidate_words(self, discovered, missed):\n",
 538       "        attempted_letters = list(set(l.lower() for l in discovered + missed if l in string.ascii_letters))\n",
 539       "        if attempted_letters:\n",
 540       "            exclusion_pattern = '[^' + ''.join(attempted_letters) + ']'\n",
 541       "        else:\n",
 542       "            exclusion_pattern = '.'\n",
 543       "        exp = re.compile('^' + ''.join(discovered).replace('_', exclusion_pattern) + '$')\n",
 544       "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]\n",
 545       "        \n",
 546       "    def set_ordered_letters(self):\n",
 547       "        counts = collections.Counter(l.lower() for l in ''.join(self.candidate_words) if l in string.ascii_letters)\n",
 548       "        self.ordered_letters = [p[0] for p in counts.most_common()]\n"
 549      ],
 550      "language": "python",
 551      "metadata": {},
 552      "outputs": [],
 553      "prompt_number": 22
 554     },
 555     {
 556      "cell_type": "code",
 557      "collapsed": false,
 558      "input": [
 559       "wins = 0\n",
 560       "for _ in range(1000):\n",
 561       "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
 562       "    g.play_game()\n",
 563       "    if g.game_won:\n",
 564       "        wins += 1\n",
 565       "print(wins)"
 566      ],
 567      "language": "python",
 568      "metadata": {},
 569      "outputs": [
 570       {
 571        "output_type": "stream",
 572        "stream": "stdout",
 573        "text": [
 574         "990\n"
 575        ]
 576       }
 577      ],
 578      "prompt_number": 23
 579     },
 580     {
 581      "cell_type": "code",
 582      "collapsed": false,
 583      "input": [
 584       "%%timeit\n",
 585       "\n",
 586       "wins = 0\n",
 587       "for _ in range(1000):\n",
 588       "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
 589       "    g.play_game()\n",
 590       "    if g.game_won:\n",
 591       "        wins += 1\n",
 592       "print(wins)"
 593      ],
 594      "language": "python",
 595      "metadata": {},
 596      "outputs": [
 597       {
 598        "output_type": "stream",
 599        "stream": "stdout",
 600        "text": [
 601         "986\n",
 602         "996"
 603        ]
 604       },
 605       {
 606        "output_type": "stream",
 607        "stream": "stdout",
 608        "text": [
 609         "\n",
 610         "991"
 611        ]
 612       },
 613       {
 614        "output_type": "stream",
 615        "stream": "stdout",
 616        "text": [
 617         "\n",
 618         "990"
 619        ]
 620       },
 621       {
 622        "output_type": "stream",
 623        "stream": "stdout",
 624        "text": [
 625         "\n",
 626         "1 loops, best of 3: 57.2 s per loop\n"
 627        ]
 628       }
 629      ],
 630      "prompt_number": 24
 631     },
 632     {
 633      "cell_type": "code",
 634      "collapsed": false,
 635      "input": [
 636       "class PlayerAdaptive:\n",
 637       "    def __init__(self, words):\n",
 638       "        self.candidate_words = words\n",
 639       "        \n",
 640       "    def guess(self, discovered, missed, lives):\n",
 641       "        self.filter_candidate_words(discovered, missed)\n",
 642       "        self.set_ordered_letters()\n",
 643       "        guessed_letters = [l.lower() for l in discovered + missed if l in string.ascii_letters]\n",
 644       "        self.ordered_subtract(guessed_letters)\n",
 645       "        return self.ordered_letters[0]\n",
 646       "\n",
 647       "    def ordered_subtract(self, to_remove):\n",
 648       "        for r in to_remove:\n",
 649       "            if r in self.ordered_letters:\n",
 650       "                ri = self.ordered_letters.index(r)\n",
 651       "                self.ordered_letters = self.ordered_letters[:ri] + self.ordered_letters[ri+1:]\n",
 652       "    \n",
 653       "    def filter_candidate_words(self, discovered, missed):\n",
 654       "        pass\n",
 655       "        \n",
 656       "    def set_ordered_letters(self):\n",
 657       "        counts = collections.Counter(l.lower() \n",
 658       "                                     for l in ''.join(self.candidate_words) + string.ascii_lowercase \n",
 659       "                                     if l in string.ascii_letters)\n",
 660       "        self.ordered_letters = [p[0] for p in counts.most_common()]"
 661      ],
 662      "language": "python",
 663      "metadata": {},
 664      "outputs": [],
 665      "prompt_number": 25
 666     },
 667     {
 668      "cell_type": "code",
 669      "collapsed": false,
 670      "input": [
 671       "class PlayerAdaptiveLength(PlayerAdaptive):\n",
 672       "    def __init__(self, words):\n",
 673       "        super().__init__(words)\n",
 674       "        self.word_len = None\n",
 675       "        self.ordered_letters = None\n",
 676       "        \n",
 677       "    def filter_candidate_words(self, discovered, missed):\n",
 678       "        if not self.word_len:\n",
 679       "            self.word_len = len(discovered)\n",
 680       "            self.candidate_words = [w for w in self.candidate_words if len(w) == self.word_len]\n",
 681       "    \n",
 682       "    def set_ordered_letters(self):\n",
 683       "        if not self.ordered_letters:\n",
 684       "            super().set_ordered_letters()"
 685      ],
 686      "language": "python",
 687      "metadata": {},
 688      "outputs": [],
 689      "prompt_number": 26
 690     },
 691     {
 692      "cell_type": "code",
 693      "collapsed": false,
 694      "input": [
 695       "class PlayerAdaptiveIncludedLetters(PlayerAdaptive):\n",
 696       "    def filter_candidate_words(self, discovered, missed):\n",
 697       "        exp = re.compile('^' + ''.join(discovered).replace('_', '.') + '$')\n",
 698       "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]"
 699      ],
 700      "language": "python",
 701      "metadata": {},
 702      "outputs": [],
 703      "prompt_number": 27
 704     },
 705     {
 706      "cell_type": "code",
 707      "collapsed": false,
 708      "input": [
 709       "class PlayerAdaptiveExcludedLetters(PlayerAdaptive):\n",
 710       "    def filter_candidate_words(self, discovered, missed):\n",
 711       "        if missed:\n",
 712       "            exp = re.compile('^[^' + ''.join(missed) + ']*$')\n",
 713       "            self.candidate_words = [w for w in self.candidate_words if exp.match(w)]        "
 714      ],
 715      "language": "python",
 716      "metadata": {},
 717      "outputs": [],
 718      "prompt_number": 28
 719     },
 720     {
 721      "cell_type": "code",
 722      "collapsed": false,
 723      "input": [
 724       "class PlayerAdaptivePattern(PlayerAdaptive):\n",
 725       "    def filter_candidate_words(self, discovered, missed):\n",
 726       "        attempted_letters = [l for l in discovered if l != '_'] + missed\n",
 727       "        if attempted_letters:\n",
 728       "            exclusion_pattern = '[^' + ''.join(attempted_letters) + ']'\n",
 729       "        else:\n",
 730       "            exclusion_pattern = '.'\n",
 731       "        exp = re.compile('^' + ''.join(discovered).replace('_', exclusion_pattern) + '$')\n",
 732       "        self.candidate_words = [w for w in self.candidate_words if exp.match(w)]"
 733      ],
 734      "language": "python",
 735      "metadata": {},
 736      "outputs": [],
 737      "prompt_number": 29
 738     },
 739     {
 740      "cell_type": "code",
 741      "collapsed": false,
 742      "input": [
 743       "%%timeit\n",
 744       "\n",
 745       "wins = 0\n",
 746       "for _ in range(1000):\n",
 747       "    g = Game(random.choice(WORDS), player=PlayerAdaptiveLength(WORDS))\n",
 748       "    g.play_game()\n",
 749       "    if g.game_won:\n",
 750       "        wins += 1\n",
 751       "print(wins)"
 752      ],
 753      "language": "python",
 754      "metadata": {},
 755      "outputs": [
 756       {
 757        "output_type": "stream",
 758        "stream": "stdout",
 759        "text": [
 760         "463\n",
 761         "492"
 762        ]
 763       },
 764       {
 765        "output_type": "stream",
 766        "stream": "stdout",
 767        "text": [
 768         "\n",
 769         "451"
 770        ]
 771       },
 772       {
 773        "output_type": "stream",
 774        "stream": "stdout",
 775        "text": [
 776         "\n",
 777         "448"
 778        ]
 779       },
 780       {
 781        "output_type": "stream",
 782        "stream": "stdout",
 783        "text": [
 784         "\n",
 785         "1 loops, best of 3: 30.9 s per loop\n"
 786        ]
 787       }
 788      ],
 789      "prompt_number": 30
 790     },
 791     {
 792      "cell_type": "code",
 793      "collapsed": false,
 794      "input": [
 795       "%%timeit\n",
 796       "\n",
 797       "wins = 0\n",
 798       "for _ in range(1000):\n",
 799       "    g = Game(random.choice(WORDS), player=PlayerAdaptiveIncludedLetters(WORDS))\n",
 800       "    g.play_game()\n",
 801       "    if g.game_won:\n",
 802       "        wins += 1\n",
 803       "print(wins)"
 804      ],
 805      "language": "python",
 806      "metadata": {},
 807      "outputs": [
 808       {
 809        "output_type": "stream",
 810        "stream": "stdout",
 811        "text": [
 812         "985\n",
 813         "972"
 814        ]
 815       },
 816       {
 817        "output_type": "stream",
 818        "stream": "stdout",
 819        "text": [
 820         "\n",
 821         "976"
 822        ]
 823       },
 824       {
 825        "output_type": "stream",
 826        "stream": "stdout",
 827        "text": [
 828         "\n",
 829         "986"
 830        ]
 831       },
 832       {
 833        "output_type": "stream",
 834        "stream": "stdout",
 835        "text": [
 836         "\n",
 837         "1 loops, best of 3: 1min 8s per loop\n"
 838        ]
 839       }
 840      ],
 841      "prompt_number": 31
 842     },
 843     {
 844      "cell_type": "code",
 845      "collapsed": false,
 846      "input": [
 847       "%%timeit\n",
 848       "\n",
 849       "wins = 0\n",
 850       "for _ in range(1000):\n",
 851       "    g = Game(random.choice(WORDS), player=PlayerAdaptiveExcludedLetters(WORDS))\n",
 852       "    g.play_game()\n",
 853       "    if g.game_won:\n",
 854       "        wins += 1\n",
 855       "print(wins)"
 856      ],
 857      "language": "python",
 858      "metadata": {},
 859      "outputs": [
 860       {
 861        "output_type": "stream",
 862        "stream": "stdout",
 863        "text": [
 864         "502\n",
 865         "491"
 866        ]
 867       },
 868       {
 869        "output_type": "stream",
 870        "stream": "stdout",
 871        "text": [
 872         "\n",
 873         "537"
 874        ]
 875       },
 876       {
 877        "output_type": "stream",
 878        "stream": "stdout",
 879        "text": [
 880         "\n",
 881         "524"
 882        ]
 883       },
 884       {
 885        "output_type": "stream",
 886        "stream": "stdout",
 887        "text": [
 888         "\n",
 889         "1 loops, best of 3: 13min 6s per loop\n"
 890        ]
 891       }
 892      ],
 893      "prompt_number": 32
 894     },
 895     {
 896      "cell_type": "code",
 897      "collapsed": false,
 898      "input": [
 899       "%%timeit\n",
 900       "\n",
 901       "wins = 0\n",
 902       "for _ in range(1000):\n",
 903       "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
 904       "    g.play_game()\n",
 905       "    if g.game_won:\n",
 906       "        wins += 1\n",
 907       "print(wins)"
 908      ],
 909      "language": "python",
 910      "metadata": {},
 911      "outputs": [
 912       {
 913        "output_type": "stream",
 914        "stream": "stdout",
 915        "text": [
 916         "993\n",
 917         "991"
 918        ]
 919       },
 920       {
 921        "output_type": "stream",
 922        "stream": "stdout",
 923        "text": [
 924         "\n",
 925         "994"
 926        ]
 927       },
 928       {
 929        "output_type": "stream",
 930        "stream": "stdout",
 931        "text": [
 932         "\n",
 933         "989"
 934        ]
 935       },
 936       {
 937        "output_type": "stream",
 938        "stream": "stdout",
 939        "text": [
 940         "\n",
 941         "1 loops, best of 3: 56.6 s per loop\n"
 942        ]
 943       }
 944      ],
 945      "prompt_number": 33
 946     },
 947     {
 948      "cell_type": "code",
 949      "collapsed": false,
 950      "input": [
 951       "for _ in range(1000):\n",
 952       "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
 953       "    g.play_game()\n",
 954       "    if not g.game_won:\n",
 955       "        print(g.target, g.discovered, g.wrong_letters)"
 956      ],
 957      "language": "python",
 958      "metadata": {},
 959      "outputs": [
 960       {
 961        "output_type": "stream",
 962        "stream": "stdout",
 963        "text": [
 964         "jutting ['_', 'u', 't', 't', 'i', 'n', 'g'] ['e', 'a', 'o', 'l', 's', 'f', 'p', 'b', 'c', 'r']\n",
 965         "faze"
 966        ]
 967       },
 968       {
 969        "output_type": "stream",
 970        "stream": "stdout",
 971        "text": [
 972         " ['_', 'a', '_', 'e'] ['r', 'l', 'm', 'p', 's', 'g', 'b', 'd', 'v', 'k']\n",
 973         "fate"
 974        ]
 975       },
 976       {
 977        "output_type": "stream",
 978        "stream": "stdout",
 979        "text": [
 980         " ['_', 'a', '_', 'e'] ['r', 'l', 'm', 'p', 's', 'g', 'b', 'd', 'v', 'k']\n",
 981         "dunk"
 982        ]
 983       },
 984       {
 985        "output_type": "stream",
 986        "stream": "stdout",
 987        "text": [
 988         " ['_', 'u', 'n', 'k'] ['e', 's', 'o', 'a', 'i', 'l', 'f', 'r', 'j', 'p']\n",
 989         "loons"
 990        ]
 991       },
 992       {
 993        "output_type": "stream",
 994        "stream": "stdout",
 995        "text": [
 996         " ['_', 'o', 'o', 'n', 's'] ['e', 't', 'k', 'm', 'p', 'd', 'f', 'c', 'b', 'g']\n",
 997         "lab"
 998        ]
 999       },
1000       {
1001        "output_type": "stream",
1002        "stream": "stdout",
1003        "text": [
1004         " ['_', 'a', 'b'] ['t', 'p', 'g', 'w', 'm', 'd', 'y', 'r', 'c', 'n']\n",
1005         "joked"
1006        ]
1007       },
1008       {
1009        "output_type": "stream",
1010        "stream": "stdout",
1011        "text": [
1012         " ['_', 'o', 'k', 'e', 'd'] ['s', 'a', 'w', 'p', 't', 'r', 'h', 'b', 'y', 'c']\n"
1013        ]
1014       }
1015      ],
1016      "prompt_number": 34
1017     },
1018     {
1019      "cell_type": "code",
1020      "collapsed": false,
1021      "input": [
1022       "iterations = 10000\n",
1023       "wins = 0\n",
1024       "for _ in range(iterations):\n",
1025       "    g = Game(random.choice(WORDS), player=PlayerAdaptivePattern(WORDS))\n",
1026       "    g.play_game()\n",
1027       "    if g.game_won:\n",
1028       "        wins += 1\n",
1029       "print(wins / iterations)"
1030      ],
1031      "language": "python",
1032      "metadata": {},
1033      "outputs": [
1034       {
1035        "output_type": "stream",
1036        "stream": "stdout",
1037        "text": [
1038         "0.9923\n"
1039        ]
1040       }
1041      ],
1042      "prompt_number": 35
1043     },
1044     {
1045      "cell_type": "code",
1046      "collapsed": false,
1047      "input": [],
1048      "language": "python",
1049      "metadata": {},
1050      "outputs": []
1051     }
1052    ],
1053    "metadata": {}
1054   }
1055  ]
1056 }