example_fast_optimize.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A general overview and code of how the merging of the calculated points goes.\n",
    "\n",
    "For the two groupings we're merging, the first, varaibles with no number at the end, we have 3 parings of ids where we have the information of their combined cost and combined points. For the second group, variables that end in `2`, there are four groups of ids, costs, and points. We're working in deminsions here, so it's important to keep in mind that as long as the indicies of the values associated with the people are legal, then we're good.\n",
    "\n",
    "As a note, look and go through the `example_brisk_optimize` notebook first. It's a simlar calculations, but easier to understand than this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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>ids</th>\n",
       "      <th>sal</th>\n",
       "      <th>pts</th>\n",
       "      <th>pos</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[0, 4]</td>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[1, 5]</td>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[2, 6]</td>\n",
       "      <td>8</td>\n",
       "      <td>6</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[3, 7]</td>\n",
       "      <td>9</td>\n",
       "      <td>7</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[8, 13]</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>[9, 14]</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>[10, 15]</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>[11, 16]</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>[12, 17]</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        ids  sal  pts pos\n",
       "0    [0, 4]    5    3  PG\n",
       "1    [1, 5]    7    5  PG\n",
       "2    [2, 6]    8    6  PG\n",
       "3    [3, 7]    9    7  PG\n",
       "4   [8, 13]    2    2  SG\n",
       "5   [9, 14]    3    4  SG\n",
       "6  [10, 15]    5    6  SG\n",
       "7  [11, 16]    6    6  SG\n",
       "8  [12, 17]    8    7  SG"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import itertools\n",
    "import pandas as pd\n",
    "import ast #used for conversion of the id list pandas is reading\n",
    "df = pd.read_csv('data/example_data.csv', converters={0:lambda x: ast.literal_eval(x)})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>ids</th>\n",
       "      <th>sal</th>\n",
       "      <th>pts</th>\n",
       "      <th>pos</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[0, 4]</td>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[1, 5]</td>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[2, 6]</td>\n",
       "      <td>8</td>\n",
       "      <td>6</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[3, 7]</td>\n",
       "      <td>9</td>\n",
       "      <td>7</td>\n",
       "      <td>PG</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      ids  sal  pts pos\n",
       "0  [0, 4]    5    3  PG\n",
       "1  [1, 5]    7    5  PG\n",
       "2  [2, 6]    8    6  PG\n",
       "3  [3, 7]    9    7  PG"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pgdf = df[df.pos=='PG']\n",
    "pgdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>ids</th>\n",
       "      <th>sal</th>\n",
       "      <th>pts</th>\n",
       "      <th>pos</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[8, 13]</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>[9, 14]</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>[10, 15]</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>[11, 16]</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>[12, 17]</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        ids  sal  pts pos\n",
       "4   [8, 13]    2    2  SG\n",
       "5   [9, 14]    3    4  SG\n",
       "6  [10, 15]    5    6  SG\n",
       "7  [11, 16]    6    6  SG\n",
       "8  [12, 17]    8    7  SG"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgdf = df[df.pos=='SG']\n",
    "sgdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ids: [[0 4]\n",
      " [1 5]\n",
      " [2 6]\n",
      " [3 7]]\n",
      "Salaries: [5 7 8 9]\n",
      "Points: [3 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "pgids = np.array(pgdf.ids.tolist())\n",
    "pgsals = np.array(pgdf.sal.tolist())\n",
    "pgpts = np.array(pgdf.pts.tolist())\n",
    "print(\"Ids:\", pgids)\n",
    "print(\"Salaries:\", pgsals)\n",
    "print(\"Points:\", pgpts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SG Ids: [[ 8 13]\n",
      " [ 9 14]\n",
      " [10 15]\n",
      " [11 16]\n",
      " [12 17]]\n",
      "SG Salaries: [2 3 5 6 8]\n",
      "SG Points: [2 4 6 6 7]\n"
     ]
    }
   ],
   "source": [
    "sgids = np.array(sgdf.ids.tolist())\n",
    "sgsals = np.array(sgdf.sal.tolist())\n",
    "sgpts = np.array(sgdf.pts.tolist())\n",
    "print(\"SG Ids:\", sgids)\n",
    "print(\"SG Salaries:\", sgsals)\n",
    "print(\"SG Points:\", sgpts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8, 13],\n",
       "       [ 0,  4,  9, 14],\n",
       "       [ 0,  4, 10, 15],\n",
       "       [ 0,  4, 11, 16],\n",
       "       [ 0,  4, 12, 17],\n",
       "       [ 1,  5,  8, 13],\n",
       "       [ 1,  5,  9, 14],\n",
       "       [ 1,  5, 10, 15],\n",
       "       [ 1,  5, 11, 16],\n",
       "       [ 1,  5, 12, 17],\n",
       "       [ 2,  6,  8, 13],\n",
       "       [ 2,  6,  9, 14],\n",
       "       [ 2,  6, 10, 15],\n",
       "       [ 2,  6, 11, 16],\n",
       "       [ 2,  6, 12, 17],\n",
       "       [ 3,  7,  8, 13],\n",
       "       [ 3,  7,  9, 14],\n",
       "       [ 3,  7, 10, 15],\n",
       "       [ 3,  7, 11, 16],\n",
       "       [ 3,  7, 12, 17]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ids_comb = np.array([np.concatenate((x,y)) for x,y in list(itertools.product(pgids, sgids))])\n",
    "ids_comb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the array below has all the different ways we can combined those salary numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 2],\n",
       "       [5, 3],\n",
       "       [5, 5],\n",
       "       [5, 6],\n",
       "       [5, 8],\n",
       "       [7, 2],\n",
       "       [7, 3],\n",
       "       [7, 5],\n",
       "       [7, 6],\n",
       "       [7, 8],\n",
       "       [8, 2],\n",
       "       [8, 3],\n",
       "       [8, 5],\n",
       "       [8, 6],\n",
       "       [8, 8],\n",
       "       [9, 2],\n",
       "       [9, 3],\n",
       "       [9, 5],\n",
       "       [9, 6],\n",
       "       [9, 8]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sal_comb = np.array(list(itertools.product(pgsals, sgsals)))\n",
    "sal_comb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we can see that those values have been added together. Now we know the combined salaries of those groups of players"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  8, 10, 11, 13,  9, 10, 12, 13, 15, 10, 11, 13, 14, 16, 11, 12,\n",
       "       14, 15, 17])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sal_sum = sal_comb.sum(axis=1)\n",
    "sal_sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like above, were calculating the product of the `points` and `points2` variables. Key point is that `itertools.product` returns the values in the same order. If that wasn't the case, this fails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 2],\n",
       "       [3, 4],\n",
       "       [3, 6],\n",
       "       [3, 6],\n",
       "       [3, 7],\n",
       "       [5, 2],\n",
       "       [5, 4],\n",
       "       [5, 6],\n",
       "       [5, 6],\n",
       "       [5, 7],\n",
       "       [6, 2],\n",
       "       [6, 4],\n",
       "       [6, 6],\n",
       "       [6, 6],\n",
       "       [6, 7],\n",
       "       [7, 2],\n",
       "       [7, 4],\n",
       "       [7, 6],\n",
       "       [7, 6],\n",
       "       [7, 7]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_comb = np.array(list(itertools.product(pgpts, sgpts)))\n",
    "points_comb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  7,  9,  9, 10,  7,  9, 11, 11, 12,  8, 10, 12, 12, 13,  9, 11,\n",
       "       13, 13, 14])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_sum = points_comb.sum(axis=1)\n",
    "points_sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the third time, we're grouping the ids together in the same order. The concatenate makes the array have only two dimensions which is what we want for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9, 10, 11, 12])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_salaries = np.array([9,10,11,12])\n",
    "test_salaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we run the `broadcast_to`, we can see that with the following shape, each row is a test for each salary. Keep that in mind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,\n",
       "         9,  9,  9,  9],\n",
       "       [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n",
       "        10, 10, 10, 10],\n",
       "       [11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n",
       "        11, 11, 11, 11],\n",
       "       [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n",
       "        12, 12, 12, 12]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_salaries_full = np.broadcast_to(test_salaries, (sal_sum.size, test_salaries.size)).T\n",
    "test_salaries_full"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4,  8, 13],\n",
       "        [ 0,  4,  9, 14],\n",
       "        [ 0,  4, 10, 15],\n",
       "        [ 0,  4, 11, 16],\n",
       "        [ 0,  4, 12, 17],\n",
       "        [ 1,  5,  8, 13],\n",
       "        [ 1,  5,  9, 14],\n",
       "        [ 1,  5, 10, 15],\n",
       "        [ 1,  5, 11, 16],\n",
       "        [ 1,  5, 12, 17],\n",
       "        [ 2,  6,  8, 13],\n",
       "        [ 2,  6,  9, 14],\n",
       "        [ 2,  6, 10, 15],\n",
       "        [ 2,  6, 11, 16],\n",
       "        [ 2,  6, 12, 17],\n",
       "        [ 3,  7,  8, 13],\n",
       "        [ 3,  7,  9, 14],\n",
       "        [ 3,  7, 10, 15],\n",
       "        [ 3,  7, 11, 16],\n",
       "        [ 3,  7, 12, 17]],\n",
       "\n",
       "       [[ 0,  4,  8, 13],\n",
       "        [ 0,  4,  9, 14],\n",
       "        [ 0,  4, 10, 15],\n",
       "        [ 0,  4, 11, 16],\n",
       "        [ 0,  4, 12, 17],\n",
       "        [ 1,  5,  8, 13],\n",
       "        [ 1,  5,  9, 14],\n",
       "        [ 1,  5, 10, 15],\n",
       "        [ 1,  5, 11, 16],\n",
       "        [ 1,  5, 12, 17],\n",
       "        [ 2,  6,  8, 13],\n",
       "        [ 2,  6,  9, 14],\n",
       "        [ 2,  6, 10, 15],\n",
       "        [ 2,  6, 11, 16],\n",
       "        [ 2,  6, 12, 17],\n",
       "        [ 3,  7,  8, 13],\n",
       "        [ 3,  7,  9, 14],\n",
       "        [ 3,  7, 10, 15],\n",
       "        [ 3,  7, 11, 16],\n",
       "        [ 3,  7, 12, 17]],\n",
       "\n",
       "       [[ 0,  4,  8, 13],\n",
       "        [ 0,  4,  9, 14],\n",
       "        [ 0,  4, 10, 15],\n",
       "        [ 0,  4, 11, 16],\n",
       "        [ 0,  4, 12, 17],\n",
       "        [ 1,  5,  8, 13],\n",
       "        [ 1,  5,  9, 14],\n",
       "        [ 1,  5, 10, 15],\n",
       "        [ 1,  5, 11, 16],\n",
       "        [ 1,  5, 12, 17],\n",
       "        [ 2,  6,  8, 13],\n",
       "        [ 2,  6,  9, 14],\n",
       "        [ 2,  6, 10, 15],\n",
       "        [ 2,  6, 11, 16],\n",
       "        [ 2,  6, 12, 17],\n",
       "        [ 3,  7,  8, 13],\n",
       "        [ 3,  7,  9, 14],\n",
       "        [ 3,  7, 10, 15],\n",
       "        [ 3,  7, 11, 16],\n",
       "        [ 3,  7, 12, 17]],\n",
       "\n",
       "       [[ 0,  4,  8, 13],\n",
       "        [ 0,  4,  9, 14],\n",
       "        [ 0,  4, 10, 15],\n",
       "        [ 0,  4, 11, 16],\n",
       "        [ 0,  4, 12, 17],\n",
       "        [ 1,  5,  8, 13],\n",
       "        [ 1,  5,  9, 14],\n",
       "        [ 1,  5, 10, 15],\n",
       "        [ 1,  5, 11, 16],\n",
       "        [ 1,  5, 12, 17],\n",
       "        [ 2,  6,  8, 13],\n",
       "        [ 2,  6,  9, 14],\n",
       "        [ 2,  6, 10, 15],\n",
       "        [ 2,  6, 11, 16],\n",
       "        [ 2,  6, 12, 17],\n",
       "        [ 3,  7,  8, 13],\n",
       "        [ 3,  7,  9, 14],\n",
       "        [ 3,  7, 10, 15],\n",
       "        [ 3,  7, 11, 16],\n",
       "        [ 3,  7, 12, 17]]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ids_comb_full = np.broadcast_to(ids_comb, (test_salaries.size, points_sum.size, 4))\n",
    "ids_comb_full"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7,  8, 10, 11, 13,  9, 10, 12, 13, 15, 10, 11, 13, 14, 16, 11,\n",
       "        12, 14, 15, 17],\n",
       "       [ 7,  8, 10, 11, 13,  9, 10, 12, 13, 15, 10, 11, 13, 14, 16, 11,\n",
       "        12, 14, 15, 17],\n",
       "       [ 7,  8, 10, 11, 13,  9, 10, 12, 13, 15, 10, 11, 13, 14, 16, 11,\n",
       "        12, 14, 15, 17],\n",
       "       [ 7,  8, 10, 11, 13,  9, 10, 12, 13, 15, 10, 11, 13, 14, 16, 11,\n",
       "        12, 14, 15, 17]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sal_sum_full = np.broadcast_to(sal_sum,(test_salaries.size, sal_sum.size))\n",
    "sal_sum_full"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  7,  9,  9, 10,  7,  9, 11, 11, 12,  8, 10, 12, 12, 13,  9,\n",
       "        11, 13, 13, 14],\n",
       "       [ 5,  7,  9,  9, 10,  7,  9, 11, 11, 12,  8, 10, 12, 12, 13,  9,\n",
       "        11, 13, 13, 14],\n",
       "       [ 5,  7,  9,  9, 10,  7,  9, 11, 11, 12,  8, 10, 12, 12, 13,  9,\n",
       "        11, 13, 13, 14],\n",
       "       [ 5,  7,  9,  9, 10,  7,  9, 11, 11, 12,  8, 10, 12, 12, 13,  9,\n",
       "        11, 13, 13, 14]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_sum_full = np.broadcast_to(points_sum,(test_salaries.size, points_sum.size))\n",
    "points_sum_full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, note the shapes of `sal_sum_full`, `points_sum_full`, `test_salaries_full`, and `ids_comb_full`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sal_sum_full:      (4, 20)\n",
      "points_sum_full:    (4, 20)\n",
      "test_salaries_full: (4, 20)\n",
      "ids_comb_full:      (4, 20, 4)\n"
     ]
    }
   ],
   "source": [
    "print(\"sal_sum_full:     \", sal_sum_full.shape)\n",
    "print(\"points_sum_full:   \", points_sum_full.shape)\n",
    "print(\"test_salaries_full:\", test_salaries_full.shape)\n",
    "print(\"ids_comb_full:     \", ids_comb_full.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key work before was to get these deminsions to match up so we can do direct comparison. As an example, we can pick (x,y) coords as (2,4) and see that the information matches up. Remember, the reason that `ids_comb_full` has that 3rd dimension is because we're combining groups of 4 player ids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indexes:  [ 0  4 12 17]\n",
      "Salaries:  13\n",
      "Points:  10\n"
     ]
    }
   ],
   "source": [
    "x,y = 2,4\n",
    "print(\"Indexes: \", ids_comb_full[x][y])\n",
    "print(\"Salaries: \", sal_sum_full[x][y])\n",
    "print(\"Points: \", points_sum_full[x][y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True, False, False, False,  True, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False],\n",
       "       [ True,  True,  True, False, False,  True,  True, False, False,\n",
       "        False,  True, False, False, False, False, False, False, False,\n",
       "        False, False],\n",
       "       [ True,  True,  True,  True, False,  True,  True, False, False,\n",
       "        False,  True,  True, False, False, False,  True, False, False,\n",
       "        False, False],\n",
       "       [ True,  True,  True,  True, False,  True,  True,  True, False,\n",
       "        False,  True,  True, False, False, False,  True,  True, False,\n",
       "        False, False]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valids = sal_sum_full <= test_salaries_full\n",
    "valids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  7,  0,  0,  0,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "         0,  0,  0,  0],\n",
       "       [ 5,  7,  9,  0,  0,  7,  9,  0,  0,  0,  8,  0,  0,  0,  0,  0,\n",
       "         0,  0,  0,  0],\n",
       "       [ 5,  7,  9,  9,  0,  7,  9,  0,  0,  0,  8, 10,  0,  0,  0,  9,\n",
       "         0,  0,  0,  0],\n",
       "       [ 5,  7,  9,  9,  0,  7,  9, 11,  0,  0,  8, 10,  0,  0,  0,  9,\n",
       "        11,  0,  0,  0]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "possibilities = points_sum_full * valids\n",
    "possibilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2, 11,  7])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_inds = possibilities.argmax(axis=1)\n",
    "top_inds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_selectors = np.arange(test_salaries.size)\n",
    "row_selectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might be looking at this oddly, as to what the `top_inds` and `row_selectors` are for. This brings up an important point with numpy where the actual dimensions of the matricies that are being used isn't all important, as long as you know how to extract the information you're looking for. I could have reshaped these however I wanted as long as I used the same shape for all the matricies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9, 10, 11])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_points = points_sum_full[row_selectors, top_inds]\n",
    "max_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8, 10, 11, 12])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_sals = sal_sum_full[row_selectors, top_inds]\n",
    "max_sals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  9, 14],\n",
       "       [ 0,  4, 10, 15],\n",
       "       [ 2,  6,  9, 14],\n",
       "       [ 1,  5, 10, 15]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_inds = ids_comb_full[row_selectors, top_inds]\n",
    "max_inds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9, 10, 11, 12])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_salaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I included the test_salaries above as a reminder of which index in the array the test salary of 11 was.\n",
    "When you run the cell below, you'll see that those values match with what was calculated in the brisk solution notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top players: [ 2  6  9 14]\n",
      "Top points: 10\n",
      "Combined salaries: 11\n"
     ]
    }
   ],
   "source": [
    "print(\"Top players:\", max_inds[2]) #2, because that's where test_salaries is 11\n",
    "print(\"Top points:\", max_points[2])\n",
    "print(\"Combined salaries:\", max_sals[2])"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}