hangman-both.ipynb

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