I2A2 - Test N°1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import unittest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Priorities dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "Priorities={\"ROYAL FLUSH\":10,\"STRAIGHT FLUSH\":9,\"FOUR OF A KIND\":8,\n",
    "            \"FULL HOUSE\":7,\"FLUSH\":6,\"STRAIGHT\":5,\"THREE OF A KIND\":4,\n",
    "           \"TWO PAIR\":3,\"ONE PAIR\":2,\"HIGH CARD\":1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choose the best ranked poker hand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_tuples(x,y):\n",
    "    if x==y:\n",
    "        return \"TIE\"\n",
    "    elif x>y: \n",
    "        return \"WIN\"\n",
    "    else:\n",
    "        return \"LOSS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_frequencies(card_numbers):\n",
    "    \"\"\"\n",
    "    Sorts the card numbers given the counts association. They are sorted in descending order\n",
    "    by count, and if count is equal, then by rank of the card. Returned cards and counts sequences maintain the association.\n",
    "    \n",
    "    Input:\n",
    "        card_numbers: Unsorted numbers in the poker hand\n",
    "        type card_numbers: list of integers\n",
    "    Output:\n",
    "        return: cards and counts sorted packed\n",
    "        return type: zip(cards,counts)\n",
    "    \"\"\"\n",
    "    cards=list(set(card_numbers))\n",
    "    dictionary=dict()\n",
    "    for card in cards:\n",
    "        dictionary[card]=card_numbers.count(card)\n",
    "    data=pd.DataFrame(list(dictionary.items()),columns=[\"card\",\"frequency\"])\n",
    "    data_sorted=data.sort_values(by=[\"frequency\",\"card\"],ascending=False)\n",
    "    return zip(data_sorted[\"card\"],data_sorted[\"frequency\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def non_consecutive(card_numbers,suits):\n",
    "    cards=list(set(card_numbers))\n",
    "    dictionary=dict()\n",
    "    for card in cards:\n",
    "        dictionary[card]=card_numbers.count(card)\n",
    "    frequencies=list(dictionary.values())\n",
    "    if 4 in frequencies:\n",
    "        return \"FOUR OF A KIND\"\n",
    "    elif sorted(frequencies)==[2,3]:\n",
    "        return \"FULL HOUSE\"\n",
    "    elif len(set(suits))==1:\n",
    "        return \"FLUSH\"\n",
    "    elif 3 in frequencies:\n",
    "        return \"THREE OF A KIND\"\n",
    "    elif frequencies.count(2)==2:\n",
    "        return \"TWO PAIR\"\n",
    "    elif 2 in frequencies:\n",
    "        return \"ONE PAIR\"\n",
    "    else:\n",
    "        return \"HIGH CARD\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def special_consecutive(card_numbers):\n",
    "    #Evaluating special case of consecutive numbers Ace(14)->1\n",
    "    numbers_text=\" \".join([str(x) for x in card_numbers])\n",
    "    numbers_text=numbers_text.replace(\"14\",\"1\")\n",
    "    temp_numbers=numbers_text.split(\" \")\n",
    "    temp_numbers=[int(x) for x in temp_numbers]\n",
    "    return consecutive_numbers(temp_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def consecutive_numbers(card_numbers):\n",
    "    return sorted(card_numbers)==list(range(min(card_numbers),max(card_numbers)+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_numbers_suits(cards):\n",
    "    numbers_text=\" \".join([x[0] for x in cards])\n",
    "    numbers_text=numbers_text.replace(\"T\",\"10\")\n",
    "    numbers_text=numbers_text.replace(\"J\",\"11\")\n",
    "    numbers_text=numbers_text.replace(\"Q\",\"12\")\n",
    "    numbers_text=numbers_text.replace(\"K\",\"13\")\n",
    "    numbers_text=numbers_text.replace(\"A\",\"14\")\n",
    "    numbers_text=numbers_text.split(\" \")\n",
    "    numbers=[int(x) for x in numbers_text]\n",
    "    suits=[x[1] for x in cards]\n",
    "    return numbers,suits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_hand(numbers,suits):\n",
    "    \"\"\"\n",
    "    Evaluate which is the best possible hand with the numbers and suits. First, it is evaluated if the cards have a consecutive\n",
    "    order or a special consecutive order(A,2,3,4,5). As a result, if the cards have a consecutive order it is decided whether \n",
    "    it is \"ROYAL FLUSH\", \"STRAIGHT FLUSH\" or \"STRAIGHT\". Secondly, if there aren't five consecutive numbers, it is evaluated \n",
    "    which is the best hand excluding the aforementioned.\n",
    "    \n",
    "    Input:\n",
    "        numbers: Unsorted numbers in the poker hand\n",
    "        type numbers: list of integers\n",
    "        \n",
    "        suits: Card suits \n",
    "        type suits: list of characters\n",
    "        \n",
    "    Output:\n",
    "        return: name of the best possible poker hand\n",
    "        return type: string\n",
    "    \"\"\"\n",
    "    #First let´s check if there is a sequence of 5 cards\n",
    "    if consecutive_numbers(numbers):\n",
    "        if (sum(numbers)==60)&(len(list(set(suits)))==1):\n",
    "            return \"ROYAL FLUSH\"\n",
    "        elif len(list(set(suits)))==1:\n",
    "            return \"STRAIGHT FLUSH\"\n",
    "        else:\n",
    "            return \"STRAIGHT\"\n",
    "    elif special_consecutive(numbers):\n",
    "        if len(list(set(suits)))==1:\n",
    "            return \"STRAIGHT FLUSH\"\n",
    "        else:\n",
    "            return \"STRAIGHT\"\n",
    "        \n",
    "    return non_consecutive(numbers,suits)      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PokerHand:\n",
    "    def __init__(self,text):\n",
    "        self.cards=text.split(\" \")\n",
    "        if len(self.cards) != 5:\n",
    "            raise ValueError(\"Invalid Poker Hand\")\n",
    "        numbers,suits=get_numbers_suits(self.cards)\n",
    "        self.best_hand=evaluate_hand(numbers,suits)\n",
    "        self.sorted_counts=sort_frequencies(numbers)\n",
    "        self.special_consecutive=special_consecutive(numbers)\n",
    "        \n",
    "    def compare_with(self,poker_hand_2):\n",
    "        \"\"\"\n",
    "        Return the result of the first poker hand versus the second poker hand. If the rank is the same, compare the highest\n",
    "        card in both sorted_counts and hand with a bigger number wins.If there is a tie, continue with the next high card in\n",
    "        the sorted_counts until there is a tiebreaker.If the hands are completely equal return \"TIE\".\n",
    "\n",
    "        Input:\n",
    "            self,poker_hand_2: Poker hands to compare\n",
    "            type self,poker_hand_2: class PokerHand\n",
    "\n",
    "        Output:\n",
    "            return: \"WIN\",\"LOSS\" or \"TIE\"\n",
    "            return type: string\n",
    "        \"\"\"\n",
    "        if Priorities[self.best_hand]==Priorities[poker_hand_2.best_hand]:\n",
    "            if self.special_consecutive &poker_hand_2.special_consecutive:\n",
    "                return \"TIE\"\n",
    "            elif self.special_consecutive:\n",
    "                return \"LOSS\"\n",
    "            elif poker_hand_2.special_consecutive:\n",
    "                return \"WIN\"\n",
    "\n",
    "            if self.sorted_counts==poker_hand_2.sorted_counts:\n",
    "                return \"TIE\"\n",
    "\n",
    "            number_self_cards, _ =  zip(*self.sorted_counts)\n",
    "            number_poker_hand2_cards, _=zip(*poker_hand_2.sorted_counts)\n",
    "            for x,y in zip(number_self_cards,number_poker_hand2_cards):\n",
    "                answer_temp=compare_tuples(x,y)\n",
    "                if answer_temp==\"TIE\":\n",
    "                    pass\n",
    "                else:\n",
    "                    return answer_temp\n",
    "\n",
    "        elif Priorities[self.best_hand]>Priorities[poker_hand_2.best_hand]:\n",
    "            return \"WIN\"\n",
    "\n",
    "        else:\n",
    "            return \"LOSS\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Result:\n",
    "    WIN=\"WIN\"\n",
    "    LOSS=\"LOSS\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "poker_hand_1 = PokerHand(\"TD TD TD 2D QD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'FLUSH'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poker_hand_1.best_hand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UNIT TEST CASES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### UNIT TEST CASES FOR ATTRIBUTE \"best_hand\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "......\n",
      "----------------------------------------------------------------------\n",
      "Ran 6 tests in 0.079s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c31ab381d0>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Adapting the test cases FROM https://github.com/ninadpage/poker-hands-comparator/blob/master/test_poker_hands.py\n",
    "\n",
    "class TestPokerHand(unittest.TestCase):\n",
    "    def test_one_pair(self):\n",
    "        h1 = PokerHand('KH KD 2C 5D 8D')\n",
    "        h2 = PokerHand('KS 8H KC 2H 5S')\n",
    "        h3 = PokerHand('KH KD TC 5D 8D')\n",
    "        self.assertEqual(h1.best_hand, \"ONE PAIR\")\n",
    "        self.assertEqual(h2.best_hand, \"ONE PAIR\")\n",
    "        self.assertEqual(h3.best_hand, \"ONE PAIR\")\n",
    "        \n",
    "    def test_two_pair(self):\n",
    "        h1 = PokerHand('KH KS JC JD 8D')\n",
    "        h2 = PokerHand('KD KC 8C JH JS')\n",
    "        h3 = PokerHand('8D 8S 5H 5S AS')\n",
    "        self.assertEqual(h1.best_hand, \"TWO PAIR\")\n",
    "        self.assertEqual(h2.best_hand, \"TWO PAIR\")\n",
    "        self.assertEqual(h3.best_hand, \"TWO PAIR\")\n",
    "        \n",
    "    def test_three_of_a_kind(self):\n",
    "        h1 = PokerHand('JH QH JC JD 8D')\n",
    "        h2 = PokerHand('JD QH 8C JH JS')\n",
    "        h3 = PokerHand('AD KS TH TD TS')\n",
    "        self.assertEqual(h1.best_hand, \"THREE OF A KIND\")\n",
    "        self.assertEqual(h2.best_hand, \"THREE OF A KIND\")\n",
    "        self.assertEqual(h3.best_hand, \"THREE OF A KIND\")\n",
    "        \n",
    "    def test_straight(self):\n",
    "        h1 = PokerHand('4H 5H 6C 7D 8D')\n",
    "        h2 = PokerHand('4D 5S 6D 7H 8S')\n",
    "        h3 = PokerHand('3D 4S 5H 6D 7S')\n",
    "        # Special case: Five-high straight (wheel)\n",
    "        h4 = PokerHand('AD 3S 5H 2D 4S')\n",
    "        self.assertEqual(h1.best_hand, \"STRAIGHT\")\n",
    "        self.assertEqual(h2.best_hand, \"STRAIGHT\")\n",
    "        self.assertEqual(h3.best_hand, \"STRAIGHT\")\n",
    "        self.assertEqual(h4.best_hand, \"STRAIGHT\")\n",
    "        \n",
    "    def test_straight_flush(self):\n",
    "        h1 = PokerHand('8H 9H TH JH QH')\n",
    "        h2 = PokerHand('QS JS TS 9S 8S')\n",
    "        h3 = PokerHand('9D TD JD QD KD')\n",
    "        self.assertEqual(h1.best_hand, \"STRAIGHT FLUSH\")\n",
    "        self.assertEqual(h2.best_hand, \"STRAIGHT FLUSH\")\n",
    "        self.assertEqual(h3.best_hand, \"STRAIGHT FLUSH\")\n",
    "        \n",
    "    def test_royal_flush(self):\n",
    "        h1 = PokerHand('TD JD QD KD AD')\n",
    "        h2 = PokerHand('TH JH QH KH AH')\n",
    "        self.assertEqual(h1.best_hand,\"ROYAL FLUSH\")\n",
    "        self.assertEqual(h1.best_hand, \"ROYAL FLUSH\")\n",
    "        self.assertNotEqual(h1.best_hand, \"STRAIGHT FLUSH\")\n",
    "        \n",
    "unittest.main(argv=['first-arg-is-ignored'], exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### UNIT TEST CASES FOR HAND COMPARISON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.135s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x1c31ab4d5c0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#This test cases have been proposed by I2A2\n",
    "class TestPokerHand(unittest.TestCase):\n",
    "    def test_comparison(self):\n",
    "        self.assertTrue(PokerHand(\"TC TH 5C 5H KH\").compare_with(PokerHand(\"9C 9H 5C 5H AC\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"TS TD KC JC 7C\").compare_with(PokerHand(\"JS JC AS KC TD\")) == Result.LOSS)\n",
    "        self.assertTrue(PokerHand(\"7H 7C QC JS TS\").compare_with(PokerHand(\"7D 7C JS TS 6D\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"5S 5D 8C 7S 6H\").compare_with(PokerHand(\"7D 7S 5S 5D JS\")) == Result.LOSS)\n",
    "        self.assertTrue(PokerHand(\"AS AD KD 7C 3D\").compare_with(PokerHand(\"AD AH KD 7C 4S\")) == Result.LOSS)\n",
    "        self.assertTrue(PokerHand(\"TS JS QS KS AS\").compare_with(PokerHand(\"AC AH AS AS KS\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"TS JS QS KS AS\").compare_with(PokerHand(\"TC JS QC KS AC\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"TS JS QS KS AS\").compare_with(PokerHand(\"QH QS QC AS 8H\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"AC AH AS AS KS\").compare_with(PokerHand(\"TC JS QC KS AC\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"AC AH AS AS KS\").compare_with(PokerHand(\"QH QS QC AS 8H\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"TC JS QC KS AC\").compare_with(PokerHand(\"QH QS QC AS 8H\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"7H 8H 9H TH JH\").compare_with(PokerHand(\"JH JC JS JD TH\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"7H 8H 9H TH JH\").compare_with(PokerHand(\"4H 5H 9H TH JH\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"7H 8H 9H TH JH\").compare_with(PokerHand(\"7C 8S 9H TH JH\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"7H 8H 9H TH JH\").compare_with(PokerHand(\"TS TH TD JH JD\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"7H 8H 9H TH JH\").compare_with(PokerHand(\"JH JD TH TC 4C\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"JH JC JS JD TH\").compare_with(PokerHand(\"4H 5H 9H TH JH\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"JH JC JS JD TH\").compare_with(PokerHand(\"7C 8S 9H TH JH\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"JH JC JS JD TH\").compare_with(PokerHand(\"TS TH TD JH JD\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"JH JC JS JD TH\").compare_with(PokerHand(\"JH JD TH TC 4C\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"4H 5H 9H TH JH\").compare_with(PokerHand(\"7C 8S 9H TH JH\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"4H 5H 9H TH JH\").compare_with(PokerHand(\"TS TH TD JH JD\")) == Result.LOSS)\n",
    "        self.assertTrue(PokerHand(\"4H 5H 9H TH JH\").compare_with(PokerHand(\"JH JD TH TC 4C\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"7C 8S 9H TH JH\").compare_with(PokerHand(\"TS TH TD JH JD\")) == Result.LOSS)\n",
    "        self.assertTrue(PokerHand(\"7C 8S 9H TH JH\").compare_with(PokerHand(\"JH JD TH TC 4C\")) == Result.WIN)\n",
    "        self.assertTrue(PokerHand(\"TS TH TD JH JD\").compare_with(PokerHand(\"JH JD TH TC 4C\")) == Result.WIN)\n",
    "\n",
    "unittest.main(argv=['first-arg-is-ignored'], exit=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}