A01 - Angelo Rosace.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Statistics: Assignment 1\n",
    " \n",
    "## Angelo Rosace\n",
    "\n",
    "General info: some print statements have been comented out but were left on purpose in order for the professor to test each single result of each single function by simply decommenting the statement and run the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Write a function that list all the possible outcomes with five dice.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All possible outcomes length: 252\n",
      "(1, 1, 1, 2, 3)\n",
      "(3, 5, 6, 6, 6)\n",
      "(5, 5, 5, 5, 6)\n",
      "(1, 1, 2, 2, 3)\n",
      "(1, 2, 4, 6, 6)\n",
      "(3, 3, 3, 6, 6)\n",
      "(3, 4, 4, 6, 6)\n",
      "(2, 2, 2, 2, 2)\n",
      "(3, 3, 3, 3, 3)\n",
      "(2, 3, 5, 6, 6)\n",
      "(5, 5, 5, 6, 6)\n",
      "(2, 3, 3, 3, 5)\n",
      "(2, 3, 5, 5, 5)\n",
      "(2, 2, 3, 5, 6)\n",
      "(1, 5, 5, 6, 6)\n",
      "(4, 5, 5, 5, 5)\n",
      "(1, 2, 2, 2, 6)\n",
      "(1, 2, 4, 4, 6)\n",
      "(1, 2, 6, 6, 6)\n",
      "(1, 1, 3, 5, 6)\n",
      "(2, 3, 3, 4, 5)\n",
      "(3, 4, 4, 4, 6)\n",
      "(1, 3, 4, 5, 6)\n",
      "(3, 4, 6, 6, 6)\n",
      "(2, 2, 3, 3, 6)\n",
      "(2, 2, 5, 5, 6)\n",
      "(2, 5, 5, 6, 6)\n",
      "(1, 2, 2, 3, 3)\n",
      "(2, 2, 2, 4, 5)\n",
      "(1, 2, 2, 4, 4)\n",
      "(1, 1, 1, 5, 6)\n",
      "(2, 2, 2, 3, 5)\n",
      "(2, 2, 4, 5, 5)\n",
      "(1, 2, 5, 6, 6)\n",
      "(1, 2, 3, 3, 3)\n",
      "(2, 2, 3, 4, 4)\n",
      "(4, 4, 4, 5, 5)\n",
      "(1, 1, 2, 2, 2)\n",
      "(2, 3, 4, 5, 5)\n",
      "(1, 3, 3, 4, 4)\n",
      "(1, 1, 1, 3, 6)\n",
      "(2, 3, 3, 3, 6)\n",
      "(2, 3, 5, 5, 6)\n",
      "(3, 3, 4, 6, 6)\n",
      "(1, 3, 3, 3, 6)\n",
      "(1, 3, 5, 5, 6)\n",
      "(3, 3, 4, 5, 5)\n",
      "(1, 4, 4, 5, 6)\n",
      "(4, 5, 5, 5, 6)\n",
      "(1, 1, 3, 5, 5)\n",
      "(1, 5, 6, 6, 6)\n",
      "(1, 1, 1, 4, 4)\n",
      "(2, 3, 3, 4, 4)\n",
      "(1, 1, 5, 5, 6)\n",
      "(1, 1, 3, 3, 6)\n",
      "(1, 1, 1, 1, 6)\n",
      "(1, 1, 1, 1, 1)\n",
      "(1, 4, 5, 5, 5)\n",
      "(1, 2, 3, 4, 6)\n",
      "(2, 2, 3, 3, 5)\n",
      "(2, 2, 5, 5, 5)\n",
      "(3, 3, 4, 4, 6)\n",
      "(3, 3, 6, 6, 6)\n",
      "(2, 2, 5, 6, 6)\n",
      "(3, 3, 3, 4, 4)\n",
      "(1, 2, 2, 3, 5)\n",
      "(1, 2, 4, 5, 5)\n",
      "(2, 2, 2, 4, 4)\n",
      "(1, 2, 2, 4, 5)\n",
      "(4, 4, 5, 6, 6)\n",
      "(1, 1, 1, 2, 6)\n",
      "(1, 1, 5, 6, 6)\n",
      "(1, 2, 3, 3, 4)\n",
      "(2, 2, 3, 4, 5)\n",
      "(1, 2, 3, 6, 6)\n",
      "(1, 5, 5, 5, 5)\n",
      "(1, 1, 2, 2, 5)\n",
      "(1, 1, 4, 4, 5)\n",
      "(1, 4, 4, 4, 6)\n",
      "(1, 3, 3, 4, 5)\n",
      "(1, 4, 6, 6, 6)\n",
      "(4, 4, 5, 5, 5)\n",
      "(2, 3, 3, 5, 6)\n",
      "(3, 3, 3, 3, 5)\n",
      "(1, 1, 1, 3, 5)\n",
      "(3, 3, 5, 5, 5)\n",
      "(1, 2, 3, 5, 6)\n",
      "(4, 4, 4, 4, 6)\n",
      "(1, 3, 3, 3, 5)\n",
      "(1, 3, 5, 5, 5)\n",
      "(3, 3, 4, 5, 6)\n",
      "(4, 4, 6, 6, 6)\n",
      "(1, 4, 4, 5, 5)\n",
      "(1, 3, 3, 5, 6)\n",
      "(2, 4, 5, 5, 6)\n",
      "(1, 4, 4, 6, 6)\n",
      "(1, 1, 1, 4, 5)\n",
      "(4, 6, 6, 6, 6)\n",
      "(2, 2, 3, 6, 6)\n",
      "(1, 2, 3, 4, 5)\n",
      "(1, 1, 2, 5, 5)\n",
      "(2, 2, 3, 3, 3)\n",
      "(2, 2, 3, 3, 4)\n",
      "(4, 4, 4, 6, 6)\n",
      "(3, 3, 3, 4, 5)\n",
      "(1, 3, 3, 6, 6)\n",
      "(1, 2, 2, 3, 4)\n",
      "(2, 3, 4, 4, 4)\n",
      "(2, 4, 5, 6, 6)\n",
      "(2, 2, 2, 3, 3)\n",
      "(2, 4, 4, 4, 5)\n",
      "(1, 2, 3, 3, 5)\n",
      "(1, 2, 5, 5, 5)\n",
      "(2, 2, 3, 4, 6)\n",
      "(3, 4, 5, 6, 6)\n",
      "(3, 4, 5, 5, 5)\n",
      "(2, 5, 5, 5, 6)\n",
      "(1, 1, 2, 2, 4)\n",
      "(1, 1, 4, 4, 4)\n",
      "(1, 3, 3, 4, 6)\n",
      "(1, 1, 1, 6, 6)\n",
      "(1, 1, 3, 4, 6)\n",
      "(3, 3, 3, 3, 4)\n",
      "(1, 1, 1, 3, 4)\n",
      "(1, 1, 1, 3, 3)\n",
      "(4, 4, 4, 4, 5)\n",
      "(1, 3, 3, 3, 4)\n",
      "(3, 5, 5, 5, 6)\n",
      "(5, 5, 6, 6, 6)\n",
      "(2, 2, 2, 6, 6)\n",
      "(1, 2, 2, 2, 2)\n",
      "(1, 1, 1, 4, 6)\n",
      "(1, 1, 3, 6, 6)\n",
      "(1, 3, 4, 5, 5)\n",
      "(1, 1, 1, 1, 3)\n",
      "(1, 1, 3, 3, 3)\n",
      "(1, 2, 3, 4, 4)\n",
      "(1, 1, 2, 3, 3)\n",
      "(1, 1, 2, 3, 4)\n",
      "(2, 3, 4, 4, 5)\n",
      "(2, 2, 2, 4, 6)\n",
      "(3, 4, 4, 5, 5)\n",
      "(1, 1, 1, 2, 4)\n",
      "(1, 6, 6, 6, 6)\n",
      "(5, 5, 5, 5, 5)\n",
      "(2, 4, 4, 4, 4)\n",
      "(1, 2, 3, 3, 6)\n",
      "(1, 2, 5, 5, 6)\n",
      "(1, 1, 2, 4, 6)\n",
      "(3, 4, 5, 5, 6)\n",
      "(2, 3, 4, 5, 6)\n",
      "(3, 3, 3, 5, 6)\n",
      "(1, 4, 4, 4, 4)\n",
      "(2, 2, 2, 2, 6)\n",
      "(2, 2, 4, 4, 6)\n",
      "(2, 2, 6, 6, 6)\n",
      "(2, 3, 3, 6, 6)\n",
      "(2, 2, 3, 5, 5)\n",
      "(1, 1, 2, 6, 6)\n",
      "(1, 3, 3, 3, 3)\n",
      "(4, 4, 4, 4, 4)\n",
      "(1, 3, 5, 6, 6)\n",
      "(3, 5, 5, 5, 5)\n",
      "(2, 3, 4, 6, 6)\n",
      "(6, 6, 6, 6, 6)\n",
      "(3, 5, 5, 6, 6)\n",
      "(1, 2, 2, 2, 3)\n",
      "(2, 2, 4, 6, 6)\n",
      "(1, 1, 1, 1, 2)\n",
      "(1, 1, 4, 6, 6)\n",
      "(1, 1, 2, 3, 5)\n",
      "(1, 1, 4, 5, 5)\n",
      "(1, 2, 2, 3, 6)\n",
      "(1, 2, 4, 5, 6)\n",
      "(2, 3, 4, 4, 6)\n",
      "(2, 3, 6, 6, 6)\n",
      "(1, 1, 1, 5, 5)\n",
      "(1, 3, 4, 4, 6)\n",
      "(1, 3, 6, 6, 6)\n",
      "(1, 1, 1, 2, 5)\n",
      "(2, 2, 2, 3, 6)\n",
      "(2, 2, 4, 5, 6)\n",
      "(4, 5, 6, 6, 6)\n",
      "(1, 1, 2, 4, 5)\n",
      "(1, 5, 5, 5, 6)\n",
      "(4, 4, 4, 5, 6)\n",
      "(1, 1, 4, 4, 6)\n",
      "(1, 1, 6, 6, 6)\n",
      "(1, 1, 2, 2, 6)\n",
      "(3, 3, 3, 5, 5)\n",
      "(1, 4, 4, 4, 5)\n",
      "(1, 2, 2, 5, 6)\n",
      "(1, 1, 3, 4, 4)\n",
      "(2, 2, 2, 2, 5)\n",
      "(2, 2, 4, 4, 5)\n",
      "(2, 3, 3, 5, 5)\n",
      "(3, 3, 3, 3, 6)\n",
      "(1, 3, 4, 6, 6)\n",
      "(3, 3, 5, 5, 6)\n",
      "(1, 4, 5, 6, 6)\n",
      "(1, 2, 3, 5, 5)\n",
      "(4, 5, 5, 6, 6)\n",
      "(1, 2, 2, 2, 4)\n",
      "(1, 2, 4, 4, 4)\n",
      "(2, 2, 2, 5, 5)\n",
      "(3, 3, 5, 6, 6)\n",
      "(3, 4, 4, 4, 4)\n",
      "(1, 1, 1, 1, 5)\n",
      "(1, 1, 3, 3, 5)\n",
      "(1, 1, 5, 5, 5)\n",
      "(2, 4, 4, 6, 6)\n",
      "(1, 4, 5, 5, 6)\n",
      "(2, 4, 4, 5, 5)\n",
      "(3, 3, 4, 4, 5)\n",
      "(3, 6, 6, 6, 6)\n",
      "(2, 6, 6, 6, 6)\n",
      "(1, 1, 2, 3, 6)\n",
      "(1, 1, 4, 5, 6)\n",
      "(5, 6, 6, 6, 6)\n",
      "(1, 2, 2, 4, 6)\n",
      "(4, 4, 5, 5, 6)\n",
      "(1, 3, 4, 4, 5)\n",
      "(1, 1, 1, 2, 2)\n",
      "(2, 4, 4, 4, 6)\n",
      "(2, 4, 6, 6, 6)\n",
      "(1, 1, 2, 4, 4)\n",
      "(2, 5, 5, 5, 5)\n",
      "(1, 2, 2, 5, 5)\n",
      "(1, 1, 3, 4, 5)\n",
      "(2, 2, 2, 2, 3)\n",
      "(2, 2, 2, 2, 4)\n",
      "(1, 2, 2, 6, 6)\n",
      "(2, 2, 4, 4, 4)\n",
      "(2, 3, 3, 3, 3)\n",
      "(2, 3, 3, 3, 4)\n",
      "(1, 3, 3, 5, 5)\n",
      "(1, 2, 2, 2, 5)\n",
      "(1, 2, 4, 4, 5)\n",
      "(2, 2, 2, 5, 6)\n",
      "(2, 4, 5, 5, 5)\n",
      "(2, 3, 3, 4, 6)\n",
      "(3, 4, 4, 4, 5)\n",
      "(2, 5, 6, 6, 6)\n",
      "(1, 1, 1, 1, 4)\n",
      "(1, 1, 3, 3, 4)\n",
      "(2, 4, 4, 5, 6)\n",
      "(1, 1, 2, 5, 6)\n",
      "(3, 3, 4, 4, 4)\n",
      "(3, 3, 3, 4, 6)\n",
      "(3, 4, 4, 5, 6)\n",
      "(2, 2, 2, 3, 4)\n",
      "(1, 3, 4, 4, 4)\n"
     ]
    }
   ],
   "source": [
    "#The function fills up a list with lists containing all possible results that could be obtained by throwing 5 dice.\n",
    "#In this sense there is room for repetitions of outcomes.\n",
    "def get_outcomes_with_5_dice():\n",
    "    #empty starting list of outcomes\n",
    "    possible_outcomes = [[]]\n",
    "    #for loop iterating through a range of numbers from 0 to n, n being excluded, that is the number of the dice that are rolled.\n",
    "    for flip in range(5):\n",
    "        #a copy list is generated\n",
    "        tmp = possible_outcomes.copy()\n",
    "        #starting list is emptied\n",
    "        possible_outcomes = []\n",
    "        #for loop iterating through the results currently stored in the copy list.\n",
    "        for current_outcome in tmp:\n",
    "            #for each one of the already computed intermidiate outcomes the result of another die is added.\n",
    "            for outcome in range(6):\n",
    "                possible_outcomes.append(current_outcome + [outcome+1])\n",
    "    #the complete list is returned after eliminating all duplicate entries\n",
    "    return list(set(tuple(sorted(sub)) for sub in possible_outcomes))\n",
    "    \n",
    "\n",
    "result = get_outcomes_with_5_dice()\n",
    "print(\"All possible outcomes length:\", len(result))\n",
    "for a in result:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know that all the possible combinations of results of throwing 5 dice simultaneously are 6 to the power of 5. \n",
    "This calculation gives 7776 as a result, but this also takes in consideration all duplicate combinations. They have to be considered duplicates because the order of the results of the dice dont metter for the purpose of defining the whole set of results. SInce they are duplicates we want to remove them and that leaves us with a list of possible outcomes without duplicates.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Write a function that takes a number of dices and return all the possible outcomes for that amount of dices.**\n",
    " \n",
    "The function implemented is the same as the one of the chunk above with the addition of a paramenter that let us state how many dice are we throwing. I could have just implemented this function also for the question above but I wanted to separate them for the purpose of answering both question as completely as I could.\n",
    " \n",
    "Here are some examples of the result of throwing 3, 4 and 5 dice.\n",
    "For a metter of readability just the length of the generated lists are printed below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All possible outcomes length for the throw of 3 dice: 56\n"
     ]
    }
   ],
   "source": [
    "#the function takes as an input a number describing the number of the dice we are rolling simultaneously.\n",
    "#It fills up a list with lists containing all possible results that could be obtained by throwing n dice.\n",
    "#In this sense there is room for repetitions of outcomes.\n",
    "#n is the number of dice we are rolling.\n",
    "def get_outcomes(n):\n",
    "    #empty starting list of outcomes\n",
    "    possible_outcomes = [[]]\n",
    "    #for loop iterating through a range of numbers from 0 to n, n being excluded, that is the number of the dice that are rolled.\n",
    "    for flip in range(n):\n",
    "        #a copy list is generated\n",
    "        tmp = possible_outcomes.copy()\n",
    "        #starting list is emptied\n",
    "        possible_outcomes = []\n",
    "        #for loop iterating through the results currently stored in the copy list.\n",
    "        for current_outcome in tmp:\n",
    "            #for each one of the already computed intermidiate outcomes the result of another die is added.\n",
    "            for outcome in range(6):\n",
    "                possible_outcomes.append(current_outcome + [outcome+1])\n",
    "    #the complete list is returned\n",
    "    return list(set(tuple(sorted(sub)) for sub in possible_outcomes))\n",
    "    \n",
    "print(\"All possible outcomes length for the throw of 3 dice:\", len(get_outcomes(3)))\n",
    "#print(\"All possible outcomes length for the throw of 4 dice:\", len(get_outcomes(4)))\n",
    "#print(\"All possible outcomes length for the throw of 5 dice:\", len(get_outcomes(5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Write functions that return, given five dice, True or False if we have Straight, Full,Poker or Generala.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#check_equal is an auxiliary function that given a list as parameter returns true if all the elements in the lis are equal and\n",
    "#false otherwise\n",
    "def check_equal(lst):\n",
    "    return lst[1:] == lst[:-1]\n",
    "\n",
    "#is_straight is a function that given a list containing the result of the throw of 5 dice returns whether the list contains a straight or not\n",
    "def is_straight(result):\n",
    "    for i in result:\n",
    "        if result.count(i) > 1:\n",
    "            #print(result,\"is not a straight\")\n",
    "            return 0\n",
    "    #print(result, \"is a straight\")\n",
    "    return 1\n",
    "\n",
    "\n",
    "#is_straight([1,2,3,4,5])\n",
    "#is_straight([1,1,3,4,5])\n",
    "#is_straight([1,2,3,5,5])\n",
    "\n",
    "#is_full is a function that given a list containing the result of the throw of 5 dice returns whether the list contains a full or not\n",
    "def is_full(result):\n",
    "    result.sort()\n",
    "    full = 0\n",
    "    if check_equal(result[0:2]):\n",
    "        if check_equal(result[2:5]):\n",
    "            full = 1\n",
    "    if (full == 0) and check_equal(result[0:3]):\n",
    "        if check_equal(result[3:5]):\n",
    "            full = 1\n",
    "    #if full == 1:\n",
    "    #    print(result,\"is a full\")\n",
    "    #else:\n",
    "    #    print(result,\"is not a full\")\n",
    "    return full\n",
    "\n",
    "\n",
    "#is_full([1,3,3,1,3])\n",
    "#is_full([1,3,1,3,1])\n",
    "#is_full([1,1,3,2,4])\n",
    "#is_full([1,1,1,4,5])\n",
    "#is_full([3,4,5,6,1])\n",
    "\n",
    "\n",
    "#is_poker is a function that given a list containing the result of the throw of 5 dice returns whether the list contains a poker or not\n",
    "def is_poker(result):\n",
    "    result.sort()\n",
    "    poker = 0\n",
    "    if check_equal(result[0:4]) or check_equal(result[1:5]):\n",
    "        poker = 1\n",
    "    #    print(result,\"is a poker\")\n",
    "    #else:\n",
    "    #    print(result,\"is not a poker\")\n",
    "    return poker\n",
    "\n",
    "\n",
    "#is_poker([1,1,1,1,3])\n",
    "#is_poker([1,3,3,3,3])\n",
    "#is_poker([2,2,3,3,3])\n",
    "#is_poker([3,4,5,6,2])\n",
    "\n",
    "#is_generala is a function that given a list containing the result of the throw of 5 dice returns whether the list contains a generala or not\n",
    "def is_generala(result):\n",
    "    generala = 0\n",
    "    if check_equal(result):\n",
    "        generala = 1\n",
    "    #    print(result, \"is a generala\")\n",
    "    #else:\n",
    "    #    print(result, \"is not a generala\")\n",
    "    return generala\n",
    "\n",
    "\n",
    "#is_generala([1, 1, 1, 1, 1])\n",
    "#is_generala([1, 1, 1, 1, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Compute the probabilities that you already computed by hand by counting the outcomes describing each roll result in the list of all possible hands served.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'generala': 0.023809523809523808,\n",
       " 'full': 0.11904761904761904,\n",
       " 'poker': 0.11904761904761904,\n",
       " 'straight': 0.023809523809523808}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#is_served_probability makes use of the functions that generate the results for a throw of 5 dice and that check if a \n",
    "#certain result is one of the four types of hands in order to calculate the probability of getting a served hand out\n",
    "#of all possible results\n",
    "def is_served_probability():\n",
    "    total_outcomes = get_outcomes_with_5_dice()\n",
    "    n_total_outcomes = len(total_outcomes)\n",
    "    n_generala = 0\n",
    "    n_full = 0\n",
    "    n_poker = 0\n",
    "    n_straight = 0\n",
    "    for i in total_outcomes:\n",
    "        i = list(i)\n",
    "        if is_generala(i):\n",
    "            n_generala = n_generala + 1\n",
    "        elif is_full(i):\n",
    "            n_full = n_full + 1\n",
    "        elif is_poker(i):\n",
    "            n_poker = n_poker + 1\n",
    "        elif is_straight(i):\n",
    "            n_straight = n_straight + 1\n",
    "    probabilities = {\n",
    "        \"generala\" : (n_generala/n_total_outcomes),\n",
    "        \"full\" : (n_full/n_total_outcomes),\n",
    "        \"poker\" : (n_poker/n_total_outcomes),\n",
    "        \"straight\" : (n_straight/n_total_outcomes)\n",
    "    }\n",
    "    #print(\"the calculated probabilities for a served hand are:\")\n",
    "    #for key in probabilities:\n",
    "    #    print(key, \" = \", probabilities[key])\n",
    "    return probabilities\n",
    "\n",
    "is_served_probability()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Compute the probabilities that you already computed by hand by counting the outcomes describing each roll result in the list of all possible hands**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the calculated probabilities for a non served hand are:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'generala': 0.07142857142857142,\n",
       " 'full': 0.3571428571428571,\n",
       " 'poker': 0.3571428571428571,\n",
       " 'straight': 0.07142857142857142}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#is_not_served_probability makes use of the functions that generate the results for a throw of 5 dice and that check if a \n",
    "#certain result is one of the four types of hands in order to calculate the probability of getting a hand out\n",
    "#of all possible results taking in account that a player could get the searched result in any of 3 re-throws.\n",
    "def is_not_served_probability():\n",
    "    probabilities = is_served_probability()\n",
    "    print(\"the calculated probabilities for a non served hand are:\")\n",
    "    for key in probabilities:\n",
    "        probabilities[key] = (probabilities.get(key)*3)\n",
    "    #for key in probabilities:\n",
    "    #    print(key, \" = \", probabilities[key])\n",
    "    return probabilities\n",
    "\n",
    "is_not_served_probability()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both probabilities (for a served and for a non-served hand) seem odd since the probability of getting a full or a poker and the one of getting a generala and a straight are the same. That is due to the fact that we eliminated any duplicate in the list of all the possible outcomes. Duplicates are all those lists of results that once sorted (since the order of the dices is not important) give the same hand.\n",
    "\n",
    "**6. Write a function that simulate a roll with n fair dices.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this function simulates the roll of n fair dices by using random numbers in a range from one to six as result of a thorw of dice.\n",
    "#the parameter n is the number of dice that are thrown simultaneously\n",
    "def roll(n):\n",
    "    result = []\n",
    "    for i in range(n):\n",
    "        result.append(random.randint(1, 6))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7. Write a function that plays automatically, always looking for a Generala with a greedy strategy (always keeping the most dices of the same kind and rolling the others) that returns True if we get a Generala and a False otherwise. Which kind of distribution follow this function results? Explain your reasoning within the delivered python notebook.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f4dc8bffc50>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#This function, given a list of numbers as a parameter, returns the longest sequence of metching numbers. If more numbers appear \n",
    "#the same ammount of time the first longest sequence is considered\n",
    "def get_longest_matched_sequence(list):\n",
    "    longest_seq = {}\n",
    "    for i in list:\n",
    "        if not i in longest_seq:\n",
    "            longest_seq[i] = 1\n",
    "        else:\n",
    "            longest_seq[i] = longest_seq.get(i) + 1\n",
    "    max_value = max(longest_seq, key=longest_seq.get)\n",
    "    seq = [max_value] * longest_seq[max_value]\n",
    "    return seq\n",
    "\n",
    "#This function uses an auxiliary recurrent function to play generala in the attempt to get one generala hand. It return true if\n",
    "#it does.\n",
    "#n is the number of dice we are rolling\n",
    "#k is the maximum amount of time we can reroll all or some of the dice\n",
    "def get_generala(n,k):\n",
    "    return get_generala_aux([],[],n,k-1,5)\n",
    "\n",
    "def get_generala_aux(result,keep,n,k,expected_len):\n",
    "    if is_generala(result) and len(result) == expected_len:\n",
    "        #print(\"You got a generala!\", result)\n",
    "        return True\n",
    "    else:\n",
    "        if k == 0 and (not is_generala(result)):\n",
    "            #print(\"maximum number of re-rolls reached without a generala\", result)\n",
    "            return False\n",
    "        else:\n",
    "            intermediate_result = roll(n)\n",
    "            for i in intermediate_result:\n",
    "                keep.append(i)\n",
    "            result = keep\n",
    "            keep = get_longest_matched_sequence(keep)\n",
    "            new_n = expected_len - len(keep)\n",
    "            return get_generala_aux(result, keep, new_n, (k-1), expected_len)\n",
    "\n",
    "results = []\n",
    "for i in range(500):\n",
    "    if get_generala(5,3):\n",
    "        results.append(1)\n",
    "    else:\n",
    "        results.append(0)\n",
    "    \n",
    "sns.distplot(results, bins=10, kde=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The graph above is not very informative but it lets us clearly see that we can just distinghish between two results (true or false) and that we have a higher probability of not getting a generala then getting it. This makes up for a Bernulli Distribution.\n",
    "\n",
    "**8. Write a function that plays until it gets a Generala, count how many times it had to play to get it and return this number. Which kind of distribution follow this function results? Explain your reasoning within the delivered python notebook.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f4dc8b81ac8>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def play_until_generala():\n",
    "    number_of_attempts = 0\n",
    "    while True:\n",
    "        number_of_attempts = number_of_attempts + 1\n",
    "        if get_generala(5, 3):\n",
    "            break\n",
    "    #print(\"You had to play \", number_of_attempts, \"times before getting a generala\")\n",
    "    return number_of_attempts\n",
    "\n",
    "play_until_generala()\n",
    "\n",
    "results = []\n",
    "for i in range(500):\n",
    "    results.append(play_until_generala())\n",
    "    \n",
    "sns.distplot(results, bins=10, kde=False)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the graph above we see the number of people that got a generala on the y axis and the amount of times one had to play in order to get a generala. As we can see by appling a greedy approach to the way we play generala we will experience higher probabilities of getting a generala after a little amount of games and a lower amount of people getting a generala after playing for a long time. This makes up for a decreasing exponential distribution."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}