Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pokemon Analysis - Some Questions and Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This notebook answers some theoretical and emperical questions about pokemon typings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "from itertools import combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# These questions can be answered with two datasets:\n",
    "pokemon = pd.read_csv('Pokemon_extensive.csv')\n",
    "types = pd.read_csv('Types.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pokedex_number</th>\n",
       "      <th>name</th>\n",
       "      <th>generation</th>\n",
       "      <th>is_sub_legendary</th>\n",
       "      <th>is_legendary</th>\n",
       "      <th>is_mythical</th>\n",
       "      <th>species</th>\n",
       "      <th>type_number</th>\n",
       "      <th>type_1</th>\n",
       "      <th>type_2</th>\n",
       "      <th>...</th>\n",
       "      <th>against_Ground</th>\n",
       "      <th>against_Flying</th>\n",
       "      <th>against_Psychic</th>\n",
       "      <th>against_Bug</th>\n",
       "      <th>against_Rock</th>\n",
       "      <th>against_Ghost</th>\n",
       "      <th>against_Dragon</th>\n",
       "      <th>against_Dark</th>\n",
       "      <th>against_Steel</th>\n",
       "      <th>against_Fairy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Bulbasaur</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Seed Pokémon</td>\n",
       "      <td>2</td>\n",
       "      <td>Grass</td>\n",
       "      <td>Poison</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Ivysaur</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Seed Pokémon</td>\n",
       "      <td>2</td>\n",
       "      <td>Grass</td>\n",
       "      <td>Poison</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Venusaur</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Seed Pokémon</td>\n",
       "      <td>2</td>\n",
       "      <td>Grass</td>\n",
       "      <td>Poison</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>Mega Venusaur</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Seed Pokémon</td>\n",
       "      <td>2</td>\n",
       "      <td>Grass</td>\n",
       "      <td>Poison</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>Charmander</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Lizard Pokémon</td>\n",
       "      <td>1</td>\n",
       "      <td>Fire</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 44 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   pokedex_number           name  generation  is_sub_legendary  is_legendary  \\\n",
       "0               1      Bulbasaur           1                 0             0   \n",
       "1               2        Ivysaur           1                 0             0   \n",
       "2               3       Venusaur           1                 0             0   \n",
       "3               3  Mega Venusaur           1                 0             0   \n",
       "4               4     Charmander           1                 0             0   \n",
       "\n",
       "   is_mythical         species  type_number type_1  type_2  ...  \\\n",
       "0            0    Seed Pokémon            2  Grass  Poison  ...   \n",
       "1            0    Seed Pokémon            2  Grass  Poison  ...   \n",
       "2            0    Seed Pokémon            2  Grass  Poison  ...   \n",
       "3            0    Seed Pokémon            2  Grass  Poison  ...   \n",
       "4            0  Lizard Pokémon            1   Fire     NaN  ...   \n",
       "\n",
       "   against_Ground  against_Flying  against_Psychic against_Bug against_Rock  \\\n",
       "0             1.0             2.0              2.0         1.0          1.0   \n",
       "1             1.0             2.0              2.0         1.0          1.0   \n",
       "2             1.0             2.0              2.0         1.0          1.0   \n",
       "3             1.0             2.0              2.0         1.0          1.0   \n",
       "4             2.0             1.0              1.0         0.5          2.0   \n",
       "\n",
       "  against_Ghost  against_Dragon  against_Dark  against_Steel  against_Fairy  \n",
       "0           1.0             1.0           1.0            1.0            0.5  \n",
       "1           1.0             1.0           1.0            1.0            0.5  \n",
       "2           1.0             1.0           1.0            1.0            0.5  \n",
       "3           1.0             1.0           1.0            1.0            0.5  \n",
       "4           1.0             1.0           1.0            0.5            0.5  \n",
       "\n",
       "[5 rows x 44 columns]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The pokemon dataframe contains all pokemons (first 7 generations) and their stats\n",
    "pokemon.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Attacking</th>\n",
       "      <th>Normal</th>\n",
       "      <th>Fire</th>\n",
       "      <th>Water</th>\n",
       "      <th>Electric</th>\n",
       "      <th>Grass</th>\n",
       "      <th>Ice</th>\n",
       "      <th>Fighting</th>\n",
       "      <th>Poison</th>\n",
       "      <th>Ground</th>\n",
       "      <th>Flying</th>\n",
       "      <th>Psychic</th>\n",
       "      <th>Bug</th>\n",
       "      <th>Rock</th>\n",
       "      <th>Ghost</th>\n",
       "      <th>Dragon</th>\n",
       "      <th>Dark</th>\n",
       "      <th>Steel</th>\n",
       "      <th>Fairy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Normal</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Fire</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Water</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Electric</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Grass</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Ice</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Fighting</td>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Poison</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Ground</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Flying</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Psychic</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Bug</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Rock</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Ghost</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Dragon</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Dark</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Steel</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>Fairy</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Attacking  Normal  Fire  Water  Electric  Grass  Ice  Fighting  Poison  \\\n",
       "0     Normal       1   1.0    1.0       1.0    1.0  1.0       1.0     1.0   \n",
       "1       Fire       1   0.5    0.5       1.0    2.0  2.0       1.0     1.0   \n",
       "2      Water       1   2.0    0.5       1.0    0.5  1.0       1.0     1.0   \n",
       "3   Electric       1   1.0    2.0       0.5    0.5  1.0       1.0     1.0   \n",
       "4      Grass       1   0.5    2.0       1.0    0.5  1.0       1.0     0.5   \n",
       "5        Ice       1   0.5    0.5       1.0    2.0  0.5       1.0     1.0   \n",
       "6   Fighting       2   1.0    1.0       1.0    1.0  2.0       1.0     0.5   \n",
       "7     Poison       1   1.0    1.0       1.0    2.0  1.0       1.0     0.5   \n",
       "8     Ground       1   2.0    1.0       2.0    0.5  1.0       1.0     2.0   \n",
       "9     Flying       1   1.0    1.0       0.5    2.0  1.0       2.0     1.0   \n",
       "10   Psychic       1   1.0    1.0       1.0    1.0  1.0       2.0     2.0   \n",
       "11       Bug       1   0.5    1.0       1.0    2.0  1.0       0.5     0.5   \n",
       "12      Rock       1   2.0    1.0       1.0    1.0  2.0       0.5     1.0   \n",
       "13     Ghost       0   1.0    1.0       1.0    1.0  1.0       1.0     1.0   \n",
       "14    Dragon       1   1.0    1.0       1.0    1.0  1.0       1.0     1.0   \n",
       "15      Dark       1   1.0    1.0       1.0    1.0  1.0       0.5     1.0   \n",
       "16     Steel       1   0.5    0.5       0.5    1.0  2.0       1.0     1.0   \n",
       "17     Fairy       1   0.5    1.0       1.0    1.0  1.0       2.0     0.5   \n",
       "\n",
       "    Ground  Flying  Psychic  Bug  Rock  Ghost  Dragon  Dark  Steel  Fairy  \n",
       "0      1.0     1.0      1.0  1.0   0.5    0.0     1.0   1.0    0.5    1.0  \n",
       "1      1.0     1.0      1.0  2.0   0.5    1.0     0.5   1.0    2.0    1.0  \n",
       "2      2.0     1.0      1.0  1.0   2.0    1.0     0.5   1.0    1.0    1.0  \n",
       "3      0.0     2.0      1.0  1.0   1.0    1.0     0.5   1.0    1.0    1.0  \n",
       "4      2.0     0.5      1.0  0.5   2.0    1.0     0.5   1.0    0.5    1.0  \n",
       "5      2.0     2.0      1.0  1.0   1.0    1.0     2.0   1.0    0.5    1.0  \n",
       "6      1.0     0.5      0.5  0.5   2.0    0.0     1.0   2.0    2.0    0.5  \n",
       "7      0.5     1.0      1.0  1.0   0.5    0.5     1.0   1.0    0.0    2.0  \n",
       "8      1.0     0.0      1.0  0.5   2.0    1.0     1.0   1.0    2.0    1.0  \n",
       "9      1.0     1.0      1.0  2.0   0.5    1.0     1.0   1.0    0.5    1.0  \n",
       "10     1.0     1.0      0.5  1.0   1.0    1.0     1.0   0.0    0.5    1.0  \n",
       "11     1.0     0.5      2.0  1.0   1.0    0.5     1.0   2.0    0.5    0.5  \n",
       "12     0.5     2.0      1.0  2.0   1.0    1.0     1.0   1.0    0.5    1.0  \n",
       "13     1.0     1.0      2.0  1.0   1.0    2.0     1.0   0.5    1.0    1.0  \n",
       "14     1.0     1.0      1.0  1.0   1.0    1.0     2.0   1.0    0.5    0.0  \n",
       "15     1.0     1.0      2.0  1.0   1.0    2.0     1.0   0.5    1.0    0.5  \n",
       "16     1.0     1.0      1.0  1.0   2.0    1.0     1.0   1.0    0.5    2.0  \n",
       "17     1.0     1.0      1.0  1.0   1.0    1.0     2.0   2.0    0.5    1.0  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The types dataframe contains type effectiveness information\n",
    "types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 1: How many unique type combinations are there?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let $V$ be a one-dimensional vector containing all pokemon types. Then, all type combinations are uniquely defined by the upper (or lower) triangle of the outer product of this vector. \n",
    "\n",
    "$\\text{all_combos} = V.V^T$\n",
    "\n",
    "Note1: the diagonal of this matrix is all monotypes. there are 18 \n",
    "<br>\n",
    "Note2: the upper and lower triangle (discluding the diagonal) are symmetric with respect to combinations, but non-unique with respect to permutations. The permutations can represent primary and secondary typings of dual type pokemons. For example, all_combos[0,1] = NormalFire and all_combos[1,0] = FireNormal. Since I am not aware of primary/secondary typings having much impact, let us only care about unique combinations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "types_vector = np.asarray(types['Attacking'])\n",
    "all_permutations = types_vector[:,None]+types_vector # outer product\n",
    "all_combos = set(np.triu(all_permutations).flatten())\n",
    "all_combos.remove(0) # some extra fluff from np.triu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: There are exactly 171 type combinations in Pokemon\n"
     ]
    }
   ],
   "source": [
    "print(\"Answer: There are exactly %d type combinations in Pokemon\" % (len(all_combos)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, it was not necessary to compute all unique combinations explicitly, since the answer is a triangular number: \n",
    "<br>\n",
    "$N * (N+1) / 2 = 18 * 19 / 2 = 171$\n",
    "\n",
    "However, storing these combinations for later will help us answer some questiosn :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Question 2: Are all combinations available?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this helper function will help us solve some problems\n",
    "def typeCombinationSplitter(combo: str):\n",
    "    \"\"\"\n",
    "        Args:\n",
    "            combo (str) : A pokemon typing string from what is produced by \n",
    "            all_combos above. E.g. 'GroundWater', 'WaterWater'\n",
    "        \n",
    "        Returns:\n",
    "            2-tuple : lists both \n",
    "    \n",
    "    \"\"\"\n",
    "    # splits the combination typing into component types\n",
    "    t = set([])\n",
    "    for pokemon_type in types_vector:\n",
    "        if pokemon_type in combo:\n",
    "            t.add(pokemon_type)\n",
    "    # note: we lexographically sort here, to aid in \n",
    "    # checking for uniqueness later on.\n",
    "    return tuple(sorted(list(t)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to re-orient all_combos so that type1, type2 are lexographically ordered. \n",
    "# This could have also been achieved by sorting the types in the original types data table.\n",
    "all_sorted_combos = set([])\n",
    "for combo in all_combos:\n",
    "    this_combo = reduce(lambda x,y : x+y, typeCombinationSplitter(combo))\n",
    "    all_sorted_combos.add(this_combo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 153 of 171 theoretical typings\n",
      "The following typings are currently unavailable\n",
      "IcePoison\n",
      "BugDark\n",
      "NormalSteel\n",
      "BugNormal\n",
      "FairyFire\n",
      "PoisonPsychic\n",
      "GhostRock\n",
      "IceNormal\n",
      "ElectricFighting\n",
      "BugDragon\n",
      "GhostNormal\n",
      "PoisonSteel\n",
      "FireGrass\n",
      "NormalRock\n",
      "FairyFighting\n",
      "NormalPoison\n",
      "FairyGround\n",
      "FightingGround\n"
     ]
    }
   ],
   "source": [
    "# Now, we can gather the emperical combos for comparisons\n",
    "all_emperical_combos = set([])\n",
    "pokemon\n",
    "for ind, row in pokemon.iterrows():\n",
    "    nonzero_types = [row['type_1']]\n",
    "    if row['type_number'] > 1: \n",
    "        nonzero_types.append(row['type_2'])\n",
    "\n",
    "    # sorting to avoid non-unique permuatations. \n",
    "    this_combo = reduce(lambda x,y : x+y, sorted(nonzero_types))\n",
    "\n",
    "    # missing data\n",
    "    if this_combo == 'nan' or this_combo == None or (type(this_combo) == float and np.isnan(this_combo)):\n",
    "        assert False\n",
    "    all_emperical_combos.add(this_combo)\n",
    "\n",
    "print(\"There are {} of {} theoretical typings\".format(len(all_emperical_combos), len(all_sorted_combos)))\n",
    "print(\"The following typings are currently unavailable\")\n",
    "for combo in all_sorted_combos - all_emperical_combos:\n",
    "    print(combo)\n",
    "\n",
    "# sanity check, we should have no emperical combos outside of the theoretical ones\n",
    "assert (len(all_emperical_combos - all_sorted_combos) == 0)   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interesting. There are still 18 dual types that do not yet exist :). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2 Bonus: The smaller dataset only had 133 emperical types.. which ones are new?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I originally did this investigation with a smaller dataset. Interestingly, the number jumped form 133 to 153 when I switched to the larger dataset. Out of curiosity, which pokemons were introduced ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emperical set differences: (Old - New)\n",
      "set()\n",
      "Emperical set differences: (New - New)\n",
      "{'FightingGhost', 'DarkElectric', 'DarkFairy', 'DragonNormal', 'FireIce', 'FightingIce', 'ElectricPsychic', 'FairyPoison', 'DarkNormal', 'PoisonRock', 'FirePoison', 'IceSteel', 'ElectricPoison', 'FairyGhost', 'BugFairy', 'ElectricRock', 'DragonFighting', 'BugIce', 'BugPsychic', 'FairyIce'}\n",
      "\n",
      "Here are the new pokemon that occupied the previously missing dual types: \n",
      "FightingGhost ['Marshadow']\n",
      "DarkElectric ['Morpeko Full Belly Mode', 'Morpeko Hangry Mode']\n",
      "DarkFairy ['Impidimp', 'Morgrem', 'Grimmsnarl']\n",
      "DragonNormal ['Drampa']\n",
      "FireIce ['Darmanitan Galarian Zen Mode']\n",
      "FightingIce ['Crabominable']\n",
      "ElectricPsychic ['Alolan Raichu']\n",
      "FairyPoison ['Galarian Weezing']\n",
      "DarkNormal ['Alolan Rattata', 'Alolan Raticate', 'Galarian Zigzagoon', 'Galarian Linoone', 'Obstagoon']\n",
      "PoisonRock ['Nihilego']\n",
      "FirePoison ['Salandit', 'Salazzle']\n",
      "IceSteel ['Alolan Sandshrew', 'Alolan Sandslash']\n",
      "ElectricPoison ['Toxel', 'Toxtricity Low Key Form', 'Toxtricity Amped Form']\n",
      "FairyGhost ['Mimikyu']\n",
      "BugFairy ['Cutiefly', 'Ribombee']\n",
      "ElectricRock ['Alolan Geodude', 'Alolan Graveler', 'Alolan Golem']\n",
      "DragonFighting ['Hakamo-o', 'Kommo-o']\n",
      "BugIce ['Snom', 'Frosmoth']\n",
      "BugPsychic ['Dottler', 'Orbeetle']\n",
      "FairyIce ['Alolan Ninetales']\n"
     ]
    }
   ],
   "source": [
    "# TODO: move this into a funciton.. 4th time using it..\n",
    "previous_pokemon = pd.read_csv(\"Pokemon.csv\")\n",
    "previous_emperical_combos = {}\n",
    "for ind, row in previous_pokemon.iterrows():\n",
    "    type1, type2 = row[\"Type 1\"], row[\"Type 2\"]\n",
    "    nonzero_types = [type1]\n",
    "    if type2 != None and type(type2) == str: # otherwise it is NaN - monotype\n",
    "        nonzero_types.append(type2)\n",
    "\n",
    "    # sorting to avoid non-unique permuatations. \n",
    "    this_combo = reduce(lambda x,y : x+y, sorted(nonzero_types))\n",
    "    if this_combo in previous_emperical_combos:\n",
    "        previous_emperical_combos[this_combo] += 1\n",
    "    else:\n",
    "        previous_emperical_combos[this_combo] = 1\n",
    "\n",
    "        \n",
    "s1 = set([val for val in previous_emperical_combos.keys()])\n",
    "s2 = set([val for val in all_emperical_combos.keys()])\n",
    "print(\"Emperical set differences: (Old - New)\")\n",
    "print(s1 - s2)\n",
    "print(\"Emperical set differences: (New - New)\")\n",
    "print(s2 - s1)\n",
    "print('')\n",
    "print(\"Here are the new pokemon that occupied the previously missing dual types: \")\n",
    "for combo in s2 - s1:\n",
    "    print(combo, all_emperical_combos[combo])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3: Which types are most and least prevelant?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "The top 10 most prevalant pokemon types are:\n",
      "Water 72\n",
      "Normal 71\n",
      "Psychic 44\n",
      "Grass 43\n",
      "Fire 34\n",
      "Electric 33\n",
      "Fighting 28\n",
      "FlyingNormal 27\n",
      "Bug 19\n",
      "Fairy 19\n",
      "\n",
      "\n",
      "The top 10 least prevalant pokemon types are:\n",
      "ElectricGround 1\n",
      "FightingRock 1\n",
      "GroundNormal 1\n",
      "FightingFlying 1\n",
      "FireWater 1\n",
      "FightingIce 1\n",
      "FairyGhost 1\n",
      "DragonNormal 1\n",
      "PoisonRock 1\n",
      "FightingGhost 1\n"
     ]
    }
   ],
   "source": [
    "# To answer this question, we can repurpose the above code to use a counter:\n",
    "all_emperical_combos = {}\n",
    "pokemon\n",
    "for ind, row in pokemon.iterrows():\n",
    "    nonzero_types = [row['type_1']]\n",
    "    if row['type_number'] > 1: \n",
    "        nonzero_types.append(row['type_2'])\n",
    "\n",
    "    # sorting to avoid non-unique permuatations. \n",
    "    this_combo = reduce(lambda x,y : x+y, sorted(nonzero_types))\n",
    "\n",
    "    # missing data\n",
    "    if this_combo == 'nan' or this_combo == None or (type(this_combo) == float and np.isnan(this_combo)):\n",
    "        assert False\n",
    "    \n",
    "    if this_combo in all_emperical_combos:\n",
    "        all_emperical_combos[this_combo] += 1\n",
    "    else:\n",
    "        all_emperical_combos[this_combo] = 1\n",
    "\n",
    "        \n",
    "ranked_by_prevalance = [(combo, count) for combo, count in all_emperical_combos.items()]\n",
    "ranked_by_prevalance.sort(key=lambda x : x[1], reverse=True)\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"The top 10 most prevalant pokemon types are:\")\n",
    "for combo, count in ranked_by_prevalance[:10]:\n",
    "    print(combo, count)\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"The top 10 least prevalant pokemon types are:\")\n",
    "for combo, count in ranked_by_prevalance[-10:]:\n",
    "    print(combo, count)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool! Some people would definitely had guessed that Water and Normal would be most prevalent. However I was surprised to see some dual types in the top 10.. Although it must be true that \"FlyingNormal\" blankets all regions xD. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3 Bonus: How many pokemon are the *only* one of their type combo, and what are they?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This question is begging to be answered by the previous result. How many pokemon are lonely (only ones)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "There are 24 pokemon who are the only ones of their type combo!. Here they Are:\n",
      "ElectricPsychic - Alolan Raichu\n",
      "FairyIce - Alolan Ninetales\n",
      "FairyPoison - Galarian Weezing\n",
      "BugGhost - Shedinja\n",
      "DragonFairy - Mega Altaria\n",
      "GrassGround - Torterra\n",
      "SteelWater - Empoleon\n",
      "NormalWater - Bibarel\n",
      "GhostIce - Froslass\n",
      "ElectricGhost - Rotom\n",
      "ElectricFire - Heat Rotom\n",
      "ElectricGrass - Mow Rotom\n",
      "FireSteel - Heatran\n",
      "FireIce - Darmanitan Galarian Zen Mode\n",
      "ElectricGround - Stunfisk\n",
      "FightingRock - Terrakion\n",
      "GroundNormal - Diggersby\n",
      "FightingFlying - Hawlucha\n",
      "FireWater - Volcanion\n",
      "FightingIce - Crabominable\n",
      "FairyGhost - Mimikyu\n",
      "DragonNormal - Drampa\n",
      "PoisonRock - Nihilego\n",
      "FightingGhost - Marshadow\n"
     ]
    }
   ],
   "source": [
    "# Gathering them all by name, it's easiest just to repurpose the above code (third time)\n",
    "all_emperical_combos = {}\n",
    "pokemon\n",
    "for ind, row in pokemon.iterrows():\n",
    "    nonzero_types = [row['type_1']]\n",
    "    if row['type_number'] > 1: \n",
    "        nonzero_types.append(row['type_2'])\n",
    "\n",
    "    # sorting to avoid non-unique permuatations. \n",
    "    this_combo = reduce(lambda x,y : x+y, sorted(nonzero_types))\n",
    "\n",
    "    # missing data\n",
    "    if this_combo == 'nan' or this_combo == None or (type(this_combo) == float and np.isnan(this_combo)):\n",
    "        assert False\n",
    "\n",
    "    if this_combo in all_emperical_combos:\n",
    "        all_emperical_combos[this_combo].append(row[\"name\"])\n",
    "    else:\n",
    "        all_emperical_combos[this_combo] = [row['name']]\n",
    "\n",
    "\n",
    "ranked_by_prevalance = [(combo, len(val), val) for combo, val in all_emperical_combos.items()]\n",
    "ranked_by_prevalance.sort(key=lambda x : x[1], reverse=True)\n",
    "pb = 1\n",
    "while(ranked_by_prevalance[-(pb+1)][1] == 1):\n",
    "    pb += 1\n",
    "    \n",
    "print(\"\\n\")\n",
    "print(\"There are {} pokemon who are the only ones of their type combo!. Here they Are:\".format(pb))\n",
    "for combo, count, these_pokemon in ranked_by_prevalance[-pb:]:\n",
    "    print(\"{} - {}\".format(combo, these_pokemon[0]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 4: Which 4-move movepool has the most super effective coverage?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need a helper function to compute type vulnerabilities\n",
    "def typeComboVulnerabilities(combo):\n",
    "    # computes the vector of type vulnerabilities for this \n",
    "    # type combinations    \n",
    "    if(len(combo) == 1):\n",
    "        vals = types[combo[0]].copy()\n",
    "    else:\n",
    "        # it's just broadcasted product\n",
    "        vals = types[combo[0]] * types[combo[1]]\n",
    "    vals.index = types['Attacking']\n",
    "    return vals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attacking\n",
      "Normal      1.00\n",
      "Fire        1.00\n",
      "Water       2.00\n",
      "Electric    1.00\n",
      "Grass       0.25\n",
      "Ice         0.50\n",
      "Fighting    0.50\n",
      "Poison      1.00\n",
      "Ground      1.00\n",
      "Flying      2.00\n",
      "Psychic     1.00\n",
      "Bug         0.50\n",
      "Rock        4.00\n",
      "Ghost       1.00\n",
      "Dragon      1.00\n",
      "Dark        1.00\n",
      "Steel       0.50\n",
      "Fairy       0.50\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# for example, we can evaluate the vulnerabilities of a BugFire type. E.g. Volcarona\n",
    "type1 = typeCombinationSplitter(\"BugFire\")\n",
    "print(typeComboVulnerabilities(type1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def typePoolEffectiveness(type_pool: list, target_pokemon : set):\n",
    "    \"\"\"\n",
    "        Returns how many pokemons this type movepool would be\n",
    "        super effective against\n",
    "        \n",
    "        Args: \n",
    "            type_pool (list) : list of types, indicating a pokes movepool\n",
    "            target_pokemon (set) : pokemon in the arena (could be tier ? TODO count of all of them?)\n",
    "    \"\"\"\n",
    "    count = 0\n",
    "    for pokemon_typing in target_pokemon:\n",
    "        combo = typeCombinationSplitter(pokemon_typing)\n",
    "        vuln = typeComboVulnerabilities(combo)\n",
    "        for movetype in type_pool:\n",
    "            if vuln[movetype] >= 2: # not distinguishing between x2 and 4x here, both are super effective\n",
    "                count += 1\n",
    "                break\n",
    "    return count\n",
    "\n",
    "def getBestMovePoolsUsingNMoves(N, target_pokemon : set):\n",
    "    ans = None\n",
    "    best = 0\n",
    "    for type_pool_combo in combinations(types['Attacking'], N):\n",
    "        val = typePoolEffectiveness(type_pool_combo, target_pokemon)\n",
    "        if val == best:\n",
    "            ans.append(type_pool_combo)\n",
    "        elif(val > best):\n",
    "            best = val\n",
    "            ans = [type_pool_combo]\n",
    "    \n",
    "    return best, ans\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Effective against 135 out of 171 theoretical typings (78.94736842105263%)\n",
      "Effective against 122 out of 133 emperical typings (79.73856209150327%)\n"
     ]
    }
   ],
   "source": [
    "# typePoolEffectiveness will give us the number of theoretical types that \n",
    "# a given movepool will at least have one super effective move against.\n",
    "\n",
    "# Here is a test of one of the well-known high coverage movepoools for\n",
    "# Electivire: \n",
    "count = typePoolEffectiveness(['Electric', 'Ice', 'Fighting', 'Ground'], all_sorted_combos)\n",
    "print(\"Effective against {} out of 171 theoretical typings ({}%)\".format(count, count / float(len(all_sorted_combos)) * 100.))\n",
    "count = typePoolEffectiveness(['Electric', 'Ice', 'Fighting', 'Ground'], all_emperical_combos)\n",
    "print(\"Effective against {} out of 133 emperical typings ({}%)\".format(count, count / float(len(all_emperical_combos)) * 100.))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool! Electivire's movepool can hit 80% of all emperical typings for super effective! That is impressive. Note: as we saw above, the actual distritions of these type combos will fluctuate and naturally, the percentage of all actual pokemont that can be hit will be slightly different. Moreover, it may be interesting to examine the result of getBestMovePoolsUsingNMoves() on different tiers or universes, since this naturally comes up in both competitive and casual play."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, can we find a movepool that is better ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150 [('Ice', 'Ground', 'Rock', 'Fairy')]\n"
     ]
    }
   ],
   "source": [
    "count, ans = getBestMovePoolsUsingNMoves(4, all_sorted_combos)\n",
    "print(count, ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice! The movepool: ('Ice', 'Ground', 'Rock', 'Fairy'), hits more!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Effective against 150 out of 171 theoretical typings (87.71929824561403%)\n",
      "Effective against 133 out of 153 emperical typings (86.9281045751634%)\n"
     ]
    }
   ],
   "source": [
    "# Now, let's see what percentage it hits!\n",
    "best4 = ['Ice', 'Ground', 'Rock', 'Fairy']\n",
    "count = typePoolEffectiveness(best4, all_sorted_combos)\n",
    "print(\"Effective against {} out of 171 theoretical typings ({}%)\".format(count, count / float(len(all_sorted_combos)) * 100.))\n",
    "count = typePoolEffectiveness(best4, all_emperical_combos)\n",
    "print(\"Effective against {} out of {} emperical typings ({}%)\".format(count, len(all_emperical_combos), count / float(len(all_emperical_combos)) * 100.))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is a nice improvement! A follow up investigation: can any pokemon incorporate these 4 types into a valid movepool ? This would require more data sets. Namely, we would need to know the movepool of each pokemon. Moreover, not all moves are createded equally, so this investigation could baloon in complexity once we leverage damage/accuracy/effects of the pertinent moves. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 5: Which pokemon has the most offensive dual type?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's simplify this question to: Which dual type has the most super effective STAB coverage?\n",
    "If you do not know: STAB = Same Type Additive Bonus = if a pokemon is using a move of its type, it will do 1.5x damage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "109 [('Ice', 'Ground')]\n"
     ]
    }
   ],
   "source": [
    "# Functionaly, this question is a subset of the one above:\n",
    "count, ans = getBestMovePoolsUsingNMoves(2, all_sorted_combos)\n",
    "print(count, ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice! A lot of people will not guess this. Maybe people would guess FireWater or ElectricIce. Interstingly, this dual typing is a subset of the 4-move movepool shown above. This must mean that ground and ice constitute a decent amount of coverage. Now, how many pokemon are of this type?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Swinub', 'Piloswine', 'Mamoswine']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For this, we can recyle our data structure from earlier:\n",
    "all_emperical_combos[\"GroundIce\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow! That is a single evolutionary line. Take a look at mamoswine's current smogon page:\n",
    "https://www.smogon.com/dex/sm/pokemon/mamoswine/\n",
    "\n",
    "\n",
    "So most STAB coverage + 130 attk + priority moves!? Is mamoswine OP?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 6: Which pokemon has the most defensive type?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can evaluate this question from a couple different angles. For example, some pokemon may have few weakness, while others may have a lot of invulnerabilities. Let's take a look at both:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most defensive types: (with 1 weaknesses)\n",
      "('Dark', 'Ghost')\n",
      "('Normal',)\n",
      "('Ghost', 'Normal')\n",
      "('Bug', 'Steel')\n",
      "('Dark', 'Poison')\n",
      "('Ground', 'Water')\n",
      "('Electric',)\n",
      "Least defensive types: (with 7 weaknesses)\n",
      "('Dark', 'Grass')\n",
      "('Dark', 'Rock')\n",
      "('Grass', 'Psychic')\n",
      "('Psychic', 'Rock')\n",
      "('Grass', 'Ice')\n",
      "('Fighting', 'Rock')\n"
     ]
    }
   ],
   "source": [
    "# based on what is super effective against it\n",
    "super_effective_counts = {}\n",
    "for pokemon_typing in all_sorted_combos:\n",
    "    combo = typeCombinationSplitter(pokemon_typing)\n",
    "    vuln = typeComboVulnerabilities(combo)\n",
    "    supp = [val for val in vuln if val >= 2]\n",
    "    n = len(supp)\n",
    "    if n in super_effective_counts:\n",
    "        super_effective_counts[n].append(combo)\n",
    "    else:\n",
    "        super_effective_counts[n] = [combo]\n",
    "        \n",
    "sorted_defensive_types = [(key, val) for key, val in super_effective_counts.items()]\n",
    "sorted_defensive_types.sort(key=lambda x:x[0])\n",
    "\n",
    "\n",
    "print(\"Most defensive types: (with {} weaknesses)\".format(sorted_defensive_types[0][0]))\n",
    "for combo in sorted_defensive_types[0][1]:\n",
    "    print(combo)\n",
    "print(\"Least defensive types: (with {} weaknesses)\".format(sorted_defensive_types[-1][0]))\n",
    "for combo in sorted_defensive_types[-1][1]:\n",
    "    print(combo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice. One of the commonly touted defensive typings is BugSteel, which ends up here. Interestlingly, by default, Normal and Electric both end up with only one weakness (Fighting, Ground, resp.). It's also nice to see GroundWater show up; not only am I a huge swampert fan, but this combo makes so much since when you think the constituent types. Let's list the pokemons of these types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most defensive types: (with 1 weaknesses)\n",
      "DarkGhost ['Sableye', 'Mega Sableye', 'Spiritomb']\n",
      "\n",
      "Normal ['Rattata', 'Raticate', 'Meowth', 'Persian', 'Lickitung', 'Chansey', 'Kangaskhan', 'Mega Kangaskhan', 'Tauros', 'Ditto', 'Eevee', 'Partner Eevee', 'Porygon', 'Snorlax', 'Sentret', 'Furret', 'Aipom', 'Dunsparce', 'Teddiursa', 'Ursaring', 'Porygon2', 'Stantler', 'Smeargle', 'Miltank', 'Blissey', 'Zigzagoon', 'Linoone', 'Slakoth', 'Vigoroth', 'Slaking', 'Whismur', 'Loudred', 'Exploud', 'Skitty', 'Delcatty', 'Spinda', 'Zangoose', 'Castform', 'Kecleon', 'Bidoof', 'Ambipom', 'Buneary', 'Lopunny', 'Glameow', 'Purugly', 'Happiny', 'Munchlax', 'Lickilicky', 'Porygon-Z', 'Regigigas', 'Arceus', 'Patrat', 'Watchog', 'Lillipup', 'Herdier', 'Stoutland', 'Audino', 'Minccino', 'Cinccino', 'Bouffalant', 'Bunnelby', 'Furfrou', 'Yungoos', 'Gumshoos', 'Type: Null', 'Silvally', 'Komala', 'Skwovet', 'Greedent', 'Wooloo', 'Dubwool']\n",
      "\n",
      "This combo: - GhostNormal - doesn't exist!\n",
      "\n",
      "BugSteel ['Forretress', 'Scizor', 'Mega Scizor', 'Wormadam Trash Cloak', 'Escavalier', 'Durant', 'Genesect']\n",
      "\n",
      "DarkPoison ['Alolan Grimer', 'Alolan Muk', 'Stunky', 'Skuntank', 'Drapion']\n",
      "\n",
      "GroundWater ['Wooper', 'Quagsire', 'Marshtomp', 'Swampert', 'Mega Swampert', 'Barboach', 'Whiscash', 'Gastrodon', 'Palpitoad', 'Seismitoad']\n",
      "\n",
      "Electric ['Pikachu', 'Partner Pikachu', 'Raichu', 'Voltorb', 'Electrode', 'Electabuzz', 'Jolteon', 'Pichu', 'Mareep', 'Flaaffy', 'Ampharos', 'Elekid', 'Raikou', 'Electrike', 'Manectric', 'Mega Manectric', 'Plusle', 'Minun', 'Shinx', 'Luxio', 'Luxray', 'Pachirisu', 'Electivire', 'Blitzle', 'Zebstrika', 'Tynamo', 'Eelektrik', 'Eelektross', 'Xurkitree', 'Zeraora', 'Yamper', 'Boltund', 'Pincurchin']\n",
      "\n",
      "Least defensive types: (with 7 weaknesses)\n",
      "DarkGrass ['Nuzleaf', 'Shiftry', 'Cacturne']\n",
      "\n",
      "DarkRock ['Tyranitar', 'Mega Tyranitar']\n",
      "\n",
      "GrassPsychic ['Exeggcute', 'Exeggutor', 'Celebi']\n",
      "\n",
      "PsychicRock ['Lunatone', 'Solrock']\n",
      "\n",
      "GrassIce ['Snover', 'Abomasnow', 'Mega Abomasnow']\n",
      "\n",
      "FightingRock ['Terrakion']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Most defensive types: (with {} weaknesses)\".format(sorted_defensive_types[0][0]))\n",
    "for combo in sorted_defensive_types[0][1]:\n",
    "    combo = reduce(lambda x,y:x+y, sorted(combo))\n",
    "    try:\n",
    "        print(combo, all_emperical_combos[combo])\n",
    "    except:\n",
    "        print(\"This combo: - {} - doesn't exist!\".format(combo))\n",
    "    print('')\n",
    "print(\"Least defensive types: (with {} weaknesses)\".format(sorted_defensive_types[-1][0]))\n",
    "for combo in sorted_defensive_types[-1][1]:\n",
    "    combo = reduce(lambda x,y:x+y, sorted(combo))\n",
    "    try:\n",
    "        print(combo, all_emperical_combos[combo])\n",
    "    except:\n",
    "        print(\"This combo: - {} - doesn't exist!\".format(combo))\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most defensive types: (with 3 invulnerabilities)\n",
      "GhostGround ['Galarian Yamask', 'Golett', 'Golurk', 'Sandygast', 'Palossand', 'Runerigus']\n",
      "\n",
      "DarkGhost ['Sableye', 'Mega Sableye', 'Spiritomb']\n",
      "\n",
      "This combo: - GhostNormal - doesn't exist!\n",
      "\n",
      "FairyGhost ['Mimikyu']\n",
      "\n",
      "GhostSteel ['Honedge', 'Doublade', 'Aegislash Blade Forme', 'Aegislash Shield Forme']\n",
      "\n",
      "FlyingGhost ['Drifloon', 'Drifblim', 'Oricorio Sensu Style']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Now, let's answer the same question based on the pokemon's invulnerabilities:\n",
    "# based on what is super effective against it\n",
    "super_effective_counts = {}\n",
    "for pokemon_typing in all_sorted_combos:\n",
    "    combo = typeCombinationSplitter(pokemon_typing)\n",
    "    vuln = typeComboVulnerabilities(combo)\n",
    "    no_effects = [val for val in vuln if val == 0]\n",
    "    n = len(no_effects)\n",
    "    if n in super_effective_counts:\n",
    "        super_effective_counts[n].append(combo)\n",
    "    else:\n",
    "        super_effective_counts[n] = [combo]\n",
    "        \n",
    "sorted_defensive_types = [(key, val) for key, val in super_effective_counts.items()]\n",
    "sorted_defensive_types.sort(key=lambda x:x[0], reverse=True)\n",
    "\n",
    "print(\"Most defensive types: (with {} invulnerabilities)\".format(sorted_defensive_types[0][0]))\n",
    "for combo in sorted_defensive_types[0][1]:\n",
    "    combo = reduce(lambda x,y:x+y, sorted(combo))\n",
    "    try:\n",
    "        print(combo, all_emperical_combos[combo])\n",
    "    except:\n",
    "        print(\"This combo: - {} - doesn't exist!\".format(combo))\n",
    "    print('')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that all of these typings include Ghost, since it is the only type with two vulnerabilites (Fighting and Normal). "
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}