hangman_api_user (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trexquant Interview Project (The Hangman Game)\n",
    "\n",
    "* Copyright Trexquant Investment LP. All Rights Reserved. \n",
    "* Redistribution of this question without written consent from Trexquant is prohibited"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instruction:\n",
    "For this coding test, your mission is to write an algorithm that plays the game of Hangman through our API server. \n",
    "\n",
    "When a user plays Hangman, the server first selects a secret word at random from a list. The server then returns a row of underscores (space separated)—one for each letter in the secret word—and asks the user to guess a letter. If the user guesses a letter that is in the word, the word is redisplayed with all instances of that letter shown in the correct positions, along with any letters correctly guessed on previous turns. If the letter does not appear in the word, the user is charged with an incorrect guess. The user keeps guessing letters until either (1) the user has correctly guessed all the letters in the word\n",
    "or (2) the user has made six incorrect guesses.\n",
    "\n",
    "You are required to write a \"guess\" function that takes current word (with underscores) as input and returns a guess letter. You will use the API codes below to play 1,000 Hangman games. You have the opportunity to practice before you want to start recording your game results.\n",
    "\n",
    "Your algorithm is permitted to use a training set of approximately 250,000 dictionary words. Your algorithm will be tested on an entirely disjoint set of 250,000 dictionary words. Please note that this means the words that you will ultimately be tested on do NOT appear in the dictionary that you are given. You are not permitted to use any dictionary other than the training dictionary we provided. This requirement will be strictly enforced by code review.\n",
    "\n",
    "You are provided with a basic, working algorithm. This algorithm will match the provided masked string (e.g. a _ _ l e) to all possible words in the dictionary, tabulate the frequency of letters appearing in these possible words, and then guess the letter with the highest frequency of appearence that has not already been guessed. If there are no remaining words that match then it will default back to the character frequency distribution of the entire dictionary.\n",
    "\n",
    "This benchmark strategy is successful approximately 18% of the time. Your task is to design an algorithm that significantly outperforms this benchmark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "import random\n",
    "import string\n",
    "import secrets\n",
    "import time\n",
    "import re\n",
    "import collections\n",
    "try:\n",
    "    from urllib.parse import parse_qs, urlencode, urlparse\n",
    "except ImportError:\n",
    "    from urlparse import parse_qs, urlparse\n",
    "    from urllib import urlencode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "vowels = ['a', 'e', 'i', 'o', 'u']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for ratio of vowels to length of word\n",
    "def vowel_count(clean_word):\n",
    "    count = 0\n",
    "    for i in clean_word:\n",
    "        if i in vowels:\n",
    "            count = count+1.0\n",
    "    return count/len(clean_word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"words_250000_train.txt\", \"r\")\n",
    "df = []\n",
    "for x in f:\n",
    "  df.append(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(df)):\n",
    "    df[i] = df[i].replace(\"\\n\", \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    227300.000000\n",
       "mean          0.386889\n",
       "std           0.095527\n",
       "min           0.000000\n",
       "25%           0.333333\n",
       "50%           0.384615\n",
       "75%           0.444444\n",
       "max           1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=[]\n",
    "for words in df:\n",
    "    l.append(vowel_count(words))\n",
    "l = pd.Series(l)\n",
    "l.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1.2490e+03, 2.0000e+00, 6.8100e+02, 1.7410e+03, 6.7780e+03,\n",
       "        3.2538e+04, 3.5853e+04, 3.6370e+04, 6.0189e+04, 1.2807e+04,\n",
       "        2.8992e+04, 7.8220e+03, 7.7600e+02, 1.1180e+03, 1.0800e+02,\n",
       "        1.8300e+02, 5.4000e+01, 1.0000e+00, 0.0000e+00]),\n",
       " array([0.  , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 ,\n",
       "        0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95]),\n",
       " <a list of 19 Patch objects>)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = np.arange(0.0, 1.0, 0.05)\n",
    "plt.hist(x = l, bins = bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# From the above plot we can stastically say that if the number of vowels in it are greater than 0.55 times of its lenght than guessing a vowel will not be a good choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 0\n",
    "for words in df:\n",
    "    if(len(words)>max_length):\n",
    "        max_length = len(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_word_dictionary = {i:[] for i in range(3, 30)}\n",
    "count = 3\n",
    "while count<=max_length:\n",
    "    for words in df:\n",
    "        if(len(words)>=count):\n",
    "            for i in range(len(words)-count+1):\n",
    "                #if words[i:i+count-1] not in n_word_dictionary[count]:\n",
    "                n_word_dictionary[count].append(words[i:i+count]) \n",
    "    count = count+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to find number of times a letter come in whole dictionary, keeping count of letter 1 if it comes in a word else 0\n",
    "def func(new_dictionary):\n",
    "    dictx = collections.Counter()\n",
    "    for words in new_dictionary:\n",
    "        temp = collections.Counter(words)\n",
    "        for i in temp:\n",
    "            temp[i] = 1\n",
    "            dictx = dictx + temp\n",
    "    return dictx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to generate a list of words which are substring in the original dictionary and of same length as clean word\n",
    "def func2(n_word_dictionary, clean_word):\n",
    "    new_dictionary = []\n",
    "    l = len(clean_word)\n",
    "    for dict_word in n_word_dictionary[l]:\n",
    "        if re.match(clean_word,dict_word):\n",
    "            new_dictionary.append(dict_word)\n",
    "    return new_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "HANGMAN_URL = \"https://www.trexsim.com/trexsim/hangman\"\n",
    "\n",
    "class HangmanAPI(object):\n",
    "    def __init__(self, access_token=None, session=None, timeout=None):\n",
    "        self.access_token = access_token\n",
    "        self.session = session or requests.Session()\n",
    "        self.timeout = timeout\n",
    "        self.guessed_letters = []\n",
    "        \n",
    "        full_dictionary_location = \"words_250000_train.txt\"\n",
    "        self.full_dictionary = self.build_dictionary(full_dictionary_location)        \n",
    "        self.full_dictionary_common_letter_sorted = collections.Counter(\"\".join(self.full_dictionary)).most_common()\n",
    "        \n",
    "        self.current_dictionary = []\n",
    "        \n",
    "    \n",
    "\n",
    "    \n",
    "        \n",
    "    def guess(self, word): # word input example: \"_ p p _ e \"\n",
    "        ###############################################\n",
    "        # Replace with your own \"guess\" function here #\n",
    "        ###############################################\n",
    "\n",
    "        # clean the word so that we strip away the space characters\n",
    "        # replace \"_\" with \".\" as \".\" indicates any character in regular expressions\n",
    "        clean_word = word[::2].replace(\"_\",\".\")\n",
    "        \n",
    "        # find length of passed word\n",
    "        len_word = len(clean_word)\n",
    "        \n",
    "        # grab current dictionary of possible words from self object, initialize new possible words dictionary to empty\n",
    "        current_dictionary = self.current_dictionary\n",
    "        new_dictionary = []\n",
    "        \n",
    "        # iterate through all of the words in the old plausible dictionary\n",
    "        for dict_word in current_dictionary:\n",
    "            # continue if the word is not of the appropriate length\n",
    "            if len(dict_word) != len_word:\n",
    "                continue\n",
    "                \n",
    "            # if dictionary word is a possible match then add it to the current dictionary\n",
    "            if re.match(clean_word,dict_word):\n",
    "                new_dictionary.append(dict_word)\n",
    "        \n",
    "        # overwrite old possible words dictionary with updated version\n",
    "        self.current_dictionary = new_dictionary\n",
    "        \n",
    "        '''\n",
    "        # count occurrence of all characters in possible word matches\n",
    "        full_dict_string = \"\".join(new_dictionary)\n",
    "        \n",
    "        c = collections.Counter(full_dict_string)\n",
    "        '''\n",
    "        \n",
    "        c = func(new_dictionary)\n",
    "        \n",
    "        sorted_letter_count = c.most_common()                   \n",
    "        \n",
    "        guess_letter = '!'\n",
    "        \n",
    "        # return most frequently occurring letter in all possible words that hasn't been guessed yet\n",
    "        for letter,instance_count in sorted_letter_count:\n",
    "            if letter not in self.guessed_letters:\n",
    "                if letter in vowels and vowel_count(clean_word)>0.55:\n",
    "                    self.guessed_letters.append(letter)\n",
    "                    continue\n",
    "                guess_letter = letter\n",
    "                break\n",
    "                \n",
    "        if guess_letter == '!':\n",
    "            new_dictionary = func2(n_word_dictionary, clean_word)\n",
    "            c = func(new_dictionary)\n",
    "            sorted_letter_count = c.most_common()\n",
    "            for letter,instance_count in sorted_letter_count:\n",
    "                if letter not in self.guessed_letters:\n",
    "                    if letter in vowels and vowel_count(clean_word)>0.55:\n",
    "                        self.guessed_letters.append(letter)\n",
    "                        continue\n",
    "                    guess_letter = letter\n",
    "                    break\n",
    "                    \n",
    "                    \n",
    "        if guess_letter == '!':\n",
    "            x = int(len(clean_word)/2)\n",
    "            if x>=3:\n",
    "                c = collections.Counter()\n",
    "                for i in range(len(clean_word)-x+1):\n",
    "                    s = clean_word[i:i+x]\n",
    "                    new_dictionary = func2(n_word_dictionary, s)\n",
    "                    temp = func(new_dictionary)\n",
    "                    c = c+temp\n",
    "                sorted_letter_count = c.most_common()\n",
    "                for letter, instance_count in sorted_letter_count:\n",
    "                    if letter not in self.guessed_letters:\n",
    "                        guess_letter = letter\n",
    "                        break\n",
    "                    \n",
    "                    \n",
    "        if guess_letter == '!':\n",
    "            x = int(len(clean_word)/3)\n",
    "            if x>=3:\n",
    "                c = collections.Counter()\n",
    "                for i in range(len(clean_word)-x+1):\n",
    "                    s = clean_word[i:i+x]\n",
    "                    new_dictionary = func2(n_word_dictionary, s)\n",
    "                    temp = func(new_dictionary)\n",
    "                    c = c+temp\n",
    "                sorted_letter_count = c.most_common()\n",
    "                for letter, instance_count in sorted_letter_count:\n",
    "                    if letter not in self.guessed_letters:\n",
    "                        guess_letter = letter\n",
    "                        break\n",
    "            \n",
    "            \n",
    "        # if no word matches in training dictionary, default back to ordering of full dictionary\n",
    "        if guess_letter == '!':\n",
    "            sorted_letter_count = self.full_dictionary_common_letter_sorted\n",
    "            for letter,instance_count in sorted_letter_count:\n",
    "                if letter not in self.guessed_letters:\n",
    "                    if letter in vowels and vowel_count(clean_word)>0.55:\n",
    "                        self.guessed_letters.append(letter)\n",
    "                        continue\n",
    "                    guess_letter = letter\n",
    "                    break            \n",
    "        \n",
    "        return guess_letter\n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    ##########################################################\n",
    "    # You'll likely not need to modify any of the code below #\n",
    "    ##########################################################\n",
    "    \n",
    "    def build_dictionary(self, dictionary_file_location):\n",
    "        text_file = open(dictionary_file_location,\"r\")\n",
    "        full_dictionary = text_file.read().splitlines()\n",
    "        text_file.close()\n",
    "        return full_dictionary\n",
    "                \n",
    "    def start_game(self, practice=True, verbose=True):\n",
    "        # reset guessed letters to empty set and current plausible dictionary to the full dictionary\n",
    "        self.guessed_letters = []\n",
    "        self.current_dictionary = self.full_dictionary\n",
    "                         \n",
    "        response = self.request(\"/new_game\", {\"practice\":practice})\n",
    "        if response.get('status')==\"approved\":\n",
    "            game_id = response.get('game_id')\n",
    "            word = response.get('word')\n",
    "            tries_remains = response.get('tries_remains')\n",
    "            if verbose:\n",
    "                print(\"Successfully start a new game! Game ID: {0}. # of tries remaining: {1}. Word: {2}.\".format(game_id, tries_remains, word))\n",
    "            while tries_remains>0:\n",
    "                # get guessed letter from user code\n",
    "                guess_letter = self.guess(word)\n",
    "                    \n",
    "                # append guessed letter to guessed letters field in hangman object\n",
    "                self.guessed_letters.append(guess_letter)\n",
    "                if verbose:\n",
    "                    print(\"Guessing letter: {0}\".format(guess_letter))\n",
    "                    \n",
    "                try:    \n",
    "                    res = self.request(\"/guess_letter\", {\"request\":\"guess_letter\", \"game_id\":game_id, \"letter\":guess_letter})\n",
    "                except HangmanAPIError:\n",
    "                    print('HangmanAPIError exception caught on request.')\n",
    "                    continue\n",
    "                except Exception as e:\n",
    "                    print('Other exception caught on request.')\n",
    "                    raise e\n",
    "               \n",
    "                if verbose:\n",
    "                    print(\"Sever response: {0}\".format(res))\n",
    "                status = res.get('status')\n",
    "                tries_remains = res.get('tries_remains')\n",
    "                if status==\"success\":\n",
    "                    if verbose:\n",
    "                        print(\"Successfully finished game: {0}\".format(game_id))\n",
    "                    return True\n",
    "                elif status==\"failed\":\n",
    "                    reason = res.get('reason', '# of tries exceeded!')\n",
    "                    if verbose:\n",
    "                        print(\"Failed game: {0}. Because of: {1}\".format(game_id, reason))\n",
    "                    return False\n",
    "                elif status==\"ongoing\":\n",
    "                    word = res.get('word')\n",
    "        else:\n",
    "            if verbose:\n",
    "                print(\"Failed to start a new game\")\n",
    "        return status==\"success\"\n",
    "        \n",
    "    def my_status(self):\n",
    "        return self.request(\"/my_status\", {})\n",
    "    \n",
    "    def request(\n",
    "            self, path, args=None, post_args=None, method=None):\n",
    "        if args is None:\n",
    "            args = dict()\n",
    "        if post_args is not None:\n",
    "            method = \"POST\"\n",
    "\n",
    "        # Add `access_token` to post_args or args if it has not already been\n",
    "        # included.\n",
    "        if self.access_token:\n",
    "            # If post_args exists, we assume that args either does not exists\n",
    "            # or it does not need `access_token`.\n",
    "            if post_args and \"access_token\" not in post_args:\n",
    "                post_args[\"access_token\"] = self.access_token\n",
    "            elif \"access_token\" not in args:\n",
    "                args[\"access_token\"] = self.access_token\n",
    "\n",
    "        try:\n",
    "            # response = self.session.request(\n",
    "            response = requests.request(\n",
    "                method or \"GET\",\n",
    "                HANGMAN_URL + path,\n",
    "                timeout=self.timeout,\n",
    "                params=args,\n",
    "                data=post_args)\n",
    "        except requests.HTTPError as e:\n",
    "            response = json.loads(e.read())\n",
    "            raise HangmanAPIError(response)\n",
    "\n",
    "        headers = response.headers\n",
    "        if 'json' in headers['content-type']:\n",
    "            result = response.json()\n",
    "        elif \"access_token\" in parse_qs(response.text):\n",
    "            query_str = parse_qs(response.text)\n",
    "            if \"access_token\" in query_str:\n",
    "                result = {\"access_token\": query_str[\"access_token\"][0]}\n",
    "                if \"expires\" in query_str:\n",
    "                    result[\"expires\"] = query_str[\"expires\"][0]\n",
    "            else:\n",
    "                raise HangmanAPIError(response.json())\n",
    "        else:\n",
    "            raise HangmanAPIError('Maintype was not text, or querystring')\n",
    "\n",
    "        if result and isinstance(result, dict) and result.get(\"error\"):\n",
    "            raise HangmanAPIError(result)\n",
    "        return result\n",
    "    \n",
    "class HangmanAPIError(Exception):\n",
    "    def __init__(self, result):\n",
    "        self.result = result\n",
    "        self.code = None\n",
    "        try:\n",
    "            self.type = result[\"error_code\"]\n",
    "        except (KeyError, TypeError):\n",
    "            self.type = \"\"\n",
    "\n",
    "        try:\n",
    "            self.message = result[\"error_description\"]\n",
    "        except (KeyError, TypeError):\n",
    "            try:\n",
    "                self.message = result[\"error\"][\"message\"]\n",
    "                self.code = result[\"error\"].get(\"code\")\n",
    "                if not self.type:\n",
    "                    self.type = result[\"error\"].get(\"type\", \"\")\n",
    "            except (KeyError, TypeError):\n",
    "                try:\n",
    "                    self.message = result[\"error_msg\"]\n",
    "                except (KeyError, TypeError):\n",
    "                    self.message = result\n",
    "\n",
    "        Exception.__init__(self, self.message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# API Usage Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To start a new game:\n",
    "1. Make sure you have implemented your own \"guess\" method.\n",
    "2. Use the access_token that we sent you to create your HangmanAPI object. \n",
    "3. Start a game by calling \"start_game\" method.\n",
    "4. If you wish to test your function without being recorded, set \"practice\" parameter to 1.\n",
    "5. Note: You have a rate limit of 20 new games per minute. DO NOT start more than 20 new games within one minute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "api = HangmanAPI(access_token=\"da89a79ad1fcaf99cfc2300cf09e49\", timeout=2000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playing practice games:\n",
    "You can use the command below to play up to 100,000 practice games."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully start a new game! Game ID: 92ff26361135. # of tries remaining: 6. Word: _ _ _ _ _ _ _ .\n",
      "Guessing letter: e\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 6, 'word': '_ _ _ e _ _ _ '}\n",
      "Guessing letter: a\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 5, 'word': '_ _ _ e _ _ _ '}\n",
      "Guessing letter: r\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 5, 'word': '_ _ _ e r _ _ '}\n",
      "Guessing letter: i\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 5, 'word': '_ i _ e r _ _ '}\n",
      "Guessing letter: n\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 4, 'word': '_ i _ e r _ _ '}\n",
      "Guessing letter: d\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 3, 'word': '_ i _ e r _ _ '}\n",
      "Guessing letter: s\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 3, 'word': '_ i _ e r _ s '}\n",
      "Guessing letter: v\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 2, 'word': '_ i _ e r _ s '}\n",
      "Guessing letter: t\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 1, 'word': '_ i _ e r _ s '}\n",
      "Guessing letter: h\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 1, 'word': 'h i _ e r _ s '}\n",
      "Guessing letter: m\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'ongoing', 'tries_remains': 1, 'word': 'h i m e r _ s '}\n",
      "Guessing letter: u\n",
      "Sever response: {'game_id': '92ff26361135', 'status': 'failed', 'tries_remains': 0, 'word': 'h i m e r _ s '}\n",
      "Failed game: 92ff26361135. Because of: # of tries exceeded!\n",
      "run 129 practice games out of an allotted 100,000. practice success rate so far = 0.550\n"
     ]
    }
   ],
   "source": [
    "\n",
    "api.start_game(practice=1,verbose=True)\n",
    "[total_practice_runs,total_recorded_runs,total_recorded_successes,total_practice_successes] = api.my_status() # Get my game stats: (# of tries, # of wins)\n",
    "practice_success_rate = total_practice_successes / total_practice_runs\n",
    "print('run %d practice games out of an allotted 100,000. practice success rate so far = %.3f' % (total_practice_runs, practice_success_rate))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playing recorded games:\n",
    "Please finalize your code prior to running the cell below. Once this code executes once successfully your submission will be finalized. Our system will not allow you to rerun any additional games.\n",
    "\n",
    "Please note that it is expected that after you successfully run this block of code that subsequent runs will result in the error message \"Your account has been deactivated\".\n",
    "\n",
    "Once you've run this section of the code your submission is complete. Please send us your source code via email."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Playing  0  th game\n",
      "Playing  1  th game\n",
      "Playing  2  th game\n",
      "Playing  3  th game\n",
      "Playing  4  th game\n",
      "Playing  5  th game\n",
      "Playing  6  th game\n",
      "Playing  7  th game\n",
      "Playing  8  th game\n",
      "Playing  9  th game\n",
      "Playing  10  th game\n",
      "Playing  11  th game\n",
      "Playing  12  th game\n",
      "Playing  13  th game\n",
      "Playing  14  th game\n",
      "Playing  15  th game\n",
      "Playing  16  th game\n",
      "Playing  17  th game\n",
      "Playing  18  th game\n",
      "Playing  19  th game\n",
      "Playing  20  th game\n",
      "Playing  21  th game\n",
      "Playing  22  th game\n",
      "Playing  23  th game\n",
      "Playing  24  th game\n",
      "Playing  25  th game\n",
      "Playing  26  th game\n",
      "Playing  27  th game\n",
      "Playing  28  th game\n",
      "Playing  29  th game\n",
      "Playing  30  th game\n",
      "Playing  31  th game\n",
      "Playing  32  th game\n",
      "Playing  33  th game\n",
      "Playing  34  th game\n",
      "Playing  35  th game\n",
      "Playing  36  th game\n",
      "Playing  37  th game\n",
      "Playing  38  th game\n",
      "Playing  39  th game\n",
      "Playing  40  th game\n",
      "Playing  41  th game\n",
      "Playing  42  th game\n",
      "Playing  43  th game\n",
      "Playing  44  th game\n",
      "Playing  45  th game\n",
      "Playing  46  th game\n",
      "Playing  47  th game\n",
      "Playing  48  th game\n",
      "Playing  49  th game\n",
      "Playing  50  th game\n",
      "Playing  51  th game\n",
      "Playing  52  th game\n",
      "Playing  53  th game\n",
      "Playing  54  th game\n",
      "Playing  55  th game\n",
      "Playing  56  th game\n",
      "Playing  57  th game\n",
      "Playing  58  th game\n",
      "Playing  59  th game\n",
      "Playing  60  th game\n",
      "Playing  61  th game\n",
      "Playing  62  th game\n",
      "Playing  63  th game\n",
      "Playing  64  th game\n",
      "Playing  65  th game\n",
      "Playing  66  th game\n",
      "Playing  67  th game\n",
      "Playing  68  th game\n",
      "Playing  69  th game\n",
      "Playing  70  th game\n",
      "Playing  71  th game\n",
      "Playing  72  th game\n",
      "Playing  73  th game\n",
      "Playing  74  th game\n",
      "Playing  75  th game\n",
      "Playing  76  th game\n",
      "Playing  77  th game\n",
      "Playing  78  th game\n",
      "Playing  79  th game\n",
      "Playing  80  th game\n",
      "Playing  81  th game\n",
      "Playing  82  th game\n",
      "Playing  83  th game\n",
      "Playing  84  th game\n",
      "Playing  85  th game\n",
      "Playing  86  th game\n",
      "Playing  87  th game\n",
      "Playing  88  th game\n",
      "Playing  89  th game\n",
      "Playing  90  th game\n",
      "Playing  91  th game\n",
      "Playing  92  th game\n",
      "Playing  93  th game\n",
      "Playing  94  th game\n",
      "Playing  95  th game\n",
      "Playing  96  th game\n",
      "Playing  97  th game\n",
      "Playing  98  th game\n",
      "Playing  99  th game\n",
      "Playing  100  th game\n",
      "Playing  101  th game\n",
      "Playing  102  th game\n",
      "Playing  103  th game\n",
      "Playing  104  th game\n",
      "Playing  105  th game\n",
      "Playing  106  th game\n",
      "Playing  107  th game\n",
      "Playing  108  th game\n",
      "Playing  109  th game\n",
      "Playing  110  th game\n",
      "Playing  111  th game\n",
      "Playing  112  th game\n",
      "Playing  113  th game\n",
      "Playing  114  th game\n",
      "Playing  115  th game\n",
      "Playing  116  th game\n",
      "Playing  117  th game\n",
      "Playing  118  th game\n",
      "Playing  119  th game\n",
      "Playing  120  th game\n",
      "Playing  121  th game\n",
      "Playing  122  th game\n",
      "Playing  123  th game\n",
      "Playing  124  th game\n",
      "Playing  125  th game\n",
      "Playing  126  th game\n",
      "Playing  127  th game\n",
      "Playing  128  th game\n",
      "Playing  129  th game\n",
      "Playing  130  th game\n",
      "Playing  131  th game\n",
      "Playing  132  th game\n",
      "Playing  133  th game\n",
      "Playing  134  th game\n",
      "Playing  135  th game\n",
      "Playing  136  th game\n",
      "Playing  137  th game\n",
      "Playing  138  th game\n",
      "Playing  139  th game\n",
      "Playing  140  th game\n",
      "Playing  141  th game\n",
      "Playing  142  th game\n",
      "Playing  143  th game\n",
      "Playing  144  th game\n",
      "Playing  145  th game\n",
      "Playing  146  th game\n",
      "Playing  147  th game\n",
      "Playing  148  th game\n",
      "Playing  149  th game\n",
      "Playing  150  th game\n",
      "Playing  151  th game\n",
      "Playing  152  th game\n",
      "Playing  153  th game\n",
      "Playing  154  th game\n",
      "Playing  155  th game\n",
      "Playing  156  th game\n",
      "Playing  157  th game\n",
      "Playing  158  th game\n",
      "Playing  159  th game\n",
      "Playing  160  th game\n",
      "Playing  161  th game\n",
      "Playing  162  th game\n",
      "Playing  163  th game\n",
      "Playing  164  th game\n",
      "Playing  165  th game\n",
      "Playing  166  th game\n",
      "Playing  167  th game\n",
      "Playing  168  th game\n",
      "Playing  169  th game\n",
      "Playing  170  th game\n",
      "Playing  171  th game\n",
      "Playing  172  th game\n",
      "Playing  173  th game\n",
      "Playing  174  th game\n",
      "Playing  175  th game\n",
      "Playing  176  th game\n",
      "Playing  177  th game\n",
      "Playing  178  th game\n",
      "Playing  179  th game\n",
      "Playing  180  th game\n",
      "Playing  181  th game\n",
      "Playing  182  th game\n",
      "Playing  183  th game\n",
      "Playing  184  th game\n",
      "Playing  185  th game\n",
      "Playing  186  th game\n",
      "Playing  187  th game\n",
      "Playing  188  th game\n",
      "Playing  189  th game\n",
      "Playing  190  th game\n",
      "Playing  191  th game\n",
      "Playing  192  th game\n",
      "Playing  193  th game\n",
      "Playing  194  th game\n",
      "Playing  195  th game\n",
      "Playing  196  th game\n",
      "Playing  197  th game\n",
      "Playing  198  th game\n",
      "Playing  199  th game\n",
      "Playing  200  th game\n",
      "Playing  201  th game\n",
      "Playing  202  th game\n",
      "Playing  203  th game\n",
      "Playing  204  th game\n",
      "Playing  205  th game\n",
      "Playing  206  th game\n",
      "Playing  207  th game\n",
      "Playing  208  th game\n",
      "Playing  209  th game\n",
      "Playing  210  th game\n",
      "Playing  211  th game\n",
      "Playing  212  th game\n",
      "Playing  213  th game\n",
      "Playing  214  th game\n",
      "Playing  215  th game\n",
      "Playing  216  th game\n",
      "Playing  217  th game\n",
      "Playing  218  th game\n",
      "Playing  219  th game\n",
      "Playing  220  th game\n",
      "Playing  221  th game\n",
      "Playing  222  th game\n",
      "Playing  223  th game\n",
      "Playing  224  th game\n",
      "Playing  225  th game\n",
      "Playing  226  th game\n",
      "Playing  227  th game\n",
      "Playing  228  th game\n",
      "Playing  229  th game\n",
      "Playing  230  th game\n",
      "Playing  231  th game\n",
      "Playing  232  th game\n",
      "Playing  233  th game\n",
      "Playing  234  th game\n",
      "Playing  235  th game\n",
      "Playing  236  th game\n",
      "Playing  237  th game\n",
      "Playing  238  th game\n",
      "Playing  239  th game\n",
      "Playing  240  th game\n",
      "Playing  241  th game\n",
      "Playing  242  th game\n",
      "Playing  243  th game\n",
      "Playing  244  th game\n",
      "Playing  245  th game\n",
      "Playing  246  th game\n",
      "Playing  247  th game\n",
      "Playing  248  th game\n",
      "Playing  249  th game\n",
      "Playing  250  th game\n",
      "Playing  251  th game\n",
      "Playing  252  th game\n",
      "Playing  253  th game\n",
      "Playing  254  th game\n",
      "Playing  255  th game\n",
      "Playing  256  th game\n",
      "Playing  257  th game\n",
      "Playing  258  th game\n",
      "Playing  259  th game\n",
      "Playing  260  th game\n",
      "Playing  261  th game\n",
      "Playing  262  th game\n",
      "Playing  263  th game\n",
      "Playing  264  th game\n",
      "Playing  265  th game\n",
      "Playing  266  th game\n",
      "Playing  267  th game\n",
      "Playing  268  th game\n",
      "Playing  269  th game\n",
      "Playing  270  th game\n"
     ]
    },
    {
     "ename": "HangmanAPIError",
     "evalue": "{'error': 'You have reached 1000 of games', 'status': 'denied'}",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mHangmanAPIError\u001b[0m                           Traceback (most recent call last)",
      "\u001b[1;32md:\\Downloads\\hangman_api_user (1).ipynb Cell 23\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mPlaying \u001b[39m\u001b[39m'\u001b[39m, i, \u001b[39m'\u001b[39m\u001b[39m th game\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39m# Uncomment the following line to execute your final runs. Do not do this until you are satisfied with your submission\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m api\u001b[39m.\u001b[39;49mstart_game(practice\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m,verbose\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39m# DO NOT REMOVE as otherwise the server may lock you out for too high frequency of requests\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m time\u001b[39m.\u001b[39msleep(\u001b[39m0.5\u001b[39m)\n",
      "\u001b[1;32md:\\Downloads\\hangman_api_user (1).ipynb Cell 23\u001b[0m in \u001b[0;36mHangmanAPI.start_game\u001b[1;34m(self, practice, verbose)\u001b[0m\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=146'>147</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mguessed_letters \u001b[39m=\u001b[39m []\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=147'>148</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcurrent_dictionary \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfull_dictionary\n\u001b[1;32m--> <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=149'>150</a>\u001b[0m response \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrequest(\u001b[39m\"\u001b[39;49m\u001b[39m/new_game\u001b[39;49m\u001b[39m\"\u001b[39;49m, {\u001b[39m\"\u001b[39;49m\u001b[39mpractice\u001b[39;49m\u001b[39m\"\u001b[39;49m:practice})\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=150'>151</a>\u001b[0m \u001b[39mif\u001b[39;00m response\u001b[39m.\u001b[39mget(\u001b[39m'\u001b[39m\u001b[39mstatus\u001b[39m\u001b[39m'\u001b[39m)\u001b[39m==\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mapproved\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=151'>152</a>\u001b[0m     game_id \u001b[39m=\u001b[39m response\u001b[39m.\u001b[39mget(\u001b[39m'\u001b[39m\u001b[39mgame_id\u001b[39m\u001b[39m'\u001b[39m)\n",
      "\u001b[1;32md:\\Downloads\\hangman_api_user (1).ipynb Cell 23\u001b[0m in \u001b[0;36mHangmanAPI.request\u001b[1;34m(self, path, args, post_args, method)\u001b[0m\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=238'>239</a>\u001b[0m     \u001b[39mraise\u001b[39;00m HangmanAPIError(\u001b[39m'\u001b[39m\u001b[39mMaintype was not text, or querystring\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=240'>241</a>\u001b[0m \u001b[39mif\u001b[39;00m result \u001b[39mand\u001b[39;00m \u001b[39misinstance\u001b[39m(result, \u001b[39mdict\u001b[39m) \u001b[39mand\u001b[39;00m result\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39merror\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[1;32m--> <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=241'>242</a>\u001b[0m     \u001b[39mraise\u001b[39;00m HangmanAPIError(result)\n\u001b[0;32m    <a href='vscode-notebook-cell:/d%3A/Downloads/hangman_api_user%20%281%29.ipynb#X31sZmlsZQ%3D%3D?line=242'>243</a>\u001b[0m \u001b[39mreturn\u001b[39;00m result\n",
      "\u001b[1;31mHangmanAPIError\u001b[0m: {'error': 'You have reached 1000 of games', 'status': 'denied'}"
     ]
    }
   ],
   "source": [
    "for i in range(1000):\n",
    "    print('Playing ', i, ' th game')\n",
    "    # Uncomment the following line to execute your final runs. Do not do this until you are satisfied with your submission\n",
    "    \n",
    "    api.start_game(practice=0,verbose=False)\n",
    "    \n",
    "    # DO NOT REMOVE as otherwise the server may lock you out for too high frequency of requests\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To check your game statistics\n",
    "1. Simply use \"my_status\" method.\n",
    "2. Returns your total number of games, and number of wins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "overall success rate = 0.553\n"
     ]
    }
   ],
   "source": [
    "[total_practice_runs,total_recorded_runs,total_recorded_successes,total_practice_successes] = api.my_status() # Get my game stats: (# of tries, # of wins)\n",
    "success_rate = total_recorded_successes/total_recorded_runs\n",
    "print('overall success rate = %.3f' % success_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit (microsoft store)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "edc69e2013d20b793f0b195478e50af454875c51ff11c315880103bbc4c5eddb"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}