Python Essentials and Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework #2 - Python Essentials + NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Author - Jenil Kansara \n",
    "#### MS in Information Systems - MB11\n",
    "#### Robert H. Smith School of Business\n",
    "#### University of Maryland"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shuffle deck: [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13]\n"
     ]
    }
   ],
   "source": [
    "#a statement that will generate a list of values associated with a standard deck of playing cards. \n",
    "import random\n",
    "    \n",
    "#using comprehension syntex to create a shuffle\n",
    "deckGenerated=[x for x in range(1,14) for y in range(0,4)]\n",
    "print('The shuffle deck: ' + str(deckGenerated))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total value of the deck is: 364\n"
     ]
    }
   ],
   "source": [
    "#total value associated with a full deck of cards, which represents the maximum total for a game.\n",
    "print('The total value of the deck is: ' + str(sum(deckGenerated)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a function deal that will shuffle (randomize) and distribute the 52 playing cards evenly to two players (26 each) and return a tuple of each player's hand (as a list of values).\n",
    "import numpy as np\n",
    "\n",
    "deckPlayer1=()\n",
    "deckPlayer2=()\n",
    "\n",
    "def deal():\n",
    "    deck=[]\n",
    "    \n",
    "    deck=[x for x in range(1,14) for y in range(0,4)]\n",
    "    random.shuffle(deck)\n",
    "    \n",
    "    global deckPlayer1\n",
    "    global deckPlayer2\n",
    "    deckPlayer1 = tuple(deck[:26])\n",
    "    deckPlayer2 = tuple(deck[26:])\n",
    "    return deckPlayer1, deckPlayer2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 Deck: (5, 9, 8, 13, 3, 7, 2, 5, 13, 9, 10, 9, 12, 7, 8, 3, 10, 1, 1, 8, 5, 2, 13, 11, 2, 1)\n",
      "Total nuber of cards of Player 1: 26\n",
      "Total value of Hand for PLayer 1: 177\n",
      "Player 2 Deck: (5, 12, 4, 11, 7, 2, 11, 10, 4, 3, 12, 9, 12, 6, 13, 8, 10, 7, 11, 6, 6, 4, 3, 4, 6, 1)\n",
      "Total number of cards of Player 2: 26\n",
      "Total value of Hand for PLayer 2: 187\n"
     ]
    }
   ],
   "source": [
    "#Deal a hand to two players and display (print) each player's hand. \n",
    "deal()\n",
    "\n",
    "#Print each player's number of cards and the total value of the hand.\n",
    "print('Player 1 Deck: ' + str(deckPlayer1))\n",
    "print('Total nuber of cards of Player 1: ' + str(len(deckPlayer1)))\n",
    "print('Total value of Hand for PLayer 1: ' + str(sum(deckPlayer1)))\n",
    "print('Player 2 Deck: ' + str(deckPlayer2))\n",
    "print('Total number of cards of Player 2: ' + str(len(deckPlayer2)))\n",
    "print('Total value of Hand for PLayer 2: ' + str(sum(deckPlayer2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Steps of Additional War"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Shuffle deck\n",
    "2. Deal half of deck to each player\n",
    "3. Each player plays two cards on each round.\n",
    "4. On each round, the value of two cards are summed up for each player, and the player with the highest value wins and puts the four cards in their own discard pile. \n",
    "5. If there is a tie, additional rounds will be played until a player wins the game. The winner takes all the cards played since the first(tie) round.\n",
    "6. If the player runs out of cards in the middle of the tiebreaker round, each player's respective cards are returned to them for the final score.\n",
    "7. Game terminates after a maximum of 13 rounds (occurs when there are no ties) and the deck is exhausted.\n",
    "8. The player with the highest total card points (in their discard pile) wins the game."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setting up initial values\n",
    "i=0\n",
    "discardPile1=[]\n",
    "discardPile2=[]\n",
    "tiebuffer1=[]\n",
    "tiebuffer2=[] \n",
    "tieSignal=0\n",
    "\n",
    "#function play that will simulate a single game of Addition War between two players.\n",
    "def play():\n",
    "    \n",
    "    global i, tieSignal,deckPlayer1, deckPlayer2, tiebuffer1, tiebuffer2\n",
    "    deckPlayer1,deckPlayer2=deal()\n",
    "    if (tieSignal==1 & i==13):\n",
    "        discardPile1.extend(tiebuffer1)\n",
    "        discardPile2.extend(tiebuffer2)\n",
    "        \n",
    "    while i<14:\n",
    "        if deckPlayer1[i]+deckPlayer1[i+1]>deckPlayer2[i]+deckPlayer2[i+1]:\n",
    "            tieSignal=0\n",
    "            discardPile1.extend(tiebuffer1)\n",
    "            discardPile1.extend(tiebuffer2)\n",
    "            tiebuffer1=[]\n",
    "            tiebuffer2=[]\n",
    "            discardPile1.extend([deckPlayer1[i],deckPlayer1[i+1],deckPlayer2[i],deckPlayer2[i+1]])\n",
    "            i=i+2\n",
    "        elif deckPlayer1[i]+deckPlayer1[i+1]<deckPlayer2[i]+deckPlayer2[i+1]:\n",
    "            tieSignal=0\n",
    "            discardPile2.extend(tiebuffer1)\n",
    "            discardPile2.extend(tiebuffer2)\n",
    "            tiebuffer1=[]\n",
    "            tiebuffer2=[]\n",
    "            discardPile2.extend([deckPlayer1[i],deckPlayer1[i+1],deckPlayer2[i],deckPlayer2[i+1]])\n",
    "            i=i+2\n",
    "        else:\n",
    "            tieSignal=1\n",
    "            tiebuffer1.extend([deckPlayer1[i],deckPlayer1[i+1]])\n",
    "            tiebuffer2.extend([deckPlayer2[i],deckPlayer2[i+1]])\n",
    "            i=i+2\n",
    "            play()\n",
    "            \n",
    "    if i>=14:   \n",
    "        if sum(discardPile1)>sum(discardPile2):\n",
    "            winner='Player 1'\n",
    "        elif sum(discardPile1)<sum(discardPile2):\n",
    "            winner='Player 2'\n",
    "        else:\n",
    "            winner='Tie'\n",
    "            \n",
    "        return(winner, sum(discardPile1), sum(discardPile2))        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The winner is Player 1\n",
      "Card Total of Player 1 is 144\n",
      "Card Total of Player 2 is 62\n"
     ]
    }
   ],
   "source": [
    "#returning the winner of the game and the card totals for the winner and loser. Printing the result.\n",
    "winner,score1,score2=play()\n",
    "print('The winner is ' + str(winner))\n",
    "\n",
    "if(winner == 'Player 1'):\n",
    "    print('Card Total of Player 1 is ' + str(score1))\n",
    "    \n",
    "    print('Card Total of Player 2 is ' + str(score2)) \n",
    "elif(winner == 'Player 2'):\n",
    "    print('Card Total of Player 2 is ' + str(score2)) \n",
    "    print('Card Total of Player 1 is ' + str(score1))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of Winner Scores: 126.57894736842105\n",
      "Mean of Loser Scores: 65.6842105263158\n",
      "Stdev of Winner Scores: 23.380864396865192\n",
      "Stdev of Loser Scores: 21.55055899037851\n",
      "Min of Winner Scores: 90\n",
      "Max of Winner Scores: 181\n",
      "Min of Loser Scores: 25\n",
      "Max of Loser Scores: 94\n"
     ]
    }
   ],
   "source": [
    "#Defining function play1 for simulation\n",
    "def play1():\n",
    "    \n",
    "    global i, tieSignal,deckPlayer1, deckPlayer2, tiebuffer1, tiebuffer2\n",
    "    deckPlayer1,deckPlayer2=deal()\n",
    "    initialTotal1=sum(deckPlayer1)\n",
    "    initialTotal2=sum(deckPlayer2)\n",
    "    if (tieSignal==1 & i==13):\n",
    "        discardPile1.extend(tiebuffer1)\n",
    "        discardPile2.extend(tiebuffer2)\n",
    "        \n",
    "    while i<14:\n",
    "        if deckPlayer1[i]+deckPlayer1[i+1]>deckPlayer2[i]+deckPlayer2[i+1]:\n",
    "            tieSignal=0\n",
    "            discardPile1.extend(tiebuffer1)\n",
    "            discardPile1.extend(tiebuffer2)\n",
    "            tiebuffer1=[]\n",
    "            tiebuffer2=[]\n",
    "            discardPile1.extend([deckPlayer1[i],deckPlayer1[i+1],deckPlayer2[i],deckPlayer2[i+1]])\n",
    "            i=i+2\n",
    "        elif deckPlayer1[i]+deckPlayer1[i+1]<deckPlayer2[i]+deckPlayer2[i+1]:\n",
    "            tieSignal=0\n",
    "            discardPile2.extend(tiebuffer1)\n",
    "            discardPile2.extend(tiebuffer2)\n",
    "            tiebuffer1=[]\n",
    "            tiebuffer2=[]\n",
    "            discardPile2.extend([deckPlayer1[i],deckPlayer1[i+1],deckPlayer2[i],deckPlayer2[i+1]])\n",
    "            i=i+2\n",
    "        else:\n",
    "            tieSignal=1\n",
    "            tiebuffer1.extend([deckPlayer1[i],deckPlayer1[i+1]])\n",
    "            tiebuffer2.extend([deckPlayer2[i],deckPlayer2[i+1]])\n",
    "            i=i+2\n",
    "            play1()\n",
    "            \n",
    "    if i>=14:   \n",
    "        if sum(discardPile1)>sum(discardPile2):\n",
    "            winner='Player 1'\n",
    "        elif sum(discardPile1)<sum(discardPile2):\n",
    "            winner='Player 2'\n",
    "        else:\n",
    "            winner='Tie'\n",
    "            \n",
    "        return(winner, sum(discardPile1), sum(discardPile2),initialTotal1,initialTotal2)\n",
    "\n",
    "#setting up initial values\n",
    "winnerScoreList=[]\n",
    "loserScoreList=[]\n",
    "scoresPlayer1List=[]\n",
    "scoresPlayer2List=[]\n",
    "initialTotal1List=[]\n",
    "initialTotal2List=[]\n",
    "winnerInitialTotalList=[]\n",
    "loserInitialTotalList=[]\n",
    "\n",
    "#running the simulation\n",
    "for val in range(0,20):\n",
    "    i=0\n",
    "    discardPile1=[]\n",
    "    discardPile2=[]\n",
    "    tiebuffer1=[]\n",
    "    tiebuffer2=[] \n",
    "    tieSignal=0\n",
    "\n",
    "    winner,scoreP1,scoreP2,initialTotal1, initialTotal2=play1()\n",
    "    scoresPlayer1List.append(scoreP1)\n",
    "    scoresPlayer2List.append(scoreP2)\n",
    "    initialTotal1List.append(initialTotal1)\n",
    "    initialTotal2List.append(initialTotal2)\n",
    "    #print(scoreP1, scoreP2)\n",
    "    #print(initialTotal1,initialTotal2)\n",
    "    \n",
    "    if scoreP1>scoreP2:\n",
    "        winnerScoreList.append(scoreP1)\n",
    "        winnerInitialTotalList.append(initialTotal1)\n",
    "        loserScoreList.append(scoreP2)\n",
    "        loserInitialTotalList.append(initialTotal2)\n",
    "        \n",
    "    elif scoreP1<scoreP2:\n",
    "        loserScoreList.append(scoreP1)\n",
    "        loserInitialTotalList.append(initialTotal1)\n",
    "        winnerScoreList.append(scoreP2)\n",
    "        winnerInitialTotalList.append(initialTotal2)\n",
    "\n",
    "npWinnerScoreList=np.array(winnerScoreList)\n",
    "npLoserScoreList=np.array(loserScoreList)\n",
    "\n",
    "#produce descriptive statistics for each scenario\n",
    "print('Mean of Winner Scores: ' + str(np.mean(npWinnerScoreList)))\n",
    "print('Mean of Loser Scores: ' + str(np.mean(npLoserScoreList)))\n",
    "\n",
    "print('Stdev of Winner Scores: ' + str(np.std(npWinnerScoreList)))\n",
    "print('Stdev of Loser Scores: ' + str(np.std(npLoserScoreList)))\n",
    "\n",
    "print('Min of Winner Scores: ' + str(min(npWinnerScoreList)))\n",
    "print('Max of Winner Scores: ' + str(max(npWinnerScoreList)))\n",
    "print('Min of Loser Scores: ' + str(min(npLoserScoreList)))\n",
    "print('Max of Loser Scores: ' + str(max(npLoserScoreList)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can observe intuitively that the mean of the total winner scores is higher than the mean of total loser scores. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of games that resulted in a winner that had a lower initial total than their opponent: 35.0%\n",
      "Lowest initial total to win a game: 163\n",
      "Highest initial total to lose a game: 201\n"
     ]
    }
   ],
   "source": [
    "#proportion of games resulted in a winner that had a lower initial total than their opponent\n",
    "#Also finding lowest initial total to win a game and the highest initial total to lose a game\n",
    "\n",
    "proportionMeasure=0\n",
    "lowestInitialTotal=1000\n",
    "highestInitialTotal=0\n",
    "\n",
    "for i in range(0,20):\n",
    "    \n",
    "    if(scoresPlayer1List[i]>scoresPlayer2List[i]):\n",
    "        \n",
    "        if(initialTotal1List[i]<initialTotal2List[i]):\n",
    "            proportionMeasure+=1\n",
    "            \n",
    "            if(initialTotal1List[i]<lowestInitialTotal):\n",
    "                lowestInitialTotal=initialTotal1List[i]\n",
    "            if(initialTotal2List[i]>highestInitialTotal):\n",
    "                highestInitialTotal=initialTotal2List[i]\n",
    "                \n",
    "    if(scoresPlayer1List[i]<scoresPlayer2List[i]):\n",
    "        \n",
    "        if(initialTotal1List[i]>initialTotal2List[i]):\n",
    "            proportionMeasure+=1\n",
    "            \n",
    "            if(initialTotal2List[i]<lowestInitialTotal):\n",
    "                lowestInitialTotal=initialTotal2List[i]\n",
    "            if(initialTotal1List[i]>highestInitialTotal):\n",
    "                highestInitialTotal=initialTotal1List[i]\n",
    "                \n",
    "print('Proportion of games that resulted in a winner that had a lower initial total than their opponent: '+ str(proportionMeasure/20*100) + '%') \n",
    "\n",
    "print('Lowest initial total to win a game: ' + str(lowestInitialTotal))\n",
    "print('Highest initial total to lose a game: ' + str(highestInitialTotal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation between winner final scores and initial scores is -0.12825694718087785\n",
      "Correlation between loser final scores and initial scores is -0.16598979124952723\n"
     ]
    }
   ],
   "source": [
    "# Calculate the (linear) correlation between the initial and final totals for winners vs. losers\n",
    "\n",
    "npWinnerInitialTotalList = np.array(winnerInitialTotalList)\n",
    "npLoserInitialTotalList = np.array(loserInitialTotalList)\n",
    "\n",
    "print('Correlation between winner final scores and initial scores is ' + str(np.corrcoef(npWinnerScoreList, npWinnerInitialTotalList)[0][1]))\n",
    "print('Correlation between loser final scores and initial scores is ' + str(np.corrcoef(npLoserScoreList, npLoserInitialTotalList)[0][1]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the cards are randomly distributed, hence, the correlation can vary depending on the hands dealt in a game. \n",
    "\n",
    "The correlation varies on every simulation. On some trials, the correlation between loser final and initial scores also become negative. It shows that the initial scores is not a sufficient measure to predict which player will win.\n",
    "\n",
    "In addition, the correlation for both the cases are very similar. It shows both winning and losing case depend on the initial values equally."
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}