From 1b0db49f8d4131294623073f77a43b29badadebf Mon Sep 17 00:00:00 2001 From: Zack Cooper Date: Wed, 28 Jan 2015 13:10:07 -0500 Subject: [PATCH 1/2] initial creation of files --- requirements.txt | 4 ++++ some-pig.py | 0 2 files changed, 4 insertions(+) create mode 100644 requirements.txt create mode 100644 some-pig.py diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..22a297f --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +statistics +matplotlib +seaborn +ipython[all] diff --git a/some-pig.py b/some-pig.py new file mode 100644 index 0000000..e69de29 From 41726d412f9ad480780cbba4a75fb8021e049743 Mon Sep 17 00:00:00 2001 From: Zack Cooper Date: Wed, 28 Jan 2015 21:26:32 -0500 Subject: [PATCH 2/2] Finished project --- some_pig.ipynb | 291 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 291 insertions(+) create mode 100644 some_pig.ipynb diff --git a/some_pig.ipynb b/some_pig.ipynb new file mode 100644 index 0000000..b311221 --- /dev/null +++ b/some_pig.ipynb @@ -0,0 +1,291 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:29800ab04f0756c778f5ea64089670c104e24497395bb3cf9c00216489bd4fc9" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import random\n", + "import matplotlib.pyplot as ply\n", + "import statistics as st\n", + "\n", + "\n", + "class Player:\n", + " \"\"\"\n", + " Contains the score\n", + " Contains the count of rolls\n", + " Decides to to roll or hold\n", + " Perform function of holding\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " self.turn_score = 0\n", + " self.turn_count = 0\n", + " self.total_score = 0\n", + " self.roll_chance = .3\n", + "\n", + " def user_choice(self, roll_count=0):\n", + "\n", + " if roll_count == 0:\n", + " return 'roll'\n", + "\n", + " else:\n", + " if random.random() < self.roll_chance:\n", + " return 'roll'\n", + " else:\n", + " return 'hold'\n", + "\n", + " def roll_dice(self, dice_sides = 6):\n", + " return random.randint(1, dice_sides)\n", + "\n", + " def reset_player(self, player):\n", + " return player.__init__()\n", + "\n", + "\n", + "class Simulation:\n", + " \"\"\"\n", + " Accounts for a 1 being rolled\n", + " runs player's options\n", + " end after 7 rounds\n", + " shows count\n", + " keeps track of results\n", + " \"\"\"\n", + "\n", + " def __init__(self, action_or_roll = []):\n", + " self.action_or_roll = []\n", + "\n", + " def in_turn_scoring(self, roll, player):\n", + " if roll == 1:\n", + " return 'no points'\n", + " else:\n", + " player.turn_score += roll\n", + "\n", + " def in_turn_gameplay(self, player):\n", + "\n", + " player.turn_score = 0\n", + " roll_count = 0\n", + "\n", + " while True:\n", + " user_input = player.user_choice(roll_count)\n", + "\n", + " if user_input == 'hold':\n", + " self.action_or_roll.append(user_input)\n", + " break\n", + " else:\n", + " dice_roll = player.roll_dice()\n", + " self.action_or_roll.append(dice_roll)\n", + "\n", + " if self.in_turn_scoring(dice_roll, player) == 'no points':\n", + " player.turn_score = 0\n", + " break\n", + " roll_count += 1\n", + "\n", + " player.total_score += player.turn_score\n", + " return self.action_or_roll\n", + "\n", + "\n", + " def gameplay(self, player):\n", + " player.reset_player(player)\n", + "\n", + " while player.turn_count < 7:\n", + " self.in_turn_gameplay(player)\n", + " player.turn_count += 1\n", + "\n", + " return player.total_score\n", + "\n", + "\n", + "class RiskyPlayer(Player):\n", + "\n", + " def __init__(self):\n", + " self.turn_score = 0\n", + " self.turn_count = 0\n", + " self.total_score = 0\n", + " self.roll_chance = .9\n", + "\n", + "class MidRiskPlayer(Player):\n", + "\n", + " def __init__(self):\n", + " self.turn_score = 0\n", + " self.turn_count = 0\n", + " self.total_score = 0\n", + " self.roll_chance = .6\n", + "\n", + "class MinimumTwenty(Player):\n", + "\n", + " def user_choice(self, roll_count=0):\n", + " if roll_count == 0:\n", + " return 'roll'\n", + " else:\n", + " if self.turn_score < 19:\n", + " return 'roll'\n", + " else:\n", + " return 'hold'\n", + "\n", + "\n", + "def multiple_runs(player, num = 1000):\n", + " return [Simulation().gameplay(player) for _ in range(num)]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 100 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "standard_roll_player = Player()\n", + "standard_roll_sim = Simulation()\n", + "print('standard ', standard_roll_sim.gameplay(standard_roll_player))\n", + "\n", + "mid_roll_player = MidRiskPlayer()\n", + "standard_roll_sim = Simulation()\n", + "print('Mid Risk ', standard_roll_sim.gameplay(mid_roll_player))\n", + "\n", + "risky_player = RiskyPlayer()\n", + "standard_roll_sim = Simulation()\n", + "print('risky ', standard_roll_sim.gameplay(risky_player))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "standard 27\n", + "Mid Risk 42\n", + "risky 0\n" + ] + } + ], + "prompt_number": 96 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "standard_list = multiple_runs(standard_roll_player, num=10000)\n", + "mid_list = multiple_runs(mid_roll_player, num=10000)\n", + "risky_list = multiple_runs(risky_player, num=10000)\n", + "\n", + "strd_mean = st.mean(standard_list)\n", + "mid_mean = st.mean(mid_list)\n", + "risky_mean = st.mean(risky_list)\n", + "\n", + "strd_dev = st.pstdev(standard_list)\n", + "mid_dev = st.pstdev(mid_list)\n", + "risky_dev = st.pstdev(risky_list)\n", + "\n", + "print('standard ', strd_mean, strd_dev)\n", + "print('middle ', mid_mean, mid_dev)\n", + "print('risky ', risky_mean, risky_dev)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "standard 28.9678 9.47386738138127\n", + "middle 37.3702 16.315390033952607\n", + "risky 37.2681 29.24368346139043\n" + ] + } + ], + "prompt_number": 97 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "nineteen_player = MinimumTwenty()\n", + "\n", + "nineteen_list = multiple_runs(nineteen_player, num=100000)\n", + "nineteen_mean = st.mean(nineteen_list)\n", + "nineteen_dev = st.pstdev(nineteen_list)\n", + "\n", + "\n", + "print('nineteen ', nineteen_mean, nineteen_dev)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "nineteen 56.85432 26.760708461055362\n" + ] + } + ], + "prompt_number": 103 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ply.boxplot([standard_list, mid_list, risky_list, nineteen_list])\n", + "ply.xticks(range(1, 5), [\"30%\", \"60%\", \"90%\", \"19 per turn\"])\n", + "ply.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEACAYAAACuzv3DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text": [ + "" + ] + } + ], + "prompt_number": 105 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All of my strategies followed a central hypothesis - the amount a user rolled vs held impacted their overall chance of winning. So, the first strategy said that 30% of the time, we'll roll vs hold. The second said 60% of the time we'll roll instead of hold. The last said we'll roll 90% of the time and hold just 10% of the time.\n", + "\n", + "The mean for all 3 strategies over 100,000 rolls was relatively varied.\n", + "30% = 28.9\n", + "60% = 37.6\n", + "90% = 37.8\n", + "\n", + "As expected, it is better to roll than hold the majority of the time. Surprisingly though, it's best to roll 9 of 10 times. That I didn't expect. If you look at the boxplot though, you'll see that the results are all over the place. There are a lot of outliers, and as expected, the standard deviation is much higher than the others at 29.85.\n", + "\n", + "After this was completed, I added a 4th strategy. This strategy only looked at how many points the user had each turn before deciding whether or not to roll or hold. If the user has less than 19 points, then they will always roll. Once they hit >19, they must hold. This performed substantially better than the other 2 groups with a mean of 56.8." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 109 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file