Repository: MJeremy2017/reinforcement-learning-implementation Branch: master Commit: 0fecb49bc674 Files: 49 Total size: 2.7 MB Directory structure: gitextract_zmbv1ji4/ ├── .gitignore ├── AccessControl/ │ ├── ServerAccess.ipynb │ ├── ServerAccess.py │ └── TileCoding.py ├── BairdExample/ │ ├── BairdCounterExample.ipynb │ └── BairdCounterExample.py ├── BlackJack/ │ ├── blackjack_mc.ipynb │ ├── blackjack_mc.py │ ├── blackjack_solution.ipynb │ ├── blackjack_solution.py │ ├── blackjack_test.ipynb │ └── policy ├── CliffWalking/ │ ├── cliffWalking.ipynb │ └── cliffWalking.py ├── DynaMaze/ │ ├── DynaMaze.ipynb │ ├── DynaMaze.py │ ├── DynaQ+.py │ ├── PrioritySweeping.ipynb │ └── PrioritySweeping.py ├── GridWorld/ │ ├── GridBoard-Q.ipynb │ ├── GridWorld.ipynb │ ├── gridWorld.py │ └── gridWorld_Q.py ├── LICENSE ├── MountainCar/ │ ├── MountainCar.ipynb │ ├── MountainCar.py │ └── TileCoding.py ├── MountainCar(Lambda)/ │ ├── MountainCar(Lambda).ipynb │ ├── MountainCar.py │ └── TileCoding.py ├── Multi-ArmBandit/ │ ├── Bandit.ipynb │ └── bandit.py ├── README.md ├── RandomWalk/ │ ├── RandomWalk(n-step).ipynb │ └── RandomWalk(n-step).py ├── RandomWalk(General)/ │ ├── RandomWalk.ipynb │ └── RandomWalk.py ├── RandomWalk(Lambda)/ │ ├── TD(Lambda).ipynb │ └── TD_Lambda.py ├── ShortCorridor/ │ ├── ShortCorridor.ipynb │ └── ShortCorridor.py ├── TicTacToe/ │ ├── policy_p1 │ ├── policy_p2 │ ├── tic-tac-toe.ipynb │ └── ticTacToe.py ├── TileCoding/ │ ├── TileCoding.ipynb │ └── tile_coding.py └── WindyGridWorld/ ├── Windy_GW.ipynb └── windyGridWorld.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ .idea/* .idea */.ipynb_checkpoints .ipynb_checkpoints */__pycache__ ================================================ FILE: AccessControl/ServerAccess.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Access-Control Queuing Task\n", "---\n", "This is a decision task involving access control to a set of 10 servers. Customers of four different priorities arrive at a single queue. If given access to a server, the customers pay a reward of `1, 2, 4, or 8` to the server, depending on their priority, with higher priority customers paying more. In each time step, the customer at the head of the queue is either accepted (assigned to one of the servers) or rejected (removed from the queue, with a reward of zero). In either case, on the next time step the next customer in the queue is considered. The queue never empties, and the priorities of the customers in the queue are equally randomly distributed. Of course a customer cannot be served if there is no free server; the customer is always rejected in this case. Each busy server becomes free with probability `p = 0.06` on each time step.\n", "\n", "The task is to decide on each step whether to accept or reject the next customer, on the basis of his priority and the number of free servers, so as `to maximize long-term reward without discounting`.\n", "\n", "- State(num_servers, priority)\n", "- Action(1, 0)\n", "- Reward(1, 2, 4, 8)\n", "---\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from TileCoding import *" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "ACTIONS = [0, 1]" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "class ValueFunction:\n", "\n", " def __init__(self, alpha=0.01, numOfTilings=8, maxSize=2048):\n", " self.maxSize = maxSize\n", " self.numOfTilings = numOfTilings\n", "\n", " # divide step size equally to each tiling\n", " self.alpha = alpha / numOfTilings # learning rate for each tile\n", "\n", " self.hashTable = IHT(maxSize)\n", "\n", " # weight for each tile\n", " self.weights = np.zeros(maxSize)\n", "\n", " # position and velocity needs scaling to satisfy the tile software\n", " self.serverScale = self.numOfTilings / 10.0 # 10 servers\n", " self.priorityScale = self.numOfTilings / 3.0 # 4 kinds of priorities\n", "\n", " # get indices of active tiles for given state and action\n", " def getActiveTiles(self, n_server, priority, action):\n", " activeTiles = tiles(self.hashTable, self.numOfTilings,\n", " [self.serverScale * n_server, self.priorityScale * priority],\n", " [action])\n", " return activeTiles\n", "\n", " # estimate the value of given state and action\n", " def value(self, state, action):\n", " n_server, priority = state\n", " activeTiles = self.getActiveTiles(n_server, priority, action)\n", " return np.sum(self.weights[activeTiles]) \n", " \n", " # learn with given state, action and target\n", " def update(self, state, action, delta):\n", " n_server, priority = state\n", " activeTiles = self.getActiveTiles(n_server, priority, action)\n", " \n", " delta *= self.alpha\n", " for activeTile in activeTiles:\n", " self.weights[activeTile] += delta\n", " \n", " def stateValue(self, state):\n", " if state[0] == 0:\n", " # no server available\n", " return self.value(state, 0)\n", " values = [self.value(state, a) for a in ACTIONS]\n", " return max(values)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "code_folding": [ 0 ] }, "outputs": [], "source": [ "class ServerAcess:\n", " def __init__(self, exp_rate=0.3, beta=0.01):\n", " self.n_server = 10\n", " self.free_prob = 0.06\n", " self.priorities = range(4)\n", " self.actions = ACTIONS # 0: reject; 1: accept\n", " self.state = (0, 0) # (num_servers, priority)\n", " \n", " self.exp_rate = exp_rate\n", " self.beta = beta\n", " \n", " def numFreeServers(self):\n", " n = 0\n", " n_free_server = self.state[0]\n", " n_busy_server = self.n_server - n_free_server\n", " for _ in range(n_busy_server):\n", " if np.random.uniform(0, 1) <= 0.06:\n", " n += 1\n", " n_free_server += n\n", " self.state = (n_free_server, self.state[1])\n", " return n_free_server\n", " \n", " def chooseAction(self, valueFunc):\n", " n_free_server = self.numFreeServers()\n", " if n_free_server == 0:\n", " return 0\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " values = {}\n", " for a in self.actions:\n", " v = valueFunc.value(self.state, a)\n", " values[a] = v\n", " action = np.random.choice([k for k, v in values.items() if v == max(values.values())])\n", " return action\n", " \n", " def nxtState(self, action):\n", " if action == 1:\n", " n_free_server = self.state[0] - 1\n", " else:\n", " n_free_server = self.state[0]\n", " priority = np.random.choice(self.priorities)\n", " self.state = (n_free_server, priority)\n", " return self.state\n", " \n", " def giveReward(self, action):\n", " # recieve a reward by taking the action\n", " if action == 1:\n", " priority = self.state[1]\n", " return np.power(2, priority)\n", " return 0\n", " \n", " def run(self, valueFunc, steps=1000, inner_steps=100, debug=False):\n", " # updating average reward estimation along the way\n", " avg_reward = 0\n", " self.state = (10, np.random.choice(self.priorities))\n", " cur_state = self.state\n", " cur_action = self.chooseAction(valueFunc) # n free server is also updated\n", " \n", " total_reward = 0\n", " for i in range(1, steps+1):\n", " reward = self.giveReward(cur_action)\n", " new_state = self.nxtState(cur_action)\n", " new_action = self.chooseAction(valueFunc)\n", " \n", " total_reward += reward\n", " if debug:\n", " print(\"state {} action {} reward {}\".format(cur_state, cur_action, reward))\n", " if i % inner_steps == 0:\n", " print(\"step {} -> avg reward {} total reward {}\".format(i, avg_reward, total_reward))\n", " \n", "# target = reward - avg_reward + valueFunc.value(new_state, new_action)\n", " delta = reward - avg_reward + valueFunc.value(new_state, new_action) - valueFunc.value(cur_state, cur_action)\n", " avg_reward += self.beta*delta\n", " valueFunc.update(cur_state, cur_action, delta)\n", " \n", " cur_state = new_state\n", " cur_action = new_action" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "step 5000 -> avg reward 2.712112568654349 total reward 11381\n", "step 10000 -> avg reward 1.6655055071811895 total reward 22506\n", "step 15000 -> avg reward 2.1391137499926955 total reward 33799\n", "step 20000 -> avg reward 2.5933342886336863 total reward 45665\n", "step 25000 -> avg reward 1.9671566131725278 total reward 57326\n", "step 30000 -> avg reward 1.632133694866927 total reward 68798\n", "step 35000 -> avg reward 2.390062004123471 total reward 80434\n", "step 40000 -> avg reward 2.3949169842321223 total reward 91930\n", "step 45000 -> avg reward 2.151052488612957 total reward 103797\n", "step 50000 -> avg reward 2.032857873620931 total reward 115250\n" ] } ], "source": [ "sa = ServerAcess(exp_rate=0.1)\n", "vf = ValueFunction()\n", "sa.run(vf, steps=50000, inner_steps=5000, debug=False)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "for prioriy in range(4):\n", " n_servers = []\n", " values = []\n", " for n_server in range(11):\n", " value = vf.stateValue((n_server, prioriy))\n", " n_servers.append(n_server)\n", " values.append(value)\n", " plt.plot(n_servers, values, label=\"priority {}\".format(np.power(2, prioriy)))\n", "\n", "plt.xlabel(\"Number of Free Servers\", size=14)\n", "plt.ylabel(\"State Value\", size=14)\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "l = []\n", "for prioriy in range(4):\n", " for n_server in range(11):\n", " action = \"reject\" if vf.value((n_server, prioriy), 0) >= vf.value((n_server, prioriy), 1) else \"accept\"\n", " l.append([prioriy, n_server, action])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Self Tile Coding" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "\n", "def create_tiling(feat_range, bins, offset):\n", " \"\"\"\n", " Create 1 tiling spec of 1 dimension(feature)\n", " feat_range: feature range; example: [-1, 1]\n", " bins: number of bins for that feature; example: 10\n", " offset: offset for that feature; example: 0.2\n", " \"\"\"\n", " \n", " return np.linspace(feat_range[0], feat_range[1], bins+1)[1:-1] + offset\n", "\n", "\n", "def create_tilings(feature_ranges, number_tilings, bins, offsets):\n", " \"\"\"\n", " feature_ranges: range of each feature; example: x: [-1, 1], y: [2, 5] -> [[-1, 1], [2, 5]]\n", " number_tilings: number of tilings; example: 3 tilings\n", " bins: bin size for each tiling and dimension; example: [[10, 10], [10, 10], [10, 10]]: 3 tilings * [x_bin, y_bin]\n", " offsets: offset for each tiling and dimension; example: [[0, 0], [0.2, 1], [0.4, 1.5]]: 3 tilings * [x_offset, y_offset]\n", " \"\"\"\n", " tilings = []\n", " # for each tiling\n", " for tile_i in range(number_tilings):\n", " tiling_bin = bins[tile_i]\n", " tiling_offset = offsets[tile_i]\n", " \n", " tiling = []\n", " # for each feature dimension\n", " for feat_i in range(len(feature_ranges)):\n", " feat_range = feature_ranges[feat_i]\n", " # tiling for 1 feature\n", " feat_tiling = create_tiling(feat_range, tiling_bin[feat_i], tiling_offset[feat_i])\n", " tiling.append(feat_tiling)\n", " tilings.append(tiling)\n", " return np.array(tilings)\n", "\n", "\n", "def get_tile_coding(feature, tilings):\n", " \"\"\"\n", " feature: sample feature with multiple dimensions that need to be encoded; example: [0.1, 2.5], [-0.3, 2.0]\n", " tilings: tilings with a few layers\n", " return: the encoding for the feature on each layer\n", " \"\"\"\n", " num_dims = len(feature)\n", " feat_codings = []\n", " for tiling in tilings:\n", " feat_coding = []\n", " for i in range(num_dims):\n", " feat_i = feature[i]\n", " tiling_i = tiling[i] # tiling on that dimension\n", " coding_i = np.digitize(feat_i, tiling_i)\n", " feat_coding.append(coding_i)\n", " feat_codings.append(feat_coding)\n", " return np.array(feat_codings)" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [], "source": [ "server_range = [0, 10]\n", "priority_range = [0, 3]\n", "feature_ranges = [server_range, priority_range] # 2 features\n", "number_tilings = 8\n", "bins = [[16, 16] for _ in range(number_tilings)]\n", "offsets = [[i, j] for i, j in zip(np.linspace(server_range[0], server_range[1], number_tilings), \n", " np.linspace(priority_range[0], priority_range[1], number_tilings))]\n", "\n", "tilings = create_tilings(feature_ranges=feature_ranges, number_tilings=number_tilings, bins=bins, offsets=offsets)" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(8, 2, 15)" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tilings.shape" ] }, { "cell_type": "code", "execution_count": 99, "metadata": {}, "outputs": [], "source": [ "# example Q-function\n", "\n", "class QValueFunction:\n", "\n", " def __init__(self, tilings, actions, lr):\n", " self.tilings = tilings\n", " self.num_tilings = len(self.tilings)\n", " self.actions = [0, 1]\n", " self.lr = lr # / self.num_tilings # learning rate equally assigned to each tiling\n", " self.state_sizes = [tuple(len(splits) + 1 for splits in tiling) for tiling in\n", " self.tilings] # [(10, 10), (10, 10), (10, 10)]\n", " self.q_tables = [np.zeros(shape=(state_size + (len(self.actions),))) for state_size in self.state_sizes]\n", "\n", " def value(self, state, action):\n", " state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ...\n", " action_idx = self.actions.index(action)\n", "\n", " value = 0\n", " for coding, q_table in zip(state_codings, self.q_tables):\n", " # for each q table\n", " value += q_table[tuple(coding) + (action_idx,)]\n", " return value / self.num_tilings\n", "\n", "# def update(self, state, action, target):\n", "# n_server, priority = state\n", "# state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ...\n", "# action_idx = self.actions.index(action)\n", " \n", "# delta *= self.lr\n", "# for coding, q_table in zip(state_codings, self.q_tables):\n", "# q_table[tuple(coding) + (action_idx,)] += delta\n", " \n", " def update(self, state, action, target):\n", " n_server, priority = state\n", " state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ...\n", " action_idx = self.actions.index(action)\n", " \n", " for coding, q_table in zip(state_codings, self.q_tables):\n", " delta = target - q_table[tuple(coding) + (action_idx,)]\n", " q_table[tuple(coding) + (action_idx,)] += self.lr*delta\n", " \n", " def stateValue(self, state):\n", " if state[0] == 0:\n", " # no server available\n", " return self.value(state, 0)\n", " values = [self.value(state, a) for a in ACTIONS]\n", " return max(values)" ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "code_folding": [ 0 ] }, "outputs": [], "source": [ "class ServerAcess:\n", " def __init__(self, exp_rate=0.3, lr=0.1, beta=0.01):\n", " self.n_server = 10\n", " self.free_prob = 0.06\n", " self.priorities = range(4)\n", " self.actions = ACTIONS # 0: reject; 1: accept\n", " self.state = (0, 0) # (num_servers, priority)\n", " \n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", " self.beta = beta\n", "# self.alpha = alpha\n", " \n", " def numFreeServers(self):\n", " n = 0\n", " n_free_server = self.state[0]\n", " n_busy_server = self.n_server - n_free_server\n", " for _ in range(n_busy_server):\n", " if np.random.uniform(0, 1) <= 0.06:\n", " n += 1\n", " n_free_server += n\n", " self.state = (n_free_server, self.state[1])\n", " return n_free_server\n", " \n", " def chooseAction(self, valueFunc):\n", " n_free_server = self.numFreeServers()\n", " if n_free_server == 0:\n", " return 0\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " values = {}\n", " for a in self.actions:\n", " v = valueFunc.value(self.state, a)\n", " values[a] = v\n", " action = np.random.choice([k for k, v in values.items() if v == max(values.values())])\n", " return action\n", " \n", " def nxtState(self, action):\n", " if action == 1:\n", " n_free_server = self.state[0] - 1\n", " else:\n", " n_free_server = self.state[0]\n", " priority = np.random.choice(self.priorities)\n", " self.state = (n_free_server, priority)\n", " return self.state\n", " \n", " def giveReward(self, action):\n", " # recieve a reward by taking the action\n", " if action == 1:\n", " priority = self.state[1]\n", " return np.power(2, priority)\n", " return 0\n", " \n", " def run(self, valueFunc, steps=1000, inner_steps=100, debug=False):\n", " # updating average reward estimation along the way\n", " avg_reward = 0\n", " self.state = (10, np.random.choice(self.priorities))\n", " cur_state = self.state\n", " cur_action = self.chooseAction(valueFunc) # n free server is also updated\n", " \n", " total_reward = 0\n", " for i in range(1, steps+1):\n", " reward = self.giveReward(cur_action)\n", " new_state = self.nxtState(cur_action)\n", " new_action = self.chooseAction(valueFunc)\n", " \n", " total_reward += reward\n", " if debug:\n", " print(\"state {} action {} reward {}\".format(cur_state, cur_action, reward))\n", " if i % inner_steps == 0:\n", " print(\"step {} -> avg reward {} total reward {}\".format(i, avg_reward, total_reward))\n", " total_reward = 0\n", " \n", " target = reward - avg_reward + valueFunc.value(new_state, new_action)\n", " delta = reward - avg_reward + valueFunc.value(new_state, new_action) - valueFunc.value(cur_state, cur_action)\n", " avg_reward += self.beta*delta\n", " valueFunc.update(cur_state, cur_action, target)\n", " \n", " cur_state = new_state\n", " cur_action = new_action" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "step 5000 -> avg reward 1.764197559156301 total reward 10802\n", "step 10000 -> avg reward 2.2187221384375064 total reward 10614\n", "step 15000 -> avg reward 2.169983119676696 total reward 11053\n", "step 20000 -> avg reward 1.8439132889821988 total reward 10432\n", "step 25000 -> avg reward 2.0885899636716974 total reward 10768\n", "step 30000 -> avg reward 1.9450030230763382 total reward 10697\n", "step 35000 -> avg reward 2.463629138140144 total reward 11127\n", "step 40000 -> avg reward 2.20450155554836 total reward 10859\n", "step 45000 -> avg reward 2.51961257884254 total reward 10881\n", "step 50000 -> avg reward 2.2825924235160775 total reward 10984\n" ] } ], "source": [ "sa = ServerAcess(exp_rate=0.1)\n", "vf = QValueFunction(tilings=tilings, actions=[0, 1], lr=0.01)\n", "sa.run(vf, steps=50000, inner_steps=5000, debug=False)" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "for prioriy in range(4):\n", " n_servers = []\n", " values = []\n", " for n_server in range(11):\n", " value = vf.stateValue((n_server, prioriy))\n", " n_servers.append(n_server)\n", " values.append(value)\n", " plt.plot(n_servers, values, label=\"priority {}\".format(np.power(2, prioriy)))\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## If not avg Reward" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "class ValueFunction:\n", "\n", " def __init__(self, alpha=0.01, numOfTilings=8, maxSize=2048):\n", " self.maxSize = maxSize\n", " self.numOfTilings = numOfTilings\n", "\n", " # divide step size equally to each tiling\n", " self.alpha = alpha / numOfTilings # learning rate for each tile\n", "\n", " self.hashTable = IHT(maxSize)\n", "\n", " # weight for each tile\n", " self.weights = np.zeros(maxSize)\n", "\n", " # position and velocity needs scaling to satisfy the tile software\n", " self.serverScale = self.numOfTilings / 10.0 # 10 servers\n", " self.priorityScale = self.numOfTilings / 3.0 # 4 kinds of priorities\n", "\n", " # get indices of active tiles for given state and action\n", " def getActiveTiles(self, n_server, priority, action):\n", " activeTiles = tiles(self.hashTable, self.numOfTilings,\n", " [self.serverScale * n_server, self.priorityScale * priority],\n", " [action])\n", " return activeTiles\n", "\n", " # estimate the value of given state and action\n", " def value(self, state, action):\n", " n_server, priority = state\n", " activeTiles = self.getActiveTiles(n_server, priority, action)\n", " return np.sum(self.weights[activeTiles]) # /self.numOfTilings\n", "\n", " # learn with given state, action and target\n", " def update(self, state, action, delta):\n", " n_server, priority = state\n", " activeTiles = self.getActiveTiles(n_server, priority, action)\n", " \n", " delta *= self.alpha\n", " for activeTile in activeTiles:\n", " self.weights[activeTile] += delta\n", " \n", " def stateValue(self, state):\n", " if state[0] == 0:\n", " # no server available\n", " return self.value(state, 0)\n", " values = [self.value(state, a) for a in ACTIONS]\n", " return max(values)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "class ServerAcess:\n", " def __init__(self, exp_rate=0.3, lr=0.1, beta=0.01):\n", " self.n_server = 10\n", " self.free_prob = 0.06\n", " self.priorities = range(4)\n", " self.actions = ACTIONS # 0: reject; 1: accept\n", " self.state = (0, 0) # (num_servers, priority)\n", " \n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", " self.beta = beta\n", "# self.alpha = alpha\n", " \n", " def numFreeServers(self):\n", " n = 0\n", " n_free_server = self.state[0]\n", " n_busy_server = self.n_server - n_free_server\n", " for _ in range(n_busy_server):\n", " if np.random.uniform(0, 1) <= 0.06:\n", " n += 1\n", " n_free_server += n\n", " self.state = (n_free_server, self.state[1])\n", " return n_free_server\n", " \n", " def chooseAction(self, valueFunc):\n", " n_free_server = self.numFreeServers()\n", " if n_free_server == 0:\n", " return 0\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " values = {}\n", " for a in self.actions:\n", " v = valueFunc.value(self.state, a)\n", " values[a] = v\n", " action = np.random.choice([k for k, v in values.items() if v == max(values.values())])\n", " return action\n", " \n", " def nxtState(self, action):\n", " if action == 1:\n", " n_free_server = self.state[0] - 1\n", " else:\n", " n_free_server = self.state[0]\n", " priority = np.random.choice(self.priorities)\n", " self.state = (n_free_server, priority)\n", " return self.state\n", " \n", " def giveReward(self, action):\n", " # recieve a reward by taking the action\n", " if action == 1:\n", " priority = self.state[1]\n", " return np.power(2, priority)\n", " return 0\n", " \n", " def run(self, valueFunc, steps=1000, inner_steps=100, debug=False):\n", " # updating average reward estimation along the way\n", " self.state = (10, np.random.choice(self.priorities))\n", " cur_state = self.state\n", " cur_action = self.chooseAction(valueFunc) # n free server is also updated\n", " \n", " total_reward = 0\n", " for i in range(1, steps+1):\n", " reward = self.giveReward(cur_action)\n", " new_state = self.nxtState(cur_action)\n", " new_action = self.chooseAction(valueFunc)\n", " \n", " total_reward += reward\n", "# print(i)\n", " if debug:\n", " print(\"state {} action {} reward {}\".format(cur_state, cur_action, reward)) \n", "# target = reward - avg_reward + valueFunc.value(new_state, new_action)\n", " delta = reward + valueFunc.value(new_state, new_action) - valueFunc.value(cur_state, cur_action)\n", " valueFunc.update(cur_state, cur_action, delta)\n", " \n", " cur_state = new_state\n", " cur_action = new_action" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "sa = ServerAcess(exp_rate=0.1)\n", "vf = ValueFunction()\n", "sa.run(vf, steps=50000, inner_steps=5000, debug=False)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "for prioriy in range(4):\n", " n_servers = []\n", " values = []\n", " for n_server in range(11):\n", " value = vf.stateValue((n_server, prioriy))\n", " n_servers.append(n_server)\n", " values.append(value)\n", " plt.plot(n_servers, values, label=\"priority {}\".format(np.power(2, prioriy)))\n", " \n", "plt.xlabel(\"Number of Free Servers\", size=14)\n", "plt.ylabel(\"State Value\", size=14)\n", "plt.legend()" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: AccessControl/ServerAccess.py ================================================ import numpy as np import matplotlib.pyplot as plt from TileCoding import * ACTIONS = [0, 1] class ValueFunction: def __init__(self, alpha=0.01, numOfTilings=8, maxSize=2048): self.maxSize = maxSize self.numOfTilings = numOfTilings # divide step size equally to each tiling self.alpha = alpha / numOfTilings # learning rate for each tile self.hashTable = IHT(maxSize) # weight for each tile self.weights = np.zeros(maxSize) # position and velocity needs scaling to satisfy the tile software self.serverScale = self.numOfTilings / 10.0 # 10 servers self.priorityScale = self.numOfTilings / 3.0 # 4 kinds of priorities # get indices of active tiles for given state and action def getActiveTiles(self, n_server, priority, action): activeTiles = tiles(self.hashTable, self.numOfTilings, [self.serverScale * n_server, self.priorityScale * priority], [action]) return activeTiles # estimate the value of given state and action def value(self, state, action): n_server, priority = state activeTiles = self.getActiveTiles(n_server, priority, action) return np.sum(self.weights[activeTiles]) # /self.numOfTilings # learn with given state, action and target def update(self, state, action, delta): n_server, priority = state activeTiles = self.getActiveTiles(n_server, priority, action) delta *= self.alpha for activeTile in activeTiles: self.weights[activeTile] += delta def stateValue(self, state): if state[0] == 0: # no server available return self.value(state, 0) values = [self.value(state, a) for a in ACTIONS] return max(values) class ServerAcess: def __init__(self, exp_rate=0.3, lr=0.1, beta=0.01): self.n_server = 10 self.free_prob = 0.06 self.priorities = range(4) self.actions = ACTIONS # 0: reject; 1: accept self.state = (0, 0) # (num_servers, priority) self.exp_rate = exp_rate self.lr = lr self.beta = beta # self.alpha = alpha def numFreeServers(self): n = 0 n_free_server = self.state[0] n_busy_server = self.n_server - n_free_server for _ in range(n_busy_server): if np.random.uniform(0, 1) <= 0.06: n += 1 n_free_server += n self.state = (n_free_server, self.state[1]) return n_free_server def chooseAction(self, valueFunc): n_free_server = self.numFreeServers() if n_free_server == 0: return 0 if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: values = {} for a in self.actions: v = valueFunc.value(self.state, a) values[a] = v action = np.random.choice([k for k, v in values.items() if v == max(values.values())]) return action def nxtState(self, action): if action == 1: n_free_server = self.state[0] - 1 else: n_free_server = self.state[0] priority = np.random.choice(self.priorities) self.state = (n_free_server, priority) return self.state def giveReward(self, action): # recieve a reward by taking the action if action == 1: priority = self.state[1] return np.power(2, priority) return 0 def run(self, valueFunc, steps=1000, inner_steps=100, debug=False): # updating average reward estimation along the way avg_reward = 0 self.state = (10, np.random.choice(self.priorities)) cur_state = self.state cur_action = self.chooseAction(valueFunc) # n free server is also updated total_reward = 0 for i in range(1, steps + 1): reward = self.giveReward(cur_action) new_state = self.nxtState(cur_action) new_action = self.chooseAction(valueFunc) total_reward += reward if debug: print("state {} action {} reward {}".format(cur_state, cur_action, reward)) if i % inner_steps == 0: print("step {} -> avg reward {} total reward {}".format(i, avg_reward, total_reward)) # target = reward - avg_reward + valueFunc.value(new_state, new_action) delta = reward - avg_reward + valueFunc.value(new_state, new_action) - valueFunc.value(cur_state, cur_action) avg_reward += self.beta * delta valueFunc.update(cur_state, cur_action, delta) cur_state = new_state cur_action = new_action if __name__ == "__main__": sa = ServerAcess(exp_rate=0.1) vf = ValueFunction() sa.run(vf, steps=50000, inner_steps=5000, debug=False) plt.figure(figsize=[10, 6]) for prioriy in range(4): n_servers = [] values = [] for n_server in range(11): value = vf.stateValue((n_server, prioriy)) n_servers.append(n_server) values.append(value) plt.plot(n_servers, values, label="priority {}".format(np.power(2, prioriy))) plt.legend() ================================================ FILE: AccessControl/TileCoding.py ================================================ """ Tile Coding Software version 3.0beta by Rich Sutton based on a program created by Steph Schaeffer and others External documentation and recommendations on the use of this code is available in the reinforcement learning textbook by Sutton and Barto, and on the web. These need to be understood before this code is. This software is for Python 3 or more. This is an implementation of grid-style tile codings, based originally on the UNH CMAC code (see http://www.ece.unh.edu/robots/cmac.htm), but by now highly changed. Here we provide a function, "tiles", that maps floating and integer variables to a list of tiles, and a second function "tiles-wrap" that does the same while wrapping some floats to provided widths (the lower wrap value is always 0). The float variables will be gridded at unit intervals, so generalization will be by approximately 1 in each direction, and any scaling will have to be done externally before calling tiles. Num-tilings should be a power of 2, e.g., 16. To make the offsetting work properly, it should also be greater than or equal to four times the number of floats. The first argument is either an index hash table of a given size (created by (make-iht size)), an integer "size" (range of the indices from 0), or nil (for testing, indicating that the tile coordinates are to be returned without being converted to indices). """ basehash = hash class IHT: "Structure to handle collisions" def __init__(self, sizeval): self.size = sizeval self.overfullCount = 0 self.dictionary = {} def __str__(self): "Prepares a string for printing whenever this object is printed" return "Collision table:" + \ " size:" + str(self.size) + \ " overfullCount:" + str(self.overfullCount) + \ " dictionary:" + str(len(self.dictionary)) + " items" def count (self): return len(self.dictionary) def fullp (self): return len(self.dictionary) >= self.size def getindex (self, obj, readonly=False): d = self.dictionary if obj in d: return d[obj] elif readonly: return None size = self.size count = self.count() if count >= size: if self.overfullCount==0: print('IHT full, starting to allow collisions') self.overfullCount += 1 return basehash(obj) % self.size else: d[obj] = count return count def hashcoords(coordinates, m, readonly=False): if isinstance(m, IHT): return m.getindex(tuple(coordinates), readonly) if isinstance(m, int): return basehash(tuple(coordinates)) % m if m is None: return coordinates from math import floor, log from six.moves import zip_longest def tiles(ihtORsize, numtilings, floats, ints=[], readonly=False): """returns num-tilings tile indices corresponding to the floats and ints""" qfloats = [floor(f*numtilings) for f in floats] Tiles = [] for tiling in range(numtilings): tilingX2 = tiling*2 coords = [tiling] b = tiling for q in qfloats: coords.append( (q + b) // numtilings ) b += tilingX2 coords.extend(ints) Tiles.append(hashcoords(coords, ihtORsize, readonly)) return Tiles def tileswrap (ihtORsize, numtilings, floats, wrapwidths, ints=[], readonly=False): """returns num-tilings tile indices corresponding to the floats and ints, wrapping some floats""" qfloats = [floor(f*numtilings) for f in floats] Tiles = [] for tiling in range(numtilings): tilingX2 = tiling*2 coords = [tiling] b = tiling for q, width in zip_longest(qfloats, wrapwidths): c = (q + b%numtilings) // numtilings coords.append(c%width if width else c) b += tilingX2 coords.extend(ints) Tiles.append(hashcoords(coords, ihtORsize, readonly)) return Tiles ================================================ FILE: BairdExample/BairdCounterExample.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Baird Counter Example\n", "---\n", "To convert them to semi-gradient form, we simply replace the update to an array `(V or Q)` to an update to a weight vector `(w)`, using the approximate value function (`vˆ` or `qˆ`) and its gradient. Many of these algorithms use the per-step `importance sampling ratio` (importance weight):\n", "\n", "\n", "\n", "\n", "\n", "---\n", "The dashed action takes the system to one of the six upper states with equal probability, whereas the solid action takes the system to the seventh state. The `behavior policy b` selects the dashed and solid actions with probabilities `6/7` and `1/7`, so that the next-state distribution under it is uniform (the same for all nonterminal states), which is also the starting distribution for each episode. The target policy `π` always takes the solid action, and so the on-policy distribution (for `π`) is concentrated in the seventh state. The reward is `zero` on all transitions. The discount rate is `γ = 0.99`.\n", "\n", "\n", "\n", "- [Target Policy & Behaviour Policy](https://stats.stackexchange.com/questions/410131/in-rl-why-using-a-behavior-policy-instead-of-the-target-policy-for-an-episode-i)\n", "- [Target Policy & Behaviour Policy2](https://stats.stackexchange.com/questions/237085/how-to-correctly-compute-rho-in-reinforcement-learning-with-importance-sampli?rq=1)\n", "\n", "---\n", "## TDC\n", "\n", "\n", "\n", "which again is O(d) if the final product (xt*vt) is done first. This algorithm is known as either TD(0) with gradient correction (TDC) or, alternatively, as GTD(0)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "STATES = range(7)" ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [], "source": [ "class Baird:\n", " \n", " def __init__(self, gamma=0.99, alpha=0.01):\n", " self.state = np.random.choice(STATES)\n", " self.prob = 1.0/7\n", " self.actions = [\"solid\", \"dash\"]\n", " self.gamma = gamma\n", " self.alpha = alpha\n", " \n", " self.features = np.zeros((len(STATES), 8)) # n_states x n_weights (this is the representation of states)\n", " for i in range(len(STATES)):\n", " if i == 6:\n", " self.features[i, -2] = 1\n", " self.features[i, -1] = 2\n", " else:\n", " self.features[i, i] = 2\n", " self.features[i, -1] = 1\n", " \n", " self.weights = np.ones(8)\n", " self.weights[-2] = 10\n", " \n", " def chooseAction(self):\n", " if np.random.binomial(1, self.prob) == 1:\n", " action = \"solid\"\n", " else:\n", " action = \"dash\"\n", " return action\n", " \n", " def takeAction(self, action):\n", " if action == \"solid\":\n", " nxtState = 6\n", " else:\n", " nxtState = np.random.choice(STATES[:-1])\n", " return nxtState\n", " \n", " def value(self, state):\n", " v = np.dot(ba.features[state, :], ba.weights)\n", " return v\n", " \n", " def run_semi_gradient_TD(self, rounds=100, sarsa=False):\n", " reward = 0\n", " \n", " step_weights = np.zeros((rounds, len(self.weights)))\n", " for i in range(rounds):\n", " step_weights[i, :] = self.weights\n", " action = self.chooseAction()\n", " nxtState = self.takeAction(action)\n", " \n", " if action == \"dash\":\n", " rho = 0\n", " else:\n", " rho = 1/self.prob\n", " \n", " if sarsa:\n", " rho = 1\n", " \n", " delta = reward + self.gamma*self.value(nxtState) - self.value(self.state)\n", " delta *= self.alpha*rho\n", " # update\n", " self.weights += delta*self.features[state, :]\n", " \n", " self.state = nxtState\n", " return step_weights\n", " \n", " def run_TDC(self, beta=0.01, rounds=100):\n", " reward = 0\n", " v = np.zeros(8)\n", " \n", " step_weights = np.zeros((rounds, len(self.weights)))\n", " for i in range(rounds):\n", " step_weights[i, :] = self.weights\n", " action = self.chooseAction()\n", " nxtState = self.takeAction(action)\n", " \n", " if action == \"dash\":\n", " rho = 0\n", " else:\n", " rho = 1/self.prob\n", " \n", " delta = reward + self.gamma*self.value(nxtState) - self.value(self.state)\n", " self.weights += self.alpha*rho*(delta*self.features[self.state, :] - \n", " self.gamma*self.features[nxtState, :]*np.dot(self.features[self.state, :], v))\n", " v += beta*rho*(delta - np.dot(v, self.features[self.state, :]))*self.features[self.state, :]\n", " \n", " self.state = nxtState\n", " print(\"last v \\n\", v)\n", " return step_weights" ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[2. 0. 0. 0. 0. 0. 0. 1.]\n", " [0. 2. 0. 0. 0. 0. 0. 1.]\n", " [0. 0. 2. 0. 0. 0. 0. 1.]\n", " [0. 0. 0. 2. 0. 0. 0. 1.]\n", " [0. 0. 0. 0. 2. 0. 0. 1.]\n", " [0. 0. 0. 0. 0. 2. 0. 1.]\n", " [0. 0. 0. 0. 0. 0. 1. 2.]]\n", "\n", "[ 1. 1. 1. 1. 1. 1. 10. 1.]\n" ] } ], "source": [ "ba = Baird()\n", "print(ba.features)\n", "print()\n", "print(ba.weights)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Semi-gradient TD" ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "scrolled": true }, "outputs": [], "source": [ "ba = Baird()\n", "step_weigts_q = ba.run_semi_gradient_TD(rounds=1000)" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [], "source": [ "ba = Baird()\n", "step_weigts_sarsa = ba.run_semi_gradient_TD(rounds=1000, sarsa=True)" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[15, 6])\n", "\n", "ax1 = plt.subplot(121)\n", "ax2 = plt.subplot(122)\n", "\n", "row, col = step_weigts_q.shape\n", "for i in range(col):\n", " ax1.plot(range(row), step_weigts_q[:, i], label=\"w{}\".format(i+1))\n", " ax2.plot(range(row), step_weigts_sarsa[:, i], label=\"w{}\".format(i+1))\n", "\n", "ax1.set_title(\"off-policy\", size=14)\n", "ax2.set_title(\"on-policy\", size=14)\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TDC" ] }, { "cell_type": "code", "execution_count": 123, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "last v \n", " [-0.03695354 0.02034874 -0.00248629 0.03586568 -0.01377544 -0.00124259\n", " -0.00417839 -0.0074785 ]\n" ] } ], "source": [ "ba = Baird(alpha=0.005)\n", "step_weigts_tdc = ba.run_TDC(rounds=1000, beta=0.05)" ] }, { "cell_type": "code", "execution_count": 125, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 125, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 7])\n", "\n", "row, col = step_weigts_tdc.shape\n", "\n", "for i in range(col):\n", " plt.plot(range(row), step_weigts_q[:, i], label=\"w{}\".format(i+1))\n", "\n", "plt.xlabel(\"episode\", size=14)\n", "plt.ylabel(\"value\", size=14)\n", "plt.legend()" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: BairdExample/BairdCounterExample.py ================================================ import numpy as np import matplotlib.pyplot as plt STATES = range(7) class Baird: def __init__(self, gamma=0.99, alpha=0.01): self.state = np.random.choice(STATES) self.prob = 1.0 / 7 self.actions = ["solid", "dash"] self.gamma = gamma self.alpha = alpha self.features = np.zeros((len(STATES), 8)) # n_states x n_weights (this is the representation of states) for i in range(len(STATES)): if i == 6: self.features[i, -2] = 1 self.features[i, -1] = 2 else: self.features[i, i] = 2 self.features[i, -1] = 1 self.weights = np.ones(8) self.weights[-2] = 10 def chooseAction(self): if np.random.binomial(1, self.prob) == 1: action = "solid" else: action = "dash" return action def takeAction(self, action): if action == "solid": nxtState = 6 else: nxtState = np.random.choice(STATES[:-1]) return nxtState def value(self, state): v = np.dot(ba.features[state, :], ba.weights) return v def run_semi_gradient_TD(self, rounds=100, sarsa=False): reward = 0 step_weights = np.zeros((rounds, len(self.weights))) for i in range(rounds): step_weights[i, :] = self.weights action = self.chooseAction() nxtState = self.takeAction(action) if action == "dash": rho = 0 else: rho = 1 / self.prob if sarsa: rho = 1 delta = reward + self.gamma * self.value(nxtState) - self.value(self.state) delta *= self.alpha * rho # update self.weights += delta * self.features[state, :] self.state = nxtState return step_weights def run_TDC(self, beta=0.01, rounds=100): reward = 0 v = np.zeros(8) step_weights = np.zeros((rounds, len(self.weights))) for i in range(rounds): step_weights[i, :] = self.weights action = self.chooseAction() nxtState = self.takeAction(action) if action == "dash": rho = 0 else: rho = 1 / self.prob delta = reward + self.gamma * self.value(nxtState) - self.value(self.state) self.weights += self.alpha * rho * (delta * self.features[self.state, :] - self.gamma * self.features[nxtState, :] * np.dot( self.features[self.state, :], v)) v += beta * rho * (delta - np.dot(v, self.features[self.state, :])) * self.features[self.state, :] self.state = nxtState print("last v \n", v) return step_weights if __name__ == "__main__": ba = Baird() step_weigts_q = ba.run_semi_gradient_TD(rounds=1000) ba = Baird() step_weigts_sarsa = ba.run_semi_gradient_TD(rounds=1000, sarsa=True) plt.figure(figsize=[15, 6]) ax1 = plt.subplot(121) ax2 = plt.subplot(122) row, col = step_weigts_q.shape for i in range(col): ax1.plot(range(row), step_weigts_q[:, i], label="w{}".format(i + 1)) ax2.plot(range(row), step_weigts_sarsa[:, i], label="w{}".format(i + 1)) ax1.set_title("off-policy", size=14) ax2.set_title("on-policy", size=14) plt.legend() ba = Baird(alpha=0.005) step_weigts_tdc = ba.run_TDC(rounds=1000, beta=0.05) plt.figure(figsize=[10, 7]) row, col = step_weigts_tdc.shape for i in range(col): plt.plot(range(row), step_weigts_q[:, i], label="w{}".format(i + 1)) plt.xlabel("episode", size=14) plt.ylabel("value", size=14) plt.legend() ================================================ FILE: BlackJack/blackjack_mc.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### MC Simulation BlackJack State-Value\n", "---\n", "- dealer policy: HIT17\n", "- player policy: sticks on 20 or 21, otherwise hit\n", "---\n", "**States:** player's current sum(12–21), the dealer’s one showing card (ace–10), player's usable ace" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true }, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from mpl_toolkits.mplot3d import Axes3D" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": true }, "outputs": [], "source": [ "class BlackJackMC(object):\n", " \n", " def __init__(self):\n", " self.player_state_value = {}\n", " self.player_states = []\n", " self.player_win = 0\n", " self.player_draw = 0\n", " \n", " # give card\n", " @staticmethod\n", " def giveCard():\n", " # 1 stands for ace\n", " c_list = list(range(1, 11)) + [10, 10, 10]\n", " return np.random.choice(c_list)\n", " \n", " def dealerPolicy(self, current_value, usable_ace, is_end):\n", " if current_value > 21:\n", " if usable_ace:\n", " current_value -= 10\n", " usable_ace = False\n", " else:\n", " return current_value, usable_ace, True\n", " # HIT17\n", " if current_value >= 17:\n", " return current_value, usable_ace, True\n", " else:\n", " card = self.giveCard()\n", " if card == 1:\n", " if current_value <= 10:\n", " return current_value+11, True, False\n", " return current_value+1, usable_ace, False\n", " else:\n", " return current_value+card, usable_ace, False\n", " \n", " # one can only has 1 usable ace \n", " def playerPolicy(self, current_value, usable_ace, is_end):\n", " if current_value > 21:\n", " if usable_ace:\n", " current_value -= 10\n", " usable_ace = False\n", " else:\n", " return current_value, usable_ace, True\n", " # HIT20\n", " if current_value >= 20:\n", " return current_value, usable_ace, True\n", " else:\n", " card = self.giveCard()\n", " if card == 1:\n", " if current_value <= 10:\n", " return current_value+11, True, False\n", " return current_value+1, usable_ace, False\n", " else:\n", " return current_value+card, usable_ace, False\n", " \n", " \n", " def _giveCredit(self, player_value, dealer_value, is_end=True):\n", " if is_end:\n", " # give reward only to last state\n", " last_state = self.player_states[-1]\n", " if player_value > 21:\n", " if dealer_value > 21:\n", " # draw\n", " self.player_draw += 1\n", " else:\n", " self.player_state_value[last_state] -= 1\n", " else:\n", " if dealer_value > 21:\n", " self.player_state_value[last_state] += 1\n", " self.player_win += 1\n", " else:\n", " if player_value < dealer_value:\n", " self.player_state_value[last_state] -= 1\n", " elif player_value > dealer_value:\n", " self.player_state_value[last_state] += 1\n", " self.player_win += 1\n", " else:\n", " # draw\n", " self.player_draw += 1\n", " \n", " \n", " def play(self, rounds=1000):\n", " for i in range(rounds):\n", " if i % 1000 == 0:\n", " print(\"round\", i)\n", " # hit 2 cards each\n", " dealer_value, player_value = 0, 0\n", " show_card = 0\n", "\n", " # give dealer 2 cards and show 1\n", " dealer_value += self.giveCard()\n", " show_card = dealer_value\n", " dealer_value += self.giveCard()\n", "\n", " # player's turn\n", " # always hit if less than 12\n", " usable_ace, is_end = False, False\n", " while True:\n", " player_value, usable_ace, is_end = self.playerPolicy(player_value, usable_ace, is_end)\n", "\n", " if is_end: \n", " break\n", " # when value goes higher than 12, record states\n", " if (player_value >= 12) and (player_value <= 21):\n", " self.player_states.append((player_value, show_card, usable_ace))\n", " # print(\"player card sum\", player_value)\n", "\n", " # dealer's turn\n", " usable_ace, is_end = False, False\n", " while not is_end:\n", " dealer_value, usable_ace, is_end = self.dealerPolicy(dealer_value, usable_ace, is_end)\n", " # print(\"dealer card sum\", dealer_value)\n", "\n", " # judge winner\n", " # set intermediate state to 0\n", " for s in self.player_states:\n", " self.player_state_value[s] = 0 if self.player_state_value.get(s) is None else self.player_state_value.get(s)\n", "\n", " self._giveCredit(player_value, dealer_value) " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 0\n", "round 1000\n", "round 2000\n", "round 3000\n", "round 4000\n", "round 5000\n", "round 6000\n", "round 7000\n", "round 8000\n", "round 9000\n" ] } ], "source": [ "b = BlackJackMC()\n", "b.play(10000)" ] }, { "cell_type": "code", "execution_count": 151, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Player wining rate 0.306\n", "Not losing rate 0.5497\n" ] } ], "source": [ "print(\"Player wining rate\", b.player_win/10000)\n", "print(\"Not losing rate\", (b.player_win+b.player_draw)/10000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Plots" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'reward')" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=[10, 6])\n", "ax = fig.add_subplot(111, projection='3d')\n", "\n", "x = [k[1] for k in b.player_state_value.keys()]\n", "y = [k[0] for k in b.player_state_value.keys()]\n", "z = [v for v in b.player_state_value.values()]\n", "ax.scatter(x, y, z)\n", "\n", "ax.set_xlabel(\"dealer showing\")\n", "ax.set_ylabel(\"player sum\")\n", "ax.set_zlabel(\"reward\")" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": true }, "outputs": [], "source": [ "usable_ace = {}\n", "nonusable_ace = {}\n", "\n", "for k, v in b.player_state_value.items():\n", " if k[2]:\n", " usable_ace[k] = v\n", " else:\n", " nonusable_ace[k] = v" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'reward')" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=[15, 6])\n", "\n", "ax1 = fig.add_subplot(121, projection='3d')\n", "ax2 = fig.add_subplot(122, projection='3d')\n", "\n", "x1 = [k[1] for k in usable_ace.keys()]\n", "y1 = [k[0] for k in usable_ace.keys()]\n", "z1 = [v for v in usable_ace.values()]\n", "ax1.scatter(x1, y1, z1)\n", "\n", "ax1.set_title(\"usable ace\")\n", "ax1.set_xlabel(\"dealer showing\")\n", "ax1.set_ylabel(\"player sum\")\n", "ax1.set_zlabel(\"reward\")\n", "\n", "x2 = [k[1] for k in nonusable_ace.keys()]\n", "y2 = [k[0] for k in nonusable_ace.keys()]\n", "z2 = [v for v in nonusable_ace.values()]\n", "ax2.scatter(x2, y2, z2)\n", "\n", "ax2.set_title(\"non-usable ace\")\n", "ax2.set_xlabel(\"dealer showing\")\n", "ax2.set_ylabel(\"player sum\")\n", "ax2.set_zlabel(\"reward\")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-256" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.player_state_value.get((18, 10, False))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-52" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.player_state_value.get((18, 5, False))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: BlackJack/blackjack_mc.py ================================================ import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D class BlackJackMC(object): def __init__(self): self.player_state_value = {} self.player_states = [] self.player_win = 0 self.player_draw = 0 # give card @staticmethod def giveCard(): # 1 stands for ace c_list = list(range(1, 11)) + [10, 10, 10] return np.random.choice(c_list) def dealerPolicy(self, current_value, usable_ace, is_end): if current_value > 21: if usable_ace: current_value -= 10 usable_ace = False else: return current_value, usable_ace, True # HIT17 if current_value >= 17: return current_value, usable_ace, True else: card = self.giveCard() if card == 1: if current_value <= 10: return current_value + 11, True, False return current_value + 1, usable_ace, False else: return current_value + card, usable_ace, False # one can only has 1 usable ace def playerPolicy(self, current_value, usable_ace, is_end): if current_value > 21: if usable_ace: current_value -= 10 usable_ace = False else: return current_value, usable_ace, True # HIT17 if current_value >= 20: return current_value, usable_ace, True else: card = self.giveCard() if card == 1: if current_value <= 10: return current_value + 11, True, False return current_value + 1, usable_ace, False else: return current_value + card, usable_ace, False def _giveCredit(self, player_value, dealer_value, is_end=True): if is_end: # give reward only to last state last_state = self.player_states[-1] if player_value > 21: if dealer_value > 21: # draw self.player_draw += 1 else: self.player_state_value[last_state] -= 1 else: if dealer_value > 21: self.player_state_value[last_state] += 1 self.player_win += 1 else: if player_value < dealer_value: self.player_state_value[last_state] -= 1 elif player_value > dealer_value: self.player_state_value[last_state] += 1 self.player_win += 1 else: # draw self.player_draw += 1 def play(self, rounds=1000): for i in range(rounds): if i % 1000 == 0: print("round", i) # hit 2 cards each dealer_value, player_value = 0, 0 show_card = 0 # give dealer 2 cards and show 1 dealer_value += self.giveCard() show_card = dealer_value dealer_value += self.giveCard() # player's turn # always hit if less than 12 usable_ace, is_end = False, False while True: player_value, usable_ace, is_end = self.playerPolicy(player_value, usable_ace, is_end) if is_end: break # when value goes higher than 12, record states if (player_value >= 12) and (player_value <= 21): self.player_states.append((player_value, show_card, usable_ace)) # print("player card sum", player_value) # dealer's turn usable_ace, is_end = False, False while not is_end: dealer_value, usable_ace, is_end = self.dealerPolicy(dealer_value, usable_ace, is_end) # print("dealer card sum", dealer_value) # judge winner # set intermediate state to 0 for s in self.player_states: self.player_state_value[s] = 0 if self.player_state_value.get( s) is None else self.player_state_value.get(s) self._giveCredit(player_value, dealer_value) if __name__ == "__main__": rounds = 10000 b = BlackJackMC() b.play(rounds) print("Player wining rate", b.player_win / rounds) print("Not losing rate", (b.player_win + b.player_draw) / rounds) print("Plots ----------------") usable_ace = {} nonusable_ace = {} for k, v in b.player_state_value.items(): if k[2]: usable_ace[k] = v else: nonusable_ace[k] = v fig = plt.figure(figsize=[15, 6]) ax1 = fig.add_subplot(121, projection='3d') ax2 = fig.add_subplot(122, projection='3d') x1 = [k[1] for k in usable_ace.keys()] y1 = [k[0] for k in usable_ace.keys()] z1 = [v for v in usable_ace.values()] ax1.scatter(x1, y1, z1) ax1.set_title("usable ace") ax1.set_xlabel("dealer showing") ax1.set_ylabel("player sum") ax1.set_zlabel("reward") x2 = [k[1] for k in nonusable_ace.keys()] y2 = [k[0] for k in nonusable_ace.keys()] z2 = [v for v in nonusable_ace.values()] ax2.scatter(x2, y2, z2) ax2.set_title("non-usable ace") ax2.set_xlabel("dealer showing") ax2.set_ylabel("player sum") ax2.set_zlabel("reward") plt.show() ================================================ FILE: BlackJack/blackjack_solution.ipynb ================================================ { "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pickle" ] }, { "cell_type": "code", "execution_count": 88, "metadata": {}, "outputs": [], "source": [ "class BlackJackSolution:\n", " \n", " def __init__(self, lr=0.1, exp_rate=0.3):\n", " self.player_Q_Values = {} # key: [(player_value, show_card, usable_ace)][action] = value\n", " # initialise Q values | (12-21) x (1-10) x (True, False) x (1, 0) 400 in total\n", " for i in range(12, 22):\n", " for j in range(1, 12):\n", " for k in [True, False]:\n", " self.player_Q_Values[(i, j, k)] = {}\n", " for a in [1, 0]:\n", " self.player_Q_Values[(i, j, k)][a] = 0\n", " \n", " self.player_state_action = []\n", " self.state = (0, 0, False) # initial state\n", " self.actions = [1, 0] # 1: HIT 0: STAND\n", " self.end = False\n", " self.lr = lr\n", " self.exp_rate = exp_rate\n", " \n", " # give card\n", " @staticmethod\n", " def giveCard():\n", " # 1 stands for ace\n", " c_list = list(range(1, 11)) + [10, 10, 10]\n", " return np.random.choice(c_list)\n", " \n", " def dealerPolicy(self, current_value, usable_ace, is_end):\n", " if current_value > 21:\n", " if usable_ace:\n", " current_value -= 10\n", " usable_ace = False\n", " else:\n", " return current_value, usable_ace, True\n", " # HIT17\n", " if current_value >= 17:\n", " return current_value, usable_ace, True\n", " else:\n", " card = self.giveCard()\n", " if card == 1:\n", " if current_value <= 10:\n", " return current_value+11, True, False\n", " return current_value+1, usable_ace, False\n", " else:\n", " return current_value+card, usable_ace, False\n", " \n", " def chooseAction(self):\n", " # if current value <= 11, always hit\n", " current_value = self.state[0]\n", " if current_value <= 11:\n", " return 1\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " v = -999\n", " action = 0\n", " for a in self.player_Q_Values[self.state]:\n", " if self.player_Q_Values[self.state][a] > v:\n", " action = a\n", " v = self.player_Q_Values[self.state][a]\n", " return action\n", " \n", " # one can only has 1 usable ace \n", " # return next state\n", " def playerNxtState(self, action):\n", " current_value = self.state[0]\n", " show_card = self.state[1]\n", " usable_ace = self.state[2]\n", " \n", " if current_value > 21:\n", " if usable_ace:\n", " current_value -= 10\n", " usable_ace = False\n", " else:\n", " # should not reach here\n", " self.end = True\n", " self.state = (current_value, show_card, usable_ace)\n", " return\n", " if action:\n", " card = self.giveCard()\n", " if card == 1:\n", " if current_value <= 10:\n", " current_value += 11\n", " usable_ace = True\n", " else:\n", " current_value += 1\n", " else:\n", " current_value += card\n", " else:\n", " # action stand\n", " self.end = True\n", " \n", " if current_value > 21:\n", " self.end = True\n", " self.state = (current_value, show_card, usable_ace)\n", " \n", " def _giveCredit(self, player_value, dealer_value, is_end=True):\n", " reward = 0\n", " if is_end:\n", " if player_value > 21:\n", " if dealer_value > 21:\n", " # draw\n", " reward = 0\n", " else:\n", " reward = -1\n", " else:\n", " if dealer_value > 21:\n", " reward = 1\n", " else:\n", " if player_value < dealer_value:\n", " reward = -1\n", " elif player_value > dealer_value:\n", " reward = 1\n", " else:\n", " # draw\n", " reward = 0\n", " # backpropagate reward\n", " for s in reversed(self.player_state_action):\n", " state, action = s[0], s[1]\n", " reward = self.lr*(reward - self.player_Q_Values[state][action])\n", " self.player_Q_Values[state][action] += reward\n", " \n", " def reset(self):\n", " self.player_state_action = []\n", " self.state = (0, 0, False) # initial state\n", " self.end = False\n", " \n", " def play(self, rounds=1000):\n", " wins = np.zeros(2)\n", " for i in range(rounds):\n", " if i % 1000 == 0:\n", " print(\"round\", i)\n", " # hit 2 cards each\n", " dealer_value, player_value = 0, 0\n", " d_usable_ace, p_usable_ace = False, False\n", " show_card = 0\n", "\n", " # give dealer 2 cards and show 1\n", " # card 1\n", " \n", " card = self.giveCard()\n", " if card == 1:\n", " card = 11\n", " d_usable_ace = True\n", " \n", " show_card = card\n", " dealer_value += card\n", " self.state = (player_value, show_card, p_usable_ace)\n", " # card 2\n", " card = self.giveCard()\n", " if card == 1:\n", " if dealer_value == 11:\n", " dealer_value += 1\n", " else:\n", " dealer_value += 11\n", " d_usable_ace = True\n", " else:\n", " dealer_value += card\n", " \n", " # player's turn\n", " # player gets 2 cards\n", " \n", " card = self.giveCard()\n", " if card == 1:\n", " player_value += 11\n", " p_usable_ace = True\n", " else:\n", " player_value += card\n", " self.state = (player_value, show_card, p_usable_ace)\n", " \n", " card = self.giveCard()\n", " if card == 1:\n", " if player_value == 11:\n", " player_value += 1\n", " else:\n", " player_value += 11\n", " p_usable_ace = True\n", " else:\n", " player_value += card\n", " self.state = (player_value, show_card, p_usable_ace)\n", " \n", " # judge winner after 2 cards\n", " if player_value == 21 or dealer_value == 21:\n", " if player_value == 21:\n", " wins[0] += 1\n", " if dealer_value == 21:\n", " wins[1] += 1\n", " # game end\n", " print(\"reach 21 in 2 cards: player value {} | dealer value {}\".format(player_value, dealer_value))\n", " else: \n", " while True:\n", " action = self.chooseAction()\n", " # print(\"current value {}, action {}\".format(self.state[0], action))\n", " if self.state[0] >= 12:\n", " self.player_state_action.append([self.state, action])\n", " # update next state\n", " self.playerNxtState(action)\n", " if self.end:\n", " break \n", "\n", " # dealer's turn\n", " is_end = False\n", " while not is_end:\n", " dealer_value, d_usable_ace, is_end = self.dealerPolicy(dealer_value, d_usable_ace, is_end)\n", "\n", " # judge winner\n", " # give reward and update Q value\n", " player_value = self.state[0]\n", " print(\"player value {} | dealer value {}\".format(player_value, dealer_value))\n", " self._giveCredit(player_value, dealer_value)\n", " self.reset()\n", " print(wins)\n", " \n", " def savePolicy(self, file=\"policy\"):\n", " fw = open(file, 'wb')\n", " pickle.dump(self.player_Q_Values, fw)\n", " fw.close()\n", "\n", " def loadPolicy(self, file=\"policy\"):\n", " fr = open(file,'rb')\n", " self.player_Q_Values = pickle.load(fr)\n", " fr.close()\n", " \n", " # trained robot play against dealer\n", " def playWithDealer(self, rounds=1000):\n", " self.reset()\n", " self.loadPolicy()\n", " self.exp_rate = 0\n", " \n", " result = np.zeros(3) # player [win, draw, lose]\n", " for _ in range(rounds):\n", " # hit 2 cards each\n", " dealer_value, player_value = 0, 0\n", " d_usable_ace, p_usable_ace = False, False\n", " show_card = 0\n", "\n", " # give dealer 2 cards and show 1\n", " # card 1\n", " card = self.giveCard()\n", " if card == 1:\n", " card = 11\n", " d_usable_ace = True\n", " \n", " show_card = card\n", " dealer_value += card\n", " self.state = (player_value, show_card, p_usable_ace)\n", " # card 2\n", " card = self.giveCard()\n", " if card == 1:\n", " if dealer_value == 11:\n", " dealer_value += 1\n", " else:\n", " dealer_value += 11\n", " d_usable_ace = True\n", " else:\n", " dealer_value += card\n", " \n", " # player's turn\n", " # player gets 2 cards\n", " card = self.giveCard()\n", " if card == 1:\n", " player_value += 11\n", " p_usable_ace = True\n", " else:\n", " player_value += card\n", " self.state = (player_value, show_card, p_usable_ace)\n", " \n", " card = self.giveCard()\n", " if card == 1:\n", " if player_value == 11:\n", " player_value += 1\n", " else:\n", " player_value += 11\n", " p_usable_ace = True\n", " else:\n", " player_value += card\n", " self.state = (player_value, show_card, p_usable_ace)\n", " \n", " # judge winner after 2 cards\n", " if player_value == 21 or dealer_value == 21:\n", " if player_value == dealer_value:\n", " result[1] += 1\n", " elif player_value > dealer_value:\n", " result[0] += 1\n", " else:\n", " result[2] += 1\n", " else:\n", " # player's turn\n", " while True:\n", " action = self.chooseAction()\n", " # update next state\n", " self.playerNxtState(action)\n", " if self.end:\n", " break \n", "\n", " # dealer's turn\n", " is_end = False\n", " while not is_end:\n", " dealer_value, d_usable_ace, is_end = self.dealerPolicy(dealer_value, d_usable_ace, is_end)\n", "\n", " # judge\n", " player_value = self.state[0]\n", " # print(\"player value {} | dealer value {}\".format(player_value, dealer_value))\n", " if player_value > 21:\n", " if dealer_value > 21:\n", " # draw\n", " result[1] += 1\n", " else:\n", " result[2] += 1\n", " else:\n", " if dealer_value > 21:\n", " result[0] += 1\n", " else:\n", " if player_value < dealer_value:\n", " result[2] += 1\n", " elif player_value > dealer_value:\n", " result[0] += 1\n", " else:\n", " # draw\n", " result[1] += 1\n", " self.reset()\n", " return result" ] }, { "cell_type": "code", "execution_count": 100, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 0\n", "player value 26 | dealer value 22\n", "player value 27 | dealer value 22\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 19 | dealer value 19\n", "player value 20 | dealer value 20\n", "player value 26 | dealer value 17\n", "player value 13 | dealer value 17\n", "player value 12 | dealer value 19\n", "player value 22 | dealer value 20\n", "player value 26 | dealer value 22\n", "player value 29 | dealer value 17\n", "player value 14 | dealer value 24\n", "player value 26 | dealer value 19\n", "player value 22 | dealer value 17\n", "player value 24 | dealer value 17\n", "player value 13 | dealer value 18\n", "player value 27 | dealer value 23\n", "player value 27 | dealer value 20\n", "player value 17 | dealer value 20\n", "player value 20 | dealer value 22\n", "player value 14 | dealer value 20\n", "player value 21 | dealer value 19\n", "player value 26 | dealer value 20\n", "player value 22 | dealer value 19\n", "player value 25 | dealer value 21\n", "player value 28 | dealer value 20\n", "player value 26 | dealer value 17\n", "player value 26 | dealer value 20\n", "player value 25 | dealer value 18\n", "reach 21 in 2 cards: player value 12 | dealer value 21\n", "player value 19 | dealer value 19\n", "player value 25 | dealer value 20\n", "player value 23 | dealer value 22\n", "player value 21 | dealer value 20\n", "player value 24 | dealer value 26\n", "reach 21 in 2 cards: player value 5 | dealer value 21\n", "player value 23 | dealer value 20\n", "player value 25 | dealer value 23\n", "player value 24 | dealer value 17\n", "player value 15 | dealer value 17\n", "player value 25 | dealer value 17\n", "player value 20 | dealer value 21\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 20 | dealer value 24\n", "player value 27 | dealer value 20\n", "player value 27 | dealer value 19\n", "player value 17 | dealer value 22\n", "player value 17 | dealer value 19\n", "player value 28 | dealer value 17\n", "player value 16 | dealer value 20\n", "player value 25 | dealer value 21\n", "reach 21 in 2 cards: player value 14 | dealer value 21\n", "player value 25 | dealer value 25\n", "player value 29 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 16\n", "player value 22 | dealer value 24\n", "player value 21 | dealer value 26\n", "player value 20 | dealer value 24\n", "player value 24 | dealer value 26\n", "player value 26 | dealer value 17\n", "player value 29 | dealer value 23\n", "player value 24 | dealer value 17\n", "player value 27 | dealer value 19\n", "player value 31 | dealer value 20\n", "player value 23 | dealer value 26\n", "player value 25 | dealer value 20\n", "player value 18 | dealer value 22\n", "reach 21 in 2 cards: player value 21 | dealer value 11\n", "player value 23 | dealer value 26\n", "player value 12 | dealer value 17\n", "player value 26 | dealer value 19\n", "player value 26 | dealer value 18\n", "player value 29 | dealer value 20\n", "player value 12 | dealer value 20\n", "player value 18 | dealer value 19\n", "player value 17 | dealer value 19\n", "player value 19 | dealer value 18\n", "player value 25 | dealer value 22\n", "reach 21 in 2 cards: player value 21 | dealer value 15\n", "player value 20 | dealer value 26\n", "player value 23 | dealer value 20\n", "player value 27 | dealer value 23\n", "player value 27 | dealer value 22\n", "player value 18 | dealer value 20\n", "player value 19 | dealer value 23\n", "player value 21 | dealer value 25\n", "player value 24 | dealer value 24\n", "player value 21 | dealer value 20\n", "player value 26 | dealer value 17\n", "player value 27 | dealer value 17\n", "player value 21 | dealer value 20\n", "player value 28 | dealer value 18\n", "player value 23 | dealer value 19\n", "player value 15 | dealer value 18\n", "player value 24 | dealer value 22\n", "player value 22 | dealer value 22\n", "player value 12 | dealer value 23\n", "player value 22 | dealer value 25\n", "player value 21 | dealer value 17\n", "player value 20 | dealer value 17\n", "player value 27 | dealer value 22\n", "player value 16 | dealer value 22\n", "player value 25 | dealer value 19\n", "player value 18 | dealer value 20\n", "player value 30 | dealer value 25\n", "player value 18 | dealer value 17\n", "player value 31 | dealer value 18\n", "player value 26 | dealer value 20\n", "player value 17 | dealer value 22\n", "player value 24 | dealer value 26\n", "player value 17 | dealer value 17\n", "player value 17 | dealer value 22\n", "player value 14 | dealer value 20\n", "player value 19 | dealer value 21\n", "player value 14 | dealer value 19\n", "player value 22 | dealer value 24\n", "player value 25 | dealer value 24\n", "player value 20 | dealer value 19\n", "player value 22 | dealer value 22\n", "player value 27 | dealer value 23\n", "player value 25 | dealer value 19\n", "player value 23 | dealer value 23\n", "player value 23 | dealer value 25\n", "player value 17 | dealer value 22\n", "player value 22 | dealer value 20\n", "player value 22 | dealer value 18\n", "player value 23 | dealer value 22\n", "player value 31 | dealer value 21\n", "player value 24 | dealer value 17\n", "player value 14 | dealer value 26\n", "player value 28 | dealer value 25\n", "player value 14 | dealer value 20\n", "player value 16 | dealer value 20\n", "player value 28 | dealer value 20\n", "player value 24 | dealer value 22\n", "player value 20 | dealer value 23\n", "player value 17 | dealer value 18\n", "player value 16 | dealer value 24\n", "player value 20 | dealer value 20\n", "player value 22 | dealer value 18\n", "player value 20 | dealer value 21\n", "player value 21 | dealer value 17\n", "player value 18 | dealer value 18\n", "player value 25 | dealer value 24\n", "reach 21 in 2 cards: player value 14 | dealer value 21\n", "player value 12 | dealer value 18\n", "player value 19 | dealer value 20\n", "player value 17 | dealer value 17\n", "player value 22 | dealer value 22\n", "player value 25 | dealer value 22\n", "player value 16 | dealer value 23\n", "player value 15 | dealer value 17\n", "player value 23 | dealer value 17\n", "player value 24 | dealer value 24\n", "player value 27 | dealer value 26\n", "reach 21 in 2 cards: player value 6 | dealer value 21\n", "player value 15 | dealer value 20\n", "player value 12 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 20 | dealer value 25\n", "player value 25 | dealer value 25\n", "player value 22 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 15\n", "player value 24 | dealer value 21\n", "player value 28 | dealer value 19\n", "player value 18 | dealer value 21\n", "player value 22 | dealer value 21\n", "player value 16 | dealer value 18\n", "player value 29 | dealer value 17\n", "player value 23 | dealer value 21\n", "player value 27 | dealer value 21\n", "reach 21 in 2 cards: player value 21 | dealer value 19\n", "player value 13 | dealer value 17\n", "player value 19 | dealer value 20\n", "player value 18 | dealer value 21\n", "player value 26 | dealer value 20\n", "player value 30 | dealer value 24\n", "player value 19 | dealer value 25\n", "player value 18 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 5\n", "player value 29 | dealer value 18\n", "player value 21 | dealer value 22\n", "player value 16 | dealer value 23\n", "player value 21 | dealer value 21\n", "player value 22 | dealer value 24\n", "player value 24 | dealer value 22\n", "player value 27 | dealer value 23\n", "player value 23 | dealer value 24\n", "reach 21 in 2 cards: player value 17 | dealer value 21\n", "player value 19 | dealer value 20\n", "player value 18 | dealer value 18\n", "player value 24 | dealer value 18\n", "player value 22 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 12\n", "player value 28 | dealer value 19\n", "player value 20 | dealer value 17\n", "player value 19 | dealer value 18\n", "player value 27 | dealer value 20\n", "player value 18 | dealer value 23\n", "reach 21 in 2 cards: player value 21 | dealer value 17\n", "player value 14 | dealer value 22\n", "reach 21 in 2 cards: player value 15 | dealer value 21\n", "player value 24 | dealer value 25\n", "player value 16 | dealer value 19\n", "player value 20 | dealer value 20\n", "player value 14 | dealer value 20\n", "player value 19 | dealer value 24\n", "player value 27 | dealer value 23\n", "player value 17 | dealer value 21\n", "player value 23 | dealer value 26\n", "player value 23 | dealer value 22\n", "player value 23 | dealer value 22\n", "player value 20 | dealer value 19\n", "player value 15 | dealer value 22\n", "player value 15 | dealer value 20\n", "player value 21 | dealer value 20\n", "player value 26 | dealer value 18\n", "player value 16 | dealer value 20\n", "player value 18 | dealer value 21\n", "player value 18 | dealer value 19\n", "player value 20 | dealer value 17\n", "player value 26 | dealer value 20\n", "reach 21 in 2 cards: player value 7 | dealer value 21\n", "player value 16 | dealer value 21\n", "player value 22 | dealer value 20\n", "player value 19 | dealer value 18\n", "player value 14 | dealer value 24\n", "player value 20 | dealer value 22\n", "player value 26 | dealer value 20\n", "player value 18 | dealer value 19\n", "player value 26 | dealer value 18\n", "player value 23 | dealer value 19\n", "player value 20 | dealer value 18\n", "player value 15 | dealer value 18\n", "player value 15 | dealer value 21\n", "player value 30 | dealer value 23\n", "player value 22 | dealer value 17\n", "player value 29 | dealer value 17\n", "player value 26 | dealer value 23\n", "player value 18 | dealer value 17\n", "player value 20 | dealer value 21\n", "reach 21 in 2 cards: player value 21 | dealer value 8\n", "player value 20 | dealer value 17\n", "reach 21 in 2 cards: player value 21 | dealer value 14\n", "player value 26 | dealer value 18\n", "player value 13 | dealer value 19\n", "player value 21 | dealer value 20\n", "player value 20 | dealer value 23\n", "player value 28 | dealer value 20\n", "player value 19 | dealer value 21\n", "player value 24 | dealer value 18\n", "player value 13 | dealer value 19\n", "player value 12 | dealer value 17\n", "player value 12 | dealer value 21\n", "player value 20 | dealer value 25\n", "player value 17 | dealer value 17\n", "player value 24 | dealer value 17\n", "player value 22 | dealer value 22\n", "reach 21 in 2 cards: player value 12 | dealer value 21\n", "player value 22 | dealer value 17\n", "player value 18 | dealer value 18\n", "player value 16 | dealer value 20\n", "player value 19 | dealer value 23\n", "reach 21 in 2 cards: player value 10 | dealer value 21\n", "player value 29 | dealer value 25\n", "player value 18 | dealer value 21\n", "player value 20 | dealer value 21\n", "player value 23 | dealer value 18\n", "player value 26 | dealer value 22\n", "player value 20 | dealer value 19\n", "player value 18 | dealer value 20\n", "player value 14 | dealer value 17\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 26 | dealer value 18\n", "reach 21 in 2 cards: player value 14 | dealer value 21\n", "player value 19 | dealer value 25\n", "player value 30 | dealer value 18\n", "player value 24 | dealer value 17\n", "player value 15 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 12\n", "player value 19 | dealer value 24\n", "player value 24 | dealer value 20\n", "player value 20 | dealer value 20\n", "player value 21 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 16\n", "player value 18 | dealer value 18\n", "player value 28 | dealer value 22\n", "player value 20 | dealer value 20\n", "player value 19 | dealer value 19\n", "player value 12 | dealer value 19\n", "player value 15 | dealer value 20\n", "player value 20 | dealer value 23\n", "player value 25 | dealer value 17\n", "player value 16 | dealer value 19\n", "player value 20 | dealer value 19\n", "player value 24 | dealer value 18\n", "player value 21 | dealer value 17\n", "player value 14 | dealer value 22\n", "player value 23 | dealer value 18\n", "player value 17 | dealer value 18\n", "player value 16 | dealer value 22\n", "player value 23 | dealer value 23\n", "player value 21 | dealer value 20\n", "player value 23 | dealer value 17\n", "player value 13 | dealer value 21\n", "player value 21 | dealer value 20\n", "player value 27 | dealer value 18\n", "player value 29 | dealer value 19\n", "player value 20 | dealer value 26\n", "player value 20 | dealer value 17\n", "player value 23 | dealer value 25\n", "player value 18 | dealer value 26\n", "player value 17 | dealer value 20\n", "player value 24 | dealer value 18\n", "player value 19 | dealer value 20\n", "player value 28 | dealer value 23\n", "player value 19 | dealer value 17\n", "player value 25 | dealer value 22\n", "player value 18 | dealer value 19\n", "player value 29 | dealer value 20\n", "player value 21 | dealer value 17\n", "player value 31 | dealer value 18\n", "player value 16 | dealer value 23\n", "player value 23 | dealer value 19\n", "player value 20 | dealer value 19\n", "player value 16 | dealer value 24\n", "player value 21 | dealer value 22\n", "player value 15 | dealer value 19\n", "player value 19 | dealer value 22\n", "player value 23 | dealer value 17\n", "player value 27 | dealer value 17\n", "player value 25 | dealer value 18\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 12 | dealer value 17\n", "player value 14 | dealer value 18\n", "player value 19 | dealer value 23\n", "player value 12 | dealer value 24\n", "player value 20 | dealer value 23\n", "player value 12 | dealer value 19\n", "player value 18 | dealer value 17\n", "player value 24 | dealer value 25\n", "player value 12 | dealer value 22\n", "player value 20 | dealer value 20\n", "player value 18 | dealer value 18\n", "player value 12 | dealer value 17\n", "player value 20 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 8\n", "player value 24 | dealer value 21\n", "player value 25 | dealer value 20\n", "player value 26 | dealer value 18\n", "player value 22 | dealer value 20\n", "player value 31 | dealer value 22\n", "player value 26 | dealer value 25\n", "reach 21 in 2 cards: player value 12 | dealer value 21\n", "player value 21 | dealer value 24\n", "reach 21 in 2 cards: player value 14 | dealer value 21\n", "player value 18 | dealer value 18\n", "player value 15 | dealer value 21\n", "player value 21 | dealer value 20\n", "player value 24 | dealer value 24\n", "player value 19 | dealer value 22\n", "player value 30 | dealer value 20\n", "player value 20 | dealer value 20\n", "reach 21 in 2 cards: player value 18 | dealer value 21\n", "player value 15 | dealer value 22\n", "player value 23 | dealer value 18\n", "player value 14 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 15\n", "player value 19 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 17\n", "player value 25 | dealer value 19\n", "player value 18 | dealer value 17\n", "player value 26 | dealer value 18\n", "player value 19 | dealer value 17\n", "player value 18 | dealer value 24\n", "player value 19 | dealer value 18\n", "player value 24 | dealer value 19\n", "player value 20 | dealer value 19\n", "player value 29 | dealer value 19\n", "player value 30 | dealer value 22\n", "player value 24 | dealer value 17\n", "player value 28 | dealer value 24\n", "reach 21 in 2 cards: player value 21 | dealer value 14\n", "player value 24 | dealer value 20\n", "player value 20 | dealer value 19\n", "player value 15 | dealer value 17\n", "player value 14 | dealer value 17\n", "player value 22 | dealer value 17\n", "player value 18 | dealer value 25\n", "player value 12 | dealer value 17\n", "player value 23 | dealer value 18\n", "reach 21 in 2 cards: player value 7 | dealer value 21\n", "player value 24 | dealer value 21\n", "player value 26 | dealer value 20\n", "player value 20 | dealer value 20\n", "player value 18 | dealer value 17\n", "player value 18 | dealer value 17\n", "player value 15 | dealer value 20\n", "player value 15 | dealer value 25\n", "player value 18 | dealer value 19\n", "player value 23 | dealer value 19\n", "player value 21 | dealer value 26\n", "player value 30 | dealer value 19\n", "player value 19 | dealer value 22\n", "player value 22 | dealer value 20\n", "player value 22 | dealer value 20\n", "player value 26 | dealer value 19\n", "player value 17 | dealer value 19\n", "player value 14 | dealer value 17\n", "player value 18 | dealer value 20\n", "player value 26 | dealer value 21\n", "reach 21 in 2 cards: player value 21 | dealer value 13\n", "player value 22 | dealer value 19\n", "player value 28 | dealer value 18\n", "player value 12 | dealer value 17\n", "player value 13 | dealer value 19\n", "player value 27 | dealer value 20\n", "player value 17 | dealer value 20\n", "player value 16 | dealer value 19\n", "player value 29 | dealer value 17\n", "player value 14 | dealer value 22\n", "player value 21 | dealer value 17\n", "player value 19 | dealer value 17\n", "player value 17 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 18 | dealer value 21\n", "player value 15 | dealer value 20\n", "player value 20 | dealer value 24\n", "player value 25 | dealer value 21\n", "player value 15 | dealer value 25\n", "player value 13 | dealer value 21\n", "player value 14 | dealer value 21\n", "player value 13 | dealer value 17\n", "reach 21 in 2 cards: player value 16 | dealer value 21\n", "player value 20 | dealer value 20\n", "player value 12 | dealer value 20\n", "player value 21 | dealer value 17\n", "player value 19 | dealer value 26\n", "player value 25 | dealer value 20\n", "player value 18 | dealer value 19\n", "player value 20 | dealer value 22\n", "player value 21 | dealer value 23\n", "player value 17 | dealer value 25\n", "player value 13 | dealer value 18\n", "player value 18 | dealer value 18\n", "player value 18 | dealer value 21\n", "player value 20 | dealer value 20\n", "player value 19 | dealer value 21\n", "player value 20 | dealer value 18\n", "player value 15 | dealer value 19\n", "player value 18 | dealer value 20\n", "player value 24 | dealer value 19\n", "player value 18 | dealer value 26\n", "reach 21 in 2 cards: player value 10 | dealer value 21\n", "player value 12 | dealer value 17\n", "player value 22 | dealer value 19\n", "player value 17 | dealer value 24\n", "player value 19 | dealer value 18\n", "player value 24 | dealer value 20\n", "player value 19 | dealer value 22\n", "player value 17 | dealer value 19\n", "player value 14 | dealer value 17\n", "player value 22 | dealer value 17\n", "player value 20 | dealer value 23\n", "reach 21 in 2 cards: player value 14 | dealer value 21\n", "player value 26 | dealer value 25\n", "player value 22 | dealer value 21\n", "player value 19 | dealer value 19\n", "reach 21 in 2 cards: player value 18 | dealer value 21\n", "player value 23 | dealer value 19\n", "reach 21 in 2 cards: player value 4 | dealer value 21\n", "player value 16 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 16 | dealer value 21\n", "player value 20 | dealer value 21\n", "player value 15 | dealer value 23\n", "player value 17 | dealer value 17\n", "player value 22 | dealer value 17\n", "player value 17 | dealer value 20\n", "player value 25 | dealer value 17\n", "player value 16 | dealer value 20\n", "reach 21 in 2 cards: player value 18 | dealer value 21\n", "player value 20 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 19\n", "player value 15 | dealer value 17\n", "player value 16 | dealer value 19\n", "player value 20 | dealer value 24\n", "player value 19 | dealer value 24\n", "player value 29 | dealer value 19\n", "player value 17 | dealer value 20\n", "player value 12 | dealer value 18\n", "player value 14 | dealer value 23\n", "player value 20 | dealer value 20\n", "player value 25 | dealer value 18\n", "player value 14 | dealer value 20\n", "player value 25 | dealer value 17\n", "player value 19 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 9\n", "player value 20 | dealer value 19\n", "player value 15 | dealer value 17\n", "player value 26 | dealer value 20\n", "player value 14 | dealer value 17\n", "player value 24 | dealer value 23\n", "player value 26 | dealer value 17\n", "player value 16 | dealer value 24\n", "player value 25 | dealer value 25\n", "player value 18 | dealer value 21\n", "player value 12 | dealer value 17\n", "player value 22 | dealer value 18\n", "player value 22 | dealer value 18\n", "player value 16 | dealer value 20\n", "player value 24 | dealer value 20\n", "player value 16 | dealer value 20\n", "player value 17 | dealer value 22\n", "player value 14 | dealer value 20\n", "player value 15 | dealer value 19\n", "player value 23 | dealer value 25\n", "player value 21 | dealer value 22\n", "player value 19 | dealer value 25\n", "player value 15 | dealer value 19\n", "player value 14 | dealer value 22\n", "player value 14 | dealer value 19\n", "player value 15 | dealer value 23\n", "player value 23 | dealer value 20\n", "player value 20 | dealer value 22\n", "player value 13 | dealer value 22\n", "player value 14 | dealer value 20\n", "player value 14 | dealer value 23\n", "reach 21 in 2 cards: player value 21 | dealer value 7\n", "reach 21 in 2 cards: player value 21 | dealer value 12\n", "player value 20 | dealer value 18\n", "player value 27 | dealer value 23\n", "player value 13 | dealer value 22\n", "player value 20 | dealer value 26\n", "reach 21 in 2 cards: player value 4 | dealer value 21\n", "player value 31 | dealer value 26\n", "player value 27 | dealer value 18\n", "player value 16 | dealer value 17\n", "player value 19 | dealer value 21\n", "player value 25 | dealer value 20\n", "player value 15 | dealer value 20\n", "player value 19 | dealer value 18\n", "player value 19 | dealer value 22\n", "player value 20 | dealer value 19\n", "player value 20 | dealer value 23\n", "player value 14 | dealer value 21\n", "player value 26 | dealer value 24\n", "reach 21 in 2 cards: player value 18 | dealer value 21\n", "player value 20 | dealer value 18\n", "player value 12 | dealer value 18\n", "player value 20 | dealer value 20\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 22 | dealer value 17\n", "player value 17 | dealer value 19\n", "player value 14 | dealer value 17\n", "player value 22 | dealer value 17\n", "player value 15 | dealer value 23\n", "player value 20 | dealer value 19\n", "player value 16 | dealer value 19\n", "player value 16 | dealer value 24\n", "player value 18 | dealer value 26\n", "player value 16 | dealer value 26\n", "player value 18 | dealer value 22\n", "player value 15 | dealer value 24\n", "player value 16 | dealer value 23\n", "player value 20 | dealer value 17\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 26 | dealer value 23\n", "player value 24 | dealer value 19\n", "player value 26 | dealer value 25\n", "reach 21 in 2 cards: player value 20 | dealer value 21\n", "player value 17 | dealer value 20\n", "player value 15 | dealer value 18\n", "reach 21 in 2 cards: player value 21 | dealer value 14\n", "player value 16 | dealer value 19\n", "player value 26 | dealer value 21\n", "player value 19 | dealer value 17\n", "player value 24 | dealer value 18\n", "player value 20 | dealer value 22\n", "player value 16 | dealer value 20\n", "player value 22 | dealer value 18\n", "player value 20 | dealer value 19\n", "player value 28 | dealer value 23\n", "player value 20 | dealer value 23\n", "player value 18 | dealer value 24\n", "reach 21 in 2 cards: player value 15 | dealer value 21\n", "player value 27 | dealer value 17\n", "player value 28 | dealer value 24\n", "player value 24 | dealer value 20\n", "player value 19 | dealer value 20\n", "player value 16 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 23 | dealer value 21\n", "player value 17 | dealer value 24\n", "player value 23 | dealer value 23\n", "player value 14 | dealer value 18\n", "player value 15 | dealer value 17\n", "player value 22 | dealer value 20\n", "player value 20 | dealer value 22\n", "player value 28 | dealer value 23\n", "reach 21 in 2 cards: player value 21 | dealer value 15\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 19 | dealer value 20\n", "player value 22 | dealer value 20\n", "player value 25 | dealer value 23\n", "player value 22 | dealer value 20\n", "player value 16 | dealer value 23\n", "player value 25 | dealer value 24\n", "player value 17 | dealer value 18\n", "reach 21 in 2 cards: player value 21 | dealer value 9\n", "player value 24 | dealer value 22\n", "player value 21 | dealer value 26\n", "player value 29 | dealer value 22\n", "player value 21 | dealer value 18\n", "player value 14 | dealer value 23\n", "player value 19 | dealer value 24\n", "player value 21 | dealer value 20\n", "player value 12 | dealer value 17\n", "reach 21 in 2 cards: player value 15 | dealer value 21\n", "player value 14 | dealer value 20\n", "player value 12 | dealer value 20\n", "player value 20 | dealer value 20\n", "player value 19 | dealer value 22\n", "player value 20 | dealer value 26\n", "player value 13 | dealer value 23\n", "player value 15 | dealer value 21\n", "player value 17 | dealer value 17\n", "player value 20 | dealer value 17\n", "player value 19 | dealer value 20\n", "player value 24 | dealer value 22\n", "player value 15 | dealer value 17\n", "player value 18 | dealer value 21\n", "player value 30 | dealer value 18\n", "player value 25 | dealer value 24\n", "player value 19 | dealer value 18\n", "player value 28 | dealer value 22\n", "player value 17 | dealer value 20\n", "player value 14 | dealer value 19\n", "player value 18 | dealer value 21\n", "player value 17 | dealer value 18\n", "player value 16 | dealer value 18\n", "player value 15 | dealer value 17\n", "player value 25 | dealer value 24\n", "player value 31 | dealer value 18\n", "player value 15 | dealer value 18\n", "player value 25 | dealer value 22\n", "player value 23 | dealer value 23\n", "player value 15 | dealer value 20\n", "player value 25 | dealer value 19\n", "player value 26 | dealer value 17\n", "player value 23 | dealer value 25\n", "player value 24 | dealer value 18\n", "player value 12 | dealer value 21\n", "player value 12 | dealer value 19\n", "player value 23 | dealer value 18\n", "player value 20 | dealer value 25\n", "player value 25 | dealer value 22\n", "player value 13 | dealer value 19\n", "player value 25 | dealer value 25\n", "player value 18 | dealer value 18\n", "player value 19 | dealer value 18\n", "player value 13 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 19 | dealer value 25\n", "reach 21 in 2 cards: player value 13 | dealer value 21\n", "player value 19 | dealer value 21\n", "player value 22 | dealer value 17\n", "reach 21 in 2 cards: player value 21 | dealer value 16\n", "player value 16 | dealer value 21\n", "player value 27 | dealer value 17\n", "player value 20 | dealer value 20\n", "player value 17 | dealer value 18\n", "player value 22 | dealer value 24\n", "player value 12 | dealer value 17\n", "player value 29 | dealer value 19\n", "player value 24 | dealer value 20\n", "player value 19 | dealer value 24\n", "player value 21 | dealer value 18\n", "player value 20 | dealer value 17\n", "player value 30 | dealer value 17\n", "player value 21 | dealer value 25\n", "player value 19 | dealer value 17\n", "player value 16 | dealer value 24\n", "player value 17 | dealer value 23\n", "player value 22 | dealer value 23\n", "player value 12 | dealer value 20\n", "player value 16 | dealer value 26\n", "player value 22 | dealer value 23\n", "player value 20 | dealer value 20\n", "player value 23 | dealer value 20\n", "player value 30 | dealer value 21\n", "player value 27 | dealer value 18\n", "player value 15 | dealer value 18\n", "player value 20 | dealer value 22\n", "player value 16 | dealer value 18\n", "reach 21 in 2 cards: player value 13 | dealer value 21\n", "player value 17 | dealer value 17\n", "player value 18 | dealer value 20\n", "player value 18 | dealer value 19\n", "player value 20 | dealer value 20\n", "player value 23 | dealer value 18\n", "player value 22 | dealer value 19\n", "player value 23 | dealer value 19\n", "player value 18 | dealer value 20\n", "player value 19 | dealer value 17\n", "reach 21 in 2 cards: player value 11 | dealer value 21\n", "player value 15 | dealer value 22\n", "player value 20 | dealer value 19\n", "player value 13 | dealer value 17\n", "player value 18 | dealer value 17\n", "player value 17 | dealer value 23\n", "player value 13 | dealer value 19\n", "player value 21 | dealer value 17\n", "player value 21 | dealer value 18\n", "player value 13 | dealer value 18\n", "player value 27 | dealer value 26\n", "player value 15 | dealer value 19\n", "player value 19 | dealer value 19\n", "player value 22 | dealer value 17\n", "player value 19 | dealer value 18\n", "player value 15 | dealer value 20\n", "player value 23 | dealer value 18\n", "player value 25 | dealer value 17\n", "player value 17 | dealer value 18\n", "player value 15 | dealer value 19\n", "player value 12 | dealer value 26\n", "player value 20 | dealer value 21\n", "player value 15 | dealer value 20\n", "player value 17 | dealer value 23\n", "player value 21 | dealer value 19\n", "player value 19 | dealer value 23\n", "player value 18 | dealer value 24\n", "player value 26 | dealer value 20\n", "player value 15 | dealer value 24\n", "player value 23 | dealer value 24\n", "player value 18 | dealer value 17\n", "player value 13 | dealer value 25\n", "player value 16 | dealer value 17\n", "player value 17 | dealer value 17\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 24 | dealer value 25\n", "player value 24 | dealer value 19\n", "player value 19 | dealer value 18\n", "reach 21 in 2 cards: player value 21 | dealer value 11\n", "player value 18 | dealer value 23\n", "player value 16 | dealer value 20\n", "player value 18 | dealer value 24\n", "player value 17 | dealer value 17\n", "player value 22 | dealer value 19\n", "player value 17 | dealer value 17\n", "player value 18 | dealer value 21\n", "player value 20 | dealer value 18\n", "player value 23 | dealer value 24\n", "player value 26 | dealer value 23\n", "player value 13 | dealer value 21\n", "player value 17 | dealer value 18\n", "player value 12 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 13\n", "player value 23 | dealer value 20\n", "reach 21 in 2 cards: player value 7 | dealer value 21\n", "player value 28 | dealer value 18\n", "player value 18 | dealer value 19\n", "player value 14 | dealer value 20\n", "player value 14 | dealer value 25\n", "reach 21 in 2 cards: player value 18 | dealer value 21\n", "player value 12 | dealer value 20\n", "player value 18 | dealer value 25\n", "player value 19 | dealer value 20\n", "player value 20 | dealer value 25\n", "player value 22 | dealer value 19\n", "player value 16 | dealer value 25\n", "reach 21 in 2 cards: player value 11 | dealer value 21\n", "player value 17 | dealer value 18\n", "player value 24 | dealer value 17\n", "player value 14 | dealer value 19\n", "player value 26 | dealer value 20\n", "player value 23 | dealer value 22\n", "player value 26 | dealer value 25\n", "player value 18 | dealer value 26\n", "reach 21 in 2 cards: player value 21 | dealer value 11\n", "player value 25 | dealer value 25\n", "player value 22 | dealer value 20\n", "player value 25 | dealer value 26\n", "reach 21 in 2 cards: player value 21 | dealer value 13\n", "player value 15 | dealer value 23\n", "player value 17 | dealer value 19\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 22 | dealer value 25\n", "player value 28 | dealer value 19\n", "player value 18 | dealer value 22\n", "player value 22 | dealer value 21\n", "reach 21 in 2 cards: player value 8 | dealer value 21\n", "player value 14 | dealer value 19\n", "player value 16 | dealer value 17\n", "player value 25 | dealer value 26\n", "player value 12 | dealer value 23\n", "player value 29 | dealer value 18\n", "player value 27 | dealer value 21\n", "player value 22 | dealer value 23\n", "player value 21 | dealer value 17\n", "player value 15 | dealer value 20\n", "player value 14 | dealer value 18\n", "player value 20 | dealer value 20\n", "player value 15 | dealer value 22\n", "player value 16 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 13\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 27 | dealer value 23\n", "player value 18 | dealer value 17\n", "player value 21 | dealer value 23\n", "player value 18 | dealer value 19\n", "reach 21 in 2 cards: player value 17 | dealer value 21\n", "player value 20 | dealer value 17\n", "player value 19 | dealer value 26\n", "player value 25 | dealer value 24\n", "player value 28 | dealer value 24\n", "player value 21 | dealer value 24\n", "player value 13 | dealer value 19\n", "player value 16 | dealer value 25\n", "player value 18 | dealer value 18\n", "player value 15 | dealer value 18\n", "player value 19 | dealer value 20\n", "player value 15 | dealer value 20\n", "player value 15 | dealer value 25\n", "player value 17 | dealer value 23\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "player value 20 | dealer value 20\n", "player value 15 | dealer value 18\n", "player value 28 | dealer value 20\n", "player value 22 | dealer value 21\n", "player value 16 | dealer value 24\n", "player value 24 | dealer value 20\n", "player value 22 | dealer value 18\n", "player value 15 | dealer value 23\n", "player value 20 | dealer value 22\n", "player value 26 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 14\n", "player value 20 | dealer value 20\n", "player value 19 | dealer value 23\n", "player value 29 | dealer value 19\n", "reach 21 in 2 cards: player value 17 | dealer value 21\n", "player value 22 | dealer value 20\n", "player value 25 | dealer value 20\n", "player value 13 | dealer value 17\n", "reach 21 in 2 cards: player value 11 | dealer value 21\n", "player value 26 | dealer value 18\n", "reach 21 in 2 cards: player value 12 | dealer value 21\n", "player value 20 | dealer value 18\n", "player value 21 | dealer value 22\n", "player value 31 | dealer value 20\n", "player value 23 | dealer value 18\n", "player value 23 | dealer value 20\n", "player value 26 | dealer value 18\n", "player value 15 | dealer value 17\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 22 | dealer value 22\n", "reach 21 in 2 cards: player value 21 | dealer value 6\n", "player value 19 | dealer value 22\n", "player value 20 | dealer value 24\n", "player value 18 | dealer value 18\n", "player value 21 | dealer value 24\n", "player value 20 | dealer value 20\n", "player value 18 | dealer value 18\n", "reach 21 in 2 cards: player value 21 | dealer value 13\n", "player value 20 | dealer value 18\n", "player value 13 | dealer value 18\n", "reach 21 in 2 cards: player value 4 | dealer value 21\n", "player value 17 | dealer value 23\n", "player value 19 | dealer value 20\n", "player value 19 | dealer value 18\n", "player value 13 | dealer value 23\n", "player value 20 | dealer value 18\n", "player value 20 | dealer value 20\n", "player value 20 | dealer value 18\n", "player value 20 | dealer value 18\n", "player value 16 | dealer value 19\n", "player value 20 | dealer value 19\n", "player value 15 | dealer value 19\n", "player value 26 | dealer value 17\n", "player value 14 | dealer value 25\n", "player value 16 | dealer value 19\n", "player value 14 | dealer value 21\n", "player value 18 | dealer value 21\n", "player value 16 | dealer value 23\n", "reach 21 in 2 cards: player value 12 | dealer value 21\n", "player value 20 | dealer value 17\n", "player value 20 | dealer value 22\n", "player value 20 | dealer value 20\n", "player value 16 | dealer value 26\n", "player value 20 | dealer value 24\n", "player value 16 | dealer value 26\n", "reach 21 in 2 cards: player value 17 | dealer value 21\n", "player value 17 | dealer value 17\n", "reach 21 in 2 cards: player value 21 | dealer value 20\n", "player value 19 | dealer value 20\n", "player value 16 | dealer value 17\n", "reach 21 in 2 cards: player value 21 | dealer value 10\n", "player value 21 | dealer value 19\n", "player value 21 | dealer value 26\n", "player value 12 | dealer value 25\n", "player value 19 | dealer value 19\n", "player value 12 | dealer value 17\n", "player value 19 | dealer value 19\n", "player value 22 | dealer value 21\n", "player value 20 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 11\n", "player value 22 | dealer value 22\n", "player value 19 | dealer value 17\n", "player value 21 | dealer value 17\n", "player value 26 | dealer value 18\n", "player value 18 | dealer value 18\n", "player value 30 | dealer value 17\n", "player value 26 | dealer value 25\n", "player value 18 | dealer value 24\n", "reach 21 in 2 cards: player value 9 | dealer value 21\n", "player value 14 | dealer value 20\n", "reach 21 in 2 cards: player value 15 | dealer value 21\n", "player value 13 | dealer value 23\n", "player value 19 | dealer value 23\n", "player value 17 | dealer value 20\n", "player value 16 | dealer value 18\n", "player value 14 | dealer value 24\n", "player value 28 | dealer value 17\n", "player value 13 | dealer value 21\n", "player value 19 | dealer value 25\n", "player value 15 | dealer value 26\n", "player value 19 | dealer value 22\n", "player value 18 | dealer value 20\n", "reach 21 in 2 cards: player value 21 | dealer value 15\n", "player value 24 | dealer value 19\n", "player value 22 | dealer value 20\n", "player value 14 | dealer value 23\n", "player value 16 | dealer value 20\n", "player value 20 | dealer value 19\n", "player value 20 | dealer value 20\n", "player value 17 | dealer value 17\n", "player value 12 | dealer value 18\n", "reach 21 in 2 cards: player value 19 | dealer value 21\n", "reach 21 in 2 cards: player value 21 | dealer value 14\n", "player value 19 | dealer value 22\n", "player value 23 | dealer value 17\n", "player value 12 | dealer value 19\n", "player value 22 | dealer value 25\n", "player value 19 | dealer value 17\n", "player value 20 | dealer value 19\n", "player value 20 | dealer value 23\n", "player value 20 | dealer value 17\n", "player value 20 | dealer value 26\n", "player value 17 | dealer value 20\n", "player value 16 | dealer value 18\n", "player value 22 | dealer value 24\n", "player value 24 | dealer value 22\n", "player value 22 | dealer value 22\n", "player value 21 | dealer value 21\n", "player value 15 | dealer value 18\n", "player value 20 | dealer value 19\n", "player value 18 | dealer value 18\n", "player value 20 | dealer value 25\n", "player value 18 | dealer value 19\n", "player value 13 | dealer value 21\n", "player value 20 | dealer value 21\n", "player value 26 | dealer value 18\n", "player value 17 | dealer value 23\n", "player value 22 | dealer value 18\n", "player value 20 | dealer value 20\n", "player value 22 | dealer value 20\n", "player value 20 | dealer value 19\n", "player value 18 | dealer value 23\n", "player value 21 | dealer value 20\n", "player value 13 | dealer value 23\n", "reach 21 in 2 cards: player value 21 | dealer value 12\n", "player value 18 | dealer value 19\n", "player value 21 | dealer value 23\n", "player value 20 | dealer value 26\n", "player value 18 | dealer value 22\n", "player value 13 | dealer value 19\n", "player value 22 | dealer value 19\n", "reach 21 in 2 cards: player value 21 | dealer value 21\n", "player value 18 | dealer value 18\n", "player value 20 | dealer value 26\n", "player value 16 | dealer value 20\n", "player value 14 | dealer value 22\n", "player value 15 | dealer value 17\n", "player value 22 | dealer value 17\n", "player value 20 | dealer value 18\n", "reach 21 in 2 cards: player value 15 | dealer value 21\n", "player value 16 | dealer value 17\n", "player value 20 | dealer value 17\n", "player value 14 | dealer value 17\n", "player value 17 | dealer value 24\n", "player value 13 | dealer value 22\n", "player value 12 | dealer value 19\n", "player value 18 | dealer value 17\n", "player value 15 | dealer value 20\n", "player value 22 | dealer value 22\n", "reach 21 in 2 cards: player value 20 | dealer value 21\n", "player value 15 | dealer value 19\n", "player value 20 | dealer value 18\n", "player value 17 | dealer value 19\n", "player value 14 | dealer value 19\n", "[50. 53.]\n" ] } ], "source": [ "b = BlackJackSolution()\n", "b.play(1000)" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [], "source": [ "b.savePolicy()" ] }, { "cell_type": "code", "execution_count": 105, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([407., 127., 466.])" ] }, "execution_count": 105, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = b.playWithDealer(rounds=1000)\n", "a" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: BlackJack/blackjack_solution.py ================================================ import numpy as np import pickle class BlackJackSolution: def __init__(self, lr=0.1, exp_rate=0.3): self.player_Q_Values = {} # key: [(player_value, show_card, usable_ace)][action] = value # initialise Q values | (12-21) x (1-10) x (True, False) x (1, 0) 400 in total for i in range(12, 22): for j in range(1, 11): for k in [True, False]: self.player_Q_Values[(i, j, k)] = {} for a in [1, 0]: if (i == 21) and (a == 0): self.player_Q_Values[(i, j, k)][a] = 1 else: self.player_Q_Values[(i, j, k)][a] = 0 self.player_state_action = [] self.state = (0, 0, False) # initial state self.actions = [1, 0] # 1: HIT 0: STAND self.end = False self.lr = lr self.exp_rate = exp_rate # give card @staticmethod def giveCard(): # 1 stands for ace c_list = list(range(1, 11)) + [10, 10, 10] return np.random.choice(c_list) def dealerPolicy(self, current_value, usable_ace, is_end): if current_value > 21: if usable_ace: current_value -= 10 usable_ace = False else: return current_value, usable_ace, True # HIT17 if current_value >= 17: return current_value, usable_ace, True else: card = self.giveCard() if card == 1: if current_value <= 10: return current_value + 11, True, False return current_value + 1, usable_ace, False else: return current_value + card, usable_ace, False def chooseAction(self): # if current value <= 11, always hit current_value = self.state[0] if current_value <= 11: return 1 if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) # print("random action", action) else: # greedy action v = -999 action = 0 for a in self.player_Q_Values[self.state]: if self.player_Q_Values[self.state][a] > v: action = a v = self.player_Q_Values[self.state][a] # print("greedy action", action) return action # one can only has 1 usable ace # return next state def playerNxtState(self, action): current_value = self.state[0] show_card = self.state[1] usable_ace = self.state[2] if action: # action hit card = self.giveCard() if card == 1: if current_value <= 10: current_value += 11 usable_ace = True else: current_value += 1 else: current_value += card else: # action stand self.end = True return (current_value, show_card, usable_ace) if current_value > 21: if usable_ace: current_value -= 10 usable_ace = False else: self.end = True return (current_value, show_card, usable_ace) return (current_value, show_card, usable_ace) def winner(self, player_value, dealer_value): # player 1 | draw 0 | dealer -1 winner = 0 if player_value > 21: if dealer_value > 21: # draw winner = 0 else: winner = -1 else: if dealer_value > 21: winner = 1 else: if player_value < dealer_value: winner = -1 elif player_value > dealer_value: winner = 1 else: # draw winner = 0 return winner def _giveCredit(self, player_value, dealer_value): reward = self.winner(player_value, dealer_value) # backpropagate reward for s in reversed(self.player_state_action): state, action = s[0], s[1] reward = self.player_Q_Values[state][action] + self.lr*(reward - self.player_Q_Values[state][action]) self.player_Q_Values[state][action] = round(reward, 3) def reset(self): self.player_state_action = [] self.state = (0, 0, False) # initial state self.end = False def deal2cards(self, show=False): # return value after 2 cards and usable ace value, usable_ace = 0, False cards = [self.giveCard(), self.giveCard()] if 1 in cards: value = sum(cards) + 10 usable_ace = True else: value = sum(cards) usable_ace = False if show: return value, usable_ace, cards[0] else: return value, usable_ace def play(self, rounds=1000): for i in range(rounds): if i % 1000 == 0: print("round", i) # give 2 cards dealer_value, d_usable_ace, show_card = self.deal2cards(show=True) player_value, p_usable_ace = self.deal2cards(show=False) self.state = (player_value, show_card, p_usable_ace) print("init", self.state) # judge winner after 2 cards if player_value == 21 or dealer_value == 21: # game end next else: while True: action = self.chooseAction() # state -> action if self.state[0] >= 12: state_action_pair = [self.state, action] self.player_state_action.append(state_action_pair) # update next state self.state = self.playerNxtState(action) if self.end: break # dealer's turn is_end = False while not is_end: dealer_value, d_usable_ace, is_end = self.dealerPolicy(dealer_value, d_usable_ace, is_end) # judge winner # give reward and update Q value player_value = self.state[0] print("player value {} | dealer value {}".format(player_value, dealer_value)) self._giveCredit(player_value, dealer_value) self.reset() def savePolicy(self, file="policy"): fw = open(file, 'wb') pickle.dump(self.player_Q_Values, fw) fw.close() def loadPolicy(self, file="policy"): fr = open(file, 'rb') self.player_Q_Values = pickle.load(fr) fr.close() # trained robot play against dealer def playWithDealer(self, rounds=1000): self.reset() self.loadPolicy() self.exp_rate = 0 result = np.zeros(3) # player [win, draw, lose] for _ in range(rounds): # hit 2 cards each # give 2 cards dealer_value, d_usable_ace, show_card = self.deal2cards(show=True) player_value, p_usable_ace = self.deal2cards(show=False) self.state = (player_value, show_card, p_usable_ace) # judge winner after 2 cards if player_value == 21 or dealer_value == 21: if player_value == dealer_value: result[1] += 1 elif player_value > dealer_value: result[0] += 1 else: result[2] += 1 else: # player's turn while True: action = self.chooseAction() # update next state self.state = self.playerNxtState(action) if self.end: break # dealer's turn is_end = False while not is_end: dealer_value, d_usable_ace, is_end = self.dealerPolicy(dealer_value, d_usable_ace, is_end) # judge player_value = self.state[0] # print("player value {} | dealer value {}".format(player_value, dealer_value)) w = self.winner(player_value, dealer_value) if w == 1: result[0] += 1 elif w == 0: result[1] += 1 else: result[2] += 1 self.reset() return result if __name__ == "__main__": # training b = BlackJackSolution() b.play(10000) print("Done training") # save policy b.savePolicy() # play result = b.playWithDealer(rounds=1000) print(result) ================================================ FILE: BlackJack/blackjack_test.ipynb ================================================ { "cells": [ { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pickle" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class BlackJackSolution:\n", " \n", " def __init__(self, lr=0.1, exp_rate=0.3):\n", " self.player_Q_Values = {} # key: [(player_value, show_card, usable_ace)][action] = value\n", " # initialise Q values | (12-21) x (1-10) x (True, False) x (1, 0) 400 in total\n", " for i in range(12, 22):\n", " for j in range(1, 11):\n", " for k in [True, False]:\n", " self.player_Q_Values[(i, j, k)] = {}\n", " for a in [1, 0]:\n", " if (i == 21) and (a == 0):\n", " self.player_Q_Values[(i, j, k)][a] = 1\n", " else:\n", " self.player_Q_Values[(i, j, k)][a] = 0\n", " \n", " self.player_state_action = []\n", " self.state = (0, 0, False) # initial state\n", " self.actions = [1, 0] # 1: HIT 0: STAND\n", " self.end = False\n", " self.lr = lr\n", " self.exp_rate = exp_rate\n", " \n", " # give card\n", " @staticmethod\n", " def giveCard():\n", " # 1 stands for ace\n", " c_list = list(range(1, 11)) + [10, 10, 10]\n", " return np.random.choice(c_list)\n", " \n", " def dealerPolicy(self, current_value, usable_ace, is_end):\n", " if current_value > 21:\n", " if usable_ace:\n", " current_value -= 10\n", " usable_ace = False\n", " else:\n", " return current_value, usable_ace, True\n", " # HIT17\n", " if current_value >= 17:\n", " return current_value, usable_ace, True\n", " else:\n", " card = self.giveCard()\n", " if card == 1:\n", " if current_value <= 10:\n", " return current_value+11, True, False\n", " return current_value+1, usable_ace, False\n", " else:\n", " return current_value+card, usable_ace, False\n", " \n", " def chooseAction(self):\n", " # if current value <= 11, always hit\n", " current_value = self.state[0]\n", " if current_value <= 11:\n", " return 1\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", "# print(\"random action\", action)\n", " else:\n", " # greedy action\n", " v = -999\n", " action = 0\n", " for a in self.player_Q_Values[self.state]:\n", " if self.player_Q_Values[self.state][a] > v:\n", " action = a\n", " v = self.player_Q_Values[self.state][a]\n", "# print(\"greedy action\", action)\n", " return action\n", " \n", " # one can only has 1 usable ace \n", " # return next state\n", " def playerNxtState(self, action):\n", " current_value = self.state[0]\n", " show_card = self.state[1]\n", " usable_ace = self.state[2]\n", " \n", " if action:\n", " # action hit\n", " card = self.giveCard()\n", " if card == 1:\n", " if current_value <= 10:\n", " current_value += 11\n", " usable_ace = True\n", " else:\n", " current_value += 1\n", " else:\n", " current_value += card\n", " else:\n", " # action stand\n", " self.end = True\n", " return (current_value, show_card, usable_ace)\n", " \n", " if current_value > 21:\n", " if usable_ace:\n", " current_value -= 10\n", " usable_ace = False\n", " else:\n", " self.end = True\n", " return (current_value, show_card, usable_ace)\n", " \n", " return (current_value, show_card, usable_ace)\n", " \n", " def winner(self, player_value, dealer_value):\n", " # player 1 | draw 0 | dealer -1\n", " winner = 0\n", " if player_value > 21:\n", " if dealer_value > 21:\n", " # draw\n", " winner = 0\n", " else:\n", " winner = -1\n", " else:\n", " if dealer_value > 21:\n", " winner = 1\n", " else:\n", " if player_value < dealer_value:\n", " winner = -1\n", " elif player_value > dealer_value:\n", " winner = 1\n", " else:\n", " # draw\n", " winner = 0\n", " return winner\n", " \n", " def _giveCredit(self, player_value, dealer_value):\n", " reward = self.winner(player_value, dealer_value)\n", " # backpropagate reward\n", " for s in reversed(self.player_state_action):\n", " state, action = s[0], s[1]\n", " reward = self.player_Q_Values[state][action] + self.lr*(reward - self.player_Q_Values[state][action])\n", " self.player_Q_Values[state][action] = round(reward, 3)\n", " reward = np.max(list(self.player_Q_Values[state].values())) # Q-learning\n", " \n", " def reset(self):\n", " self.player_state_action = []\n", " self.state = (0, 0, False) # initial state\n", " self.end = False\n", " \n", " def deal2cards(self, show=False):\n", " # return value after 2 cards and usable ace\n", " value, usable_ace = 0, False\n", " cards = [self.giveCard(), self.giveCard()]\n", " if 1 in cards:\n", " value = sum(cards)+10\n", " usable_ace = True\n", " else:\n", " value = sum(cards)\n", " usable_ace = False\n", " \n", " if show:\n", " return value, usable_ace, cards[0]\n", " else:\n", " return value, usable_ace\n", "\n", " def play(self, rounds=1000):\n", " for i in range(rounds):\n", " if i % 1000 == 0:\n", " print(\"round\", i)\n", " \n", " # give 2 cards\n", " dealer_value, d_usable_ace, show_card = self.deal2cards(show=True)\n", " player_value, p_usable_ace = self.deal2cards(show=False)\n", " \n", " self.state = (player_value, show_card, p_usable_ace)\n", " print(\"init\", self.state)\n", " \n", " # judge winner after 2 cards\n", " if player_value == 21 or dealer_value == 21:\n", " # game end\n", " # print(\"reach 21 in 2 cards: player value {} | dealer value {}\".format(player_value, dealer_value))\n", " next\n", " else:\n", " while True:\n", " action = self.chooseAction() # state -> action \n", " # print(\"current value {}, action {}\".format(self.state[0], action))\n", " if self.state[0] >= 12:\n", " state_action_pair = [self.state, action]\n", " # print(state_action_pair)\n", " self.player_state_action.append(state_action_pair)\n", " # update next state\n", " self.state = self.playerNxtState(action)\n", " if self.end:\n", " break \n", "\n", " # dealer's turn\n", " is_end = False\n", " while not is_end:\n", " dealer_value, d_usable_ace, is_end = self.dealerPolicy(dealer_value, d_usable_ace, is_end)\n", "\n", " # judge winner\n", " # give reward and update Q value\n", " player_value = self.state[0]\n", " print(\"player value {} | dealer value {}\".format(player_value, dealer_value))\n", " self._giveCredit(player_value, dealer_value)\n", " # print(\"player state action\", self.player_state_action)\n", " self.reset()\n", " \n", " def savePolicy(self, file=\"policy\"):\n", " fw = open(file, 'wb')\n", " pickle.dump(self.player_Q_Values, fw)\n", " fw.close()\n", "\n", " def loadPolicy(self, file=\"policy\"):\n", " fr = open(file,'rb')\n", " self.player_Q_Values = pickle.load(fr)\n", " fr.close()\n", " \n", " # trained robot play against dealer\n", " def playWithDealer(self, rounds=1000):\n", " self.reset()\n", " self.loadPolicy()\n", " self.exp_rate = 0\n", " \n", " result = np.zeros(3) # player [win, draw, lose]\n", " for _ in range(rounds):\n", " # hit 2 cards each\n", " # give 2 cards\n", " dealer_value, d_usable_ace, show_card = self.deal2cards(show=True)\n", " player_value, p_usable_ace = self.deal2cards(show=False)\n", " \n", " self.state = (player_value, show_card, p_usable_ace)\n", " \n", " # judge winner after 2 cards\n", " if player_value == 21 or dealer_value == 21:\n", " if player_value == dealer_value:\n", " result[1] += 1\n", " elif player_value > dealer_value:\n", " result[0] += 1\n", " else:\n", " result[2] += 1\n", " else:\n", " # player's turn\n", " while True:\n", " action = self.chooseAction()\n", " # update next state\n", " self.state = self.playerNxtState(action)\n", " if self.end:\n", " break \n", "\n", " # dealer's turn\n", " is_end = False\n", " while not is_end:\n", " dealer_value, d_usable_ace, is_end = self.dealerPolicy(dealer_value, d_usable_ace, is_end)\n", "\n", " # judge\n", " player_value = self.state[0]\n", " # print(\"player value {} | dealer value {}\".format(player_value, dealer_value))\n", " w = self.winner(player_value, dealer_value)\n", " if w == 1:\n", " result[0] += 1\n", " elif w == 0:\n", " result[1] += 1\n", " else:\n", " result[2] += 1\n", " self.reset()\n", " return result" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 0\n", "init (20, 9, False)\n", "player value 22 | dealer value 24\n" ] } ], "source": [ "b = BlackJackSolution()\n", "b.play(1)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "18 16 1\n", "22 29 0\n", "16 25 1\n", "13 26 1\n", "21 18 1\n", "14 23 1\n", "13 18 -1\n", "29 29 0\n", "17 18 -1\n", "28 27 0\n" ] } ], "source": [ "# winner test\n", "for _ in range(10):\n", " p_value = np.random.choice(range(12, 30))\n", " d_value = np.random.choice(range(12, 30))\n", " r = b.winner(p_value, d_value)\n", " print(p_value, d_value, r)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", "4 False\n", "14 False\n", "15 False\n", "16 False\n", "20 False\n", "20 False\n", "------------------\n", "3 False\n", "10 False\n", "19 False\n", "19 False\n", "------------------\n", "9 False\n", "11 False\n", "17 False\n", "17 False\n", "------------------\n", "7 False\n", "16 False\n", "18 False\n", "18 False\n", "------------------\n", "5 False\n", "15 False\n", "25 False\n", "25 False\n", "------------------\n", "11 True\n", "17 True\n", "17 True\n", "------------------\n", "7 False\n", "11 False\n", "14 False\n", "24 False\n", "24 False\n", "------------------\n", "10 False\n", "16 False\n", "24 False\n", "24 False\n", "------------------\n", "7 False\n", "13 False\n", "19 False\n", "19 False\n", "------------------\n", "6 False\n", "9 False\n", "16 False\n", "26 False\n", "26 False\n" ] } ], "source": [ "# test dealer policy\n", "for _ in range(10):\n", " print(\"------------------\")\n", " dealer_value, d_usable_ace, is_end = 0, False, False\n", " while not is_end:\n", " dealer_value, d_usable_ace, is_end = b.dealerPolicy(dealer_value, d_usable_ace, is_end)\n", " print(dealer_value, d_usable_ace)" ] }, { "cell_type": "code", "execution_count": 177, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "50 47\n" ] } ], "source": [ "# test deal2cards\n", "i, j = 0, 0\n", "for _ in range(1000):\n", " p, _ = b.deal2cards()\n", " d, _ = b.deal2cards()\n", " if p == 21:\n", " i += 1\n", " if d == 21:\n", " j += 1\n", "print(i, j)" ] }, { "cell_type": "code", "execution_count": 179, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(12, 10, False)\n", "False\n", "(21, 10, True)\n", "False\n" ] } ], "source": [ "# test next state\n", "b = BlackJackSolution()\n", "b.state = (19, 10, True)\n", "print(b.playerNxtState(action=1))\n", "print(b.end)\n", "\n", "b = BlackJackSolution()\n", "b.state = (11, 10, True)\n", "print(b.playerNxtState(action=1))\n", "print(b.end)" ] }, { "cell_type": "code", "execution_count": 110, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 0\n", "[(17, 8, False), 1]\n", "(18, 8, False)\n", "[(18, 8, False), 1]\n", "(21, 8, False)\n", "[(21, 8, False), 1]\n", "(27, 8, False)\n", "[(19, 8, False), 1]\n", "(22, 8, False)\n", "[(17, 10, False), 1]\n", "(22, 10, False)\n", "(13, 10, False)\n", "[(13, 10, False), 1]\n", "(17, 10, False)\n", "[(17, 10, False), 0]\n", "(17, 10, False)\n", "[(16, 10, True), 1]\n", "(14, 10, False)\n", "[(14, 10, False), 1]\n", "(17, 10, False)\n", "[(17, 10, False), 0]\n", "(17, 10, False)\n", "[(16, 10, False), 1]\n", "(26, 10, False)\n", "[(15, 7, False), 1]\n", "(25, 7, False)\n", "[(15, 10, False), 1]\n", "(16, 10, False)\n", "[(16, 10, False), 0]\n", "(16, 10, False)\n", "[(16, 8, False), 1]\n", "(26, 8, False)\n", "[(15, 4, False), 1]\n", "(25, 4, False)\n" ] } ], "source": [ "# test play\n", "b = BlackJackSolution()\n", "b.play(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Play" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 0\n", "init (9, 6, False)\n", "player value 29 | dealer value 17\n", "init (19, 3, False)\n", "player value 29 | dealer value 24\n", "init (16, 1, False)\n", "player value 23 | dealer value 20\n", "init (7, 8, False)\n", "player value 26 | dealer value 18\n", "init (17, 10, True)\n", "player value 17 | dealer value 24\n", "init (19, 10, False)\n", "player value 26 | dealer value 17\n", "init (6, 6, False)\n", "player value 30 | dealer value 23\n", "init (9, 7, False)\n", "player value 19 | dealer value 18\n", "init (13, 6, False)\n", "player value 23 | dealer value 20\n", "init (15, 8, False)\n", "player value 17 | dealer value 18\n", "init (15, 8, False)\n", "player value 29 | dealer value 18\n", "init (13, 2, False)\n", "player value 23 | dealer value 26\n", "init (15, 10, False)\n", "init (13, 8, False)\n", "player value 23 | dealer value 21\n", "init (17, 10, False)\n", "player value 21 | dealer value 22\n", "init (18, 10, True)\n", "player value 27 | dealer value 19\n", "init (4, 6, False)\n", "player value 22 | dealer value 24\n", "init (15, 10, True)\n", "player value 17 | dealer value 18\n", "init (18, 5, False)\n", "player value 27 | dealer value 23\n", "init (13, 5, False)\n", "player value 13 | dealer value 25\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (20, 10, False)\n", "player value 30 | dealer value 17\n", "init (20, 1, False)\n", "player value 24 | dealer value 20\n", "init (15, 8, False)\n", "player value 15 | dealer value 22\n", "init (12, 1, False)\n", "init (10, 3, False)\n", "player value 25 | dealer value 18\n", "init (6, 6, False)\n", "player value 25 | dealer value 19\n", "init (14, 4, False)\n", "player value 24 | dealer value 24\n", "init (15, 3, False)\n", "player value 25 | dealer value 24\n", "init (17, 1, False)\n", "init (15, 10, True)\n", "player value 19 | dealer value 20\n", "init (11, 2, False)\n", "player value 21 | dealer value 18\n", "init (14, 8, False)\n", "player value 25 | dealer value 18\n", "init (21, 2, True)\n", "init (16, 7, False)\n", "player value 25 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (16, 2, False)\n", "player value 25 | dealer value 20\n", "init (5, 3, False)\n", "player value 22 | dealer value 19\n", "init (12, 6, False)\n", "player value 18 | dealer value 20\n", "init (14, 9, False)\n", "player value 23 | dealer value 18\n", "init (9, 7, False)\n", "player value 24 | dealer value 19\n", "init (9, 2, False)\n", "player value 21 | dealer value 20\n", "init (8, 8, False)\n", "player value 25 | dealer value 19\n", "init (13, 10, False)\n", "player value 19 | dealer value 20\n", "init (6, 1, False)\n", "init (19, 8, False)\n", "player value 28 | dealer value 19\n", "init (6, 10, False)\n", "player value 26 | dealer value 20\n", "init (14, 9, False)\n", "player value 14 | dealer value 17\n", "init (17, 6, True)\n", "player value 26 | dealer value 25\n", "init (12, 10, True)\n", "player value 28 | dealer value 22\n", "init (19, 10, False)\n", "init (20, 7, False)\n", "player value 20 | dealer value 20\n", "init (7, 4, False)\n", "player value 22 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 6, False)\n", "player value 22 | dealer value 19\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 1, False)\n", "player value 21 | dealer value 19\n", "init (17, 10, False)\n", "player value 21 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "init (11, 10, False)\n", "player value 16 | dealer value 22\n", "init (18, 9, False)\n", "player value 28 | dealer value 21\n", "init (19, 10, False)\n", "player value 26 | dealer value 18\n", "init (12, 7, False)\n", "player value 16 | dealer value 17\n", "init (15, 10, False)\n", "player value 21 | dealer value 17\n", "init (8, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 8, False)\n", "player value 28 | dealer value 19\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (15, 9, False)\n", "player value 21 | dealer value 24\n", "init (12, 7, False)\n", "player value 12 | dealer value 24\n", "init (11, 1, False)\n", "player value 31 | dealer value 20\n", "init (7, 8, False)\n", "player value 26 | dealer value 20\n", "init (21, 7, True)\n", "init (14, 2, False)\n", "player value 26 | dealer value 24\n", "init (10, 5, False)\n", "player value 22 | dealer value 19\n", "init (17, 10, False)\n", "player value 23 | dealer value 24\n", "init (17, 1, True)\n", "player value 17 | dealer value 24\n", "init (20, 1, False)\n", "player value 20 | dealer value 24\n", "init (14, 6, False)\n", "player value 23 | dealer value 24\n", "init (13, 2, False)\n", "player value 13 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (16, 7, False)\n", "player value 25 | dealer value 17\n", "init (16, 3, False)\n", "player value 16 | dealer value 20\n", "init (14, 3, True)\n", "player value 22 | dealer value 24\n", "init (12, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 2, True)\n", "player value 19 | dealer value 17\n", "init (8, 5, False)\n", "player value 25 | dealer value 25\n", "init (21, 4, True)\n", "init (21, 10, True)\n", "init (9, 10, False)\n", "init (12, 8, False)\n", "player value 13 | dealer value 18\n", "init (14, 3, False)\n", "player value 24 | dealer value 20\n", "init (12, 10, False)\n", "player value 12 | dealer value 25\n", "init (10, 8, False)\n", "player value 20 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (21, 1, True)\n", "init (17, 6, False)\n", "player value 21 | dealer value 26\n", "init (18, 10, False)\n", "player value 22 | dealer value 20\n", "init (9, 10, False)\n", "init (21, 10, True)\n", "init (21, 6, True)\n", "init (16, 1, False)\n", "player value 16 | dealer value 18\n", "init (16, 10, False)\n", "player value 16 | dealer value 17\n", "init (14, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "player value 14 | dealer value 23\n", "init (21, 10, True)\n", "init (21, 7, True)\n", "init (15, 3, False)\n", "player value 25 | dealer value 22\n", "init (15, 3, False)\n", "player value 25 | dealer value 21\n", "init (17, 1, False)\n", "init (14, 9, False)\n", "player value 21 | dealer value 19\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (15, 4, False)\n", "player value 25 | dealer value 19\n", "init (19, 10, False)\n", "player value 29 | dealer value 24\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (18, 4, False)\n", "player value 24 | dealer value 22\n", "init (17, 4, False)\n", "player value 26 | dealer value 24\n", "init (14, 8, False)\n", "player value 21 | dealer value 18\n", "init (8, 7, False)\n", "player value 24 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 24\n", "init (13, 1, False)\n", "player value 26 | dealer value 17\n", "init (15, 2, False)\n", "player value 15 | dealer value 19\n", "init (15, 7, False)\n", "player value 20 | dealer value 19\n", "init (11, 10, False)\n", "player value 26 | dealer value 20\n", "init (15, 6, True)\n", "player value 21 | dealer value 22\n", "init (12, 5, False)\n", "player value 22 | dealer value 17\n", "init (9, 10, False)\n", "player value 29 | dealer value 20\n", "init (14, 2, False)\n", "player value 14 | dealer value 25\n", "init (18, 7, False)\n", "player value 28 | dealer value 18\n", "init (13, 10, False)\n", "player value 13 | dealer value 19\n", "init (15, 4, False)\n", "player value 15 | dealer value 17\n", "init (14, 1, False)\n", "player value 22 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 26\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 3, False)\n", "player value 21 | dealer value 22\n", "init (9, 8, False)\n", "player value 18 | dealer value 26\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (18, 6, False)\n", "player value 28 | dealer value 21\n", "init (9, 10, False)\n", "player value 27 | dealer value 19\n", "init (14, 10, False)\n", "init (20, 10, False)\n", "init (15, 10, False)\n", "player value 20 | dealer value 20\n", "init (8, 8, False)\n", "player value 20 | dealer value 17\n", "init (4, 10, False)\n", "player value 24 | dealer value 20\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 9, True)\n", "player value 22 | dealer value 18\n", "init (8, 2, False)\n", "player value 22 | dealer value 22\n", "init (16, 7, False)\n", "player value 16 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 23\n", "init (14, 7, False)\n", "player value 24 | dealer value 26\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (14, 3, False)\n", "player value 15 | dealer value 17\n", "init (16, 5, True)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 3, False)\n", "player value 21 | dealer value 20\n", "init (15, 9, False)\n", "player value 21 | dealer value 19\n", "init (10, 8, False)\n", "player value 18 | dealer value 18\n", "init (20, 5, False)\n", "player value 30 | dealer value 23\n", "init (12, 10, False)\n", "player value 15 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (8, 7, False)\n", "player value 22 | dealer value 25\n", "init (15, 5, False)\n", "player value 25 | dealer value 18\n", "init (15, 6, True)\n", "player value 28 | dealer value 26\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (6, 10, False)\n", "player value 19 | dealer value 20\n", "init (7, 8, False)\n", "player value 17 | dealer value 17\n", "init (15, 10, False)\n", "player value 27 | dealer value 22\n", "init (5, 10, False)\n", "player value 23 | dealer value 17\n", "init (17, 10, False)\n", "player value 25 | dealer value 20\n", "init (19, 1, False)\n", "player value 27 | dealer value 18\n", "init (21, 2, True)\n", "init (18, 10, False)\n", "player value 28 | dealer value 24\n", "init (15, 2, False)\n", "player value 22 | dealer value 18\n", "init (13, 8, False)\n", "player value 23 | dealer value 22\n", "init (17, 4, False)\n", "player value 17 | dealer value 17\n", "init (7, 7, False)\n", "player value 18 | dealer value 20\n", "init (8, 6, False)\n", "player value 21 | dealer value 21\n", "init (20, 4, False)\n", "player value 30 | dealer value 19\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 8, True)\n", "player value 17 | dealer value 25\n", "init (14, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "init (12, 10, False)\n", "player value 24 | dealer value 20\n", "init (19, 1, False)\n", "init (13, 10, True)\n", "player value 17 | dealer value 18\n", "init (8, 5, False)\n", "player value 17 | dealer value 22\n", "init (20, 3, False)\n", "player value 21 | dealer value 20\n", "init (14, 8, False)\n", "player value 17 | dealer value 18\n", "init (7, 10, False)\n", "player value 22 | dealer value 25\n", "init (14, 10, False)\n", "player value 14 | dealer value 18\n", "init (12, 10, False)\n", "player value 17 | dealer value 19\n", "init (21, 8, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 23\n", "init (12, 8, False)\n", "player value 12 | dealer value 18\n", "init (13, 4, False)\n", "player value 28 | dealer value 19\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (16, 1, False)\n", "player value 26 | dealer value 18\n", "init (13, 2, False)\n", "player value 23 | dealer value 17\n", "init (18, 7, True)\n", "player value 21 | dealer value 17\n", "init (18, 10, True)\n", "player value 28 | dealer value 21\n", "init (20, 5, False)\n", "player value 27 | dealer value 24\n", "init (13, 1, False)\n", "player value 23 | dealer value 19\n", "init (16, 9, True)\n", "player value 20 | dealer value 23\n", "init (5, 9, False)\n", "player value 13 | dealer value 19\n", "init (16, 10, False)\n", "player value 16 | dealer value 23\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 22\n", "init (13, 10, False)\n", "player value 22 | dealer value 22\n", "init (19, 3, False)\n", "player value 19 | dealer value 26\n", "init (15, 8, False)\n", "player value 15 | dealer value 19\n", "init (14, 5, True)\n", "player value 12 | dealer value 25\n", "init (18, 6, False)\n", "player value 18 | dealer value 26\n", "init (14, 2, False)\n", "player value 14 | dealer value 17\n", "init (14, 7, False)\n", "player value 24 | dealer value 17\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 2, False)\n", "player value 24 | dealer value 21\n", "init (11, 8, False)\n", "player value 23 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 2, False)\n", "player value 30 | dealer value 18\n", "init (15, 9, True)\n", "player value 26 | dealer value 19\n", "init (14, 1, False)\n", "init (18, 10, False)\n", "player value 21 | dealer value 20\n", "init (18, 10, True)\n", "player value 18 | dealer value 18\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (10, 2, False)\n", "player value 14 | dealer value 22\n", "init (12, 7, False)\n", "player value 12 | dealer value 24\n", "init (19, 4, False)\n", "player value 23 | dealer value 25\n", "init (12, 4, False)\n", "player value 18 | dealer value 17\n", "init (13, 5, False)\n", "player value 13 | dealer value 21\n", "init (21, 2, True)\n", "init (16, 4, False)\n", "player value 26 | dealer value 23\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (8, 10, False)\n", "player value 28 | dealer value 24\n", "init (21, 10, True)\n", "init (14, 3, True)\n", "player value 14 | dealer value 19\n", "init (10, 2, False)\n", "player value 19 | dealer value 22\n", "init (19, 3, False)\n", "player value 19 | dealer value 21\n", "init (7, 8, False)\n", "player value 17 | dealer value 21\n", "init (20, 6, False)\n", "player value 30 | dealer value 26\n", "init (21, 6, True)\n", "init (13, 3, True)\n", "player value 21 | dealer value 24\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (7, 5, False)\n", "player value 19 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "player value 14 | dealer value 20\n", "init (12, 2, False)\n", "player value 25 | dealer value 22\n", "init (8, 7, False)\n", "player value 19 | dealer value 21\n", "init (18, 10, True)\n", "player value 18 | dealer value 26\n", "init (6, 10, False)\n", "player value 23 | dealer value 19\n", "init (17, 4, False)\n", "player value 17 | dealer value 20\n", "init (9, 10, False)\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (18, 1, False)\n", "player value 18 | dealer value 21\n", "init (17, 9, False)\n", "player value 27 | dealer value 19\n", "init (16, 4, False)\n", "player value 16 | dealer value 17\n", "init (18, 5, False)\n", "player value 23 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (15, 7, False)\n", "player value 25 | dealer value 21\n", "init (17, 10, False)\n", "init (12, 5, False)\n", "player value 12 | dealer value 24\n", "init (19, 5, True)\n", "player value 26 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (7, 7, False)\n", "player value 26 | dealer value 19\n", "init (13, 7, True)\n", "player value 13 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (9, 3, False)\n", "player value 30 | dealer value 20\n", "init (15, 9, False)\n", "player value 17 | dealer value 17\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (15, 6, False)\n", "player value 25 | dealer value 24\n", "init (17, 5, True)\n", "player value 23 | dealer value 23\n", "init (12, 3, False)\n", "player value 30 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 5, True)\n", "player value 23 | dealer value 22\n", "init (10, 10, False)\n", "player value 16 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 20\n", "init (13, 4, False)\n", "player value 13 | dealer value 20\n", "init (17, 4, False)\n", "player value 27 | dealer value 17\n", "init (6, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, True)\n", "init (14, 10, True)\n", "init (17, 5, False)\n", "player value 17 | dealer value 24\n", "init (15, 4, False)\n", "player value 25 | dealer value 18\n", "init (10, 9, False)\n", "player value 17 | dealer value 17\n", "init (13, 10, False)\n", "player value 28 | dealer value 17\n", "init (10, 10, False)\n", "player value 21 | dealer value 20\n", "init (13, 5, False)\n", "player value 16 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (21, 10, True)\n", "init (12, 5, False)\n", "player value 12 | dealer value 22\n", "init (13, 6, False)\n", "player value 22 | dealer value 22\n", "init (15, 9, False)\n", "player value 30 | dealer value 18\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (15, 9, False)\n", "player value 22 | dealer value 20\n", "init (8, 10, False)\n", "player value 15 | dealer value 20\n", "init (17, 9, True)\n", "player value 17 | dealer value 24\n", "init (17, 6, False)\n", "player value 27 | dealer value 26\n", "init (8, 1, False)\n", "player value 28 | dealer value 19\n", "init (14, 10, False)\n", "player value 14 | dealer value 17\n", "init (10, 10, False)\n", "player value 12 | dealer value 19\n", "init (18, 7, False)\n", "player value 28 | dealer value 25\n", "init (16, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 7, True)\n", "player value 14 | dealer value 21\n", "init (17, 4, False)\n", "player value 17 | dealer value 20\n", "init (21, 10, True)\n", "init (13, 10, False)\n", "player value 25 | dealer value 21\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 10, False)\n", "player value 21 | dealer value 18\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (9, 10, False)\n", "player value 19 | dealer value 18\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (7, 8, False)\n", "player value 23 | dealer value 17\n", "init (14, 6, False)\n", "player value 22 | dealer value 24\n", "init (17, 7, False)\n", "player value 17 | dealer value 24\n", "init (14, 10, False)\n", "player value 23 | dealer value 23\n", "init (15, 7, False)\n", "player value 15 | dealer value 26\n", "init (13, 6, False)\n", "player value 26 | dealer value 20\n", "init (16, 4, False)\n", "player value 26 | dealer value 19\n", "init (10, 7, False)\n", "player value 14 | dealer value 17\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (9, 5, False)\n", "player value 17 | dealer value 18\n", "init (15, 10, True)\n", "player value 15 | dealer value 17\n", "init (15, 5, False)\n", "player value 15 | dealer value 19\n", "init (17, 1, True)\n", "init (21, 2, True)\n", "init (17, 4, False)\n", "player value 25 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (10, 3, False)\n", "player value 24 | dealer value 18\n", "init (13, 4, False)\n", "player value 18 | dealer value 23\n", "init (12, 10, False)\n", "player value 28 | dealer value 20\n", "init (21, 6, True)\n", "init (9, 10, False)\n", "player value 29 | dealer value 26\n", "init (14, 2, False)\n", "player value 14 | dealer value 21\n", "init (5, 9, False)\n", "player value 22 | dealer value 22\n", "init (20, 4, False)\n", "player value 22 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (21, 10, True)\n", "init (18, 2, False)\n", "player value 21 | dealer value 18\n", "init (14, 10, False)\n", "player value 22 | dealer value 26\n", "init (9, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 1, False)\n", "player value 18 | dealer value 18\n", "init (14, 10, False)\n", "player value 15 | dealer value 20\n", "init (7, 7, False)\n", "player value 27 | dealer value 17\n", "init (13, 2, False)\n", "player value 30 | dealer value 25\n", "init (9, 9, False)\n", "player value 20 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 24\n", "init (21, 9, True)\n", "init (10, 9, False)\n", "player value 17 | dealer value 19\n", "init (13, 3, False)\n", "player value 23 | dealer value 19\n", "init (15, 5, False)\n", "player value 22 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 22 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "init (13, 8, False)\n", "player value 23 | dealer value 23\n", "init (14, 4, False)\n", "player value 14 | dealer value 24\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (12, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (12, 4, False)\n", "player value 20 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 24\n", "init (11, 8, False)\n", "player value 15 | dealer value 17\n", "init (16, 10, False)\n", "player value 22 | dealer value 22\n", "init (17, 5, False)\n", "player value 17 | dealer value 17\n", "init (14, 8, False)\n", "player value 18 | dealer value 23\n", "init (21, 10, True)\n", "init (16, 6, False)\n", "player value 16 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (14, 2, False)\n", "player value 14 | dealer value 19\n", "init (17, 10, True)\n", "player value 17 | dealer value 20\n", "init (5, 10, False)\n", "player value 15 | dealer value 22\n", "init (17, 8, False)\n", "player value 17 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (13, 10, True)\n", "player value 21 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (16, 8, False)\n", "player value 16 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 17\n", "init (15, 9, True)\n", "player value 15 | dealer value 20\n", "init (19, 7, True)\n", "player value 12 | dealer value 18\n", "init (14, 6, False)\n", "player value 18 | dealer value 21\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (12, 10, False)\n", "player value 13 | dealer value 25\n", "init (11, 7, False)\n", "player value 22 | dealer value 17\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (20, 2, False)\n", "player value 23 | dealer value 19\n", "init (13, 6, False)\n", "player value 29 | dealer value 21\n", "init (18, 5, False)\n", "player value 28 | dealer value 25\n", "init (7, 10, False)\n", "player value 15 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 22\n", "init (15, 10, False)\n", "player value 19 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 21\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (13, 3, False)\n", "player value 13 | dealer value 20\n", "init (15, 6, False)\n", "player value 18 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 2, False)\n", "player value 15 | dealer value 20\n", "init (17, 9, False)\n", "player value 17 | dealer value 22\n", "init (20, 8, True)\n", "player value 18 | dealer value 20\n", "init (14, 6, False)\n", "player value 19 | dealer value 22\n", "init (13, 7, True)\n", "player value 24 | dealer value 26\n", "init (11, 3, False)\n", "player value 17 | dealer value 21\n", "init (21, 7, True)\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (16, 7, True)\n", "player value 16 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (21, 2, True)\n", "init (15, 1, True)\n", "player value 26 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 1, False)\n", "player value 12 | dealer value 17\n", "init (17, 3, False)\n", "player value 27 | dealer value 25\n", "init (12, 5, False)\n", "player value 12 | dealer value 17\n", "init (13, 2, False)\n", "player value 23 | dealer value 26\n", "init (12, 4, False)\n", "player value 25 | dealer value 21\n", "init (12, 10, True)\n", "player value 18 | dealer value 22\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (21, 10, True)\n", "init (14, 4, False)\n", "player value 14 | dealer value 19\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (7, 8, False)\n", "player value 23 | dealer value 17\n", "init (20, 1, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (16, 9, False)\n", "player value 16 | dealer value 19\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (14, 5, False)\n", "player value 24 | dealer value 21\n", "init (5, 10, False)\n", "player value 15 | dealer value 19\n", "init (17, 3, False)\n", "player value 27 | dealer value 18\n", "init (20, 1, False)\n", "init (21, 7, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (10, 7, False)\n", "player value 17 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 18\n", "init (15, 4, True)\n", "player value 15 | dealer value 22\n", "init (9, 9, False)\n", "player value 26 | dealer value 17\n", "init (12, 9, False)\n", "player value 15 | dealer value 20\n", "init (11, 4, False)\n", "player value 30 | dealer value 22\n", "init (8, 4, False)\n", "player value 18 | dealer value 23\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (7, 10, False)\n", "player value 19 | dealer value 18\n", "init (21, 4, True)\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (21, 2, True)\n", "init (12, 6, False)\n", "player value 22 | dealer value 25\n", "init (18, 4, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (11, 3, False)\n", "player value 26 | dealer value 26\n", "init (20, 3, True)\n", "player value 22 | dealer value 20\n", "init (8, 10, False)\n", "player value 13 | dealer value 20\n", "init (15, 1, False)\n", "player value 15 | dealer value 17\n", "init (19, 9, False)\n", "player value 22 | dealer value 19\n", "init (8, 9, False)\n", "player value 20 | dealer value 20\n", "init (16, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 5, False)\n", "player value 14 | dealer value 25\n", "init (13, 4, False)\n", "player value 18 | dealer value 22\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 20\n", "init (12, 7, False)\n", "player value 12 | dealer value 17\n", "init (12, 2, False)\n", "player value 12 | dealer value 22\n", "init (12, 10, False)\n", "player value 25 | dealer value 21\n", "init (12, 6, False)\n", "player value 12 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (14, 9, False)\n", "player value 24 | dealer value 26\n", "init (7, 8, False)\n", "player value 21 | dealer value 18\n", "init (6, 9, False)\n", "player value 16 | dealer value 19\n", "init (14, 10, False)\n", "init (17, 10, False)\n", "player value 23 | dealer value 20\n", "init (6, 6, False)\n", "player value 25 | dealer value 21\n", "init (5, 9, False)\n", "player value 15 | dealer value 21\n", "init (17, 10, False)\n", "player value 27 | dealer value 18\n", "init (13, 9, False)\n", "player value 18 | dealer value 19\n", "init (16, 4, False)\n", "player value 23 | dealer value 25\n", "init (16, 2, True)\n", "player value 26 | dealer value 23\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (8, 10, False)\n", "player value 26 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 24\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (10, 7, False)\n", "player value 13 | dealer value 18\n", "init (7, 8, False)\n", "player value 22 | dealer value 17\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (10, 9, False)\n", "player value 26 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (12, 6, False)\n", "player value 22 | dealer value 17\n", "init (14, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 10, False)\n", "player value 19 | dealer value 17\n", "init (14, 10, True)\n", "player value 18 | dealer value 20\n", "init (10, 4, False)\n", "player value 15 | dealer value 23\n", "init (16, 2, False)\n", "player value 19 | dealer value 20\n", "init (5, 10, False)\n", "player value 15 | dealer value 25\n", "init (12, 7, False)\n", "player value 20 | dealer value 18\n", "init (6, 3, False)\n", "player value 21 | dealer value 22\n", "init (15, 5, False)\n", "player value 15 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 17\n", "init (6, 2, False)\n", "player value 28 | dealer value 19\n", "init (16, 5, False)\n", "player value 25 | dealer value 25\n", "init (14, 10, False)\n", "player value 14 | dealer value 25\n", "init (9, 6, False)\n", "player value 23 | dealer value 22\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (14, 2, False)\n", "player value 22 | dealer value 22\n", "init (16, 10, True)\n", "player value 26 | dealer value 26\n", "init (17, 3, False)\n", "player value 20 | dealer value 20\n", "init (15, 9, False)\n", "player value 15 | dealer value 23\n", "init (9, 3, False)\n", "player value 19 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 19\n", "init (12, 10, False)\n", "init (21, 1, True)\n", "init (10, 2, False)\n", "player value 27 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (11, 2, False)\n", "player value 21 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 23\n", "init (17, 3, False)\n", "player value 17 | dealer value 19\n", "init (13, 2, False)\n", "player value 24 | dealer value 22\n", "init (16, 7, True)\n", "player value 16 | dealer value 22\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (17, 5, True)\n", "player value 17 | dealer value 18\n", "init (14, 8, True)\n", "player value 16 | dealer value 18\n", "init (15, 1, True)\n", "player value 20 | dealer value 20\n", "init (16, 4, False)\n", "player value 25 | dealer value 24\n", "init (11, 10, False)\n", "player value 26 | dealer value 17\n", "init (20, 9, True)\n", "player value 20 | dealer value 20\n", "init (12, 6, False)\n", "player value 19 | dealer value 20\n", "init (17, 10, False)\n", "player value 19 | dealer value 25\n", "init (10, 5, False)\n", "player value 20 | dealer value 23\n", "init (15, 10, False)\n", "player value 15 | dealer value 26\n", "init (18, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (15, 2, False)\n", "player value 19 | dealer value 21\n", "init (10, 10, False)\n", "player value 20 | dealer value 19\n", "init (18, 10, False)\n", "player value 24 | dealer value 20\n", "init (17, 5, False)\n", "player value 27 | dealer value 23\n", "init (17, 7, True)\n", "player value 15 | dealer value 25\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (20, 10, True)\n", "player value 20 | dealer value 21\n", "init (12, 4, False)\n", "player value 12 | dealer value 20\n", "init (11, 8, False)\n", "player value 14 | dealer value 19\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 9, False)\n", "player value 23 | dealer value 17\n", "init (7, 5, False)\n", "player value 20 | dealer value 19\n", "init (10, 6, False)\n", "player value 30 | dealer value 18\n", "init (10, 8, False)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 28 | dealer value 18\n", "init (11, 6, False)\n", "player value 19 | dealer value 17\n", "init (7, 10, False)\n", "player value 27 | dealer value 20\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 7, True)\n", "player value 20 | dealer value 17\n", "init (21, 10, True)\n", "init (18, 10, True)\n", "init (5, 1, False)\n", "player value 14 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (15, 7, False)\n", "player value 15 | dealer value 18\n", "init (16, 10, False)\n", "player value 17 | dealer value 17\n", "init (12, 2, False)\n", "player value 12 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (11, 3, False)\n", "player value 18 | dealer value 21\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (16, 6, True)\n", "player value 16 | dealer value 19\n", "init (21, 10, True)\n", "init (12, 6, False)\n", "player value 22 | dealer value 25\n", "init (9, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (9, 4, False)\n", "player value 24 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (11, 6, False)\n", "player value 27 | dealer value 26\n", "init (11, 10, False)\n", "player value 31 | dealer value 20\n", "init (21, 5, True)\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (12, 6, False)\n", "player value 30 | dealer value 21\n", "init (17, 8, False)\n", "player value 17 | dealer value 19\n", "init (10, 10, False)\n", "player value 19 | dealer value 24\n", "init (12, 10, False)\n", "player value 14 | dealer value 18\n", "init (7, 10, False)\n", "init (9, 10, False)\n", "player value 19 | dealer value 25\n", "init (17, 5, False)\n", "player value 27 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (6, 2, False)\n", "player value 27 | dealer value 19\n", "init (13, 5, False)\n", "player value 19 | dealer value 21\n", "init (8, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 9, False)\n", "player value 12 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 5, False)\n", "player value 12 | dealer value 25\n", "init (16, 2, False)\n", "player value 16 | dealer value 18\n", "init (13, 8, False)\n", "player value 13 | dealer value 18\n", "init (10, 10, False)\n", "player value 21 | dealer value 18\n", "init (11, 9, False)\n", "player value 21 | dealer value 18\n", "init (16, 9, False)\n", "player value 24 | dealer value 17\n", "init (11, 10, False)\n", "player value 18 | dealer value 20\n", "init (19, 7, False)\n", "player value 29 | dealer value 21\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (18, 4, True)\n", "player value 13 | dealer value 24\n", "init (21, 10, True)\n", "init (12, 10, False)\n", "player value 28 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 22\n", "init (11, 5, False)\n", "player value 14 | dealer value 20\n", "init (11, 6, False)\n", "player value 21 | dealer value 17\n", "init (8, 6, False)\n", "player value 21 | dealer value 20\n", "init (15, 10, False)\n", "player value 28 | dealer value 20\n", "init (17, 5, False)\n", "player value 17 | dealer value 17\n", "init (8, 3, False)\n", "player value 21 | dealer value 21\n", "init (19, 1, False)\n", "player value 19 | dealer value 18\n", "init (20, 6, False)\n", "player value 22 | dealer value 22\n", "init (11, 2, False)\n", "player value 17 | dealer value 23\n", "init (21, 6, True)\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (17, 9, False)\n", "player value 22 | dealer value 18\n", "init (16, 4, False)\n", "player value 22 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (18, 8, False)\n", "player value 18 | dealer value 19\n", "init (14, 9, False)\n", "player value 14 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (16, 8, False)\n", "player value 22 | dealer value 24\n", "init (14, 9, False)\n", "player value 20 | dealer value 19\n", "init (12, 7, False)\n", "player value 22 | dealer value 22\n", "init (12, 3, False)\n", "player value 12 | dealer value 23\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (6, 8, False)\n", "player value 20 | dealer value 22\n", "init (18, 3, False)\n", "player value 27 | dealer value 25\n", "init (17, 9, False)\n", "player value 17 | dealer value 24\n", "init (18, 3, True)\n", "player value 14 | dealer value 18\n", "init (19, 6, False)\n", "player value 24 | dealer value 22\n", "init (21, 10, True)\n", "init (10, 6, False)\n", "player value 30 | dealer value 19\n", "init (12, 4, True)\n", "player value 27 | dealer value 21\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (20, 7, True)\n", "player value 20 | dealer value 26\n", "init (16, 9, False)\n", "player value 26 | dealer value 19\n", "init (8, 5, False)\n", "player value 16 | dealer value 19\n", "init (14, 10, False)\n", "player value 23 | dealer value 19\n", "init (17, 2, True)\n", "player value 26 | dealer value 19\n", "init (18, 5, False)\n", "player value 27 | dealer value 23\n", "init (8, 10, False)\n", "player value 20 | dealer value 22\n", "init (4, 2, False)\n", "player value 23 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 8, False)\n", "player value 25 | dealer value 18\n", "init (15, 6, False)\n", "player value 25 | dealer value 21\n", "init (12, 10, True)\n", "player value 17 | dealer value 19\n", "init (19, 10, False)\n", "init (18, 10, False)\n", "player value 18 | dealer value 23\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (8, 1, False)\n", "player value 21 | dealer value 18\n", "init (21, 8, True)\n", "init (13, 5, False)\n", "player value 17 | dealer value 25\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (20, 3, True)\n", "player value 21 | dealer value 25\n", "init (15, 1, False)\n", "player value 30 | dealer value 17\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (21, 4, True)\n", "init (13, 9, False)\n", "player value 13 | dealer value 18\n", "init (19, 9, False)\n", "player value 29 | dealer value 19\n", "init (7, 10, False)\n", "player value 22 | dealer value 17\n", "init (19, 10, True)\n", "player value 19 | dealer value 22\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (12, 4, True)\n", "player value 14 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 24\n", "init (17, 5, False)\n", "player value 17 | dealer value 24\n", "init (17, 2, False)\n", "player value 17 | dealer value 17\n", "init (18, 1, False)\n", "player value 18 | dealer value 18\n", "init (13, 2, False)\n", "player value 13 | dealer value 26\n", "init (16, 7, False)\n", "player value 23 | dealer value 17\n", "init (13, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 10, False)\n", "player value 25 | dealer value 22\n", "init (16, 7, False)\n", "player value 26 | dealer value 17\n", "init (14, 3, False)\n", "player value 21 | dealer value 23\n", "init (8, 3, False)\n", "player value 13 | dealer value 17\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (12, 8, False)\n", "player value 22 | dealer value 25\n", "init (18, 6, False)\n", "player value 18 | dealer value 22\n", "init (10, 8, False)\n", "player value 16 | dealer value 21\n", "init (13, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 10, False)\n", "player value 20 | dealer value 22\n", "init (9, 3, False)\n", "player value 23 | dealer value 17\n", "init (13, 4, False)\n", "player value 15 | dealer value 23\n", "init (20, 1, False)\n", "init (10, 3, False)\n", "player value 21 | dealer value 20\n", "init (13, 3, False)\n", "player value 18 | dealer value 26\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (21, 6, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (18, 5, True)\n", "player value 21 | dealer value 19\n", "init (21, 2, True)\n", "init (21, 10, True)\n", "init (14, 3, False)\n", "player value 21 | dealer value 23\n", "init (5, 4, False)\n", "player value 20 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 24\n", "init (9, 4, False)\n", "player value 28 | dealer value 18\n", "init (18, 4, False)\n", "player value 18 | dealer value 20\n", "init (12, 1, False)\n", "player value 22 | dealer value 17\n", "init (17, 7, True)\n", "player value 16 | dealer value 25\n", "init (16, 10, False)\n", "player value 26 | dealer value 23\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (8, 3, False)\n", "player value 20 | dealer value 25\n", "init (16, 2, False)\n", "player value 16 | dealer value 19\n", "init (12, 10, False)\n", "player value 21 | dealer value 18\n", "init (15, 8, False)\n", "player value 19 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 8, False)\n", "player value 15 | dealer value 19\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (10, 2, False)\n", "player value 28 | dealer value 21\n", "init (12, 10, False)\n", "player value 19 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 10, False)\n", "player value 23 | dealer value 17\n", "init (9, 3, False)\n", "player value 29 | dealer value 20\n", "init (17, 2, False)\n", "player value 17 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 2, True)\n", "player value 19 | dealer value 19\n", "init (15, 2, True)\n", "player value 17 | dealer value 22\n", "init (7, 10, False)\n", "player value 17 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (14, 6, False)\n", "player value 22 | dealer value 19\n", "init (12, 10, True)\n", "init (13, 1, False)\n", "player value 13 | dealer value 18\n", "init (13, 10, False)\n", "player value 21 | dealer value 21\n", "init (14, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 1, False)\n", "player value 19 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (16, 1, False)\n", "player value 16 | dealer value 25\n", "init (11, 10, False)\n", "player value 25 | dealer value 26\n", "init (9, 6, False)\n", "player value 19 | dealer value 21\n", "init (12, 10, False)\n", "player value 19 | dealer value 20\n", "init (8, 1, False)\n", "player value 23 | dealer value 17\n", "init (12, 10, False)\n", "player value 25 | dealer value 20\n", "init (21, 5, True)\n", "init (17, 1, True)\n", "player value 20 | dealer value 18\n", "init (17, 7, False)\n", "player value 17 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "player value 25 | dealer value 20\n", "init (9, 9, False)\n", "player value 16 | dealer value 26\n", "init (13, 2, False)\n", "player value 13 | dealer value 17\n", "init (17, 9, True)\n", "player value 23 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (10, 6, False)\n", "player value 15 | dealer value 20\n", "init (14, 3, False)\n", "player value 17 | dealer value 19\n", "init (18, 9, False)\n", "player value 28 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 26\n", "init (19, 9, True)\n", "player value 17 | dealer value 19\n", "init (5, 1, False)\n", "init (14, 10, False)\n", "player value 26 | dealer value 18\n", "init (20, 6, False)\n", "player value 30 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 21\n", "init (13, 10, False)\n", "player value 23 | dealer value 17\n", "init (12, 9, False)\n", "player value 22 | dealer value 17\n", "init (15, 1, False)\n", "player value 20 | dealer value 21\n", "init (16, 2, False)\n", "player value 23 | dealer value 17\n", "init (17, 4, False)\n", "player value 27 | dealer value 18\n", "init (13, 10, False)\n", "init (12, 9, False)\n", "player value 16 | dealer value 22\n", "init (16, 4, True)\n", "player value 26 | dealer value 19\n", "init (16, 2, False)\n", "player value 16 | dealer value 22\n", "init (20, 9, True)\n", "player value 20 | dealer value 17\n", "init (13, 8, False)\n", "player value 23 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (21, 3, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (16, 10, False)\n", "player value 26 | dealer value 19\n", "init (10, 7, False)\n", "player value 18 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (9, 10, False)\n", "player value 20 | dealer value 21\n", "init (13, 1, False)\n", "init (7, 4, False)\n", "player value 23 | dealer value 19\n", "init (11, 8, False)\n", "player value 21 | dealer value 17\n", "init (12, 7, True)\n", "player value 22 | dealer value 18\n", "init (17, 5, True)\n", "player value 17 | dealer value 19\n", "init (13, 7, False)\n", "player value 30 | dealer value 18\n", "init (8, 5, False)\n", "player value 24 | dealer value 17\n", "init (14, 3, False)\n", "player value 20 | dealer value 23\n", "init (12, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 5, False)\n", "player value 26 | dealer value 18\n", "init (10, 7, False)\n", "player value 19 | dealer value 17\n", "init (16, 8, False)\n", "player value 26 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 1, False)\n", "player value 16 | dealer value 17\n", "init (9, 7, False)\n", "player value 19 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 23\n", "init (19, 5, True)\n", "player value 25 | dealer value 18\n", "init (13, 10, False)\n", "player value 19 | dealer value 19\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (13, 6, False)\n", "player value 23 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (12, 10, False)\n", "player value 19 | dealer value 23\n", "init (16, 6, True)\n", "player value 16 | dealer value 25\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (12, 9, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (17, 9, False)\n", "player value 17 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (17, 2, False)\n", "player value 17 | dealer value 17\n", "init (11, 1, False)\n", "player value 21 | dealer value 18\n", "init (5, 7, False)\n", "player value 12 | dealer value 24\n", "init (11, 5, False)\n", "player value 15 | dealer value 19\n", "init (21, 7, True)\n", "init (15, 10, True)\n", "player value 18 | dealer value 18\n", "init (8, 10, False)\n", "player value 26 | dealer value 20\n", "init (13, 10, False)\n", "player value 22 | dealer value 20\n", "init (21, 1, True)\n", "init (18, 8, False)\n", "player value 25 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (12, 7, False)\n", "player value 12 | dealer value 24\n", "init (14, 2, False)\n", "player value 25 | dealer value 23\n", "init (17, 9, False)\n", "player value 17 | dealer value 19\n", "init (17, 10, True)\n", "player value 21 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "init (17, 8, False)\n", "player value 17 | dealer value 20\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (15, 1, True)\n", "init (12, 6, False)\n", "player value 20 | dealer value 19\n", "init (17, 9, False)\n", "player value 17 | dealer value 18\n", "init (17, 4, False)\n", "player value 25 | dealer value 20\n", "init (17, 10, True)\n", "player value 17 | dealer value 20\n", "init (18, 7, False)\n", "player value 22 | dealer value 21\n", "init (17, 3, True)\n", "player value 17 | dealer value 23\n", "init (21, 5, True)\n", "init (10, 10, False)\n", "player value 18 | dealer value 24\n", "init (18, 6, False)\n", "player value 18 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (14, 10, False)\n", "player value 17 | dealer value 17\n", "init (13, 3, False)\n", "player value 23 | dealer value 19\n", "init (13, 1, False)\n", "player value 20 | dealer value 21\n", "init (16, 8, False)\n", "player value 16 | dealer value 19\n", "init (9, 6, False)\n", "player value 18 | dealer value 21\n", "init (13, 2, False)\n", "player value 19 | dealer value 22\n", "init (4, 9, False)\n", "player value 23 | dealer value 22\n", "init (14, 5, False)\n", "player value 14 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (8, 10, False)\n", "player value 18 | dealer value 18\n", "init (12, 3, False)\n", "player value 12 | dealer value 17\n", "init (7, 9, False)\n", "player value 19 | dealer value 23\n", "init (12, 9, False)\n", "player value 24 | dealer value 19\n", "init (15, 4, False)\n", "player value 25 | dealer value 17\n", "init (4, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 6, True)\n", "player value 19 | dealer value 25\n", "init (17, 2, False)\n", "player value 26 | dealer value 21\n", "init (17, 6, False)\n", "player value 27 | dealer value 21\n", "init (19, 10, True)\n", "player value 19 | dealer value 25\n", "init (5, 1, False)\n", "player value 16 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 4, False)\n", "player value 16 | dealer value 23\n", "init (16, 3, False)\n", "player value 19 | dealer value 21\n", "init (14, 9, False)\n", "player value 14 | dealer value 24\n", "init (17, 1, False)\n", "player value 27 | dealer value 19\n", "init (16, 8, True)\n", "player value 26 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 19\n", "init (12, 2, False)\n", "player value 17 | dealer value 20\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 7, True)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (5, 10, False)\n", "player value 15 | dealer value 17\n", "init (11, 4, False)\n", "player value 24 | dealer value 17\n", "init (14, 10, False)\n", "player value 14 | dealer value 19\n", "init (15, 10, False)\n", "player value 19 | dealer value 17\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (13, 9, False)\n", "player value 19 | dealer value 19\n", "init (11, 2, False)\n", "player value 21 | dealer value 21\n", "init (6, 10, False)\n", "player value 18 | dealer value 26\n", "init (12, 6, False)\n", "player value 22 | dealer value 22\n", "init (14, 1, False)\n", "player value 14 | dealer value 21\n", "init (17, 1, False)\n", "player value 17 | dealer value 22\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (11, 7, False)\n", "player value 24 | dealer value 18\n", "init (13, 1, False)\n", "init (20, 10, False)\n", "player value 30 | dealer value 17\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (15, 8, False)\n", "player value 24 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 22\n", "init (10, 4, False)\n", "player value 19 | dealer value 17\n", "init (16, 7, False)\n", "player value 16 | dealer value 19\n", "init (9, 6, False)\n", "player value 19 | dealer value 17\n", "init (8, 4, False)\n", "player value 16 | dealer value 19\n", "init (15, 1, False)\n", "init (20, 8, True)\n", "player value 19 | dealer value 18\n", "init (9, 5, False)\n", "player value 17 | dealer value 17\n", "init (20, 5, True)\n", "player value 20 | dealer value 24\n", "init (20, 7, False)\n", "player value 28 | dealer value 19\n", "init (19, 6, False)\n", "player value 23 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (13, 7, False)\n", "player value 17 | dealer value 18\n", "init (12, 4, False)\n", "player value 18 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (12, 2, False)\n", "player value 20 | dealer value 19\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (13, 2, False)\n", "player value 22 | dealer value 18\n", "init (12, 6, False)\n", "player value 12 | dealer value 26\n", "init (15, 9, False)\n", "player value 26 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (15, 6, False)\n", "player value 25 | dealer value 26\n", "init (6, 10, False)\n", "player value 20 | dealer value 19\n", "init (16, 4, True)\n", "player value 16 | dealer value 18\n", "init (21, 10, True)\n", "init (11, 8, False)\n", "player value 15 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 24\n", "init (18, 6, False)\n", "player value 18 | dealer value 18\n", "init (16, 3, True)\n", "player value 21 | dealer value 24\n", "init (21, 10, True)\n", "init (19, 3, False)\n", "player value 19 | dealer value 22\n", "init (21, 8, True)\n", "init (16, 1, True)\n", "init (10, 1, False)\n", "player value 24 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 17\n", "init (19, 2, False)\n", "player value 19 | dealer value 19\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (14, 10, False)\n", "player value 22 | dealer value 20\n", "init (5, 10, False)\n", "player value 16 | dealer value 17\n", "init (9, 3, False)\n", "player value 18 | dealer value 19\n", "init (21, 10, True)\n", "init (18, 6, False)\n", "player value 18 | dealer value 23\n", "init (13, 7, False)\n", "player value 15 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (8, 2, False)\n", "player value 19 | dealer value 18\n", "init (13, 5, False)\n", "player value 15 | dealer value 21\n", "init (10, 7, False)\n", "player value 20 | dealer value 17\n", "init (14, 7, False)\n", "player value 14 | dealer value 23\n", "init (15, 10, False)\n", "player value 15 | dealer value 22\n", "init (16, 9, False)\n", "player value 16 | dealer value 20\n", "init (16, 3, False)\n", "player value 25 | dealer value 19\n", "init (17, 4, False)\n", "player value 17 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 9, True)\n", "player value 20 | dealer value 20\n", "init (16, 8, False)\n", "player value 24 | dealer value 21\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (21, 10, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (5, 10, False)\n", "init (7, 10, False)\n", "player value 17 | dealer value 19\n", "init (13, 10, False)\n", "player value 16 | dealer value 17\n", "init (13, 3, False)\n", "player value 13 | dealer value 25\n", "init (13, 8, False)\n", "player value 13 | dealer value 21\n", "init (14, 7, False)\n", "player value 16 | dealer value 17\n", "init (9, 1, False)\n", "init (21, 6, True)\n", "init (16, 10, False)\n", "init (15, 7, False)\n", "player value 15 | dealer value 18\n", "init (16, 6, False)\n", "player value 26 | dealer value 20\n", "init (11, 6, False)\n", "player value 21 | dealer value 24\n", "init (19, 7, True)\n", "player value 12 | dealer value 25\n", "init (19, 3, False)\n", "player value 19 | dealer value 18\n", "init (13, 10, False)\n", "player value 15 | dealer value 19\n", "init (21, 2, True)\n", "init (21, 10, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (17, 9, False)\n", "player value 25 | dealer value 18\n", "init (21, 9, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (15, 7, False)\n", "player value 25 | dealer value 18\n", "init (15, 5, False)\n", "player value 17 | dealer value 21\n", "init (20, 4, False)\n", "player value 20 | dealer value 19\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (20, 10, False)\n", "init (14, 1, False)\n", "player value 14 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 22\n", "init (10, 4, False)\n", "player value 20 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (5, 2, False)\n", "player value 16 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (8, 10, False)\n", "player value 27 | dealer value 20\n", "init (8, 7, False)\n", "player value 28 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (13, 7, True)\n", "player value 23 | dealer value 26\n", "init (8, 1, False)\n", "player value 20 | dealer value 22\n", "init (10, 10, False)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, False)\n", "init (17, 10, True)\n", "player value 17 | dealer value 19\n", "init (14, 4, False)\n", "player value 22 | dealer value 20\n", "round 1000\n", "init (12, 3, False)\n", "player value 12 | dealer value 19\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (17, 10, False)\n", "player value 20 | dealer value 17\n", "init (11, 10, False)\n", "player value 20 | dealer value 17\n", "init (9, 3, False)\n", "player value 20 | dealer value 18\n", "init (14, 4, False)\n", "player value 14 | dealer value 22\n", "init (18, 10, True)\n", "player value 18 | dealer value 17\n", "init (20, 8, False)\n", "player value 20 | dealer value 24\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (12, 8, False)\n", "player value 22 | dealer value 21\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (12, 9, False)\n", "player value 22 | dealer value 19\n", "init (13, 8, True)\n", "player value 18 | dealer value 19\n", "init (15, 2, False)\n", "player value 24 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (13, 1, False)\n", "player value 18 | dealer value 17\n", "init (12, 10, False)\n", "player value 19 | dealer value 25\n", "init (8, 10, False)\n", "player value 12 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (15, 6, False)\n", "player value 25 | dealer value 24\n", "init (21, 10, True)\n", "init (18, 10, True)\n", "player value 18 | dealer value 21\n", "init (21, 2, True)\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (6, 8, False)\n", "player value 22 | dealer value 18\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (13, 4, True)\n", "player value 13 | dealer value 21\n", "init (12, 2, False)\n", "player value 17 | dealer value 21\n", "init (12, 3, False)\n", "player value 18 | dealer value 23\n", "init (7, 3, False)\n", "player value 20 | dealer value 18\n", "init (13, 4, False)\n", "player value 23 | dealer value 21\n", "init (14, 8, False)\n", "player value 20 | dealer value 18\n", "init (21, 10, True)\n", "init (20, 3, False)\n", "player value 20 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 20 | dealer value 22\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (12, 3, False)\n", "player value 26 | dealer value 20\n", "init (13, 4, False)\n", "player value 13 | dealer value 19\n", "init (13, 5, False)\n", "player value 13 | dealer value 19\n", "init (18, 5, False)\n", "player value 27 | dealer value 20\n", "init (12, 10, False)\n", "player value 23 | dealer value 22\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (14, 5, False)\n", "player value 24 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 20\n", "init (16, 10, False)\n", "player value 17 | dealer value 19\n", "init (12, 1, True)\n", "init (8, 2, False)\n", "player value 27 | dealer value 21\n", "init (10, 2, False)\n", "player value 18 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 21\n", "init (21, 10, True)\n", "init (19, 6, False)\n", "player value 19 | dealer value 24\n", "init (12, 10, False)\n", "player value 12 | dealer value 22\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (21, 10, True)\n", "init (17, 7, False)\n", "player value 17 | dealer value 26\n", "init (21, 3, True)\n", "init (12, 10, False)\n", "player value 17 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 21\n", "init (18, 10, True)\n", "player value 18 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (5, 1, False)\n", "player value 19 | dealer value 17\n", "init (11, 10, False)\n", "player value 13 | dealer value 24\n", "init (13, 5, False)\n", "player value 16 | dealer value 25\n", "init (15, 4, False)\n", "player value 15 | dealer value 22\n", "init (12, 3, True)\n", "player value 26 | dealer value 23\n", "init (19, 8, False)\n", "player value 29 | dealer value 18\n", "init (15, 5, False)\n", "player value 25 | dealer value 25\n", "init (19, 10, True)\n", "player value 19 | dealer value 18\n", "init (13, 1, True)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 21\n", "init (6, 8, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (11, 9, False)\n", "player value 21 | dealer value 18\n", "init (6, 10, False)\n", "player value 22 | dealer value 22\n", "init (14, 10, False)\n", "player value 20 | dealer value 19\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (17, 9, False)\n", "player value 17 | dealer value 19\n", "init (17, 2, False)\n", "player value 17 | dealer value 22\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (6, 2, False)\n", "player value 16 | dealer value 17\n", "init (17, 10, False)\n", "player value 19 | dealer value 20\n", "init (9, 7, False)\n", "player value 16 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (17, 3, False)\n", "player value 26 | dealer value 19\n", "init (15, 4, True)\n", "player value 15 | dealer value 19\n", "init (10, 4, False)\n", "player value 18 | dealer value 23\n", "init (7, 9, False)\n", "player value 28 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (15, 10, False)\n", "init (18, 7, False)\n", "player value 28 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (17, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n", "init (12, 2, False)\n", "player value 17 | dealer value 19\n", "init (21, 8, True)\n", "init (4, 2, False)\n", "player value 14 | dealer value 19\n", "init (18, 8, True)\n", "player value 18 | dealer value 20\n", "init (10, 2, False)\n", "player value 12 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (19, 3, False)\n", "player value 24 | dealer value 25\n", "init (12, 8, False)\n", "player value 26 | dealer value 25\n", "init (13, 6, False)\n", "player value 13 | dealer value 19\n", "init (20, 10, True)\n", "player value 20 | dealer value 19\n", "init (6, 10, False)\n", "player value 20 | dealer value 17\n", "init (5, 2, False)\n", "player value 16 | dealer value 20\n", "init (9, 5, False)\n", "player value 14 | dealer value 25\n", "init (17, 7, False)\n", "player value 17 | dealer value 25\n", "init (13, 5, False)\n", "player value 19 | dealer value 17\n", "init (21, 9, True)\n", "init (11, 4, False)\n", "player value 21 | dealer value 20\n", "init (16, 1, False)\n", "player value 16 | dealer value 18\n", "init (14, 9, False)\n", "player value 14 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 20\n", "init (21, 10, True)\n", "init (11, 8, False)\n", "player value 22 | dealer value 18\n", "init (16, 2, False)\n", "player value 16 | dealer value 20\n", "init (16, 1, False)\n", "player value 16 | dealer value 24\n", "init (20, 1, False)\n", "player value 24 | dealer value 21\n", "init (12, 9, False)\n", "player value 21 | dealer value 19\n", "init (7, 3, False)\n", "player value 21 | dealer value 23\n", "init (20, 7, False)\n", "player value 20 | dealer value 20\n", "init (13, 9, False)\n", "player value 20 | dealer value 19\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (10, 10, False)\n", "player value 19 | dealer value 23\n", "init (19, 3, False)\n", "player value 19 | dealer value 21\n", "init (13, 3, False)\n", "player value 13 | dealer value 25\n", "init (8, 3, False)\n", "player value 20 | dealer value 20\n", "init (4, 1, False)\n", "player value 20 | dealer value 19\n", "init (13, 4, True)\n", "player value 13 | dealer value 21\n", "init (16, 5, False)\n", "player value 16 | dealer value 23\n", "init (9, 8, False)\n", "player value 20 | dealer value 18\n", "init (20, 1, True)\n", "init (16, 4, False)\n", "player value 16 | dealer value 19\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 8, False)\n", "player value 16 | dealer value 23\n", "init (12, 3, True)\n", "player value 17 | dealer value 20\n", "init (19, 3, True)\n", "player value 24 | dealer value 22\n", "init (18, 2, True)\n", "player value 18 | dealer value 17\n", "init (8, 10, False)\n", "player value 13 | dealer value 19\n", "init (8, 10, False)\n", "player value 19 | dealer value 17\n", "init (17, 10, False)\n", "player value 24 | dealer value 26\n", "init (10, 7, False)\n", "player value 20 | dealer value 25\n", "init (7, 2, False)\n", "player value 25 | dealer value 18\n", "init (5, 3, False)\n", "player value 25 | dealer value 19\n", "init (13, 10, False)\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (9, 8, False)\n", "player value 23 | dealer value 22\n", "init (16, 8, False)\n", "player value 16 | dealer value 23\n", "init (18, 9, False)\n", "player value 18 | dealer value 21\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (17, 10, False)\n", "player value 18 | dealer value 17\n", "init (15, 6, False)\n", "player value 22 | dealer value 18\n", "init (13, 10, False)\n", "player value 13 | dealer value 22\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (19, 4, False)\n", "player value 19 | dealer value 17\n", "init (19, 1, True)\n", "init (21, 8, True)\n", "init (15, 6, False)\n", "player value 17 | dealer value 17\n", "init (9, 10, False)\n", "player value 26 | dealer value 20\n", "init (11, 5, False)\n", "player value 20 | dealer value 19\n", "init (18, 4, False)\n", "player value 18 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (6, 10, False)\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (15, 5, False)\n", "player value 16 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (10, 1, False)\n", "player value 21 | dealer value 22\n", "init (20, 10, False)\n", "player value 22 | dealer value 20\n", "init (12, 6, False)\n", "player value 14 | dealer value 17\n", "init (16, 7, False)\n", "player value 18 | dealer value 24\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (9, 9, False)\n", "player value 18 | dealer value 20\n", "init (16, 1, False)\n", "player value 16 | dealer value 20\n", "init (7, 10, False)\n", "player value 23 | dealer value 20\n", "init (8, 10, False)\n", "player value 13 | dealer value 25\n", "init (12, 7, False)\n", "player value 12 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 22\n", "init (9, 1, False)\n", "player value 19 | dealer value 19\n", "init (7, 3, False)\n", "player value 17 | dealer value 19\n", "init (12, 7, False)\n", "player value 12 | dealer value 18\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (7, 10, False)\n", "player value 17 | dealer value 21\n", "init (12, 6, False)\n", "player value 24 | dealer value 25\n", "init (11, 7, False)\n", "player value 21 | dealer value 22\n", "init (18, 5, True)\n", "player value 20 | dealer value 18\n", "init (13, 2, False)\n", "player value 13 | dealer value 22\n", "init (7, 10, False)\n", "player value 24 | dealer value 20\n", "init (13, 4, False)\n", "player value 20 | dealer value 24\n", "init (12, 7, False)\n", "player value 12 | dealer value 20\n", "init (15, 7, False)\n", "player value 15 | dealer value 18\n", "init (16, 7, False)\n", "player value 18 | dealer value 18\n", "init (11, 10, False)\n", "player value 25 | dealer value 20\n", "init (20, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 21\n", "init (8, 6, False)\n", "player value 16 | dealer value 23\n", "init (15, 6, False)\n", "player value 24 | dealer value 19\n", "init (21, 10, True)\n", "init (8, 3, False)\n", "player value 20 | dealer value 18\n", "init (15, 5, False)\n", "player value 17 | dealer value 26\n", "init (9, 3, False)\n", "player value 24 | dealer value 24\n", "init (12, 6, True)\n", "player value 16 | dealer value 21\n", "init (11, 10, False)\n", "player value 18 | dealer value 19\n", "init (15, 9, False)\n", "player value 15 | dealer value 20\n", "init (19, 10, True)\n", "player value 19 | dealer value 17\n", "init (14, 1, False)\n", "init (19, 8, False)\n", "player value 24 | dealer value 21\n", "init (14, 10, False)\n", "player value 23 | dealer value 18\n", "init (15, 6, False)\n", "player value 15 | dealer value 17\n", "init (14, 6, False)\n", "player value 17 | dealer value 18\n", "init (17, 3, False)\n", "player value 22 | dealer value 18\n", "init (14, 10, True)\n", "player value 24 | dealer value 21\n", "init (13, 3, False)\n", "player value 13 | dealer value 23\n", "init (11, 9, False)\n", "player value 16 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (9, 10, False)\n", "player value 19 | dealer value 19\n", "init (15, 9, False)\n", "player value 20 | dealer value 19\n", "init (14, 4, False)\n", "player value 14 | dealer value 18\n", "init (11, 4, False)\n", "player value 21 | dealer value 17\n", "init (18, 3, False)\n", "player value 18 | dealer value 22\n", "init (15, 7, False)\n", "player value 23 | dealer value 19\n", "init (11, 7, False)\n", "player value 15 | dealer value 24\n", "init (14, 4, True)\n", "player value 14 | dealer value 20\n", "init (12, 10, False)\n", "player value 18 | dealer value 22\n", "init (19, 1, False)\n", "player value 19 | dealer value 24\n", "init (4, 3, False)\n", "player value 18 | dealer value 19\n", "init (9, 10, False)\n", "player value 18 | dealer value 17\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (5, 7, False)\n", "player value 17 | dealer value 17\n", "init (19, 7, False)\n", "player value 29 | dealer value 17\n", "init (9, 7, False)\n", "player value 19 | dealer value 18\n", "init (13, 2, False)\n", "player value 13 | dealer value 20\n", "init (15, 5, True)\n", "player value 17 | dealer value 17\n", "init (13, 5, False)\n", "player value 23 | dealer value 25\n", "init (21, 10, True)\n", "init (11, 9, False)\n", "player value 19 | dealer value 18\n", "init (15, 1, False)\n", "player value 15 | dealer value 17\n", "init (16, 6, False)\n", "player value 22 | dealer value 18\n", "init (18, 1, False)\n", "player value 18 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 17\n", "init (13, 9, True)\n", "player value 13 | dealer value 22\n", "init (11, 10, False)\n", "player value 20 | dealer value 21\n", "init (18, 3, False)\n", "player value 18 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 23\n", "init (16, 8, False)\n", "player value 16 | dealer value 18\n", "init (6, 10, False)\n", "init (21, 3, True)\n", "init (13, 4, False)\n", "player value 17 | dealer value 24\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (9, 10, False)\n", "player value 18 | dealer value 25\n", "init (14, 7, False)\n", "player value 14 | dealer value 19\n", "init (9, 5, False)\n", "player value 12 | dealer value 17\n", "init (12, 4, False)\n", "player value 18 | dealer value 21\n", "init (20, 8, False)\n", "player value 20 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (11, 8, False)\n", "player value 21 | dealer value 19\n", "init (14, 8, True)\n", "player value 16 | dealer value 25\n", "init (17, 8, False)\n", "player value 17 | dealer value 18\n", "init (12, 9, False)\n", "player value 22 | dealer value 18\n", "init (14, 9, False)\n", "player value 14 | dealer value 26\n", "init (4, 1, False)\n", "player value 23 | dealer value 22\n", "init (7, 3, False)\n", "player value 13 | dealer value 26\n", "init (15, 2, False)\n", "player value 22 | dealer value 22\n", "init (19, 8, True)\n", "player value 12 | dealer value 18\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (21, 10, True)\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (19, 3, True)\n", "player value 20 | dealer value 21\n", "init (13, 1, False)\n", "player value 25 | dealer value 19\n", "init (12, 3, False)\n", "player value 21 | dealer value 17\n", "init (15, 9, False)\n", "player value 24 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 7, False)\n", "player value 12 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (19, 3, False)\n", "player value 29 | dealer value 19\n", "init (16, 10, False)\n", "init (11, 9, False)\n", "player value 21 | dealer value 19\n", "init (19, 2, True)\n", "player value 19 | dealer value 17\n", "init (13, 1, False)\n", "player value 23 | dealer value 20\n", "init (17, 5, False)\n", "player value 17 | dealer value 19\n", "init (16, 5, True)\n", "player value 18 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (16, 10, True)\n", "player value 16 | dealer value 18\n", "init (21, 1, True)\n", "init (12, 6, False)\n", "player value 21 | dealer value 17\n", "init (7, 3, False)\n", "player value 19 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (6, 10, False)\n", "player value 17 | dealer value 20\n", "init (12, 1, False)\n", "player value 22 | dealer value 18\n", "init (12, 10, False)\n", "player value 21 | dealer value 22\n", "init (17, 3, True)\n", "player value 17 | dealer value 17\n", "init (16, 10, True)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 4, False)\n", "player value 23 | dealer value 22\n", "init (18, 5, False)\n", "player value 18 | dealer value 17\n", "init (19, 4, False)\n", "player value 19 | dealer value 17\n", "init (17, 7, False)\n", "player value 17 | dealer value 24\n", "init (15, 6, False)\n", "player value 21 | dealer value 26\n", "init (15, 2, False)\n", "player value 25 | dealer value 21\n", "init (12, 10, False)\n", "init (18, 3, False)\n", "player value 27 | dealer value 23\n", "init (18, 6, False)\n", "player value 18 | dealer value 17\n", "init (12, 6, False)\n", "player value 22 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (6, 1, False)\n", "player value 16 | dealer value 19\n", "init (21, 2, True)\n", "init (13, 4, False)\n", "player value 20 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (14, 1, False)\n", "player value 14 | dealer value 19\n", "init (15, 9, False)\n", "player value 25 | dealer value 22\n", "init (13, 6, True)\n", "player value 13 | dealer value 18\n", "init (11, 6, False)\n", "player value 16 | dealer value 20\n", "init (14, 10, False)\n", "player value 17 | dealer value 24\n", "init (6, 10, False)\n", "player value 26 | dealer value 19\n", "init (13, 3, False)\n", "player value 13 | dealer value 25\n", "init (13, 10, False)\n", "player value 13 | dealer value 19\n", "init (10, 2, False)\n", "player value 13 | dealer value 21\n", "init (17, 5, False)\n", "player value 17 | dealer value 19\n", "init (21, 2, True)\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (16, 1, False)\n", "init (12, 2, True)\n", "player value 20 | dealer value 17\n", "init (9, 6, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, True)\n", "player value 24 | dealer value 20\n", "init (9, 6, False)\n", "player value 19 | dealer value 25\n", "init (12, 2, True)\n", "player value 16 | dealer value 17\n", "init (14, 5, False)\n", "player value 14 | dealer value 17\n", "init (13, 8, False)\n", "player value 19 | dealer value 23\n", "init (9, 7, False)\n", "player value 19 | dealer value 21\n", "init (19, 7, True)\n", "player value 19 | dealer value 25\n", "init (17, 1, False)\n", "init (21, 10, True)\n", "init (13, 2, True)\n", "player value 15 | dealer value 22\n", "init (20, 5, False)\n", "player value 20 | dealer value 26\n", "init (11, 3, False)\n", "player value 21 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (9, 10, False)\n", "player value 18 | dealer value 20\n", "init (11, 3, False)\n", "player value 22 | dealer value 17\n", "init (18, 2, False)\n", "player value 18 | dealer value 26\n", "init (13, 7, False)\n", "player value 13 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (19, 2, False)\n", "player value 19 | dealer value 22\n", "init (15, 7, True)\n", "player value 21 | dealer value 19\n", "init (12, 9, False)\n", "player value 23 | dealer value 19\n", "init (14, 3, True)\n", "player value 14 | dealer value 22\n", "init (15, 10, True)\n", "player value 25 | dealer value 17\n", "init (5, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 10, False)\n", "init (13, 9, False)\n", "player value 23 | dealer value 23\n", "init (20, 10, True)\n", "player value 18 | dealer value 20\n", "init (13, 5, False)\n", "player value 14 | dealer value 25\n", "init (12, 4, False)\n", "player value 28 | dealer value 21\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (15, 9, False)\n", "player value 15 | dealer value 21\n", "init (12, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (12, 7, False)\n", "player value 22 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (7, 8, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 23\n", "init (16, 10, False)\n", "player value 24 | dealer value 19\n", "init (9, 10, False)\n", "init (12, 10, False)\n", "player value 14 | dealer value 18\n", "init (10, 10, False)\n", "player value 15 | dealer value 21\n", "init (15, 10, False)\n", "player value 23 | dealer value 17\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (15, 7, False)\n", "player value 15 | dealer value 25\n", "init (16, 10, False)\n", "player value 16 | dealer value 18\n", "init (21, 7, True)\n", "init (18, 1, False)\n", "player value 18 | dealer value 17\n", "init (12, 1, False)\n", "init (13, 4, False)\n", "player value 17 | dealer value 19\n", "init (15, 10, True)\n", "player value 24 | dealer value 20\n", "init (6, 10, False)\n", "player value 21 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (20, 10, False)\n", "player value 30 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (8, 2, False)\n", "player value 18 | dealer value 21\n", "init (9, 10, False)\n", "player value 19 | dealer value 17\n", "init (17, 7, False)\n", "player value 17 | dealer value 18\n", "init (13, 6, False)\n", "player value 13 | dealer value 24\n", "init (12, 3, False)\n", "player value 12 | dealer value 23\n", "init (15, 8, False)\n", "player value 23 | dealer value 23\n", "init (6, 8, False)\n", "player value 16 | dealer value 20\n", "init (15, 2, True)\n", "player value 18 | dealer value 18\n", "init (21, 10, True)\n", "init (11, 8, False)\n", "player value 21 | dealer value 18\n", "init (12, 4, False)\n", "player value 18 | dealer value 19\n", "init (14, 9, False)\n", "player value 14 | dealer value 19\n", "init (14, 3, False)\n", "player value 24 | dealer value 20\n", "init (9, 7, False)\n", "player value 19 | dealer value 22\n", "init (10, 1, False)\n", "player value 20 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (21, 8, True)\n", "init (15, 10, False)\n", "player value 23 | dealer value 24\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (14, 4, False)\n", "player value 24 | dealer value 20\n", "init (14, 2, False)\n", "player value 17 | dealer value 17\n", "init (12, 4, False)\n", "player value 21 | dealer value 24\n", "init (6, 6, False)\n", "player value 13 | dealer value 26\n", "init (20, 8, False)\n", "player value 20 | dealer value 22\n", "init (19, 2, False)\n", "player value 19 | dealer value 17\n", "init (17, 9, False)\n", "player value 27 | dealer value 19\n", "init (15, 10, False)\n", "player value 25 | dealer value 18\n", "init (17, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 7, True)\n", "player value 20 | dealer value 18\n", "init (8, 4, False)\n", "player value 17 | dealer value 23\n", "init (13, 7, False)\n", "player value 23 | dealer value 18\n", "init (8, 3, False)\n", "player value 18 | dealer value 23\n", "init (10, 4, False)\n", "player value 21 | dealer value 24\n", "init (12, 9, False)\n", "player value 22 | dealer value 17\n", "init (15, 8, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (20, 1, False)\n", "init (11, 10, False)\n", "player value 20 | dealer value 19\n", "init (18, 3, True)\n", "player value 25 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 22\n", "init (14, 2, False)\n", "player value 23 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (18, 1, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 25 | dealer value 21\n", "init (15, 2, False)\n", "player value 15 | dealer value 18\n", "init (16, 7, False)\n", "player value 26 | dealer value 22\n", "init (12, 8, False)\n", "player value 21 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 25\n", "init (12, 9, True)\n", "player value 13 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (11, 5, False)\n", "player value 23 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (4, 8, False)\n", "player value 25 | dealer value 24\n", "init (16, 10, False)\n", "init (16, 1, False)\n", "player value 16 | dealer value 17\n", "init (16, 1, False)\n", "init (14, 4, False)\n", "player value 14 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (9, 8, False)\n", "player value 15 | dealer value 18\n", "init (15, 6, False)\n", "player value 18 | dealer value 20\n", "init (12, 7, False)\n", "player value 12 | dealer value 22\n", "init (14, 3, False)\n", "player value 19 | dealer value 21\n", "init (19, 10, True)\n", "player value 19 | dealer value 18\n", "init (9, 4, False)\n", "player value 21 | dealer value 20\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (19, 2, False)\n", "player value 27 | dealer value 19\n", "init (17, 4, True)\n", "player value 17 | dealer value 18\n", "init (14, 5, False)\n", "player value 14 | dealer value 26\n", "init (15, 6, False)\n", "player value 25 | dealer value 17\n", "init (15, 5, True)\n", "player value 15 | dealer value 20\n", "init (17, 10, False)\n", "init (7, 7, False)\n", "player value 17 | dealer value 20\n", "init (15, 5, True)\n", "player value 21 | dealer value 23\n", "init (18, 2, False)\n", "player value 19 | dealer value 23\n", "init (12, 3, False)\n", "player value 12 | dealer value 21\n", "init (11, 10, False)\n", "player value 21 | dealer value 22\n", "init (13, 7, False)\n", "player value 13 | dealer value 17\n", "init (18, 2, False)\n", "player value 18 | dealer value 20\n", "init (10, 8, False)\n", "player value 23 | dealer value 18\n", "init (11, 6, False)\n", "player value 21 | dealer value 20\n", "init (16, 8, False)\n", "player value 16 | dealer value 24\n", "init (12, 10, False)\n", "player value 30 | dealer value 19\n", "init (13, 5, False)\n", "player value 23 | dealer value 23\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 21\n", "init (16, 8, False)\n", "player value 19 | dealer value 18\n", "init (16, 2, False)\n", "player value 16 | dealer value 22\n", "init (11, 5, False)\n", "player value 21 | dealer value 19\n", "init (17, 1, False)\n", "player value 17 | dealer value 17\n", "init (16, 7, False)\n", "player value 26 | dealer value 22\n", "init (15, 10, False)\n", "init (14, 7, False)\n", "player value 14 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (14, 9, False)\n", "player value 14 | dealer value 19\n", "init (12, 9, False)\n", "player value 12 | dealer value 19\n", "init (17, 5, False)\n", "player value 17 | dealer value 17\n", "init (10, 9, False)\n", "player value 17 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (11, 6, False)\n", "player value 13 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (21, 10, True)\n", "init (15, 5, True)\n", "player value 18 | dealer value 21\n", "init (12, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 3, False)\n", "player value 26 | dealer value 21\n", "init (18, 1, True)\n", "player value 18 | dealer value 17\n", "init (15, 8, False)\n", "player value 19 | dealer value 17\n", "init (10, 2, False)\n", "player value 14 | dealer value 21\n", "init (10, 10, False)\n", "player value 23 | dealer value 23\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (14, 10, True)\n", "player value 14 | dealer value 17\n", "init (8, 1, False)\n", "init (17, 2, False)\n", "player value 17 | dealer value 19\n", "init (10, 9, False)\n", "player value 19 | dealer value 19\n", "init (8, 7, False)\n", "player value 23 | dealer value 17\n", "init (12, 2, False)\n", "player value 17 | dealer value 22\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (15, 2, False)\n", "player value 15 | dealer value 21\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (11, 9, False)\n", "player value 21 | dealer value 23\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (11, 9, False)\n", "player value 23 | dealer value 19\n", "init (14, 7, True)\n", "player value 14 | dealer value 17\n", "init (17, 6, False)\n", "player value 27 | dealer value 18\n", "init (11, 3, False)\n", "player value 19 | dealer value 20\n", "init (15, 8, False)\n", "player value 24 | dealer value 18\n", "init (12, 5, False)\n", "player value 12 | dealer value 19\n", "init (20, 1, False)\n", "player value 23 | dealer value 21\n", "init (17, 10, False)\n", "init (8, 10, False)\n", "player value 18 | dealer value 17\n", "init (10, 10, False)\n", "player value 13 | dealer value 21\n", "init (20, 2, False)\n", "player value 20 | dealer value 26\n", "init (21, 8, True)\n", "init (12, 8, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (10, 7, False)\n", "player value 30 | dealer value 17\n", "init (21, 10, True)\n", "init (10, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, True)\n", "player value 21 | dealer value 20\n", "init (20, 10, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (16, 5, False)\n", "player value 16 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (11, 9, False)\n", "player value 19 | dealer value 22\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (15, 1, False)\n", "player value 24 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (14, 3, True)\n", "player value 14 | dealer value 20\n", "init (20, 9, False)\n", "player value 24 | dealer value 19\n", "init (15, 7, False)\n", "player value 15 | dealer value 21\n", "init (18, 2, True)\n", "player value 16 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (20, 1, False)\n", "init (21, 10, True)\n", "init (17, 8, True)\n", "player value 20 | dealer value 19\n", "init (18, 7, False)\n", "player value 23 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, True)\n", "player value 12 | dealer value 26\n", "init (16, 8, False)\n", "player value 16 | dealer value 24\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (19, 6, False)\n", "player value 19 | dealer value 19\n", "init (19, 6, False)\n", "player value 19 | dealer value 17\n", "init (9, 10, False)\n", "player value 20 | dealer value 17\n", "init (19, 2, True)\n", "player value 19 | dealer value 22\n", "init (12, 4, False)\n", "player value 22 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 24\n", "init (13, 10, True)\n", "player value 19 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 16 | dealer value 18\n", "init (19, 3, True)\n", "player value 19 | dealer value 17\n", "init (19, 4, False)\n", "player value 19 | dealer value 22\n", "init (9, 1, False)\n", "player value 18 | dealer value 19\n", "init (19, 9, False)\n", "player value 22 | dealer value 21\n", "init (9, 8, False)\n", "player value 16 | dealer value 18\n", "init (13, 7, False)\n", "player value 13 | dealer value 20\n", "init (19, 1, True)\n", "player value 19 | dealer value 18\n", "init (18, 6, True)\n", "player value 16 | dealer value 17\n", "init (13, 10, False)\n", "player value 21 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 21\n", "init (13, 10, False)\n", "player value 27 | dealer value 20\n", "init (17, 5, False)\n", "player value 17 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (15, 5, True)\n", "player value 12 | dealer value 26\n", "init (17, 3, False)\n", "player value 17 | dealer value 23\n", "init (14, 10, False)\n", "init (6, 9, False)\n", "player value 20 | dealer value 19\n", "init (7, 4, False)\n", "player value 17 | dealer value 23\n", "init (20, 5, False)\n", "player value 30 | dealer value 23\n", "init (9, 6, False)\n", "player value 18 | dealer value 17\n", "init (9, 8, False)\n", "player value 12 | dealer value 18\n", "init (12, 4, False)\n", "player value 17 | dealer value 24\n", "init (15, 10, False)\n", "player value 22 | dealer value 18\n", "init (14, 5, False)\n", "player value 14 | dealer value 25\n", "init (15, 1, True)\n", "player value 17 | dealer value 17\n", "init (21, 10, True)\n", "init (14, 7, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (21, 8, True)\n", "init (13, 4, False)\n", "player value 22 | dealer value 20\n", "init (12, 10, False)\n", "init (13, 10, False)\n", "player value 14 | dealer value 21\n", "init (15, 6, False)\n", "player value 15 | dealer value 25\n", "init (19, 1, True)\n", "player value 19 | dealer value 19\n", "init (20, 7, False)\n", "player value 20 | dealer value 21\n", "init (20, 4, False)\n", "player value 20 | dealer value 19\n", "init (16, 4, False)\n", "player value 16 | dealer value 17\n", "init (11, 4, False)\n", "player value 21 | dealer value 24\n", "init (11, 2, False)\n", "player value 19 | dealer value 18\n", "init (13, 8, False)\n", "player value 23 | dealer value 17\n", "init (12, 1, False)\n", "player value 12 | dealer value 26\n", "init (12, 9, True)\n", "player value 12 | dealer value 17\n", "init (10, 8, False)\n", "player value 25 | dealer value 18\n", "init (20, 10, True)\n", "player value 19 | dealer value 22\n", "init (10, 9, False)\n", "player value 21 | dealer value 18\n", "init (13, 1, False)\n", "player value 18 | dealer value 20\n", "init (14, 4, False)\n", "player value 20 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (11, 4, False)\n", "player value 19 | dealer value 19\n", "init (9, 10, False)\n", "player value 22 | dealer value 26\n", "init (5, 8, False)\n", "player value 22 | dealer value 23\n", "init (12, 3, False)\n", "player value 12 | dealer value 19\n", "init (15, 4, False)\n", "player value 15 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 17\n", "init (13, 2, False)\n", "player value 23 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 18\n", "init (7, 3, False)\n", "player value 24 | dealer value 21\n", "init (14, 1, False)\n", "player value 19 | dealer value 20\n", "init (21, 1, True)\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (15, 5, False)\n", "player value 23 | dealer value 18\n", "init (18, 10, False)\n", "init (16, 4, False)\n", "player value 19 | dealer value 21\n", "init (15, 7, False)\n", "player value 15 | dealer value 17\n", "init (4, 8, False)\n", "player value 24 | dealer value 22\n", "init (8, 10, False)\n", "player value 18 | dealer value 25\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (19, 7, True)\n", "player value 19 | dealer value 21\n", "init (19, 6, False)\n", "player value 19 | dealer value 18\n", "init (16, 5, False)\n", "player value 16 | dealer value 19\n", "init (20, 1, True)\n", "player value 28 | dealer value 22\n", "init (6, 8, False)\n", "player value 20 | dealer value 25\n", "init (15, 7, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (6, 10, False)\n", "player value 18 | dealer value 19\n", "init (8, 10, False)\n", "player value 18 | dealer value 19\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (16, 1, False)\n", "player value 25 | dealer value 17\n", "init (15, 6, False)\n", "player value 15 | dealer value 20\n", "init (13, 10, False)\n", "player value 17 | dealer value 25\n", "init (9, 4, False)\n", "player value 13 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (15, 10, False)\n", "player value 21 | dealer value 19\n", "init (12, 1, False)\n", "init (13, 4, False)\n", "player value 24 | dealer value 24\n", "init (15, 7, False)\n", "player value 15 | dealer value 17\n", "init (7, 1, False)\n", "player value 14 | dealer value 17\n", "init (16, 5, False)\n", "player value 25 | dealer value 19\n", "init (15, 4, True)\n", "player value 22 | dealer value 23\n", "init (10, 4, False)\n", "player value 24 | dealer value 23\n", "init (14, 6, False)\n", "player value 24 | dealer value 22\n", "init (12, 5, False)\n", "player value 13 | dealer value 24\n", "init (7, 10, False)\n", "player value 17 | dealer value 18\n", "init (19, 1, False)\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (17, 3, True)\n", "player value 17 | dealer value 23\n", "init (14, 4, False)\n", "player value 17 | dealer value 22\n", "init (7, 9, False)\n", "player value 20 | dealer value 18\n", "init (20, 4, False)\n", "player value 20 | dealer value 18\n", "init (7, 3, False)\n", "player value 13 | dealer value 21\n", "init (9, 3, False)\n", "player value 12 | dealer value 25\n", "init (12, 5, False)\n", "player value 22 | dealer value 25\n", "init (11, 10, False)\n", "player value 20 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 9, False)\n", "player value 16 | dealer value 19\n", "init (13, 8, False)\n", "player value 13 | dealer value 18\n", "init (13, 8, False)\n", "player value 16 | dealer value 18\n", "init (16, 10, False)\n", "player value 18 | dealer value 17\n", "init (15, 10, False)\n", "player value 19 | dealer value 19\n", "init (6, 8, False)\n", "player value 29 | dealer value 26\n", "init (21, 10, True)\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (17, 4, False)\n", "player value 17 | dealer value 19\n", "init (16, 8, False)\n", "player value 16 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (17, 10, True)\n", "player value 24 | dealer value 26\n", "init (10, 10, False)\n", "player value 18 | dealer value 19\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (17, 8, False)\n", "player value 22 | dealer value 17\n", "init (21, 5, True)\n", "init (13, 10, False)\n", "player value 27 | dealer value 19\n", "init (13, 9, False)\n", "player value 23 | dealer value 24\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (14, 2, False)\n", "player value 19 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 24\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 3, False)\n", "player value 12 | dealer value 22\n", "init (12, 7, False)\n", "player value 12 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (17, 4, False)\n", "player value 19 | dealer value 20\n", "init (18, 6, False)\n", "player value 18 | dealer value 21\n", "init (9, 10, False)\n", "player value 25 | dealer value 22\n", "init (10, 10, False)\n", "player value 15 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 25\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (17, 9, True)\n", "player value 17 | dealer value 20\n", "init (12, 3, False)\n", "player value 12 | dealer value 22\n", "init (13, 10, False)\n", "init (15, 7, False)\n", "player value 17 | dealer value 18\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (11, 10, False)\n", "player value 17 | dealer value 20\n", "init (12, 4, False)\n", "player value 22 | dealer value 24\n", "init (19, 5, False)\n", "player value 28 | dealer value 25\n", "init (21, 10, True)\n", "init (15, 9, False)\n", "player value 25 | dealer value 19\n", "init (12, 7, False)\n", "player value 12 | dealer value 17\n", "init (17, 8, False)\n", "player value 23 | dealer value 19\n", "init (17, 5, False)\n", "player value 21 | dealer value 25\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (9, 10, False)\n", "player value 17 | dealer value 19\n", "init (15, 10, False)\n", "player value 22 | dealer value 18\n", "init (16, 1, False)\n", "player value 16 | dealer value 20\n", "init (15, 6, False)\n", "player value 15 | dealer value 26\n", "init (14, 7, False)\n", "player value 14 | dealer value 17\n", "init (20, 4, False)\n", "player value 20 | dealer value 26\n", "init (13, 2, False)\n", "player value 13 | dealer value 20\n", "init (5, 4, False)\n", "player value 24 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (21, 2, True)\n", "init (13, 7, False)\n", "player value 26 | dealer value 21\n", "init (16, 7, False)\n", "player value 21 | dealer value 17\n", "init (13, 10, False)\n", "player value 19 | dealer value 19\n", "init (16, 10, False)\n", "player value 23 | dealer value 18\n", "init (16, 9, False)\n", "player value 16 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 22\n", "init (14, 6, True)\n", "player value 15 | dealer value 24\n", "init (16, 10, False)\n", "player value 16 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 9, False)\n", "player value 26 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 25\n", "init (9, 10, False)\n", "player value 29 | dealer value 20\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 10, True)\n", "player value 21 | dealer value 21\n", "init (21, 8, True)\n", "init (13, 6, False)\n", "player value 13 | dealer value 24\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (13, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 4, False)\n", "player value 14 | dealer value 18\n", "init (14, 10, False)\n", "player value 14 | dealer value 24\n", "init (14, 8, False)\n", "player value 19 | dealer value 19\n", "init (18, 10, False)\n", "player value 28 | dealer value 19\n", "init (17, 4, False)\n", "player value 17 | dealer value 23\n", "init (15, 4, False)\n", "player value 15 | dealer value 20\n", "init (19, 6, True)\n", "player value 19 | dealer value 21\n", "init (7, 4, False)\n", "player value 17 | dealer value 23\n", "init (19, 4, False)\n", "player value 19 | dealer value 22\n", "init (5, 8, False)\n", "player value 25 | dealer value 18\n", "init (14, 4, False)\n", "player value 14 | dealer value 18\n", "init (16, 10, False)\n", "player value 23 | dealer value 18\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (13, 2, False)\n", "player value 23 | dealer value 19\n", "init (14, 10, False)\n", "player value 22 | dealer value 17\n", "init (15, 3, False)\n", "player value 15 | dealer value 20\n", "init (8, 10, False)\n", "player value 22 | dealer value 18\n", "init (14, 3, True)\n", "player value 14 | dealer value 18\n", "init (9, 1, False)\n", "init (16, 3, True)\n", "player value 13 | dealer value 23\n", "init (15, 8, False)\n", "player value 16 | dealer value 20\n", "init (16, 1, False)\n", "init (10, 10, False)\n", "player value 22 | dealer value 22\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (15, 10, False)\n", "player value 17 | dealer value 19\n", "init (11, 10, False)\n", "player value 17 | dealer value 19\n", "init (19, 8, False)\n", "player value 19 | dealer value 23\n", "init (17, 10, False)\n", "player value 23 | dealer value 20\n", "init (14, 7, False)\n", "player value 20 | dealer value 17\n", "init (17, 8, True)\n", "player value 28 | dealer value 18\n", "init (14, 8, False)\n", "player value 19 | dealer value 17\n", "init (13, 10, False)\n", "player value 23 | dealer value 17\n", "init (5, 10, False)\n", "player value 18 | dealer value 17\n", "init (13, 8, False)\n", "player value 23 | dealer value 17\n", "init (8, 10, False)\n", "player value 18 | dealer value 19\n", "init (14, 2, False)\n", "player value 19 | dealer value 26\n", "init (14, 4, False)\n", "player value 14 | dealer value 17\n", "init (11, 9, False)\n", "player value 27 | dealer value 18\n", "init (14, 1, False)\n", "player value 28 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (19, 1, False)\n", "init (14, 1, False)\n", "player value 28 | dealer value 22\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (14, 4, True)\n", "player value 20 | dealer value 23\n", "init (13, 5, False)\n", "player value 25 | dealer value 25\n", "init (11, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 9, False)\n", "player value 20 | dealer value 18\n", "init (12, 7, False)\n", "player value 22 | dealer value 26\n", "init (15, 9, False)\n", "player value 24 | dealer value 20\n", "init (11, 10, False)\n", "player value 17 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 25\n", "init (16, 5, False)\n", "player value 16 | dealer value 25\n", "init (15, 6, True)\n", "player value 15 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 19\n", "init (16, 9, False)\n", "player value 16 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (10, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 9, False)\n", "player value 23 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (9, 5, False)\n", "player value 15 | dealer value 23\n", "init (14, 3, False)\n", "player value 23 | dealer value 23\n", "init (19, 7, True)\n", "player value 21 | dealer value 18\n", "init (18, 8, False)\n", "player value 25 | dealer value 18\n", "init (11, 8, False)\n", "player value 24 | dealer value 18\n", "init (14, 5, False)\n", "player value 14 | dealer value 25\n", "init (4, 1, False)\n", "player value 17 | dealer value 20\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 10, False)\n", "player value 26 | dealer value 20\n", "init (16, 10, True)\n", "player value 25 | dealer value 19\n", "init (18, 9, True)\n", "player value 18 | dealer value 17\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (19, 2, False)\n", "player value 19 | dealer value 21\n", "init (9, 1, False)\n", "player value 12 | dealer value 20\n", "init (10, 9, False)\n", "player value 16 | dealer value 18\n", "init (14, 10, True)\n", "player value 18 | dealer value 20\n", "init (12, 9, False)\n", "player value 22 | dealer value 21\n", "init (14, 10, True)\n", "player value 20 | dealer value 20\n", "init (19, 5, True)\n", "player value 19 | dealer value 24\n", "init (21, 4, True)\n", "init (7, 7, False)\n", "player value 25 | dealer value 25\n", "init (16, 6, False)\n", "player value 16 | dealer value 21\n", "init (8, 10, False)\n", "player value 19 | dealer value 19\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (18, 4, False)\n", "player value 28 | dealer value 17\n", "init (11, 10, False)\n", "player value 19 | dealer value 21\n", "init (13, 8, False)\n", "player value 13 | dealer value 17\n", "init (15, 6, False)\n", "player value 15 | dealer value 21\n", "init (21, 9, True)\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (15, 8, True)\n", "player value 15 | dealer value 17\n", "init (14, 10, False)\n", "player value 14 | dealer value 18\n", "init (11, 7, False)\n", "player value 18 | dealer value 19\n", "init (14, 6, False)\n", "player value 24 | dealer value 23\n", "init (13, 6, False)\n", "player value 13 | dealer value 18\n", "init (12, 5, False)\n", "player value 12 | dealer value 20\n", "init (11, 9, False)\n", "player value 21 | dealer value 21\n", "init (13, 9, True)\n", "player value 13 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 24\n", "init (12, 2, False)\n", "player value 22 | dealer value 21\n", "init (17, 9, False)\n", "player value 23 | dealer value 21\n", "init (11, 7, False)\n", "player value 19 | dealer value 23\n", "init (15, 10, True)\n", "player value 18 | dealer value 20\n", "init (12, 8, False)\n", "player value 24 | dealer value 24\n", "init (10, 3, False)\n", "player value 20 | dealer value 19\n", "init (16, 8, False)\n", "player value 20 | dealer value 19\n", "init (20, 3, False)\n", "player value 26 | dealer value 20\n", "init (12, 5, False)\n", "player value 12 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 19\n", "init (9, 10, False)\n", "player value 27 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 25\n", "init (21, 2, True)\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (18, 5, True)\n", "player value 19 | dealer value 18\n", "init (16, 6, False)\n", "player value 22 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (11, 4, False)\n", "player value 14 | dealer value 23\n", "init (21, 7, True)\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (14, 4, False)\n", "player value 14 | dealer value 21\n", "init (17, 2, False)\n", "player value 17 | dealer value 19\n", "init (19, 6, False)\n", "player value 19 | dealer value 21\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (16, 7, False)\n", "player value 26 | dealer value 17\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 2, True)\n", "player value 16 | dealer value 26\n", "init (13, 1, False)\n", "player value 23 | dealer value 21\n", "init (14, 2, False)\n", "player value 23 | dealer value 18\n", "init (16, 10, False)\n", "player value 27 | dealer value 20\n", "init (18, 10, True)\n", "init (13, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 10, False)\n", "player value 17 | dealer value 20\n", "init (15, 8, False)\n", "player value 30 | dealer value 21\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (11, 7, False)\n", "player value 21 | dealer value 18\n", "init (14, 4, True)\n", "player value 22 | dealer value 22\n", "init (16, 8, True)\n", "player value 21 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 19 | dealer value 19\n", "init (21, 9, True)\n", "init (14, 7, False)\n", "player value 18 | dealer value 23\n", "init (9, 10, False)\n", "player value 23 | dealer value 22\n", "init (14, 9, False)\n", "player value 24 | dealer value 25\n", "init (18, 7, True)\n", "player value 18 | dealer value 17\n", "init (19, 6, False)\n", "player value 19 | dealer value 20\n", "init (12, 8, False)\n", "player value 19 | dealer value 18\n", "init (13, 9, True)\n", "player value 19 | dealer value 21\n", "init (15, 7, False)\n", "player value 22 | dealer value 22\n", "init (12, 10, False)\n", "player value 27 | dealer value 20\n", "init (15, 5, False)\n", "player value 20 | dealer value 18\n", "init (13, 3, True)\n", "player value 13 | dealer value 18\n", "init (16, 2, False)\n", "player value 26 | dealer value 24\n", "init (14, 5, False)\n", "player value 14 | dealer value 25\n", "init (14, 10, False)\n", "player value 23 | dealer value 21\n", "init (15, 9, False)\n", "player value 18 | dealer value 21\n", "init (16, 10, True)\n", "player value 30 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (11, 10, False)\n", "player value 17 | dealer value 21\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (12, 2, False)\n", "player value 19 | dealer value 26\n", "init (13, 5, False)\n", "player value 19 | dealer value 25\n", "init (11, 10, False)\n", "player value 21 | dealer value 22\n", "init (11, 3, False)\n", "player value 21 | dealer value 21\n", "init (17, 4, False)\n", "player value 17 | dealer value 17\n", "init (15, 1, False)\n", "player value 16 | dealer value 18\n", "init (14, 5, False)\n", "player value 14 | dealer value 21\n", "init (17, 7, False)\n", "player value 22 | dealer value 19\n", "init (13, 1, False)\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "init (9, 7, False)\n", "player value 17 | dealer value 26\n", "init (13, 9, False)\n", "player value 23 | dealer value 18\n", "init (12, 4, False)\n", "player value 22 | dealer value 20\n", "init (12, 10, False)\n", "player value 26 | dealer value 23\n", "init (12, 8, False)\n", "player value 22 | dealer value 24\n", "init (13, 7, False)\n", "player value 21 | dealer value 25\n", "init (12, 9, False)\n", "player value 12 | dealer value 17\n", "init (12, 2, False)\n", "player value 12 | dealer value 24\n", "init (14, 4, False)\n", "player value 23 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 9, False)\n", "player value 16 | dealer value 21\n", "init (15, 10, True)\n", "player value 18 | dealer value 23\n", "init (16, 2, False)\n", "player value 22 | dealer value 23\n", "init (15, 6, False)\n", "player value 15 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (6, 10, False)\n", "player value 25 | dealer value 18\n", "init (10, 10, False)\n", "player value 19 | dealer value 17\n", "init (7, 4, False)\n", "player value 12 | dealer value 19\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (18, 6, False)\n", "player value 18 | dealer value 24\n", "init (10, 10, False)\n", "player value 17 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (5, 5, False)\n", "player value 22 | dealer value 20\n", "init (16, 7, False)\n", "player value 25 | dealer value 22\n", "init (15, 10, False)\n", "player value 15 | dealer value 23\n", "init (9, 9, False)\n", "player value 17 | dealer value 26\n", "init (20, 10, False)\n", "init (16, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 10, True)\n", "player value 12 | dealer value 19\n", "init (13, 1, False)\n", "init (16, 5, False)\n", "player value 16 | dealer value 19\n", "init (8, 1, False)\n", "init (18, 4, False)\n", "player value 20 | dealer value 26\n", "init (10, 9, False)\n", "player value 25 | dealer value 19\n", "init (15, 5, False)\n", "player value 20 | dealer value 24\n", "init (12, 9, True)\n", "player value 21 | dealer value 19\n", "init (10, 7, False)\n", "player value 22 | dealer value 17\n", "init (16, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (4, 2, False)\n", "player value 17 | dealer value 21\n", "init (6, 7, False)\n", "player value 21 | dealer value 25\n", "init (20, 9, False)\n", "player value 23 | dealer value 19\n", "init (17, 8, False)\n", "player value 24 | dealer value 21\n", "init (15, 6, False)\n", "player value 20 | dealer value 24\n", "init (9, 1, False)\n", "player value 19 | dealer value 23\n", "init (12, 1, False)\n", "player value 12 | dealer value 22\n", "init (17, 6, False)\n", "player value 17 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (16, 4, False)\n", "player value 21 | dealer value 21\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (15, 1, False)\n", "player value 24 | dealer value 23\n", "init (15, 3, False)\n", "player value 15 | dealer value 19\n", "init (8, 6, False)\n", "player value 18 | dealer value 17\n", "init (13, 3, False)\n", "player value 13 | dealer value 19\n", "init (12, 1, False)\n", "init (14, 4, False)\n", "player value 14 | dealer value 19\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (11, 8, False)\n", "player value 21 | dealer value 19\n", "init (9, 2, False)\n", "player value 25 | dealer value 24\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (17, 6, False)\n", "player value 17 | dealer value 26\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 1, False)\n", "player value 25 | dealer value 21\n", "init (15, 10, True)\n", "player value 21 | dealer value 19\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (14, 9, False)\n", "player value 23 | dealer value 20\n", "init (8, 10, False)\n", "player value 19 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 17\n", "init (12, 2, False)\n", "player value 12 | dealer value 26\n", "init (19, 10, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 10, True)\n", "player value 20 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "round 2000\n", "init (21, 2, True)\n", "init (21, 9, True)\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 21 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 17\n", "init (13, 8, False)\n", "player value 25 | dealer value 21\n", "init (9, 8, False)\n", "player value 20 | dealer value 21\n", "init (10, 10, False)\n", "player value 19 | dealer value 20\n", "init (7, 7, False)\n", "player value 17 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (16, 7, False)\n", "player value 25 | dealer value 17\n", "init (10, 1, False)\n", "player value 30 | dealer value 18\n", "init (20, 10, False)\n", "player value 30 | dealer value 20\n", "init (13, 7, False)\n", "player value 18 | dealer value 17\n", "init (20, 8, True)\n", "player value 20 | dealer value 18\n", "init (18, 2, False)\n", "player value 19 | dealer value 19\n", "init (6, 10, False)\n", "player value 26 | dealer value 20\n", "init (9, 2, False)\n", "player value 27 | dealer value 20\n", "init (11, 9, False)\n", "player value 22 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (6, 6, False)\n", "player value 16 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (19, 2, False)\n", "player value 19 | dealer value 17\n", "init (9, 10, False)\n", "player value 17 | dealer value 17\n", "init (13, 3, False)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "player value 13 | dealer value 24\n", "init (21, 5, True)\n", "init (18, 4, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, False)\n", "player value 21 | dealer value 20\n", "init (17, 5, True)\n", "player value 23 | dealer value 23\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (6, 2, False)\n", "player value 17 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (11, 6, False)\n", "player value 23 | dealer value 22\n", "init (5, 6, False)\n", "player value 14 | dealer value 26\n", "init (20, 4, False)\n", "player value 27 | dealer value 25\n", "init (16, 10, False)\n", "player value 23 | dealer value 20\n", "init (12, 5, False)\n", "player value 22 | dealer value 20\n", "init (8, 4, False)\n", "player value 28 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 1, False)\n", "player value 12 | dealer value 18\n", "init (10, 2, False)\n", "player value 23 | dealer value 24\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (21, 2, True)\n", "init (14, 5, False)\n", "player value 14 | dealer value 22\n", "init (13, 1, False)\n", "init (13, 10, False)\n", "player value 28 | dealer value 20\n", "init (12, 5, False)\n", "player value 12 | dealer value 21\n", "init (6, 8, False)\n", "player value 26 | dealer value 18\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (8, 8, False)\n", "player value 18 | dealer value 17\n", "init (8, 1, False)\n", "player value 18 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (15, 8, False)\n", "player value 25 | dealer value 18\n", "init (10, 4, False)\n", "player value 23 | dealer value 18\n", "init (10, 9, False)\n", "player value 15 | dealer value 23\n", "init (17, 8, False)\n", "player value 17 | dealer value 26\n", "init (7, 8, False)\n", "player value 17 | dealer value 18\n", "init (13, 2, False)\n", "player value 19 | dealer value 21\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (13, 5, False)\n", "player value 23 | dealer value 21\n", "init (18, 9, True)\n", "player value 18 | dealer value 22\n", "init (7, 2, False)\n", "player value 25 | dealer value 20\n", "init (16, 9, False)\n", "player value 26 | dealer value 19\n", "init (12, 6, True)\n", "player value 12 | dealer value 19\n", "init (15, 9, False)\n", "player value 15 | dealer value 26\n", "init (11, 5, False)\n", "player value 23 | dealer value 19\n", "init (15, 10, False)\n", "player value 21 | dealer value 19\n", "init (13, 10, False)\n", "player value 24 | dealer value 20\n", "init (15, 2, True)\n", "player value 20 | dealer value 18\n", "init (9, 10, False)\n", "player value 19 | dealer value 17\n", "init (11, 7, False)\n", "player value 21 | dealer value 17\n", "init (13, 10, False)\n", "player value 22 | dealer value 17\n", "init (17, 4, False)\n", "player value 17 | dealer value 21\n", "init (15, 8, False)\n", "player value 15 | dealer value 20\n", "init (13, 8, False)\n", "player value 17 | dealer value 21\n", "init (20, 10, False)\n", "player value 27 | dealer value 26\n", "init (17, 10, False)\n", "player value 17 | dealer value 22\n", "init (15, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 9, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "player value 24 | dealer value 19\n", "init (15, 6, False)\n", "player value 23 | dealer value 21\n", "init (11, 3, False)\n", "player value 21 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 23\n", "init (20, 9, False)\n", "player value 20 | dealer value 24\n", "init (9, 4, False)\n", "player value 20 | dealer value 26\n", "init (12, 2, False)\n", "player value 12 | dealer value 19\n", "init (17, 1, False)\n", "init (17, 9, False)\n", "player value 27 | dealer value 18\n", "init (19, 2, False)\n", "player value 19 | dealer value 20\n", "init (15, 6, False)\n", "player value 25 | dealer value 18\n", "init (11, 5, False)\n", "player value 27 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 23\n", "init (16, 8, False)\n", "player value 17 | dealer value 21\n", "init (20, 1, True)\n", "player value 20 | dealer value 18\n", "init (12, 4, False)\n", "player value 20 | dealer value 21\n", "init (14, 1, False)\n", "player value 23 | dealer value 20\n", "init (12, 10, False)\n", "player value 15 | dealer value 20\n", "init (14, 10, False)\n", "player value 18 | dealer value 17\n", "init (14, 6, False)\n", "player value 14 | dealer value 18\n", "init (11, 10, False)\n", "player value 25 | dealer value 20\n", "init (21, 10, True)\n", "init (12, 10, False)\n", "player value 18 | dealer value 19\n", "init (12, 3, False)\n", "player value 12 | dealer value 23\n", "init (18, 10, False)\n", "init (20, 9, True)\n", "player value 20 | dealer value 18\n", "init (11, 5, False)\n", "player value 21 | dealer value 23\n", "init (10, 2, False)\n", "player value 16 | dealer value 20\n", "init (18, 2, False)\n", "player value 27 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 18\n", "init (14, 9, False)\n", "player value 17 | dealer value 18\n", "init (14, 10, False)\n", "player value 19 | dealer value 24\n", "init (14, 10, False)\n", "player value 18 | dealer value 24\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (17, 5, False)\n", "player value 22 | dealer value 21\n", "init (6, 4, False)\n", "player value 18 | dealer value 20\n", "init (7, 4, False)\n", "player value 29 | dealer value 20\n", "init (15, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 10, True)\n", "init (6, 10, False)\n", "init (13, 5, False)\n", "player value 13 | dealer value 18\n", "init (13, 4, False)\n", "player value 20 | dealer value 26\n", "init (18, 1, False)\n", "init (13, 3, False)\n", "player value 13 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (15, 2, False)\n", "player value 19 | dealer value 20\n", "init (19, 10, True)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (12, 10, False)\n", "player value 17 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (14, 4, True)\n", "player value 14 | dealer value 18\n", "init (10, 7, False)\n", "player value 23 | dealer value 25\n", "init (12, 10, False)\n", "player value 29 | dealer value 20\n", "init (12, 10, False)\n", "player value 23 | dealer value 25\n", "init (15, 10, False)\n", "player value 22 | dealer value 18\n", "init (17, 1, False)\n", "player value 27 | dealer value 19\n", "init (14, 1, False)\n", "player value 24 | dealer value 22\n", "init (16, 10, False)\n", "player value 25 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (21, 6, True)\n", "init (14, 9, True)\n", "player value 22 | dealer value 19\n", "init (12, 6, False)\n", "player value 18 | dealer value 24\n", "init (17, 6, True)\n", "player value 17 | dealer value 21\n", "init (8, 3, False)\n", "player value 12 | dealer value 25\n", "init (7, 4, False)\n", "player value 13 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (13, 8, False)\n", "player value 23 | dealer value 19\n", "init (12, 7, False)\n", "player value 12 | dealer value 17\n", "init (14, 3, False)\n", "player value 25 | dealer value 24\n", "init (6, 10, False)\n", "player value 19 | dealer value 18\n", "init (21, 7, True)\n", "init (12, 9, False)\n", "player value 12 | dealer value 19\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (18, 7, False)\n", "player value 18 | dealer value 20\n", "init (14, 6, False)\n", "player value 22 | dealer value 17\n", "init (6, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 6, False)\n", "player value 18 | dealer value 17\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (7, 5, False)\n", "player value 17 | dealer value 21\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (21, 1, True)\n", "init (20, 9, False)\n", "player value 30 | dealer value 18\n", "init (16, 10, False)\n", "player value 25 | dealer value 22\n", "init (10, 4, False)\n", "player value 27 | dealer value 20\n", "init (13, 8, False)\n", "player value 13 | dealer value 18\n", "init (14, 9, False)\n", "player value 14 | dealer value 23\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (8, 7, False)\n", "player value 22 | dealer value 17\n", "init (15, 10, False)\n", "init (10, 1, False)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "init (13, 10, True)\n", "player value 13 | dealer value 17\n", "init (4, 5, False)\n", "player value 22 | dealer value 19\n", "init (10, 4, False)\n", "player value 20 | dealer value 19\n", "init (8, 10, False)\n", "player value 13 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (20, 1, False)\n", "init (16, 1, False)\n", "init (14, 9, True)\n", "player value 14 | dealer value 19\n", "init (7, 3, False)\n", "player value 25 | dealer value 19\n", "init (14, 8, False)\n", "player value 22 | dealer value 17\n", "init (12, 2, False)\n", "player value 12 | dealer value 17\n", "init (17, 1, False)\n", "player value 17 | dealer value 20\n", "init (5, 2, False)\n", "player value 14 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (13, 3, False)\n", "player value 13 | dealer value 21\n", "init (18, 6, True)\n", "player value 18 | dealer value 26\n", "init (17, 5, False)\n", "player value 25 | dealer value 23\n", "init (11, 7, False)\n", "player value 26 | dealer value 17\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (18, 5, False)\n", "player value 22 | dealer value 23\n", "init (9, 3, False)\n", "player value 24 | dealer value 23\n", "init (20, 4, False)\n", "player value 20 | dealer value 18\n", "init (14, 10, True)\n", "player value 21 | dealer value 24\n", "init (7, 1, False)\n", "player value 19 | dealer value 20\n", "init (19, 5, False)\n", "player value 19 | dealer value 20\n", "init (16, 3, False)\n", "player value 20 | dealer value 18\n", "init (9, 2, False)\n", "player value 19 | dealer value 17\n", "init (13, 1, False)\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (21, 5, True)\n", "init (8, 4, False)\n", "player value 26 | dealer value 19\n", "init (6, 6, False)\n", "player value 14 | dealer value 25\n", "init (9, 8, False)\n", "player value 22 | dealer value 18\n", "init (21, 8, True)\n", "init (20, 6, False)\n", "player value 20 | dealer value 18\n", "init (13, 4, False)\n", "player value 22 | dealer value 21\n", "init (12, 4, False)\n", "player value 15 | dealer value 21\n", "init (21, 10, True)\n", "init (14, 10, False)\n", "player value 23 | dealer value 19\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (19, 3, False)\n", "player value 24 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (13, 3, False)\n", "player value 13 | dealer value 18\n", "init (15, 1, True)\n", "init (19, 9, False)\n", "player value 19 | dealer value 18\n", "init (9, 10, False)\n", "init (11, 7, False)\n", "player value 12 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 21\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (15, 9, False)\n", "player value 15 | dealer value 22\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (7, 7, False)\n", "player value 19 | dealer value 21\n", "init (13, 8, False)\n", "player value 27 | dealer value 23\n", "init (14, 3, True)\n", "player value 14 | dealer value 24\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (9, 2, False)\n", "player value 23 | dealer value 19\n", "init (15, 5, False)\n", "player value 18 | dealer value 25\n", "init (7, 7, False)\n", "player value 24 | dealer value 22\n", "init (15, 5, False)\n", "player value 25 | dealer value 17\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (9, 5, False)\n", "player value 28 | dealer value 25\n", "init (19, 10, True)\n", "player value 21 | dealer value 20\n", "init (18, 7, False)\n", "player value 28 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 22\n", "init (11, 4, False)\n", "player value 18 | dealer value 22\n", "init (18, 10, False)\n", "player value 18 | dealer value 24\n", "init (16, 10, False)\n", "player value 26 | dealer value 18\n", "init (12, 10, False)\n", "player value 25 | dealer value 19\n", "init (16, 7, False)\n", "player value 16 | dealer value 18\n", "init (14, 6, False)\n", "player value 14 | dealer value 18\n", "init (14, 3, False)\n", "player value 24 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (11, 10, False)\n", "player value 13 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (7, 10, False)\n", "player value 14 | dealer value 20\n", "init (19, 10, False)\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (21, 10, True)\n", "init (14, 1, False)\n", "player value 23 | dealer value 18\n", "init (13, 10, True)\n", "player value 18 | dealer value 19\n", "init (12, 8, False)\n", "player value 20 | dealer value 19\n", "init (7, 10, False)\n", "player value 25 | dealer value 24\n", "init (20, 5, True)\n", "player value 12 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (16, 9, False)\n", "player value 16 | dealer value 19\n", "init (13, 8, False)\n", "player value 20 | dealer value 22\n", "init (4, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 2, False)\n", "player value 14 | dealer value 21\n", "init (14, 2, False)\n", "player value 14 | dealer value 18\n", "init (6, 3, False)\n", "player value 22 | dealer value 17\n", "init (15, 6, False)\n", "player value 15 | dealer value 17\n", "init (12, 1, False)\n", "player value 12 | dealer value 17\n", "init (13, 1, False)\n", "player value 13 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (14, 10, False)\n", "player value 17 | dealer value 20\n", "init (12, 10, False)\n", "player value 18 | dealer value 24\n", "init (13, 8, False)\n", "player value 13 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (21, 8, True)\n", "init (17, 7, False)\n", "player value 17 | dealer value 20\n", "init (12, 9, False)\n", "player value 19 | dealer value 21\n", "init (15, 9, False)\n", "player value 15 | dealer value 20\n", "init (13, 4, False)\n", "player value 22 | dealer value 17\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (8, 8, False)\n", "player value 18 | dealer value 18\n", "init (21, 2, True)\n", "init (13, 2, False)\n", "player value 13 | dealer value 24\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (15, 10, False)\n", "init (14, 2, False)\n", "player value 14 | dealer value 24\n", "init (12, 9, False)\n", "player value 15 | dealer value 17\n", "init (17, 9, False)\n", "player value 18 | dealer value 22\n", "init (14, 9, False)\n", "player value 14 | dealer value 19\n", "init (13, 2, True)\n", "player value 16 | dealer value 18\n", "init (12, 1, False)\n", "init (17, 4, True)\n", "player value 15 | dealer value 21\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (16, 5, True)\n", "player value 21 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (7, 8, False)\n", "player value 23 | dealer value 24\n", "init (13, 5, False)\n", "player value 23 | dealer value 17\n", "init (6, 6, False)\n", "player value 18 | dealer value 23\n", "init (13, 6, False)\n", "player value 13 | dealer value 24\n", "init (13, 7, False)\n", "player value 21 | dealer value 17\n", "init (17, 1, False)\n", "player value 27 | dealer value 21\n", "init (17, 2, False)\n", "player value 18 | dealer value 22\n", "init (17, 7, False)\n", "player value 22 | dealer value 24\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (19, 3, False)\n", "player value 19 | dealer value 24\n", "init (13, 2, False)\n", "player value 13 | dealer value 17\n", "init (5, 4, False)\n", "player value 14 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 21\n", "init (5, 3, False)\n", "player value 15 | dealer value 19\n", "init (8, 3, False)\n", "player value 12 | dealer value 23\n", "init (16, 4, False)\n", "player value 25 | dealer value 23\n", "init (10, 9, False)\n", "player value 30 | dealer value 18\n", "init (15, 6, False)\n", "player value 24 | dealer value 21\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (20, 7, True)\n", "player value 16 | dealer value 17\n", "init (8, 4, False)\n", "player value 18 | dealer value 21\n", "init (8, 10, False)\n", "player value 19 | dealer value 18\n", "init (10, 10, False)\n", "player value 18 | dealer value 20\n", "init (10, 6, False)\n", "player value 20 | dealer value 24\n", "init (14, 2, False)\n", "player value 14 | dealer value 24\n", "init (12, 5, False)\n", "player value 12 | dealer value 22\n", "init (15, 4, False)\n", "player value 15 | dealer value 25\n", "init (14, 10, True)\n", "player value 21 | dealer value 23\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (8, 4, False)\n", "player value 18 | dealer value 18\n", "init (16, 10, True)\n", "player value 16 | dealer value 17\n", "init (15, 4, False)\n", "player value 15 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (11, 2, False)\n", "player value 21 | dealer value 18\n", "init (9, 4, False)\n", "player value 19 | dealer value 24\n", "init (13, 1, False)\n", "player value 17 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (14, 8, False)\n", "player value 14 | dealer value 17\n", "init (16, 3, True)\n", "player value 22 | dealer value 19\n", "init (8, 3, False)\n", "player value 12 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 26\n", "init (11, 5, False)\n", "player value 31 | dealer value 17\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n", "init (6, 8, False)\n", "player value 24 | dealer value 18\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (21, 10, True)\n", "init (14, 3, False)\n", "player value 25 | dealer value 18\n", "init (21, 2, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (12, 2, False)\n", "player value 12 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 7, False)\n", "player value 24 | dealer value 19\n", "init (16, 10, True)\n", "init (16, 5, False)\n", "player value 16 | dealer value 20\n", "init (16, 3, False)\n", "player value 16 | dealer value 24\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (21, 10, True)\n", "init (15, 6, False)\n", "player value 15 | dealer value 26\n", "init (12, 6, False)\n", "player value 18 | dealer value 17\n", "init (14, 3, False)\n", "player value 24 | dealer value 17\n", "init (18, 6, True)\n", "player value 13 | dealer value 21\n", "init (15, 3, False)\n", "player value 15 | dealer value 20\n", "init (12, 7, False)\n", "player value 23 | dealer value 23\n", "init (13, 9, False)\n", "player value 13 | dealer value 23\n", "init (17, 8, False)\n", "player value 23 | dealer value 18\n", "init (19, 6, False)\n", "player value 19 | dealer value 18\n", "init (13, 1, False)\n", "init (13, 4, False)\n", "player value 17 | dealer value 23\n", "init (20, 1, False)\n", "player value 20 | dealer value 21\n", "init (8, 7, False)\n", "player value 17 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (17, 5, True)\n", "player value 21 | dealer value 19\n", "init (15, 7, False)\n", "player value 18 | dealer value 17\n", "init (17, 5, False)\n", "player value 21 | dealer value 20\n", "init (11, 4, False)\n", "player value 21 | dealer value 19\n", "init (8, 10, False)\n", "player value 25 | dealer value 18\n", "init (7, 5, False)\n", "player value 12 | dealer value 25\n", "init (16, 10, False)\n", "player value 20 | dealer value 18\n", "init (16, 5, False)\n", "player value 20 | dealer value 19\n", "init (6, 10, False)\n", "player value 22 | dealer value 18\n", "init (12, 9, False)\n", "player value 19 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 24\n", "init (11, 10, False)\n", "player value 22 | dealer value 26\n", "init (10, 1, False)\n", "init (16, 3, False)\n", "player value 16 | dealer value 19\n", "init (20, 10, True)\n", "player value 19 | dealer value 21\n", "init (19, 7, True)\n", "player value 19 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (9, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 7, False)\n", "player value 18 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (11, 6, False)\n", "player value 26 | dealer value 22\n", "init (8, 2, False)\n", "player value 12 | dealer value 20\n", "init (9, 3, False)\n", "player value 16 | dealer value 17\n", "init (12, 3, False)\n", "player value 12 | dealer value 19\n", "init (12, 4, False)\n", "player value 19 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 19\n", "init (15, 6, False)\n", "player value 15 | dealer value 21\n", "init (15, 9, False)\n", "player value 15 | dealer value 18\n", "init (16, 10, False)\n", "player value 26 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (14, 6, True)\n", "player value 21 | dealer value 21\n", "init (10, 4, False)\n", "player value 20 | dealer value 17\n", "init (7, 2, False)\n", "player value 27 | dealer value 17\n", "init (18, 8, False)\n", "player value 28 | dealer value 22\n", "init (11, 8, False)\n", "player value 21 | dealer value 18\n", "init (18, 2, True)\n", "player value 18 | dealer value 17\n", "init (8, 6, False)\n", "player value 12 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (17, 3, False)\n", "player value 17 | dealer value 22\n", "init (21, 2, True)\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (17, 10, True)\n", "player value 16 | dealer value 20\n", "init (12, 2, False)\n", "player value 12 | dealer value 26\n", "init (16, 7, False)\n", "player value 22 | dealer value 21\n", "init (13, 3, False)\n", "player value 13 | dealer value 23\n", "init (16, 1, False)\n", "init (13, 10, False)\n", "player value 13 | dealer value 22\n", "init (20, 9, False)\n", "player value 20 | dealer value 20\n", "init (15, 3, False)\n", "player value 21 | dealer value 20\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (11, 5, False)\n", "player value 21 | dealer value 18\n", "init (12, 2, False)\n", "player value 12 | dealer value 19\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (11, 4, False)\n", "player value 18 | dealer value 26\n", "init (5, 3, False)\n", "player value 18 | dealer value 23\n", "init (18, 6, False)\n", "player value 18 | dealer value 22\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (14, 7, False)\n", "player value 24 | dealer value 25\n", "init (8, 3, False)\n", "player value 15 | dealer value 25\n", "init (5, 10, False)\n", "player value 17 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 20\n", "init (10, 10, False)\n", "player value 21 | dealer value 18\n", "init (12, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (14, 1, False)\n", "player value 22 | dealer value 19\n", "init (14, 3, False)\n", "player value 25 | dealer value 23\n", "init (12, 10, False)\n", "player value 26 | dealer value 18\n", "init (21, 3, True)\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (17, 5, False)\n", "player value 27 | dealer value 21\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (12, 10, False)\n", "player value 18 | dealer value 17\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 26\n", "init (7, 10, False)\n", "player value 17 | dealer value 17\n", "init (12, 6, False)\n", "player value 22 | dealer value 18\n", "init (14, 10, False)\n", "player value 17 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (15, 5, True)\n", "player value 14 | dealer value 26\n", "init (20, 2, False)\n", "player value 20 | dealer value 23\n", "init (11, 4, False)\n", "player value 19 | dealer value 20\n", "init (15, 6, False)\n", "player value 15 | dealer value 19\n", "init (16, 2, False)\n", "player value 16 | dealer value 20\n", "init (21, 10, True)\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (21, 7, True)\n", "init (21, 3, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (11, 6, False)\n", "player value 13 | dealer value 17\n", "init (12, 5, False)\n", "player value 12 | dealer value 25\n", "init (14, 5, False)\n", "player value 14 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 9, False)\n", "player value 15 | dealer value 18\n", "init (13, 1, False)\n", "player value 22 | dealer value 24\n", "init (15, 10, False)\n", "player value 17 | dealer value 20\n", "init (11, 3, False)\n", "player value 21 | dealer value 22\n", "init (11, 10, False)\n", "player value 22 | dealer value 25\n", "init (20, 5, False)\n", "player value 20 | dealer value 24\n", "init (12, 8, False)\n", "player value 12 | dealer value 17\n", "init (16, 9, False)\n", "player value 19 | dealer value 19\n", "init (8, 1, False)\n", "player value 25 | dealer value 20\n", "init (13, 4, False)\n", "player value 23 | dealer value 19\n", "init (15, 10, True)\n", "player value 28 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (9, 7, False)\n", "player value 14 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (18, 10, False)\n", "player value 28 | dealer value 20\n", "init (12, 4, False)\n", "player value 21 | dealer value 20\n", "init (21, 4, True)\n", "init (17, 1, False)\n", "player value 27 | dealer value 18\n", "init (9, 3, False)\n", "player value 17 | dealer value 18\n", "init (16, 10, False)\n", "player value 22 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (19, 10, True)\n", "player value 21 | dealer value 20\n", "init (12, 10, False)\n", "player value 17 | dealer value 17\n", "init (12, 4, False)\n", "player value 18 | dealer value 26\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (18, 1, False)\n", "player value 28 | dealer value 19\n", "init (12, 10, False)\n", "player value 17 | dealer value 17\n", "init (10, 6, False)\n", "player value 20 | dealer value 26\n", "init (11, 7, False)\n", "player value 18 | dealer value 17\n", "init (15, 6, False)\n", "player value 15 | dealer value 17\n", "init (19, 1, False)\n", "player value 19 | dealer value 18\n", "init (7, 1, False)\n", "player value 22 | dealer value 22\n", "init (12, 7, False)\n", "player value 22 | dealer value 22\n", "init (15, 1, False)\n", "init (12, 5, False)\n", "player value 12 | dealer value 18\n", "init (17, 8, False)\n", "player value 27 | dealer value 17\n", "init (21, 6, True)\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (8, 5, False)\n", "player value 26 | dealer value 25\n", "init (10, 1, False)\n", "player value 20 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (21, 10, True)\n", "init (13, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 4, True)\n", "player value 13 | dealer value 18\n", "init (11, 4, False)\n", "player value 21 | dealer value 22\n", "init (9, 7, False)\n", "player value 19 | dealer value 18\n", "init (11, 2, False)\n", "player value 26 | dealer value 21\n", "init (17, 1, False)\n", "player value 23 | dealer value 17\n", "init (16, 5, True)\n", "player value 16 | dealer value 17\n", "init (15, 4, False)\n", "player value 15 | dealer value 24\n", "init (5, 2, False)\n", "player value 19 | dealer value 24\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (7, 2, False)\n", "player value 14 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (15, 3, False)\n", "player value 15 | dealer value 23\n", "init (6, 1, False)\n", "init (13, 1, False)\n", "player value 17 | dealer value 26\n", "init (14, 6, True)\n", "player value 14 | dealer value 18\n", "init (13, 9, False)\n", "player value 13 | dealer value 19\n", "init (6, 2, False)\n", "player value 12 | dealer value 21\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (14, 5, False)\n", "player value 14 | dealer value 19\n", "init (21, 10, True)\n", "init (14, 1, False)\n", "player value 24 | dealer value 17\n", "init (15, 6, False)\n", "player value 24 | dealer value 26\n", "init (16, 5, False)\n", "player value 20 | dealer value 23\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (12, 3, False)\n", "player value 12 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (12, 4, False)\n", "player value 19 | dealer value 26\n", "init (8, 10, False)\n", "player value 26 | dealer value 19\n", "init (15, 2, False)\n", "player value 25 | dealer value 17\n", "init (20, 3, False)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "player value 20 | dealer value 24\n", "init (20, 9, False)\n", "player value 26 | dealer value 19\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (20, 4, False)\n", "player value 26 | dealer value 24\n", "init (5, 8, False)\n", "player value 24 | dealer value 17\n", "init (5, 8, False)\n", "player value 15 | dealer value 21\n", "init (13, 7, False)\n", "player value 17 | dealer value 22\n", "init (13, 8, False)\n", "player value 18 | dealer value 17\n", "init (9, 10, False)\n", "player value 18 | dealer value 18\n", "init (15, 9, False)\n", "player value 15 | dealer value 19\n", "init (17, 10, False)\n", "player value 17 | dealer value 22\n", "init (5, 10, False)\n", "player value 25 | dealer value 19\n", "init (19, 10, True)\n", "init (15, 9, False)\n", "player value 22 | dealer value 20\n", "init (12, 6, False)\n", "player value 21 | dealer value 26\n", "init (16, 8, False)\n", "player value 18 | dealer value 18\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (12, 10, False)\n", "player value 18 | dealer value 23\n", "init (10, 9, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (13, 8, True)\n", "player value 21 | dealer value 18\n", "init (15, 2, False)\n", "player value 19 | dealer value 17\n", "init (13, 8, False)\n", "player value 13 | dealer value 18\n", "init (14, 10, False)\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (12, 3, False)\n", "player value 12 | dealer value 20\n", "init (11, 9, False)\n", "player value 22 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 10, False)\n", "player value 17 | dealer value 17\n", "init (19, 10, False)\n", "init (13, 2, False)\n", "player value 21 | dealer value 24\n", "init (11, 3, False)\n", "player value 12 | dealer value 25\n", "init (12, 6, True)\n", "player value 24 | dealer value 23\n", "init (13, 5, False)\n", "player value 13 | dealer value 17\n", "init (15, 3, False)\n", "player value 15 | dealer value 18\n", "init (11, 7, False)\n", "player value 15 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (12, 4, False)\n", "player value 22 | dealer value 17\n", "init (16, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 3, False)\n", "player value 17 | dealer value 20\n", "init (21, 10, True)\n", "init (20, 4, True)\n", "player value 25 | dealer value 22\n", "init (10, 10, False)\n", "player value 21 | dealer value 17\n", "init (12, 4, False)\n", "player value 22 | dealer value 18\n", "init (8, 5, False)\n", "player value 18 | dealer value 20\n", "init (16, 5, False)\n", "player value 24 | dealer value 18\n", "init (14, 10, False)\n", "init (14, 4, False)\n", "player value 18 | dealer value 18\n", "init (5, 1, False)\n", "player value 25 | dealer value 17\n", "init (21, 6, True)\n", "init (10, 5, False)\n", "player value 20 | dealer value 18\n", "init (15, 4, False)\n", "player value 15 | dealer value 21\n", "init (16, 10, False)\n", "player value 24 | dealer value 26\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 7, True)\n", "player value 20 | dealer value 25\n", "init (19, 9, False)\n", "player value 19 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (13, 5, False)\n", "player value 19 | dealer value 18\n", "init (16, 2, False)\n", "player value 23 | dealer value 21\n", "init (12, 3, False)\n", "player value 12 | dealer value 19\n", "init (14, 5, False)\n", "player value 14 | dealer value 24\n", "init (21, 3, True)\n", "init (12, 4, False)\n", "player value 22 | dealer value 18\n", "init (11, 10, False)\n", "player value 16 | dealer value 19\n", "init (12, 7, False)\n", "player value 21 | dealer value 18\n", "init (10, 5, False)\n", "player value 25 | dealer value 21\n", "init (8, 4, False)\n", "player value 18 | dealer value 17\n", "init (10, 10, False)\n", "player value 30 | dealer value 20\n", "init (13, 8, True)\n", "player value 13 | dealer value 17\n", "init (20, 2, False)\n", "player value 30 | dealer value 17\n", "init (20, 3, False)\n", "player value 29 | dealer value 19\n", "init (17, 8, True)\n", "player value 17 | dealer value 18\n", "init (14, 8, False)\n", "player value 14 | dealer value 25\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (18, 10, False)\n", "player value 23 | dealer value 18\n", "init (9, 10, False)\n", "player value 19 | dealer value 19\n", "init (15, 1, False)\n", "init (10, 10, False)\n", "player value 22 | dealer value 21\n", "init (19, 2, False)\n", "player value 19 | dealer value 23\n", "init (13, 7, False)\n", "player value 22 | dealer value 21\n", "init (14, 4, False)\n", "player value 24 | dealer value 21\n", "init (19, 1, False)\n", "player value 19 | dealer value 17\n", "init (17, 5, False)\n", "player value 27 | dealer value 25\n", "init (19, 6, True)\n", "player value 18 | dealer value 24\n", "init (21, 9, True)\n", "init (15, 6, False)\n", "player value 22 | dealer value 26\n", "init (17, 4, False)\n", "player value 17 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (15, 7, False)\n", "player value 25 | dealer value 25\n", "init (11, 2, False)\n", "player value 21 | dealer value 18\n", "init (16, 3, False)\n", "player value 16 | dealer value 18\n", "init (16, 4, False)\n", "player value 22 | dealer value 20\n", "init (11, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 22 | dealer value 22\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (14, 10, True)\n", "player value 24 | dealer value 24\n", "init (12, 10, False)\n", "player value 26 | dealer value 20\n", "init (12, 8, False)\n", "player value 14 | dealer value 17\n", "init (21, 10, True)\n", "init (16, 5, True)\n", "player value 14 | dealer value 18\n", "init (14, 6, False)\n", "player value 20 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (15, 8, False)\n", "player value 17 | dealer value 20\n", "init (16, 6, False)\n", "player value 17 | dealer value 17\n", "init (16, 10, False)\n", "player value 16 | dealer value 21\n", "init (6, 8, False)\n", "player value 18 | dealer value 17\n", "init (16, 10, False)\n", "player value 16 | dealer value 18\n", "init (12, 6, False)\n", "player value 22 | dealer value 19\n", "init (15, 8, False)\n", "player value 24 | dealer value 17\n", "init (6, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (16, 10, True)\n", "player value 19 | dealer value 17\n", "init (11, 8, False)\n", "player value 20 | dealer value 25\n", "init (20, 9, True)\n", "player value 20 | dealer value 19\n", "init (13, 10, True)\n", "player value 18 | dealer value 19\n", "init (20, 10, True)\n", "player value 22 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "init (10, 1, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 29 | dealer value 19\n", "init (19, 5, False)\n", "player value 19 | dealer value 25\n", "init (11, 6, False)\n", "player value 24 | dealer value 17\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (9, 1, False)\n", "player value 19 | dealer value 20\n", "init (20, 2, True)\n", "player value 20 | dealer value 17\n", "init (11, 5, False)\n", "player value 12 | dealer value 21\n", "init (18, 1, True)\n", "player value 20 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 21\n", "init (16, 4, False)\n", "player value 20 | dealer value 20\n", "init (11, 8, False)\n", "player value 21 | dealer value 20\n", "init (15, 10, False)\n", "player value 23 | dealer value 20\n", "init (12, 6, False)\n", "player value 21 | dealer value 17\n", "init (15, 5, True)\n", "player value 12 | dealer value 24\n", "init (11, 2, False)\n", "player value 21 | dealer value 20\n", "init (15, 3, True)\n", "player value 23 | dealer value 18\n", "init (11, 5, False)\n", "player value 28 | dealer value 19\n", "init (12, 10, False)\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (16, 3, False)\n", "player value 17 | dealer value 25\n", "init (14, 10, False)\n", "player value 22 | dealer value 17\n", "init (11, 9, False)\n", "player value 18 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (16, 5, False)\n", "player value 26 | dealer value 26\n", "init (10, 5, False)\n", "player value 18 | dealer value 25\n", "init (12, 10, False)\n", "player value 12 | dealer value 21\n", "init (19, 4, False)\n", "player value 19 | dealer value 19\n", "init (14, 8, False)\n", "player value 14 | dealer value 17\n", "init (15, 10, True)\n", "player value 14 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 22\n", "init (14, 3, False)\n", "player value 25 | dealer value 25\n", "init (21, 3, True)\n", "init (20, 4, False)\n", "player value 20 | dealer value 23\n", "init (16, 3, False)\n", "player value 26 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 7, True)\n", "player value 19 | dealer value 19\n", "init (14, 2, False)\n", "player value 14 | dealer value 22\n", "init (18, 8, True)\n", "player value 20 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (16, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 10, False)\n", "init (15, 4, True)\n", "player value 20 | dealer value 19\n", "init (17, 10, False)\n", "player value 17 | dealer value 23\n", "init (12, 1, False)\n", "player value 12 | dealer value 19\n", "init (6, 10, False)\n", "player value 26 | dealer value 17\n", "init (14, 2, False)\n", "player value 14 | dealer value 25\n", "init (12, 6, False)\n", "player value 22 | dealer value 17\n", "init (14, 10, False)\n", "player value 14 | dealer value 25\n", "init (13, 8, False)\n", "player value 20 | dealer value 22\n", "init (9, 7, False)\n", "player value 18 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (21, 9, True)\n", "init (16, 2, False)\n", "player value 16 | dealer value 20\n", "init (12, 7, False)\n", "player value 22 | dealer value 19\n", "init (9, 3, False)\n", "player value 25 | dealer value 20\n", "init (8, 6, False)\n", "player value 19 | dealer value 26\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 20\n", "init (11, 1, False)\n", "player value 12 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (8, 7, False)\n", "player value 18 | dealer value 23\n", "init (10, 3, False)\n", "player value 17 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (14, 5, False)\n", "player value 14 | dealer value 19\n", "init (15, 8, False)\n", "player value 24 | dealer value 22\n", "init (20, 3, False)\n", "player value 30 | dealer value 20\n", "init (17, 8, True)\n", "player value 27 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (11, 9, False)\n", "player value 25 | dealer value 20\n", "init (21, 2, True)\n", "init (10, 1, False)\n", "init (14, 3, False)\n", "player value 14 | dealer value 21\n", "init (19, 1, False)\n", "player value 19 | dealer value 18\n", "init (12, 4, False)\n", "player value 12 | dealer value 19\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (15, 9, True)\n", "player value 18 | dealer value 19\n", "init (16, 10, True)\n", "player value 16 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 24\n", "init (20, 10, True)\n", "init (14, 10, False)\n", "player value 14 | dealer value 17\n", "init (11, 4, False)\n", "player value 19 | dealer value 20\n", "init (21, 5, True)\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 1, False)\n", "init (12, 2, False)\n", "player value 14 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (18, 3, True)\n", "player value 18 | dealer value 21\n", "init (10, 7, False)\n", "player value 18 | dealer value 18\n", "init (13, 8, False)\n", "player value 25 | dealer value 23\n", "init (20, 2, False)\n", "player value 20 | dealer value 21\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (21, 6, True)\n", "init (7, 7, False)\n", "player value 17 | dealer value 19\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (18, 6, False)\n", "player value 18 | dealer value 21\n", "init (5, 8, False)\n", "player value 19 | dealer value 22\n", "init (16, 5, False)\n", "player value 26 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (14, 1, True)\n", "player value 24 | dealer value 20\n", "init (21, 5, True)\n", "init (9, 10, False)\n", "player value 21 | dealer value 20\n", "init (21, 10, True)\n", "init (21, 10, True)\n", "init (10, 8, False)\n", "player value 17 | dealer value 19\n", "init (12, 3, True)\n", "player value 12 | dealer value 24\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (10, 10, False)\n", "player value 19 | dealer value 18\n", "init (15, 3, False)\n", "player value 15 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (12, 5, False)\n", "player value 12 | dealer value 21\n", "init (20, 7, True)\n", "player value 20 | dealer value 24\n", "init (14, 9, True)\n", "player value 19 | dealer value 18\n", "init (18, 6, False)\n", "player value 18 | dealer value 19\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 22\n", "init (14, 6, False)\n", "player value 21 | dealer value 21\n", "init (15, 8, False)\n", "player value 22 | dealer value 21\n", "init (17, 8, False)\n", "player value 23 | dealer value 23\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (12, 10, False)\n", "player value 14 | dealer value 17\n", "init (5, 10, False)\n", "player value 19 | dealer value 21\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (18, 5, True)\n", "player value 18 | dealer value 19\n", "init (15, 8, False)\n", "player value 23 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 2, False)\n", "player value 18 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (6, 4, False)\n", "player value 17 | dealer value 21\n", "init (14, 7, False)\n", "player value 21 | dealer value 20\n", "init (8, 8, False)\n", "player value 26 | dealer value 18\n", "init (6, 4, False)\n", "player value 22 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 5, True)\n", "player value 16 | dealer value 21\n", "init (16, 10, True)\n", "init (13, 4, False)\n", "player value 18 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 22\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (13, 3, False)\n", "player value 17 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (10, 10, False)\n", "player value 14 | dealer value 19\n", "init (16, 10, False)\n", "player value 22 | dealer value 25\n", "init (19, 3, False)\n", "player value 19 | dealer value 17\n", "init (21, 7, True)\n", "init (20, 8, False)\n", "player value 20 | dealer value 24\n", "init (14, 10, False)\n", "init (21, 10, True)\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 1, False)\n", "player value 15 | dealer value 19\n", "init (8, 10, False)\n", "player value 17 | dealer value 17\n", "init (19, 5, False)\n", "player value 25 | dealer value 20\n", "init (16, 2, False)\n", "player value 19 | dealer value 17\n", "init (17, 8, False)\n", "player value 27 | dealer value 18\n", "init (15, 3, False)\n", "player value 18 | dealer value 19\n", "init (14, 3, True)\n", "player value 14 | dealer value 25\n", "init (12, 10, False)\n", "player value 17 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 22\n", "init (13, 6, False)\n", "player value 13 | dealer value 19\n", "init (17, 10, False)\n", "init (16, 10, False)\n", "init (8, 7, False)\n", "player value 24 | dealer value 20\n", "init (21, 10, True)\n", "init (7, 5, False)\n", "player value 26 | dealer value 22\n", "init (11, 7, False)\n", "player value 17 | dealer value 17\n", "init (11, 4, False)\n", "player value 21 | dealer value 20\n", "init (19, 10, False)\n", "init (12, 10, False)\n", "player value 21 | dealer value 17\n", "init (17, 2, False)\n", "player value 27 | dealer value 17\n", "init (19, 5, True)\n", "player value 19 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 24\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (17, 10, True)\n", "player value 18 | dealer value 23\n", "init (7, 5, False)\n", "player value 20 | dealer value 25\n", "init (13, 6, False)\n", "player value 20 | dealer value 22\n", "init (12, 4, False)\n", "player value 18 | dealer value 17\n", "init (15, 8, False)\n", "player value 15 | dealer value 24\n", "init (14, 10, False)\n", "player value 14 | dealer value 18\n", "init (13, 2, False)\n", "player value 23 | dealer value 19\n", "init (4, 1, False)\n", "init (13, 9, False)\n", "player value 13 | dealer value 19\n", "init (10, 1, False)\n", "player value 16 | dealer value 17\n", "init (14, 9, True)\n", "player value 15 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 19\n", "init (20, 6, False)\n", "player value 27 | dealer value 22\n", "init (12, 9, False)\n", "player value 26 | dealer value 17\n", "init (14, 3, False)\n", "player value 20 | dealer value 17\n", "init (13, 10, True)\n", "player value 13 | dealer value 20\n", "init (13, 8, False)\n", "player value 13 | dealer value 18\n", "init (17, 8, False)\n", "player value 27 | dealer value 19\n", "init (12, 9, False)\n", "player value 12 | dealer value 18\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (14, 2, False)\n", "player value 14 | dealer value 18\n", "init (10, 7, False)\n", "player value 20 | dealer value 25\n", "init (19, 1, False)\n", "player value 19 | dealer value 18\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 17\n", "init (17, 3, False)\n", "player value 17 | dealer value 17\n", "init (15, 10, False)\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (14, 1, False)\n", "init (8, 8, False)\n", "player value 18 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 22\n", "init (5, 2, False)\n", "player value 21 | dealer value 21\n", "init (6, 3, False)\n", "player value 19 | dealer value 23\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (4, 9, False)\n", "player value 21 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 19\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 26\n", "init (15, 4, True)\n", "player value 21 | dealer value 18\n", "init (15, 1, True)\n", "player value 21 | dealer value 22\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (16, 2, False)\n", "player value 26 | dealer value 25\n", "init (18, 5, False)\n", "player value 22 | dealer value 19\n", "init (16, 9, False)\n", "player value 26 | dealer value 17\n", "init (10, 6, False)\n", "player value 19 | dealer value 25\n", "init (6, 3, False)\n", "player value 16 | dealer value 22\n", "init (13, 4, False)\n", "player value 17 | dealer value 21\n", "init (13, 4, False)\n", "player value 22 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "player value 17 | dealer value 20\n", "init (15, 8, False)\n", "player value 25 | dealer value 21\n", "init (18, 4, False)\n", "player value 18 | dealer value 23\n", "init (18, 6, False)\n", "player value 18 | dealer value 23\n", "init (17, 10, False)\n", "init (16, 10, False)\n", "player value 26 | dealer value 26\n", "init (11, 8, False)\n", "player value 19 | dealer value 19\n", "init (15, 10, False)\n", "player value 17 | dealer value 17\n", "init (7, 8, False)\n", "player value 18 | dealer value 21\n", "init (19, 9, False)\n", "player value 19 | dealer value 26\n", "init (12, 3, False)\n", "player value 12 | dealer value 19\n", "init (14, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 4, False)\n", "player value 24 | dealer value 17\n", "init (20, 1, False)\n", "init (19, 3, False)\n", "player value 19 | dealer value 21\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (10, 9, False)\n", "player value 25 | dealer value 21\n", "init (13, 7, False)\n", "player value 17 | dealer value 25\n", "init (9, 3, False)\n", "player value 19 | dealer value 19\n", "init (13, 8, False)\n", "player value 18 | dealer value 20\n", "init (17, 7, True)\n", "player value 26 | dealer value 23\n", "init (17, 3, False)\n", "player value 23 | dealer value 18\n", "init (13, 4, False)\n", "player value 20 | dealer value 23\n", "init (9, 3, False)\n", "player value 17 | dealer value 26\n", "init (12, 1, False)\n", "player value 14 | dealer value 19\n", "init (8, 8, False)\n", "player value 15 | dealer value 19\n", "init (5, 10, False)\n", "player value 16 | dealer value 19\n", "init (17, 3, False)\n", "player value 17 | dealer value 18\n", "init (14, 6, False)\n", "player value 21 | dealer value 18\n", "init (13, 10, False)\n", "player value 20 | dealer value 21\n", "init (12, 3, True)\n", "player value 14 | dealer value 23\n", "init (9, 10, False)\n", "player value 21 | dealer value 25\n", "init (17, 9, False)\n", "player value 17 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 24\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 4, False)\n", "player value 17 | dealer value 17\n", "init (16, 2, False)\n", "player value 27 | dealer value 17\n", "init (12, 10, False)\n", "player value 19 | dealer value 18\n", "init (12, 4, False)\n", "player value 15 | dealer value 26\n", "init (8, 6, False)\n", "player value 18 | dealer value 17\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (16, 10, False)\n", "player value 23 | dealer value 18\n", "init (11, 2, False)\n", "player value 21 | dealer value 22\n", "init (13, 10, False)\n", "player value 22 | dealer value 20\n", "init (17, 10, False)\n", "init (16, 8, True)\n", "player value 23 | dealer value 21\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 17\n", "init (19, 2, False)\n", "player value 19 | dealer value 22\n", "init (8, 2, False)\n", "player value 18 | dealer value 17\n", "init (18, 5, False)\n", "player value 18 | dealer value 19\n", "init (21, 6, True)\n", "init (6, 6, False)\n", "player value 21 | dealer value 20\n", "init (19, 4, False)\n", "player value 19 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (16, 1, False)\n", "init (17, 9, False)\n", "player value 27 | dealer value 17\n", "init (14, 10, False)\n", "player value 14 | dealer value 19\n", "init (21, 4, True)\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (16, 8, False)\n", "player value 16 | dealer value 24\n", "init (5, 4, False)\n", "player value 24 | dealer value 17\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (14, 10, False)\n", "init (12, 8, False)\n", "player value 12 | dealer value 17\n", "init (13, 1, False)\n", "player value 23 | dealer value 18\n", "init (17, 10, True)\n", "player value 17 | dealer value 18\n", "init (6, 3, False)\n", "player value 16 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 6, False)\n", "player value 19 | dealer value 21\n", "init (12, 2, False)\n", "player value 22 | dealer value 19\n", "init (20, 7, False)\n", "player value 20 | dealer value 24\n", "init (7, 5, False)\n", "player value 19 | dealer value 18\n", "init (20, 4, True)\n", "player value 21 | dealer value 24\n", "init (15, 10, False)\n", "player value 17 | dealer value 19\n", "init (12, 4, False)\n", "player value 15 | dealer value 24\n", "init (6, 1, False)\n", "player value 13 | dealer value 17\n", "init (11, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 23\n", "init (8, 4, False)\n", "player value 18 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (19, 3, True)\n", "player value 19 | dealer value 17\n", "init (18, 10, True)\n", "player value 18 | dealer value 20\n", "init (14, 8, True)\n", "player value 24 | dealer value 26\n", "init (8, 1, False)\n", "player value 28 | dealer value 20\n", "init (7, 3, False)\n", "player value 17 | dealer value 21\n", "init (15, 5, False)\n", "player value 15 | dealer value 24\n", "init (12, 10, False)\n", "player value 17 | dealer value 17\n", "init (14, 10, False)\n", "init (16, 2, False)\n", "player value 25 | dealer value 21\n", "init (21, 6, True)\n", "init (7, 10, False)\n", "player value 17 | dealer value 21\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (10, 3, False)\n", "player value 12 | dealer value 19\n", "init (14, 2, False)\n", "player value 14 | dealer value 20\n", "init (16, 6, False)\n", "player value 26 | dealer value 21\n", "init (16, 10, False)\n", "player value 20 | dealer value 18\n", "init (13, 5, False)\n", "player value 18 | dealer value 25\n", "init (19, 8, True)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 30 | dealer value 20\n", "init (15, 8, False)\n", "player value 17 | dealer value 18\n", "init (11, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "round 3000\n", "init (10, 10, False)\n", "player value 21 | dealer value 20\n", "init (21, 3, True)\n", "init (16, 10, False)\n", "player value 25 | dealer value 25\n", "init (11, 4, False)\n", "player value 21 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 23\n", "init (11, 10, False)\n", "init (17, 4, False)\n", "player value 17 | dealer value 24\n", "init (19, 2, True)\n", "player value 19 | dealer value 19\n", "init (13, 2, False)\n", "player value 17 | dealer value 21\n", "init (15, 5, False)\n", "player value 15 | dealer value 25\n", "init (13, 4, True)\n", "player value 21 | dealer value 17\n", "init (17, 1, True)\n", "player value 20 | dealer value 20\n", "init (16, 5, False)\n", "player value 18 | dealer value 19\n", "init (6, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 18 | dealer value 21\n", "init (12, 10, False)\n", "player value 19 | dealer value 20\n", "init (9, 6, False)\n", "player value 18 | dealer value 18\n", "init (14, 8, False)\n", "player value 20 | dealer value 18\n", "init (13, 5, False)\n", "player value 23 | dealer value 24\n", "init (20, 5, False)\n", "player value 20 | dealer value 23\n", "init (11, 10, False)\n", "player value 21 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (15, 6, False)\n", "player value 23 | dealer value 17\n", "init (10, 3, False)\n", "player value 25 | dealer value 21\n", "init (19, 7, False)\n", "player value 19 | dealer value 22\n", "init (19, 4, False)\n", "player value 26 | dealer value 19\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (16, 3, False)\n", "player value 16 | dealer value 22\n", "init (18, 8, False)\n", "player value 18 | dealer value 23\n", "init (15, 1, False)\n", "player value 16 | dealer value 23\n", "init (15, 6, False)\n", "player value 25 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 1, False)\n", "player value 23 | dealer value 20\n", "init (11, 9, False)\n", "player value 14 | dealer value 18\n", "init (11, 1, False)\n", "player value 21 | dealer value 19\n", "init (19, 8, True)\n", "player value 19 | dealer value 18\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (18, 7, False)\n", "player value 18 | dealer value 23\n", "init (13, 4, False)\n", "player value 23 | dealer value 24\n", "init (9, 4, False)\n", "player value 19 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 10, True)\n", "player value 21 | dealer value 17\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 22\n", "init (6, 5, False)\n", "player value 23 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (11, 7, False)\n", "player value 21 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (21, 10, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (21, 8, True)\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (17, 10, True)\n", "init (16, 1, False)\n", "player value 16 | dealer value 19\n", "init (15, 4, False)\n", "player value 15 | dealer value 22\n", "init (14, 10, True)\n", "player value 20 | dealer value 25\n", "init (15, 7, False)\n", "player value 23 | dealer value 23\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (18, 2, True)\n", "player value 18 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 17\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 8, False)\n", "player value 14 | dealer value 24\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (13, 10, False)\n", "player value 13 | dealer value 23\n", "init (13, 10, False)\n", "player value 25 | dealer value 19\n", "init (8, 2, False)\n", "player value 21 | dealer value 17\n", "init (13, 8, False)\n", "player value 22 | dealer value 19\n", "init (18, 10, True)\n", "player value 17 | dealer value 19\n", "init (14, 10, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (7, 8, False)\n", "player value 27 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (15, 10, True)\n", "player value 26 | dealer value 20\n", "init (17, 10, False)\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (13, 3, False)\n", "player value 13 | dealer value 22\n", "init (11, 6, False)\n", "player value 22 | dealer value 26\n", "init (21, 7, True)\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 17\n", "init (16, 8, True)\n", "player value 18 | dealer value 18\n", "init (13, 9, True)\n", "player value 21 | dealer value 21\n", "init (9, 2, False)\n", "player value 28 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (18, 10, False)\n", "init (15, 10, True)\n", "player value 15 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (19, 6, True)\n", "player value 21 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (12, 2, False)\n", "player value 12 | dealer value 22\n", "init (14, 4, False)\n", "player value 24 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 20\n", "init (14, 7, True)\n", "player value 21 | dealer value 22\n", "init (16, 9, True)\n", "player value 21 | dealer value 17\n", "init (14, 10, False)\n", "player value 25 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (18, 1, False)\n", "player value 18 | dealer value 18\n", "init (11, 5, False)\n", "player value 21 | dealer value 25\n", "init (11, 4, False)\n", "player value 21 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (13, 4, False)\n", "player value 17 | dealer value 20\n", "init (17, 1, False)\n", "player value 27 | dealer value 17\n", "init (16, 2, False)\n", "player value 18 | dealer value 18\n", "init (15, 1, False)\n", "init (19, 3, False)\n", "player value 19 | dealer value 23\n", "init (10, 8, False)\n", "player value 20 | dealer value 18\n", "init (12, 4, False)\n", "player value 29 | dealer value 23\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (12, 10, False)\n", "player value 26 | dealer value 19\n", "init (15, 8, False)\n", "player value 15 | dealer value 20\n", "init (19, 4, False)\n", "player value 29 | dealer value 19\n", "init (8, 8, False)\n", "player value 28 | dealer value 25\n", "init (20, 4, False)\n", "player value 20 | dealer value 18\n", "init (12, 2, False)\n", "player value 12 | dealer value 21\n", "init (17, 9, False)\n", "player value 17 | dealer value 19\n", "init (18, 1, False)\n", "init (17, 8, False)\n", "player value 20 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (14, 7, True)\n", "player value 21 | dealer value 18\n", "init (16, 6, True)\n", "player value 16 | dealer value 22\n", "init (15, 6, True)\n", "player value 19 | dealer value 17\n", "init (12, 4, False)\n", "player value 20 | dealer value 24\n", "init (16, 2, False)\n", "player value 26 | dealer value 24\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (21, 1, True)\n", "init (15, 8, False)\n", "player value 24 | dealer value 21\n", "init (18, 10, False)\n", "player value 22 | dealer value 23\n", "init (11, 9, False)\n", "player value 25 | dealer value 20\n", "init (14, 7, False)\n", "player value 20 | dealer value 19\n", "init (13, 6, True)\n", "player value 13 | dealer value 19\n", "init (21, 3, True)\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (20, 1, False)\n", "player value 20 | dealer value 21\n", "init (17, 2, False)\n", "player value 17 | dealer value 22\n", "init (21, 6, True)\n", "init (14, 1, False)\n", "init (5, 10, False)\n", "player value 14 | dealer value 20\n", "init (9, 7, False)\n", "player value 17 | dealer value 21\n", "init (7, 10, False)\n", "player value 17 | dealer value 24\n", "init (12, 5, False)\n", "player value 12 | dealer value 21\n", "init (12, 5, False)\n", "player value 12 | dealer value 18\n", "init (10, 4, False)\n", "player value 22 | dealer value 20\n", "init (20, 7, True)\n", "player value 20 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 18\n", "init (12, 5, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 20 | dealer value 20\n", "init (8, 3, False)\n", "player value 19 | dealer value 18\n", "init (9, 6, False)\n", "player value 20 | dealer value 24\n", "init (11, 1, False)\n", "player value 23 | dealer value 17\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (16, 6, True)\n", "player value 13 | dealer value 25\n", "init (11, 6, False)\n", "player value 25 | dealer value 25\n", "init (7, 6, False)\n", "player value 23 | dealer value 21\n", "init (16, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (11, 10, False)\n", "player value 23 | dealer value 26\n", "init (12, 8, False)\n", "player value 22 | dealer value 22\n", "init (21, 3, True)\n", "init (15, 4, False)\n", "player value 15 | dealer value 21\n", "init (16, 6, False)\n", "player value 16 | dealer value 20\n", "init (14, 6, False)\n", "player value 24 | dealer value 19\n", "init (12, 9, False)\n", "player value 26 | dealer value 19\n", "init (9, 5, False)\n", "player value 15 | dealer value 25\n", "init (13, 1, False)\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 2, False)\n", "player value 12 | dealer value 20\n", "init (9, 3, False)\n", "player value 20 | dealer value 18\n", "init (15, 1, False)\n", "player value 20 | dealer value 21\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (13, 3, False)\n", "player value 13 | dealer value 20\n", "init (16, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 2, False)\n", "player value 23 | dealer value 17\n", "init (19, 8, False)\n", "player value 19 | dealer value 21\n", "init (15, 10, False)\n", "player value 24 | dealer value 24\n", "init (21, 9, True)\n", "init (7, 7, False)\n", "player value 17 | dealer value 19\n", "init (15, 1, False)\n", "player value 25 | dealer value 26\n", "init (13, 1, False)\n", "player value 13 | dealer value 20\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (4, 8, False)\n", "player value 21 | dealer value 20\n", "init (17, 1, False)\n", "player value 17 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (10, 1, False)\n", "player value 23 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 25\n", "init (15, 10, True)\n", "player value 21 | dealer value 26\n", "init (13, 3, False)\n", "player value 13 | dealer value 23\n", "init (13, 10, False)\n", "player value 18 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (13, 6, False)\n", "player value 13 | dealer value 17\n", "init (12, 5, False)\n", "player value 22 | dealer value 17\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (14, 2, False)\n", "player value 24 | dealer value 26\n", "init (15, 2, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 25\n", "init (9, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 18\n", "init (10, 9, False)\n", "player value 15 | dealer value 17\n", "init (12, 10, False)\n", "player value 25 | dealer value 20\n", "init (9, 6, False)\n", "player value 25 | dealer value 26\n", "init (8, 7, False)\n", "player value 17 | dealer value 17\n", "init (13, 10, True)\n", "player value 15 | dealer value 20\n", "init (14, 2, False)\n", "player value 14 | dealer value 18\n", "init (16, 8, False)\n", "player value 27 | dealer value 17\n", "init (5, 8, False)\n", "player value 23 | dealer value 25\n", "init (15, 1, True)\n", "player value 15 | dealer value 17\n", "init (16, 9, False)\n", "player value 18 | dealer value 20\n", "init (20, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 20\n", "init (13, 6, True)\n", "player value 13 | dealer value 17\n", "init (20, 10, False)\n", "player value 26 | dealer value 20\n", "init (10, 10, False)\n", "init (11, 1, False)\n", "player value 25 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (14, 3, False)\n", "player value 18 | dealer value 19\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (11, 8, False)\n", "player value 19 | dealer value 21\n", "init (18, 1, True)\n", "player value 18 | dealer value 18\n", "init (18, 2, False)\n", "player value 18 | dealer value 17\n", "init (12, 10, False)\n", "init (8, 7, False)\n", "player value 28 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 25\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (17, 7, False)\n", "player value 17 | dealer value 21\n", "init (10, 1, False)\n", "player value 16 | dealer value 20\n", "init (13, 8, False)\n", "player value 20 | dealer value 19\n", "init (10, 9, False)\n", "player value 20 | dealer value 20\n", "init (16, 5, False)\n", "player value 26 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (17, 6, False)\n", "player value 17 | dealer value 24\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (13, 7, False)\n", "player value 23 | dealer value 24\n", "init (9, 8, False)\n", "player value 16 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 18\n", "init (16, 9, True)\n", "player value 16 | dealer value 22\n", "init (19, 9, False)\n", "player value 19 | dealer value 21\n", "init (15, 8, False)\n", "player value 23 | dealer value 21\n", "init (14, 7, True)\n", "player value 14 | dealer value 17\n", "init (19, 1, False)\n", "init (12, 8, False)\n", "player value 19 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 23\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (17, 9, True)\n", "player value 17 | dealer value 21\n", "init (11, 8, False)\n", "player value 27 | dealer value 26\n", "init (13, 1, False)\n", "init (17, 3, False)\n", "player value 17 | dealer value 18\n", "init (14, 9, False)\n", "player value 29 | dealer value 21\n", "init (13, 7, False)\n", "player value 22 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 9, True)\n", "player value 20 | dealer value 19\n", "init (14, 5, False)\n", "player value 14 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (18, 1, False)\n", "player value 18 | dealer value 19\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 2, False)\n", "player value 13 | dealer value 17\n", "init (15, 4, True)\n", "player value 15 | dealer value 19\n", "init (15, 7, False)\n", "player value 25 | dealer value 17\n", "init (14, 9, False)\n", "player value 15 | dealer value 19\n", "init (21, 2, True)\n", "init (19, 4, False)\n", "player value 19 | dealer value 23\n", "init (13, 10, False)\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 10, False)\n", "player value 16 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (14, 2, False)\n", "player value 14 | dealer value 19\n", "init (15, 4, False)\n", "player value 15 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 20\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (21, 10, True)\n", "init (16, 6, False)\n", "player value 25 | dealer value 25\n", "init (15, 4, False)\n", "player value 15 | dealer value 19\n", "init (7, 4, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (21, 2, True)\n", "init (12, 6, True)\n", "player value 17 | dealer value 26\n", "init (17, 5, False)\n", "player value 27 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (19, 5, False)\n", "player value 19 | dealer value 24\n", "init (11, 10, False)\n", "player value 17 | dealer value 26\n", "init (17, 4, False)\n", "player value 17 | dealer value 24\n", "init (18, 3, False)\n", "player value 18 | dealer value 22\n", "init (20, 6, False)\n", "player value 29 | dealer value 22\n", "init (17, 9, False)\n", "player value 17 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (13, 4, False)\n", "player value 19 | dealer value 22\n", "init (21, 1, True)\n", "init (9, 5, False)\n", "player value 28 | dealer value 17\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (17, 10, True)\n", "player value 22 | dealer value 20\n", "init (13, 7, False)\n", "player value 18 | dealer value 23\n", "init (13, 7, False)\n", "player value 16 | dealer value 23\n", "init (13, 8, False)\n", "player value 16 | dealer value 19\n", "init (17, 8, False)\n", "player value 27 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 26\n", "init (14, 3, False)\n", "player value 24 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (15, 7, False)\n", "player value 16 | dealer value 23\n", "init (21, 4, True)\n", "init (13, 2, False)\n", "player value 20 | dealer value 20\n", "init (18, 6, False)\n", "player value 18 | dealer value 21\n", "init (10, 10, False)\n", "player value 30 | dealer value 20\n", "init (20, 10, True)\n", "player value 17 | dealer value 20\n", "init (6, 7, False)\n", "player value 22 | dealer value 22\n", "init (12, 5, False)\n", "player value 12 | dealer value 17\n", "init (12, 6, False)\n", "player value 20 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (14, 1, False)\n", "player value 25 | dealer value 23\n", "init (21, 8, True)\n", "init (12, 3, False)\n", "player value 12 | dealer value 21\n", "init (18, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 9, False)\n", "player value 15 | dealer value 21\n", "init (20, 10, False)\n", "init (17, 4, False)\n", "player value 17 | dealer value 19\n", "init (12, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 3, False)\n", "player value 14 | dealer value 24\n", "init (11, 1, False)\n", "player value 21 | dealer value 19\n", "init (12, 10, False)\n", "player value 17 | dealer value 17\n", "init (15, 10, False)\n", "init (15, 7, False)\n", "player value 16 | dealer value 18\n", "init (15, 6, False)\n", "player value 19 | dealer value 17\n", "init (6, 2, False)\n", "player value 19 | dealer value 24\n", "init (12, 10, False)\n", "player value 31 | dealer value 20\n", "init (14, 2, False)\n", "player value 14 | dealer value 21\n", "init (13, 1, False)\n", "player value 13 | dealer value 20\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (21, 5, True)\n", "init (7, 2, False)\n", "player value 17 | dealer value 22\n", "init (20, 9, True)\n", "player value 20 | dealer value 19\n", "init (15, 1, False)\n", "player value 15 | dealer value 25\n", "init (14, 10, False)\n", "player value 20 | dealer value 26\n", "init (16, 10, False)\n", "player value 28 | dealer value 23\n", "init (11, 3, False)\n", "player value 21 | dealer value 17\n", "init (14, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 17\n", "init (13, 4, False)\n", "player value 13 | dealer value 21\n", "init (16, 8, False)\n", "player value 26 | dealer value 21\n", "init (13, 8, False)\n", "player value 23 | dealer value 23\n", "init (21, 2, True)\n", "init (14, 6, False)\n", "player value 19 | dealer value 26\n", "init (17, 8, False)\n", "player value 27 | dealer value 18\n", "init (19, 8, True)\n", "player value 20 | dealer value 18\n", "init (13, 1, False)\n", "player value 20 | dealer value 17\n", "init (19, 9, True)\n", "player value 13 | dealer value 19\n", "init (14, 8, False)\n", "player value 16 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 24\n", "init (14, 7, False)\n", "player value 14 | dealer value 17\n", "init (4, 10, False)\n", "player value 13 | dealer value 18\n", "init (15, 9, True)\n", "player value 15 | dealer value 19\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (14, 6, False)\n", "player value 20 | dealer value 25\n", "init (20, 7, False)\n", "player value 24 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 24\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (10, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (12, 9, False)\n", "player value 22 | dealer value 22\n", "init (15, 2, True)\n", "player value 15 | dealer value 22\n", "init (15, 9, True)\n", "player value 21 | dealer value 19\n", "init (16, 10, False)\n", "player value 24 | dealer value 20\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (15, 7, False)\n", "player value 25 | dealer value 17\n", "init (20, 5, True)\n", "player value 23 | dealer value 18\n", "init (17, 9, True)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "player value 21 | dealer value 21\n", "init (15, 10, False)\n", "init (18, 8, False)\n", "player value 18 | dealer value 25\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (9, 10, False)\n", "init (11, 9, False)\n", "player value 21 | dealer value 17\n", "init (21, 10, True)\n", "init (12, 3, False)\n", "player value 22 | dealer value 23\n", "init (14, 10, True)\n", "player value 24 | dealer value 20\n", "init (19, 5, False)\n", "player value 19 | dealer value 26\n", "init (5, 6, False)\n", "player value 22 | dealer value 21\n", "init (15, 9, False)\n", "player value 15 | dealer value 25\n", "init (14, 10, False)\n", "player value 18 | dealer value 19\n", "init (14, 10, False)\n", "player value 24 | dealer value 24\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (11, 10, False)\n", "player value 14 | dealer value 18\n", "init (15, 3, False)\n", "player value 25 | dealer value 19\n", "init (12, 10, False)\n", "player value 15 | dealer value 17\n", "init (13, 3, False)\n", "player value 13 | dealer value 24\n", "init (19, 6, True)\n", "player value 22 | dealer value 23\n", "init (9, 5, False)\n", "player value 15 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 7, True)\n", "player value 27 | dealer value 18\n", "init (15, 2, False)\n", "player value 25 | dealer value 22\n", "init (12, 1, False)\n", "player value 19 | dealer value 18\n", "init (13, 1, False)\n", "init (21, 10, True)\n", "init (10, 3, False)\n", "player value 16 | dealer value 19\n", "init (15, 8, False)\n", "player value 25 | dealer value 17\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (15, 7, False)\n", "player value 25 | dealer value 21\n", "init (16, 5, False)\n", "player value 26 | dealer value 18\n", "init (19, 10, False)\n", "player value 25 | dealer value 24\n", "init (13, 9, True)\n", "player value 22 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 7, False)\n", "player value 20 | dealer value 22\n", "init (20, 2, False)\n", "player value 20 | dealer value 23\n", "init (13, 2, False)\n", "player value 13 | dealer value 25\n", "init (19, 5, False)\n", "player value 19 | dealer value 25\n", "init (11, 3, False)\n", "player value 16 | dealer value 23\n", "init (19, 10, False)\n", "player value 21 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 10, True)\n", "player value 25 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 19\n", "init (16, 8, False)\n", "player value 26 | dealer value 18\n", "init (12, 9, False)\n", "player value 16 | dealer value 17\n", "init (14, 10, True)\n", "player value 25 | dealer value 19\n", "init (12, 6, False)\n", "player value 18 | dealer value 19\n", "init (7, 3, False)\n", "player value 21 | dealer value 19\n", "init (14, 3, False)\n", "player value 26 | dealer value 21\n", "init (12, 10, True)\n", "player value 12 | dealer value 19\n", "init (10, 4, False)\n", "player value 17 | dealer value 19\n", "init (12, 8, False)\n", "player value 14 | dealer value 20\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (7, 5, False)\n", "player value 16 | dealer value 21\n", "init (9, 4, False)\n", "player value 18 | dealer value 22\n", "init (13, 5, False)\n", "player value 13 | dealer value 22\n", "init (16, 4, False)\n", "player value 17 | dealer value 19\n", "init (14, 1, True)\n", "player value 14 | dealer value 25\n", "init (20, 10, False)\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (19, 3, False)\n", "player value 19 | dealer value 22\n", "init (21, 10, True)\n", "init (13, 10, False)\n", "player value 22 | dealer value 17\n", "init (12, 7, False)\n", "player value 21 | dealer value 24\n", "init (15, 9, False)\n", "player value 15 | dealer value 19\n", "init (15, 6, False)\n", "player value 23 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 8, True)\n", "player value 14 | dealer value 21\n", "init (13, 9, False)\n", "player value 21 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 25\n", "init (19, 1, False)\n", "player value 19 | dealer value 20\n", "init (16, 7, False)\n", "player value 21 | dealer value 18\n", "init (21, 10, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (18, 1, True)\n", "player value 18 | dealer value 18\n", "init (15, 4, False)\n", "player value 21 | dealer value 23\n", "init (13, 8, False)\n", "player value 24 | dealer value 17\n", "init (13, 2, False)\n", "player value 13 | dealer value 23\n", "init (11, 10, False)\n", "player value 19 | dealer value 23\n", "init (12, 10, False)\n", "init (15, 7, False)\n", "player value 17 | dealer value 18\n", "init (16, 10, True)\n", "player value 24 | dealer value 18\n", "init (9, 10, False)\n", "player value 24 | dealer value 20\n", "init (7, 6, False)\n", "player value 18 | dealer value 17\n", "init (17, 5, True)\n", "player value 19 | dealer value 18\n", "init (13, 7, False)\n", "player value 21 | dealer value 25\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (12, 5, False)\n", "player value 13 | dealer value 20\n", "init (15, 1, False)\n", "player value 22 | dealer value 22\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (19, 3, False)\n", "player value 19 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (13, 3, False)\n", "player value 13 | dealer value 18\n", "init (9, 9, False)\n", "player value 19 | dealer value 19\n", "init (13, 3, False)\n", "player value 13 | dealer value 19\n", "init (18, 3, True)\n", "player value 23 | dealer value 18\n", "init (11, 4, False)\n", "player value 18 | dealer value 22\n", "init (15, 3, False)\n", "player value 21 | dealer value 20\n", "init (13, 5, False)\n", "player value 13 | dealer value 20\n", "init (13, 10, True)\n", "player value 13 | dealer value 20\n", "init (16, 5, False)\n", "player value 23 | dealer value 23\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (10, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 9, False)\n", "player value 15 | dealer value 20\n", "init (16, 9, False)\n", "player value 20 | dealer value 20\n", "init (10, 10, False)\n", "player value 21 | dealer value 26\n", "init (7, 10, False)\n", "player value 26 | dealer value 17\n", "init (17, 3, False)\n", "player value 25 | dealer value 19\n", "init (10, 10, False)\n", "player value 23 | dealer value 23\n", "init (18, 7, True)\n", "player value 18 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 17\n", "init (16, 2, False)\n", "player value 24 | dealer value 20\n", "init (13, 10, True)\n", "player value 13 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 5, False)\n", "player value 15 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 18\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 7, False)\n", "player value 20 | dealer value 21\n", "init (20, 1, False)\n", "init (15, 1, False)\n", "init (5, 2, False)\n", "player value 25 | dealer value 21\n", "init (16, 4, False)\n", "player value 26 | dealer value 22\n", "init (8, 10, False)\n", "player value 23 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 2, False)\n", "player value 12 | dealer value 23\n", "init (16, 8, True)\n", "player value 19 | dealer value 18\n", "init (9, 6, False)\n", "player value 22 | dealer value 19\n", "init (16, 7, False)\n", "player value 26 | dealer value 17\n", "init (7, 10, False)\n", "player value 17 | dealer value 23\n", "init (15, 5, True)\n", "player value 15 | dealer value 20\n", "init (4, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 2, False)\n", "player value 23 | dealer value 18\n", "init (12, 9, False)\n", "player value 22 | dealer value 19\n", "init (18, 3, True)\n", "player value 19 | dealer value 20\n", "init (7, 8, False)\n", "player value 18 | dealer value 18\n", "init (14, 10, True)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 20\n", "init (13, 4, False)\n", "player value 20 | dealer value 24\n", "init (12, 7, False)\n", "player value 24 | dealer value 17\n", "init (14, 2, False)\n", "player value 22 | dealer value 20\n", "init (11, 10, False)\n", "player value 17 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (8, 8, False)\n", "player value 15 | dealer value 18\n", "init (12, 4, False)\n", "player value 22 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 25\n", "init (12, 4, False)\n", "player value 17 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (11, 10, False)\n", "player value 24 | dealer value 26\n", "init (14, 6, True)\n", "player value 24 | dealer value 26\n", "init (11, 3, False)\n", "player value 20 | dealer value 23\n", "init (10, 1, False)\n", "player value 21 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 25\n", "init (21, 10, True)\n", "init (15, 10, True)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 30 | dealer value 20\n", "init (18, 10, True)\n", "init (21, 1, True)\n", "init (19, 1, False)\n", "player value 26 | dealer value 19\n", "init (15, 1, False)\n", "init (11, 1, False)\n", "player value 21 | dealer value 19\n", "init (12, 9, True)\n", "player value 17 | dealer value 17\n", "init (11, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 10, False)\n", "player value 22 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 21\n", "init (15, 2, False)\n", "player value 25 | dealer value 21\n", "init (12, 8, False)\n", "player value 21 | dealer value 18\n", "init (12, 4, False)\n", "player value 25 | dealer value 19\n", "init (20, 10, False)\n", "player value 30 | dealer value 22\n", "init (8, 3, False)\n", "player value 18 | dealer value 17\n", "init (21, 10, True)\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 24\n", "init (13, 8, True)\n", "player value 23 | dealer value 26\n", "init (10, 7, False)\n", "player value 20 | dealer value 17\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (8, 10, False)\n", "init (13, 10, False)\n", "player value 13 | dealer value 25\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (8, 3, False)\n", "player value 18 | dealer value 20\n", "init (12, 1, False)\n", "player value 22 | dealer value 17\n", "init (14, 10, False)\n", "init (9, 10, False)\n", "player value 27 | dealer value 19\n", "init (19, 7, False)\n", "player value 19 | dealer value 20\n", "init (11, 10, False)\n", "player value 17 | dealer value 22\n", "init (9, 5, False)\n", "player value 26 | dealer value 18\n", "init (13, 8, False)\n", "player value 16 | dealer value 22\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (12, 5, False)\n", "player value 19 | dealer value 22\n", "init (9, 10, False)\n", "player value 24 | dealer value 19\n", "init (15, 7, False)\n", "player value 26 | dealer value 26\n", "init (10, 10, False)\n", "player value 19 | dealer value 25\n", "init (12, 10, False)\n", "player value 19 | dealer value 19\n", "init (9, 5, False)\n", "player value 19 | dealer value 24\n", "init (16, 3, False)\n", "player value 18 | dealer value 22\n", "init (14, 10, False)\n", "player value 24 | dealer value 17\n", "init (16, 5, False)\n", "player value 16 | dealer value 25\n", "init (8, 7, False)\n", "player value 19 | dealer value 17\n", "init (16, 2, True)\n", "player value 19 | dealer value 25\n", "init (10, 6, False)\n", "player value 20 | dealer value 23\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (6, 7, False)\n", "player value 21 | dealer value 19\n", "init (11, 8, False)\n", "player value 25 | dealer value 17\n", "init (19, 8, True)\n", "player value 19 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 21\n", "init (6, 10, False)\n", "player value 25 | dealer value 20\n", "init (20, 10, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (14, 3, True)\n", "player value 14 | dealer value 23\n", "init (11, 3, False)\n", "player value 22 | dealer value 23\n", "init (12, 2, False)\n", "player value 12 | dealer value 20\n", "init (10, 6, False)\n", "player value 14 | dealer value 25\n", "init (19, 4, False)\n", "player value 27 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 21\n", "init (8, 5, False)\n", "player value 19 | dealer value 23\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (7, 7, False)\n", "player value 23 | dealer value 18\n", "init (12, 5, False)\n", "player value 21 | dealer value 23\n", "init (21, 5, True)\n", "init (20, 8, False)\n", "player value 24 | dealer value 23\n", "init (4, 10, False)\n", "player value 25 | dealer value 21\n", "init (21, 10, True)\n", "init (21, 1, True)\n", "init (8, 6, False)\n", "player value 17 | dealer value 21\n", "init (6, 6, False)\n", "player value 26 | dealer value 24\n", "init (4, 7, False)\n", "player value 28 | dealer value 24\n", "init (18, 10, True)\n", "player value 18 | dealer value 19\n", "init (21, 10, True)\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (14, 10, False)\n", "player value 21 | dealer value 19\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (16, 2, False)\n", "player value 16 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 23\n", "init (14, 5, False)\n", "player value 20 | dealer value 21\n", "init (4, 7, False)\n", "player value 22 | dealer value 17\n", "init (18, 4, False)\n", "player value 18 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 24\n", "init (14, 4, False)\n", "player value 23 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 4, False)\n", "player value 25 | dealer value 17\n", "init (11, 2, False)\n", "player value 19 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (10, 10, False)\n", "player value 16 | dealer value 20\n", "init (19, 1, False)\n", "player value 19 | dealer value 22\n", "init (19, 1, False)\n", "player value 19 | dealer value 19\n", "init (18, 10, False)\n", "init (17, 4, False)\n", "player value 26 | dealer value 18\n", "init (20, 2, False)\n", "player value 26 | dealer value 20\n", "init (13, 3, False)\n", "player value 22 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (10, 5, False)\n", "player value 16 | dealer value 26\n", "init (12, 2, False)\n", "player value 17 | dealer value 26\n", "init (16, 6, True)\n", "player value 16 | dealer value 26\n", "init (14, 9, False)\n", "player value 18 | dealer value 24\n", "init (19, 10, False)\n", "player value 21 | dealer value 18\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (7, 1, False)\n", "player value 24 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (17, 7, False)\n", "player value 24 | dealer value 17\n", "init (12, 1, False)\n", "init (11, 10, False)\n", "player value 13 | dealer value 20\n", "init (12, 5, False)\n", "player value 22 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (13, 8, False)\n", "player value 22 | dealer value 17\n", "init (14, 8, False)\n", "player value 14 | dealer value 22\n", "init (18, 10, False)\n", "player value 18 | dealer value 22\n", "init (13, 9, False)\n", "player value 23 | dealer value 22\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (15, 3, False)\n", "player value 17 | dealer value 24\n", "init (19, 6, False)\n", "player value 19 | dealer value 21\n", "init (18, 5, False)\n", "player value 18 | dealer value 24\n", "init (16, 5, False)\n", "player value 16 | dealer value 19\n", "init (16, 4, False)\n", "player value 20 | dealer value 18\n", "init (14, 1, False)\n", "init (13, 5, False)\n", "player value 20 | dealer value 24\n", "init (16, 10, False)\n", "player value 25 | dealer value 17\n", "init (5, 8, False)\n", "player value 18 | dealer value 18\n", "init (15, 2, False)\n", "player value 25 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 24\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (21, 6, True)\n", "init (12, 2, False)\n", "player value 12 | dealer value 17\n", "init (15, 5, True)\n", "player value 15 | dealer value 23\n", "init (13, 4, False)\n", "player value 23 | dealer value 23\n", "init (7, 4, False)\n", "player value 22 | dealer value 24\n", "init (10, 8, False)\n", "player value 14 | dealer value 18\n", "init (13, 3, False)\n", "player value 22 | dealer value 22\n", "init (13, 3, False)\n", "player value 13 | dealer value 26\n", "init (15, 1, False)\n", "player value 22 | dealer value 19\n", "init (18, 10, True)\n", "player value 13 | dealer value 20\n", "init (17, 10, True)\n", "player value 21 | dealer value 19\n", "init (11, 6, False)\n", "player value 26 | dealer value 25\n", "init (16, 1, False)\n", "player value 21 | dealer value 23\n", "init (8, 10, False)\n", "player value 18 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 4, True)\n", "player value 14 | dealer value 17\n", "init (13, 1, False)\n", "init (20, 10, True)\n", "player value 20 | dealer value 25\n", "init (9, 8, False)\n", "player value 14 | dealer value 17\n", "init (6, 8, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 25\n", "init (18, 7, False)\n", "player value 18 | dealer value 22\n", "init (11, 6, False)\n", "player value 14 | dealer value 17\n", "init (10, 9, False)\n", "player value 19 | dealer value 17\n", "init (18, 8, False)\n", "player value 18 | dealer value 24\n", "init (9, 5, False)\n", "player value 16 | dealer value 19\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (15, 8, False)\n", "player value 22 | dealer value 18\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (12, 9, False)\n", "player value 21 | dealer value 17\n", "init (13, 4, False)\n", "player value 25 | dealer value 25\n", "init (17, 1, False)\n", "init (16, 7, False)\n", "player value 26 | dealer value 17\n", "init (8, 10, False)\n", "player value 24 | dealer value 18\n", "init (4, 10, False)\n", "player value 21 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (7, 7, False)\n", "player value 18 | dealer value 17\n", "init (15, 6, False)\n", "player value 22 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (12, 6, False)\n", "player value 13 | dealer value 18\n", "init (15, 6, False)\n", "player value 22 | dealer value 20\n", "init (12, 7, False)\n", "player value 18 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 21\n", "init (5, 4, False)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 20 | dealer value 26\n", "init (16, 7, False)\n", "player value 21 | dealer value 24\n", "init (10, 6, False)\n", "player value 13 | dealer value 26\n", "init (13, 4, False)\n", "player value 19 | dealer value 17\n", "init (9, 9, False)\n", "player value 20 | dealer value 21\n", "init (14, 4, True)\n", "player value 19 | dealer value 25\n", "init (12, 10, True)\n", "init (15, 4, False)\n", "player value 15 | dealer value 26\n", "init (16, 1, False)\n", "player value 23 | dealer value 18\n", "init (17, 1, False)\n", "player value 25 | dealer value 20\n", "init (9, 9, False)\n", "player value 26 | dealer value 19\n", "init (19, 7, False)\n", "player value 19 | dealer value 21\n", "init (16, 8, False)\n", "player value 16 | dealer value 20\n", "init (14, 8, False)\n", "player value 16 | dealer value 18\n", "init (19, 8, True)\n", "player value 19 | dealer value 18\n", "init (15, 10, False)\n", "init (8, 3, False)\n", "player value 23 | dealer value 21\n", "init (18, 10, True)\n", "player value 21 | dealer value 25\n", "init (15, 9, False)\n", "player value 15 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (9, 6, False)\n", "player value 18 | dealer value 23\n", "init (9, 6, False)\n", "player value 19 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 17\n", "init (12, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (19, 10, True)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (8, 3, False)\n", "player value 16 | dealer value 20\n", "init (18, 5, True)\n", "player value 20 | dealer value 17\n", "init (13, 7, True)\n", "player value 22 | dealer value 26\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 22\n", "init (6, 3, False)\n", "player value 26 | dealer value 22\n", "init (8, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 6, False)\n", "player value 24 | dealer value 23\n", "init (15, 5, False)\n", "player value 15 | dealer value 23\n", "init (8, 6, False)\n", "player value 24 | dealer value 22\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (13, 4, False)\n", "player value 19 | dealer value 24\n", "init (13, 3, False)\n", "player value 13 | dealer value 22\n", "init (18, 5, False)\n", "player value 18 | dealer value 18\n", "init (11, 10, False)\n", "player value 13 | dealer value 20\n", "init (13, 2, False)\n", "player value 13 | dealer value 17\n", "init (20, 4, True)\n", "player value 20 | dealer value 24\n", "init (13, 3, False)\n", "player value 13 | dealer value 21\n", "init (5, 3, False)\n", "player value 20 | dealer value 22\n", "init (12, 2, False)\n", "player value 17 | dealer value 17\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (13, 7, False)\n", "player value 19 | dealer value 20\n", "init (12, 9, False)\n", "player value 28 | dealer value 18\n", "init (12, 7, False)\n", "player value 20 | dealer value 23\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (19, 3, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (18, 4, True)\n", "player value 18 | dealer value 17\n", "init (20, 3, True)\n", "player value 18 | dealer value 22\n", "init (14, 8, False)\n", "player value 24 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (16, 10, False)\n", "player value 21 | dealer value 20\n", "init (16, 8, False)\n", "player value 16 | dealer value 21\n", "init (6, 7, False)\n", "player value 20 | dealer value 20\n", "init (12, 6, False)\n", "player value 25 | dealer value 17\n", "init (9, 4, False)\n", "player value 19 | dealer value 17\n", "init (9, 8, False)\n", "player value 18 | dealer value 18\n", "init (9, 9, False)\n", "player value 20 | dealer value 18\n", "init (20, 9, True)\n", "player value 20 | dealer value 24\n", "init (8, 10, False)\n", "player value 13 | dealer value 17\n", "init (4, 6, False)\n", "player value 23 | dealer value 18\n", "init (13, 1, True)\n", "init (17, 8, False)\n", "player value 19 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 26\n", "init (18, 10, True)\n", "player value 23 | dealer value 17\n", "init (18, 1, False)\n", "init (12, 3, False)\n", "player value 22 | dealer value 23\n", "init (21, 10, True)\n", "init (14, 10, True)\n", "player value 24 | dealer value 20\n", "init (19, 2, False)\n", "player value 19 | dealer value 19\n", "init (12, 9, False)\n", "player value 27 | dealer value 19\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (13, 2, False)\n", "player value 13 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 19\n", "init (14, 4, False)\n", "player value 24 | dealer value 25\n", "init (15, 2, True)\n", "player value 15 | dealer value 17\n", "init (15, 4, True)\n", "player value 12 | dealer value 19\n", "init (10, 6, False)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 21\n", "init (13, 5, False)\n", "player value 22 | dealer value 25\n", "init (10, 10, False)\n", "init (19, 1, False)\n", "player value 19 | dealer value 21\n", "init (16, 7, False)\n", "player value 18 | dealer value 22\n", "init (12, 10, True)\n", "player value 13 | dealer value 23\n", "init (13, 10, False)\n", "player value 13 | dealer value 19\n", "init (8, 6, False)\n", "player value 18 | dealer value 24\n", "init (19, 4, False)\n", "player value 19 | dealer value 21\n", "init (20, 1, False)\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (15, 1, False)\n", "player value 15 | dealer value 18\n", "init (17, 10, False)\n", "player value 17 | dealer value 23\n", "init (19, 9, False)\n", "player value 19 | dealer value 18\n", "init (13, 7, False)\n", "player value 23 | dealer value 26\n", "init (9, 3, False)\n", "player value 14 | dealer value 24\n", "init (18, 5, True)\n", "player value 16 | dealer value 20\n", "init (9, 10, False)\n", "player value 19 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 7, False)\n", "player value 23 | dealer value 17\n", "init (10, 10, False)\n", "player value 13 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 1, True)\n", "player value 23 | dealer value 19\n", "init (7, 7, False)\n", "player value 17 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (8, 10, False)\n", "player value 24 | dealer value 18\n", "init (17, 4, True)\n", "player value 26 | dealer value 21\n", "init (19, 10, False)\n", "player value 29 | dealer value 17\n", "init (17, 6, False)\n", "player value 17 | dealer value 24\n", "init (13, 6, True)\n", "player value 21 | dealer value 21\n", "init (15, 9, False)\n", "player value 18 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 23\n", "init (15, 10, False)\n", "player value 25 | dealer value 18\n", "init (15, 9, False)\n", "player value 22 | dealer value 26\n", "init (14, 2, False)\n", "player value 20 | dealer value 22\n", "init (13, 8, False)\n", "player value 13 | dealer value 19\n", "init (5, 10, False)\n", "player value 18 | dealer value 17\n", "init (19, 9, True)\n", "player value 19 | dealer value 26\n", "init (17, 10, False)\n", "player value 21 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (16, 6, False)\n", "player value 29 | dealer value 20\n", "init (8, 4, False)\n", "player value 15 | dealer value 22\n", "init (15, 4, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 26 | dealer value 20\n", "init (12, 3, False)\n", "player value 18 | dealer value 23\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (13, 3, True)\n", "player value 17 | dealer value 18\n", "init (6, 10, False)\n", "player value 22 | dealer value 19\n", "init (19, 3, False)\n", "player value 19 | dealer value 24\n", "init (15, 7, False)\n", "player value 27 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (15, 6, False)\n", "player value 15 | dealer value 17\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (6, 2, False)\n", "player value 13 | dealer value 24\n", "init (14, 8, False)\n", "player value 14 | dealer value 26\n", "init (10, 3, False)\n", "player value 20 | dealer value 21\n", "init (14, 10, False)\n", "player value 17 | dealer value 20\n", "init (9, 1, False)\n", "init (8, 9, False)\n", "player value 19 | dealer value 17\n", "init (21, 1, True)\n", "init (14, 3, False)\n", "player value 23 | dealer value 20\n", "init (7, 10, False)\n", "player value 20 | dealer value 25\n", "init (19, 2, False)\n", "player value 19 | dealer value 25\n", "init (17, 6, False)\n", "player value 17 | dealer value 20\n", "init (6, 7, False)\n", "player value 26 | dealer value 21\n", "init (14, 2, False)\n", "player value 23 | dealer value 21\n", "init (16, 8, True)\n", "player value 19 | dealer value 18\n", "init (9, 5, False)\n", "player value 17 | dealer value 18\n", "init (21, 6, True)\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (14, 6, False)\n", "player value 17 | dealer value 26\n", "init (13, 2, False)\n", "player value 13 | dealer value 21\n", "init (20, 10, False)\n", "player value 24 | dealer value 18\n", "init (21, 10, True)\n", "init (16, 4, False)\n", "player value 19 | dealer value 21\n", "init (21, 10, True)\n", "init (11, 4, False)\n", "player value 21 | dealer value 23\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (16, 9, True)\n", "player value 16 | dealer value 19\n", "init (12, 9, False)\n", "player value 12 | dealer value 19\n", "init (7, 2, False)\n", "player value 17 | dealer value 20\n", "init (14, 7, False)\n", "player value 24 | dealer value 17\n", "init (15, 10, False)\n", "player value 23 | dealer value 17\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (13, 10, True)\n", "player value 13 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (13, 3, False)\n", "player value 23 | dealer value 20\n", "init (6, 7, False)\n", "player value 17 | dealer value 22\n", "init (21, 9, True)\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (12, 7, True)\n", "player value 12 | dealer value 23\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 10, True)\n", "player value 15 | dealer value 25\n", "init (14, 10, False)\n", "player value 31 | dealer value 21\n", "init (14, 10, True)\n", "player value 14 | dealer value 17\n", "init (16, 7, False)\n", "player value 27 | dealer value 17\n", "init (11, 5, False)\n", "player value 21 | dealer value 19\n", "init (13, 7, False)\n", "player value 20 | dealer value 19\n", "init (15, 3, False)\n", "player value 20 | dealer value 19\n", "init (14, 8, False)\n", "player value 14 | dealer value 18\n", "init (13, 3, False)\n", "player value 13 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 25\n", "init (17, 5, False)\n", "player value 21 | dealer value 25\n", "init (10, 7, False)\n", "player value 17 | dealer value 17\n", "init (16, 3, False)\n", "player value 16 | dealer value 21\n", "init (10, 8, False)\n", "player value 26 | dealer value 21\n", "init (14, 8, False)\n", "player value 14 | dealer value 23\n", "init (16, 4, False)\n", "player value 21 | dealer value 24\n", "init (13, 7, True)\n", "player value 23 | dealer value 19\n", "init (10, 10, False)\n", "player value 14 | dealer value 20\n", "init (19, 1, False)\n", "init (12, 8, False)\n", "player value 12 | dealer value 20\n", "init (13, 4, False)\n", "player value 20 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 26\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (12, 2, False)\n", "player value 13 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (17, 4, False)\n", "player value 25 | dealer value 17\n", "init (11, 4, False)\n", "player value 21 | dealer value 22\n", "init (10, 10, False)\n", "player value 20 | dealer value 19\n", "init (19, 2, False)\n", "player value 19 | dealer value 22\n", "init (16, 6, True)\n", "player value 16 | dealer value 26\n", "init (15, 3, True)\n", "player value 17 | dealer value 19\n", "init (21, 3, True)\n", "init (19, 2, False)\n", "player value 19 | dealer value 24\n", "init (20, 7, False)\n", "player value 30 | dealer value 17\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (20, 5, False)\n", "player value 30 | dealer value 19\n", "init (18, 6, False)\n", "player value 18 | dealer value 18\n", "init (13, 6, False)\n", "player value 13 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (19, 10, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (5, 4, False)\n", "player value 22 | dealer value 21\n", "init (21, 10, True)\n", "init (14, 5, False)\n", "player value 21 | dealer value 21\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (16, 3, False)\n", "player value 16 | dealer value 17\n", "init (15, 6, False)\n", "player value 25 | dealer value 26\n", "init (17, 8, True)\n", "player value 18 | dealer value 22\n", "init (20, 10, False)\n", "init (9, 10, False)\n", "player value 20 | dealer value 17\n", "init (8, 4, False)\n", "player value 26 | dealer value 24\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (14, 5, False)\n", "player value 24 | dealer value 18\n", "init (13, 3, False)\n", "player value 18 | dealer value 20\n", "init (16, 5, False)\n", "player value 26 | dealer value 18\n", "init (13, 8, False)\n", "player value 22 | dealer value 26\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (13, 1, False)\n", "init (21, 10, True)\n", "init (17, 8, False)\n", "player value 23 | dealer value 18\n", "init (21, 2, True)\n", "init (15, 1, False)\n", "player value 25 | dealer value 18\n", "init (13, 9, False)\n", "player value 19 | dealer value 17\n", "init (19, 3, False)\n", "player value 19 | dealer value 17\n", "init (11, 5, False)\n", "player value 23 | dealer value 26\n", "init (18, 10, False)\n", "player value 18 | dealer value 22\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (19, 1, False)\n", "init (16, 1, False)\n", "player value 22 | dealer value 24\n", "init (18, 8, False)\n", "player value 28 | dealer value 22\n", "init (12, 1, False)\n", "init (4, 5, False)\n", "player value 16 | dealer value 23\n", "init (17, 4, True)\n", "player value 20 | dealer value 24\n", "init (13, 7, False)\n", "player value 26 | dealer value 21\n", "init (16, 9, False)\n", "player value 26 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (16, 9, True)\n", "player value 16 | dealer value 18\n", "init (20, 10, False)\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (17, 8, True)\n", "player value 15 | dealer value 23\n", "init (13, 9, False)\n", "player value 22 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (15, 5, False)\n", "player value 15 | dealer value 23\n", "init (16, 9, False)\n", "player value 19 | dealer value 18\n", "init (15, 1, False)\n", "player value 15 | dealer value 20\n", "init (17, 2, False)\n", "player value 17 | dealer value 18\n", "round 4000\n", "init (20, 6, False)\n", "player value 20 | dealer value 18\n", "init (16, 8, True)\n", "player value 20 | dealer value 19\n", "init (12, 4, False)\n", "player value 18 | dealer value 23\n", "init (20, 3, True)\n", "player value 20 | dealer value 25\n", "init (21, 7, True)\n", "init (12, 3, False)\n", "player value 22 | dealer value 21\n", "init (17, 4, False)\n", "player value 27 | dealer value 17\n", "init (12, 7, False)\n", "player value 22 | dealer value 17\n", "init (19, 3, False)\n", "player value 19 | dealer value 20\n", "init (17, 6, True)\n", "player value 17 | dealer value 19\n", "init (12, 4, False)\n", "player value 27 | dealer value 19\n", "init (7, 6, False)\n", "player value 18 | dealer value 26\n", "init (11, 10, False)\n", "init (8, 7, False)\n", "player value 20 | dealer value 17\n", "init (12, 7, False)\n", "player value 19 | dealer value 20\n", "init (21, 5, True)\n", "init (10, 7, False)\n", "player value 20 | dealer value 23\n", "init (11, 1, False)\n", "player value 21 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (14, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (13, 9, False)\n", "player value 26 | dealer value 24\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 2, False)\n", "player value 20 | dealer value 17\n", "init (17, 4, False)\n", "player value 22 | dealer value 19\n", "init (15, 6, False)\n", "player value 25 | dealer value 18\n", "init (13, 10, False)\n", "player value 15 | dealer value 18\n", "init (12, 3, False)\n", "player value 21 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (9, 10, False)\n", "player value 18 | dealer value 26\n", "init (20, 1, True)\n", "init (13, 9, False)\n", "player value 22 | dealer value 18\n", "init (8, 6, False)\n", "player value 18 | dealer value 18\n", "init (17, 10, True)\n", "player value 17 | dealer value 20\n", "init (16, 5, True)\n", "player value 20 | dealer value 17\n", "init (10, 1, False)\n", "init (6, 8, False)\n", "player value 18 | dealer value 19\n", "init (14, 10, False)\n", "player value 14 | dealer value 19\n", "init (16, 5, False)\n", "player value 16 | dealer value 23\n", "init (6, 3, False)\n", "player value 19 | dealer value 24\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (17, 6, False)\n", "player value 17 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (8, 10, False)\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (18, 7, True)\n", "player value 18 | dealer value 25\n", "init (15, 2, True)\n", "player value 15 | dealer value 18\n", "init (9, 9, False)\n", "player value 22 | dealer value 20\n", "init (12, 2, False)\n", "player value 21 | dealer value 17\n", "init (17, 5, True)\n", "player value 17 | dealer value 23\n", "init (7, 10, False)\n", "player value 25 | dealer value 18\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 9, False)\n", "player value 22 | dealer value 20\n", "init (13, 1, False)\n", "player value 19 | dealer value 22\n", "init (18, 5, False)\n", "player value 18 | dealer value 18\n", "init (15, 9, False)\n", "player value 22 | dealer value 19\n", "init (7, 2, False)\n", "player value 21 | dealer value 20\n", "init (20, 2, False)\n", "player value 27 | dealer value 18\n", "init (6, 3, False)\n", "player value 25 | dealer value 24\n", "init (17, 4, False)\n", "player value 18 | dealer value 21\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 1, False)\n", "init (21, 1, True)\n", "init (11, 4, False)\n", "player value 21 | dealer value 18\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 7, False)\n", "player value 20 | dealer value 25\n", "init (10, 6, False)\n", "player value 25 | dealer value 17\n", "init (14, 6, False)\n", "player value 24 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 10, False)\n", "player value 20 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (21, 4, True)\n", "init (12, 2, False)\n", "player value 19 | dealer value 17\n", "init (15, 10, False)\n", "player value 18 | dealer value 19\n", "init (11, 10, False)\n", "player value 28 | dealer value 20\n", "init (11, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, False)\n", "player value 22 | dealer value 17\n", "init (9, 6, False)\n", "player value 20 | dealer value 26\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (16, 9, False)\n", "player value 21 | dealer value 19\n", "init (20, 3, False)\n", "player value 29 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 25\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (8, 8, False)\n", "player value 18 | dealer value 25\n", "init (7, 5, False)\n", "player value 27 | dealer value 18\n", "init (10, 10, False)\n", "player value 27 | dealer value 24\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (13, 2, True)\n", "player value 20 | dealer value 22\n", "init (20, 6, False)\n", "player value 24 | dealer value 17\n", "init (9, 10, False)\n", "player value 21 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (8, 7, False)\n", "player value 18 | dealer value 24\n", "init (16, 5, False)\n", "player value 16 | dealer value 18\n", "init (17, 4, False)\n", "player value 27 | dealer value 20\n", "init (14, 2, True)\n", "player value 15 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (14, 8, False)\n", "player value 14 | dealer value 25\n", "init (20, 3, False)\n", "player value 30 | dealer value 20\n", "init (16, 1, True)\n", "player value 26 | dealer value 20\n", "init (16, 7, False)\n", "player value 22 | dealer value 21\n", "init (14, 1, False)\n", "init (7, 3, False)\n", "player value 21 | dealer value 21\n", "init (19, 6, False)\n", "player value 19 | dealer value 17\n", "init (21, 1, True)\n", "init (15, 3, True)\n", "player value 15 | dealer value 19\n", "init (10, 10, False)\n", "player value 20 | dealer value 18\n", "init (15, 6, False)\n", "player value 15 | dealer value 19\n", "init (10, 9, False)\n", "player value 15 | dealer value 19\n", "init (12, 9, False)\n", "player value 22 | dealer value 23\n", "init (15, 3, False)\n", "player value 15 | dealer value 18\n", "init (20, 5, True)\n", "player value 15 | dealer value 21\n", "init (21, 5, True)\n", "init (16, 10, False)\n", "player value 25 | dealer value 18\n", "init (14, 8, False)\n", "player value 14 | dealer value 20\n", "init (14, 7, False)\n", "player value 21 | dealer value 20\n", "init (9, 1, False)\n", "player value 16 | dealer value 20\n", "init (15, 6, False)\n", "player value 23 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (15, 2, False)\n", "player value 25 | dealer value 22\n", "init (17, 5, False)\n", "player value 27 | dealer value 25\n", "init (12, 3, False)\n", "player value 12 | dealer value 25\n", "init (17, 8, False)\n", "player value 27 | dealer value 21\n", "init (15, 2, True)\n", "player value 17 | dealer value 20\n", "init (15, 4, False)\n", "player value 20 | dealer value 24\n", "init (5, 8, False)\n", "player value 22 | dealer value 21\n", "init (14, 3, False)\n", "player value 14 | dealer value 23\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (11, 1, False)\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (10, 4, False)\n", "player value 20 | dealer value 19\n", "init (15, 3, False)\n", "player value 24 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (15, 6, False)\n", "player value 15 | dealer value 19\n", "init (13, 5, False)\n", "player value 22 | dealer value 20\n", "init (4, 6, False)\n", "player value 17 | dealer value 24\n", "init (13, 9, False)\n", "player value 13 | dealer value 17\n", "init (17, 2, False)\n", "player value 17 | dealer value 24\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (8, 5, False)\n", "player value 20 | dealer value 26\n", "init (14, 1, False)\n", "player value 14 | dealer value 22\n", "init (17, 2, False)\n", "player value 17 | dealer value 25\n", "init (15, 3, False)\n", "player value 18 | dealer value 22\n", "init (16, 7, False)\n", "player value 16 | dealer value 17\n", "init (11, 1, False)\n", "player value 21 | dealer value 17\n", "init (16, 10, False)\n", "init (13, 8, False)\n", "player value 23 | dealer value 24\n", "init (13, 9, False)\n", "player value 19 | dealer value 19\n", "init (14, 2, False)\n", "player value 22 | dealer value 20\n", "init (16, 10, True)\n", "player value 16 | dealer value 23\n", "init (17, 10, False)\n", "player value 23 | dealer value 19\n", "init (20, 4, True)\n", "player value 18 | dealer value 22\n", "init (15, 7, False)\n", "player value 15 | dealer value 23\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (7, 10, False)\n", "player value 25 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 21\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (7, 2, False)\n", "player value 19 | dealer value 18\n", "init (21, 10, True)\n", "init (12, 3, False)\n", "player value 20 | dealer value 19\n", "init (8, 4, False)\n", "player value 18 | dealer value 18\n", "init (10, 5, False)\n", "player value 20 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 23\n", "init (14, 5, True)\n", "player value 30 | dealer value 21\n", "init (17, 6, False)\n", "player value 22 | dealer value 17\n", "init (13, 10, True)\n", "player value 17 | dealer value 21\n", "init (17, 7, False)\n", "player value 27 | dealer value 24\n", "init (21, 6, True)\n", "init (17, 9, False)\n", "player value 26 | dealer value 23\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 2, True)\n", "player value 13 | dealer value 17\n", "init (19, 2, False)\n", "player value 28 | dealer value 20\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (9, 2, False)\n", "player value 17 | dealer value 22\n", "init (12, 2, False)\n", "player value 22 | dealer value 20\n", "init (8, 3, False)\n", "player value 21 | dealer value 25\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (17, 5, False)\n", "player value 22 | dealer value 25\n", "init (21, 10, True)\n", "init (10, 5, False)\n", "player value 19 | dealer value 24\n", "init (15, 6, False)\n", "player value 15 | dealer value 17\n", "init (14, 1, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (16, 5, False)\n", "player value 16 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (16, 10, False)\n", "player value 25 | dealer value 25\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (14, 10, False)\n", "player value 21 | dealer value 24\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (12, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 25\n", "init (13, 4, True)\n", "player value 22 | dealer value 24\n", "init (13, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 9, False)\n", "player value 24 | dealer value 19\n", "init (8, 8, False)\n", "player value 18 | dealer value 21\n", "init (17, 3, False)\n", "player value 17 | dealer value 22\n", "init (13, 8, False)\n", "player value 25 | dealer value 26\n", "init (20, 10, False)\n", "init (19, 7, False)\n", "player value 24 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 23\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 7, False)\n", "player value 20 | dealer value 18\n", "init (17, 8, False)\n", "player value 23 | dealer value 17\n", "init (14, 6, True)\n", "player value 14 | dealer value 21\n", "init (12, 4, False)\n", "player value 16 | dealer value 18\n", "init (15, 9, False)\n", "player value 24 | dealer value 22\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 24\n", "init (12, 10, True)\n", "player value 22 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 22\n", "init (5, 7, False)\n", "player value 22 | dealer value 17\n", "init (13, 9, False)\n", "player value 23 | dealer value 17\n", "init (15, 9, False)\n", "player value 22 | dealer value 18\n", "init (17, 1, False)\n", "player value 20 | dealer value 23\n", "init (17, 10, False)\n", "init (20, 9, False)\n", "player value 27 | dealer value 19\n", "init (13, 2, False)\n", "player value 13 | dealer value 19\n", "init (4, 4, False)\n", "player value 24 | dealer value 21\n", "init (12, 4, False)\n", "player value 18 | dealer value 18\n", "init (14, 8, False)\n", "player value 14 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 2, False)\n", "player value 18 | dealer value 18\n", "init (15, 10, False)\n", "player value 22 | dealer value 20\n", "init (21, 10, True)\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (21, 10, True)\n", "init (14, 1, False)\n", "player value 14 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (20, 2, True)\n", "player value 17 | dealer value 26\n", "init (20, 1, False)\n", "player value 20 | dealer value 19\n", "init (16, 8, True)\n", "player value 19 | dealer value 21\n", "init (10, 9, False)\n", "player value 22 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 23\n", "init (11, 10, False)\n", "player value 23 | dealer value 24\n", "init (13, 10, False)\n", "player value 20 | dealer value 19\n", "init (9, 9, False)\n", "player value 18 | dealer value 18\n", "init (14, 5, False)\n", "player value 14 | dealer value 21\n", "init (17, 1, False)\n", "player value 25 | dealer value 18\n", "init (13, 2, False)\n", "player value 17 | dealer value 25\n", "init (14, 6, False)\n", "player value 28 | dealer value 18\n", "init (21, 10, True)\n", "init (14, 10, False)\n", "player value 24 | dealer value 26\n", "init (12, 10, False)\n", "player value 29 | dealer value 20\n", "init (5, 8, False)\n", "player value 15 | dealer value 18\n", "init (17, 10, False)\n", "player value 30 | dealer value 25\n", "init (15, 5, False)\n", "player value 15 | dealer value 17\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (21, 2, True)\n", "init (5, 10, False)\n", "player value 15 | dealer value 20\n", "init (15, 2, False)\n", "player value 15 | dealer value 24\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (11, 10, False)\n", "player value 26 | dealer value 19\n", "init (13, 4, False)\n", "player value 21 | dealer value 21\n", "init (19, 1, False)\n", "init (7, 2, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 22 | dealer value 23\n", "init (12, 1, False)\n", "init (7, 4, False)\n", "player value 27 | dealer value 24\n", "init (12, 1, False)\n", "player value 25 | dealer value 19\n", "init (15, 10, False)\n", "player value 21 | dealer value 23\n", "init (12, 6, False)\n", "player value 17 | dealer value 17\n", "init (21, 9, True)\n", "init (16, 2, False)\n", "player value 23 | dealer value 22\n", "init (19, 10, False)\n", "player value 22 | dealer value 19\n", "init (6, 10, False)\n", "player value 14 | dealer value 18\n", "init (12, 10, False)\n", "player value 23 | dealer value 17\n", "init (21, 9, True)\n", "init (11, 10, False)\n", "player value 18 | dealer value 19\n", "init (8, 10, False)\n", "player value 24 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (10, 8, False)\n", "player value 20 | dealer value 17\n", "init (8, 5, False)\n", "player value 26 | dealer value 18\n", "init (13, 7, False)\n", "player value 16 | dealer value 25\n", "init (14, 7, True)\n", "player value 24 | dealer value 24\n", "init (20, 2, False)\n", "player value 21 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 18\n", "init (13, 10, False)\n", "player value 22 | dealer value 17\n", "init (16, 2, False)\n", "player value 21 | dealer value 18\n", "init (7, 4, False)\n", "player value 22 | dealer value 24\n", "init (13, 4, False)\n", "player value 23 | dealer value 17\n", "init (17, 10, True)\n", "player value 17 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 23\n", "init (10, 6, False)\n", "player value 17 | dealer value 17\n", "init (21, 3, True)\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 1, False)\n", "player value 23 | dealer value 19\n", "init (14, 3, False)\n", "player value 14 | dealer value 20\n", "init (14, 10, False)\n", "player value 22 | dealer value 23\n", "init (15, 10, False)\n", "player value 28 | dealer value 18\n", "init (21, 8, True)\n", "init (13, 7, True)\n", "player value 18 | dealer value 25\n", "init (4, 5, False)\n", "player value 24 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (15, 9, False)\n", "player value 22 | dealer value 22\n", "init (9, 6, False)\n", "player value 18 | dealer value 26\n", "init (12, 3, False)\n", "player value 17 | dealer value 24\n", "init (18, 5, False)\n", "player value 18 | dealer value 23\n", "init (14, 3, False)\n", "player value 16 | dealer value 17\n", "init (12, 10, False)\n", "init (17, 7, False)\n", "player value 17 | dealer value 19\n", "init (15, 1, False)\n", "player value 15 | dealer value 21\n", "init (8, 1, False)\n", "init (21, 2, True)\n", "init (5, 10, False)\n", "player value 25 | dealer value 18\n", "init (16, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 6, False)\n", "player value 22 | dealer value 17\n", "init (15, 3, False)\n", "player value 23 | dealer value 17\n", "init (20, 3, True)\n", "player value 23 | dealer value 18\n", "init (13, 4, False)\n", "player value 21 | dealer value 20\n", "init (13, 10, False)\n", "player value 27 | dealer value 22\n", "init (10, 7, False)\n", "player value 26 | dealer value 26\n", "init (8, 4, False)\n", "player value 18 | dealer value 19\n", "init (17, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 10, False)\n", "player value 22 | dealer value 20\n", "init (17, 3, False)\n", "player value 17 | dealer value 17\n", "init (19, 3, False)\n", "player value 19 | dealer value 18\n", "init (7, 2, False)\n", "player value 17 | dealer value 22\n", "init (18, 5, False)\n", "player value 18 | dealer value 24\n", "init (8, 6, False)\n", "player value 21 | dealer value 24\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 21 | dealer value 17\n", "init (7, 1, False)\n", "player value 23 | dealer value 24\n", "init (21, 2, True)\n", "init (21, 10, True)\n", "init (17, 4, False)\n", "player value 27 | dealer value 19\n", "init (9, 10, False)\n", "player value 27 | dealer value 24\n", "init (12, 7, False)\n", "player value 19 | dealer value 19\n", "init (13, 8, False)\n", "player value 21 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (6, 7, False)\n", "player value 22 | dealer value 21\n", "init (15, 10, False)\n", "init (17, 10, False)\n", "player value 27 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (16, 7, False)\n", "player value 16 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (6, 7, False)\n", "player value 17 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (17, 8, False)\n", "player value 24 | dealer value 18\n", "init (13, 8, False)\n", "player value 18 | dealer value 23\n", "init (16, 5, False)\n", "player value 16 | dealer value 22\n", "init (13, 7, False)\n", "player value 21 | dealer value 18\n", "init (19, 9, False)\n", "player value 22 | dealer value 19\n", "init (11, 6, False)\n", "player value 18 | dealer value 19\n", "init (16, 10, False)\n", "player value 27 | dealer value 18\n", "init (14, 10, False)\n", "player value 22 | dealer value 17\n", "init (13, 9, False)\n", "player value 21 | dealer value 20\n", "init (8, 2, False)\n", "player value 19 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (16, 5, False)\n", "player value 16 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (12, 8, False)\n", "player value 23 | dealer value 23\n", "init (14, 10, False)\n", "player value 14 | dealer value 18\n", "init (12, 1, False)\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (7, 10, False)\n", "player value 27 | dealer value 23\n", "init (21, 10, True)\n", "init (4, 7, False)\n", "player value 26 | dealer value 17\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 8, True)\n", "player value 15 | dealer value 20\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (16, 10, False)\n", "player value 19 | dealer value 20\n", "init (10, 3, False)\n", "player value 18 | dealer value 18\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (17, 5, False)\n", "player value 17 | dealer value 20\n", "init (12, 5, True)\n", "player value 16 | dealer value 18\n", "init (15, 8, False)\n", "player value 15 | dealer value 25\n", "init (19, 3, False)\n", "player value 19 | dealer value 19\n", "init (10, 9, False)\n", "player value 23 | dealer value 18\n", "init (21, 10, True)\n", "init (14, 5, False)\n", "player value 24 | dealer value 18\n", "init (21, 4, True)\n", "init (10, 6, False)\n", "player value 18 | dealer value 25\n", "init (14, 8, False)\n", "player value 14 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 1, False)\n", "player value 18 | dealer value 17\n", "init (12, 5, False)\n", "player value 22 | dealer value 17\n", "init (14, 10, False)\n", "player value 26 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (19, 1, False)\n", "player value 19 | dealer value 23\n", "init (12, 10, False)\n", "player value 21 | dealer value 21\n", "init (11, 2, False)\n", "player value 19 | dealer value 22\n", "init (13, 7, True)\n", "player value 21 | dealer value 17\n", "init (16, 4, False)\n", "player value 21 | dealer value 20\n", "init (16, 5, False)\n", "player value 20 | dealer value 22\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (12, 1, False)\n", "init (5, 8, False)\n", "player value 13 | dealer value 20\n", "init (19, 2, False)\n", "player value 19 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 19\n", "init (15, 10, False)\n", "player value 19 | dealer value 24\n", "init (17, 10, False)\n", "player value 24 | dealer value 20\n", "init (16, 6, False)\n", "player value 26 | dealer value 21\n", "init (15, 5, False)\n", "player value 15 | dealer value 24\n", "init (15, 10, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (12, 9, False)\n", "player value 24 | dealer value 26\n", "init (20, 9, False)\n", "player value 30 | dealer value 20\n", "init (8, 9, False)\n", "player value 21 | dealer value 22\n", "init (14, 2, False)\n", "player value 22 | dealer value 24\n", "init (15, 10, False)\n", "player value 20 | dealer value 21\n", "init (13, 5, True)\n", "player value 18 | dealer value 19\n", "init (14, 7, False)\n", "player value 23 | dealer value 17\n", "init (12, 7, False)\n", "player value 17 | dealer value 20\n", "init (21, 4, True)\n", "init (9, 7, False)\n", "player value 16 | dealer value 18\n", "init (13, 10, False)\n", "init (17, 6, False)\n", "player value 17 | dealer value 26\n", "init (5, 10, False)\n", "player value 24 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (11, 2, False)\n", "player value 19 | dealer value 24\n", "init (8, 4, False)\n", "player value 21 | dealer value 21\n", "init (8, 4, False)\n", "player value 18 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 10, False)\n", "player value 16 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (18, 10, False)\n", "init (19, 10, False)\n", "player value 28 | dealer value 20\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 21 | dealer value 17\n", "init (21, 10, True)\n", "init (12, 5, False)\n", "player value 22 | dealer value 20\n", "init (12, 10, False)\n", "player value 12 | dealer value 18\n", "init (9, 10, False)\n", "player value 22 | dealer value 20\n", "init (12, 2, False)\n", "player value 19 | dealer value 18\n", "init (11, 7, False)\n", "player value 20 | dealer value 24\n", "init (5, 6, False)\n", "player value 17 | dealer value 24\n", "init (10, 5, False)\n", "player value 15 | dealer value 21\n", "init (14, 8, False)\n", "player value 24 | dealer value 21\n", "init (14, 6, True)\n", "player value 14 | dealer value 26\n", "init (18, 4, False)\n", "player value 18 | dealer value 18\n", "init (21, 10, True)\n", "init (12, 2, False)\n", "player value 22 | dealer value 20\n", "init (17, 8, True)\n", "player value 20 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 21\n", "init (9, 1, False)\n", "player value 26 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (7, 3, False)\n", "player value 18 | dealer value 23\n", "init (18, 2, False)\n", "player value 18 | dealer value 20\n", "init (17, 7, False)\n", "player value 17 | dealer value 18\n", "init (10, 6, False)\n", "player value 13 | dealer value 20\n", "init (17, 2, True)\n", "player value 17 | dealer value 26\n", "init (8, 5, False)\n", "player value 12 | dealer value 24\n", "init (12, 2, False)\n", "player value 18 | dealer value 23\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (9, 10, False)\n", "player value 24 | dealer value 24\n", "init (4, 1, False)\n", "init (17, 9, True)\n", "player value 19 | dealer value 22\n", "init (13, 1, False)\n", "init (19, 1, False)\n", "init (20, 9, False)\n", "player value 25 | dealer value 19\n", "init (13, 9, False)\n", "player value 23 | dealer value 22\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (13, 10, False)\n", "player value 24 | dealer value 18\n", "init (13, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 19\n", "init (11, 4, False)\n", "player value 14 | dealer value 26\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (15, 2, False)\n", "player value 15 | dealer value 19\n", "init (12, 2, False)\n", "player value 22 | dealer value 18\n", "init (14, 8, False)\n", "player value 27 | dealer value 18\n", "init (16, 10, False)\n", "player value 21 | dealer value 25\n", "init (11, 10, False)\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 7, False)\n", "player value 21 | dealer value 17\n", "init (13, 7, True)\n", "player value 24 | dealer value 17\n", "init (17, 8, True)\n", "player value 21 | dealer value 18\n", "init (8, 9, False)\n", "player value 18 | dealer value 19\n", "init (12, 2, True)\n", "player value 15 | dealer value 18\n", "init (14, 7, False)\n", "player value 14 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (12, 8, False)\n", "player value 31 | dealer value 21\n", "init (10, 9, False)\n", "player value 27 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (4, 10, False)\n", "player value 26 | dealer value 20\n", "init (7, 2, False)\n", "player value 22 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (12, 10, False)\n", "player value 21 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 5, False)\n", "player value 20 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 18\n", "init (12, 2, False)\n", "player value 19 | dealer value 23\n", "init (9, 8, False)\n", "player value 19 | dealer value 20\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 23\n", "init (18, 6, False)\n", "player value 18 | dealer value 23\n", "init (19, 9, False)\n", "player value 19 | dealer value 21\n", "init (21, 10, True)\n", "init (17, 4, False)\n", "player value 27 | dealer value 21\n", "init (17, 10, True)\n", "player value 19 | dealer value 17\n", "init (10, 2, False)\n", "player value 25 | dealer value 17\n", "init (8, 10, False)\n", "player value 28 | dealer value 20\n", "init (15, 6, False)\n", "player value 15 | dealer value 17\n", "init (11, 5, False)\n", "player value 21 | dealer value 25\n", "init (9, 3, False)\n", "player value 14 | dealer value 24\n", "init (8, 1, False)\n", "player value 24 | dealer value 17\n", "init (12, 7, False)\n", "player value 24 | dealer value 24\n", "init (12, 10, False)\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (9, 10, False)\n", "player value 20 | dealer value 18\n", "init (12, 1, True)\n", "player value 18 | dealer value 18\n", "init (15, 1, False)\n", "init (12, 1, False)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 27 | dealer value 20\n", "init (19, 10, False)\n", "init (6, 7, False)\n", "player value 21 | dealer value 18\n", "init (16, 1, False)\n", "init (10, 4, False)\n", "player value 18 | dealer value 20\n", "init (13, 4, False)\n", "player value 15 | dealer value 19\n", "init (8, 1, False)\n", "player value 25 | dealer value 20\n", "init (21, 7, True)\n", "init (21, 5, True)\n", "init (18, 4, False)\n", "player value 18 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 26\n", "init (15, 3, False)\n", "player value 25 | dealer value 20\n", "init (11, 1, False)\n", "init (5, 10, False)\n", "player value 16 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (15, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 8, False)\n", "player value 15 | dealer value 20\n", "init (13, 6, True)\n", "player value 13 | dealer value 25\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (11, 3, False)\n", "player value 21 | dealer value 20\n", "init (13, 2, False)\n", "player value 17 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (6, 1, False)\n", "init (12, 1, False)\n", "init (11, 6, False)\n", "player value 21 | dealer value 21\n", "init (12, 5, False)\n", "player value 12 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (16, 4, False)\n", "player value 24 | dealer value 20\n", "init (7, 9, False)\n", "player value 18 | dealer value 19\n", "init (14, 7, False)\n", "player value 24 | dealer value 22\n", "init (20, 7, True)\n", "player value 20 | dealer value 17\n", "init (11, 8, False)\n", "player value 21 | dealer value 19\n", "init (9, 2, False)\n", "player value 25 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 4, False)\n", "player value 15 | dealer value 25\n", "init (11, 5, False)\n", "player value 15 | dealer value 24\n", "init (9, 10, False)\n", "player value 20 | dealer value 23\n", "init (12, 8, False)\n", "player value 25 | dealer value 18\n", "init (11, 1, False)\n", "player value 17 | dealer value 22\n", "init (14, 9, False)\n", "player value 20 | dealer value 23\n", "init (20, 4, False)\n", "player value 29 | dealer value 19\n", "init (7, 1, False)\n", "player value 17 | dealer value 17\n", "init (13, 2, False)\n", "player value 17 | dealer value 23\n", "init (8, 1, False)\n", "player value 17 | dealer value 19\n", "init (14, 4, True)\n", "player value 30 | dealer value 19\n", "init (21, 10, True)\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (10, 4, False)\n", "player value 21 | dealer value 22\n", "init (15, 7, False)\n", "player value 27 | dealer value 17\n", "init (13, 4, False)\n", "player value 20 | dealer value 18\n", "init (14, 2, False)\n", "player value 17 | dealer value 21\n", "init (15, 7, False)\n", "player value 25 | dealer value 17\n", "init (16, 3, False)\n", "player value 19 | dealer value 23\n", "init (9, 7, False)\n", "player value 19 | dealer value 20\n", "init (12, 9, False)\n", "player value 18 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 26\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (9, 3, False)\n", "player value 14 | dealer value 24\n", "init (12, 1, True)\n", "player value 21 | dealer value 19\n", "init (7, 10, False)\n", "player value 17 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (21, 10, True)\n", "init (9, 1, False)\n", "player value 19 | dealer value 19\n", "init (14, 2, False)\n", "player value 19 | dealer value 21\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (14, 5, False)\n", "player value 24 | dealer value 24\n", "init (17, 8, False)\n", "player value 17 | dealer value 22\n", "init (14, 10, False)\n", "player value 26 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (13, 1, False)\n", "init (19, 3, False)\n", "player value 29 | dealer value 23\n", "init (10, 1, False)\n", "player value 22 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 19\n", "init (14, 8, False)\n", "player value 20 | dealer value 17\n", "init (13, 7, False)\n", "player value 25 | dealer value 23\n", "init (16, 10, False)\n", "player value 25 | dealer value 23\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (15, 1, False)\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (17, 4, False)\n", "player value 24 | dealer value 23\n", "init (10, 7, False)\n", "player value 17 | dealer value 18\n", "init (9, 1, False)\n", "init (13, 10, False)\n", "player value 19 | dealer value 18\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (12, 3, False)\n", "player value 21 | dealer value 21\n", "init (12, 10, False)\n", "init (18, 10, False)\n", "player value 26 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 20\n", "init (14, 1, False)\n", "player value 14 | dealer value 22\n", "init (17, 10, False)\n", "player value 27 | dealer value 17\n", "init (20, 10, False)\n", "init (16, 9, False)\n", "player value 18 | dealer value 17\n", "init (14, 3, False)\n", "player value 14 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 21\n", "init (6, 2, False)\n", "player value 25 | dealer value 18\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (13, 8, False)\n", "player value 20 | dealer value 19\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (11, 8, False)\n", "player value 15 | dealer value 18\n", "init (21, 10, True)\n", "init (10, 7, False)\n", "player value 21 | dealer value 17\n", "init (17, 4, False)\n", "player value 27 | dealer value 24\n", "init (9, 5, False)\n", "player value 25 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "player value 27 | dealer value 25\n", "init (14, 7, False)\n", "player value 14 | dealer value 23\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (16, 4, False)\n", "player value 26 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 23\n", "init (15, 5, False)\n", "player value 15 | dealer value 20\n", "init (6, 6, False)\n", "player value 25 | dealer value 22\n", "init (13, 10, True)\n", "player value 21 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 17\n", "init (17, 10, False)\n", "player value 24 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 21\n", "init (12, 3, False)\n", "player value 22 | dealer value 17\n", "init (17, 6, True)\n", "player value 26 | dealer value 26\n", "init (10, 1, False)\n", "player value 13 | dealer value 19\n", "init (11, 7, False)\n", "player value 27 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (16, 7, False)\n", "player value 26 | dealer value 20\n", "init (12, 8, False)\n", "player value 21 | dealer value 23\n", "init (6, 10, False)\n", "player value 26 | dealer value 20\n", "init (17, 4, True)\n", "player value 14 | dealer value 22\n", "init (12, 1, False)\n", "player value 21 | dealer value 18\n", "init (17, 4, False)\n", "player value 18 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (14, 1, False)\n", "init (6, 8, False)\n", "player value 19 | dealer value 18\n", "init (12, 6, False)\n", "player value 24 | dealer value 21\n", "init (9, 9, False)\n", "player value 19 | dealer value 24\n", "init (11, 4, False)\n", "player value 14 | dealer value 22\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 4, True)\n", "player value 17 | dealer value 17\n", "init (13, 4, True)\n", "player value 20 | dealer value 20\n", "init (10, 5, False)\n", "player value 19 | dealer value 19\n", "init (21, 4, True)\n", "init (12, 6, False)\n", "player value 22 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 24\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (15, 9, False)\n", "player value 23 | dealer value 19\n", "init (17, 6, True)\n", "player value 23 | dealer value 17\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (15, 7, False)\n", "player value 27 | dealer value 24\n", "init (20, 2, False)\n", "player value 20 | dealer value 24\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (18, 10, False)\n", "player value 24 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (8, 1, False)\n", "player value 19 | dealer value 19\n", "init (19, 10, False)\n", "player value 25 | dealer value 24\n", "init (21, 6, True)\n", "init (21, 1, True)\n", "init (8, 10, False)\n", "player value 22 | dealer value 20\n", "init (17, 5, False)\n", "player value 24 | dealer value 19\n", "init (15, 10, False)\n", "player value 22 | dealer value 23\n", "init (11, 6, False)\n", "player value 24 | dealer value 18\n", "init (14, 5, False)\n", "player value 23 | dealer value 18\n", "init (15, 10, False)\n", "player value 20 | dealer value 21\n", "init (16, 3, False)\n", "player value 22 | dealer value 19\n", "init (18, 10, True)\n", "player value 23 | dealer value 17\n", "init (7, 2, False)\n", "player value 17 | dealer value 23\n", "init (10, 10, False)\n", "player value 25 | dealer value 20\n", "init (21, 2, True)\n", "init (21, 10, True)\n", "init (19, 9, True)\n", "player value 19 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 18\n", "init (13, 3, False)\n", "player value 23 | dealer value 19\n", "init (12, 10, False)\n", "player value 20 | dealer value 18\n", "init (18, 6, False)\n", "player value 18 | dealer value 17\n", "init (7, 4, False)\n", "player value 23 | dealer value 17\n", "init (16, 5, False)\n", "player value 23 | dealer value 25\n", "init (12, 7, False)\n", "player value 18 | dealer value 21\n", "init (18, 1, False)\n", "player value 18 | dealer value 17\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (14, 10, False)\n", "player value 20 | dealer value 22\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (17, 4, False)\n", "player value 25 | dealer value 23\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 25\n", "init (14, 1, False)\n", "player value 14 | dealer value 19\n", "init (18, 5, False)\n", "player value 18 | dealer value 24\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 8, False)\n", "player value 22 | dealer value 19\n", "init (17, 10, False)\n", "init (8, 9, False)\n", "player value 18 | dealer value 20\n", "init (16, 7, False)\n", "player value 20 | dealer value 17\n", "init (5, 6, False)\n", "player value 13 | dealer value 24\n", "init (15, 2, False)\n", "player value 24 | dealer value 24\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (12, 4, False)\n", "player value 22 | dealer value 24\n", "init (11, 7, False)\n", "player value 21 | dealer value 20\n", "init (12, 4, True)\n", "player value 12 | dealer value 18\n", "init (13, 8, False)\n", "player value 23 | dealer value 24\n", "init (6, 4, False)\n", "player value 18 | dealer value 20\n", "init (21, 6, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 6, False)\n", "player value 26 | dealer value 17\n", "init (21, 5, True)\n", "init (14, 5, False)\n", "player value 14 | dealer value 25\n", "init (10, 10, False)\n", "init (14, 7, False)\n", "player value 21 | dealer value 18\n", "init (17, 7, False)\n", "player value 27 | dealer value 22\n", "init (13, 7, False)\n", "player value 23 | dealer value 18\n", "init (9, 2, False)\n", "player value 21 | dealer value 19\n", "init (14, 1, False)\n", "player value 14 | dealer value 25\n", "init (13, 10, False)\n", "player value 21 | dealer value 18\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (15, 10, False)\n", "player value 25 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 17\n", "init (15, 2, False)\n", "player value 15 | dealer value 17\n", "init (10, 8, False)\n", "player value 20 | dealer value 19\n", "init (14, 4, False)\n", "player value 14 | dealer value 18\n", "init (16, 10, False)\n", "player value 25 | dealer value 19\n", "init (12, 7, False)\n", "player value 22 | dealer value 18\n", "init (13, 2, False)\n", "player value 23 | dealer value 22\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (5, 1, False)\n", "player value 17 | dealer value 25\n", "init (20, 8, False)\n", "player value 20 | dealer value 22\n", "init (11, 10, False)\n", "player value 25 | dealer value 18\n", "init (13, 5, False)\n", "player value 27 | dealer value 17\n", "init (14, 7, False)\n", "player value 22 | dealer value 19\n", "init (7, 7, False)\n", "player value 18 | dealer value 17\n", "init (19, 6, True)\n", "player value 24 | dealer value 21\n", "init (10, 3, False)\n", "player value 18 | dealer value 23\n", "init (17, 10, False)\n", "player value 25 | dealer value 20\n", "init (12, 9, True)\n", "player value 17 | dealer value 17\n", "init (13, 7, False)\n", "player value 13 | dealer value 24\n", "init (9, 7, False)\n", "player value 20 | dealer value 17\n", "init (15, 3, False)\n", "player value 16 | dealer value 17\n", "init (13, 9, False)\n", "player value 22 | dealer value 20\n", "init (19, 7, True)\n", "player value 18 | dealer value 25\n", "init (12, 10, False)\n", "player value 26 | dealer value 19\n", "init (17, 4, False)\n", "player value 22 | dealer value 21\n", "init (14, 10, True)\n", "player value 25 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (10, 10, False)\n", "player value 18 | dealer value 20\n", "init (8, 10, False)\n", "player value 26 | dealer value 20\n", "init (13, 7, False)\n", "player value 24 | dealer value 18\n", "init (15, 10, False)\n", "player value 21 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "player value 20 | dealer value 18\n", "init (7, 3, False)\n", "player value 24 | dealer value 23\n", "init (15, 4, True)\n", "player value 21 | dealer value 18\n", "init (12, 10, False)\n", "player value 20 | dealer value 18\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (21, 10, True)\n", "init (12, 10, False)\n", "player value 19 | dealer value 17\n", "init (11, 5, False)\n", "player value 23 | dealer value 19\n", "init (11, 3, False)\n", "player value 19 | dealer value 22\n", "init (20, 1, False)\n", "init (14, 4, False)\n", "player value 14 | dealer value 20\n", "init (14, 2, False)\n", "player value 18 | dealer value 26\n", "init (14, 10, False)\n", "player value 20 | dealer value 18\n", "init (21, 7, True)\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 24\n", "init (9, 4, False)\n", "player value 22 | dealer value 18\n", "init (21, 10, True)\n", "init (12, 10, False)\n", "player value 24 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 5, False)\n", "player value 14 | dealer value 23\n", "init (18, 6, False)\n", "player value 28 | dealer value 17\n", "init (19, 3, False)\n", "player value 19 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 17\n", "init (21, 7, True)\n", "init (7, 5, False)\n", "player value 27 | dealer value 21\n", "init (7, 6, False)\n", "player value 14 | dealer value 26\n", "init (13, 10, False)\n", "player value 22 | dealer value 25\n", "init (8, 6, False)\n", "player value 18 | dealer value 18\n", "init (8, 9, False)\n", "player value 18 | dealer value 17\n", "init (16, 4, False)\n", "player value 20 | dealer value 24\n", "init (12, 6, False)\n", "player value 12 | dealer value 21\n", "init (10, 4, False)\n", "player value 20 | dealer value 18\n", "init (21, 10, True)\n", "init (14, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 1, False)\n", "player value 14 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 17\n", "init (12, 7, False)\n", "player value 26 | dealer value 24\n", "init (10, 4, False)\n", "player value 14 | dealer value 20\n", "init (11, 9, False)\n", "player value 21 | dealer value 24\n", "init (17, 8, True)\n", "player value 17 | dealer value 19\n", "init (12, 3, False)\n", "player value 20 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 25\n", "init (18, 6, False)\n", "player value 18 | dealer value 26\n", "init (9, 10, False)\n", "player value 18 | dealer value 26\n", "init (17, 1, False)\n", "player value 17 | dealer value 20\n", "init (11, 1, False)\n", "player value 19 | dealer value 20\n", "init (5, 6, False)\n", "player value 13 | dealer value 25\n", "init (6, 10, False)\n", "player value 21 | dealer value 21\n", "init (15, 10, False)\n", "player value 18 | dealer value 25\n", "init (18, 10, True)\n", "player value 15 | dealer value 20\n", "init (10, 9, False)\n", "player value 19 | dealer value 22\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (13, 7, False)\n", "player value 21 | dealer value 21\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 7, False)\n", "player value 22 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (5, 10, False)\n", "player value 21 | dealer value 20\n", "init (16, 5, True)\n", "player value 20 | dealer value 19\n", "init (21, 8, True)\n", "init (17, 6, False)\n", "player value 17 | dealer value 19\n", "init (17, 8, True)\n", "player value 21 | dealer value 22\n", "init (9, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 2, True)\n", "player value 19 | dealer value 21\n", "init (16, 3, False)\n", "player value 26 | dealer value 23\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (11, 6, False)\n", "player value 21 | dealer value 22\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (12, 9, False)\n", "player value 20 | dealer value 19\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 17\n", "init (21, 7, True)\n", "init (15, 10, False)\n", "player value 24 | dealer value 18\n", "init (14, 4, False)\n", "player value 20 | dealer value 23\n", "init (5, 4, False)\n", "player value 25 | dealer value 19\n", "init (4, 4, False)\n", "player value 18 | dealer value 18\n", "init (9, 1, False)\n", "player value 19 | dealer value 19\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (9, 3, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 2, False)\n", "player value 22 | dealer value 19\n", "init (21, 10, True)\n", "init (7, 5, False)\n", "player value 26 | dealer value 21\n", "init (14, 4, False)\n", "player value 24 | dealer value 24\n", "init (19, 8, False)\n", "player value 19 | dealer value 17\n", "init (16, 10, True)\n", "init (20, 2, False)\n", "player value 24 | dealer value 23\n", "init (21, 8, True)\n", "init (17, 9, False)\n", "player value 22 | dealer value 24\n", "init (15, 7, False)\n", "player value 23 | dealer value 21\n", "init (14, 1, False)\n", "player value 14 | dealer value 17\n", "init (11, 3, False)\n", "player value 20 | dealer value 25\n", "init (9, 1, False)\n", "player value 18 | dealer value 20\n", "init (14, 5, False)\n", "player value 14 | dealer value 18\n", "init (15, 7, False)\n", "player value 25 | dealer value 20\n", "init (19, 10, False)\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (11, 6, False)\n", "player value 17 | dealer value 21\n", "init (21, 8, True)\n", "init (6, 5, False)\n", "player value 16 | dealer value 19\n", "init (9, 1, False)\n", "init (14, 7, False)\n", "player value 24 | dealer value 19\n", "init (16, 2, False)\n", "player value 18 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 24\n", "init (13, 3, False)\n", "player value 23 | dealer value 23\n", "init (16, 4, False)\n", "player value 22 | dealer value 23\n", "init (16, 6, False)\n", "player value 26 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 17\n", "init (15, 10, False)\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, True)\n", "player value 15 | dealer value 24\n", "init (14, 9, False)\n", "player value 22 | dealer value 24\n", "init (16, 8, False)\n", "player value 16 | dealer value 24\n", "init (14, 3, False)\n", "player value 14 | dealer value 22\n", "init (6, 3, False)\n", "player value 26 | dealer value 20\n", "init (13, 2, False)\n", "player value 17 | dealer value 20\n", "init (19, 3, True)\n", "player value 19 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (16, 4, False)\n", "player value 26 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (12, 8, False)\n", "player value 25 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 20\n", "init (4, 4, False)\n", "player value 19 | dealer value 24\n", "init (16, 6, False)\n", "player value 16 | dealer value 22\n", "init (11, 7, False)\n", "player value 13 | dealer value 17\n", "init (10, 10, False)\n", "player value 23 | dealer value 19\n", "init (14, 9, False)\n", "player value 14 | dealer value 22\n", "init (7, 10, False)\n", "player value 28 | dealer value 18\n", "init (16, 9, True)\n", "player value 16 | dealer value 17\n", "init (4, 10, False)\n", "player value 23 | dealer value 20\n", "init (11, 4, False)\n", "player value 21 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 8, False)\n", "player value 19 | dealer value 18\n", "init (5, 10, False)\n", "player value 22 | dealer value 18\n", "init (17, 6, False)\n", "player value 24 | dealer value 23\n", "init (17, 9, False)\n", "player value 19 | dealer value 17\n", "init (16, 10, True)\n", "player value 16 | dealer value 20\n", "init (19, 5, False)\n", "player value 19 | dealer value 18\n", "init (12, 7, False)\n", "player value 14 | dealer value 26\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 3, False)\n", "player value 21 | dealer value 24\n", "init (9, 9, False)\n", "player value 21 | dealer value 18\n", "init (15, 2, False)\n", "player value 15 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 25\n", "init (16, 10, False)\n", "player value 19 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (14, 3, False)\n", "player value 22 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 19\n", "init (20, 5, False)\n", "player value 23 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (14, 10, False)\n", "player value 20 | dealer value 19\n", "init (15, 1, False)\n", "player value 26 | dealer value 17\n", "init (20, 10, True)\n", "player value 20 | dealer value 21\n", "init (16, 8, False)\n", "player value 23 | dealer value 24\n", "init (14, 5, False)\n", "player value 14 | dealer value 17\n", "init (20, 10, False)\n", "init (12, 10, False)\n", "player value 19 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 1, False)\n", "player value 14 | dealer value 22\n", "init (18, 2, False)\n", "player value 18 | dealer value 17\n", "init (18, 4, False)\n", "player value 18 | dealer value 19\n", "init (9, 5, False)\n", "player value 20 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (19, 2, True)\n", "player value 19 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 8, False)\n", "player value 30 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 23\n", "init (16, 5, False)\n", "player value 26 | dealer value 25\n", "init (21, 3, True)\n", "init (10, 10, False)\n", "player value 23 | dealer value 20\n", "init (14, 9, False)\n", "player value 21 | dealer value 24\n", "init (12, 4, False)\n", "player value 22 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 17\n", "init (10, 6, False)\n", "player value 16 | dealer value 17\n", "init (12, 4, False)\n", "player value 19 | dealer value 19\n", "init (7, 10, False)\n", "player value 18 | dealer value 20\n", "init (9, 10, False)\n", "player value 20 | dealer value 17\n", "init (13, 7, False)\n", "player value 21 | dealer value 20\n", "init (8, 6, False)\n", "player value 22 | dealer value 21\n", "init (21, 3, True)\n", "init (12, 10, False)\n", "player value 20 | dealer value 19\n", "init (16, 1, False)\n", "init (21, 10, True)\n", "init (20, 10, True)\n", "init (13, 3, False)\n", "player value 19 | dealer value 19\n", "init (21, 5, True)\n", "init (8, 1, False)\n", "player value 21 | dealer value 18\n", "init (13, 5, False)\n", "player value 13 | dealer value 24\n", "init (16, 6, False)\n", "player value 16 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 21\n", "init (14, 10, False)\n", "player value 18 | dealer value 18\n", "init (15, 9, False)\n", "player value 15 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (14, 5, False)\n", "player value 14 | dealer value 17\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n", "init (15, 8, False)\n", "player value 15 | dealer value 23\n", "init (19, 2, True)\n", "player value 19 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 5, False)\n", "player value 18 | dealer value 25\n", "init (18, 7, False)\n", "player value 18 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 18\n", "init (9, 3, False)\n", "player value 25 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 17\n", "init (5, 7, False)\n", "player value 18 | dealer value 17\n", "init (18, 6, True)\n", "player value 18 | dealer value 21\n", "init (16, 6, False)\n", "player value 16 | dealer value 21\n", "init (12, 2, False)\n", "player value 24 | dealer value 21\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (19, 4, False)\n", "player value 19 | dealer value 20\n", "init (12, 3, False)\n", "player value 14 | dealer value 19\n", "init (12, 7, False)\n", "player value 20 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 19\n", "init (16, 4, False)\n", "player value 23 | dealer value 18\n", "init (13, 9, False)\n", "player value 27 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (14, 4, False)\n", "player value 15 | dealer value 22\n", "init (12, 2, False)\n", "player value 15 | dealer value 19\n", "init (18, 6, False)\n", "player value 26 | dealer value 17\n", "init (21, 5, True)\n", "init (18, 10, True)\n", "player value 18 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 20\n", "init (12, 6, False)\n", "player value 22 | dealer value 21\n", "init (19, 4, False)\n", "player value 24 | dealer value 18\n", "init (13, 3, False)\n", "player value 23 | dealer value 20\n", "round 5000\n", "init (13, 3, False)\n", "player value 20 | dealer value 20\n", "init (10, 1, False)\n", "player value 17 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (5, 8, False)\n", "player value 18 | dealer value 22\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (10, 10, False)\n", "player value 15 | dealer value 17\n", "init (17, 3, False)\n", "player value 17 | dealer value 18\n", "init (6, 5, False)\n", "player value 15 | dealer value 23\n", "init (13, 1, False)\n", "player value 23 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 25\n", "init (15, 6, False)\n", "player value 21 | dealer value 18\n", "init (21, 5, True)\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (13, 2, False)\n", "player value 19 | dealer value 19\n", "init (20, 5, False)\n", "player value 24 | dealer value 19\n", "init (15, 1, False)\n", "player value 19 | dealer value 25\n", "init (19, 9, False)\n", "player value 19 | dealer value 26\n", "init (16, 9, False)\n", "player value 19 | dealer value 19\n", "init (19, 1, False)\n", "player value 19 | dealer value 20\n", "init (21, 2, True)\n", "init (20, 3, False)\n", "player value 20 | dealer value 25\n", "init (12, 3, False)\n", "player value 22 | dealer value 23\n", "init (11, 10, False)\n", "player value 22 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 26\n", "init (13, 10, False)\n", "player value 22 | dealer value 26\n", "init (4, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 3, False)\n", "player value 13 | dealer value 17\n", "init (9, 9, False)\n", "player value 22 | dealer value 19\n", "init (10, 4, False)\n", "player value 15 | dealer value 18\n", "init (9, 5, False)\n", "player value 19 | dealer value 25\n", "init (18, 6, False)\n", "player value 18 | dealer value 24\n", "init (15, 1, False)\n", "player value 15 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 17\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (21, 2, True)\n", "init (12, 1, False)\n", "player value 19 | dealer value 20\n", "init (19, 1, False)\n", "player value 19 | dealer value 21\n", "init (10, 5, False)\n", "player value 26 | dealer value 19\n", "init (14, 4, True)\n", "player value 21 | dealer value 22\n", "init (16, 2, False)\n", "player value 26 | dealer value 22\n", "init (20, 7, False)\n", "player value 24 | dealer value 18\n", "init (5, 6, False)\n", "player value 12 | dealer value 25\n", "init (14, 3, False)\n", "player value 14 | dealer value 21\n", "init (12, 9, False)\n", "player value 22 | dealer value 20\n", "init (9, 5, False)\n", "player value 17 | dealer value 21\n", "init (16, 4, False)\n", "player value 20 | dealer value 23\n", "init (19, 9, True)\n", "player value 19 | dealer value 26\n", "init (21, 1, True)\n", "init (18, 6, False)\n", "player value 18 | dealer value 18\n", "init (13, 10, False)\n", "player value 20 | dealer value 23\n", "init (16, 7, False)\n", "player value 27 | dealer value 26\n", "init (20, 7, False)\n", "player value 20 | dealer value 24\n", "init (16, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 9, False)\n", "player value 19 | dealer value 19\n", "init (15, 10, False)\n", "player value 24 | dealer value 17\n", "init (9, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 26 | dealer value 22\n", "init (8, 6, False)\n", "player value 17 | dealer value 25\n", "init (7, 3, False)\n", "player value 15 | dealer value 20\n", "init (11, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 9, True)\n", "player value 19 | dealer value 17\n", "init (11, 9, False)\n", "player value 21 | dealer value 18\n", "init (11, 1, False)\n", "player value 22 | dealer value 20\n", "init (14, 4, False)\n", "player value 22 | dealer value 22\n", "init (13, 8, True)\n", "player value 25 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 24\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (19, 2, False)\n", "player value 19 | dealer value 17\n", "init (13, 10, False)\n", "player value 21 | dealer value 24\n", "init (10, 1, False)\n", "player value 22 | dealer value 17\n", "init (17, 3, False)\n", "player value 17 | dealer value 18\n", "init (13, 5, True)\n", "player value 13 | dealer value 22\n", "init (17, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 2, False)\n", "player value 22 | dealer value 21\n", "init (12, 6, False)\n", "player value 12 | dealer value 22\n", "init (15, 7, False)\n", "player value 27 | dealer value 19\n", "init (19, 3, False)\n", "player value 19 | dealer value 23\n", "init (16, 8, False)\n", "player value 24 | dealer value 18\n", "init (15, 6, False)\n", "player value 20 | dealer value 18\n", "init (11, 5, False)\n", "player value 27 | dealer value 24\n", "init (13, 10, True)\n", "player value 20 | dealer value 18\n", "init (11, 3, False)\n", "player value 17 | dealer value 17\n", "init (13, 3, False)\n", "player value 23 | dealer value 23\n", "init (20, 10, False)\n", "init (16, 10, False)\n", "init (13, 8, False)\n", "player value 23 | dealer value 26\n", "init (15, 6, False)\n", "player value 25 | dealer value 17\n", "init (13, 8, False)\n", "player value 14 | dealer value 25\n", "init (11, 10, False)\n", "init (20, 2, False)\n", "player value 20 | dealer value 18\n", "init (16, 9, True)\n", "player value 21 | dealer value 23\n", "init (12, 3, False)\n", "player value 12 | dealer value 23\n", "init (14, 5, False)\n", "player value 14 | dealer value 20\n", "init (6, 7, False)\n", "player value 26 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (13, 5, False)\n", "player value 13 | dealer value 18\n", "init (9, 7, False)\n", "player value 23 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 17\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (7, 8, False)\n", "player value 19 | dealer value 21\n", "init (13, 10, False)\n", "player value 18 | dealer value 18\n", "init (15, 10, False)\n", "player value 24 | dealer value 20\n", "init (9, 9, False)\n", "player value 29 | dealer value 19\n", "init (14, 2, False)\n", "player value 26 | dealer value 20\n", "init (20, 10, True)\n", "player value 23 | dealer value 26\n", "init (16, 7, False)\n", "player value 22 | dealer value 17\n", "init (14, 10, False)\n", "player value 21 | dealer value 20\n", "init (17, 10, False)\n", "init (12, 10, False)\n", "player value 24 | dealer value 19\n", "init (15, 2, False)\n", "player value 15 | dealer value 22\n", "init (13, 7, False)\n", "player value 13 | dealer value 17\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 4, False)\n", "player value 26 | dealer value 18\n", "init (16, 8, True)\n", "player value 25 | dealer value 23\n", "init (21, 3, True)\n", "init (15, 10, False)\n", "player value 23 | dealer value 25\n", "init (14, 10, False)\n", "player value 23 | dealer value 19\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 2, False)\n", "player value 14 | dealer value 18\n", "init (13, 6, True)\n", "player value 16 | dealer value 17\n", "init (12, 8, False)\n", "player value 26 | dealer value 18\n", "init (14, 10, False)\n", "player value 25 | dealer value 17\n", "init (9, 10, False)\n", "player value 18 | dealer value 18\n", "init (6, 7, False)\n", "player value 19 | dealer value 18\n", "init (16, 7, False)\n", "player value 20 | dealer value 23\n", "init (15, 10, False)\n", "init (17, 7, False)\n", "player value 27 | dealer value 18\n", "init (15, 4, False)\n", "player value 25 | dealer value 23\n", "init (18, 2, True)\n", "player value 15 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (20, 6, False)\n", "player value 20 | dealer value 18\n", "init (11, 1, False)\n", "init (15, 10, True)\n", "player value 15 | dealer value 22\n", "init (10, 10, False)\n", "player value 20 | dealer value 22\n", "init (9, 10, False)\n", "player value 20 | dealer value 17\n", "init (7, 8, False)\n", "player value 28 | dealer value 18\n", "init (10, 4, False)\n", "player value 19 | dealer value 18\n", "init (13, 9, False)\n", "player value 23 | dealer value 18\n", "init (15, 10, False)\n", "init (8, 4, False)\n", "player value 18 | dealer value 22\n", "init (12, 6, False)\n", "player value 12 | dealer value 19\n", "init (15, 10, False)\n", "init (18, 3, False)\n", "player value 18 | dealer value 26\n", "init (18, 6, True)\n", "player value 18 | dealer value 25\n", "init (19, 6, False)\n", "player value 19 | dealer value 22\n", "init (9, 10, False)\n", "player value 19 | dealer value 23\n", "init (12, 10, False)\n", "player value 25 | dealer value 20\n", "init (17, 7, False)\n", "player value 21 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (17, 10, True)\n", "init (19, 2, False)\n", "player value 19 | dealer value 26\n", "init (17, 2, True)\n", "player value 17 | dealer value 18\n", "init (11, 2, False)\n", "player value 18 | dealer value 21\n", "init (12, 10, False)\n", "player value 12 | dealer value 23\n", "init (10, 5, False)\n", "player value 16 | dealer value 21\n", "init (4, 10, False)\n", "player value 24 | dealer value 20\n", "init (19, 2, False)\n", "player value 19 | dealer value 18\n", "init (13, 10, False)\n", "init (13, 8, False)\n", "player value 14 | dealer value 18\n", "init (11, 5, False)\n", "player value 15 | dealer value 23\n", "init (16, 7, False)\n", "player value 26 | dealer value 22\n", "init (16, 10, False)\n", "player value 27 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (12, 7, False)\n", "player value 22 | dealer value 22\n", "init (9, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 1, False)\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (10, 3, False)\n", "player value 17 | dealer value 17\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (7, 1, False)\n", "player value 17 | dealer value 18\n", "init (16, 1, False)\n", "init (14, 10, False)\n", "player value 24 | dealer value 23\n", "init (15, 10, False)\n", "player value 23 | dealer value 20\n", "init (9, 10, False)\n", "init (16, 2, False)\n", "player value 26 | dealer value 20\n", "init (12, 2, False)\n", "player value 22 | dealer value 22\n", "init (16, 10, False)\n", "player value 24 | dealer value 18\n", "init (13, 10, False)\n", "player value 19 | dealer value 22\n", "init (16, 6, True)\n", "player value 16 | dealer value 17\n", "init (16, 9, True)\n", "player value 20 | dealer value 19\n", "init (17, 10, False)\n", "player value 24 | dealer value 17\n", "init (16, 5, False)\n", "player value 26 | dealer value 26\n", "init (17, 8, False)\n", "player value 17 | dealer value 19\n", "init (14, 7, False)\n", "player value 14 | dealer value 25\n", "init (8, 10, False)\n", "player value 18 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 24\n", "init (9, 10, False)\n", "player value 19 | dealer value 18\n", "init (18, 5, False)\n", "player value 18 | dealer value 21\n", "init (12, 9, False)\n", "player value 12 | dealer value 17\n", "init (14, 4, False)\n", "player value 20 | dealer value 24\n", "init (13, 5, True)\n", "player value 13 | dealer value 17\n", "init (4, 10, False)\n", "player value 12 | dealer value 23\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (13, 4, False)\n", "player value 22 | dealer value 18\n", "init (10, 6, False)\n", "player value 13 | dealer value 17\n", "init (14, 9, False)\n", "player value 24 | dealer value 19\n", "init (10, 6, False)\n", "player value 20 | dealer value 20\n", "init (21, 7, True)\n", "init (13, 2, False)\n", "player value 22 | dealer value 18\n", "init (13, 10, False)\n", "player value 18 | dealer value 23\n", "init (18, 7, True)\n", "player value 18 | dealer value 17\n", "init (15, 2, False)\n", "player value 15 | dealer value 18\n", "init (17, 10, True)\n", "player value 22 | dealer value 20\n", "init (14, 1, False)\n", "init (17, 9, False)\n", "player value 19 | dealer value 21\n", "init (12, 7, False)\n", "player value 12 | dealer value 23\n", "init (13, 4, False)\n", "player value 27 | dealer value 17\n", "init (17, 10, True)\n", "player value 15 | dealer value 18\n", "init (19, 3, False)\n", "player value 19 | dealer value 24\n", "init (10, 7, False)\n", "player value 15 | dealer value 25\n", "init (5, 8, False)\n", "player value 23 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 22\n", "init (17, 8, True)\n", "player value 22 | dealer value 18\n", "init (19, 1, False)\n", "player value 29 | dealer value 25\n", "init (9, 3, False)\n", "player value 19 | dealer value 24\n", "init (16, 10, True)\n", "player value 21 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 23\n", "init (19, 10, True)\n", "player value 21 | dealer value 18\n", "init (21, 1, True)\n", "init (8, 5, False)\n", "player value 26 | dealer value 22\n", "init (21, 5, True)\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 7, False)\n", "player value 22 | dealer value 21\n", "init (16, 7, False)\n", "player value 29 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 22\n", "init (15, 10, False)\n", "player value 18 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 1, True)\n", "player value 16 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (17, 4, False)\n", "player value 17 | dealer value 20\n", "init (21, 10, True)\n", "init (7, 3, False)\n", "player value 14 | dealer value 17\n", "init (17, 10, False)\n", "player value 25 | dealer value 19\n", "init (12, 9, True)\n", "player value 19 | dealer value 18\n", "init (15, 10, True)\n", "player value 26 | dealer value 19\n", "init (17, 1, False)\n", "player value 26 | dealer value 20\n", "init (16, 10, False)\n", "player value 22 | dealer value 24\n", "init (21, 7, True)\n", "init (21, 10, True)\n", "init (4, 3, False)\n", "player value 20 | dealer value 20\n", "init (8, 3, False)\n", "player value 18 | dealer value 18\n", "init (11, 4, False)\n", "player value 21 | dealer value 18\n", "init (13, 1, False)\n", "init (13, 4, False)\n", "player value 23 | dealer value 18\n", "init (11, 9, False)\n", "player value 21 | dealer value 19\n", "init (21, 7, True)\n", "init (10, 2, False)\n", "player value 24 | dealer value 20\n", "init (13, 9, False)\n", "player value 13 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (16, 10, False)\n", "player value 21 | dealer value 17\n", "init (16, 1, False)\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (12, 4, False)\n", "player value 24 | dealer value 26\n", "init (12, 5, True)\n", "player value 12 | dealer value 22\n", "init (13, 8, True)\n", "player value 13 | dealer value 18\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (11, 9, False)\n", "player value 19 | dealer value 19\n", "init (14, 6, False)\n", "player value 14 | dealer value 19\n", "init (11, 10, False)\n", "player value 27 | dealer value 20\n", "init (9, 10, False)\n", "player value 24 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 22\n", "init (11, 7, False)\n", "player value 18 | dealer value 18\n", "init (19, 6, False)\n", "player value 19 | dealer value 20\n", "init (18, 1, False)\n", "player value 18 | dealer value 18\n", "init (13, 7, False)\n", "player value 21 | dealer value 17\n", "init (8, 9, False)\n", "player value 20 | dealer value 22\n", "init (15, 8, False)\n", "player value 15 | dealer value 19\n", "init (12, 10, False)\n", "player value 24 | dealer value 23\n", "init (19, 4, False)\n", "player value 23 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (16, 3, False)\n", "player value 28 | dealer value 21\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 2, False)\n", "player value 19 | dealer value 21\n", "init (21, 1, True)\n", "init (5, 10, False)\n", "player value 26 | dealer value 19\n", "init (16, 9, False)\n", "player value 24 | dealer value 19\n", "init (15, 10, False)\n", "player value 23 | dealer value 18\n", "init (16, 9, False)\n", "player value 20 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 25\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (21, 7, True)\n", "init (10, 10, False)\n", "player value 18 | dealer value 19\n", "init (21, 6, True)\n", "init (9, 9, False)\n", "player value 19 | dealer value 20\n", "init (15, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 1, False)\n", "init (12, 1, False)\n", "player value 22 | dealer value 19\n", "init (11, 1, False)\n", "init (21, 10, True)\n", "init (13, 10, False)\n", "player value 24 | dealer value 25\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (16, 4, False)\n", "player value 18 | dealer value 24\n", "init (6, 3, False)\n", "player value 13 | dealer value 17\n", "init (21, 6, True)\n", "init (15, 10, False)\n", "player value 27 | dealer value 17\n", "init (16, 4, False)\n", "player value 23 | dealer value 18\n", "init (11, 4, False)\n", "player value 27 | dealer value 20\n", "init (10, 10, False)\n", "player value 23 | dealer value 20\n", "init (21, 3, True)\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (14, 8, False)\n", "player value 14 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (21, 5, True)\n", "init (18, 5, False)\n", "player value 18 | dealer value 21\n", "init (16, 3, True)\n", "player value 22 | dealer value 25\n", "init (17, 10, False)\n", "player value 21 | dealer value 24\n", "init (16, 4, False)\n", "player value 26 | dealer value 21\n", "init (15, 9, False)\n", "player value 16 | dealer value 26\n", "init (8, 3, False)\n", "player value 23 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (20, 9, False)\n", "player value 20 | dealer value 20\n", "init (17, 4, False)\n", "player value 20 | dealer value 24\n", "init (16, 8, False)\n", "player value 16 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (14, 1, False)\n", "player value 14 | dealer value 17\n", "init (11, 7, False)\n", "player value 29 | dealer value 18\n", "init (21, 10, True)\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (21, 10, True)\n", "init (11, 10, False)\n", "player value 19 | dealer value 19\n", "init (19, 5, True)\n", "player value 19 | dealer value 19\n", "init (12, 6, False)\n", "player value 16 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (12, 5, False)\n", "player value 22 | dealer value 21\n", "init (17, 9, False)\n", "player value 24 | dealer value 17\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (12, 8, False)\n", "player value 12 | dealer value 21\n", "init (19, 3, False)\n", "player value 19 | dealer value 23\n", "init (7, 10, False)\n", "player value 27 | dealer value 19\n", "init (13, 8, False)\n", "player value 18 | dealer value 18\n", "init (11, 7, False)\n", "player value 18 | dealer value 17\n", "init (6, 5, False)\n", "player value 21 | dealer value 21\n", "init (15, 6, False)\n", "player value 16 | dealer value 21\n", "init (11, 2, False)\n", "player value 17 | dealer value 23\n", "init (7, 2, False)\n", "player value 17 | dealer value 19\n", "init (18, 7, False)\n", "player value 27 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 26\n", "init (17, 1, True)\n", "player value 21 | dealer value 17\n", "init (11, 4, False)\n", "player value 21 | dealer value 17\n", "init (15, 10, False)\n", "player value 22 | dealer value 21\n", "init (18, 7, False)\n", "player value 21 | dealer value 18\n", "init (15, 5, False)\n", "player value 15 | dealer value 17\n", "init (16, 10, False)\n", "player value 27 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (11, 2, False)\n", "player value 21 | dealer value 20\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (6, 9, False)\n", "player value 30 | dealer value 19\n", "init (13, 1, False)\n", "player value 22 | dealer value 21\n", "init (20, 1, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "player value 25 | dealer value 22\n", "init (4, 4, False)\n", "player value 24 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 23\n", "init (12, 5, True)\n", "player value 12 | dealer value 19\n", "init (8, 8, False)\n", "player value 19 | dealer value 18\n", "init (16, 1, False)\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (18, 6, False)\n", "player value 18 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 22\n", "init (7, 10, False)\n", "player value 24 | dealer value 17\n", "init (12, 3, False)\n", "player value 12 | dealer value 20\n", "init (14, 1, False)\n", "player value 14 | dealer value 20\n", "init (6, 4, False)\n", "player value 16 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 22\n", "init (20, 1, False)\n", "player value 29 | dealer value 17\n", "init (9, 6, False)\n", "player value 18 | dealer value 24\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (10, 10, False)\n", "player value 20 | dealer value 19\n", "init (21, 9, True)\n", "init (10, 9, False)\n", "player value 21 | dealer value 19\n", "init (13, 7, False)\n", "player value 22 | dealer value 21\n", "init (15, 4, False)\n", "player value 15 | dealer value 22\n", "init (14, 8, False)\n", "player value 14 | dealer value 21\n", "init (9, 9, False)\n", "player value 18 | dealer value 22\n", "init (13, 7, False)\n", "player value 18 | dealer value 20\n", "init (11, 6, False)\n", "player value 21 | dealer value 19\n", "init (14, 10, False)\n", "player value 18 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (12, 7, False)\n", "player value 18 | dealer value 24\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (12, 8, False)\n", "player value 15 | dealer value 18\n", "init (10, 8, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (12, 1, False)\n", "init (13, 2, False)\n", "player value 23 | dealer value 24\n", "init (7, 2, False)\n", "player value 21 | dealer value 22\n", "init (9, 4, False)\n", "player value 18 | dealer value 19\n", "init (17, 3, False)\n", "player value 17 | dealer value 18\n", "init (12, 3, False)\n", "player value 22 | dealer value 17\n", "init (20, 10, False)\n", "player value 30 | dealer value 17\n", "init (15, 1, False)\n", "init (16, 5, False)\n", "player value 24 | dealer value 24\n", "init (21, 5, True)\n", "init (20, 9, False)\n", "player value 26 | dealer value 20\n", "init (8, 1, False)\n", "player value 18 | dealer value 21\n", "init (20, 4, False)\n", "player value 20 | dealer value 23\n", "init (13, 4, False)\n", "player value 23 | dealer value 22\n", "init (12, 10, False)\n", "player value 25 | dealer value 23\n", "init (10, 5, False)\n", "player value 20 | dealer value 21\n", "init (9, 2, False)\n", "player value 26 | dealer value 17\n", "init (14, 6, False)\n", "player value 14 | dealer value 23\n", "init (12, 6, False)\n", "player value 12 | dealer value 18\n", "init (16, 10, False)\n", "player value 23 | dealer value 19\n", "init (16, 10, False)\n", "player value 18 | dealer value 25\n", "init (17, 7, False)\n", "player value 23 | dealer value 18\n", "init (21, 5, True)\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (8, 7, False)\n", "player value 22 | dealer value 18\n", "init (16, 9, False)\n", "player value 17 | dealer value 23\n", "init (13, 10, False)\n", "player value 30 | dealer value 20\n", "init (12, 4, True)\n", "player value 19 | dealer value 23\n", "init (15, 10, False)\n", "player value 24 | dealer value 20\n", "init (18, 3, False)\n", "player value 22 | dealer value 20\n", "init (21, 4, True)\n", "init (21, 8, True)\n", "init (9, 5, False)\n", "player value 18 | dealer value 17\n", "init (9, 7, False)\n", "player value 18 | dealer value 21\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (19, 10, False)\n", "player value 22 | dealer value 20\n", "init (17, 10, False)\n", "player value 23 | dealer value 17\n", "init (15, 7, False)\n", "player value 15 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 1, False)\n", "player value 14 | dealer value 21\n", "init (10, 4, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 22 | dealer value 17\n", "init (13, 1, False)\n", "player value 22 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (16, 10, False)\n", "player value 22 | dealer value 21\n", "init (20, 4, False)\n", "player value 29 | dealer value 26\n", "init (18, 8, True)\n", "player value 23 | dealer value 23\n", "init (12, 2, False)\n", "player value 17 | dealer value 17\n", "init (16, 8, True)\n", "player value 26 | dealer value 22\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (12, 6, False)\n", "player value 12 | dealer value 25\n", "init (20, 8, False)\n", "player value 24 | dealer value 21\n", "init (6, 10, False)\n", "player value 18 | dealer value 18\n", "init (13, 10, True)\n", "player value 13 | dealer value 20\n", "init (17, 10, False)\n", "player value 22 | dealer value 19\n", "init (13, 1, False)\n", "init (16, 3, False)\n", "player value 16 | dealer value 23\n", "init (13, 7, False)\n", "player value 23 | dealer value 20\n", "init (16, 6, False)\n", "player value 16 | dealer value 21\n", "init (14, 6, False)\n", "player value 14 | dealer value 18\n", "init (11, 10, False)\n", "player value 21 | dealer value 19\n", "init (8, 4, False)\n", "player value 30 | dealer value 19\n", "init (18, 2, False)\n", "player value 28 | dealer value 26\n", "init (17, 2, False)\n", "player value 17 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 6, False)\n", "player value 18 | dealer value 17\n", "init (11, 1, False)\n", "player value 16 | dealer value 17\n", "init (19, 2, False)\n", "player value 19 | dealer value 22\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (12, 5, False)\n", "player value 12 | dealer value 19\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 26\n", "init (16, 10, False)\n", "player value 19 | dealer value 25\n", "init (12, 1, False)\n", "player value 12 | dealer value 18\n", "init (19, 8, True)\n", "player value 19 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (16, 9, False)\n", "player value 26 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (9, 1, False)\n", "player value 18 | dealer value 18\n", "init (8, 4, False)\n", "player value 19 | dealer value 17\n", "init (8, 3, False)\n", "player value 18 | dealer value 19\n", "init (15, 10, False)\n", "player value 23 | dealer value 23\n", "init (15, 2, False)\n", "player value 15 | dealer value 21\n", "init (16, 4, False)\n", "player value 26 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 4, False)\n", "player value 24 | dealer value 19\n", "init (21, 1, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (19, 5, False)\n", "player value 19 | dealer value 17\n", "init (16, 9, False)\n", "player value 21 | dealer value 19\n", "init (9, 10, False)\n", "player value 25 | dealer value 18\n", "init (17, 4, False)\n", "player value 27 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 25\n", "init (19, 1, False)\n", "player value 19 | dealer value 19\n", "init (11, 5, False)\n", "player value 18 | dealer value 18\n", "init (15, 4, True)\n", "player value 15 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 17\n", "init (11, 10, False)\n", "player value 24 | dealer value 18\n", "init (8, 5, False)\n", "player value 19 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (10, 10, False)\n", "player value 22 | dealer value 20\n", "init (12, 1, False)\n", "player value 22 | dealer value 19\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 6, False)\n", "player value 22 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 24\n", "init (16, 10, False)\n", "player value 26 | dealer value 17\n", "init (19, 9, False)\n", "player value 19 | dealer value 22\n", "init (16, 2, False)\n", "player value 19 | dealer value 25\n", "init (15, 8, False)\n", "player value 15 | dealer value 22\n", "init (12, 9, False)\n", "player value 22 | dealer value 19\n", "init (12, 8, False)\n", "player value 21 | dealer value 17\n", "init (13, 10, False)\n", "player value 22 | dealer value 17\n", "init (17, 10, False)\n", "init (16, 10, False)\n", "player value 16 | dealer value 23\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (16, 4, False)\n", "player value 16 | dealer value 23\n", "init (17, 9, False)\n", "player value 17 | dealer value 19\n", "init (12, 7, False)\n", "player value 22 | dealer value 20\n", "init (15, 3, False)\n", "player value 15 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 24\n", "init (13, 8, False)\n", "player value 23 | dealer value 18\n", "init (14, 1, False)\n", "player value 14 | dealer value 18\n", "init (6, 5, False)\n", "player value 19 | dealer value 20\n", "init (6, 8, False)\n", "player value 15 | dealer value 17\n", "init (14, 3, False)\n", "player value 14 | dealer value 23\n", "init (17, 5, False)\n", "player value 24 | dealer value 17\n", "init (13, 10, False)\n", "player value 30 | dealer value 24\n", "init (21, 10, True)\n", "init (13, 2, False)\n", "player value 23 | dealer value 20\n", "init (18, 8, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (6, 10, False)\n", "player value 24 | dealer value 19\n", "init (8, 8, False)\n", "player value 17 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 21\n", "init (9, 3, False)\n", "player value 12 | dealer value 19\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (17, 10, False)\n", "player value 20 | dealer value 24\n", "init (15, 9, False)\n", "player value 19 | dealer value 23\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (16, 3, True)\n", "player value 21 | dealer value 23\n", "init (17, 6, False)\n", "player value 17 | dealer value 26\n", "init (9, 1, False)\n", "player value 20 | dealer value 18\n", "init (12, 4, False)\n", "player value 19 | dealer value 19\n", "init (21, 3, True)\n", "init (16, 8, False)\n", "player value 23 | dealer value 25\n", "init (12, 3, False)\n", "player value 22 | dealer value 24\n", "init (17, 8, True)\n", "player value 17 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (8, 4, False)\n", "player value 23 | dealer value 20\n", "init (14, 2, False)\n", "player value 24 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (18, 10, True)\n", "player value 18 | dealer value 20\n", "init (19, 10, True)\n", "player value 18 | dealer value 23\n", "init (12, 6, False)\n", "player value 12 | dealer value 23\n", "init (19, 10, True)\n", "player value 19 | dealer value 22\n", "init (15, 3, False)\n", "player value 16 | dealer value 20\n", "init (15, 3, False)\n", "player value 25 | dealer value 21\n", "init (6, 7, False)\n", "player value 20 | dealer value 20\n", "init (11, 6, False)\n", "player value 21 | dealer value 20\n", "init (12, 2, False)\n", "player value 12 | dealer value 19\n", "init (13, 3, False)\n", "player value 28 | dealer value 19\n", "init (13, 1, False)\n", "player value 17 | dealer value 19\n", "init (16, 5, False)\n", "player value 16 | dealer value 21\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (12, 4, False)\n", "player value 22 | dealer value 24\n", "init (19, 1, True)\n", "player value 19 | dealer value 19\n", "init (14, 6, False)\n", "player value 14 | dealer value 23\n", "init (11, 3, False)\n", "player value 20 | dealer value 17\n", "init (7, 10, False)\n", "player value 19 | dealer value 19\n", "init (17, 1, False)\n", "player value 22 | dealer value 23\n", "init (19, 1, False)\n", "init (4, 1, False)\n", "player value 14 | dealer value 20\n", "init (11, 4, False)\n", "player value 21 | dealer value 25\n", "init (13, 1, False)\n", "player value 18 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (14, 4, False)\n", "player value 21 | dealer value 17\n", "init (12, 3, True)\n", "player value 14 | dealer value 19\n", "init (4, 4, False)\n", "player value 15 | dealer value 23\n", "init (16, 1, False)\n", "player value 19 | dealer value 19\n", "init (14, 6, True)\n", "player value 14 | dealer value 20\n", "init (13, 10, False)\n", "player value 19 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 2, False)\n", "player value 23 | dealer value 20\n", "init (15, 9, True)\n", "player value 15 | dealer value 19\n", "init (7, 7, False)\n", "player value 27 | dealer value 17\n", "init (18, 7, False)\n", "player value 18 | dealer value 20\n", "init (19, 4, False)\n", "player value 29 | dealer value 18\n", "init (12, 1, False)\n", "player value 12 | dealer value 20\n", "init (13, 4, False)\n", "player value 15 | dealer value 21\n", "init (14, 7, False)\n", "player value 14 | dealer value 23\n", "init (9, 2, False)\n", "player value 13 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (10, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (9, 10, False)\n", "player value 18 | dealer value 18\n", "init (13, 5, False)\n", "player value 26 | dealer value 23\n", "init (10, 4, False)\n", "player value 18 | dealer value 22\n", "init (20, 5, True)\n", "player value 20 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (12, 3, False)\n", "player value 22 | dealer value 22\n", "init (13, 9, False)\n", "player value 23 | dealer value 24\n", "init (16, 7, False)\n", "player value 23 | dealer value 21\n", "init (21, 6, True)\n", "init (13, 2, False)\n", "player value 13 | dealer value 26\n", "init (21, 6, True)\n", "init (12, 6, False)\n", "player value 12 | dealer value 17\n", "init (16, 10, True)\n", "player value 25 | dealer value 20\n", "init (17, 6, True)\n", "player value 17 | dealer value 22\n", "init (17, 8, False)\n", "player value 17 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (18, 10, True)\n", "player value 18 | dealer value 18\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (16, 8, False)\n", "player value 19 | dealer value 19\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (11, 10, False)\n", "player value 25 | dealer value 20\n", "init (16, 10, True)\n", "player value 27 | dealer value 18\n", "init (11, 2, False)\n", "player value 21 | dealer value 23\n", "init (16, 8, False)\n", "player value 26 | dealer value 18\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (16, 6, False)\n", "player value 16 | dealer value 22\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (9, 1, False)\n", "init (14, 4, False)\n", "player value 24 | dealer value 24\n", "init (15, 2, False)\n", "player value 19 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 10, False)\n", "init (19, 6, False)\n", "player value 19 | dealer value 20\n", "init (5, 9, False)\n", "player value 25 | dealer value 25\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (13, 9, False)\n", "player value 23 | dealer value 18\n", "init (12, 4, False)\n", "player value 19 | dealer value 20\n", "init (13, 5, False)\n", "player value 20 | dealer value 25\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (12, 10, False)\n", "init (9, 6, False)\n", "player value 19 | dealer value 22\n", "init (15, 4, False)\n", "player value 15 | dealer value 21\n", "init (12, 2, False)\n", "player value 22 | dealer value 19\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (13, 5, False)\n", "player value 22 | dealer value 18\n", "init (16, 3, False)\n", "player value 17 | dealer value 22\n", "init (6, 1, False)\n", "player value 27 | dealer value 21\n", "init (12, 6, False)\n", "player value 12 | dealer value 26\n", "init (16, 7, False)\n", "player value 26 | dealer value 17\n", "init (17, 6, False)\n", "player value 17 | dealer value 20\n", "init (15, 9, False)\n", "player value 15 | dealer value 19\n", "init (19, 8, False)\n", "player value 19 | dealer value 23\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (21, 10, True)\n", "init (11, 10, False)\n", "player value 23 | dealer value 18\n", "init (20, 4, True)\n", "player value 27 | dealer value 22\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (13, 2, False)\n", "player value 22 | dealer value 22\n", "init (16, 7, True)\n", "player value 16 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (14, 7, True)\n", "player value 14 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 22\n", "init (16, 1, False)\n", "player value 20 | dealer value 17\n", "init (14, 5, True)\n", "player value 14 | dealer value 17\n", "init (16, 9, False)\n", "player value 19 | dealer value 20\n", "init (11, 10, False)\n", "init (4, 10, False)\n", "player value 27 | dealer value 22\n", "init (10, 10, False)\n", "player value 20 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 25\n", "init (12, 1, False)\n", "player value 25 | dealer value 20\n", "init (15, 7, False)\n", "player value 15 | dealer value 17\n", "init (15, 4, False)\n", "player value 15 | dealer value 18\n", "init (12, 3, False)\n", "player value 26 | dealer value 21\n", "init (12, 1, False)\n", "init (11, 8, False)\n", "player value 30 | dealer value 18\n", "init (16, 7, False)\n", "player value 26 | dealer value 22\n", "init (12, 9, False)\n", "player value 19 | dealer value 17\n", "init (16, 8, False)\n", "player value 25 | dealer value 24\n", "init (15, 5, False)\n", "player value 15 | dealer value 21\n", "init (19, 8, False)\n", "player value 19 | dealer value 21\n", "init (12, 10, False)\n", "player value 25 | dealer value 26\n", "init (15, 1, False)\n", "init (17, 8, True)\n", "player value 17 | dealer value 22\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (12, 9, False)\n", "player value 18 | dealer value 22\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (5, 10, False)\n", "player value 25 | dealer value 18\n", "init (14, 7, False)\n", "player value 19 | dealer value 17\n", "init (19, 6, False)\n", "player value 19 | dealer value 19\n", "init (15, 10, False)\n", "init (7, 3, False)\n", "player value 15 | dealer value 18\n", "init (10, 5, False)\n", "player value 21 | dealer value 21\n", "init (21, 10, True)\n", "init (20, 10, False)\n", "player value 30 | dealer value 24\n", "init (12, 6, False)\n", "player value 12 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (8, 9, False)\n", "player value 18 | dealer value 25\n", "init (6, 10, False)\n", "player value 25 | dealer value 20\n", "init (10, 3, False)\n", "player value 20 | dealer value 21\n", "init (17, 10, True)\n", "init (17, 10, False)\n", "player value 19 | dealer value 24\n", "init (21, 8, True)\n", "init (19, 6, False)\n", "player value 19 | dealer value 18\n", "init (15, 10, False)\n", "player value 23 | dealer value 19\n", "init (10, 5, False)\n", "player value 20 | dealer value 25\n", "init (9, 10, False)\n", "player value 21 | dealer value 17\n", "init (7, 8, False)\n", "player value 21 | dealer value 19\n", "init (21, 10, True)\n", "init (14, 9, False)\n", "player value 14 | dealer value 20\n", "init (13, 4, False)\n", "player value 16 | dealer value 19\n", "init (15, 7, False)\n", "player value 24 | dealer value 17\n", "init (17, 6, False)\n", "player value 17 | dealer value 25\n", "init (18, 9, False)\n", "player value 18 | dealer value 20\n", "init (17, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (16, 1, False)\n", "player value 26 | dealer value 18\n", "init (13, 1, False)\n", "player value 21 | dealer value 20\n", "init (11, 10, False)\n", "player value 20 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 25\n", "init (16, 8, False)\n", "player value 22 | dealer value 19\n", "init (21, 2, True)\n", "init (15, 4, False)\n", "player value 21 | dealer value 19\n", "init (13, 2, False)\n", "player value 13 | dealer value 21\n", "init (11, 10, False)\n", "player value 21 | dealer value 21\n", "init (16, 10, True)\n", "player value 18 | dealer value 17\n", "init (14, 9, False)\n", "player value 21 | dealer value 19\n", "init (16, 7, False)\n", "player value 26 | dealer value 18\n", "init (6, 5, False)\n", "player value 25 | dealer value 17\n", "init (16, 10, False)\n", "player value 27 | dealer value 18\n", "init (17, 3, False)\n", "player value 17 | dealer value 17\n", "init (19, 5, False)\n", "player value 28 | dealer value 23\n", "init (16, 10, False)\n", "player value 22 | dealer value 21\n", "init (18, 10, False)\n", "player value 18 | dealer value 26\n", "init (21, 2, True)\n", "init (13, 5, False)\n", "player value 24 | dealer value 23\n", "init (16, 7, False)\n", "player value 16 | dealer value 21\n", "init (15, 3, False)\n", "player value 22 | dealer value 21\n", "init (14, 2, False)\n", "player value 18 | dealer value 18\n", "init (16, 9, False)\n", "player value 26 | dealer value 18\n", "init (12, 2, False)\n", "player value 22 | dealer value 22\n", "init (8, 2, False)\n", "player value 18 | dealer value 17\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (13, 10, False)\n", "player value 18 | dealer value 18\n", "init (16, 10, False)\n", "player value 19 | dealer value 18\n", "init (15, 1, True)\n", "player value 19 | dealer value 23\n", "init (10, 4, False)\n", "player value 27 | dealer value 20\n", "init (16, 6, True)\n", "player value 16 | dealer value 19\n", "init (11, 4, False)\n", "player value 23 | dealer value 17\n", "init (13, 8, False)\n", "player value 23 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 26\n", "init (12, 9, False)\n", "player value 24 | dealer value 19\n", "init (17, 1, False)\n", "player value 17 | dealer value 21\n", "init (15, 6, False)\n", "player value 19 | dealer value 19\n", "init (16, 8, True)\n", "player value 21 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (18, 10, True)\n", "player value 23 | dealer value 20\n", "init (12, 3, False)\n", "player value 12 | dealer value 18\n", "init (14, 5, False)\n", "player value 24 | dealer value 18\n", "init (12, 7, False)\n", "player value 27 | dealer value 18\n", "init (17, 8, False)\n", "player value 17 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (9, 1, False)\n", "player value 16 | dealer value 19\n", "init (15, 10, False)\n", "player value 22 | dealer value 17\n", "init (21, 1, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (10, 1, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (8, 3, False)\n", "player value 14 | dealer value 23\n", "init (11, 10, False)\n", "player value 19 | dealer value 20\n", "init (7, 10, False)\n", "player value 18 | dealer value 25\n", "init (18, 8, False)\n", "player value 18 | dealer value 21\n", "init (16, 9, False)\n", "player value 26 | dealer value 24\n", "init (17, 7, False)\n", "player value 17 | dealer value 22\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (16, 10, False)\n", "player value 18 | dealer value 18\n", "init (12, 3, False)\n", "player value 18 | dealer value 22\n", "init (17, 10, True)\n", "player value 18 | dealer value 20\n", "init (13, 2, False)\n", "player value 13 | dealer value 24\n", "init (7, 3, False)\n", "player value 14 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (11, 8, False)\n", "player value 19 | dealer value 18\n", "init (16, 10, False)\n", "player value 26 | dealer value 19\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 18 | dealer value 18\n", "init (17, 5, False)\n", "player value 23 | dealer value 25\n", "init (12, 6, False)\n", "player value 12 | dealer value 23\n", "init (7, 2, False)\n", "player value 17 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 22\n", "init (4, 10, False)\n", "player value 19 | dealer value 17\n", "init (20, 6, True)\n", "player value 20 | dealer value 23\n", "init (10, 10, False)\n", "player value 21 | dealer value 18\n", "init (7, 10, False)\n", "player value 26 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 18\n", "init (21, 5, True)\n", "init (19, 8, False)\n", "player value 29 | dealer value 18\n", "init (21, 2, True)\n", "init (16, 5, False)\n", "player value 25 | dealer value 19\n", "init (19, 5, False)\n", "player value 19 | dealer value 19\n", "init (18, 4, False)\n", "player value 18 | dealer value 21\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (18, 10, False)\n", "player value 24 | dealer value 22\n", "init (14, 6, False)\n", "player value 14 | dealer value 24\n", "init (14, 10, False)\n", "player value 14 | dealer value 24\n", "init (15, 4, False)\n", "player value 24 | dealer value 26\n", "init (16, 2, True)\n", "player value 17 | dealer value 23\n", "init (20, 2, False)\n", "player value 20 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (10, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 19\n", "init (15, 9, False)\n", "player value 23 | dealer value 19\n", "init (15, 7, False)\n", "player value 15 | dealer value 18\n", "init (10, 6, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 27 | dealer value 20\n", "init (18, 4, True)\n", "player value 18 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (12, 3, False)\n", "player value 22 | dealer value 21\n", "init (9, 9, False)\n", "player value 19 | dealer value 17\n", "init (19, 10, False)\n", "init (14, 10, False)\n", "init (19, 8, False)\n", "player value 19 | dealer value 17\n", "init (14, 8, False)\n", "player value 14 | dealer value 18\n", "init (18, 10, False)\n", "init (13, 6, False)\n", "player value 13 | dealer value 20\n", "init (16, 7, True)\n", "player value 16 | dealer value 21\n", "init (9, 9, False)\n", "player value 19 | dealer value 24\n", "init (16, 6, False)\n", "player value 16 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (9, 10, False)\n", "player value 27 | dealer value 19\n", "init (12, 10, False)\n", "player value 18 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (8, 10, False)\n", "init (15, 10, True)\n", "player value 21 | dealer value 20\n", "init (9, 10, False)\n", "player value 19 | dealer value 21\n", "init (15, 2, False)\n", "player value 20 | dealer value 21\n", "init (16, 10, False)\n", "init (16, 5, False)\n", "player value 26 | dealer value 21\n", "init (21, 1, True)\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (17, 2, False)\n", "player value 17 | dealer value 23\n", "init (8, 10, False)\n", "player value 19 | dealer value 24\n", "init (7, 6, False)\n", "player value 18 | dealer value 17\n", "init (13, 1, False)\n", "init (15, 10, True)\n", "init (12, 7, False)\n", "player value 19 | dealer value 26\n", "init (9, 6, False)\n", "player value 19 | dealer value 17\n", "init (10, 10, False)\n", "player value 21 | dealer value 18\n", "init (18, 7, False)\n", "player value 19 | dealer value 17\n", "init (16, 10, False)\n", "player value 19 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (15, 5, False)\n", "player value 15 | dealer value 19\n", "init (17, 9, True)\n", "player value 13 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 9, False)\n", "player value 20 | dealer value 17\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (20, 4, False)\n", "player value 26 | dealer value 22\n", "init (16, 9, False)\n", "player value 24 | dealer value 19\n", "init (12, 5, False)\n", "player value 14 | dealer value 18\n", "init (13, 5, False)\n", "player value 24 | dealer value 25\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (11, 3, False)\n", "player value 17 | dealer value 19\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 7, False)\n", "player value 17 | dealer value 17\n", "init (12, 2, False)\n", "player value 22 | dealer value 17\n", "init (16, 2, False)\n", "player value 26 | dealer value 17\n", "init (15, 2, False)\n", "player value 15 | dealer value 20\n", "init (10, 8, False)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (15, 6, False)\n", "player value 22 | dealer value 25\n", "init (20, 3, True)\n", "player value 20 | dealer value 17\n", "init (8, 1, False)\n", "player value 22 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (17, 5, False)\n", "player value 27 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 21\n", "init (15, 8, False)\n", "player value 15 | dealer value 18\n", "init (19, 1, False)\n", "player value 19 | dealer value 21\n", "init (12, 5, False)\n", "player value 24 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 10, True)\n", "player value 20 | dealer value 17\n", "init (21, 2, True)\n", "init (12, 7, False)\n", "player value 14 | dealer value 18\n", "init (17, 3, False)\n", "player value 17 | dealer value 21\n", "init (7, 4, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 21 | dealer value 20\n", "init (13, 1, False)\n", "player value 19 | dealer value 22\n", "init (20, 4, False)\n", "player value 20 | dealer value 18\n", "init (13, 10, True)\n", "player value 21 | dealer value 17\n", "init (16, 5, False)\n", "player value 19 | dealer value 17\n", "init (12, 9, False)\n", "player value 22 | dealer value 18\n", "init (18, 4, True)\n", "player value 22 | dealer value 17\n", "init (6, 4, False)\n", "player value 16 | dealer value 22\n", "init (18, 2, False)\n", "player value 18 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 25\n", "init (9, 1, False)\n", "init (15, 1, False)\n", "player value 18 | dealer value 19\n", "init (17, 2, False)\n", "player value 17 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (10, 10, False)\n", "player value 20 | dealer value 22\n", "init (13, 4, False)\n", "player value 21 | dealer value 20\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (14, 2, True)\n", "player value 19 | dealer value 21\n", "init (4, 7, False)\n", "player value 14 | dealer value 20\n", "init (12, 4, False)\n", "player value 22 | dealer value 18\n", "init (15, 10, True)\n", "player value 15 | dealer value 26\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (14, 6, False)\n", "player value 14 | dealer value 17\n", "init (15, 1, False)\n", "player value 24 | dealer value 17\n", "init (17, 9, False)\n", "player value 20 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 3, False)\n", "player value 20 | dealer value 18\n", "init (14, 8, False)\n", "player value 14 | dealer value 18\n", "init (12, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 5, False)\n", "player value 26 | dealer value 23\n", "init (17, 6, False)\n", "player value 17 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 7, False)\n", "player value 21 | dealer value 17\n", "init (17, 7, False)\n", "player value 25 | dealer value 20\n", "init (18, 4, True)\n", "player value 18 | dealer value 18\n", "init (14, 6, False)\n", "player value 14 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 22\n", "init (12, 10, False)\n", "player value 12 | dealer value 17\n", "init (14, 9, False)\n", "player value 21 | dealer value 17\n", "init (15, 4, True)\n", "player value 20 | dealer value 23\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 1, False)\n", "player value 25 | dealer value 20\n", "init (8, 5, False)\n", "player value 26 | dealer value 22\n", "init (7, 2, False)\n", "player value 13 | dealer value 22\n", "init (12, 2, False)\n", "player value 18 | dealer value 19\n", "init (17, 5, False)\n", "player value 31 | dealer value 25\n", "init (20, 7, False)\n", "player value 20 | dealer value 26\n", "init (19, 10, True)\n", "init (19, 5, False)\n", "player value 19 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (19, 10, True)\n", "player value 29 | dealer value 26\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (16, 2, True)\n", "player value 13 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 22\n", "init (15, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (13, 4, False)\n", "player value 22 | dealer value 19\n", "init (20, 5, True)\n", "player value 18 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 24\n", "init (14, 5, True)\n", "player value 14 | dealer value 21\n", "init (14, 6, False)\n", "player value 14 | dealer value 18\n", "init (10, 4, False)\n", "player value 21 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 6, False)\n", "player value 22 | dealer value 21\n", "init (10, 1, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 3, False)\n", "player value 23 | dealer value 21\n", "init (11, 10, False)\n", "player value 12 | dealer value 21\n", "init (17, 9, False)\n", "player value 17 | dealer value 18\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (21, 10, True)\n", "init (10, 8, False)\n", "player value 28 | dealer value 26\n", "init (20, 6, False)\n", "player value 25 | dealer value 22\n", "init (13, 9, False)\n", "player value 18 | dealer value 25\n", "init (13, 1, False)\n", "player value 23 | dealer value 18\n", "init (16, 10, False)\n", "player value 18 | dealer value 21\n", "init (19, 4, False)\n", "player value 19 | dealer value 17\n", "init (6, 7, False)\n", "player value 19 | dealer value 17\n", "init (17, 9, True)\n", "player value 21 | dealer value 21\n", "init (13, 6, False)\n", "player value 13 | dealer value 20\n", "init (18, 1, False)\n", "player value 18 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 25\n", "init (13, 5, False)\n", "player value 13 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (16, 10, True)\n", "player value 23 | dealer value 25\n", "init (12, 4, False)\n", "player value 19 | dealer value 20\n", "init (18, 1, True)\n", "init (16, 8, True)\n", "player value 20 | dealer value 19\n", "init (13, 7, False)\n", "player value 21 | dealer value 23\n", "init (15, 5, False)\n", "player value 15 | dealer value 19\n", "init (17, 3, False)\n", "player value 17 | dealer value 21\n", "init (9, 3, False)\n", "player value 19 | dealer value 18\n", "init (11, 7, False)\n", "player value 18 | dealer value 17\n", "init (15, 7, True)\n", "player value 22 | dealer value 17\n", "init (10, 3, False)\n", "player value 19 | dealer value 23\n", "init (13, 3, False)\n", "player value 20 | dealer value 26\n", "init (5, 9, False)\n", "player value 25 | dealer value 26\n", "init (15, 7, False)\n", "player value 25 | dealer value 24\n", "init (20, 3, True)\n", "player value 20 | dealer value 20\n", "init (12, 1, False)\n", "player value 19 | dealer value 20\n", "init (17, 3, False)\n", "player value 17 | dealer value 19\n", "init (10, 4, False)\n", "player value 19 | dealer value 26\n", "init (10, 8, False)\n", "player value 21 | dealer value 18\n", "init (12, 3, False)\n", "player value 19 | dealer value 25\n", "init (14, 7, False)\n", "player value 25 | dealer value 18\n", "init (16, 1, True)\n", "init (12, 5, False)\n", "player value 19 | dealer value 19\n", "round 6000\n", "init (20, 2, False)\n", "player value 20 | dealer value 25\n", "init (17, 2, False)\n", "player value 27 | dealer value 17\n", "init (19, 4, False)\n", "player value 19 | dealer value 23\n", "init (13, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 10, False)\n", "player value 18 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (12, 9, False)\n", "player value 20 | dealer value 17\n", "init (16, 7, True)\n", "player value 19 | dealer value 20\n", "init (10, 8, False)\n", "player value 24 | dealer value 18\n", "init (11, 5, False)\n", "player value 21 | dealer value 23\n", "init (21, 6, True)\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (11, 3, False)\n", "player value 24 | dealer value 22\n", "init (10, 10, False)\n", "player value 22 | dealer value 21\n", "init (16, 4, False)\n", "player value 16 | dealer value 20\n", "init (14, 9, False)\n", "player value 24 | dealer value 19\n", "init (13, 6, False)\n", "player value 23 | dealer value 19\n", "init (16, 1, False)\n", "player value 20 | dealer value 19\n", "init (15, 5, True)\n", "player value 15 | dealer value 22\n", "init (9, 2, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 1, False)\n", "player value 12 | dealer value 21\n", "init (21, 1, True)\n", "init (11, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 19\n", "init (19, 10, False)\n", "init (15, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 24\n", "init (8, 6, False)\n", "player value 12 | dealer value 24\n", "init (12, 6, False)\n", "player value 12 | dealer value 26\n", "init (17, 9, True)\n", "player value 21 | dealer value 18\n", "init (13, 10, False)\n", "player value 21 | dealer value 22\n", "init (14, 10, False)\n", "player value 20 | dealer value 22\n", "init (18, 1, False)\n", "init (16, 2, False)\n", "player value 18 | dealer value 22\n", "init (9, 1, False)\n", "init (14, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 24\n", "init (17, 10, False)\n", "player value 26 | dealer value 20\n", "init (16, 8, False)\n", "player value 26 | dealer value 21\n", "init (11, 6, False)\n", "player value 16 | dealer value 22\n", "init (16, 10, False)\n", "player value 23 | dealer value 25\n", "init (15, 10, False)\n", "player value 25 | dealer value 26\n", "init (12, 4, False)\n", "player value 18 | dealer value 24\n", "init (17, 5, False)\n", "player value 20 | dealer value 19\n", "init (15, 4, False)\n", "player value 21 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (16, 10, True)\n", "init (7, 9, False)\n", "player value 20 | dealer value 19\n", "init (20, 10, False)\n", "player value 30 | dealer value 22\n", "init (20, 3, False)\n", "player value 25 | dealer value 18\n", "init (18, 5, False)\n", "player value 19 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (14, 2, False)\n", "player value 24 | dealer value 22\n", "init (19, 10, False)\n", "player value 24 | dealer value 20\n", "init (15, 10, False)\n", "player value 23 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (10, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 4, False)\n", "player value 20 | dealer value 17\n", "init (16, 1, False)\n", "player value 18 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 5, False)\n", "player value 15 | dealer value 26\n", "init (16, 4, False)\n", "player value 21 | dealer value 25\n", "init (7, 4, False)\n", "player value 18 | dealer value 26\n", "init (15, 9, False)\n", "player value 25 | dealer value 19\n", "init (13, 10, False)\n", "init (7, 10, False)\n", "player value 27 | dealer value 19\n", "init (11, 10, False)\n", "player value 19 | dealer value 26\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (14, 5, False)\n", "player value 18 | dealer value 26\n", "init (17, 2, True)\n", "player value 17 | dealer value 20\n", "init (16, 6, True)\n", "player value 16 | dealer value 23\n", "init (10, 3, False)\n", "player value 20 | dealer value 18\n", "init (11, 10, False)\n", "init (10, 6, False)\n", "player value 20 | dealer value 26\n", "init (14, 8, False)\n", "player value 14 | dealer value 18\n", "init (13, 2, False)\n", "player value 13 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (16, 7, False)\n", "player value 17 | dealer value 22\n", "init (12, 6, False)\n", "player value 12 | dealer value 22\n", "init (6, 2, False)\n", "player value 21 | dealer value 22\n", "init (14, 5, False)\n", "player value 23 | dealer value 21\n", "init (11, 4, False)\n", "player value 21 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 2, False)\n", "player value 13 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 23\n", "init (13, 9, False)\n", "player value 20 | dealer value 22\n", "init (10, 8, False)\n", "player value 20 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (21, 9, True)\n", "init (8, 9, False)\n", "player value 24 | dealer value 20\n", "init (21, 10, True)\n", "init (17, 9, False)\n", "player value 17 | dealer value 26\n", "init (13, 10, False)\n", "player value 18 | dealer value 23\n", "init (10, 9, False)\n", "player value 19 | dealer value 17\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (7, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 7, False)\n", "player value 18 | dealer value 21\n", "init (16, 10, True)\n", "player value 20 | dealer value 19\n", "init (8, 3, False)\n", "player value 14 | dealer value 21\n", "init (17, 10, True)\n", "player value 20 | dealer value 18\n", "init (15, 2, True)\n", "player value 20 | dealer value 23\n", "init (10, 7, False)\n", "player value 20 | dealer value 18\n", "init (18, 3, True)\n", "player value 19 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (8, 1, False)\n", "player value 18 | dealer value 19\n", "init (12, 2, False)\n", "player value 22 | dealer value 24\n", "init (10, 10, False)\n", "player value 27 | dealer value 19\n", "init (16, 10, False)\n", "player value 24 | dealer value 17\n", "init (12, 8, True)\n", "player value 15 | dealer value 17\n", "init (16, 1, False)\n", "init (14, 9, False)\n", "player value 24 | dealer value 19\n", "init (17, 9, False)\n", "player value 17 | dealer value 20\n", "init (18, 3, False)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "player value 18 | dealer value 21\n", "init (9, 10, False)\n", "init (19, 3, False)\n", "player value 28 | dealer value 19\n", "init (9, 5, False)\n", "player value 24 | dealer value 22\n", "init (17, 3, True)\n", "player value 17 | dealer value 23\n", "init (19, 1, True)\n", "player value 19 | dealer value 20\n", "init (16, 9, False)\n", "player value 26 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "player value 25 | dealer value 23\n", "init (21, 10, True)\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (21, 8, True)\n", "init (16, 10, False)\n", "player value 26 | dealer value 18\n", "init (13, 3, False)\n", "player value 19 | dealer value 21\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (14, 2, True)\n", "player value 24 | dealer value 25\n", "init (15, 7, False)\n", "player value 25 | dealer value 17\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (19, 2, True)\n", "player value 19 | dealer value 24\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (21, 10, True)\n", "init (12, 6, False)\n", "player value 12 | dealer value 22\n", "init (12, 7, False)\n", "player value 17 | dealer value 17\n", "init (10, 10, False)\n", "player value 19 | dealer value 20\n", "init (10, 8, False)\n", "player value 25 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (17, 6, True)\n", "player value 17 | dealer value 23\n", "init (11, 3, False)\n", "player value 23 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 7, False)\n", "player value 24 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (9, 10, False)\n", "player value 25 | dealer value 19\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (10, 10, False)\n", "player value 18 | dealer value 21\n", "init (13, 5, False)\n", "player value 13 | dealer value 22\n", "init (12, 10, False)\n", "player value 28 | dealer value 24\n", "init (8, 4, False)\n", "player value 19 | dealer value 17\n", "init (21, 10, True)\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (13, 10, True)\n", "player value 21 | dealer value 18\n", "init (8, 8, False)\n", "player value 15 | dealer value 19\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (11, 4, False)\n", "player value 20 | dealer value 23\n", "init (12, 10, False)\n", "player value 21 | dealer value 17\n", "init (14, 2, False)\n", "player value 22 | dealer value 25\n", "init (11, 10, False)\n", "player value 23 | dealer value 18\n", "init (14, 5, False)\n", "player value 24 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (18, 10, False)\n", "player value 27 | dealer value 20\n", "init (10, 10, False)\n", "player value 21 | dealer value 21\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (4, 5, False)\n", "player value 24 | dealer value 19\n", "init (11, 8, False)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 5, False)\n", "player value 19 | dealer value 25\n", "init (15, 10, False)\n", "player value 24 | dealer value 17\n", "init (13, 1, False)\n", "player value 25 | dealer value 20\n", "init (12, 3, False)\n", "player value 22 | dealer value 19\n", "init (16, 5, False)\n", "player value 25 | dealer value 20\n", "init (9, 10, False)\n", "player value 25 | dealer value 17\n", "init (21, 9, True)\n", "init (13, 9, False)\n", "player value 21 | dealer value 19\n", "init (15, 5, False)\n", "player value 15 | dealer value 19\n", "init (19, 6, False)\n", "player value 30 | dealer value 18\n", "init (16, 2, False)\n", "player value 23 | dealer value 17\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (7, 3, False)\n", "player value 12 | dealer value 19\n", "init (20, 1, True)\n", "player value 20 | dealer value 20\n", "init (12, 8, False)\n", "player value 22 | dealer value 23\n", "init (5, 4, False)\n", "player value 21 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (17, 8, False)\n", "player value 17 | dealer value 21\n", "init (14, 10, False)\n", "player value 23 | dealer value 19\n", "init (12, 8, False)\n", "player value 12 | dealer value 18\n", "init (15, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (13, 6, True)\n", "player value 20 | dealer value 17\n", "init (10, 9, False)\n", "player value 30 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 8, False)\n", "player value 17 | dealer value 19\n", "init (19, 7, False)\n", "player value 19 | dealer value 25\n", "init (19, 3, False)\n", "player value 19 | dealer value 23\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (18, 4, False)\n", "player value 18 | dealer value 21\n", "init (6, 9, False)\n", "player value 21 | dealer value 26\n", "init (10, 2, False)\n", "player value 20 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (16, 6, False)\n", "player value 16 | dealer value 26\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 10, True)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (13, 9, True)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (9, 9, False)\n", "player value 23 | dealer value 19\n", "init (13, 8, False)\n", "player value 27 | dealer value 24\n", "init (20, 6, False)\n", "player value 20 | dealer value 25\n", "init (20, 9, False)\n", "player value 20 | dealer value 24\n", "init (20, 1, False)\n", "init (21, 9, True)\n", "init (10, 2, False)\n", "player value 20 | dealer value 19\n", "init (15, 5, False)\n", "player value 15 | dealer value 19\n", "init (16, 3, False)\n", "player value 26 | dealer value 19\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 3, False)\n", "player value 14 | dealer value 20\n", "init (12, 1, False)\n", "player value 17 | dealer value 17\n", "init (12, 9, False)\n", "player value 12 | dealer value 25\n", "init (21, 1, True)\n", "init (13, 1, False)\n", "player value 23 | dealer value 23\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (14, 2, False)\n", "player value 17 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 19\n", "init (12, 2, False)\n", "player value 17 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 23\n", "init (16, 6, False)\n", "player value 16 | dealer value 18\n", "init (19, 6, True)\n", "player value 13 | dealer value 20\n", "init (15, 1, True)\n", "player value 20 | dealer value 19\n", "init (12, 2, False)\n", "player value 18 | dealer value 21\n", "init (5, 10, False)\n", "player value 19 | dealer value 24\n", "init (21, 6, True)\n", "init (19, 10, True)\n", "player value 19 | dealer value 20\n", "init (6, 5, False)\n", "player value 14 | dealer value 21\n", "init (14, 4, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (14, 6, False)\n", "player value 14 | dealer value 19\n", "init (16, 2, False)\n", "player value 26 | dealer value 23\n", "init (13, 5, False)\n", "player value 22 | dealer value 19\n", "init (8, 2, False)\n", "player value 18 | dealer value 26\n", "init (17, 2, False)\n", "player value 17 | dealer value 24\n", "init (15, 1, False)\n", "init (12, 9, False)\n", "player value 12 | dealer value 20\n", "init (10, 1, False)\n", "player value 21 | dealer value 17\n", "init (6, 6, False)\n", "player value 14 | dealer value 26\n", "init (17, 8, False)\n", "player value 20 | dealer value 18\n", "init (7, 5, False)\n", "player value 15 | dealer value 25\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (14, 4, False)\n", "player value 24 | dealer value 21\n", "init (18, 1, False)\n", "player value 18 | dealer value 17\n", "init (18, 9, False)\n", "player value 18 | dealer value 26\n", "init (15, 4, False)\n", "player value 23 | dealer value 24\n", "init (15, 5, False)\n", "player value 15 | dealer value 22\n", "init (13, 6, False)\n", "player value 13 | dealer value 22\n", "init (10, 2, False)\n", "player value 26 | dealer value 19\n", "init (13, 4, True)\n", "player value 24 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 24\n", "init (16, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 4, True)\n", "player value 17 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (17, 10, False)\n", "player value 24 | dealer value 20\n", "init (16, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 1, True)\n", "player value 17 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 25\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (8, 3, False)\n", "player value 16 | dealer value 23\n", "init (15, 8, False)\n", "player value 24 | dealer value 24\n", "init (17, 2, False)\n", "player value 17 | dealer value 18\n", "init (12, 1, False)\n", "player value 22 | dealer value 20\n", "init (7, 10, False)\n", "player value 19 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (17, 1, True)\n", "player value 16 | dealer value 25\n", "init (11, 6, False)\n", "player value 12 | dealer value 25\n", "init (12, 1, False)\n", "player value 22 | dealer value 20\n", "init (11, 10, False)\n", "init (5, 2, False)\n", "player value 18 | dealer value 23\n", "init (6, 8, False)\n", "player value 15 | dealer value 25\n", "init (19, 6, False)\n", "player value 19 | dealer value 17\n", "init (14, 10, False)\n", "player value 23 | dealer value 23\n", "init (16, 5, False)\n", "player value 17 | dealer value 17\n", "init (6, 5, False)\n", "player value 24 | dealer value 17\n", "init (10, 2, False)\n", "player value 23 | dealer value 20\n", "init (9, 9, False)\n", "player value 25 | dealer value 19\n", "init (20, 2, False)\n", "player value 20 | dealer value 21\n", "init (12, 8, False)\n", "player value 19 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (13, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 22\n", "init (14, 1, False)\n", "player value 14 | dealer value 18\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (8, 7, False)\n", "player value 17 | dealer value 21\n", "init (17, 6, False)\n", "player value 17 | dealer value 25\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (14, 6, False)\n", "player value 14 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 18\n", "init (14, 10, False)\n", "player value 23 | dealer value 23\n", "init (19, 1, True)\n", "init (13, 10, False)\n", "player value 19 | dealer value 19\n", "init (16, 10, False)\n", "player value 24 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (13, 4, False)\n", "player value 21 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (12, 10, False)\n", "init (19, 7, False)\n", "player value 19 | dealer value 20\n", "init (16, 10, False)\n", "init (15, 3, False)\n", "player value 25 | dealer value 22\n", "init (7, 9, False)\n", "player value 24 | dealer value 17\n", "init (13, 7, False)\n", "player value 19 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 1, False)\n", "player value 27 | dealer value 18\n", "init (11, 7, False)\n", "player value 18 | dealer value 21\n", "init (12, 8, False)\n", "player value 23 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (8, 9, False)\n", "player value 25 | dealer value 18\n", "init (18, 10, False)\n", "player value 26 | dealer value 23\n", "init (16, 6, False)\n", "player value 16 | dealer value 23\n", "init (21, 9, True)\n", "init (15, 2, True)\n", "player value 21 | dealer value 25\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (17, 5, False)\n", "player value 27 | dealer value 17\n", "init (15, 9, False)\n", "player value 25 | dealer value 20\n", "init (14, 7, True)\n", "player value 14 | dealer value 20\n", "init (19, 1, False)\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (19, 10, True)\n", "player value 19 | dealer value 23\n", "init (17, 9, False)\n", "player value 24 | dealer value 19\n", "init (13, 4, True)\n", "player value 19 | dealer value 22\n", "init (13, 2, False)\n", "player value 13 | dealer value 17\n", "init (14, 8, False)\n", "player value 19 | dealer value 18\n", "init (11, 5, False)\n", "player value 21 | dealer value 21\n", "init (19, 2, False)\n", "player value 19 | dealer value 21\n", "init (14, 10, False)\n", "player value 14 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (9, 10, False)\n", "player value 19 | dealer value 17\n", "init (15, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (12, 2, False)\n", "player value 24 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 1, False)\n", "player value 19 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (19, 10, True)\n", "player value 21 | dealer value 18\n", "init (16, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 3, False)\n", "player value 13 | dealer value 21\n", "init (19, 7, False)\n", "player value 19 | dealer value 22\n", "init (17, 10, False)\n", "player value 17 | dealer value 21\n", "init (14, 8, False)\n", "player value 19 | dealer value 20\n", "init (17, 1, True)\n", "player value 17 | dealer value 18\n", "init (17, 10, False)\n", "player value 20 | dealer value 17\n", "init (21, 8, True)\n", "init (13, 10, False)\n", "player value 21 | dealer value 21\n", "init (14, 9, False)\n", "player value 22 | dealer value 19\n", "init (12, 10, False)\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (13, 8, False)\n", "player value 26 | dealer value 21\n", "init (12, 7, True)\n", "player value 12 | dealer value 26\n", "init (12, 1, False)\n", "player value 12 | dealer value 20\n", "init (14, 5, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 23 | dealer value 19\n", "init (10, 5, False)\n", "player value 15 | dealer value 25\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (17, 9, False)\n", "player value 27 | dealer value 24\n", "init (16, 2, False)\n", "player value 26 | dealer value 22\n", "init (16, 1, False)\n", "init (8, 6, False)\n", "player value 19 | dealer value 19\n", "init (15, 8, False)\n", "player value 15 | dealer value 17\n", "init (12, 9, False)\n", "player value 13 | dealer value 21\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (19, 6, False)\n", "player value 19 | dealer value 24\n", "init (17, 6, False)\n", "player value 17 | dealer value 23\n", "init (19, 2, False)\n", "player value 19 | dealer value 23\n", "init (9, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (14, 3, False)\n", "player value 24 | dealer value 19\n", "init (17, 5, False)\n", "player value 27 | dealer value 25\n", "init (18, 10, True)\n", "player value 23 | dealer value 21\n", "init (7, 2, False)\n", "player value 24 | dealer value 24\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 8, False)\n", "player value 25 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (16, 8, True)\n", "player value 25 | dealer value 26\n", "init (17, 10, False)\n", "init (20, 3, True)\n", "player value 22 | dealer value 23\n", "init (12, 1, False)\n", "init (16, 9, False)\n", "player value 19 | dealer value 19\n", "init (13, 6, False)\n", "player value 25 | dealer value 18\n", "init (20, 10, False)\n", "player value 26 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 17\n", "init (13, 6, False)\n", "player value 17 | dealer value 20\n", "init (10, 3, False)\n", "player value 20 | dealer value 21\n", "init (9, 3, False)\n", "player value 27 | dealer value 17\n", "init (17, 7, False)\n", "player value 26 | dealer value 17\n", "init (17, 7, False)\n", "player value 17 | dealer value 21\n", "init (15, 8, False)\n", "player value 15 | dealer value 17\n", "init (9, 10, False)\n", "player value 19 | dealer value 19\n", "init (21, 1, True)\n", "init (16, 10, False)\n", "player value 25 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (7, 4, False)\n", "player value 19 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (14, 10, False)\n", "player value 21 | dealer value 22\n", "init (20, 10, False)\n", "init (14, 10, True)\n", "player value 13 | dealer value 20\n", "init (21, 3, True)\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (19, 1, False)\n", "init (12, 4, False)\n", "player value 14 | dealer value 17\n", "init (9, 10, False)\n", "player value 19 | dealer value 19\n", "init (15, 4, False)\n", "player value 22 | dealer value 24\n", "init (16, 8, False)\n", "player value 16 | dealer value 22\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (15, 9, False)\n", "player value 25 | dealer value 17\n", "init (18, 4, False)\n", "player value 18 | dealer value 20\n", "init (14, 4, False)\n", "player value 24 | dealer value 18\n", "init (18, 1, True)\n", "player value 18 | dealer value 18\n", "init (14, 7, True)\n", "player value 18 | dealer value 25\n", "init (14, 9, False)\n", "player value 14 | dealer value 23\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (21, 4, True)\n", "init (14, 5, False)\n", "player value 21 | dealer value 18\n", "init (17, 9, False)\n", "player value 26 | dealer value 17\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (17, 7, True)\n", "player value 27 | dealer value 17\n", "init (11, 7, False)\n", "player value 18 | dealer value 18\n", "init (12, 6, True)\n", "player value 21 | dealer value 21\n", "init (21, 5, True)\n", "init (17, 10, False)\n", "player value 22 | dealer value 25\n", "init (9, 4, False)\n", "player value 12 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (6, 7, False)\n", "player value 23 | dealer value 17\n", "init (18, 1, False)\n", "player value 18 | dealer value 24\n", "init (11, 10, False)\n", "player value 24 | dealer value 26\n", "init (20, 4, False)\n", "player value 20 | dealer value 19\n", "init (14, 9, False)\n", "player value 14 | dealer value 18\n", "init (18, 6, False)\n", "player value 18 | dealer value 18\n", "init (15, 5, False)\n", "player value 15 | dealer value 17\n", "init (12, 4, False)\n", "player value 21 | dealer value 22\n", "init (19, 2, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "init (12, 7, False)\n", "player value 18 | dealer value 18\n", "init (20, 1, False)\n", "player value 20 | dealer value 17\n", "init (12, 5, False)\n", "player value 22 | dealer value 25\n", "init (16, 10, False)\n", "player value 22 | dealer value 22\n", "init (14, 10, False)\n", "player value 25 | dealer value 18\n", "init (13, 4, False)\n", "player value 23 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 23\n", "init (11, 4, False)\n", "player value 21 | dealer value 18\n", "init (13, 1, False)\n", "player value 20 | dealer value 18\n", "init (21, 1, True)\n", "init (6, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 10, False)\n", "player value 28 | dealer value 25\n", "init (10, 8, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (13, 10, False)\n", "player value 18 | dealer value 20\n", "init (13, 8, False)\n", "player value 23 | dealer value 22\n", "init (5, 9, False)\n", "player value 25 | dealer value 23\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (11, 3, False)\n", "player value 21 | dealer value 23\n", "init (14, 9, False)\n", "player value 14 | dealer value 19\n", "init (17, 3, False)\n", "player value 27 | dealer value 18\n", "init (16, 5, False)\n", "player value 22 | dealer value 18\n", "init (21, 7, True)\n", "init (13, 10, False)\n", "player value 23 | dealer value 17\n", "init (17, 7, True)\n", "player value 14 | dealer value 18\n", "init (13, 9, False)\n", "player value 20 | dealer value 22\n", "init (18, 10, False)\n", "player value 27 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 19\n", "init (10, 3, False)\n", "player value 16 | dealer value 26\n", "init (14, 10, False)\n", "player value 21 | dealer value 25\n", "init (21, 1, True)\n", "init (10, 10, False)\n", "player value 20 | dealer value 18\n", "init (16, 4, False)\n", "player value 26 | dealer value 23\n", "init (15, 4, False)\n", "player value 23 | dealer value 17\n", "init (7, 6, False)\n", "player value 18 | dealer value 17\n", "init (21, 3, True)\n", "init (11, 10, False)\n", "player value 22 | dealer value 20\n", "init (15, 4, False)\n", "player value 27 | dealer value 22\n", "init (19, 6, True)\n", "player value 12 | dealer value 17\n", "init (16, 8, False)\n", "player value 16 | dealer value 18\n", "init (9, 9, False)\n", "player value 19 | dealer value 24\n", "init (11, 2, False)\n", "player value 18 | dealer value 22\n", "init (17, 5, False)\n", "player value 19 | dealer value 18\n", "init (13, 10, False)\n", "player value 20 | dealer value 19\n", "init (19, 9, False)\n", "player value 19 | dealer value 26\n", "init (9, 10, False)\n", "player value 21 | dealer value 23\n", "init (9, 10, False)\n", "player value 21 | dealer value 18\n", "init (12, 8, False)\n", "player value 22 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 21\n", "init (17, 7, False)\n", "player value 17 | dealer value 18\n", "init (21, 5, True)\n", "init (6, 2, False)\n", "player value 17 | dealer value 24\n", "init (10, 1, False)\n", "player value 22 | dealer value 18\n", "init (11, 8, False)\n", "player value 12 | dealer value 18\n", "init (11, 8, False)\n", "player value 12 | dealer value 23\n", "init (10, 7, False)\n", "player value 17 | dealer value 25\n", "init (10, 5, False)\n", "player value 22 | dealer value 19\n", "init (21, 4, True)\n", "init (7, 1, False)\n", "player value 24 | dealer value 18\n", "init (21, 8, True)\n", "init (8, 10, False)\n", "player value 27 | dealer value 20\n", "init (19, 7, True)\n", "player value 17 | dealer value 17\n", "init (7, 4, False)\n", "player value 23 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 19\n", "init (7, 10, False)\n", "player value 25 | dealer value 18\n", "init (21, 5, True)\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (14, 6, False)\n", "player value 14 | dealer value 17\n", "init (16, 10, False)\n", "player value 16 | dealer value 26\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (11, 8, False)\n", "player value 16 | dealer value 18\n", "init (12, 5, True)\n", "player value 12 | dealer value 20\n", "init (12, 5, False)\n", "player value 22 | dealer value 18\n", "init (12, 4, False)\n", "player value 18 | dealer value 17\n", "init (15, 7, False)\n", "player value 25 | dealer value 26\n", "init (19, 3, False)\n", "player value 19 | dealer value 17\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (5, 8, False)\n", "player value 27 | dealer value 20\n", "init (13, 10, False)\n", "player value 16 | dealer value 23\n", "init (10, 8, False)\n", "player value 25 | dealer value 18\n", "init (16, 6, False)\n", "player value 16 | dealer value 24\n", "init (12, 8, False)\n", "player value 19 | dealer value 19\n", "init (14, 9, False)\n", "player value 19 | dealer value 22\n", "init (16, 10, False)\n", "player value 23 | dealer value 26\n", "init (17, 5, False)\n", "player value 26 | dealer value 21\n", "init (14, 8, False)\n", "player value 22 | dealer value 17\n", "init (12, 1, False)\n", "player value 12 | dealer value 17\n", "init (10, 4, False)\n", "player value 21 | dealer value 22\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (19, 10, True)\n", "player value 19 | dealer value 21\n", "init (16, 4, False)\n", "player value 24 | dealer value 23\n", "init (20, 10, False)\n", "player value 30 | dealer value 20\n", "init (17, 6, False)\n", "player value 17 | dealer value 24\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (15, 8, False)\n", "player value 21 | dealer value 19\n", "init (17, 10, False)\n", "init (16, 1, False)\n", "player value 26 | dealer value 23\n", "init (13, 10, False)\n", "player value 27 | dealer value 23\n", "init (18, 7, True)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (8, 7, False)\n", "player value 18 | dealer value 17\n", "init (14, 4, False)\n", "player value 21 | dealer value 21\n", "init (10, 10, False)\n", "init (16, 4, False)\n", "player value 20 | dealer value 18\n", "init (5, 5, False)\n", "player value 15 | dealer value 21\n", "init (15, 4, True)\n", "player value 19 | dealer value 23\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (5, 5, False)\n", "player value 15 | dealer value 17\n", "init (14, 1, False)\n", "player value 14 | dealer value 19\n", "init (16, 3, False)\n", "player value 16 | dealer value 17\n", "init (12, 10, False)\n", "player value 23 | dealer value 17\n", "init (10, 7, False)\n", "player value 20 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (19, 5, True)\n", "player value 19 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 6, False)\n", "player value 17 | dealer value 19\n", "init (20, 1, False)\n", "player value 26 | dealer value 18\n", "init (5, 6, False)\n", "player value 25 | dealer value 24\n", "init (12, 3, False)\n", "player value 22 | dealer value 26\n", "init (16, 6, False)\n", "player value 16 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 17\n", "init (16, 8, True)\n", "player value 18 | dealer value 19\n", "init (18, 5, False)\n", "player value 18 | dealer value 25\n", "init (19, 3, False)\n", "player value 19 | dealer value 24\n", "init (12, 9, False)\n", "player value 12 | dealer value 19\n", "init (11, 1, False)\n", "init (12, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 3, False)\n", "player value 21 | dealer value 18\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 20\n", "init (15, 2, False)\n", "player value 20 | dealer value 19\n", "init (9, 4, False)\n", "player value 21 | dealer value 23\n", "init (19, 7, False)\n", "player value 29 | dealer value 17\n", "init (6, 5, False)\n", "player value 15 | dealer value 24\n", "init (15, 10, False)\n", "player value 20 | dealer value 19\n", "init (21, 8, True)\n", "init (21, 5, True)\n", "init (15, 8, True)\n", "player value 15 | dealer value 18\n", "init (7, 8, False)\n", "player value 24 | dealer value 22\n", "init (7, 8, False)\n", "player value 25 | dealer value 17\n", "init (12, 5, False)\n", "player value 22 | dealer value 17\n", "init (14, 6, False)\n", "player value 14 | dealer value 23\n", "init (11, 8, False)\n", "player value 18 | dealer value 19\n", "init (11, 5, False)\n", "player value 19 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (21, 5, True)\n", "init (9, 7, False)\n", "player value 18 | dealer value 18\n", "init (14, 4, True)\n", "player value 14 | dealer value 19\n", "init (13, 10, False)\n", "player value 21 | dealer value 25\n", "init (16, 9, False)\n", "player value 21 | dealer value 17\n", "init (13, 9, False)\n", "player value 19 | dealer value 17\n", "init (13, 10, False)\n", "player value 22 | dealer value 26\n", "init (7, 5, False)\n", "player value 24 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 10, False)\n", "player value 16 | dealer value 19\n", "init (16, 1, False)\n", "player value 21 | dealer value 19\n", "init (21, 10, True)\n", "init (6, 5, False)\n", "player value 13 | dealer value 19\n", "init (8, 4, False)\n", "player value 15 | dealer value 20\n", "init (15, 10, False)\n", "player value 23 | dealer value 17\n", "init (18, 9, False)\n", "player value 25 | dealer value 20\n", "init (19, 5, False)\n", "player value 19 | dealer value 24\n", "init (9, 3, False)\n", "player value 17 | dealer value 20\n", "init (17, 6, False)\n", "player value 17 | dealer value 26\n", "init (16, 5, False)\n", "player value 26 | dealer value 17\n", "init (14, 9, False)\n", "player value 24 | dealer value 20\n", "init (20, 10, True)\n", "init (14, 7, False)\n", "player value 26 | dealer value 25\n", "init (21, 7, True)\n", "init (14, 7, False)\n", "player value 24 | dealer value 24\n", "init (15, 3, False)\n", "player value 16 | dealer value 19\n", "init (12, 10, True)\n", "init (17, 3, False)\n", "player value 20 | dealer value 20\n", "init (16, 7, True)\n", "player value 30 | dealer value 24\n", "init (15, 10, False)\n", "player value 27 | dealer value 26\n", "init (14, 3, True)\n", "player value 14 | dealer value 22\n", "init (11, 10, False)\n", "player value 19 | dealer value 19\n", "init (21, 9, True)\n", "init (10, 5, False)\n", "player value 21 | dealer value 22\n", "init (9, 9, False)\n", "player value 25 | dealer value 20\n", "init (10, 10, False)\n", "player value 20 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 26\n", "init (12, 2, False)\n", "player value 20 | dealer value 20\n", "init (15, 8, False)\n", "player value 15 | dealer value 20\n", "init (18, 10, False)\n", "player value 26 | dealer value 24\n", "init (18, 9, True)\n", "player value 19 | dealer value 22\n", "init (15, 8, False)\n", "player value 23 | dealer value 17\n", "init (13, 8, False)\n", "player value 13 | dealer value 25\n", "init (16, 10, False)\n", "player value 19 | dealer value 26\n", "init (10, 3, False)\n", "player value 23 | dealer value 18\n", "init (17, 10, False)\n", "player value 25 | dealer value 20\n", "init (14, 7, False)\n", "player value 24 | dealer value 18\n", "init (14, 3, False)\n", "player value 14 | dealer value 22\n", "init (12, 6, False)\n", "player value 12 | dealer value 22\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (7, 1, False)\n", "player value 20 | dealer value 21\n", "init (19, 10, False)\n", "init (17, 7, False)\n", "player value 17 | dealer value 22\n", "init (21, 9, True)\n", "init (13, 10, False)\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (12, 2, False)\n", "player value 24 | dealer value 25\n", "init (12, 3, False)\n", "player value 20 | dealer value 23\n", "init (10, 5, False)\n", "player value 21 | dealer value 18\n", "init (16, 3, False)\n", "player value 16 | dealer value 26\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (13, 4, False)\n", "player value 18 | dealer value 21\n", "init (18, 2, False)\n", "player value 18 | dealer value 20\n", "init (5, 7, False)\n", "player value 18 | dealer value 17\n", "init (17, 7, True)\n", "player value 24 | dealer value 17\n", "init (9, 6, False)\n", "player value 26 | dealer value 26\n", "init (16, 10, True)\n", "player value 23 | dealer value 20\n", "init (21, 4, True)\n", "init (20, 2, False)\n", "player value 20 | dealer value 23\n", "init (10, 4, False)\n", "player value 20 | dealer value 18\n", "init (19, 1, True)\n", "player value 19 | dealer value 20\n", "init (21, 10, True)\n", "init (11, 9, False)\n", "player value 21 | dealer value 17\n", "init (18, 7, False)\n", "player value 27 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (6, 5, False)\n", "player value 15 | dealer value 25\n", "init (9, 8, False)\n", "player value 22 | dealer value 25\n", "init (8, 10, False)\n", "player value 28 | dealer value 26\n", "init (8, 7, False)\n", "player value 18 | dealer value 26\n", "init (12, 3, False)\n", "player value 26 | dealer value 18\n", "init (15, 10, False)\n", "player value 20 | dealer value 25\n", "init (21, 4, True)\n", "init (13, 10, False)\n", "player value 23 | dealer value 24\n", "init (19, 2, True)\n", "player value 19 | dealer value 17\n", "init (7, 2, False)\n", "player value 17 | dealer value 24\n", "init (13, 3, False)\n", "player value 16 | dealer value 19\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (12, 10, False)\n", "init (16, 8, True)\n", "player value 26 | dealer value 21\n", "init (10, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 2, False)\n", "player value 22 | dealer value 20\n", "init (10, 4, False)\n", "player value 20 | dealer value 22\n", "init (16, 10, False)\n", "player value 23 | dealer value 20\n", "init (7, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 7, False)\n", "player value 20 | dealer value 17\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (20, 1, False)\n", "init (20, 1, True)\n", "init (12, 2, False)\n", "player value 29 | dealer value 18\n", "init (15, 4, False)\n", "player value 24 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (21, 3, True)\n", "init (21, 2, True)\n", "init (18, 10, False)\n", "init (4, 2, False)\n", "player value 17 | dealer value 19\n", "init (15, 7, True)\n", "player value 21 | dealer value 18\n", "init (19, 6, False)\n", "player value 19 | dealer value 25\n", "init (20, 6, False)\n", "player value 20 | dealer value 23\n", "init (14, 10, False)\n", "player value 24 | dealer value 25\n", "init (10, 4, False)\n", "player value 22 | dealer value 21\n", "init (14, 6, False)\n", "player value 14 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 18\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (15, 10, False)\n", "player value 22 | dealer value 18\n", "init (15, 4, True)\n", "player value 23 | dealer value 25\n", "init (9, 2, False)\n", "player value 19 | dealer value 23\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (12, 5, False)\n", "player value 12 | dealer value 23\n", "init (12, 2, False)\n", "player value 17 | dealer value 25\n", "init (16, 10, False)\n", "player value 26 | dealer value 23\n", "init (19, 8, True)\n", "player value 19 | dealer value 17\n", "init (11, 10, False)\n", "player value 25 | dealer value 17\n", "init (15, 7, False)\n", "player value 24 | dealer value 22\n", "init (19, 10, False)\n", "init (16, 10, False)\n", "player value 27 | dealer value 19\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 4, False)\n", "player value 25 | dealer value 19\n", "init (11, 3, False)\n", "player value 21 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 22\n", "init (12, 9, False)\n", "player value 12 | dealer value 18\n", "init (19, 4, True)\n", "player value 19 | dealer value 24\n", "init (7, 10, False)\n", "player value 27 | dealer value 18\n", "init (13, 9, False)\n", "player value 23 | dealer value 18\n", "init (4, 3, False)\n", "player value 20 | dealer value 17\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (9, 10, False)\n", "player value 29 | dealer value 18\n", "init (9, 10, False)\n", "init (18, 1, False)\n", "init (7, 1, False)\n", "init (18, 10, False)\n", "player value 23 | dealer value 19\n", "init (11, 9, False)\n", "player value 23 | dealer value 18\n", "init (12, 9, False)\n", "player value 23 | dealer value 19\n", "init (14, 10, False)\n", "player value 24 | dealer value 24\n", "init (21, 1, True)\n", "init (18, 4, False)\n", "player value 18 | dealer value 23\n", "init (12, 3, False)\n", "player value 20 | dealer value 18\n", "init (20, 7, True)\n", "player value 20 | dealer value 17\n", "init (8, 2, False)\n", "player value 22 | dealer value 18\n", "init (12, 10, False)\n", "player value 20 | dealer value 26\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 24\n", "init (19, 8, False)\n", "player value 19 | dealer value 17\n", "init (18, 2, True)\n", "player value 18 | dealer value 17\n", "init (14, 1, False)\n", "player value 23 | dealer value 21\n", "init (15, 10, False)\n", "player value 22 | dealer value 20\n", "init (13, 10, False)\n", "player value 27 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 17\n", "init (18, 9, False)\n", "player value 26 | dealer value 23\n", "init (14, 10, True)\n", "player value 15 | dealer value 25\n", "init (15, 6, False)\n", "player value 24 | dealer value 17\n", "init (14, 7, True)\n", "player value 21 | dealer value 22\n", "init (16, 6, True)\n", "player value 16 | dealer value 25\n", "init (12, 5, False)\n", "player value 12 | dealer value 17\n", "init (10, 4, False)\n", "player value 20 | dealer value 20\n", "init (19, 1, False)\n", "init (12, 10, False)\n", "player value 26 | dealer value 20\n", "init (12, 10, False)\n", "player value 21 | dealer value 26\n", "init (13, 10, False)\n", "player value 21 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (14, 5, True)\n", "player value 18 | dealer value 18\n", "init (12, 10, False)\n", "player value 25 | dealer value 23\n", "init (12, 9, False)\n", "player value 21 | dealer value 20\n", "init (21, 5, True)\n", "init (16, 8, False)\n", "player value 16 | dealer value 17\n", "init (12, 3, False)\n", "player value 22 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 19 | dealer value 19\n", "init (13, 10, False)\n", "player value 22 | dealer value 17\n", "init (12, 3, False)\n", "player value 22 | dealer value 23\n", "init (8, 4, False)\n", "player value 19 | dealer value 19\n", "init (14, 2, False)\n", "player value 24 | dealer value 22\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (6, 4, False)\n", "player value 16 | dealer value 24\n", "init (15, 10, True)\n", "player value 15 | dealer value 17\n", "init (18, 10, False)\n", "init (15, 7, False)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 28 | dealer value 18\n", "init (12, 9, False)\n", "player value 22 | dealer value 17\n", "init (12, 3, False)\n", "player value 23 | dealer value 21\n", "init (18, 5, False)\n", "player value 18 | dealer value 19\n", "init (16, 7, False)\n", "player value 22 | dealer value 19\n", "init (11, 5, False)\n", "player value 28 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 19\n", "init (17, 8, True)\n", "player value 17 | dealer value 23\n", "init (13, 10, False)\n", "player value 27 | dealer value 20\n", "init (14, 9, False)\n", "player value 27 | dealer value 23\n", "init (21, 1, True)\n", "init (13, 1, False)\n", "player value 13 | dealer value 20\n", "init (21, 9, True)\n", "init (17, 8, False)\n", "player value 27 | dealer value 18\n", "init (5, 2, False)\n", "player value 22 | dealer value 24\n", "init (13, 9, False)\n", "player value 21 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 24\n", "init (15, 10, False)\n", "player value 24 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 17\n", "init (11, 1, False)\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (11, 5, False)\n", "player value 21 | dealer value 22\n", "init (15, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 4, False)\n", "player value 19 | dealer value 26\n", "init (12, 3, False)\n", "player value 12 | dealer value 20\n", "init (20, 7, False)\n", "player value 23 | dealer value 17\n", "init (18, 10, False)\n", "player value 28 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 19\n", "init (15, 10, False)\n", "player value 19 | dealer value 18\n", "init (21, 10, True)\n", "init (15, 1, False)\n", "player value 25 | dealer value 17\n", "init (11, 9, False)\n", "player value 21 | dealer value 23\n", "init (15, 5, False)\n", "player value 15 | dealer value 20\n", "init (16, 7, False)\n", "player value 26 | dealer value 23\n", "init (9, 10, False)\n", "player value 19 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (13, 4, False)\n", "player value 20 | dealer value 22\n", "init (13, 5, False)\n", "player value 18 | dealer value 22\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (15, 9, False)\n", "player value 25 | dealer value 19\n", "init (13, 4, False)\n", "player value 13 | dealer value 23\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 1, False)\n", "init (12, 4, True)\n", "player value 20 | dealer value 21\n", "init (18, 10, False)\n", "player value 26 | dealer value 19\n", "init (19, 2, False)\n", "player value 19 | dealer value 22\n", "init (16, 10, False)\n", "player value 26 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (21, 2, True)\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (13, 1, False)\n", "player value 22 | dealer value 20\n", "init (9, 5, False)\n", "player value 29 | dealer value 21\n", "init (18, 10, False)\n", "player value 23 | dealer value 20\n", "init (12, 2, False)\n", "player value 18 | dealer value 18\n", "init (13, 5, True)\n", "player value 13 | dealer value 24\n", "init (12, 3, False)\n", "player value 22 | dealer value 21\n", "init (7, 10, False)\n", "player value 24 | dealer value 17\n", "init (11, 5, False)\n", "player value 26 | dealer value 25\n", "init (13, 3, False)\n", "player value 23 | dealer value 19\n", "init (12, 10, False)\n", "player value 27 | dealer value 18\n", "init (7, 10, False)\n", "player value 25 | dealer value 17\n", "init (7, 5, False)\n", "player value 27 | dealer value 17\n", "init (19, 7, False)\n", "player value 29 | dealer value 21\n", "init (13, 4, True)\n", "player value 18 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 17\n", "init (6, 1, False)\n", "player value 12 | dealer value 20\n", "init (8, 3, False)\n", "player value 19 | dealer value 18\n", "init (11, 9, False)\n", "player value 21 | dealer value 24\n", "init (13, 9, False)\n", "player value 13 | dealer value 18\n", "init (12, 1, False)\n", "init (18, 10, False)\n", "player value 21 | dealer value 18\n", "init (17, 4, False)\n", "player value 27 | dealer value 19\n", "init (14, 9, False)\n", "player value 21 | dealer value 18\n", "init (8, 1, False)\n", "player value 26 | dealer value 24\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (20, 8, True)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 24\n", "init (15, 1, False)\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (10, 10, False)\n", "player value 19 | dealer value 19\n", "init (9, 6, False)\n", "player value 20 | dealer value 23\n", "init (21, 2, True)\n", "init (17, 7, False)\n", "player value 17 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 24\n", "init (15, 9, False)\n", "player value 25 | dealer value 19\n", "init (17, 5, False)\n", "player value 27 | dealer value 19\n", "init (16, 10, False)\n", "player value 22 | dealer value 19\n", "init (16, 4, False)\n", "player value 17 | dealer value 18\n", "init (9, 5, False)\n", "player value 20 | dealer value 23\n", "init (13, 3, False)\n", "player value 21 | dealer value 20\n", "init (16, 10, False)\n", "player value 16 | dealer value 25\n", "init (11, 6, False)\n", "player value 30 | dealer value 21\n", "init (15, 1, False)\n", "player value 15 | dealer value 22\n", "init (9, 5, False)\n", "player value 19 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 19\n", "init (17, 10, False)\n", "player value 26 | dealer value 20\n", "init (8, 7, False)\n", "player value 18 | dealer value 18\n", "init (14, 1, False)\n", "player value 24 | dealer value 18\n", "init (21, 1, True)\n", "init (14, 4, False)\n", "player value 16 | dealer value 24\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (9, 10, False)\n", "player value 22 | dealer value 23\n", "init (14, 3, False)\n", "player value 14 | dealer value 24\n", "init (12, 7, False)\n", "player value 24 | dealer value 17\n", "init (13, 8, False)\n", "player value 21 | dealer value 18\n", "init (21, 10, True)\n", "init (21, 3, True)\n", "init (19, 3, False)\n", "player value 19 | dealer value 19\n", "init (21, 1, True)\n", "init (18, 6, False)\n", "player value 18 | dealer value 20\n", "init (16, 10, False)\n", "init (17, 2, False)\n", "player value 17 | dealer value 22\n", "init (16, 5, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 1, False)\n", "player value 25 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 2, False)\n", "player value 16 | dealer value 17\n", "init (16, 5, False)\n", "player value 26 | dealer value 17\n", "init (11, 2, False)\n", "player value 22 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (21, 4, True)\n", "init (17, 4, False)\n", "player value 20 | dealer value 19\n", "init (17, 5, False)\n", "player value 23 | dealer value 25\n", "init (16, 10, False)\n", "player value 16 | dealer value 24\n", "init (21, 3, True)\n", "init (15, 10, False)\n", "player value 22 | dealer value 22\n", "init (21, 10, True)\n", "init (19, 10, False)\n", "player value 19 | dealer value 26\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (15, 9, False)\n", "player value 25 | dealer value 23\n", "init (14, 1, False)\n", "player value 14 | dealer value 18\n", "init (8, 4, False)\n", "player value 20 | dealer value 21\n", "init (14, 2, True)\n", "player value 21 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 8, False)\n", "player value 18 | dealer value 17\n", "init (17, 1, False)\n", "init (20, 10, True)\n", "player value 20 | dealer value 19\n", "init (21, 6, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (17, 10, False)\n", "init (11, 7, False)\n", "player value 20 | dealer value 18\n", "init (5, 10, False)\n", "player value 26 | dealer value 17\n", "init (7, 6, False)\n", "player value 17 | dealer value 21\n", "init (17, 2, False)\n", "player value 17 | dealer value 21\n", "init (13, 7, False)\n", "player value 21 | dealer value 25\n", "init (12, 1, False)\n", "init (20, 2, False)\n", "player value 20 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 4, False)\n", "player value 25 | dealer value 18\n", "init (12, 4, False)\n", "player value 21 | dealer value 24\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (13, 5, False)\n", "player value 27 | dealer value 23\n", "init (7, 10, False)\n", "player value 17 | dealer value 18\n", "init (15, 7, False)\n", "player value 17 | dealer value 18\n", "init (16, 10, True)\n", "player value 16 | dealer value 20\n", "init (20, 9, False)\n", "player value 28 | dealer value 18\n", "init (14, 3, False)\n", "player value 14 | dealer value 20\n", "init (12, 8, False)\n", "player value 20 | dealer value 17\n", "init (15, 1, False)\n", "player value 15 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (8, 10, False)\n", "player value 21 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (21, 10, True)\n", "init (14, 4, False)\n", "player value 24 | dealer value 26\n", "init (21, 2, True)\n", "init (16, 10, False)\n", "player value 16 | dealer value 22\n", "init (12, 4, False)\n", "player value 31 | dealer value 23\n", "init (5, 10, False)\n", "player value 20 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (12, 8, False)\n", "player value 22 | dealer value 20\n", "init (15, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 3, False)\n", "player value 14 | dealer value 22\n", "init (12, 2, False)\n", "player value 22 | dealer value 21\n", "init (12, 10, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (21, 10, True)\n", "init (17, 5, False)\n", "player value 27 | dealer value 18\n", "init (11, 4, False)\n", "player value 23 | dealer value 17\n", "init (19, 10, True)\n", "player value 21 | dealer value 20\n", "init (21, 5, True)\n", "init (10, 10, False)\n", "player value 22 | dealer value 19\n", "init (21, 3, True)\n", "init (16, 10, True)\n", "player value 16 | dealer value 20\n", "init (16, 8, False)\n", "player value 23 | dealer value 18\n", "init (13, 9, False)\n", "player value 18 | dealer value 23\n", "init (12, 7, False)\n", "player value 20 | dealer value 20\n", "init (17, 8, False)\n", "player value 23 | dealer value 17\n", "init (15, 2, False)\n", "player value 26 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (8, 2, False)\n", "player value 19 | dealer value 21\n", "init (18, 2, True)\n", "player value 18 | dealer value 24\n", "init (19, 6, True)\n", "player value 18 | dealer value 17\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (6, 4, False)\n", "player value 16 | dealer value 18\n", "init (15, 7, True)\n", "player value 19 | dealer value 19\n", "init (13, 3, False)\n", "player value 23 | dealer value 18\n", "init (10, 1, False)\n", "init (11, 6, False)\n", "player value 20 | dealer value 18\n", "init (21, 4, True)\n", "round 7000\n", "init (17, 1, True)\n", "player value 19 | dealer value 19\n", "init (19, 2, False)\n", "player value 19 | dealer value 20\n", "init (17, 10, False)\n", "player value 20 | dealer value 24\n", "init (19, 1, False)\n", "init (9, 5, False)\n", "player value 18 | dealer value 23\n", "init (16, 10, False)\n", "player value 26 | dealer value 17\n", "init (13, 3, False)\n", "player value 16 | dealer value 22\n", "init (9, 8, False)\n", "player value 19 | dealer value 26\n", "init (6, 1, False)\n", "init (13, 10, False)\n", "player value 30 | dealer value 23\n", "init (11, 10, False)\n", "player value 21 | dealer value 21\n", "init (7, 10, False)\n", "init (18, 10, False)\n", "player value 19 | dealer value 23\n", "init (9, 3, False)\n", "player value 14 | dealer value 17\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (16, 6, False)\n", "player value 16 | dealer value 26\n", "init (21, 9, True)\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (15, 5, False)\n", "player value 15 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (11, 1, False)\n", "init (14, 10, False)\n", "player value 28 | dealer value 18\n", "init (21, 9, True)\n", "init (10, 5, False)\n", "player value 21 | dealer value 20\n", "init (18, 10, False)\n", "player value 28 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (13, 8, False)\n", "player value 19 | dealer value 21\n", "init (18, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 10, True)\n", "player value 21 | dealer value 20\n", "init (15, 3, False)\n", "player value 27 | dealer value 21\n", "init (18, 10, False)\n", "player value 28 | dealer value 19\n", "init (16, 7, False)\n", "player value 25 | dealer value 17\n", "init (15, 10, True)\n", "player value 15 | dealer value 19\n", "init (12, 2, False)\n", "player value 22 | dealer value 26\n", "init (6, 4, False)\n", "player value 19 | dealer value 19\n", "init (13, 3, False)\n", "player value 18 | dealer value 23\n", "init (8, 2, False)\n", "player value 17 | dealer value 22\n", "init (13, 10, True)\n", "player value 20 | dealer value 18\n", "init (16, 1, False)\n", "player value 26 | dealer value 23\n", "init (12, 2, False)\n", "player value 18 | dealer value 17\n", "init (13, 5, False)\n", "player value 16 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 6, False)\n", "player value 16 | dealer value 17\n", "init (21, 6, True)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (7, 5, False)\n", "player value 27 | dealer value 22\n", "init (15, 5, False)\n", "player value 15 | dealer value 23\n", "init (13, 1, False)\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (17, 5, False)\n", "player value 27 | dealer value 23\n", "init (13, 9, False)\n", "player value 17 | dealer value 18\n", "init (15, 1, False)\n", "player value 15 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 1, False)\n", "player value 12 | dealer value 17\n", "init (11, 3, False)\n", "player value 21 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (13, 8, False)\n", "player value 23 | dealer value 18\n", "init (7, 8, False)\n", "player value 27 | dealer value 18\n", "init (21, 7, True)\n", "init (10, 10, False)\n", "player value 20 | dealer value 25\n", "init (14, 7, False)\n", "player value 24 | dealer value 20\n", "init (4, 1, False)\n", "player value 14 | dealer value 18\n", "init (9, 8, False)\n", "player value 19 | dealer value 18\n", "init (18, 3, True)\n", "player value 18 | dealer value 18\n", "init (16, 9, False)\n", "player value 19 | dealer value 19\n", "init (6, 2, False)\n", "player value 29 | dealer value 17\n", "init (21, 10, True)\n", "init (8, 10, False)\n", "player value 24 | dealer value 23\n", "init (14, 9, True)\n", "player value 21 | dealer value 25\n", "init (12, 10, False)\n", "init (9, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (20, 6, True)\n", "player value 20 | dealer value 17\n", "init (8, 9, False)\n", "player value 25 | dealer value 17\n", "init (11, 6, False)\n", "player value 21 | dealer value 23\n", "init (4, 10, False)\n", "player value 22 | dealer value 26\n", "init (21, 10, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 20\n", "init (13, 10, False)\n", "player value 28 | dealer value 20\n", "init (6, 6, False)\n", "player value 27 | dealer value 18\n", "init (11, 4, False)\n", "player value 20 | dealer value 17\n", "init (13, 7, False)\n", "player value 18 | dealer value 25\n", "init (16, 1, False)\n", "player value 26 | dealer value 23\n", "init (17, 2, False)\n", "player value 17 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (15, 4, False)\n", "player value 24 | dealer value 19\n", "init (8, 5, False)\n", "player value 29 | dealer value 18\n", "init (13, 10, False)\n", "player value 27 | dealer value 25\n", "init (15, 6, False)\n", "player value 19 | dealer value 18\n", "init (19, 9, False)\n", "player value 19 | dealer value 23\n", "init (21, 10, True)\n", "init (12, 8, False)\n", "player value 26 | dealer value 18\n", "init (12, 2, False)\n", "player value 18 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (12, 6, False)\n", "player value 12 | dealer value 20\n", "init (12, 7, False)\n", "player value 17 | dealer value 19\n", "init (12, 7, False)\n", "player value 22 | dealer value 17\n", "init (17, 9, False)\n", "player value 24 | dealer value 19\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (12, 1, False)\n", "player value 24 | dealer value 20\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (14, 8, False)\n", "player value 21 | dealer value 21\n", "init (15, 10, True)\n", "player value 12 | dealer value 24\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (19, 6, False)\n", "player value 19 | dealer value 23\n", "init (16, 10, False)\n", "player value 19 | dealer value 19\n", "init (11, 5, False)\n", "player value 15 | dealer value 17\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 5, False)\n", "player value 12 | dealer value 21\n", "init (9, 10, False)\n", "player value 29 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 18\n", "init (18, 6, True)\n", "player value 18 | dealer value 22\n", "init (16, 7, False)\n", "player value 21 | dealer value 19\n", "init (10, 6, False)\n", "player value 20 | dealer value 20\n", "init (21, 10, True)\n", "init (6, 3, False)\n", "player value 21 | dealer value 22\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (16, 7, False)\n", "player value 25 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (16, 1, False)\n", "init (19, 10, False)\n", "player value 29 | dealer value 18\n", "init (18, 10, False)\n", "player value 26 | dealer value 17\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (17, 3, False)\n", "player value 21 | dealer value 18\n", "init (16, 6, False)\n", "player value 16 | dealer value 19\n", "init (18, 10, False)\n", "player value 28 | dealer value 20\n", "init (21, 10, True)\n", "init (15, 1, False)\n", "player value 15 | dealer value 17\n", "init (18, 7, True)\n", "player value 18 | dealer value 17\n", "init (17, 2, True)\n", "player value 17 | dealer value 17\n", "init (13, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 7, False)\n", "player value 23 | dealer value 17\n", "init (20, 8, False)\n", "player value 20 | dealer value 25\n", "init (15, 4, True)\n", "player value 23 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (7, 5, False)\n", "player value 15 | dealer value 20\n", "init (15, 1, False)\n", "init (6, 10, False)\n", "player value 25 | dealer value 20\n", "init (14, 2, False)\n", "player value 24 | dealer value 18\n", "init (16, 3, False)\n", "player value 16 | dealer value 19\n", "init (10, 10, False)\n", "player value 18 | dealer value 18\n", "init (9, 10, False)\n", "player value 21 | dealer value 24\n", "init (14, 5, False)\n", "player value 23 | dealer value 23\n", "init (12, 6, True)\n", "player value 21 | dealer value 17\n", "init (11, 7, False)\n", "player value 22 | dealer value 17\n", "init (12, 10, False)\n", "player value 18 | dealer value 26\n", "init (13, 3, False)\n", "player value 23 | dealer value 18\n", "init (14, 6, False)\n", "player value 14 | dealer value 19\n", "init (12, 3, False)\n", "player value 19 | dealer value 21\n", "init (20, 10, False)\n", "init (16, 9, False)\n", "player value 22 | dealer value 18\n", "init (18, 6, False)\n", "player value 18 | dealer value 20\n", "init (13, 8, False)\n", "player value 16 | dealer value 22\n", "init (16, 5, False)\n", "player value 16 | dealer value 23\n", "init (6, 10, False)\n", "player value 15 | dealer value 20\n", "init (17, 9, False)\n", "player value 25 | dealer value 18\n", "init (21, 4, True)\n", "init (14, 10, False)\n", "player value 24 | dealer value 21\n", "init (8, 7, False)\n", "player value 22 | dealer value 17\n", "init (16, 2, False)\n", "player value 19 | dealer value 19\n", "init (19, 5, False)\n", "player value 19 | dealer value 18\n", "init (20, 8, True)\n", "player value 20 | dealer value 19\n", "init (13, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "init (13, 6, False)\n", "player value 13 | dealer value 25\n", "init (4, 10, False)\n", "player value 22 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (14, 10, False)\n", "player value 20 | dealer value 18\n", "init (16, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (11, 9, False)\n", "player value 20 | dealer value 19\n", "init (15, 5, False)\n", "player value 15 | dealer value 21\n", "init (15, 6, False)\n", "player value 25 | dealer value 17\n", "init (13, 10, False)\n", "player value 20 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 24\n", "init (17, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 9, False)\n", "player value 18 | dealer value 26\n", "init (7, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 3, False)\n", "player value 25 | dealer value 19\n", "init (13, 5, False)\n", "player value 16 | dealer value 22\n", "init (12, 3, False)\n", "player value 14 | dealer value 20\n", "init (12, 4, False)\n", "player value 23 | dealer value 22\n", "init (13, 4, False)\n", "player value 20 | dealer value 21\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (4, 2, False)\n", "player value 12 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (10, 10, False)\n", "player value 22 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (16, 4, False)\n", "player value 16 | dealer value 25\n", "init (13, 1, False)\n", "player value 13 | dealer value 21\n", "init (17, 8, False)\n", "player value 18 | dealer value 20\n", "init (13, 8, False)\n", "player value 13 | dealer value 19\n", "init (11, 7, False)\n", "player value 25 | dealer value 19\n", "init (13, 6, True)\n", "player value 13 | dealer value 24\n", "init (9, 10, False)\n", "player value 19 | dealer value 23\n", "init (14, 7, False)\n", "player value 30 | dealer value 17\n", "init (9, 10, False)\n", "player value 14 | dealer value 22\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (6, 10, False)\n", "player value 26 | dealer value 20\n", "init (10, 9, False)\n", "player value 19 | dealer value 19\n", "init (12, 10, False)\n", "player value 21 | dealer value 17\n", "init (15, 6, False)\n", "player value 18 | dealer value 26\n", "init (12, 2, True)\n", "player value 18 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 25\n", "init (13, 10, False)\n", "player value 21 | dealer value 19\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (14, 4, False)\n", "player value 14 | dealer value 25\n", "init (20, 10, False)\n", "player value 30 | dealer value 18\n", "init (13, 10, False)\n", "player value 14 | dealer value 18\n", "init (4, 7, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (16, 1, False)\n", "init (10, 5, False)\n", "player value 20 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 25\n", "init (12, 10, False)\n", "player value 27 | dealer value 26\n", "init (14, 6, False)\n", "player value 14 | dealer value 19\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 2, False)\n", "player value 24 | dealer value 25\n", "init (21, 3, True)\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (17, 5, False)\n", "player value 27 | dealer value 20\n", "init (15, 6, False)\n", "player value 21 | dealer value 17\n", "init (14, 8, False)\n", "player value 24 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (11, 5, False)\n", "player value 16 | dealer value 18\n", "init (12, 7, False)\n", "player value 18 | dealer value 17\n", "init (15, 2, False)\n", "player value 25 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (17, 10, True)\n", "player value 14 | dealer value 17\n", "init (7, 3, False)\n", "player value 22 | dealer value 26\n", "init (11, 10, False)\n", "player value 18 | dealer value 25\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (10, 5, False)\n", "player value 12 | dealer value 23\n", "init (19, 6, False)\n", "player value 19 | dealer value 26\n", "init (17, 10, False)\n", "init (18, 8, True)\n", "player value 16 | dealer value 20\n", "init (16, 10, False)\n", "player value 20 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 3, False)\n", "player value 19 | dealer value 19\n", "init (13, 10, False)\n", "player value 22 | dealer value 19\n", "init (13, 3, False)\n", "player value 21 | dealer value 22\n", "init (6, 10, False)\n", "init (12, 8, False)\n", "player value 16 | dealer value 17\n", "init (15, 7, False)\n", "player value 15 | dealer value 19\n", "init (10, 10, False)\n", "player value 27 | dealer value 17\n", "init (16, 6, True)\n", "player value 16 | dealer value 20\n", "init (8, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 5, True)\n", "player value 12 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 23\n", "init (17, 10, False)\n", "player value 20 | dealer value 19\n", "init (12, 10, False)\n", "player value 18 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (18, 2, False)\n", "player value 18 | dealer value 22\n", "init (13, 7, False)\n", "player value 23 | dealer value 23\n", "init (12, 9, False)\n", "player value 18 | dealer value 19\n", "init (16, 10, False)\n", "player value 24 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (14, 4, False)\n", "player value 23 | dealer value 23\n", "init (6, 10, False)\n", "player value 29 | dealer value 18\n", "init (13, 10, False)\n", "player value 14 | dealer value 18\n", "init (14, 2, False)\n", "player value 23 | dealer value 23\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (19, 8, True)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "player value 23 | dealer value 19\n", "init (17, 10, True)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (13, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 3, False)\n", "player value 16 | dealer value 25\n", "init (16, 1, False)\n", "init (12, 6, True)\n", "player value 21 | dealer value 20\n", "init (19, 4, True)\n", "player value 19 | dealer value 24\n", "init (8, 3, False)\n", "player value 18 | dealer value 22\n", "init (18, 10, True)\n", "init (11, 4, False)\n", "player value 21 | dealer value 18\n", "init (12, 8, False)\n", "player value 20 | dealer value 17\n", "init (17, 4, False)\n", "player value 27 | dealer value 22\n", "init (19, 4, True)\n", "player value 19 | dealer value 18\n", "init (14, 9, True)\n", "player value 18 | dealer value 20\n", "init (19, 9, False)\n", "player value 22 | dealer value 18\n", "init (11, 9, False)\n", "player value 30 | dealer value 19\n", "init (7, 10, False)\n", "player value 27 | dealer value 22\n", "init (20, 2, True)\n", "player value 21 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (19, 6, True)\n", "player value 19 | dealer value 22\n", "init (14, 8, False)\n", "player value 28 | dealer value 20\n", "init (13, 1, False)\n", "init (14, 10, False)\n", "player value 19 | dealer value 23\n", "init (12, 7, False)\n", "player value 20 | dealer value 17\n", "init (9, 10, False)\n", "player value 22 | dealer value 20\n", "init (16, 4, False)\n", "player value 26 | dealer value 17\n", "init (15, 6, True)\n", "player value 12 | dealer value 25\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (16, 4, False)\n", "player value 16 | dealer value 20\n", "init (11, 3, False)\n", "player value 19 | dealer value 25\n", "init (16, 8, False)\n", "player value 16 | dealer value 17\n", "init (15, 5, False)\n", "player value 19 | dealer value 18\n", "init (20, 4, False)\n", "player value 20 | dealer value 21\n", "init (18, 7, False)\n", "player value 18 | dealer value 23\n", "init (15, 9, False)\n", "player value 23 | dealer value 22\n", "init (15, 1, False)\n", "player value 25 | dealer value 23\n", "init (12, 7, False)\n", "player value 17 | dealer value 17\n", "init (12, 9, False)\n", "player value 25 | dealer value 20\n", "init (12, 8, False)\n", "player value 21 | dealer value 18\n", "init (13, 10, True)\n", "player value 19 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (13, 1, False)\n", "player value 14 | dealer value 21\n", "init (16, 10, False)\n", "player value 26 | dealer value 22\n", "init (21, 4, True)\n", "init (12, 8, False)\n", "player value 12 | dealer value 18\n", "init (20, 10, False)\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (19, 8, False)\n", "player value 31 | dealer value 18\n", "init (8, 3, False)\n", "player value 18 | dealer value 22\n", "init (10, 5, False)\n", "player value 20 | dealer value 25\n", "init (13, 10, False)\n", "player value 20 | dealer value 25\n", "init (18, 7, False)\n", "player value 18 | dealer value 22\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (13, 7, False)\n", "player value 23 | dealer value 18\n", "init (6, 2, False)\n", "player value 21 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (21, 5, True)\n", "init (16, 8, False)\n", "player value 20 | dealer value 19\n", "init (13, 8, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (11, 8, False)\n", "player value 21 | dealer value 19\n", "init (15, 10, False)\n", "player value 24 | dealer value 20\n", "init (20, 9, True)\n", "player value 20 | dealer value 22\n", "init (18, 4, False)\n", "player value 18 | dealer value 18\n", "init (8, 10, False)\n", "player value 25 | dealer value 20\n", "init (14, 7, False)\n", "player value 24 | dealer value 17\n", "init (15, 5, False)\n", "player value 15 | dealer value 24\n", "init (20, 8, False)\n", "player value 20 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 24\n", "init (20, 3, True)\n", "player value 20 | dealer value 22\n", "init (16, 7, False)\n", "player value 21 | dealer value 17\n", "init (13, 2, True)\n", "player value 16 | dealer value 24\n", "init (19, 4, True)\n", "player value 19 | dealer value 24\n", "init (13, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 1, False)\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (10, 6, False)\n", "player value 20 | dealer value 18\n", "init (16, 8, False)\n", "player value 16 | dealer value 21\n", "init (4, 7, False)\n", "player value 14 | dealer value 23\n", "init (19, 3, False)\n", "player value 19 | dealer value 20\n", "init (18, 10, False)\n", "player value 29 | dealer value 20\n", "init (15, 1, False)\n", "player value 17 | dealer value 22\n", "init (20, 5, False)\n", "player value 20 | dealer value 23\n", "init (10, 10, False)\n", "player value 23 | dealer value 20\n", "init (17, 8, False)\n", "player value 21 | dealer value 23\n", "init (13, 3, False)\n", "player value 19 | dealer value 21\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 5, False)\n", "player value 23 | dealer value 18\n", "init (20, 1, False)\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (12, 2, False)\n", "player value 25 | dealer value 19\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 6, True)\n", "player value 18 | dealer value 17\n", "init (19, 2, True)\n", "player value 19 | dealer value 19\n", "init (11, 10, False)\n", "player value 21 | dealer value 26\n", "init (16, 9, False)\n", "player value 18 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 20\n", "init (14, 1, False)\n", "player value 19 | dealer value 20\n", "init (16, 1, False)\n", "player value 26 | dealer value 17\n", "init (9, 4, False)\n", "player value 24 | dealer value 22\n", "init (15, 1, False)\n", "player value 25 | dealer value 17\n", "init (21, 10, True)\n", "init (11, 10, False)\n", "player value 20 | dealer value 20\n", "init (8, 6, False)\n", "player value 17 | dealer value 24\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (12, 2, False)\n", "player value 19 | dealer value 20\n", "init (16, 8, False)\n", "player value 20 | dealer value 22\n", "init (19, 10, False)\n", "player value 19 | dealer value 21\n", "init (11, 4, False)\n", "player value 19 | dealer value 17\n", "init (17, 7, False)\n", "player value 17 | dealer value 23\n", "init (15, 8, False)\n", "player value 25 | dealer value 17\n", "init (8, 10, False)\n", "init (6, 2, False)\n", "player value 20 | dealer value 24\n", "init (8, 1, False)\n", "player value 18 | dealer value 17\n", "init (12, 3, False)\n", "player value 19 | dealer value 21\n", "init (14, 9, True)\n", "player value 14 | dealer value 19\n", "init (8, 6, False)\n", "player value 18 | dealer value 18\n", "init (8, 9, False)\n", "player value 22 | dealer value 24\n", "init (15, 5, False)\n", "player value 24 | dealer value 19\n", "init (14, 10, False)\n", "player value 23 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (12, 8, False)\n", "player value 22 | dealer value 23\n", "init (12, 10, False)\n", "player value 12 | dealer value 24\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (11, 1, False)\n", "player value 19 | dealer value 17\n", "init (15, 1, False)\n", "player value 23 | dealer value 22\n", "init (17, 9, False)\n", "player value 27 | dealer value 19\n", "init (9, 5, False)\n", "player value 28 | dealer value 18\n", "init (19, 4, False)\n", "player value 19 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 5, False)\n", "player value 23 | dealer value 17\n", "init (13, 4, False)\n", "player value 19 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (15, 10, False)\n", "player value 15 | dealer value 26\n", "init (17, 9, False)\n", "player value 27 | dealer value 22\n", "init (20, 10, True)\n", "player value 20 | dealer value 25\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (14, 10, True)\n", "player value 21 | dealer value 20\n", "init (13, 2, True)\n", "player value 24 | dealer value 25\n", "init (20, 8, True)\n", "player value 20 | dealer value 21\n", "init (13, 6, False)\n", "player value 23 | dealer value 22\n", "init (21, 7, True)\n", "init (16, 2, False)\n", "player value 19 | dealer value 18\n", "init (12, 6, False)\n", "player value 12 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 17\n", "init (14, 6, True)\n", "player value 18 | dealer value 18\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (14, 8, False)\n", "player value 22 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (18, 8, False)\n", "player value 28 | dealer value 18\n", "init (12, 8, False)\n", "player value 25 | dealer value 19\n", "init (9, 7, False)\n", "player value 24 | dealer value 23\n", "init (16, 2, False)\n", "player value 22 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (18, 8, False)\n", "player value 18 | dealer value 19\n", "init (21, 10, True)\n", "init (20, 9, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 2, True)\n", "player value 20 | dealer value 21\n", "init (20, 2, False)\n", "player value 20 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (21, 10, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (5, 10, False)\n", "player value 26 | dealer value 22\n", "init (20, 8, False)\n", "player value 20 | dealer value 24\n", "init (13, 8, False)\n", "player value 20 | dealer value 18\n", "init (20, 1, True)\n", "init (16, 10, False)\n", "player value 19 | dealer value 19\n", "init (16, 8, False)\n", "player value 26 | dealer value 22\n", "init (16, 10, False)\n", "player value 25 | dealer value 17\n", "init (16, 7, False)\n", "player value 26 | dealer value 19\n", "init (8, 5, False)\n", "player value 18 | dealer value 25\n", "init (19, 10, True)\n", "player value 12 | dealer value 20\n", "init (9, 7, False)\n", "player value 22 | dealer value 20\n", "init (12, 2, False)\n", "player value 12 | dealer value 17\n", "init (19, 6, False)\n", "player value 26 | dealer value 18\n", "init (10, 6, False)\n", "player value 17 | dealer value 19\n", "init (14, 10, False)\n", "player value 22 | dealer value 21\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (10, 10, False)\n", "player value 22 | dealer value 20\n", "init (10, 4, False)\n", "player value 25 | dealer value 20\n", "init (20, 1, True)\n", "player value 25 | dealer value 20\n", "init (13, 7, False)\n", "player value 22 | dealer value 18\n", "init (15, 7, False)\n", "player value 25 | dealer value 17\n", "init (17, 3, False)\n", "player value 27 | dealer value 20\n", "init (17, 3, False)\n", "player value 27 | dealer value 17\n", "init (17, 8, False)\n", "player value 25 | dealer value 18\n", "init (14, 9, False)\n", "player value 16 | dealer value 19\n", "init (19, 10, True)\n", "player value 19 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (10, 6, False)\n", "player value 21 | dealer value 23\n", "init (9, 7, False)\n", "player value 14 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (11, 10, False)\n", "player value 20 | dealer value 24\n", "init (11, 8, False)\n", "player value 14 | dealer value 20\n", "init (21, 8, True)\n", "init (13, 10, False)\n", "player value 15 | dealer value 25\n", "init (11, 1, False)\n", "player value 18 | dealer value 19\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (10, 8, False)\n", "player value 20 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 17\n", "init (6, 10, False)\n", "init (17, 1, False)\n", "init (21, 10, True)\n", "init (13, 1, False)\n", "player value 22 | dealer value 19\n", "init (20, 9, False)\n", "player value 22 | dealer value 19\n", "init (9, 9, False)\n", "player value 17 | dealer value 17\n", "init (15, 2, False)\n", "player value 25 | dealer value 17\n", "init (16, 10, True)\n", "player value 18 | dealer value 20\n", "init (17, 7, True)\n", "player value 17 | dealer value 17\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (11, 10, False)\n", "player value 20 | dealer value 19\n", "init (21, 10, True)\n", "init (15, 4, False)\n", "player value 15 | dealer value 23\n", "init (12, 2, True)\n", "player value 19 | dealer value 21\n", "init (11, 7, False)\n", "player value 20 | dealer value 26\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (21, 10, True)\n", "init (10, 1, False)\n", "player value 24 | dealer value 19\n", "init (14, 4, True)\n", "player value 22 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 26\n", "init (9, 10, False)\n", "player value 21 | dealer value 17\n", "init (12, 4, False)\n", "player value 22 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 10, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (18, 10, False)\n", "player value 28 | dealer value 18\n", "init (9, 10, False)\n", "player value 20 | dealer value 26\n", "init (20, 5, True)\n", "player value 20 | dealer value 17\n", "init (18, 3, False)\n", "player value 18 | dealer value 25\n", "init (15, 2, True)\n", "player value 21 | dealer value 26\n", "init (20, 2, False)\n", "player value 20 | dealer value 20\n", "init (10, 5, False)\n", "player value 21 | dealer value 25\n", "init (15, 3, False)\n", "player value 16 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (21, 3, True)\n", "init (7, 4, False)\n", "player value 21 | dealer value 18\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (14, 7, False)\n", "player value 24 | dealer value 19\n", "init (13, 10, False)\n", "player value 24 | dealer value 20\n", "init (12, 1, False)\n", "init (21, 5, True)\n", "init (17, 4, False)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "player value 17 | dealer value 24\n", "init (14, 10, True)\n", "player value 24 | dealer value 26\n", "init (10, 7, False)\n", "player value 17 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (19, 8, True)\n", "player value 19 | dealer value 18\n", "init (13, 2, False)\n", "player value 21 | dealer value 19\n", "init (14, 4, False)\n", "player value 24 | dealer value 18\n", "init (14, 9, False)\n", "player value 20 | dealer value 19\n", "init (14, 4, False)\n", "player value 17 | dealer value 24\n", "init (13, 9, False)\n", "player value 23 | dealer value 19\n", "init (17, 3, True)\n", "player value 17 | dealer value 20\n", "init (14, 9, False)\n", "player value 24 | dealer value 19\n", "init (16, 10, False)\n", "player value 16 | dealer value 19\n", "init (9, 2, False)\n", "player value 19 | dealer value 21\n", "init (17, 7, False)\n", "player value 17 | dealer value 19\n", "init (11, 5, False)\n", "player value 16 | dealer value 25\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (20, 4, False)\n", "player value 21 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (13, 2, False)\n", "player value 25 | dealer value 19\n", "init (14, 10, False)\n", "player value 21 | dealer value 18\n", "init (12, 10, False)\n", "player value 18 | dealer value 26\n", "init (14, 1, False)\n", "init (16, 10, False)\n", "player value 26 | dealer value 22\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (21, 10, True)\n", "init (17, 10, False)\n", "player value 28 | dealer value 23\n", "init (16, 8, False)\n", "player value 23 | dealer value 23\n", "init (9, 1, False)\n", "player value 18 | dealer value 17\n", "init (7, 10, False)\n", "player value 19 | dealer value 17\n", "init (14, 4, False)\n", "player value 18 | dealer value 23\n", "init (18, 3, False)\n", "player value 22 | dealer value 19\n", "init (13, 10, False)\n", "init (21, 7, True)\n", "init (16, 4, False)\n", "player value 16 | dealer value 19\n", "init (14, 5, True)\n", "player value 20 | dealer value 17\n", "init (13, 10, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 2, False)\n", "player value 25 | dealer value 18\n", "init (16, 8, False)\n", "player value 16 | dealer value 19\n", "init (20, 1, False)\n", "init (16, 5, False)\n", "player value 16 | dealer value 23\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 24\n", "init (17, 3, False)\n", "player value 27 | dealer value 21\n", "init (7, 2, False)\n", "player value 19 | dealer value 18\n", "init (6, 10, False)\n", "player value 19 | dealer value 19\n", "init (13, 6, False)\n", "player value 13 | dealer value 26\n", "init (20, 1, False)\n", "player value 20 | dealer value 19\n", "init (12, 3, False)\n", "player value 22 | dealer value 21\n", "init (6, 3, False)\n", "player value 16 | dealer value 18\n", "init (15, 8, False)\n", "player value 26 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 21\n", "init (15, 2, False)\n", "player value 21 | dealer value 19\n", "init (14, 6, False)\n", "player value 14 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (8, 2, False)\n", "player value 13 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (7, 4, False)\n", "player value 21 | dealer value 23\n", "init (17, 5, False)\n", "player value 27 | dealer value 21\n", "init (13, 3, False)\n", "player value 19 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (12, 3, False)\n", "player value 16 | dealer value 17\n", "init (13, 10, True)\n", "player value 13 | dealer value 20\n", "init (16, 4, False)\n", "player value 16 | dealer value 20\n", "init (7, 4, False)\n", "player value 17 | dealer value 21\n", "init (6, 10, False)\n", "player value 20 | dealer value 22\n", "init (17, 7, True)\n", "player value 17 | dealer value 23\n", "init (9, 2, False)\n", "player value 20 | dealer value 26\n", "init (19, 5, False)\n", "player value 19 | dealer value 25\n", "init (9, 9, False)\n", "player value 19 | dealer value 17\n", "init (16, 5, False)\n", "player value 16 | dealer value 21\n", "init (12, 8, False)\n", "player value 26 | dealer value 18\n", "init (13, 7, False)\n", "player value 13 | dealer value 22\n", "init (11, 10, False)\n", "init (13, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 3, True)\n", "player value 21 | dealer value 20\n", "init (20, 1, False)\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (19, 2, True)\n", "player value 19 | dealer value 22\n", "init (21, 5, True)\n", "init (21, 3, True)\n", "init (17, 10, True)\n", "player value 19 | dealer value 18\n", "init (10, 8, False)\n", "player value 22 | dealer value 26\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (16, 9, False)\n", "player value 26 | dealer value 19\n", "init (6, 5, False)\n", "player value 24 | dealer value 21\n", "init (12, 10, False)\n", "init (13, 2, False)\n", "player value 21 | dealer value 22\n", "init (16, 8, False)\n", "player value 16 | dealer value 18\n", "init (14, 7, False)\n", "player value 19 | dealer value 24\n", "init (12, 2, False)\n", "player value 22 | dealer value 25\n", "init (11, 8, False)\n", "player value 21 | dealer value 24\n", "init (20, 6, False)\n", "player value 22 | dealer value 17\n", "init (16, 6, False)\n", "player value 22 | dealer value 17\n", "init (13, 7, False)\n", "player value 13 | dealer value 19\n", "init (15, 9, False)\n", "player value 18 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (11, 10, False)\n", "player value 18 | dealer value 19\n", "init (14, 8, False)\n", "player value 22 | dealer value 22\n", "init (9, 8, False)\n", "player value 21 | dealer value 23\n", "init (15, 3, False)\n", "player value 25 | dealer value 22\n", "init (14, 2, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (21, 5, True)\n", "init (13, 5, False)\n", "player value 13 | dealer value 21\n", "init (15, 4, False)\n", "player value 25 | dealer value 20\n", "init (16, 2, False)\n", "player value 20 | dealer value 18\n", "init (12, 7, False)\n", "player value 22 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 21\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 4, True)\n", "player value 19 | dealer value 25\n", "init (19, 3, False)\n", "player value 19 | dealer value 20\n", "init (14, 8, True)\n", "player value 22 | dealer value 21\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (20, 9, False)\n", "player value 23 | dealer value 24\n", "init (14, 8, True)\n", "player value 24 | dealer value 19\n", "init (18, 1, False)\n", "player value 21 | dealer value 19\n", "init (15, 3, False)\n", "player value 25 | dealer value 23\n", "init (11, 6, False)\n", "player value 21 | dealer value 18\n", "init (14, 7, False)\n", "player value 19 | dealer value 19\n", "init (12, 10, False)\n", "player value 12 | dealer value 23\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (4, 1, False)\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 6, False)\n", "player value 26 | dealer value 24\n", "init (8, 1, False)\n", "player value 24 | dealer value 19\n", "init (16, 3, False)\n", "player value 16 | dealer value 24\n", "init (21, 10, True)\n", "init (7, 5, False)\n", "player value 12 | dealer value 23\n", "init (19, 6, False)\n", "player value 19 | dealer value 23\n", "init (10, 6, False)\n", "player value 20 | dealer value 23\n", "init (16, 1, True)\n", "player value 16 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (12, 7, False)\n", "player value 21 | dealer value 17\n", "init (15, 8, False)\n", "player value 25 | dealer value 24\n", "init (11, 6, False)\n", "player value 25 | dealer value 20\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 22\n", "init (21, 4, True)\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (17, 5, False)\n", "player value 23 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (13, 1, False)\n", "init (12, 3, False)\n", "player value 20 | dealer value 22\n", "init (12, 10, False)\n", "init (9, 10, False)\n", "player value 22 | dealer value 22\n", "init (17, 9, False)\n", "player value 27 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 21\n", "init (14, 6, False)\n", "player value 14 | dealer value 17\n", "init (15, 7, False)\n", "player value 25 | dealer value 25\n", "init (14, 8, False)\n", "player value 24 | dealer value 17\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (21, 10, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 3, False)\n", "player value 20 | dealer value 24\n", "init (7, 5, False)\n", "player value 17 | dealer value 19\n", "init (11, 3, False)\n", "player value 21 | dealer value 24\n", "init (9, 1, False)\n", "player value 24 | dealer value 19\n", "init (11, 4, False)\n", "player value 21 | dealer value 25\n", "init (12, 10, False)\n", "init (16, 8, True)\n", "player value 26 | dealer value 21\n", "init (16, 1, False)\n", "player value 19 | dealer value 19\n", "init (14, 4, True)\n", "player value 19 | dealer value 23\n", "init (14, 10, False)\n", "player value 23 | dealer value 18\n", "init (13, 2, False)\n", "player value 23 | dealer value 22\n", "init (13, 8, False)\n", "player value 23 | dealer value 23\n", "init (12, 5, False)\n", "player value 12 | dealer value 25\n", "init (12, 2, False)\n", "player value 22 | dealer value 20\n", "init (8, 1, False)\n", "init (8, 10, False)\n", "player value 14 | dealer value 18\n", "init (12, 10, False)\n", "player value 15 | dealer value 25\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (8, 10, False)\n", "player value 27 | dealer value 23\n", "init (14, 10, False)\n", "player value 26 | dealer value 18\n", "init (14, 5, False)\n", "player value 24 | dealer value 17\n", "init (11, 4, False)\n", "player value 15 | dealer value 17\n", "init (21, 3, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 24\n", "init (12, 1, False)\n", "player value 26 | dealer value 22\n", "init (16, 3, False)\n", "player value 16 | dealer value 21\n", "init (14, 9, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "init (21, 10, True)\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (15, 3, True)\n", "player value 15 | dealer value 22\n", "init (9, 10, False)\n", "player value 21 | dealer value 20\n", "init (19, 1, False)\n", "player value 19 | dealer value 20\n", "init (11, 5, False)\n", "player value 21 | dealer value 20\n", "init (15, 5, False)\n", "player value 15 | dealer value 17\n", "init (12, 4, False)\n", "player value 19 | dealer value 19\n", "init (10, 9, False)\n", "player value 17 | dealer value 20\n", "init (11, 5, False)\n", "player value 20 | dealer value 25\n", "init (14, 9, False)\n", "player value 25 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 18\n", "init (14, 10, False)\n", "player value 23 | dealer value 17\n", "init (17, 10, False)\n", "player value 27 | dealer value 25\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (16, 6, False)\n", "player value 16 | dealer value 26\n", "init (13, 7, True)\n", "player value 18 | dealer value 21\n", "init (9, 10, False)\n", "player value 20 | dealer value 18\n", "init (7, 8, False)\n", "player value 19 | dealer value 17\n", "init (9, 10, False)\n", "player value 15 | dealer value 23\n", "init (12, 7, False)\n", "player value 26 | dealer value 17\n", "init (14, 3, False)\n", "player value 24 | dealer value 19\n", "init (6, 4, False)\n", "player value 24 | dealer value 26\n", "init (11, 9, False)\n", "player value 20 | dealer value 17\n", "init (14, 4, False)\n", "player value 19 | dealer value 17\n", "init (11, 10, False)\n", "player value 19 | dealer value 17\n", "init (7, 8, False)\n", "player value 19 | dealer value 22\n", "init (13, 10, True)\n", "player value 25 | dealer value 20\n", "init (12, 4, False)\n", "player value 20 | dealer value 24\n", "init (16, 9, True)\n", "player value 26 | dealer value 23\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (13, 10, False)\n", "player value 22 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 10, False)\n", "player value 21 | dealer value 19\n", "init (16, 6, False)\n", "player value 16 | dealer value 17\n", "init (14, 4, False)\n", "player value 18 | dealer value 17\n", "init (16, 2, False)\n", "player value 17 | dealer value 21\n", "init (21, 3, True)\n", "init (15, 5, False)\n", "player value 15 | dealer value 20\n", "init (14, 6, True)\n", "player value 18 | dealer value 17\n", "init (21, 10, True)\n", "init (15, 4, False)\n", "player value 15 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 26\n", "init (17, 7, True)\n", "player value 17 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 18\n", "init (9, 4, False)\n", "player value 18 | dealer value 21\n", "init (5, 6, False)\n", "player value 14 | dealer value 18\n", "init (16, 10, False)\n", "player value 26 | dealer value 24\n", "init (10, 4, False)\n", "player value 20 | dealer value 20\n", "init (14, 10, False)\n", "player value 19 | dealer value 25\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 19\n", "init (15, 10, False)\n", "init (9, 6, False)\n", "player value 19 | dealer value 23\n", "init (5, 7, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (7, 6, False)\n", "player value 25 | dealer value 18\n", "init (21, 10, True)\n", "init (7, 10, False)\n", "player value 20 | dealer value 18\n", "init (20, 3, True)\n", "player value 18 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (12, 10, False)\n", "player value 25 | dealer value 21\n", "init (19, 10, True)\n", "player value 19 | dealer value 23\n", "init (21, 2, True)\n", "init (21, 7, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (21, 10, True)\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (15, 6, False)\n", "player value 24 | dealer value 19\n", "init (12, 7, False)\n", "player value 26 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (7, 6, False)\n", "player value 18 | dealer value 17\n", "init (14, 1, False)\n", "player value 19 | dealer value 21\n", "init (5, 2, False)\n", "player value 18 | dealer value 17\n", "init (9, 4, False)\n", "player value 15 | dealer value 21\n", "init (13, 5, False)\n", "player value 18 | dealer value 20\n", "init (15, 8, False)\n", "player value 23 | dealer value 22\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (14, 1, False)\n", "init (13, 6, False)\n", "player value 13 | dealer value 23\n", "init (18, 10, False)\n", "player value 24 | dealer value 18\n", "init (21, 1, True)\n", "init (16, 10, False)\n", "init (14, 6, True)\n", "player value 14 | dealer value 21\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (15, 1, True)\n", "player value 18 | dealer value 17\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (13, 10, False)\n", "player value 18 | dealer value 19\n", "init (21, 3, True)\n", "init (16, 8, False)\n", "player value 23 | dealer value 19\n", "init (20, 6, False)\n", "player value 20 | dealer value 18\n", "init (12, 3, False)\n", "player value 12 | dealer value 21\n", "init (21, 8, True)\n", "init (14, 2, True)\n", "player value 17 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 10, False)\n", "player value 28 | dealer value 25\n", "init (11, 9, False)\n", "player value 21 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 19\n", "init (20, 8, False)\n", "player value 20 | dealer value 24\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (16, 9, False)\n", "player value 16 | dealer value 18\n", "init (10, 6, False)\n", "player value 18 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (16, 10, False)\n", "player value 23 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 20\n", "init (13, 6, True)\n", "player value 28 | dealer value 25\n", "init (12, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 20\n", "init (18, 5, True)\n", "player value 18 | dealer value 18\n", "init (18, 5, False)\n", "player value 18 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (10, 5, False)\n", "player value 15 | dealer value 17\n", "init (7, 8, False)\n", "player value 22 | dealer value 19\n", "init (9, 2, False)\n", "player value 19 | dealer value 18\n", "init (20, 9, True)\n", "player value 20 | dealer value 23\n", "init (8, 2, False)\n", "player value 21 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 19\n", "init (16, 10, True)\n", "player value 16 | dealer value 19\n", "init (15, 3, False)\n", "player value 18 | dealer value 21\n", "init (15, 5, False)\n", "player value 16 | dealer value 25\n", "init (16, 8, False)\n", "player value 25 | dealer value 23\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (13, 10, False)\n", "player value 22 | dealer value 19\n", "init (16, 8, False)\n", "player value 22 | dealer value 20\n", "init (10, 4, False)\n", "player value 18 | dealer value 20\n", "init (15, 9, False)\n", "player value 24 | dealer value 18\n", "init (6, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 8, False)\n", "player value 24 | dealer value 24\n", "init (9, 6, False)\n", "player value 17 | dealer value 18\n", "init (13, 10, False)\n", "player value 21 | dealer value 25\n", "init (15, 2, True)\n", "player value 22 | dealer value 22\n", "init (16, 10, False)\n", "init (16, 2, False)\n", "player value 20 | dealer value 18\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (6, 4, False)\n", "player value 27 | dealer value 17\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (10, 9, False)\n", "player value 20 | dealer value 19\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (17, 10, False)\n", "player value 23 | dealer value 17\n", "init (13, 5, False)\n", "player value 25 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (19, 2, True)\n", "player value 19 | dealer value 21\n", "init (14, 3, False)\n", "player value 14 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (20, 6, False)\n", "player value 20 | dealer value 24\n", "init (13, 10, False)\n", "player value 20 | dealer value 20\n", "init (10, 5, False)\n", "player value 12 | dealer value 25\n", "init (18, 5, False)\n", "player value 18 | dealer value 21\n", "init (8, 1, False)\n", "player value 18 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (17, 4, False)\n", "player value 26 | dealer value 24\n", "init (17, 4, False)\n", "player value 23 | dealer value 18\n", "init (14, 10, True)\n", "player value 20 | dealer value 19\n", "init (8, 8, False)\n", "player value 20 | dealer value 25\n", "init (11, 2, False)\n", "player value 17 | dealer value 23\n", "init (17, 10, False)\n", "player value 24 | dealer value 20\n", "init (8, 9, False)\n", "player value 22 | dealer value 19\n", "init (20, 7, False)\n", "player value 20 | dealer value 21\n", "init (14, 4, False)\n", "player value 20 | dealer value 19\n", "init (13, 1, False)\n", "player value 20 | dealer value 18\n", "init (8, 9, False)\n", "player value 22 | dealer value 19\n", "init (14, 5, False)\n", "player value 24 | dealer value 24\n", "init (13, 10, True)\n", "player value 16 | dealer value 21\n", "init (21, 7, True)\n", "init (20, 7, False)\n", "player value 20 | dealer value 21\n", "init (18, 10, False)\n", "player value 19 | dealer value 26\n", "init (13, 5, False)\n", "player value 23 | dealer value 22\n", "init (11, 8, False)\n", "player value 20 | dealer value 23\n", "init (12, 8, False)\n", "player value 24 | dealer value 22\n", "init (14, 8, False)\n", "player value 27 | dealer value 18\n", "init (16, 10, True)\n", "player value 21 | dealer value 18\n", "init (17, 10, True)\n", "player value 21 | dealer value 17\n", "init (13, 3, False)\n", "player value 23 | dealer value 21\n", "init (7, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 10, False)\n", "player value 22 | dealer value 20\n", "init (17, 1, False)\n", "init (14, 3, False)\n", "player value 14 | dealer value 23\n", "init (16, 10, False)\n", "player value 24 | dealer value 19\n", "init (16, 8, False)\n", "player value 16 | dealer value 19\n", "init (21, 1, True)\n", "init (17, 10, False)\n", "player value 17 | dealer value 19\n", "init (13, 10, True)\n", "player value 21 | dealer value 17\n", "init (13, 4, False)\n", "player value 23 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 18\n", "init (17, 4, False)\n", "player value 17 | dealer value 17\n", "init (18, 10, False)\n", "player value 27 | dealer value 20\n", "init (17, 4, False)\n", "player value 17 | dealer value 26\n", "init (18, 7, True)\n", "player value 18 | dealer value 17\n", "init (12, 10, False)\n", "player value 24 | dealer value 18\n", "init (15, 9, False)\n", "player value 25 | dealer value 23\n", "init (8, 5, False)\n", "player value 12 | dealer value 20\n", "init (15, 6, False)\n", "player value 24 | dealer value 20\n", "init (13, 10, False)\n", "player value 13 | dealer value 17\n", "init (10, 10, False)\n", "player value 15 | dealer value 18\n", "init (15, 3, False)\n", "player value 19 | dealer value 23\n", "init (12, 10, False)\n", "player value 27 | dealer value 20\n", "init (15, 1, False)\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (10, 6, False)\n", "player value 16 | dealer value 18\n", "init (13, 5, True)\n", "player value 13 | dealer value 21\n", "init (9, 8, False)\n", "player value 19 | dealer value 20\n", "init (8, 10, False)\n", "player value 18 | dealer value 24\n", "init (7, 10, False)\n", "player value 25 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 22\n", "init (20, 3, False)\n", "player value 20 | dealer value 22\n", "init (16, 10, False)\n", "player value 20 | dealer value 22\n", "init (13, 5, False)\n", "player value 23 | dealer value 25\n", "init (18, 2, False)\n", "player value 18 | dealer value 21\n", "init (14, 1, False)\n", "player value 20 | dealer value 17\n", "init (17, 10, False)\n", "player value 27 | dealer value 17\n", "init (17, 10, False)\n", "player value 24 | dealer value 20\n", "init (9, 10, False)\n", "player value 15 | dealer value 17\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (13, 10, True)\n", "player value 13 | dealer value 18\n", "init (19, 4, False)\n", "player value 19 | dealer value 19\n", "init (11, 8, False)\n", "player value 28 | dealer value 18\n", "init (14, 2, False)\n", "player value 24 | dealer value 21\n", "init (10, 5, False)\n", "player value 20 | dealer value 22\n", "init (12, 6, False)\n", "player value 12 | dealer value 23\n", "init (13, 7, False)\n", "player value 13 | dealer value 23\n", "init (16, 4, False)\n", "player value 26 | dealer value 24\n", "init (15, 8, False)\n", "player value 25 | dealer value 25\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (11, 7, False)\n", "player value 18 | dealer value 19\n", "init (14, 1, False)\n", "player value 19 | dealer value 25\n", "init (21, 6, True)\n", "init (14, 10, False)\n", "player value 16 | dealer value 20\n", "init (17, 9, True)\n", "player value 17 | dealer value 21\n", "init (12, 4, False)\n", "player value 22 | dealer value 22\n", "init (11, 8, False)\n", "player value 21 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (13, 4, False)\n", "player value 23 | dealer value 17\n", "init (13, 1, False)\n", "player value 26 | dealer value 20\n", "init (16, 4, True)\n", "player value 14 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 21\n", "init (13, 2, False)\n", "player value 13 | dealer value 26\n", "init (20, 4, True)\n", "player value 26 | dealer value 18\n", "init (15, 3, False)\n", "player value 15 | dealer value 23\n", "init (12, 1, False)\n", "init (21, 10, True)\n", "init (15, 1, False)\n", "player value 21 | dealer value 20\n", "init (8, 4, False)\n", "player value 18 | dealer value 18\n", "init (15, 6, False)\n", "player value 25 | dealer value 26\n", "init (21, 10, True)\n", "init (8, 8, False)\n", "player value 27 | dealer value 18\n", "init (9, 10, False)\n", "player value 27 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 19\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (11, 10, False)\n", "player value 18 | dealer value 24\n", "init (15, 1, False)\n", "player value 15 | dealer value 20\n", "init (14, 8, False)\n", "player value 22 | dealer value 18\n", "init (7, 2, False)\n", "player value 18 | dealer value 20\n", "init (14, 2, False)\n", "player value 24 | dealer value 20\n", "init (5, 10, False)\n", "player value 23 | dealer value 19\n", "init (17, 10, False)\n", "player value 27 | dealer value 22\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (9, 4, False)\n", "player value 18 | dealer value 26\n", "init (13, 10, False)\n", "player value 19 | dealer value 24\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (18, 5, True)\n", "player value 18 | dealer value 21\n", "init (14, 8, False)\n", "player value 22 | dealer value 22\n", "init (21, 10, True)\n", "init (16, 7, False)\n", "player value 16 | dealer value 18\n", "init (8, 5, False)\n", "player value 16 | dealer value 22\n", "init (17, 10, False)\n", "player value 27 | dealer value 17\n", "init (16, 9, False)\n", "player value 26 | dealer value 23\n", "init (11, 8, False)\n", "player value 23 | dealer value 25\n", "round 8000\n", "init (18, 4, False)\n", "player value 28 | dealer value 23\n", "init (14, 10, False)\n", "player value 18 | dealer value 23\n", "init (12, 9, False)\n", "player value 17 | dealer value 23\n", "init (12, 2, False)\n", "player value 12 | dealer value 20\n", "init (15, 9, True)\n", "player value 31 | dealer value 19\n", "init (13, 1, False)\n", "init (14, 7, False)\n", "player value 23 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 22\n", "init (19, 4, False)\n", "player value 19 | dealer value 22\n", "init (9, 10, False)\n", "player value 27 | dealer value 17\n", "init (15, 4, False)\n", "player value 23 | dealer value 17\n", "init (19, 5, False)\n", "player value 19 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (9, 3, False)\n", "player value 22 | dealer value 19\n", "init (12, 2, False)\n", "player value 22 | dealer value 19\n", "init (17, 7, False)\n", "player value 17 | dealer value 19\n", "init (16, 10, True)\n", "player value 16 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 24\n", "init (9, 6, False)\n", "player value 13 | dealer value 17\n", "init (17, 3, False)\n", "player value 26 | dealer value 22\n", "init (15, 8, False)\n", "player value 15 | dealer value 20\n", "init (10, 10, False)\n", "player value 18 | dealer value 17\n", "init (10, 10, False)\n", "init (13, 1, True)\n", "player value 13 | dealer value 19\n", "init (12, 10, False)\n", "player value 13 | dealer value 17\n", "init (21, 8, True)\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (12, 7, False)\n", "player value 17 | dealer value 17\n", "init (12, 6, False)\n", "player value 12 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 22\n", "init (13, 4, True)\n", "player value 20 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (21, 6, True)\n", "init (13, 4, True)\n", "player value 17 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 25\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 5, True)\n", "player value 15 | dealer value 19\n", "init (17, 1, True)\n", "player value 17 | dealer value 20\n", "init (20, 10, False)\n", "init (21, 4, True)\n", "init (13, 4, False)\n", "player value 20 | dealer value 24\n", "init (17, 4, False)\n", "player value 17 | dealer value 24\n", "init (13, 10, True)\n", "player value 19 | dealer value 19\n", "init (15, 3, False)\n", "player value 25 | dealer value 22\n", "init (13, 10, False)\n", "player value 22 | dealer value 18\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (6, 4, False)\n", "player value 16 | dealer value 18\n", "init (10, 10, False)\n", "player value 19 | dealer value 20\n", "init (10, 10, False)\n", "player value 19 | dealer value 26\n", "init (17, 9, False)\n", "player value 17 | dealer value 19\n", "init (14, 4, False)\n", "player value 24 | dealer value 22\n", "init (16, 2, False)\n", "player value 24 | dealer value 17\n", "init (9, 6, False)\n", "player value 18 | dealer value 19\n", "init (4, 7, False)\n", "player value 17 | dealer value 22\n", "init (17, 10, False)\n", "init (9, 2, False)\n", "player value 19 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (21, 3, True)\n", "init (13, 1, False)\n", "player value 13 | dealer value 17\n", "init (18, 5, False)\n", "player value 18 | dealer value 22\n", "init (10, 6, False)\n", "player value 20 | dealer value 21\n", "init (16, 3, False)\n", "player value 16 | dealer value 22\n", "init (16, 3, False)\n", "player value 16 | dealer value 23\n", "init (15, 1, False)\n", "init (21, 3, True)\n", "init (20, 4, True)\n", "player value 21 | dealer value 21\n", "init (17, 9, False)\n", "player value 17 | dealer value 18\n", "init (17, 10, False)\n", "player value 23 | dealer value 26\n", "init (14, 3, False)\n", "player value 14 | dealer value 17\n", "init (14, 3, False)\n", "player value 14 | dealer value 26\n", "init (15, 8, False)\n", "player value 19 | dealer value 19\n", "init (12, 6, False)\n", "player value 12 | dealer value 18\n", "init (15, 8, False)\n", "player value 22 | dealer value 25\n", "init (14, 5, True)\n", "player value 24 | dealer value 21\n", "init (19, 6, False)\n", "player value 26 | dealer value 17\n", "init (12, 9, False)\n", "player value 22 | dealer value 24\n", "init (18, 9, True)\n", "player value 18 | dealer value 21\n", "init (11, 7, False)\n", "player value 21 | dealer value 22\n", "init (13, 10, False)\n", "player value 22 | dealer value 24\n", "init (13, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 10, True)\n", "player value 20 | dealer value 26\n", "init (14, 10, False)\n", "player value 25 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, True)\n", "player value 21 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (14, 9, False)\n", "player value 19 | dealer value 24\n", "init (12, 1, False)\n", "player value 18 | dealer value 21\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (13, 3, False)\n", "player value 14 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (17, 10, False)\n", "player value 23 | dealer value 17\n", "init (10, 1, False)\n", "player value 26 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 26\n", "init (9, 8, False)\n", "player value 27 | dealer value 20\n", "init (12, 10, False)\n", "player value 23 | dealer value 20\n", "init (17, 10, False)\n", "player value 17 | dealer value 18\n", "init (10, 1, False)\n", "player value 20 | dealer value 22\n", "init (20, 9, True)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "player value 21 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (7, 9, False)\n", "player value 17 | dealer value 18\n", "init (10, 2, False)\n", "player value 17 | dealer value 17\n", "init (14, 10, False)\n", "player value 20 | dealer value 17\n", "init (20, 3, True)\n", "player value 20 | dealer value 17\n", "init (14, 1, False)\n", "player value 24 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 26\n", "init (14, 10, False)\n", "player value 21 | dealer value 19\n", "init (11, 9, False)\n", "player value 20 | dealer value 19\n", "init (11, 8, False)\n", "player value 21 | dealer value 18\n", "init (20, 7, False)\n", "player value 20 | dealer value 25\n", "init (13, 1, False)\n", "player value 23 | dealer value 18\n", "init (15, 1, True)\n", "player value 17 | dealer value 19\n", "init (12, 1, False)\n", "player value 22 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 17\n", "init (13, 10, True)\n", "player value 13 | dealer value 22\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (9, 6, False)\n", "player value 12 | dealer value 25\n", "init (10, 10, False)\n", "player value 21 | dealer value 23\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (13, 5, False)\n", "player value 16 | dealer value 17\n", "init (20, 8, False)\n", "player value 28 | dealer value 20\n", "init (17, 9, False)\n", "player value 26 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 23\n", "init (9, 8, False)\n", "player value 24 | dealer value 18\n", "init (9, 4, False)\n", "player value 15 | dealer value 20\n", "init (19, 5, False)\n", "player value 19 | dealer value 17\n", "init (15, 4, False)\n", "player value 15 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (14, 3, False)\n", "player value 14 | dealer value 23\n", "init (8, 9, False)\n", "player value 19 | dealer value 22\n", "init (16, 10, False)\n", "player value 27 | dealer value 18\n", "init (11, 8, False)\n", "player value 28 | dealer value 20\n", "init (12, 3, False)\n", "player value 22 | dealer value 23\n", "init (15, 6, False)\n", "player value 25 | dealer value 18\n", "init (12, 10, False)\n", "player value 29 | dealer value 19\n", "init (20, 1, False)\n", "player value 20 | dealer value 26\n", "init (13, 4, False)\n", "player value 20 | dealer value 24\n", "init (18, 3, False)\n", "player value 18 | dealer value 21\n", "init (11, 6, False)\n", "player value 21 | dealer value 25\n", "init (20, 2, False)\n", "player value 20 | dealer value 23\n", "init (13, 10, False)\n", "player value 22 | dealer value 22\n", "init (11, 8, False)\n", "player value 25 | dealer value 21\n", "init (14, 8, False)\n", "player value 28 | dealer value 19\n", "init (6, 1, False)\n", "init (18, 4, False)\n", "player value 18 | dealer value 21\n", "init (21, 10, True)\n", "init (12, 7, False)\n", "player value 20 | dealer value 17\n", "init (11, 1, False)\n", "player value 27 | dealer value 19\n", "init (21, 8, True)\n", "init (4, 8, False)\n", "player value 25 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (16, 10, False)\n", "player value 26 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (15, 5, False)\n", "player value 25 | dealer value 19\n", "init (15, 1, False)\n", "player value 22 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (14, 10, False)\n", "player value 14 | dealer value 18\n", "init (19, 1, True)\n", "player value 17 | dealer value 17\n", "init (13, 9, False)\n", "player value 22 | dealer value 19\n", "init (6, 10, False)\n", "player value 22 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (16, 10, False)\n", "player value 18 | dealer value 22\n", "init (16, 10, False)\n", "player value 18 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 5, False)\n", "player value 14 | dealer value 26\n", "init (9, 8, False)\n", "player value 22 | dealer value 18\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (10, 10, False)\n", "player value 19 | dealer value 18\n", "init (8, 10, False)\n", "player value 19 | dealer value 19\n", "init (15, 9, False)\n", "player value 25 | dealer value 25\n", "init (14, 10, False)\n", "player value 15 | dealer value 20\n", "init (11, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 9, False)\n", "player value 24 | dealer value 17\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (17, 5, False)\n", "player value 17 | dealer value 19\n", "init (14, 8, False)\n", "player value 22 | dealer value 19\n", "init (19, 6, True)\n", "player value 13 | dealer value 26\n", "init (20, 5, False)\n", "player value 20 | dealer value 25\n", "init (19, 1, False)\n", "player value 19 | dealer value 17\n", "init (21, 10, True)\n", "init (13, 10, False)\n", "player value 19 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (11, 7, False)\n", "player value 24 | dealer value 17\n", "init (9, 2, False)\n", "player value 19 | dealer value 18\n", "init (20, 5, True)\n", "player value 20 | dealer value 25\n", "init (10, 4, False)\n", "player value 19 | dealer value 19\n", "init (16, 5, False)\n", "player value 16 | dealer value 23\n", "init (17, 3, False)\n", "player value 18 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 22\n", "init (15, 8, False)\n", "player value 17 | dealer value 18\n", "init (21, 7, True)\n", "init (12, 9, False)\n", "player value 23 | dealer value 24\n", "init (13, 8, False)\n", "player value 22 | dealer value 18\n", "init (14, 9, False)\n", "player value 18 | dealer value 24\n", "init (20, 8, False)\n", "player value 20 | dealer value 19\n", "init (15, 7, False)\n", "player value 25 | dealer value 20\n", "init (12, 7, False)\n", "player value 22 | dealer value 17\n", "init (19, 8, False)\n", "player value 19 | dealer value 20\n", "init (10, 1, False)\n", "player value 21 | dealer value 25\n", "init (9, 2, False)\n", "player value 28 | dealer value 18\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 2, False)\n", "player value 24 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (21, 8, True)\n", "init (4, 3, False)\n", "player value 23 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 21\n", "init (20, 1, False)\n", "init (12, 5, False)\n", "player value 12 | dealer value 25\n", "init (10, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 3, False)\n", "player value 19 | dealer value 18\n", "init (16, 7, False)\n", "player value 26 | dealer value 17\n", "init (17, 4, False)\n", "player value 17 | dealer value 24\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (15, 6, False)\n", "player value 23 | dealer value 17\n", "init (12, 10, False)\n", "player value 18 | dealer value 25\n", "init (14, 7, False)\n", "player value 23 | dealer value 22\n", "init (11, 10, False)\n", "player value 20 | dealer value 19\n", "init (8, 10, False)\n", "player value 19 | dealer value 23\n", "init (9, 10, False)\n", "player value 20 | dealer value 21\n", "init (13, 2, False)\n", "player value 13 | dealer value 20\n", "init (9, 4, False)\n", "player value 17 | dealer value 18\n", "init (17, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 10, False)\n", "player value 27 | dealer value 17\n", "init (8, 1, False)\n", "player value 26 | dealer value 19\n", "init (15, 7, True)\n", "player value 18 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (17, 5, False)\n", "player value 22 | dealer value 18\n", "init (20, 1, False)\n", "init (10, 6, False)\n", "player value 16 | dealer value 18\n", "init (14, 4, False)\n", "player value 22 | dealer value 18\n", "init (17, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (20, 5, True)\n", "player value 20 | dealer value 17\n", "init (11, 8, False)\n", "player value 20 | dealer value 18\n", "init (17, 10, False)\n", "player value 23 | dealer value 20\n", "init (14, 5, False)\n", "player value 14 | dealer value 17\n", "init (11, 4, False)\n", "player value 26 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 20\n", "init (15, 6, False)\n", "player value 15 | dealer value 23\n", "init (5, 4, False)\n", "player value 16 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (17, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (17, 8, False)\n", "player value 27 | dealer value 18\n", "init (15, 7, False)\n", "player value 24 | dealer value 17\n", "init (12, 9, False)\n", "player value 23 | dealer value 19\n", "init (12, 4, False)\n", "player value 22 | dealer value 20\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (13, 6, False)\n", "player value 13 | dealer value 21\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (14, 10, False)\n", "init (17, 10, False)\n", "player value 27 | dealer value 18\n", "init (16, 1, True)\n", "player value 20 | dealer value 18\n", "init (5, 3, False)\n", "player value 24 | dealer value 23\n", "init (13, 2, True)\n", "player value 23 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 26\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 8, False)\n", "player value 16 | dealer value 25\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (21, 10, True)\n", "init (20, 9, False)\n", "player value 20 | dealer value 23\n", "init (21, 10, True)\n", "init (13, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 4, False)\n", "player value 24 | dealer value 18\n", "init (9, 2, False)\n", "player value 17 | dealer value 18\n", "init (9, 10, False)\n", "player value 21 | dealer value 18\n", "init (6, 5, False)\n", "player value 25 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (17, 9, False)\n", "player value 17 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (10, 10, False)\n", "player value 22 | dealer value 23\n", "init (18, 2, False)\n", "player value 18 | dealer value 22\n", "init (13, 5, False)\n", "player value 18 | dealer value 19\n", "init (9, 9, False)\n", "player value 13 | dealer value 18\n", "init (5, 10, False)\n", "player value 19 | dealer value 18\n", "init (15, 3, True)\n", "player value 20 | dealer value 17\n", "init (14, 6, True)\n", "player value 14 | dealer value 22\n", "init (15, 10, True)\n", "player value 18 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 24\n", "init (8, 1, False)\n", "init (8, 3, False)\n", "player value 21 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (19, 10, True)\n", "player value 23 | dealer value 24\n", "init (13, 3, False)\n", "player value 23 | dealer value 19\n", "init (15, 5, False)\n", "player value 29 | dealer value 25\n", "init (16, 5, False)\n", "player value 16 | dealer value 22\n", "init (13, 1, False)\n", "player value 19 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 23\n", "init (17, 6, False)\n", "player value 27 | dealer value 20\n", "init (7, 7, False)\n", "player value 18 | dealer value 22\n", "init (12, 5, False)\n", "player value 12 | dealer value 26\n", "init (13, 9, False)\n", "player value 18 | dealer value 18\n", "init (14, 4, False)\n", "player value 24 | dealer value 23\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (18, 3, False)\n", "player value 18 | dealer value 19\n", "init (21, 2, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (16, 3, False)\n", "player value 16 | dealer value 20\n", "init (12, 2, False)\n", "player value 22 | dealer value 23\n", "init (7, 10, False)\n", "player value 23 | dealer value 17\n", "init (11, 10, False)\n", "player value 21 | dealer value 26\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (12, 2, True)\n", "player value 19 | dealer value 19\n", "init (21, 2, True)\n", "init (18, 5, False)\n", "player value 18 | dealer value 17\n", "init (7, 8, False)\n", "player value 20 | dealer value 25\n", "init (14, 7, False)\n", "player value 17 | dealer value 17\n", "init (15, 2, False)\n", "player value 21 | dealer value 18\n", "init (14, 2, False)\n", "player value 18 | dealer value 20\n", "init (8, 9, False)\n", "player value 18 | dealer value 18\n", "init (12, 3, False)\n", "player value 12 | dealer value 18\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (18, 8, False)\n", "player value 18 | dealer value 21\n", "init (21, 1, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (12, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 4, False)\n", "player value 26 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (12, 6, False)\n", "player value 12 | dealer value 25\n", "init (20, 10, False)\n", "init (14, 4, False)\n", "player value 18 | dealer value 21\n", "init (17, 8, False)\n", "player value 27 | dealer value 18\n", "init (7, 10, False)\n", "player value 27 | dealer value 23\n", "init (14, 5, False)\n", "player value 14 | dealer value 23\n", "init (14, 10, True)\n", "player value 23 | dealer value 23\n", "init (15, 10, False)\n", "player value 25 | dealer value 20\n", "init (11, 7, False)\n", "player value 18 | dealer value 23\n", "init (19, 1, False)\n", "player value 19 | dealer value 18\n", "init (8, 9, False)\n", "player value 18 | dealer value 19\n", "init (16, 10, False)\n", "player value 26 | dealer value 26\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 10, False)\n", "player value 19 | dealer value 19\n", "init (21, 10, True)\n", "init (17, 9, True)\n", "player value 17 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 23\n", "init (21, 5, True)\n", "init (21, 3, True)\n", "init (14, 8, False)\n", "player value 21 | dealer value 18\n", "init (12, 10, False)\n", "player value 12 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 1, False)\n", "player value 17 | dealer value 22\n", "init (18, 10, False)\n", "player value 18 | dealer value 26\n", "init (21, 2, True)\n", "init (14, 2, False)\n", "player value 19 | dealer value 25\n", "init (12, 10, False)\n", "player value 15 | dealer value 20\n", "init (17, 1, False)\n", "player value 17 | dealer value 20\n", "init (13, 6, True)\n", "player value 13 | dealer value 17\n", "init (7, 10, False)\n", "player value 27 | dealer value 17\n", "init (15, 7, False)\n", "player value 25 | dealer value 20\n", "init (17, 9, False)\n", "player value 17 | dealer value 19\n", "init (12, 4, False)\n", "player value 22 | dealer value 24\n", "init (13, 2, False)\n", "player value 23 | dealer value 26\n", "init (21, 3, True)\n", "init (14, 3, False)\n", "player value 23 | dealer value 24\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (12, 10, False)\n", "player value 26 | dealer value 25\n", "init (11, 7, False)\n", "player value 13 | dealer value 22\n", "init (15, 3, False)\n", "player value 16 | dealer value 25\n", "init (8, 7, False)\n", "player value 19 | dealer value 20\n", "init (17, 6, False)\n", "player value 17 | dealer value 17\n", "init (15, 4, False)\n", "player value 24 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 24\n", "init (12, 10, False)\n", "player value 18 | dealer value 25\n", "init (18, 10, False)\n", "player value 22 | dealer value 20\n", "init (10, 4, False)\n", "player value 17 | dealer value 17\n", "init (11, 5, False)\n", "player value 25 | dealer value 25\n", "init (14, 7, False)\n", "player value 14 | dealer value 18\n", "init (15, 10, True)\n", "init (11, 8, False)\n", "player value 30 | dealer value 17\n", "init (14, 7, False)\n", "player value 24 | dealer value 23\n", "init (13, 10, False)\n", "player value 27 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (13, 9, False)\n", "player value 22 | dealer value 19\n", "init (13, 6, False)\n", "player value 23 | dealer value 25\n", "init (20, 6, False)\n", "player value 20 | dealer value 19\n", "init (15, 6, False)\n", "player value 25 | dealer value 25\n", "init (19, 5, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (11, 7, False)\n", "player value 12 | dealer value 17\n", "init (14, 5, False)\n", "player value 14 | dealer value 17\n", "init (20, 10, True)\n", "player value 20 | dealer value 26\n", "init (12, 4, False)\n", "player value 15 | dealer value 18\n", "init (16, 3, False)\n", "player value 16 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (15, 4, False)\n", "player value 15 | dealer value 17\n", "init (18, 9, False)\n", "player value 18 | dealer value 21\n", "init (13, 9, False)\n", "player value 25 | dealer value 18\n", "init (15, 8, False)\n", "player value 20 | dealer value 22\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (20, 9, True)\n", "player value 20 | dealer value 21\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (14, 6, True)\n", "player value 14 | dealer value 23\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 10, True)\n", "player value 15 | dealer value 24\n", "init (18, 6, True)\n", "player value 18 | dealer value 20\n", "init (18, 10, True)\n", "player value 17 | dealer value 23\n", "init (20, 9, False)\n", "player value 30 | dealer value 21\n", "init (11, 9, False)\n", "player value 20 | dealer value 18\n", "init (15, 2, False)\n", "player value 18 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (10, 7, False)\n", "player value 17 | dealer value 17\n", "init (14, 8, False)\n", "player value 23 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 26\n", "init (10, 10, False)\n", "player value 22 | dealer value 20\n", "init (9, 3, False)\n", "player value 19 | dealer value 21\n", "init (16, 10, False)\n", "player value 18 | dealer value 17\n", "init (11, 10, False)\n", "player value 15 | dealer value 24\n", "init (11, 6, False)\n", "player value 21 | dealer value 26\n", "init (10, 7, False)\n", "player value 26 | dealer value 19\n", "init (13, 3, False)\n", "player value 16 | dealer value 19\n", "init (17, 5, False)\n", "player value 27 | dealer value 23\n", "init (20, 1, True)\n", "player value 22 | dealer value 20\n", "init (18, 10, True)\n", "player value 20 | dealer value 20\n", "init (16, 8, False)\n", "player value 22 | dealer value 18\n", "init (17, 9, False)\n", "player value 19 | dealer value 19\n", "init (5, 10, False)\n", "player value 15 | dealer value 25\n", "init (18, 2, False)\n", "player value 18 | dealer value 22\n", "init (14, 9, False)\n", "player value 24 | dealer value 20\n", "init (7, 6, False)\n", "player value 17 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 17\n", "init (19, 1, False)\n", "init (19, 6, False)\n", "player value 19 | dealer value 18\n", "init (12, 8, False)\n", "player value 12 | dealer value 18\n", "init (13, 2, False)\n", "player value 13 | dealer value 21\n", "init (19, 6, False)\n", "player value 19 | dealer value 25\n", "init (19, 6, False)\n", "player value 19 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (15, 3, False)\n", "player value 25 | dealer value 23\n", "init (14, 8, False)\n", "player value 27 | dealer value 21\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (18, 5, False)\n", "player value 18 | dealer value 17\n", "init (16, 10, False)\n", "player value 22 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (12, 9, False)\n", "player value 19 | dealer value 19\n", "init (21, 4, True)\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (14, 5, False)\n", "player value 14 | dealer value 23\n", "init (7, 3, False)\n", "player value 16 | dealer value 17\n", "init (21, 10, True)\n", "init (21, 1, True)\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (16, 10, True)\n", "player value 16 | dealer value 17\n", "init (12, 4, False)\n", "player value 19 | dealer value 21\n", "init (13, 4, False)\n", "player value 16 | dealer value 19\n", "init (12, 9, False)\n", "player value 20 | dealer value 23\n", "init (17, 8, False)\n", "player value 27 | dealer value 20\n", "init (19, 4, False)\n", "player value 19 | dealer value 19\n", "init (13, 4, False)\n", "player value 23 | dealer value 24\n", "init (7, 2, False)\n", "player value 18 | dealer value 22\n", "init (17, 5, False)\n", "player value 21 | dealer value 25\n", "init (13, 6, False)\n", "player value 20 | dealer value 26\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (12, 9, False)\n", "player value 19 | dealer value 21\n", "init (18, 5, False)\n", "player value 18 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (13, 4, False)\n", "player value 17 | dealer value 17\n", "init (9, 5, False)\n", "player value 14 | dealer value 24\n", "init (18, 3, False)\n", "player value 18 | dealer value 21\n", "init (13, 3, False)\n", "player value 21 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 17\n", "init (17, 3, False)\n", "player value 17 | dealer value 17\n", "init (21, 5, True)\n", "init (7, 10, False)\n", "player value 23 | dealer value 26\n", "init (11, 10, False)\n", "player value 25 | dealer value 23\n", "init (17, 10, False)\n", "player value 23 | dealer value 17\n", "init (8, 7, False)\n", "player value 21 | dealer value 23\n", "init (20, 2, False)\n", "player value 25 | dealer value 19\n", "init (16, 9, True)\n", "player value 21 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 24\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (18, 5, False)\n", "player value 18 | dealer value 26\n", "init (13, 10, False)\n", "player value 23 | dealer value 19\n", "init (10, 10, False)\n", "player value 17 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 25\n", "init (9, 4, False)\n", "player value 18 | dealer value 25\n", "init (18, 8, False)\n", "player value 19 | dealer value 19\n", "init (13, 10, False)\n", "player value 31 | dealer value 24\n", "init (20, 6, False)\n", "player value 30 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 18\n", "init (9, 1, False)\n", "player value 19 | dealer value 17\n", "init (11, 6, False)\n", "player value 19 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (11, 9, False)\n", "player value 21 | dealer value 18\n", "init (13, 7, False)\n", "player value 13 | dealer value 17\n", "init (12, 10, False)\n", "player value 16 | dealer value 19\n", "init (16, 2, False)\n", "player value 24 | dealer value 23\n", "init (12, 10, False)\n", "player value 20 | dealer value 22\n", "init (12, 7, False)\n", "player value 14 | dealer value 22\n", "init (14, 9, False)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "player value 15 | dealer value 22\n", "init (12, 7, False)\n", "player value 22 | dealer value 17\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (10, 3, False)\n", "player value 25 | dealer value 26\n", "init (11, 10, False)\n", "init (16, 4, True)\n", "player value 16 | dealer value 24\n", "init (19, 5, False)\n", "player value 19 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (19, 6, False)\n", "player value 19 | dealer value 17\n", "init (16, 5, False)\n", "player value 16 | dealer value 21\n", "init (15, 8, False)\n", "player value 15 | dealer value 25\n", "init (18, 5, False)\n", "player value 18 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (21, 10, True)\n", "init (14, 9, False)\n", "player value 23 | dealer value 20\n", "init (17, 3, False)\n", "player value 21 | dealer value 20\n", "init (13, 2, False)\n", "player value 16 | dealer value 20\n", "init (4, 10, False)\n", "player value 20 | dealer value 19\n", "init (21, 5, True)\n", "init (16, 2, False)\n", "player value 26 | dealer value 21\n", "init (16, 6, False)\n", "player value 16 | dealer value 23\n", "init (18, 3, False)\n", "player value 18 | dealer value 17\n", "init (15, 4, False)\n", "player value 27 | dealer value 19\n", "init (20, 1, True)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "init (14, 3, False)\n", "player value 14 | dealer value 20\n", "init (16, 9, False)\n", "player value 19 | dealer value 17\n", "init (13, 6, False)\n", "player value 18 | dealer value 26\n", "init (10, 5, False)\n", "player value 24 | dealer value 23\n", "init (20, 4, False)\n", "player value 22 | dealer value 20\n", "init (9, 4, False)\n", "player value 29 | dealer value 20\n", "init (13, 5, False)\n", "player value 20 | dealer value 18\n", "init (11, 10, False)\n", "player value 19 | dealer value 17\n", "init (15, 6, True)\n", "player value 23 | dealer value 24\n", "init (14, 10, False)\n", "player value 14 | dealer value 22\n", "init (10, 10, False)\n", "player value 18 | dealer value 18\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (13, 6, False)\n", "player value 22 | dealer value 17\n", "init (20, 10, False)\n", "player value 23 | dealer value 18\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (5, 8, False)\n", "player value 18 | dealer value 18\n", "init (20, 10, True)\n", "player value 20 | dealer value 18\n", "init (12, 7, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "init (8, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 4, False)\n", "player value 22 | dealer value 25\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (14, 9, False)\n", "player value 27 | dealer value 24\n", "init (12, 2, False)\n", "player value 19 | dealer value 26\n", "init (11, 8, False)\n", "player value 25 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 24\n", "init (16, 6, False)\n", "player value 25 | dealer value 25\n", "init (14, 9, False)\n", "player value 19 | dealer value 17\n", "init (14, 2, False)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "player value 24 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 18\n", "init (13, 6, False)\n", "player value 13 | dealer value 21\n", "init (17, 10, True)\n", "player value 17 | dealer value 25\n", "init (12, 8, False)\n", "player value 18 | dealer value 25\n", "init (11, 4, False)\n", "player value 18 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 8, False)\n", "player value 22 | dealer value 21\n", "init (13, 1, False)\n", "player value 23 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (18, 2, False)\n", "player value 18 | dealer value 17\n", "init (6, 7, False)\n", "player value 20 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 19\n", "init (4, 10, False)\n", "init (15, 7, False)\n", "player value 21 | dealer value 18\n", "init (15, 2, False)\n", "player value 21 | dealer value 17\n", "init (21, 8, True)\n", "init (15, 2, False)\n", "player value 15 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (16, 1, False)\n", "player value 23 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 23\n", "init (13, 2, False)\n", "player value 30 | dealer value 23\n", "init (20, 3, False)\n", "player value 20 | dealer value 22\n", "init (9, 4, False)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (11, 10, False)\n", "player value 13 | dealer value 24\n", "init (14, 10, False)\n", "player value 22 | dealer value 17\n", "init (13, 7, False)\n", "player value 13 | dealer value 24\n", "init (16, 7, False)\n", "player value 22 | dealer value 17\n", "init (16, 4, False)\n", "player value 26 | dealer value 26\n", "init (11, 8, False)\n", "player value 21 | dealer value 26\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (13, 7, False)\n", "player value 13 | dealer value 17\n", "init (13, 10, False)\n", "player value 26 | dealer value 22\n", "init (17, 3, False)\n", "player value 20 | dealer value 21\n", "init (14, 4, False)\n", "player value 20 | dealer value 19\n", "init (17, 1, False)\n", "init (16, 3, False)\n", "player value 16 | dealer value 18\n", "init (13, 10, False)\n", "player value 15 | dealer value 17\n", "init (15, 8, True)\n", "player value 15 | dealer value 18\n", "init (8, 4, False)\n", "player value 19 | dealer value 20\n", "init (8, 6, False)\n", "player value 14 | dealer value 22\n", "init (8, 1, False)\n", "init (20, 9, False)\n", "player value 30 | dealer value 19\n", "init (17, 5, False)\n", "player value 27 | dealer value 20\n", "init (18, 3, False)\n", "player value 18 | dealer value 24\n", "init (7, 10, False)\n", "player value 19 | dealer value 22\n", "init (12, 6, False)\n", "player value 12 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 25\n", "init (18, 10, False)\n", "init (16, 4, False)\n", "player value 16 | dealer value 22\n", "init (7, 7, False)\n", "player value 22 | dealer value 17\n", "init (13, 5, False)\n", "player value 13 | dealer value 17\n", "init (12, 7, True)\n", "player value 12 | dealer value 17\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n", "init (17, 10, False)\n", "player value 24 | dealer value 20\n", "init (8, 1, False)\n", "player value 18 | dealer value 17\n", "init (13, 4, False)\n", "player value 23 | dealer value 22\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (13, 10, False)\n", "player value 14 | dealer value 19\n", "init (11, 10, False)\n", "player value 21 | dealer value 17\n", "init (16, 1, False)\n", "player value 16 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (9, 5, False)\n", "player value 19 | dealer value 20\n", "init (10, 9, False)\n", "player value 21 | dealer value 19\n", "init (17, 5, True)\n", "player value 19 | dealer value 17\n", "init (21, 9, True)\n", "init (13, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 25\n", "init (19, 1, False)\n", "player value 19 | dealer value 20\n", "init (16, 1, False)\n", "init (18, 5, False)\n", "player value 18 | dealer value 17\n", "init (11, 7, False)\n", "player value 21 | dealer value 24\n", "init (17, 10, False)\n", "player value 20 | dealer value 25\n", "init (16, 5, False)\n", "player value 16 | dealer value 19\n", "init (13, 7, True)\n", "player value 18 | dealer value 20\n", "init (17, 3, False)\n", "player value 20 | dealer value 20\n", "init (17, 2, False)\n", "player value 17 | dealer value 22\n", "init (16, 6, False)\n", "player value 16 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 24\n", "init (19, 10, True)\n", "player value 21 | dealer value 17\n", "init (13, 10, False)\n", "init (18, 10, False)\n", "player value 19 | dealer value 25\n", "init (8, 4, False)\n", "player value 18 | dealer value 19\n", "init (6, 6, False)\n", "player value 14 | dealer value 20\n", "init (13, 5, False)\n", "player value 23 | dealer value 21\n", "init (18, 8, False)\n", "player value 18 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 20\n", "init (16, 8, False)\n", "player value 24 | dealer value 18\n", "init (11, 10, False)\n", "player value 23 | dealer value 21\n", "init (14, 3, False)\n", "player value 14 | dealer value 22\n", "init (13, 4, False)\n", "player value 20 | dealer value 23\n", "init (17, 5, False)\n", "player value 27 | dealer value 22\n", "init (14, 1, False)\n", "player value 14 | dealer value 19\n", "init (14, 10, False)\n", "player value 25 | dealer value 22\n", "init (14, 3, False)\n", "player value 14 | dealer value 23\n", "init (13, 3, False)\n", "player value 18 | dealer value 20\n", "init (21, 10, True)\n", "init (14, 6, False)\n", "player value 14 | dealer value 26\n", "init (9, 10, False)\n", "player value 26 | dealer value 26\n", "init (14, 10, False)\n", "player value 21 | dealer value 18\n", "init (15, 10, False)\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (19, 8, False)\n", "player value 27 | dealer value 17\n", "init (10, 3, False)\n", "player value 21 | dealer value 17\n", "init (13, 9, False)\n", "player value 23 | dealer value 20\n", "init (16, 9, False)\n", "player value 16 | dealer value 17\n", "init (13, 1, False)\n", "player value 21 | dealer value 18\n", "init (11, 10, False)\n", "player value 16 | dealer value 20\n", "init (17, 7, False)\n", "player value 17 | dealer value 18\n", "init (15, 4, False)\n", "player value 18 | dealer value 22\n", "init (19, 5, False)\n", "player value 19 | dealer value 21\n", "init (18, 8, True)\n", "player value 18 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 25\n", "init (14, 3, False)\n", "player value 14 | dealer value 26\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 8, False)\n", "player value 21 | dealer value 22\n", "init (9, 3, False)\n", "player value 16 | dealer value 23\n", "init (17, 4, True)\n", "player value 22 | dealer value 21\n", "init (18, 3, True)\n", "player value 18 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 23\n", "init (12, 7, False)\n", "player value 22 | dealer value 18\n", "init (20, 5, True)\n", "player value 20 | dealer value 18\n", "init (12, 9, False)\n", "player value 22 | dealer value 20\n", "init (14, 10, False)\n", "player value 21 | dealer value 18\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (13, 4, False)\n", "player value 23 | dealer value 20\n", "init (13, 10, False)\n", "player value 20 | dealer value 20\n", "init (14, 5, False)\n", "player value 14 | dealer value 23\n", "init (12, 10, False)\n", "player value 12 | dealer value 20\n", "init (18, 10, False)\n", "player value 21 | dealer value 20\n", "init (11, 3, False)\n", "player value 31 | dealer value 21\n", "init (20, 7, False)\n", "player value 20 | dealer value 19\n", "init (19, 5, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 19\n", "init (16, 1, False)\n", "player value 26 | dealer value 22\n", "init (21, 5, True)\n", "init (16, 5, False)\n", "player value 16 | dealer value 22\n", "init (11, 7, False)\n", "player value 23 | dealer value 25\n", "init (20, 10, False)\n", "player value 26 | dealer value 18\n", "init (14, 10, True)\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (17, 10, False)\n", "player value 20 | dealer value 19\n", "init (16, 3, False)\n", "player value 16 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (14, 8, False)\n", "player value 26 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (8, 6, False)\n", "player value 18 | dealer value 17\n", "init (18, 5, False)\n", "player value 18 | dealer value 18\n", "init (12, 10, False)\n", "player value 21 | dealer value 23\n", "init (17, 8, False)\n", "player value 17 | dealer value 18\n", "init (12, 9, False)\n", "player value 18 | dealer value 17\n", "init (20, 10, False)\n", "player value 30 | dealer value 21\n", "init (15, 3, False)\n", "player value 15 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 19\n", "init (9, 9, False)\n", "player value 22 | dealer value 20\n", "init (16, 8, False)\n", "player value 26 | dealer value 17\n", "init (12, 1, False)\n", "init (14, 10, False)\n", "player value 22 | dealer value 18\n", "init (12, 10, True)\n", "player value 22 | dealer value 19\n", "init (10, 10, False)\n", "player value 22 | dealer value 22\n", "init (14, 2, False)\n", "player value 14 | dealer value 21\n", "init (17, 5, True)\n", "player value 19 | dealer value 19\n", "init (17, 5, False)\n", "player value 24 | dealer value 26\n", "init (17, 3, False)\n", "player value 19 | dealer value 18\n", "init (13, 4, False)\n", "player value 18 | dealer value 21\n", "init (16, 4, False)\n", "player value 16 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (19, 9, True)\n", "player value 19 | dealer value 19\n", "init (17, 8, True)\n", "player value 17 | dealer value 18\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (15, 5, False)\n", "player value 23 | dealer value 17\n", "init (10, 6, False)\n", "player value 14 | dealer value 22\n", "init (12, 5, False)\n", "player value 12 | dealer value 25\n", "init (14, 4, False)\n", "player value 20 | dealer value 18\n", "init (13, 6, True)\n", "player value 16 | dealer value 20\n", "init (21, 10, True)\n", "init (12, 7, False)\n", "player value 22 | dealer value 17\n", "init (10, 7, False)\n", "player value 30 | dealer value 18\n", "init (19, 3, False)\n", "player value 19 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 21\n", "init (14, 8, False)\n", "player value 18 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (20, 8, False)\n", "player value 29 | dealer value 23\n", "init (14, 7, True)\n", "player value 14 | dealer value 23\n", "init (15, 3, False)\n", "player value 22 | dealer value 21\n", "init (11, 1, False)\n", "player value 21 | dealer value 21\n", "init (9, 4, False)\n", "player value 15 | dealer value 18\n", "init (16, 10, False)\n", "player value 27 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 19\n", "init (6, 5, False)\n", "player value 21 | dealer value 17\n", "init (19, 7, False)\n", "player value 19 | dealer value 21\n", "init (14, 7, False)\n", "player value 24 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (5, 2, False)\n", "player value 19 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 8, False)\n", "player value 22 | dealer value 20\n", "init (16, 10, False)\n", "player value 21 | dealer value 17\n", "init (16, 6, False)\n", "player value 16 | dealer value 22\n", "init (20, 6, False)\n", "player value 20 | dealer value 18\n", "init (16, 10, True)\n", "player value 23 | dealer value 18\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, True)\n", "player value 18 | dealer value 20\n", "init (21, 2, True)\n", "init (16, 10, False)\n", "init (14, 10, False)\n", "init (16, 2, False)\n", "player value 26 | dealer value 22\n", "init (16, 5, False)\n", "player value 16 | dealer value 22\n", "init (12, 8, False)\n", "player value 19 | dealer value 17\n", "init (12, 7, False)\n", "player value 12 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 25\n", "init (21, 10, True)\n", "init (20, 5, True)\n", "player value 20 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 26\n", "init (14, 2, False)\n", "player value 18 | dealer value 20\n", "init (16, 5, False)\n", "player value 16 | dealer value 19\n", "init (15, 8, False)\n", "player value 25 | dealer value 21\n", "init (14, 2, True)\n", "player value 21 | dealer value 25\n", "init (11, 7, False)\n", "player value 17 | dealer value 17\n", "init (15, 6, False)\n", "player value 18 | dealer value 26\n", "init (16, 10, False)\n", "player value 22 | dealer value 24\n", "init (17, 1, False)\n", "player value 17 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (10, 7, False)\n", "player value 20 | dealer value 17\n", "init (12, 3, False)\n", "player value 20 | dealer value 24\n", "init (13, 3, False)\n", "player value 13 | dealer value 21\n", "init (6, 10, False)\n", "player value 15 | dealer value 17\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (8, 3, False)\n", "player value 20 | dealer value 21\n", "init (20, 1, False)\n", "player value 20 | dealer value 23\n", "init (11, 10, False)\n", "player value 23 | dealer value 19\n", "init (18, 8, False)\n", "player value 18 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 22\n", "init (21, 10, True)\n", "init (17, 5, False)\n", "player value 27 | dealer value 21\n", "init (19, 4, False)\n", "player value 19 | dealer value 20\n", "init (15, 8, False)\n", "player value 25 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 18\n", "init (18, 6, True)\n", "player value 22 | dealer value 24\n", "init (16, 7, False)\n", "player value 25 | dealer value 17\n", "init (21, 6, True)\n", "init (14, 2, False)\n", "player value 22 | dealer value 18\n", "init (9, 8, False)\n", "player value 28 | dealer value 22\n", "init (12, 8, False)\n", "player value 18 | dealer value 26\n", "init (11, 3, False)\n", "player value 19 | dealer value 20\n", "init (14, 5, False)\n", "player value 14 | dealer value 23\n", "init (6, 3, False)\n", "player value 19 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (12, 10, False)\n", "player value 22 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 25\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 19\n", "init (21, 10, True)\n", "init (16, 3, False)\n", "player value 16 | dealer value 26\n", "init (16, 5, False)\n", "player value 16 | dealer value 23\n", "init (19, 5, False)\n", "player value 29 | dealer value 25\n", "init (18, 10, False)\n", "player value 28 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 23\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (15, 9, False)\n", "player value 26 | dealer value 23\n", "init (17, 10, True)\n", "player value 20 | dealer value 20\n", "init (16, 7, False)\n", "player value 16 | dealer value 21\n", "init (8, 10, False)\n", "player value 18 | dealer value 25\n", "init (12, 6, False)\n", "player value 12 | dealer value 20\n", "init (21, 2, True)\n", "init (14, 10, False)\n", "player value 24 | dealer value 20\n", "init (13, 10, False)\n", "player value 23 | dealer value 26\n", "init (16, 10, False)\n", "player value 25 | dealer value 19\n", "init (15, 10, True)\n", "player value 22 | dealer value 20\n", "init (19, 6, False)\n", "player value 29 | dealer value 23\n", "init (16, 8, False)\n", "player value 18 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 26\n", "init (16, 8, False)\n", "player value 23 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (12, 9, False)\n", "player value 12 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 23\n", "init (12, 4, False)\n", "player value 22 | dealer value 17\n", "init (16, 4, False)\n", "player value 21 | dealer value 21\n", "init (20, 9, True)\n", "player value 20 | dealer value 26\n", "init (12, 2, False)\n", "player value 21 | dealer value 22\n", "init (11, 2, False)\n", "player value 24 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 20\n", "init (13, 2, False)\n", "player value 17 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 10, False)\n", "player value 24 | dealer value 26\n", "init (10, 7, False)\n", "player value 20 | dealer value 25\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (14, 10, False)\n", "player value 14 | dealer value 17\n", "init (15, 10, False)\n", "player value 19 | dealer value 22\n", "init (17, 5, False)\n", "player value 24 | dealer value 18\n", "init (19, 2, False)\n", "player value 19 | dealer value 26\n", "init (14, 3, False)\n", "player value 14 | dealer value 23\n", "init (18, 5, False)\n", "player value 18 | dealer value 22\n", "init (16, 2, False)\n", "player value 16 | dealer value 20\n", "init (14, 2, False)\n", "player value 24 | dealer value 26\n", "init (9, 3, False)\n", "player value 14 | dealer value 23\n", "init (14, 5, False)\n", "player value 14 | dealer value 21\n", "init (11, 10, False)\n", "player value 22 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 26\n", "init (20, 10, False)\n", "player value 23 | dealer value 22\n", "init (16, 6, False)\n", "player value 16 | dealer value 20\n", "init (12, 10, False)\n", "player value 24 | dealer value 19\n", "init (17, 5, False)\n", "player value 27 | dealer value 24\n", "init (16, 10, False)\n", "player value 25 | dealer value 22\n", "init (13, 6, False)\n", "player value 21 | dealer value 20\n", "init (14, 4, False)\n", "player value 27 | dealer value 20\n", "init (14, 9, False)\n", "player value 14 | dealer value 18\n", "init (17, 9, True)\n", "player value 22 | dealer value 21\n", "init (9, 10, False)\n", "player value 15 | dealer value 24\n", "init (14, 8, False)\n", "player value 24 | dealer value 22\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (14, 3, False)\n", "player value 14 | dealer value 21\n", "init (11, 10, False)\n", "player value 21 | dealer value 21\n", "init (18, 8, False)\n", "player value 27 | dealer value 24\n", "init (20, 6, False)\n", "player value 20 | dealer value 22\n", "init (14, 7, False)\n", "player value 26 | dealer value 17\n", "init (19, 3, True)\n", "player value 19 | dealer value 17\n", "init (16, 2, False)\n", "player value 16 | dealer value 17\n", "init (18, 5, False)\n", "player value 28 | dealer value 18\n", "init (19, 10, False)\n", "player value 22 | dealer value 17\n", "init (13, 9, False)\n", "player value 25 | dealer value 18\n", "init (20, 8, False)\n", "player value 20 | dealer value 20\n", "init (16, 9, False)\n", "player value 21 | dealer value 19\n", "init (16, 5, False)\n", "player value 16 | dealer value 25\n", "init (15, 3, False)\n", "player value 20 | dealer value 23\n", "init (14, 3, True)\n", "player value 21 | dealer value 17\n", "init (17, 10, False)\n", "player value 20 | dealer value 22\n", "init (15, 2, False)\n", "player value 15 | dealer value 22\n", "init (20, 3, False)\n", "player value 20 | dealer value 23\n", "init (12, 6, False)\n", "player value 12 | dealer value 17\n", "init (15, 10, False)\n", "player value 15 | dealer value 23\n", "init (13, 1, False)\n", "player value 23 | dealer value 18\n", "init (5, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 10, True)\n", "player value 15 | dealer value 19\n", "init (14, 10, False)\n", "player value 26 | dealer value 20\n", "init (21, 8, True)\n", "init (21, 8, True)\n", "init (21, 10, True)\n", "init (21, 10, True)\n", "init (16, 6, False)\n", "player value 16 | dealer value 18\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (17, 10, False)\n", "player value 20 | dealer value 17\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n", "init (15, 10, True)\n", "player value 15 | dealer value 20\n", "init (17, 3, False)\n", "player value 23 | dealer value 19\n", "init (17, 7, False)\n", "player value 17 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 21\n", "init (20, 7, False)\n", "player value 20 | dealer value 18\n", "init (14, 4, False)\n", "player value 24 | dealer value 18\n", "init (14, 1, False)\n", "player value 23 | dealer value 20\n", "init (10, 1, False)\n", "player value 21 | dealer value 17\n", "init (10, 10, False)\n", "player value 15 | dealer value 26\n", "init (14, 9, False)\n", "player value 22 | dealer value 17\n", "init (12, 9, False)\n", "player value 28 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (19, 1, True)\n", "player value 24 | dealer value 18\n", "init (16, 1, False)\n", "player value 18 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (6, 10, False)\n", "player value 21 | dealer value 20\n", "init (14, 5, False)\n", "player value 14 | dealer value 25\n", "init (8, 2, False)\n", "player value 18 | dealer value 22\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 1, False)\n", "player value 18 | dealer value 20\n", "init (18, 2, False)\n", "player value 18 | dealer value 20\n", "init (15, 2, False)\n", "player value 25 | dealer value 23\n", "init (13, 5, False)\n", "player value 19 | dealer value 24\n", "init (13, 7, False)\n", "player value 13 | dealer value 18\n", "init (13, 10, False)\n", "player value 23 | dealer value 23\n", "init (19, 2, True)\n", "player value 19 | dealer value 24\n", "init (15, 7, False)\n", "player value 25 | dealer value 21\n", "init (11, 4, False)\n", "player value 25 | dealer value 19\n", "init (16, 9, False)\n", "player value 18 | dealer value 18\n", "init (13, 3, False)\n", "player value 23 | dealer value 24\n", "init (16, 6, False)\n", "player value 16 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (13, 4, False)\n", "player value 23 | dealer value 20\n", "init (20, 10, False)\n", "player value 22 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 26\n", "init (12, 2, False)\n", "player value 21 | dealer value 24\n", "init (17, 9, True)\n", "player value 19 | dealer value 18\n", "init (12, 9, False)\n", "player value 21 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 26\n", "init (15, 10, False)\n", "player value 15 | dealer value 23\n", "init (14, 10, True)\n", "player value 21 | dealer value 20\n", "init (20, 10, False)\n", "player value 30 | dealer value 19\n", "init (12, 1, False)\n", "player value 24 | dealer value 17\n", "init (13, 8, False)\n", "player value 23 | dealer value 17\n", "init (16, 10, False)\n", "player value 23 | dealer value 17\n", "init (20, 1, False)\n", "init (5, 6, False)\n", "player value 29 | dealer value 17\n", "init (14, 2, False)\n", "player value 14 | dealer value 23\n", "init (18, 9, False)\n", "player value 18 | dealer value 25\n", "init (18, 2, False)\n", "player value 18 | dealer value 20\n", "init (5, 5, False)\n", "player value 14 | dealer value 24\n", "init (16, 1, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (13, 8, False)\n", "player value 22 | dealer value 18\n", "init (6, 3, False)\n", "player value 19 | dealer value 22\n", "init (9, 2, False)\n", "player value 21 | dealer value 19\n", "init (13, 2, False)\n", "player value 24 | dealer value 26\n", "init (21, 10, True)\n", "init (4, 10, False)\n", "init (15, 8, False)\n", "player value 24 | dealer value 18\n", "init (10, 10, False)\n", "player value 20 | dealer value 17\n", "init (11, 10, False)\n", "player value 15 | dealer value 17\n", "init (11, 10, False)\n", "player value 19 | dealer value 20\n", "init (11, 2, False)\n", "player value 21 | dealer value 22\n", "init (12, 4, False)\n", "player value 20 | dealer value 19\n", "init (19, 10, False)\n", "init (20, 6, False)\n", "player value 20 | dealer value 17\n", "init (11, 8, False)\n", "player value 27 | dealer value 17\n", "init (13, 1, False)\n", "init (19, 7, False)\n", "player value 19 | dealer value 23\n", "init (17, 7, False)\n", "player value 17 | dealer value 19\n", "init (16, 1, True)\n", "player value 18 | dealer value 19\n", "init (6, 5, False)\n", "player value 20 | dealer value 20\n", "init (20, 2, False)\n", "player value 20 | dealer value 26\n", "init (15, 5, False)\n", "player value 15 | dealer value 24\n", "init (8, 1, False)\n", "player value 29 | dealer value 20\n", "init (9, 3, False)\n", "player value 16 | dealer value 21\n", "init (9, 4, False)\n", "player value 23 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 21\n", "init (13, 7, False)\n", "player value 13 | dealer value 17\n", "init (13, 9, True)\n", "player value 19 | dealer value 17\n", "round 9000\n", "init (16, 8, False)\n", "player value 16 | dealer value 18\n", "init (20, 8, True)\n", "player value 20 | dealer value 17\n", "init (13, 4, True)\n", "player value 16 | dealer value 26\n", "init (12, 8, False)\n", "player value 22 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 25\n", "init (7, 6, False)\n", "player value 14 | dealer value 21\n", "init (16, 2, False)\n", "player value 16 | dealer value 21\n", "init (20, 8, False)\n", "player value 20 | dealer value 17\n", "init (14, 1, False)\n", "init (17, 1, False)\n", "player value 17 | dealer value 23\n", "init (8, 7, False)\n", "player value 17 | dealer value 18\n", "init (17, 8, False)\n", "player value 23 | dealer value 21\n", "init (4, 3, False)\n", "player value 19 | dealer value 21\n", "init (20, 10, True)\n", "player value 20 | dealer value 23\n", "init (8, 10, False)\n", "player value 18 | dealer value 22\n", "init (17, 10, True)\n", "player value 15 | dealer value 20\n", "init (18, 9, True)\n", "player value 18 | dealer value 18\n", "init (10, 4, False)\n", "player value 25 | dealer value 18\n", "init (17, 1, False)\n", "player value 17 | dealer value 19\n", "init (20, 6, False)\n", "player value 20 | dealer value 20\n", "init (10, 3, False)\n", "player value 17 | dealer value 26\n", "init (7, 10, False)\n", "player value 22 | dealer value 24\n", "init (13, 10, True)\n", "player value 23 | dealer value 20\n", "init (19, 8, True)\n", "player value 19 | dealer value 20\n", "init (14, 8, False)\n", "player value 20 | dealer value 19\n", "init (16, 10, True)\n", "player value 26 | dealer value 19\n", "init (12, 5, False)\n", "player value 20 | dealer value 20\n", "init (7, 4, False)\n", "player value 16 | dealer value 19\n", "init (12, 7, False)\n", "player value 13 | dealer value 18\n", "init (17, 1, False)\n", "player value 17 | dealer value 24\n", "init (19, 5, False)\n", "player value 19 | dealer value 21\n", "init (10, 8, False)\n", "player value 22 | dealer value 17\n", "init (10, 3, False)\n", "player value 20 | dealer value 17\n", "init (17, 8, False)\n", "player value 21 | dealer value 20\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (10, 8, False)\n", "player value 20 | dealer value 18\n", "init (21, 10, True)\n", "init (13, 7, False)\n", "player value 13 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (10, 10, False)\n", "player value 30 | dealer value 20\n", "init (8, 8, False)\n", "player value 18 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 19\n", "init (10, 4, False)\n", "player value 20 | dealer value 25\n", "init (14, 1, True)\n", "player value 14 | dealer value 26\n", "init (10, 3, False)\n", "player value 14 | dealer value 23\n", "init (20, 4, True)\n", "player value 20 | dealer value 24\n", "init (20, 1, False)\n", "player value 27 | dealer value 18\n", "init (16, 1, True)\n", "player value 26 | dealer value 22\n", "init (15, 5, False)\n", "player value 15 | dealer value 17\n", "init (15, 5, True)\n", "player value 19 | dealer value 18\n", "init (16, 4, False)\n", "player value 19 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 4, False)\n", "player value 20 | dealer value 23\n", "init (15, 3, False)\n", "player value 25 | dealer value 19\n", "init (11, 7, False)\n", "player value 21 | dealer value 17\n", "init (7, 10, False)\n", "player value 18 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (11, 10, False)\n", "init (14, 6, True)\n", "player value 14 | dealer value 21\n", "init (14, 3, False)\n", "player value 24 | dealer value 22\n", "init (16, 10, False)\n", "player value 25 | dealer value 20\n", "init (14, 10, False)\n", "player value 14 | dealer value 17\n", "init (9, 5, False)\n", "player value 19 | dealer value 18\n", "init (9, 10, False)\n", "player value 13 | dealer value 18\n", "init (14, 5, False)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "player value 14 | dealer value 23\n", "init (13, 5, False)\n", "player value 25 | dealer value 22\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (17, 1, True)\n", "player value 25 | dealer value 19\n", "init (18, 2, False)\n", "player value 18 | dealer value 23\n", "init (14, 8, False)\n", "player value 18 | dealer value 18\n", "init (18, 8, False)\n", "player value 18 | dealer value 21\n", "init (13, 10, False)\n", "init (11, 7, False)\n", "player value 19 | dealer value 21\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (15, 3, False)\n", "player value 25 | dealer value 21\n", "init (15, 3, False)\n", "player value 24 | dealer value 26\n", "init (17, 10, False)\n", "player value 24 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (17, 1, True)\n", "player value 17 | dealer value 20\n", "init (11, 3, False)\n", "player value 23 | dealer value 23\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (13, 3, False)\n", "player value 21 | dealer value 17\n", "init (8, 7, False)\n", "player value 25 | dealer value 23\n", "init (8, 2, False)\n", "player value 15 | dealer value 17\n", "init (10, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 26\n", "init (18, 2, False)\n", "player value 20 | dealer value 17\n", "init (14, 9, False)\n", "player value 24 | dealer value 19\n", "init (10, 1, False)\n", "init (16, 9, False)\n", "player value 20 | dealer value 26\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (9, 3, False)\n", "player value 16 | dealer value 21\n", "init (12, 10, False)\n", "init (15, 6, False)\n", "player value 23 | dealer value 26\n", "init (16, 10, False)\n", "player value 21 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 19\n", "init (7, 10, False)\n", "player value 21 | dealer value 26\n", "init (10, 8, False)\n", "player value 22 | dealer value 22\n", "init (17, 9, False)\n", "player value 26 | dealer value 24\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (10, 8, False)\n", "player value 25 | dealer value 18\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 25\n", "init (20, 10, True)\n", "player value 20 | dealer value 25\n", "init (6, 10, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 29 | dealer value 17\n", "init (14, 2, True)\n", "player value 17 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 20\n", "init (14, 2, False)\n", "player value 18 | dealer value 22\n", "init (20, 4, False)\n", "player value 26 | dealer value 22\n", "init (13, 8, True)\n", "player value 13 | dealer value 18\n", "init (17, 1, False)\n", "init (20, 10, False)\n", "player value 20 | dealer value 19\n", "init (14, 8, False)\n", "player value 14 | dealer value 17\n", "init (20, 9, False)\n", "player value 20 | dealer value 26\n", "init (16, 10, True)\n", "init (12, 1, False)\n", "player value 12 | dealer value 20\n", "init (18, 10, True)\n", "player value 19 | dealer value 20\n", "init (21, 10, True)\n", "init (5, 7, False)\n", "player value 19 | dealer value 19\n", "init (14, 3, False)\n", "player value 14 | dealer value 22\n", "init (12, 5, False)\n", "player value 12 | dealer value 25\n", "init (13, 9, False)\n", "player value 23 | dealer value 24\n", "init (10, 10, False)\n", "player value 13 | dealer value 20\n", "init (21, 3, True)\n", "init (13, 7, False)\n", "player value 23 | dealer value 21\n", "init (15, 4, False)\n", "player value 16 | dealer value 17\n", "init (9, 8, False)\n", "player value 22 | dealer value 18\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (21, 7, True)\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (5, 2, False)\n", "player value 18 | dealer value 19\n", "init (16, 9, False)\n", "player value 18 | dealer value 20\n", "init (12, 8, False)\n", "player value 15 | dealer value 18\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (21, 10, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 17\n", "init (5, 9, False)\n", "player value 16 | dealer value 19\n", "init (21, 10, True)\n", "init (14, 7, False)\n", "player value 24 | dealer value 25\n", "init (11, 10, False)\n", "player value 21 | dealer value 25\n", "init (13, 1, True)\n", "player value 13 | dealer value 19\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (18, 4, False)\n", "player value 18 | dealer value 23\n", "init (17, 5, False)\n", "player value 22 | dealer value 21\n", "init (12, 3, False)\n", "player value 18 | dealer value 24\n", "init (8, 6, False)\n", "player value 15 | dealer value 26\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 21\n", "init (12, 7, False)\n", "player value 19 | dealer value 25\n", "init (13, 7, False)\n", "player value 13 | dealer value 18\n", "init (10, 10, False)\n", "init (13, 1, False)\n", "player value 13 | dealer value 24\n", "init (10, 10, False)\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (13, 3, False)\n", "player value 16 | dealer value 23\n", "init (19, 9, False)\n", "player value 19 | dealer value 20\n", "init (15, 8, False)\n", "player value 20 | dealer value 18\n", "init (6, 4, False)\n", "player value 13 | dealer value 18\n", "init (13, 10, False)\n", "player value 20 | dealer value 19\n", "init (7, 4, False)\n", "player value 19 | dealer value 23\n", "init (12, 3, False)\n", "player value 22 | dealer value 17\n", "init (18, 8, False)\n", "player value 18 | dealer value 22\n", "init (17, 9, False)\n", "player value 18 | dealer value 25\n", "init (7, 2, False)\n", "player value 16 | dealer value 20\n", "init (21, 5, True)\n", "init (8, 9, False)\n", "player value 22 | dealer value 18\n", "init (6, 2, False)\n", "player value 22 | dealer value 17\n", "init (16, 1, True)\n", "player value 20 | dealer value 17\n", "init (9, 8, False)\n", "player value 23 | dealer value 18\n", "init (12, 10, False)\n", "player value 21 | dealer value 21\n", "init (10, 6, False)\n", "player value 21 | dealer value 23\n", "init (13, 1, True)\n", "player value 19 | dealer value 19\n", "init (8, 2, False)\n", "player value 16 | dealer value 21\n", "init (13, 7, False)\n", "player value 23 | dealer value 17\n", "init (16, 1, False)\n", "player value 20 | dealer value 17\n", "init (14, 1, False)\n", "player value 17 | dealer value 17\n", "init (12, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "player value 27 | dealer value 18\n", "init (13, 1, False)\n", "player value 21 | dealer value 18\n", "init (15, 2, True)\n", "player value 15 | dealer value 22\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (18, 8, False)\n", "player value 18 | dealer value 19\n", "init (17, 3, False)\n", "player value 27 | dealer value 20\n", "init (12, 9, True)\n", "player value 27 | dealer value 19\n", "init (16, 3, False)\n", "player value 16 | dealer value 24\n", "init (11, 10, False)\n", "player value 16 | dealer value 19\n", "init (17, 7, True)\n", "player value 17 | dealer value 21\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (11, 10, False)\n", "player value 18 | dealer value 19\n", "init (10, 5, False)\n", "player value 13 | dealer value 18\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (15, 10, False)\n", "player value 24 | dealer value 19\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (16, 2, False)\n", "player value 26 | dealer value 22\n", "init (11, 10, False)\n", "player value 21 | dealer value 25\n", "init (16, 10, True)\n", "player value 16 | dealer value 17\n", "init (15, 8, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (14, 10, True)\n", "player value 25 | dealer value 23\n", "init (17, 1, False)\n", "player value 17 | dealer value 18\n", "init (6, 7, False)\n", "player value 17 | dealer value 21\n", "init (11, 5, False)\n", "player value 18 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 25\n", "init (11, 3, False)\n", "player value 14 | dealer value 18\n", "init (13, 10, False)\n", "player value 27 | dealer value 17\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (16, 2, False)\n", "player value 16 | dealer value 21\n", "init (14, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 9, False)\n", "player value 22 | dealer value 20\n", "init (16, 6, False)\n", "player value 16 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 26\n", "init (15, 10, True)\n", "player value 15 | dealer value 20\n", "init (20, 2, True)\n", "player value 19 | dealer value 26\n", "init (15, 6, False)\n", "player value 17 | dealer value 18\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 2, False)\n", "player value 17 | dealer value 20\n", "init (17, 10, False)\n", "player value 22 | dealer value 20\n", "init (21, 8, True)\n", "init (10, 6, False)\n", "player value 25 | dealer value 17\n", "init (8, 6, False)\n", "player value 16 | dealer value 26\n", "init (14, 2, False)\n", "player value 24 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 17\n", "init (17, 10, False)\n", "player value 25 | dealer value 20\n", "init (13, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (15, 7, False)\n", "player value 25 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 22\n", "init (9, 5, False)\n", "player value 21 | dealer value 17\n", "init (15, 8, False)\n", "player value 15 | dealer value 23\n", "init (20, 1, False)\n", "player value 25 | dealer value 18\n", "init (9, 8, False)\n", "player value 23 | dealer value 23\n", "init (12, 9, False)\n", "player value 19 | dealer value 25\n", "init (21, 10, True)\n", "init (16, 2, False)\n", "player value 21 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (12, 8, False)\n", "player value 18 | dealer value 17\n", "init (8, 5, False)\n", "player value 25 | dealer value 17\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (12, 4, False)\n", "player value 12 | dealer value 20\n", "init (15, 3, False)\n", "player value 23 | dealer value 18\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (10, 1, False)\n", "player value 25 | dealer value 19\n", "init (10, 10, False)\n", "player value 21 | dealer value 20\n", "init (12, 5, False)\n", "player value 12 | dealer value 22\n", "init (8, 4, False)\n", "player value 18 | dealer value 22\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (12, 7, False)\n", "player value 12 | dealer value 23\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (21, 8, True)\n", "init (20, 5, True)\n", "player value 20 | dealer value 26\n", "init (16, 3, False)\n", "player value 16 | dealer value 21\n", "init (17, 3, False)\n", "player value 27 | dealer value 21\n", "init (11, 10, False)\n", "player value 17 | dealer value 20\n", "init (15, 10, False)\n", "player value 25 | dealer value 18\n", "init (9, 3, False)\n", "player value 23 | dealer value 24\n", "init (19, 4, False)\n", "player value 19 | dealer value 22\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (18, 5, True)\n", "player value 20 | dealer value 25\n", "init (17, 10, True)\n", "player value 24 | dealer value 25\n", "init (13, 8, False)\n", "player value 23 | dealer value 22\n", "init (15, 1, False)\n", "player value 22 | dealer value 17\n", "init (19, 1, False)\n", "player value 19 | dealer value 21\n", "init (13, 8, False)\n", "player value 13 | dealer value 20\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (12, 3, False)\n", "player value 22 | dealer value 24\n", "init (17, 6, False)\n", "player value 17 | dealer value 21\n", "init (14, 3, False)\n", "player value 14 | dealer value 18\n", "init (14, 9, False)\n", "player value 24 | dealer value 21\n", "init (17, 2, False)\n", "player value 17 | dealer value 24\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (9, 3, False)\n", "player value 19 | dealer value 21\n", "init (14, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 25\n", "init (13, 10, False)\n", "player value 23 | dealer value 17\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (19, 4, False)\n", "player value 19 | dealer value 25\n", "init (14, 5, False)\n", "player value 14 | dealer value 26\n", "init (17, 10, False)\n", "player value 27 | dealer value 23\n", "init (18, 6, False)\n", "player value 18 | dealer value 25\n", "init (12, 5, False)\n", "player value 12 | dealer value 17\n", "init (18, 1, False)\n", "init (14, 2, False)\n", "player value 21 | dealer value 22\n", "init (12, 3, False)\n", "player value 19 | dealer value 19\n", "init (10, 10, False)\n", "player value 20 | dealer value 20\n", "init (7, 8, False)\n", "player value 22 | dealer value 18\n", "init (12, 5, True)\n", "player value 19 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 22\n", "init (10, 4, False)\n", "player value 27 | dealer value 24\n", "init (15, 8, False)\n", "player value 19 | dealer value 26\n", "init (15, 6, True)\n", "player value 18 | dealer value 17\n", "init (12, 6, False)\n", "player value 12 | dealer value 18\n", "init (10, 3, False)\n", "player value 17 | dealer value 23\n", "init (20, 10, False)\n", "player value 24 | dealer value 23\n", "init (6, 8, False)\n", "player value 26 | dealer value 22\n", "init (14, 3, False)\n", "player value 14 | dealer value 25\n", "init (6, 9, False)\n", "player value 22 | dealer value 19\n", "init (15, 2, True)\n", "player value 23 | dealer value 20\n", "init (12, 4, False)\n", "player value 26 | dealer value 23\n", "init (20, 8, False)\n", "player value 20 | dealer value 23\n", "init (7, 10, False)\n", "player value 22 | dealer value 22\n", "init (11, 7, False)\n", "player value 19 | dealer value 26\n", "init (19, 10, False)\n", "player value 19 | dealer value 24\n", "init (12, 7, False)\n", "player value 12 | dealer value 20\n", "init (16, 3, False)\n", "player value 16 | dealer value 24\n", "init (18, 2, False)\n", "player value 18 | dealer value 18\n", "init (19, 2, True)\n", "player value 19 | dealer value 19\n", "init (14, 10, False)\n", "player value 25 | dealer value 21\n", "init (16, 1, True)\n", "player value 19 | dealer value 19\n", "init (14, 1, False)\n", "player value 20 | dealer value 22\n", "init (12, 8, False)\n", "player value 22 | dealer value 18\n", "init (15, 10, False)\n", "player value 25 | dealer value 19\n", "init (13, 4, False)\n", "player value 23 | dealer value 19\n", "init (13, 10, False)\n", "player value 19 | dealer value 20\n", "init (16, 4, False)\n", "player value 26 | dealer value 24\n", "init (7, 4, False)\n", "player value 24 | dealer value 19\n", "init (8, 6, False)\n", "player value 25 | dealer value 18\n", "init (17, 7, True)\n", "player value 17 | dealer value 17\n", "init (12, 5, False)\n", "player value 12 | dealer value 17\n", "init (11, 9, False)\n", "player value 18 | dealer value 19\n", "init (13, 10, True)\n", "player value 21 | dealer value 19\n", "init (15, 9, False)\n", "player value 25 | dealer value 18\n", "init (7, 9, False)\n", "player value 15 | dealer value 17\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 22\n", "init (10, 10, False)\n", "init (8, 7, False)\n", "player value 24 | dealer value 19\n", "init (14, 8, False)\n", "player value 22 | dealer value 18\n", "init (17, 10, False)\n", "player value 24 | dealer value 17\n", "init (21, 6, True)\n", "init (7, 5, False)\n", "player value 23 | dealer value 20\n", "init (13, 4, False)\n", "player value 13 | dealer value 21\n", "init (7, 7, False)\n", "player value 22 | dealer value 24\n", "init (13, 4, False)\n", "player value 16 | dealer value 20\n", "init (11, 8, False)\n", "player value 14 | dealer value 18\n", "init (14, 1, False)\n", "init (17, 1, False)\n", "init (17, 1, True)\n", "player value 26 | dealer value 18\n", "init (21, 3, True)\n", "init (12, 6, True)\n", "player value 12 | dealer value 24\n", "init (12, 9, False)\n", "player value 27 | dealer value 23\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (11, 4, False)\n", "player value 24 | dealer value 23\n", "init (14, 8, True)\n", "player value 23 | dealer value 22\n", "init (18, 5, False)\n", "player value 26 | dealer value 21\n", "init (7, 10, False)\n", "player value 15 | dealer value 20\n", "init (18, 10, False)\n", "player value 27 | dealer value 21\n", "init (14, 10, True)\n", "player value 21 | dealer value 20\n", "init (11, 1, False)\n", "init (13, 8, False)\n", "player value 19 | dealer value 19\n", "init (18, 3, False)\n", "player value 18 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (12, 3, False)\n", "player value 18 | dealer value 19\n", "init (20, 3, False)\n", "player value 20 | dealer value 21\n", "init (6, 5, False)\n", "player value 18 | dealer value 25\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (11, 6, False)\n", "player value 21 | dealer value 19\n", "init (17, 5, False)\n", "player value 17 | dealer value 25\n", "init (9, 6, False)\n", "player value 19 | dealer value 25\n", "init (14, 6, False)\n", "player value 14 | dealer value 26\n", "init (20, 8, False)\n", "player value 20 | dealer value 19\n", "init (12, 4, False)\n", "player value 22 | dealer value 23\n", "init (13, 9, False)\n", "player value 18 | dealer value 23\n", "init (20, 2, False)\n", "player value 20 | dealer value 18\n", "init (12, 2, True)\n", "player value 26 | dealer value 19\n", "init (9, 10, False)\n", "player value 19 | dealer value 20\n", "init (14, 6, False)\n", "player value 14 | dealer value 20\n", "init (16, 10, False)\n", "player value 16 | dealer value 18\n", "init (21, 10, True)\n", "init (17, 10, False)\n", "player value 17 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 20\n", "init (15, 5, False)\n", "player value 15 | dealer value 18\n", "init (18, 10, False)\n", "init (13, 5, False)\n", "player value 22 | dealer value 24\n", "init (11, 10, False)\n", "player value 17 | dealer value 20\n", "init (20, 1, False)\n", "player value 20 | dealer value 25\n", "init (21, 8, True)\n", "init (8, 1, False)\n", "init (19, 5, False)\n", "player value 26 | dealer value 19\n", "init (16, 8, False)\n", "player value 23 | dealer value 18\n", "init (15, 6, False)\n", "player value 22 | dealer value 17\n", "init (12, 10, False)\n", "player value 19 | dealer value 24\n", "init (20, 2, False)\n", "player value 20 | dealer value 24\n", "init (14, 7, False)\n", "player value 24 | dealer value 17\n", "init (16, 2, False)\n", "player value 18 | dealer value 20\n", "init (7, 6, False)\n", "player value 17 | dealer value 22\n", "init (10, 10, False)\n", "player value 20 | dealer value 17\n", "init (18, 4, False)\n", "player value 18 | dealer value 19\n", "init (16, 7, False)\n", "player value 26 | dealer value 18\n", "init (13, 4, False)\n", "player value 22 | dealer value 24\n", "init (18, 10, True)\n", "player value 22 | dealer value 18\n", "init (20, 2, True)\n", "player value 22 | dealer value 17\n", "init (19, 8, False)\n", "player value 19 | dealer value 26\n", "init (19, 5, False)\n", "player value 19 | dealer value 20\n", "init (20, 7, False)\n", "player value 20 | dealer value 17\n", "init (6, 1, False)\n", "player value 21 | dealer value 18\n", "init (14, 8, False)\n", "player value 19 | dealer value 22\n", "init (12, 3, False)\n", "player value 22 | dealer value 20\n", "init (12, 10, False)\n", "player value 19 | dealer value 22\n", "init (16, 5, False)\n", "player value 16 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (21, 2, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 17\n", "init (16, 3, False)\n", "player value 17 | dealer value 17\n", "init (16, 10, False)\n", "player value 22 | dealer value 18\n", "init (5, 10, False)\n", "player value 24 | dealer value 20\n", "init (14, 7, False)\n", "player value 23 | dealer value 25\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (14, 7, False)\n", "player value 24 | dealer value 20\n", "init (12, 2, False)\n", "player value 22 | dealer value 19\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (15, 6, False)\n", "player value 19 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (15, 5, False)\n", "player value 25 | dealer value 23\n", "init (15, 9, False)\n", "player value 24 | dealer value 18\n", "init (20, 9, False)\n", "player value 22 | dealer value 20\n", "init (15, 9, False)\n", "player value 29 | dealer value 20\n", "init (13, 7, False)\n", "player value 17 | dealer value 26\n", "init (17, 7, False)\n", "player value 17 | dealer value 17\n", "init (9, 1, False)\n", "player value 17 | dealer value 17\n", "init (15, 3, False)\n", "player value 17 | dealer value 17\n", "init (11, 5, False)\n", "player value 18 | dealer value 24\n", "init (9, 2, False)\n", "player value 19 | dealer value 23\n", "init (15, 8, False)\n", "player value 25 | dealer value 18\n", "init (16, 9, False)\n", "player value 16 | dealer value 19\n", "init (7, 8, False)\n", "player value 22 | dealer value 22\n", "init (6, 5, False)\n", "player value 17 | dealer value 22\n", "init (20, 2, False)\n", "player value 20 | dealer value 20\n", "init (11, 10, False)\n", "player value 18 | dealer value 20\n", "init (19, 7, True)\n", "player value 19 | dealer value 23\n", "init (15, 9, True)\n", "player value 21 | dealer value 20\n", "init (13, 10, True)\n", "player value 24 | dealer value 20\n", "init (17, 10, False)\n", "player value 27 | dealer value 25\n", "init (14, 6, False)\n", "player value 14 | dealer value 18\n", "init (14, 6, False)\n", "player value 21 | dealer value 17\n", "init (11, 7, False)\n", "player value 25 | dealer value 17\n", "init (18, 6, False)\n", "player value 18 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (12, 2, False)\n", "player value 26 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 20\n", "init (15, 6, False)\n", "player value 25 | dealer value 22\n", "init (15, 4, False)\n", "player value 17 | dealer value 18\n", "init (9, 5, False)\n", "player value 19 | dealer value 17\n", "init (15, 4, False)\n", "player value 18 | dealer value 21\n", "init (14, 10, False)\n", "player value 14 | dealer value 20\n", "init (20, 6, False)\n", "player value 20 | dealer value 21\n", "init (12, 5, False)\n", "player value 12 | dealer value 23\n", "init (9, 5, False)\n", "player value 19 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 21\n", "init (18, 7, False)\n", "player value 18 | dealer value 23\n", "init (8, 10, False)\n", "player value 27 | dealer value 19\n", "init (8, 5, False)\n", "player value 18 | dealer value 20\n", "init (10, 5, False)\n", "player value 16 | dealer value 18\n", "init (19, 8, True)\n", "player value 19 | dealer value 20\n", "init (13, 6, False)\n", "player value 22 | dealer value 21\n", "init (16, 10, False)\n", "init (18, 3, False)\n", "player value 18 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (10, 10, False)\n", "player value 23 | dealer value 20\n", "init (15, 5, False)\n", "player value 16 | dealer value 20\n", "init (16, 6, False)\n", "player value 16 | dealer value 19\n", "init (15, 7, False)\n", "player value 21 | dealer value 20\n", "init (8, 7, False)\n", "player value 18 | dealer value 20\n", "init (8, 10, False)\n", "player value 18 | dealer value 17\n", "init (17, 4, False)\n", "player value 23 | dealer value 18\n", "init (20, 4, False)\n", "player value 20 | dealer value 24\n", "init (11, 1, False)\n", "player value 21 | dealer value 18\n", "init (8, 2, False)\n", "player value 17 | dealer value 21\n", "init (12, 3, True)\n", "player value 17 | dealer value 26\n", "init (18, 6, False)\n", "player value 18 | dealer value 26\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (17, 10, True)\n", "init (7, 6, False)\n", "player value 18 | dealer value 21\n", "init (14, 10, False)\n", "player value 20 | dealer value 19\n", "init (11, 1, False)\n", "player value 20 | dealer value 19\n", "init (15, 9, False)\n", "player value 22 | dealer value 25\n", "init (18, 10, False)\n", "player value 25 | dealer value 17\n", "init (15, 4, True)\n", "player value 18 | dealer value 20\n", "init (11, 6, False)\n", "player value 21 | dealer value 18\n", "init (15, 10, False)\n", "player value 24 | dealer value 18\n", "init (21, 10, True)\n", "init (15, 4, False)\n", "player value 15 | dealer value 24\n", "init (12, 8, False)\n", "player value 22 | dealer value 23\n", "init (11, 8, False)\n", "player value 21 | dealer value 17\n", "init (20, 5, False)\n", "player value 20 | dealer value 21\n", "init (21, 3, True)\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (16, 8, True)\n", "player value 19 | dealer value 26\n", "init (20, 6, False)\n", "player value 20 | dealer value 25\n", "init (18, 5, True)\n", "player value 21 | dealer value 21\n", "init (18, 6, False)\n", "player value 28 | dealer value 19\n", "init (14, 7, False)\n", "player value 14 | dealer value 17\n", "init (12, 4, False)\n", "player value 18 | dealer value 23\n", "init (15, 6, False)\n", "player value 21 | dealer value 24\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (20, 8, False)\n", "player value 20 | dealer value 18\n", "init (13, 6, False)\n", "player value 13 | dealer value 24\n", "init (18, 10, True)\n", "player value 26 | dealer value 20\n", "init (16, 1, False)\n", "player value 23 | dealer value 17\n", "init (11, 6, False)\n", "player value 21 | dealer value 18\n", "init (10, 10, False)\n", "player value 22 | dealer value 20\n", "init (14, 1, False)\n", "player value 20 | dealer value 18\n", "init (13, 2, False)\n", "player value 17 | dealer value 25\n", "init (15, 1, False)\n", "init (13, 3, False)\n", "player value 14 | dealer value 21\n", "init (13, 8, False)\n", "player value 14 | dealer value 18\n", "init (13, 8, False)\n", "player value 22 | dealer value 18\n", "init (17, 10, False)\n", "player value 27 | dealer value 23\n", "init (21, 10, True)\n", "init (12, 3, False)\n", "player value 13 | dealer value 18\n", "init (15, 10, True)\n", "player value 15 | dealer value 20\n", "init (10, 2, False)\n", "player value 20 | dealer value 26\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (15, 3, True)\n", "player value 15 | dealer value 17\n", "init (17, 1, False)\n", "init (7, 3, False)\n", "player value 16 | dealer value 17\n", "init (12, 1, False)\n", "player value 25 | dealer value 18\n", "init (15, 10, False)\n", "player value 23 | dealer value 20\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (8, 10, False)\n", "player value 23 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 21\n", "init (20, 2, True)\n", "player value 23 | dealer value 19\n", "init (13, 1, False)\n", "player value 21 | dealer value 21\n", "init (21, 7, True)\n", "init (20, 8, False)\n", "player value 20 | dealer value 21\n", "init (20, 8, False)\n", "player value 20 | dealer value 25\n", "init (8, 2, False)\n", "player value 27 | dealer value 22\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (19, 6, False)\n", "player value 19 | dealer value 17\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (13, 4, False)\n", "player value 24 | dealer value 17\n", "init (10, 4, False)\n", "player value 27 | dealer value 20\n", "init (10, 10, False)\n", "player value 24 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 19\n", "init (13, 8, False)\n", "player value 23 | dealer value 20\n", "init (16, 10, False)\n", "player value 24 | dealer value 20\n", "init (21, 6, True)\n", "init (12, 6, False)\n", "player value 12 | dealer value 24\n", "init (21, 10, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (10, 10, False)\n", "player value 20 | dealer value 18\n", "init (8, 6, False)\n", "player value 18 | dealer value 20\n", "init (10, 2, False)\n", "player value 20 | dealer value 19\n", "init (10, 4, False)\n", "player value 13 | dealer value 26\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 5, False)\n", "player value 30 | dealer value 21\n", "init (9, 7, False)\n", "player value 20 | dealer value 18\n", "init (16, 10, True)\n", "player value 16 | dealer value 20\n", "init (10, 10, False)\n", "player value 17 | dealer value 24\n", "init (4, 7, False)\n", "player value 18 | dealer value 18\n", "init (17, 10, False)\n", "player value 26 | dealer value 21\n", "init (13, 10, False)\n", "player value 27 | dealer value 20\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (4, 9, False)\n", "player value 22 | dealer value 24\n", "init (13, 10, False)\n", "player value 25 | dealer value 20\n", "init (11, 2, False)\n", "player value 23 | dealer value 20\n", "init (19, 8, False)\n", "player value 19 | dealer value 25\n", "init (20, 10, True)\n", "player value 20 | dealer value 20\n", "init (13, 10, True)\n", "player value 24 | dealer value 19\n", "init (8, 6, False)\n", "player value 12 | dealer value 17\n", "init (12, 1, False)\n", "init (13, 6, False)\n", "player value 13 | dealer value 23\n", "init (13, 8, False)\n", "player value 20 | dealer value 25\n", "init (6, 7, False)\n", "player value 26 | dealer value 18\n", "init (16, 10, True)\n", "player value 27 | dealer value 20\n", "init (9, 3, False)\n", "player value 17 | dealer value 20\n", "init (12, 9, False)\n", "player value 25 | dealer value 22\n", "init (14, 7, False)\n", "player value 19 | dealer value 18\n", "init (20, 10, False)\n", "player value 25 | dealer value 23\n", "init (17, 10, False)\n", "player value 25 | dealer value 21\n", "init (15, 10, False)\n", "player value 15 | dealer value 17\n", "init (16, 2, False)\n", "player value 20 | dealer value 23\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "init (14, 2, False)\n", "player value 17 | dealer value 21\n", "init (9, 8, False)\n", "player value 18 | dealer value 19\n", "init (20, 5, False)\n", "player value 20 | dealer value 24\n", "init (11, 10, False)\n", "player value 18 | dealer value 20\n", "init (9, 7, False)\n", "player value 12 | dealer value 20\n", "init (15, 2, False)\n", "player value 25 | dealer value 24\n", "init (12, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 1, True)\n", "init (11, 10, False)\n", "init (16, 4, True)\n", "player value 16 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 17\n", "init (17, 4, False)\n", "player value 17 | dealer value 18\n", "init (11, 2, False)\n", "player value 20 | dealer value 20\n", "init (14, 8, False)\n", "player value 18 | dealer value 22\n", "init (18, 5, True)\n", "player value 23 | dealer value 24\n", "init (18, 4, False)\n", "player value 18 | dealer value 23\n", "init (9, 5, False)\n", "player value 19 | dealer value 20\n", "init (13, 10, False)\n", "player value 26 | dealer value 24\n", "init (20, 1, False)\n", "player value 20 | dealer value 20\n", "init (14, 7, True)\n", "player value 23 | dealer value 23\n", "init (20, 5, False)\n", "player value 20 | dealer value 22\n", "init (15, 3, True)\n", "player value 20 | dealer value 23\n", "init (20, 1, False)\n", "init (20, 5, False)\n", "player value 30 | dealer value 23\n", "init (16, 7, False)\n", "player value 17 | dealer value 26\n", "init (12, 10, False)\n", "player value 19 | dealer value 22\n", "init (16, 10, False)\n", "player value 16 | dealer value 20\n", "init (12, 6, False)\n", "player value 12 | dealer value 19\n", "init (15, 4, False)\n", "player value 25 | dealer value 20\n", "init (20, 10, True)\n", "player value 20 | dealer value 25\n", "init (14, 10, False)\n", "player value 24 | dealer value 19\n", "init (17, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (19, 10, False)\n", "player value 19 | dealer value 18\n", "init (14, 3, False)\n", "player value 30 | dealer value 23\n", "init (17, 8, False)\n", "player value 19 | dealer value 18\n", "init (12, 6, False)\n", "player value 12 | dealer value 21\n", "init (9, 10, False)\n", "player value 27 | dealer value 17\n", "init (15, 1, False)\n", "player value 22 | dealer value 20\n", "init (16, 3, True)\n", "player value 22 | dealer value 26\n", "init (13, 3, False)\n", "player value 20 | dealer value 17\n", "init (20, 10, False)\n", "player value 20 | dealer value 18\n", "init (18, 3, False)\n", "player value 18 | dealer value 21\n", "init (13, 10, False)\n", "player value 21 | dealer value 20\n", "init (21, 5, True)\n", "init (10, 3, False)\n", "player value 14 | dealer value 20\n", "init (9, 6, False)\n", "player value 13 | dealer value 24\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (16, 3, False)\n", "player value 16 | dealer value 23\n", "init (17, 5, False)\n", "player value 17 | dealer value 18\n", "init (12, 10, False)\n", "player value 23 | dealer value 20\n", "init (19, 1, False)\n", "init (16, 8, False)\n", "player value 26 | dealer value 19\n", "init (14, 9, False)\n", "player value 15 | dealer value 19\n", "init (15, 10, True)\n", "player value 21 | dealer value 17\n", "init (15, 3, False)\n", "player value 24 | dealer value 24\n", "init (20, 8, False)\n", "player value 24 | dealer value 22\n", "init (13, 10, False)\n", "player value 23 | dealer value 21\n", "init (14, 10, False)\n", "player value 19 | dealer value 20\n", "init (12, 8, False)\n", "player value 12 | dealer value 18\n", "init (13, 7, False)\n", "player value 13 | dealer value 21\n", "init (11, 9, False)\n", "player value 14 | dealer value 26\n", "init (12, 6, False)\n", "player value 12 | dealer value 17\n", "init (14, 9, False)\n", "player value 14 | dealer value 18\n", "init (12, 2, False)\n", "player value 22 | dealer value 18\n", "init (20, 1, True)\n", "player value 30 | dealer value 18\n", "init (13, 10, False)\n", "player value 26 | dealer value 23\n", "init (16, 2, False)\n", "player value 16 | dealer value 17\n", "init (11, 6, False)\n", "player value 18 | dealer value 19\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (16, 3, False)\n", "player value 16 | dealer value 18\n", "init (11, 9, False)\n", "player value 18 | dealer value 18\n", "init (9, 5, False)\n", "player value 19 | dealer value 25\n", "init (20, 4, False)\n", "player value 20 | dealer value 20\n", "init (16, 10, False)\n", "player value 26 | dealer value 18\n", "init (9, 4, False)\n", "player value 19 | dealer value 19\n", "init (14, 7, False)\n", "player value 24 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (17, 1, False)\n", "init (13, 2, False)\n", "player value 21 | dealer value 17\n", "init (12, 8, False)\n", "player value 19 | dealer value 21\n", "init (15, 3, False)\n", "player value 25 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 19\n", "init (5, 6, False)\n", "player value 18 | dealer value 26\n", "init (12, 10, False)\n", "player value 22 | dealer value 19\n", "init (21, 3, True)\n", "init (14, 10, True)\n", "player value 21 | dealer value 18\n", "init (17, 7, False)\n", "player value 17 | dealer value 22\n", "init (21, 7, True)\n", "init (13, 10, False)\n", "player value 18 | dealer value 18\n", "init (11, 6, False)\n", "player value 21 | dealer value 26\n", "init (16, 10, False)\n", "player value 25 | dealer value 21\n", "init (17, 10, False)\n", "player value 27 | dealer value 18\n", "init (12, 10, True)\n", "player value 12 | dealer value 18\n", "init (14, 2, False)\n", "player value 21 | dealer value 17\n", "init (8, 6, False)\n", "player value 17 | dealer value 21\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (16, 3, False)\n", "player value 16 | dealer value 18\n", "init (15, 8, False)\n", "player value 20 | dealer value 26\n", "init (17, 9, True)\n", "player value 27 | dealer value 19\n", "init (11, 5, False)\n", "player value 16 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 24\n", "init (14, 7, False)\n", "player value 24 | dealer value 19\n", "init (17, 9, False)\n", "player value 27 | dealer value 19\n", "init (15, 3, False)\n", "player value 22 | dealer value 18\n", "init (9, 8, False)\n", "player value 19 | dealer value 19\n", "init (5, 5, False)\n", "player value 14 | dealer value 26\n", "init (15, 5, False)\n", "player value 25 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (11, 7, False)\n", "player value 20 | dealer value 17\n", "init (17, 8, True)\n", "player value 17 | dealer value 17\n", "init (14, 10, True)\n", "player value 17 | dealer value 22\n", "init (19, 7, False)\n", "player value 19 | dealer value 17\n", "init (12, 5, False)\n", "player value 22 | dealer value 19\n", "init (7, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 18\n", "init (14, 4, False)\n", "player value 19 | dealer value 24\n", "init (17, 3, False)\n", "player value 17 | dealer value 20\n", "init (13, 6, False)\n", "player value 13 | dealer value 17\n", "init (15, 2, False)\n", "player value 26 | dealer value 18\n", "init (16, 5, True)\n", "player value 19 | dealer value 18\n", "init (16, 10, False)\n", "player value 25 | dealer value 17\n", "init (21, 10, True)\n", "init (5, 3, False)\n", "player value 17 | dealer value 18\n", "init (21, 1, True)\n", "init (13, 3, False)\n", "player value 19 | dealer value 23\n", "init (12, 6, False)\n", "player value 16 | dealer value 26\n", "init (15, 6, False)\n", "player value 25 | dealer value 22\n", "init (13, 10, False)\n", "player value 18 | dealer value 26\n", "init (12, 8, False)\n", "player value 22 | dealer value 19\n", "init (13, 9, False)\n", "player value 20 | dealer value 18\n", "init (13, 10, False)\n", "player value 18 | dealer value 20\n", "init (11, 3, False)\n", "player value 22 | dealer value 21\n", "init (16, 10, False)\n", "player value 22 | dealer value 24\n", "init (18, 6, False)\n", "player value 18 | dealer value 22\n", "init (12, 5, False)\n", "player value 12 | dealer value 22\n", "init (8, 3, False)\n", "player value 18 | dealer value 19\n", "init (20, 4, False)\n", "player value 20 | dealer value 22\n", "init (12, 7, False)\n", "player value 19 | dealer value 17\n", "init (13, 6, False)\n", "player value 13 | dealer value 21\n", "init (10, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 7, False)\n", "player value 19 | dealer value 17\n", "init (19, 10, True)\n", "player value 19 | dealer value 20\n", "init (7, 10, False)\n", "player value 17 | dealer value 18\n", "init (12, 7, False)\n", "player value 17 | dealer value 21\n", "init (18, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 3, True)\n", "player value 20 | dealer value 25\n", "init (11, 8, False)\n", "player value 21 | dealer value 18\n", "init (20, 9, False)\n", "player value 30 | dealer value 18\n", "init (17, 8, False)\n", "player value 17 | dealer value 18\n", "init (11, 6, False)\n", "player value 23 | dealer value 17\n", "init (15, 4, False)\n", "player value 25 | dealer value 17\n", "init (12, 9, False)\n", "player value 22 | dealer value 22\n", "init (20, 10, True)\n", "init (12, 10, False)\n", "player value 22 | dealer value 20\n", "init (6, 10, False)\n", "player value 15 | dealer value 23\n", "init (13, 7, False)\n", "player value 23 | dealer value 25\n", "init (13, 6, False)\n", "player value 13 | dealer value 17\n", "init (14, 10, False)\n", "player value 20 | dealer value 19\n", "init (15, 1, False)\n", "player value 21 | dealer value 17\n", "init (9, 10, False)\n", "player value 21 | dealer value 18\n", "init (14, 4, True)\n", "player value 19 | dealer value 20\n", "init (21, 6, True)\n", "init (18, 1, False)\n", "init (16, 5, True)\n", "player value 16 | dealer value 24\n", "init (16, 3, False)\n", "player value 16 | dealer value 17\n", "init (16, 8, True)\n", "player value 15 | dealer value 21\n", "init (16, 9, False)\n", "player value 26 | dealer value 19\n", "init (8, 1, False)\n", "init (19, 1, True)\n", "player value 19 | dealer value 20\n", "init (13, 8, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (7, 8, False)\n", "player value 25 | dealer value 19\n", "init (13, 4, True)\n", "player value 21 | dealer value 20\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 25\n", "init (7, 10, False)\n", "player value 22 | dealer value 18\n", "init (14, 5, False)\n", "player value 14 | dealer value 23\n", "init (14, 4, False)\n", "player value 25 | dealer value 25\n", "init (9, 1, False)\n", "player value 20 | dealer value 23\n", "init (18, 4, False)\n", "player value 18 | dealer value 17\n", "init (6, 10, False)\n", "player value 17 | dealer value 21\n", "init (14, 4, True)\n", "player value 20 | dealer value 18\n", "init (5, 10, False)\n", "player value 25 | dealer value 17\n", "init (19, 7, True)\n", "player value 18 | dealer value 24\n", "init (13, 10, False)\n", "player value 13 | dealer value 26\n", "init (20, 2, False)\n", "player value 30 | dealer value 20\n", "init (15, 2, False)\n", "player value 15 | dealer value 19\n", "init (9, 8, False)\n", "player value 18 | dealer value 17\n", "init (12, 10, False)\n", "player value 19 | dealer value 20\n", "init (8, 1, False)\n", "player value 25 | dealer value 20\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (11, 3, False)\n", "player value 21 | dealer value 26\n", "init (15, 1, False)\n", "player value 20 | dealer value 18\n", "init (15, 10, False)\n", "player value 25 | dealer value 17\n", "init (19, 6, True)\n", "player value 18 | dealer value 17\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (17, 8, False)\n", "player value 24 | dealer value 20\n", "init (17, 6, False)\n", "player value 17 | dealer value 19\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (12, 8, False)\n", "player value 18 | dealer value 18\n", "init (13, 7, False)\n", "player value 23 | dealer value 25\n", "init (15, 9, False)\n", "player value 19 | dealer value 25\n", "init (7, 4, False)\n", "player value 22 | dealer value 20\n", "init (17, 6, False)\n", "player value 17 | dealer value 21\n", "init (13, 6, False)\n", "player value 13 | dealer value 23\n", "init (9, 10, False)\n", "player value 15 | dealer value 17\n", "init (14, 6, False)\n", "player value 14 | dealer value 20\n", "init (18, 7, False)\n", "player value 18 | dealer value 17\n", "init (16, 2, False)\n", "player value 21 | dealer value 17\n", "init (12, 10, False)\n", "player value 25 | dealer value 21\n", "init (19, 10, False)\n", "player value 19 | dealer value 23\n", "init (13, 5, False)\n", "player value 13 | dealer value 25\n", "init (13, 8, False)\n", "player value 13 | dealer value 21\n", "init (12, 7, False)\n", "player value 22 | dealer value 25\n", "init (18, 7, False)\n", "player value 22 | dealer value 18\n", "init (10, 10, False)\n", "player value 28 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 17\n", "init (20, 6, False)\n", "player value 20 | dealer value 24\n", "init (19, 8, False)\n", "player value 19 | dealer value 18\n", "init (21, 6, True)\n", "init (9, 10, False)\n", "player value 22 | dealer value 18\n", "init (16, 7, True)\n", "player value 22 | dealer value 17\n", "init (9, 9, False)\n", "player value 19 | dealer value 20\n", "init (19, 3, True)\n", "player value 19 | dealer value 18\n", "init (19, 10, False)\n", "init (16, 1, False)\n", "player value 20 | dealer value 26\n", "init (21, 10, True)\n", "init (20, 2, False)\n", "player value 20 | dealer value 22\n", "init (21, 6, True)\n", "init (11, 8, False)\n", "player value 19 | dealer value 18\n", "init (14, 4, True)\n", "player value 21 | dealer value 21\n", "init (18, 4, False)\n", "player value 18 | dealer value 21\n", "init (20, 2, False)\n", "player value 20 | dealer value 19\n", "init (16, 10, False)\n", "player value 23 | dealer value 21\n", "init (16, 10, False)\n", "player value 20 | dealer value 17\n", "init (13, 2, False)\n", "player value 23 | dealer value 25\n", "init (11, 8, False)\n", "player value 24 | dealer value 20\n", "init (15, 10, False)\n", "player value 15 | dealer value 19\n", "init (13, 4, False)\n", "player value 22 | dealer value 25\n", "init (18, 10, False)\n", "player value 18 | dealer value 19\n", "init (7, 10, False)\n", "player value 20 | dealer value 20\n", "init (6, 2, False)\n", "player value 16 | dealer value 23\n", "init (14, 8, False)\n", "player value 24 | dealer value 24\n", "init (16, 8, False)\n", "player value 16 | dealer value 19\n", "init (14, 7, False)\n", "player value 14 | dealer value 20\n", "init (16, 2, False)\n", "player value 16 | dealer value 23\n", "init (21, 9, True)\n", "init (14, 4, False)\n", "player value 27 | dealer value 18\n", "init (21, 2, True)\n", "init (19, 10, True)\n", "player value 20 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 21\n", "init (9, 8, False)\n", "player value 29 | dealer value 18\n", "init (17, 8, False)\n", "player value 22 | dealer value 19\n", "init (16, 8, False)\n", "player value 24 | dealer value 20\n", "init (18, 9, False)\n", "player value 18 | dealer value 19\n", "init (17, 9, False)\n", "player value 23 | dealer value 19\n", "init (17, 6, False)\n", "player value 17 | dealer value 22\n", "init (11, 10, False)\n", "player value 26 | dealer value 23\n", "init (12, 10, False)\n", "player value 21 | dealer value 20\n", "init (20, 1, True)\n", "init (21, 9, True)\n", "init (18, 10, False)\n", "player value 18 | dealer value 18\n", "init (11, 3, False)\n", "player value 21 | dealer value 19\n", "init (18, 8, False)\n", "player value 18 | dealer value 17\n", "init (15, 8, True)\n", "player value 20 | dealer value 19\n", "init (19, 4, True)\n", "player value 19 | dealer value 19\n", "init (19, 4, True)\n", "player value 19 | dealer value 21\n", "init (20, 3, False)\n", "player value 20 | dealer value 24\n", "init (17, 4, False)\n", "player value 24 | dealer value 22\n", "init (18, 5, True)\n", "player value 14 | dealer value 20\n", "init (13, 5, False)\n", "player value 20 | dealer value 22\n", "init (12, 4, False)\n", "player value 21 | dealer value 24\n", "init (15, 10, True)\n", "player value 18 | dealer value 20\n", "init (14, 9, False)\n", "player value 14 | dealer value 17\n", "init (21, 7, True)\n", "init (20, 2, False)\n", "player value 20 | dealer value 20\n", "init (4, 10, False)\n", "player value 18 | dealer value 24\n", "init (20, 4, False)\n", "player value 20 | dealer value 17\n", "init (16, 10, False)\n", "player value 26 | dealer value 20\n", "init (7, 7, False)\n", "player value 19 | dealer value 17\n", "init (17, 6, False)\n", "player value 17 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 23\n", "init (21, 10, True)\n", "init (7, 2, False)\n", "player value 23 | dealer value 20\n", "init (15, 2, False)\n", "player value 22 | dealer value 21\n", "init (8, 4, False)\n", "player value 18 | dealer value 24\n", "init (20, 2, False)\n", "player value 20 | dealer value 17\n", "init (20, 2, False)\n", "player value 20 | dealer value 18\n", "init (15, 9, False)\n", "player value 25 | dealer value 21\n", "init (10, 4, False)\n", "player value 20 | dealer value 22\n", "init (11, 6, False)\n", "player value 21 | dealer value 21\n", "init (12, 10, False)\n", "player value 22 | dealer value 21\n", "init (15, 10, False)\n", "init (12, 10, False)\n", "player value 31 | dealer value 20\n", "init (17, 2, False)\n", "player value 17 | dealer value 26\n", "init (16, 1, False)\n", "init (11, 7, False)\n", "player value 19 | dealer value 18\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (13, 10, True)\n", "player value 22 | dealer value 18\n", "init (15, 2, False)\n", "player value 28 | dealer value 26\n", "init (14, 9, False)\n", "player value 14 | dealer value 22\n", "init (13, 10, False)\n", "player value 13 | dealer value 20\n", "init (20, 10, False)\n", "player value 20 | dealer value 26\n", "init (14, 10, False)\n", "player value 14 | dealer value 17\n", "init (8, 10, False)\n", "player value 18 | dealer value 20\n", "init (20, 5, False)\n", "player value 20 | dealer value 26\n", "init (20, 1, False)\n", "player value 20 | dealer value 18\n", "init (16, 4, False)\n", "player value 24 | dealer value 18\n", "init (7, 7, False)\n", "player value 17 | dealer value 23\n", "init (16, 10, False)\n", "player value 23 | dealer value 18\n", "init (14, 10, False)\n", "player value 18 | dealer value 18\n", "init (12, 9, False)\n", "player value 12 | dealer value 20\n", "init (18, 5, False)\n", "player value 18 | dealer value 20\n", "init (18, 4, True)\n", "player value 21 | dealer value 23\n", "init (17, 10, False)\n", "player value 27 | dealer value 20\n", "init (17, 8, True)\n", "player value 17 | dealer value 21\n", "init (15, 10, False)\n", "player value 23 | dealer value 19\n", "init (16, 10, False)\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (19, 1, False)\n", "player value 19 | dealer value 18\n", "init (14, 10, False)\n", "player value 17 | dealer value 20\n", "init (13, 2, False)\n", "player value 17 | dealer value 18\n", "init (15, 6, False)\n", "player value 25 | dealer value 22\n", "init (18, 1, False)\n", "player value 18 | dealer value 20\n", "init (12, 4, False)\n", "player value 25 | dealer value 19\n", "init (21, 9, True)\n", "init (17, 9, False)\n", "player value 26 | dealer value 19\n", "init (21, 8, True)\n", "init (18, 8, True)\n", "player value 23 | dealer value 17\n", "init (12, 10, False)\n", "player value 27 | dealer value 20\n", "init (13, 7, False)\n", "player value 18 | dealer value 21\n", "init (7, 10, False)\n", "player value 21 | dealer value 19\n", "init (12, 5, False)\n", "player value 12 | dealer value 17\n", "init (21, 6, True)\n", "init (15, 10, False)\n", "player value 15 | dealer value 18\n", "init (10, 10, False)\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (9, 7, False)\n", "player value 19 | dealer value 21\n", "init (17, 6, False)\n", "player value 17 | dealer value 21\n", "init (21, 10, True)\n", "init (11, 10, False)\n", "player value 21 | dealer value 20\n", "init (15, 10, True)\n", "init (11, 1, False)\n", "player value 26 | dealer value 19\n", "init (18, 9, False)\n", "player value 26 | dealer value 20\n", "init (13, 10, False)\n", "init (20, 3, False)\n", "player value 20 | dealer value 18\n", "init (16, 9, False)\n", "player value 26 | dealer value 20\n", "init (8, 5, False)\n", "player value 18 | dealer value 18\n", "init (7, 7, False)\n", "player value 22 | dealer value 17\n", "init (12, 9, False)\n", "player value 24 | dealer value 18\n", "init (14, 10, False)\n", "player value 19 | dealer value 26\n", "init (13, 4, False)\n", "player value 20 | dealer value 24\n", "init (6, 4, False)\n", "player value 22 | dealer value 21\n", "init (9, 3, False)\n", "player value 17 | dealer value 17\n", "init (14, 7, False)\n", "player value 22 | dealer value 17\n", "init (18, 4, False)\n", "player value 18 | dealer value 19\n", "init (13, 1, False)\n", "init (9, 5, False)\n", "player value 22 | dealer value 20\n", "init (19, 9, False)\n", "player value 19 | dealer value 19\n", "init (16, 5, True)\n", "player value 16 | dealer value 18\n", "init (11, 1, False)\n", "player value 21 | dealer value 20\n", "init (17, 5, False)\n", "player value 17 | dealer value 18\n", "init (14, 3, False)\n", "player value 14 | dealer value 24\n", "init (16, 5, False)\n", "player value 16 | dealer value 20\n", "init (12, 5, False)\n", "player value 12 | dealer value 19\n", "init (5, 10, False)\n", "player value 28 | dealer value 24\n", "init (14, 3, False)\n", "player value 25 | dealer value 18\n", "init (14, 10, False)\n", "player value 23 | dealer value 22\n", "init (14, 8, False)\n", "player value 25 | dealer value 18\n", "init (17, 2, False)\n", "player value 17 | dealer value 24\n", "init (20, 8, False)\n", "player value 20 | dealer value 22\n", "init (21, 10, True)\n", "init (12, 9, False)\n", "player value 18 | dealer value 25\n", "init (16, 10, False)\n", "player value 18 | dealer value 20\n", "init (16, 10, False)\n", "player value 18 | dealer value 19\n", "init (14, 10, False)\n", "player value 24 | dealer value 18\n", "init (9, 1, False)\n", "player value 20 | dealer value 19\n", "init (18, 2, False)\n", "player value 28 | dealer value 18\n", "init (20, 10, False)\n", "player value 20 | dealer value 20\n", "init (6, 1, False)\n", "init (18, 3, False)\n", "player value 18 | dealer value 23\n", "init (15, 9, False)\n", "player value 24 | dealer value 19\n", "init (12, 4, False)\n", "player value 29 | dealer value 23\n", "init (18, 4, False)\n", "player value 18 | dealer value 25\n", "init (20, 10, False)\n", "player value 20 | dealer value 24\n", "init (15, 6, False)\n", "player value 22 | dealer value 21\n", "init (19, 5, False)\n", "player value 19 | dealer value 20\n", "init (13, 4, False)\n", "player value 26 | dealer value 20\n", "init (12, 1, False)\n", "init (12, 10, False)\n", "player value 13 | dealer value 25\n", "init (19, 10, False)\n", "player value 19 | dealer value 20\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 10, True)\n", "player value 18 | dealer value 17\n", "init (17, 2, False)\n", "player value 17 | dealer value 18\n", "init (13, 1, False)\n", "player value 25 | dealer value 18\n", "init (18, 7, False)\n", "player value 18 | dealer value 18\n", "init (16, 1, True)\n", "player value 21 | dealer value 17\n", "init (8, 2, False)\n", "player value 21 | dealer value 19\n", "init (13, 10, False)\n", "player value 13 | dealer value 18\n", "init (13, 7, False)\n", "player value 13 | dealer value 22\n", "init (12, 9, False)\n", "player value 24 | dealer value 19\n", "init (14, 9, False)\n", "player value 14 | dealer value 19\n", "init (20, 9, False)\n", "player value 20 | dealer value 19\n", "init (18, 7, False)\n", "player value 22 | dealer value 20\n", "init (14, 8, False)\n", "player value 24 | dealer value 24\n", "init (17, 5, True)\n", "player value 17 | dealer value 18\n", "init (11, 1, False)\n", "player value 17 | dealer value 17\n", "init (10, 5, False)\n", "player value 21 | dealer value 22\n", "init (9, 2, False)\n", "player value 24 | dealer value 23\n", "init (18, 3, False)\n", "player value 18 | dealer value 19\n", "init (7, 2, False)\n", "player value 24 | dealer value 19\n", "init (21, 8, True)\n", "init (15, 8, False)\n", "player value 20 | dealer value 18\n", "init (20, 5, False)\n", "player value 20 | dealer value 18\n", "init (12, 10, False)\n", "player value 22 | dealer value 17\n", "init (14, 8, False)\n", "player value 24 | dealer value 18\n" ] } ], "source": [ "b = BlackJackSolution(exp_rate=0.2, lr=0.1)\n", "b.play(10000)\n", "b.savePolicy()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4066., 1524., 4410.])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.playWithDealer(10000)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(12, 1, True) HIT\n", "(12, 1, False) HIT\n", "(12, 2, True) STAND\n", "(12, 2, False) HIT\n", "(12, 3, True) HIT\n", "(12, 3, False) STAND\n", "(12, 4, True) STAND\n", "(12, 4, False) HIT\n", "(12, 5, True) HIT\n", "(12, 5, False) STAND\n", "(12, 6, True) HIT\n", "(12, 6, False) HIT\n", "(12, 7, True) HIT\n", "(12, 7, False) HIT\n", "(12, 8, True) HIT\n", "(12, 8, False) HIT\n", "(12, 9, True) HIT\n", "(12, 9, False) HIT\n", "(12, 10, True) HIT\n", "(12, 10, False) HIT\n", "(13, 1, True) HIT\n", "(13, 1, False) HIT\n", "(13, 2, True) HIT\n", "(13, 2, False) HIT\n", "(13, 3, True) HIT\n", "(13, 3, False) HIT\n", "(13, 4, True) HIT\n", "(13, 4, False) HIT\n", "(13, 5, True) HIT\n", "(13, 5, False) HIT\n", "(13, 6, True) HIT\n", "(13, 6, False) STAND\n", "(13, 7, True) HIT\n", "(13, 7, False) HIT\n", "(13, 8, True) HIT\n", "(13, 8, False) STAND\n", "(13, 9, True) HIT\n", "(13, 9, False) HIT\n", "(13, 10, True) HIT\n", "(13, 10, False) STAND\n", "(14, 1, True) HIT\n", "(14, 1, False) HIT\n", "(14, 2, True) HIT\n", "(14, 2, False) HIT\n", "(14, 3, True) HIT\n", "(14, 3, False) STAND\n", "(14, 4, True) HIT\n", "(14, 4, False) STAND\n", "(14, 5, True) HIT\n", "(14, 5, False) HIT\n", "(14, 6, True) HIT\n", "(14, 6, False) HIT\n", "(14, 7, True) HIT\n", "(14, 7, False) HIT\n", "(14, 8, True) HIT\n", "(14, 8, False) HIT\n", "(14, 9, True) HIT\n", "(14, 9, False) HIT\n", "(14, 10, True) HIT\n", "(14, 10, False) HIT\n", "(15, 1, True) HIT\n", "(15, 1, False) HIT\n", "(15, 2, True) HIT\n", "(15, 2, False) HIT\n", "(15, 3, True) HIT\n", "(15, 3, False) HIT\n", "(15, 4, True) HIT\n", "(15, 4, False) HIT\n", "(15, 5, True) STAND\n", "(15, 5, False) HIT\n", "(15, 6, True) HIT\n", "(15, 6, False) HIT\n", "(15, 7, True) HIT\n", "(15, 7, False) HIT\n", "(15, 8, True) HIT\n", "(15, 8, False) HIT\n", "(15, 9, True) HIT\n", "(15, 9, False) HIT\n", "(15, 10, True) HIT\n", "(15, 10, False) STAND\n", "(16, 1, True) HIT\n", "(16, 1, False) HIT\n", "(16, 2, True) HIT\n", "(16, 2, False) HIT\n", "(16, 3, True) HIT\n", "(16, 3, False) HIT\n", "(16, 4, True) HIT\n", "(16, 4, False) STAND\n", "(16, 5, True) HIT\n", "(16, 5, False) STAND\n", "(16, 6, True) HIT\n", "(16, 6, False) STAND\n", "(16, 7, True) HIT\n", "(16, 7, False) HIT\n", "(16, 8, True) HIT\n", "(16, 8, False) HIT\n", "(16, 9, True) HIT\n", "(16, 9, False) HIT\n", "(16, 10, True) HIT\n", "(16, 10, False) HIT\n", "(17, 1, True) HIT\n", "(17, 1, False) STAND\n", "(17, 2, True) HIT\n", "(17, 2, False) STAND\n", "(17, 3, True) HIT\n", "(17, 3, False) STAND\n", "(17, 4, True) HIT\n", "(17, 4, False) STAND\n", "(17, 5, True) STAND\n", "(17, 5, False) STAND\n", "(17, 6, True) HIT\n", "(17, 6, False) STAND\n", "(17, 7, True) HIT\n", "(17, 7, False) STAND\n", "(17, 8, True) HIT\n", "(17, 8, False) HIT\n", "(17, 9, True) HIT\n", "(17, 9, False) STAND\n", "(17, 10, True) HIT\n", "(17, 10, False) HIT\n", "(18, 1, True) HIT\n", "(18, 1, False) STAND\n", "(18, 2, True) STAND\n", "(18, 2, False) STAND\n", "(18, 3, True) HIT\n", "(18, 3, False) STAND\n", "(18, 4, True) HIT\n", "(18, 4, False) STAND\n", "(18, 5, True) HIT\n", "(18, 5, False) STAND\n", "(18, 6, True) STAND\n", "(18, 6, False) STAND\n", "(18, 7, True) STAND\n", "(18, 7, False) STAND\n", "(18, 8, True) HIT\n", "(18, 8, False) STAND\n", "(18, 9, True) HIT\n", "(18, 9, False) HIT\n", "(18, 10, True) HIT\n", "(18, 10, False) STAND\n", "(19, 1, True) STAND\n", "(19, 1, False) STAND\n", "(19, 2, True) STAND\n", "(19, 2, False) STAND\n", "(19, 3, True) STAND\n", "(19, 3, False) STAND\n", "(19, 4, True) STAND\n", "(19, 4, False) STAND\n", "(19, 5, True) HIT\n", "(19, 5, False) STAND\n", "(19, 6, True) STAND\n", "(19, 6, False) STAND\n", "(19, 7, True) STAND\n", "(19, 7, False) STAND\n", "(19, 8, True) STAND\n", "(19, 8, False) STAND\n", "(19, 9, True) STAND\n", "(19, 9, False) STAND\n", "(19, 10, True) STAND\n", "(19, 10, False) STAND\n", "(20, 1, True) STAND\n", "(20, 1, False) STAND\n", "(20, 2, True) STAND\n", "(20, 2, False) STAND\n", "(20, 3, True) STAND\n", "(20, 3, False) STAND\n", "(20, 4, True) STAND\n", "(20, 4, False) STAND\n", "(20, 5, True) STAND\n", "(20, 5, False) STAND\n", "(20, 6, True) STAND\n", "(20, 6, False) STAND\n", "(20, 7, True) STAND\n", "(20, 7, False) STAND\n", "(20, 8, True) STAND\n", "(20, 8, False) STAND\n", "(20, 9, True) STAND\n", "(20, 9, False) STAND\n", "(20, 10, True) STAND\n", "(20, 10, False) STAND\n", "(21, 1, True) STAND\n", "(21, 1, False) STAND\n", "(21, 2, True) STAND\n", "(21, 2, False) STAND\n", "(21, 3, True) STAND\n", "(21, 3, False) STAND\n", "(21, 4, True) STAND\n", "(21, 4, False) STAND\n", "(21, 5, True) STAND\n", "(21, 5, False) STAND\n", "(21, 6, True) STAND\n", "(21, 6, False) STAND\n", "(21, 7, True) STAND\n", "(21, 7, False) STAND\n", "(21, 8, True) STAND\n", "(21, 8, False) STAND\n", "(21, 9, True) STAND\n", "(21, 9, False) STAND\n", "(21, 10, True) STAND\n", "(21, 10, False) STAND\n" ] } ], "source": [ "for k, v in b.player_Q_Values.items():\n", " actions = b.player_Q_Values.get(k)\n", " action = max(actions.keys(), key=lambda k: actions[k])\n", " action = \"HIT\" if action == 1 else \"STAND\"\n", " print(k, action)" ] }, { "cell_type": "code", "execution_count": 211, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{1: 0.00787588976344472, 0: 0.1}" ] }, "execution_count": 211, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.player_Q_Values.get((12, 6, True)) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Play with same strategy" ] }, { "cell_type": "code", "execution_count": 221, "metadata": {}, "outputs": [], "source": [ "q_values = {}\n", "\n", "for i in range(12, 22):\n", " for j in range(1, 11):\n", " for k in [True, False]:\n", " q_values[(i, j, k)] = {}\n", " for a in [1, 0]:\n", " if i >= 17 and a == 0:\n", " q_values[(i, j, k)][a] = 1\n", " elif i < 17 and a == 1:\n", " q_values[(i, j, k)][a] = 1\n", " else:\n", " q_values[(i, j, k)][a] = 0" ] }, { "cell_type": "code", "execution_count": 222, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4209., 1447., 4344.])" ] }, "execution_count": 222, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = BlackJackSolution()\n", "b.player_Q_Values = q_values\n", "\n", "b.playWithDealer(rounds=10000)" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: CliffWalking/cliffWalking.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Cliff Walking\n", "---\n", "\"drawing\"\n", "---\n", "This is a standard undiscounted, episodic task, with start and goal states, and the usual actions causing movement up, down, right, and left. Reward is `-1` on all transitions except those into the region marked `Cliff`. Stepping\n", "into this region incurs a reward of optimal path `-100` and sends the agent instantly back to the start." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "ROWS = 4\n", "COLS = 12\n", "S = (3, 0)\n", "G = (3, 11)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class Cliff:\n", " \n", " def __init__(self):\n", " self.end = False\n", " self.pos = S\n", " self.board = np.zeros([4, 12])\n", " # add cliff marked as -1\n", " self.board[3, 1:11] = -1\n", " \n", " def nxtPosition(self, action):\n", " if action == \"up\":\n", " nxtPos = (self.pos[0]-1, self.pos[1])\n", " elif action == \"down\":\n", " nxtPos = (self.pos[0]+1, self.pos[1])\n", " elif action == \"left\":\n", " nxtPos = (self.pos[0], self.pos[1]-1)\n", " else:\n", " nxtPos = (self.pos[0], self.pos[1]+1)\n", " # check legitimacy\n", " if nxtPos[0] >= 0 and nxtPos[0] <= 3:\n", " if nxtPos[1] >= 0 and nxtPos[1] <= 11:\n", " self.pos = nxtPos\n", " \n", " if self.pos == G:\n", " self.end = True\n", " print(\"Game ends reaching goal\")\n", " if self.board[self.pos] == -1:\n", " self.end = True\n", " print(\"Game ends falling off cliff\")\n", " \n", " return self.pos\n", " \n", " def giveReward(self):\n", " # give reward\n", " if self.pos == G:\n", " return -1\n", " if self.board[self.pos] == 0:\n", " return -1\n", " return -100\n", " \n", " \n", " def show(self):\n", " for i in range(0, ROWS):\n", " print('-------------------------------------------------')\n", " out = '| '\n", " for j in range(0, COLS):\n", " if self.board[i, j] == -1:\n", " token = '*'\n", " if self.board[i, j] == 0:\n", " token = '0'\n", " if (i, j) == self.pos:\n", " token = 'S'\n", " if (i, j) == G:\n", " token = 'G'\n", " out += token + ' | '\n", " print(out)\n", " print('-------------------------------------------------') " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------------------\n", "| S | * | * | * | * | * | * | * | * | * | * | G | \n", "-------------------------------------------------\n" ] } ], "source": [ "c = Cliff()\n", "c.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "SARSA(on-policy) VS Q-Learning(off-policy)\n", "---\n", "\"drawing\"\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "class Agent:\n", " \n", " def __init__(self, exp_rate=0.3, lr=0.1, sarsa=True):\n", " self.cliff = Cliff()\n", " self.actions = [\"up\", \"left\", \"right\", \"down\"]\n", " self.states = [] # record position and action of each episode\n", " self.pos = S\n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", " self.sarsa = sarsa\n", " self.state_actions = {}\n", " for i in range(ROWS):\n", " for j in range(COLS):\n", " self.state_actions[(i, j)] = {}\n", " for a in self.actions:\n", " self.state_actions[(i, j)][a] = 0\n", " \n", " def chooseAction(self):\n", " # epsilon-greedy\n", " mx_nxt_reward = -999\n", " action = \"\"\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " for a in self.actions:\n", " current_position = self.pos\n", " nxt_reward = self.state_actions[current_position][a]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " return action\n", " \n", " def reset(self):\n", " self.states = []\n", " self.cliff = Cliff()\n", " self.pos = S\n", " \n", " def play(self, rounds=10):\n", " for _ in range(rounds):\n", " while 1:\n", " curr_state = self.pos\n", " cur_reward = self.cliff.giveReward()\n", " action = self.chooseAction()\n", "\n", " # next position\n", " self.cliff.pos = self.cliff.nxtPosition(action)\n", " self.pos = self.cliff.pos\n", " \n", " self.states.append([curr_state, action, cur_reward])\n", " if self.cliff.end:\n", " break\n", " # game end update estimates\n", " reward = self.cliff.giveReward()\n", " print(\"End game reward\", reward)\n", " # reward of all actions in end state is same\n", " for a in self.actions:\n", " self.state_actions[self.pos][a] = reward\n", " \n", " if self.sarsa: \n", " for s in reversed(self.states):\n", " pos, action, r = s[0], s[1], s[2]\n", " current_value = self.state_actions[pos][action]\n", " reward = current_value + self.lr*(r + reward - current_value)\n", " self.state_actions[pos][action] = round(reward, 3)\n", " else:\n", " for s in reversed(self.states):\n", " pos, action, r = s[0], s[1], s[2]\n", " current_value = self.state_actions[pos][action]\n", " reward = current_value + self.lr*(r + reward - current_value)\n", " self.state_actions[pos][action] = round(reward, 3)\n", " # update using the max value of S'\n", " reward = np.max(list(self.state_actions[pos].values())) # max\n", "\n", " self.reset()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After an initial transient, `Q-learning` learns values for the optimal policy, that which travels right along the edge of the cliff. Unfortunately, this results in its occasionally falling off the cliff because of the \"epsilon-greedy\" action selection. `Sarsa`, on the other hand, takes the action selection into account and learns the longer but\n", "safer path through the upper part of the grid." ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [], "source": [ "def showRoute(states):\n", " board = np.zeros([4, 12])\n", " # add cliff marked as -1\n", " board[3, 1:11] = -1\n", " for i in range(0, ROWS):\n", " print('-------------------------------------------------')\n", " out = '| '\n", " for j in range(0, COLS):\n", " token = '0'\n", " if board[i, j] == -1:\n", " token = '*'\n", " if (i, j) in states:\n", " token = 'R'\n", " if (i, j) == G:\n", " token = 'G'\n", " out += token + ' | '\n", " print(out)\n", " print('-------------------------------------------------') " ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n" ] } ], "source": [ "ag = Agent(exp_rate=0.1, lr=0.1, sarsa=False)\n", "ag.play(rounds=500)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Get the Best Route" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "current position (3, 0) |action up\n", "current position (2, 0) |action right\n", "current position (2, 1) |action right\n", "current position (2, 2) |action right\n", "current position (2, 3) |action right\n", "current position (2, 4) |action right\n", "current position (2, 5) |action right\n", "current position (2, 6) |action right\n", "current position (2, 7) |action right\n", "current position (2, 8) |action right\n", "current position (2, 9) |action right\n", "current position (2, 10) |action right\n", "current position (2, 11) |action down\n", "Game ends reaching goal\n" ] } ], "source": [ "# Q-learning\n", "ag_op = Agent(exp_rate=0)\n", "ag_op.state_actions = ag.state_actions\n", "\n", "states = []\n", "while 1:\n", " curr_state = ag_op.pos\n", " action = ag_op.chooseAction()\n", " states.append(curr_state)\n", " print(\"current position {} |action {}\".format(curr_state, action))\n", "\n", " # next position\n", " ag_op.cliff.pos = ag_op.cliff.nxtPosition(action)\n", " ag_op.pos = ag_op.cliff.pos\n", "\n", " if ag_op.cliff.end:\n", " break" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------------------\n", "| R | R | R | R | R | R | R | R | R | R | R | R | \n", "-------------------------------------------------\n", "| R | * | * | * | * | * | * | * | * | * | * | G | \n", "-------------------------------------------------\n" ] } ], "source": [ "showRoute(states)" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends falling off cliff\n", "End game reward -100\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n", "Game ends reaching goal\n", "End game reward -1\n" ] } ], "source": [ "ag = Agent(exp_rate=0.1, lr=0.1, sarsa=True)\n", "ag.play(rounds=500)" ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "current position (3, 0) |action up\n", "current position (2, 0) |action up\n", "current position (1, 0) |action right\n", "current position (1, 1) |action right\n", "current position (1, 2) |action right\n", "current position (1, 3) |action right\n", "current position (1, 4) |action up\n", "current position (0, 4) |action right\n", "current position (0, 5) |action right\n", "current position (0, 6) |action right\n", "current position (0, 7) |action right\n", "current position (0, 8) |action right\n", "current position (0, 9) |action right\n", "current position (0, 10) |action right\n", "current position (0, 11) |action down\n", "current position (1, 11) |action down\n", "current position (2, 11) |action down\n", "Game ends reaching goal\n" ] } ], "source": [ "# Sarsa\n", "ag_op = Agent(exp_rate=0)\n", "ag_op.state_actions = ag.state_actions\n", "\n", "states = []\n", "while 1:\n", " curr_state = ag_op.pos\n", " action = ag_op.chooseAction()\n", " states.append(curr_state)\n", " print(\"current position {} |action {}\".format(curr_state, action))\n", "\n", " # next position\n", " ag_op.cliff.pos = ag_op.cliff.nxtPosition(action)\n", " ag_op.pos = ag_op.cliff.pos\n", "\n", " if ag_op.cliff.end:\n", " break" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------------------------------------------\n", "| 0 | 0 | 0 | 0 | R | R | R | R | R | R | R | R | \n", "-------------------------------------------------\n", "| R | R | R | R | R | 0 | 0 | 0 | 0 | 0 | 0 | R | \n", "-------------------------------------------------\n", "| R | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | R | \n", "-------------------------------------------------\n", "| R | * | * | * | * | * | * | * | * | * | * | G | \n", "-------------------------------------------------\n" ] } ], "source": [ "showRoute(states)" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: CliffWalking/cliffWalking.py ================================================ import numpy as np ROWS = 4 COLS = 12 S = (3, 0) G = (3, 11) class Cliff: def __init__(self): self.end = False self.pos = S self.board = np.zeros([4, 12]) # add cliff marked as -1 self.board[3, 1:11] = -1 def nxtPosition(self, action): if action == "up": nxtPos = (self.pos[0] - 1, self.pos[1]) elif action == "down": nxtPos = (self.pos[0] + 1, self.pos[1]) elif action == "left": nxtPos = (self.pos[0], self.pos[1] - 1) else: nxtPos = (self.pos[0], self.pos[1] + 1) # check legitimacy if nxtPos[0] >= 0 and nxtPos[0] <= 3: if nxtPos[1] >= 0 and nxtPos[1] <= 11: self.pos = nxtPos if self.pos == G: self.end = True print("Game ends reaching goal") if self.board[self.pos] == -1: self.end = True print("Game ends falling off cliff") return self.pos def giveReward(self): # give reward if self.pos == G: return -1 if self.board[self.pos] == 0: return -1 return -100 def show(self): for i in range(0, ROWS): print('-------------------------------------------------') out = '| ' for j in range(0, COLS): if self.board[i, j] == -1: token = '*' if self.board[i, j] == 0: token = '0' if (i, j) == self.pos: token = 'S' if (i, j) == G: token = 'G' out += token + ' | ' print(out) print('-------------------------------------------------') class Agent: def __init__(self, exp_rate=0.3, lr=0.1, sarsa=True): self.cliff = Cliff() self.actions = ["up", "left", "right", "down"] self.states = [] # record position and action of each episode self.pos = S self.exp_rate = exp_rate self.lr = lr self.sarsa = sarsa self.state_actions = {} for i in range(ROWS): for j in range(COLS): self.state_actions[(i, j)] = {} for a in self.actions: self.state_actions[(i, j)][a] = 0 def chooseAction(self): # epsilon-greedy mx_nxt_reward = -999 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action for a in self.actions: current_position = self.pos nxt_reward = self.state_actions[current_position][a] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward return action def reset(self): self.states = [] self.cliff = Cliff() self.pos = S def play(self, rounds=10): for _ in range(rounds): while 1: curr_state = self.pos cur_reward = self.cliff.giveReward() action = self.chooseAction() # next position self.cliff.pos = self.cliff.nxtPosition(action) self.pos = self.cliff.pos self.states.append([curr_state, action, cur_reward]) if self.cliff.end: break # game end update estimates reward = self.cliff.giveReward() print("End game reward", reward) # reward of all actions in end state is same for a in self.actions: self.state_actions[self.pos][a] = reward if self.sarsa: for s in reversed(self.states): pos, action, r = s[0], s[1], s[2] current_value = self.state_actions[pos][action] reward = current_value + self.lr * (r + reward - current_value) self.state_actions[pos][action] = round(reward, 3) else: for s in reversed(self.states): pos, action, r = s[0], s[1], s[2] current_value = self.state_actions[pos][action] reward = current_value + self.lr * (r + reward - current_value) self.state_actions[pos][action] = round(reward, 3) # update using the max value of S' reward = np.max(list(self.state_actions[pos].values())) # max self.reset() def showRoute(states): board = np.zeros([4, 12]) # add cliff marked as -1 board[3, 1:11] = -1 for i in range(0, ROWS): print('-------------------------------------------------') out = '| ' for j in range(0, COLS): token = '0' if board[i, j] == -1: token = '*' if (i, j) in states: token = 'R' if (i, j) == G: token = 'G' out += token + ' | ' print(out) print('-------------------------------------------------') if __name__ == "__main__": print("sarsa training ... ") ag = Agent(exp_rate=0.1, sarsa=True) ag.play(rounds=500) # Sarsa ag_op = Agent(exp_rate=0) ag_op.state_actions = ag.state_actions states = [] while 1: curr_state = ag_op.pos action = ag_op.chooseAction() states.append(curr_state) print("current position {} |action {}".format(curr_state, action)) # next position ag_op.cliff.pos = ag_op.cliff.nxtPosition(action) ag_op.pos = ag_op.cliff.pos if ag_op.cliff.end: break showRoute(states) print("q-learning training ... ") ag = Agent(exp_rate=0.1, sarsa=False) ag.play(rounds=500) # Q-learning ag_op = Agent(exp_rate=0) ag_op.state_actions = ag.state_actions states = [] while 1: curr_state = ag_op.pos action = ag_op.chooseAction() states.append(curr_state) print("current position {} |action {}".format(curr_state, action)) # next position ag_op.cliff.pos = ag_op.cliff.nxtPosition(action) ag_op.pos = ag_op.cliff.pos if ag_op.cliff.end: break showRoute(states) ================================================ FILE: DynaMaze/DynaMaze.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Rules\n", "---\n", "\"drawing\"\n", "\n", "> Consider the simple maze shown inset in the Figure. In each of the 47 states there are four actions, `up`, `down`, `right`, and `left`, which take the agent deterministically to the corresponding neighboring states, except when movement is blocked by an obstacle or the edge of the maze, in which case the agent remains where it is. Reward is zero on all transitions, except those into the goal state, on which it is +1. After reaching the goal state `(G)`, the agent returns to the start state `(S)` to begin a new episode.\n", "---\n", ">\n", "## Dyna-Q\n", "\n", "---\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [], "source": [ "ROWS = 6\n", "COLS = 9\n", "S = (2, 0)\n", "G = (0, 8)\n", "BLOCKS = [(1, 2), (2, 2), (3, 2), (0, 7), (1, 7), (2, 7), (4, 5)]\n", "ACTIONS = [\"left\", \"up\", \"right\", \"down\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Models" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [], "source": [ "class Maze:\n", " \n", " def __init__(self):\n", " self.rows = ROWS\n", " self.cols = COLS\n", " self.start = S\n", " self.goal = G\n", " self.blocks = BLOCKS\n", " self.state = S\n", " self.end = False\n", " # init maze\n", " self.maze = np.zeros((self.rows, self.cols))\n", " for b in self.blocks:\n", " self.maze[b] = -1\n", " \n", " def nxtPosition(self, action):\n", " r, c = self.state\n", " if action == \"left\":\n", " c -= 1\n", " elif action == \"right\":\n", " c += 1\n", " elif action == \"up\":\n", " r -= 1\n", " else:\n", " r += 1\n", " \n", " if (r >= 0 and r <= self.rows-1) and (c >= 0 and c <= self.cols-1):\n", " if (r, c) not in self.blocks:\n", " self.state = (r, c)\n", " return self.state\n", " \n", " def giveReward(self):\n", " if self.state == self.goal:\n", " self.end = True\n", " return 1\n", " else:\n", " return 0\n", " \n", " def showMaze(self):\n", " self.maze[self.state] = 1\n", " for i in range(0, self.rows):\n", " print('-------------------------------------')\n", " out = '| '\n", " for j in range(0, self.cols):\n", " if self.maze[i, j] == 1:\n", " token = '*'\n", " if self.maze[i, j] == -1:\n", " token = 'z'\n", " if self.maze[i, j] == 0:\n", " token = '0'\n", " out += token + ' | '\n", " print(out)\n", " print('-------------------------------------')" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | z | 0 | \n", "-------------------------------------\n", "| 0 | 0 | z | 0 | 0 | 0 | 0 | z | 0 | \n", "-------------------------------------\n", "| * | 0 | z | 0 | 0 | 0 | 0 | z | 0 | \n", "-------------------------------------\n", "| 0 | 0 | z | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | z | 0 | 0 | 0 | \n", "-------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-------------------------------------\n" ] } ], "source": [ "m = Maze()\n", "m.showMaze()" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "class DynaAgent:\n", " \n", " def __init__(self, exp_rate=0.3, lr=0.1, n_steps=5, episodes=1):\n", " self.maze = Maze()\n", " self.state = S\n", " self.actions = ACTIONS\n", " self.state_actions = [] # state & action track\n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", " \n", " self.steps = n_steps\n", " self.episodes = episodes # number of episodes going to play\n", " self.steps_per_episode = []\n", " \n", " self.Q_values = {}\n", " # model function\n", " self.model = {}\n", " for row in range(ROWS):\n", " for col in range(COLS):\n", " self.Q_values[(row, col)] = {}\n", " for a in self.actions:\n", " self.Q_values[(row, col)][a] = 0\n", " \n", " def chooseAction(self):\n", " # epsilon-greedy\n", " mx_nxt_reward = -999\n", " action = \"\"\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " current_position = self.state\n", " # if all actions have same value, then select randomly\n", " if len(set(self.Q_values[current_position].values())) == 1:\n", " action = np.random.choice(self.actions)\n", " else:\n", " for a in self.actions:\n", " nxt_reward = self.Q_values[current_position][a]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " return action\n", " \n", " def reset(self):\n", " self.maze = Maze()\n", " self.state = S\n", " self.state_actions = []\n", " \n", " def play(self):\n", " self.steps_per_episode = [] \n", " \n", " for ep in range(self.episodes): \n", " while not self.maze.end:\n", "\n", " action = self.chooseAction()\n", " self.state_actions.append((self.state, action))\n", "\n", " nxtState = self.maze.nxtPosition(action)\n", " reward = self.maze.giveReward()\n", " # update Q-value\n", " self.Q_values[self.state][action] += self.lr*(reward + np.max(list(self.Q_values[nxtState].values())) - self.Q_values[self.state][action])\n", "\n", " # update model\n", " if self.state not in self.model.keys():\n", " self.model[self.state] = {}\n", " self.model[self.state][action] = (reward, nxtState)\n", " self.state = nxtState\n", "\n", " # loop n times to randomly update Q-value\n", " for _ in range(self.steps):\n", " # randomly choose an state\n", " rand_idx = np.random.choice(range(len(self.model.keys())))\n", " _state = list(self.model)[rand_idx]\n", " # randomly choose an action\n", " rand_idx = np.random.choice(range(len(self.model[_state].keys())))\n", " _action = list(self.model[_state])[rand_idx]\n", "\n", " _reward, _nxtState = self.model[_state][_action]\n", "\n", " self.Q_values[_state][_action] += self.lr*(_reward + np.max(list(self.Q_values[_nxtState].values())) - self.Q_values[_state][_action]) \n", " # end of game\n", " if ep % 10 == 0:\n", " print(\"episode\", ep)\n", " self.steps_per_episode.append(len(self.state_actions))\n", " self.reset()\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Steps comparison" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "N_EPISODES = 50" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "episode 0\n", "episode 10\n", "episode 20\n", "episode 30\n", "episode 40\n" ] } ], "source": [ "agent = DynaAgent(n_steps=0, episodes=N_EPISODES)\n", "agent.play()\n", "\n", "steps_episode_0 = agent.steps_per_episode" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "episode 0\n", "episode 10\n", "episode 20\n", "episode 30\n", "episode 40\n" ] } ], "source": [ "agent = DynaAgent(n_steps=5, episodes=N_EPISODES)\n", "agent.play()\n", "\n", "steps_episode_5 = agent.steps_per_episode" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "episode 0\n", "episode 10\n", "episode 20\n", "episode 30\n", "episode 40\n" ] } ], "source": [ "agent = DynaAgent(n_steps=50, episodes=N_EPISODES)\n", "agent.play()\n", "\n", "steps_episode_50 = agent.steps_per_episode" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "plt.ylim(0, 600)\n", "plt.plot(range(N_EPISODES), steps_episode_0, label=\"step=0\")\n", "plt.plot(range(N_EPISODES), steps_episode_5, label=\"step=5\")\n", "plt.plot(range(N_EPISODES), steps_episode_50, label=\"step=50\")\n", "\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### DynaQ+" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "class DynaAgentPlus:\n", "\n", " def __init__(self, exp_rate=0.3, lr=0.1, n_steps=5, episodes=1, timeWeight=1e-4):\n", " self.time = 0 # keep track of the total time\n", " self.timeWeight = timeWeight\n", " self.maze = Maze()\n", " self.state = S\n", " self.actions = ACTIONS\n", " self.state_actions = [] # state & action track\n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", "\n", " self.steps = n_steps\n", " self.episodes = episodes # number of episodes going to play\n", " self.steps_per_episode = []\n", "\n", " self.Q_values = {}\n", " # model function\n", " self.model = {}\n", " for row in range(ROWS):\n", " for col in range(COLS):\n", " self.Q_values[(row, col)] = {}\n", " for a in self.actions:\n", " self.Q_values[(row, col)][a] = 0\n", "\n", " def chooseAction(self):\n", " # epsilon-greedy\n", " mx_nxt_reward = -999\n", " action = \"\"\n", "\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " current_position = self.state\n", " # if all actions have same value, then select randomly\n", " if len(set(self.Q_values[current_position].values())) == 1:\n", " action = np.random.choice(self.actions)\n", " else:\n", " for a in self.actions:\n", " nxt_reward = self.Q_values[current_position][a]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " return action\n", "\n", " def reset(self):\n", " self.maze = Maze()\n", " self.state = S\n", " self.state_actions = []\n", " self.time = 0\n", "\n", " def updateModel(self, state, nxtState, action, reward):\n", " if state not in self.model.keys():\n", " self.model[state] = {}\n", " for a in self.actions:\n", " # the initial model for such actions was that they would\n", " # lead back to the same state with a reward of 0.\n", " if a != action:\n", " self.model[state][a] = (0, state, 1)\n", "\n", " self.model[state][action] = (reward, nxtState, self.time)\n", "\n", " def play(self):\n", " self.steps_per_episode = []\n", "\n", " for ep in range(self.episodes):\n", " while not self.maze.end:\n", "\n", " action = self.chooseAction()\n", " self.state_actions.append((self.state, action))\n", "\n", " nxtState = self.maze.nxtPosition(action)\n", " reward = self.maze.giveReward()\n", "\n", " # update Q-value\n", " self.Q_values[self.state][action] += self.lr * (reward + np.max(list(self.Q_values[nxtState].values())) - self.Q_values[self.state][action])\n", "\n", " # update model\n", " self.updateModel(self.state, nxtState, action, reward)\n", " self.state = nxtState\n", " self.time += 1\n", "\n", " # loop n times to randomly update Q-value\n", " for _ in range(self.steps):\n", " # randomly choose an state\n", " rand_idx = np.random.choice(range(len(self.model.keys())))\n", " _state = list(self.model)[rand_idx]\n", " # randomly choose an action\n", " rand_idx = np.random.choice(range(len(self.model[_state].keys())))\n", " _action = list(self.model[_state])[rand_idx]\n", "\n", " _reward, _nxtState, _time = self.model[_state][_action]\n", " # update _reward\n", " _reward += self.timeWeight * np.sqrt(self.time - _time)\n", "\n", " self.Q_values[_state][_action] += self.lr * (_reward + np.max(list(self.Q_values[_nxtState].values())) - self.Q_values[_state][_action])\n", " # end of game\n", " if ep % 10 == 0:\n", " print(\"episode\", ep)\n", " self.steps_per_episode.append(len(self.state_actions))\n", " self.reset()" ] }, { "cell_type": "code", "execution_count": 127, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "episode 0\n" ] } ], "source": [ "agent = DynaAgentPlus(n_steps=5, episodes=5) # took relatively long\n", "agent.play()" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: DynaMaze/DynaMaze.py ================================================ import numpy as np import matplotlib.pyplot as plt ROWS = 6 COLS = 9 S = (2, 0) G = (0, 8) BLOCKS = [(1, 2), (2, 2), (3, 2), (0, 7), (1, 7), (2, 7), (4, 5)] ACTIONS = ["left", "up", "right", "down"] class Maze: def __init__(self): self.rows = ROWS self.cols = COLS self.start = S self.goal = G self.blocks = BLOCKS self.state = S self.end = False # init maze self.maze = np.zeros((self.rows, self.cols)) for b in self.blocks: self.maze[b] = -1 def nxtPosition(self, action): r, c = self.state if action == "left": c -= 1 elif action == "right": c += 1 elif action == "up": r -= 1 else: r += 1 if (r >= 0 and r <= self.rows-1) and (c >= 0 and c <= self.cols-1): if (r, c) not in self.blocks: self.state = (r, c) return self.state def giveReward(self): if self.state == self.goal: self.end = True return 1 else: return 0 def showMaze(self): self.maze[self.state] = 1 for i in range(0, self.rows): print('-------------------------------------') out = '| ' for j in range(0, self.cols): if self.maze[i, j] == 1: token = '*' if self.maze[i, j] == -1: token = 'z' if self.maze[i, j] == 0: token = '0' out += token + ' | ' print(out) print('-------------------------------------') class DynaAgent: def __init__(self, exp_rate=0.3, lr=0.1, n_steps=5, episodes=1): self.maze = Maze() self.state = S self.actions = ACTIONS self.state_actions = [] # state & action track self.exp_rate = exp_rate self.lr = lr self.steps = n_steps self.episodes = episodes # number of episodes going to play self.steps_per_episode = [] self.Q_values = {} # model function self.model = {} for row in range(ROWS): for col in range(COLS): self.Q_values[(row, col)] = {} for a in self.actions: self.Q_values[(row, col)][a] = 0 def chooseAction(self): # epsilon-greedy mx_nxt_reward = -999 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action current_position = self.state # if all actions have same value, then select randomly if len(set(self.Q_values[current_position].values())) == 1: action = np.random.choice(self.actions) else: for a in self.actions: nxt_reward = self.Q_values[current_position][a] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward return action def reset(self): self.maze = Maze() self.state = S self.state_actions = [] def play(self): self.steps_per_episode = [] for ep in range(self.episodes): while not self.maze.end: action = self.chooseAction() self.state_actions.append((self.state, action)) nxtState = self.maze.nxtPosition(action) reward = self.maze.giveReward() # update Q-value self.Q_values[self.state][action] += self.lr*(reward + np.max(list(self.Q_values[nxtState].values())) - self.Q_values[self.state][action]) # update model if self.state not in self.model.keys(): self.model[self.state] = {} self.model[self.state][action] = (reward, nxtState) self.state = nxtState # loop n times to randomly update Q-value for _ in range(self.steps): # randomly choose an state rand_idx = np.random.choice(range(len(self.model.keys()))) _state = list(self.model)[rand_idx] # randomly choose an action rand_idx = np.random.choice(range(len(self.model[_state].keys()))) _action = list(self.model[_state])[rand_idx] _reward, _nxtState = self.model[_state][_action] self.Q_values[_state][_action] += self.lr*(_reward + np.max(list(self.Q_values[_nxtState].values())) - self.Q_values[_state][_action]) # end of game if ep % 10 == 0: print("episode", ep) self.steps_per_episode.append(len(self.state_actions)) self.reset() if __name__ == "__main__": N_EPISODES = 50 # comparison agent = DynaAgent(n_steps=0, episodes=N_EPISODES) agent.play() steps_episode_0 = agent.steps_per_episode agent = DynaAgent(n_steps=5, episodes=N_EPISODES) agent.play() steps_episode_5 = agent.steps_per_episode agent = DynaAgent(n_steps=50, episodes=N_EPISODES) agent.play() steps_episode_50 = agent.steps_per_episode plt.figure(figsize=[10, 6]) plt.ylim(0, 900) plt.plot(range(N_EPISODES), steps_episode_0, label="step=0") plt.plot(range(N_EPISODES), steps_episode_5, label="step=5") plt.plot(range(N_EPISODES), steps_episode_50, label="step=50") plt.legend() ================================================ FILE: DynaMaze/DynaQ+.py ================================================ import numpy as np ROWS = 6 COLS = 9 S = (2, 0) G = (0, 8) BLOCKS = [(1, 2), (2, 2), (3, 2), (0, 7), (1, 7), (2, 7), (4, 5)] ACTIONS = ["left", "up", "right", "down"] class Maze: def __init__(self): self.rows = ROWS self.cols = COLS self.start = S self.goal = G self.blocks = BLOCKS self.state = S self.end = False # init maze self.maze = np.zeros((self.rows, self.cols)) for b in self.blocks: self.maze[b] = -1 def nxtPosition(self, action): r, c = self.state if action == "left": c -= 1 elif action == "right": c += 1 elif action == "up": r -= 1 else: r += 1 if (r >= 0 and r <= self.rows - 1) and (c >= 0 and c <= self.cols - 1): if (r, c) not in self.blocks: self.state = (r, c) return self.state def giveReward(self): if self.state == self.goal: self.end = True return 1 else: return 0 def showMaze(self): self.maze[self.state] = 1 for i in range(0, self.rows): print('-------------------------------------') out = '| ' for j in range(0, self.cols): if self.maze[i, j] == 1: token = '*' if self.maze[i, j] == -1: token = 'z' if self.maze[i, j] == 0: token = '0' out += token + ' | ' print(out) print('-------------------------------------') class DynaAgentPlus: def __init__(self, exp_rate=0.3, lr=0.1, n_steps=5, episodes=1, timeWeight=1e-4): self.time = 0 # keep track of the total time self.timeWeight = timeWeight self.maze = Maze() self.state = S self.actions = ACTIONS self.state_actions = [] # state & action track self.exp_rate = exp_rate self.lr = lr self.steps = n_steps self.episodes = episodes # number of episodes going to play self.steps_per_episode = [] self.Q_values = {} # model function self.model = {} for row in range(ROWS): for col in range(COLS): self.Q_values[(row, col)] = {} for a in self.actions: self.Q_values[(row, col)][a] = 0 def chooseAction(self): # epsilon-greedy mx_nxt_reward = -999 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action current_position = self.state # if all actions have same value, then select randomly if len(set(self.Q_values[current_position].values())) == 1: action = np.random.choice(self.actions) else: for a in self.actions: nxt_reward = self.Q_values[current_position][a] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward return action def reset(self): self.maze = Maze() self.state = S self.state_actions = [] self.time = 0 def updateModel(self, state, nxtState, action, reward): if state not in self.model.keys(): self.model[state] = {} for a in self.actions: # the initial model for such actions was that they would # lead back to the same state with a reward of 0. if a != action: self.model[state][a] = (0, state, 1) self.model[state][action] = (reward, nxtState, self.time) def play(self): self.steps_per_episode = [] for ep in range(self.episodes): while not self.maze.end: action = self.chooseAction() self.state_actions.append((self.state, action)) nxtState = self.maze.nxtPosition(action) reward = self.maze.giveReward() # update Q-value self.Q_values[self.state][action] += self.lr * (reward + np.max(list(self.Q_values[nxtState].values())) - self.Q_values[self.state][action]) # update model self.updateModel(self.state, nxtState, action, reward) self.state = nxtState self.time += 1 # loop n times to randomly update Q-value for _ in range(self.steps): # randomly choose an state rand_idx = np.random.choice(range(len(self.model.keys()))) _state = list(self.model)[rand_idx] # randomly choose an action rand_idx = np.random.choice(range(len(self.model[_state].keys()))) _action = list(self.model[_state])[rand_idx] _reward, _nxtState, _time = self.model[_state][_action] # update _reward _reward += self.timeWeight * np.sqrt(self.time - _time) self.Q_values[_state][_action] += self.lr * (_reward + np.max(list(self.Q_values[_nxtState].values())) - self.Q_values[_state][_action]) # end of game if ep % 10 == 0: print("episode", ep) self.steps_per_episode.append(len(self.state_actions)) self.reset() if __name__ == "__main__": dap = DynaAgentPlus() dap.play() ================================================ FILE: DynaMaze/PrioritySweeping.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Priority Sweeping\n", "---\n", "\"drawing\"\n", "> Only an update along a transition into the state just prior to the goal, or from it, will change any values. It is natural to prioritize the updates according to a measure of their `urgency`, and perform them in order of priority. This is the idea behind `prioritized sweeping`. A queue is maintained of every state–action pair whose estimated value would change nontrivially if updated, prioritized by the size of the change." ] }, { "cell_type": "code", "execution_count": 110, "metadata": {}, "outputs": [], "source": [ "from queue import PriorityQueue\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "ROWS = 6\n", "COLS = 9\n", "S = (2, 0)\n", "G = (0, 8)\n", "BLOCKS = [(1, 2), (2, 2), (3, 2), (0, 7), (1, 7), (2, 7), (4, 5)]\n", "ACTIONS = [\"left\", \"up\", \"right\", \"down\"]" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class Maze:\n", " \n", " def __init__(self):\n", " self.rows = ROWS\n", " self.cols = COLS\n", " self.start = S\n", " self.goal = G\n", " self.blocks = BLOCKS\n", " self.state = S\n", " self.end = False\n", " # init maze\n", " self.maze = np.zeros((self.rows, self.cols))\n", " for b in self.blocks:\n", " self.maze[b] = -1\n", " \n", " def nxtPosition(self, action):\n", " r, c = self.state\n", " if action == \"left\":\n", " c -= 1\n", " elif action == \"right\":\n", " c += 1\n", " elif action == \"up\":\n", " r -= 1\n", " else:\n", " r += 1\n", " \n", " if (r >= 0 and r <= self.rows-1) and (c >= 0 and c <= self.cols-1):\n", " if (r, c) not in self.blocks:\n", " self.state = (r, c)\n", " return self.state\n", " \n", " def giveReward(self):\n", " if self.state == self.goal:\n", " self.end = True\n", " return 1\n", " else:\n", " return 0\n", " \n", " def showMaze(self):\n", " self.maze[self.state] = 1\n", " for i in range(0, self.rows):\n", " print('-------------------------------------')\n", " out = '| '\n", " for j in range(0, self.cols):\n", " if self.maze[i, j] == 1:\n", " token = '*'\n", " if self.maze[i, j] == -1:\n", " token = 'z'\n", " if self.maze[i, j] == 0:\n", " token = '0'\n", " out += token + ' | '\n", " print(out)\n", " print('-------------------------------------')" ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [], "source": [ "class PriorityAgent:\n", "\n", " def __init__(self, exp_rate=0.3, lr=0.1, n_steps=5, episodes=1, theta=0):\n", " self.maze = Maze()\n", " self.state = S\n", " self.actions = ACTIONS\n", " self.state_actions = [] # state & action track\n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", "\n", " self.steps = n_steps\n", " self.episodes = episodes # number of episodes going to play\n", " self.steps_per_episode = []\n", "\n", " self.Q_values = {}\n", " # model function\n", " self.model = {}\n", " for row in range(ROWS):\n", " for col in range(COLS):\n", " self.Q_values[(row, col)] = {}\n", " for a in self.actions:\n", " self.Q_values[(row, col)][a] = 0\n", "\n", " # for priority sweeping\n", " self.theta = theta\n", " self.queue = PriorityQueue()\n", " self.predecessors = {} # nxtState -> list[(curState, Action)...]\n", "\n", " def chooseAction(self):\n", " # epsilon-greedy\n", " mx_nxt_reward = -999\n", " action = \"\"\n", "\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " current_position = self.state\n", " # if all actions have same value, then select randomly\n", " if len(set(self.Q_values[current_position].values())) == 1:\n", " action = np.random.choice(self.actions)\n", " else:\n", " for a in self.actions:\n", " nxt_reward = self.Q_values[current_position][a]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " return action\n", "\n", " def reset(self):\n", " self.maze = Maze()\n", " self.state = S\n", " self.state_actions = []\n", "\n", " def play(self):\n", " for ep in range(self.episodes):\n", " while not self.maze.end:\n", "\n", " action = self.chooseAction()\n", " self.state_actions.append((self.state, action))\n", "\n", " nxtState = self.maze.nxtPosition(action)\n", " reward = self.maze.giveReward()\n", "\n", " # update priority queue\n", " tmp_diff = reward + np.max(list(self.Q_values[nxtState].values())) - self.Q_values[self.state][action]\n", " if tmp_diff > self.theta:\n", " self.queue.put((-tmp_diff, (self.state, action))) # -diff -> (state, action) pop the smallest\n", "\n", " # update model & predecessors\n", " if self.state not in self.model.keys():\n", " self.model[self.state] = {}\n", " self.model[self.state][action] = (reward, nxtState)\n", " if nxtState not in self.predecessors.keys():\n", " self.predecessors[nxtState] = [(self.state, action)]\n", " else:\n", " self.predecessors[nxtState].append((self.state, action))\n", " self.state = nxtState\n", "\n", " # loop n times to randomly update Q-value\n", " for _ in range(self.steps):\n", " if self.queue.empty():\n", " break\n", " _state, _action = self.queue.get()[1]\n", " _reward, _nxtState = self.model[_state][_action]\n", " self.Q_values[_state][_action] += self.lr * (_reward + np.max(list(self.Q_values[_nxtState].values())) - self.Q_values[_state][_action])\n", "\n", " # loop for all state, action predicted lead to _state\n", " if _state not in self.predecessors.keys():\n", " continue\n", " pre_state_action_list = self.predecessors[_state]\n", "\n", " for (pre_state, pre_action) in pre_state_action_list:\n", " pre_reward, _ = self.model[pre_state][pre_action]\n", " pre_tmp_diff = pre_reward + np.max(list(self.Q_values[_state].values())) - self.Q_values[pre_state][pre_action]\n", " if pre_tmp_diff > self.theta:\n", " self.queue.put((-pre_tmp_diff, (pre_state, pre_action)))\n", " # end of game\n", " if ep % 10 == 0:\n", " print(\"episode\", ep)\n", " self.steps_per_episode.append(len(self.state_actions))\n", " self.reset()" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [], "source": [ "N_EPISODES = 50" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comparing" ] }, { "cell_type": "code", "execution_count": 107, "metadata": {}, "outputs": [], "source": [ "import DynaMaze" ] }, { "cell_type": "code", "execution_count": 112, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "episode 0\n", "episode 10\n", "episode 20\n", "episode 30\n", "episode 40\n" ] } ], "source": [ "agent = PriorityAgent(n_steps=5, episodes=N_EPISODES)\n", "agent.play()\n", "\n", "steps_episode_pa = agent.steps_per_episode" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "episode 0\n", "episode 10\n", "episode 20\n", "episode 30\n", "episode 40\n" ] } ], "source": [ "agent = DynaMaze.DynaAgent(n_steps=5, episodes=N_EPISODES)\n", "agent.play()\n", "\n", "steps_episode_da = agent.steps_per_episode" ] }, { "cell_type": "code", "execution_count": 114, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 114, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "plt.ylim(0, 500)\n", "plt.plot(range(N_EPISODES), steps_episode_pa, label=\"Priority Sweeping\")\n", "plt.plot(range(N_EPISODES), steps_episode_da, label=\"Dyna-Q\")\n", "\n", "plt.legend()" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: DynaMaze/PrioritySweeping.py ================================================ from queue import PriorityQueue import numpy as np ROWS = 6 COLS = 9 S = (2, 0) G = (0, 8) BLOCKS = [(1, 2), (2, 2), (3, 2), (0, 7), (1, 7), (2, 7), (4, 5)] ACTIONS = ["left", "up", "right", "down"] class Maze: def __init__(self): self.rows = ROWS self.cols = COLS self.start = S self.goal = G self.blocks = BLOCKS self.state = S self.end = False # init maze self.maze = np.zeros((self.rows, self.cols)) for b in self.blocks: self.maze[b] = -1 def nxtPosition(self, action): r, c = self.state if action == "left": c -= 1 elif action == "right": c += 1 elif action == "up": r -= 1 else: r += 1 if (r >= 0 and r <= self.rows - 1) and (c >= 0 and c <= self.cols - 1): if (r, c) not in self.blocks: self.state = (r, c) return self.state def giveReward(self): if self.state == self.goal: self.end = True return 1 else: return 0 def showMaze(self): self.maze[self.state] = 1 for i in range(0, self.rows): print('-------------------------------------') out = '| ' for j in range(0, self.cols): if self.maze[i, j] == 1: token = '*' if self.maze[i, j] == -1: token = 'z' if self.maze[i, j] == 0: token = '0' out += token + ' | ' print(out) print('-------------------------------------') class PriorityAgent: def __init__(self, exp_rate=0.3, lr=0.1, n_steps=5, episodes=1, theta=0): self.maze = Maze() self.state = S self.actions = ACTIONS self.state_actions = [] # state & action track self.exp_rate = exp_rate self.lr = lr self.steps = n_steps self.episodes = episodes # number of episodes going to play self.steps_per_episode = [] self.Q_values = {} # model function self.model = {} for row in range(ROWS): for col in range(COLS): self.Q_values[(row, col)] = {} for a in self.actions: self.Q_values[(row, col)][a] = 0 # for priority sweeping self.theta = theta self.queue = PriorityQueue() self.predecessors = {} # nxtState -> list[(curState, Action)...] def chooseAction(self): # epsilon-greedy mx_nxt_reward = -999 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action current_position = self.state # if all actions have same value, then select randomly if len(set(self.Q_values[current_position].values())) == 1: action = np.random.choice(self.actions) else: for a in self.actions: nxt_reward = self.Q_values[current_position][a] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward return action def reset(self): self.maze = Maze() self.state = S self.state_actions = [] def play(self): for ep in range(self.episodes): while not self.maze.end: action = self.chooseAction() self.state_actions.append((self.state, action)) nxtState = self.maze.nxtPosition(action) reward = self.maze.giveReward() # update priority queue tmp_diff = reward + np.max(list(self.Q_values[nxtState].values())) - self.Q_values[self.state][action] if tmp_diff > self.theta: self.queue.put((-tmp_diff, (self.state, action))) # -diff -> (state, action) pop the smallest # update model & predecessors if self.state not in self.model.keys(): self.model[self.state] = {} self.model[self.state][action] = (reward, nxtState) if nxtState not in self.predecessors.keys(): self.predecessors[nxtState] = [(self.state, action)] else: self.predecessors[nxtState].append((self.state, action)) self.state = nxtState # loop n times to randomly update Q-value for _ in range(self.steps): if self.queue.empty(): break _state, _action = self.queue.get()[1] _reward, _nxtState = self.model[_state][_action] self.Q_values[_state][_action] += self.lr * (_reward + np.max(list(self.Q_values[_nxtState].values())) - self.Q_values[_state][_action]) # loop for all state, action predicted lead to _state if _state not in self.predecessors.keys(): continue pre_state_action_list = self.predecessors[_state] for (pre_state, pre_action) in pre_state_action_list: pre_reward, _ = self.model[pre_state][pre_action] pre_tmp_diff = pre_reward + np.max(list(self.Q_values[_state].values())) - self.Q_values[pre_state][pre_action] if pre_tmp_diff > self.theta: self.queue.put((-pre_tmp_diff, (pre_state, pre_action))) # end of game if ep % 10 == 0: print("episode", ep) self.steps_per_episode.append(len(self.state_actions)) self.reset() if __name__ == "__main__": pa = PriorityAgent() pa.play() ================================================ FILE: GridWorld/GridBoard-Q.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Grid Board Q-Learning\n", "---\n", "\"drawing\"\n", "\n", "---\n", "When the agent moving up, it has **0.8** probability moving up and **0.1** probability of going left or right. (non-deterministic)\n", "\"drawing\"\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "BOARD_ROWS = 3\n", "BOARD_COLS = 4\n", "WIN_STATE = (0, 3)\n", "LOSE_STATE = (1, 3)\n", "START = (2, 0)\n", "DETERMINISTIC = False" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class State:\n", " def __init__(self, state=START):\n", " self.board = np.zeros([BOARD_ROWS, BOARD_COLS])\n", " self.board[1, 1] = -1\n", " self.state = state\n", " self.isEnd = False\n", " self.determine = DETERMINISTIC\n", " \n", " def giveReward(self):\n", " if self.state == WIN_STATE:\n", " return 1\n", " elif self.state == LOSE_STATE:\n", " return -1\n", " else:\n", " return 0\n", " \n", " def isEndFunc(self):\n", " if (self.state == WIN_STATE) or (self.state == LOSE_STATE):\n", " self.isEnd = True\n", "\n", " def _chooseActionProb(self, action):\n", " if action == \"up\":\n", " return np.random.choice([\"up\", \"left\", \"right\"], p=[0.8, 0.1, 0.1])\n", " if action == \"down\":\n", " return np.random.choice([\"down\", \"left\", \"right\"], p=[0.8, 0.1, 0.1])\n", " if action == \"left\":\n", " return np.random.choice([\"left\", \"up\", \"down\"], p=[0.8, 0.1, 0.1])\n", " if action == \"right\":\n", " return np.random.choice([\"right\", \"up\", \"down\"], p=[0.8, 0.1, 0.1])\n", " \n", " def nxtPosition(self, action):\n", " \"\"\"\n", " action: up, down, left, right\n", " -------------\n", " 0 | 1 | 2| 3|\n", " 1 |\n", " 2 |\n", " return next position on board\n", " \"\"\"\n", " if self.determine:\n", " if action == \"up\":\n", " nxtState = (self.state[0]-1, self.state[1])\n", " elif action == \"down\":\n", " nxtState = (self.state[0]+1, self.state[1])\n", " elif action == \"left\":\n", " nxtState = (self.state[0], self.state[1]-1)\n", " else:\n", " nxtState = (self.state[0], self.state[1]+1)\n", " self.determine = False\n", " else:\n", " # non-deterministic\n", " action = self._chooseActionProb(action)\n", " self.determine = True\n", " nxtState = self.nxtPosition(action)\n", " \n", " # if next state is legal\n", " if (nxtState[0] >= 0) and (nxtState[0] <= 2):\n", " if (nxtState[1] >= 0) and (nxtState[1] <= 3):\n", " if nxtState != (1, 1):\n", " return nxtState\n", " return self.state\n", " \n", " def showBoard(self):\n", " self.board[self.state] = 1\n", " for i in range(0, BOARD_ROWS):\n", " print('-----------------')\n", " out = '| '\n", " for j in range(0, BOARD_COLS):\n", " if self.board[i, j] == 1:\n", " token = '*'\n", " if self.board[i, j] == -1:\n", " token = 'z'\n", " if self.board[i, j] == 0:\n", " token = '0'\n", " out += token + ' | '\n", " print(out)\n", " print('-----------------') " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "class Agent:\n", " \n", " def __init__(self):\n", " self.states = [] # record position and action taken at the position\n", " self.actions = [\"up\", \"down\", \"left\", \"right\"]\n", " self.State = State()\n", " self.isEnd = self.State.isEnd\n", " self.lr = 0.2\n", " self.exp_rate = 0.3\n", " self.decay_gamma = 0.9\n", "\n", " # initial Q values\n", " self.Q_values = {}\n", " for i in range(BOARD_ROWS):\n", " for j in range(BOARD_COLS):\n", " self.Q_values[(i, j)] = {}\n", " for a in self.actions:\n", " self.Q_values[(i, j)][a] = 0 # Q value is a dict of dict \n", " \n", " def chooseAction(self):\n", " # choose action with most expected value\n", " mx_nxt_reward = 0\n", " action = \"\"\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " for a in self.actions:\n", " current_position = self.State.state\n", " nxt_reward = self.Q_values[current_position][a]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " # print(\"current pos: {}, greedy aciton: {}\".format(self.State.state, action))\n", " return action\n", " \n", " def takeAction(self, action):\n", " position = self.State.nxtPosition(action)\n", " # update State\n", " return State(state=position) \n", " \n", " def reset(self):\n", " self.states = []\n", " self.State = State()\n", " self.isEnd = self.State.isEnd\n", " \n", " def play(self, rounds=10):\n", " i = 0\n", " while i < rounds:\n", " # to the end of game back propagate reward\n", " if self.State.isEnd:\n", " # back propagate\n", " reward = self.State.giveReward()\n", " for a in self.actions:\n", " self.Q_values[self.State.state][a] = reward\n", " print(\"Game End Reward\", reward)\n", " for s in reversed(self.states):\n", " current_q_value = self.Q_values[s[0]][s[1]]\n", " reward = current_q_value + self.lr*(self.decay_gamma*reward - current_q_value)\n", " self.Q_values[s[0]][s[1]] = round(reward, 3)\n", " self.reset()\n", " i += 1\n", " else:\n", " action = self.chooseAction()\n", " # append trace\n", " self.states.append([(self.State.state), action])\n", " print(\"current position {} action {}\".format(self.State.state, action))\n", " # by taking the action, it reaches the next state\n", " self.State = self.takeAction(action)\n", " # mark is end\n", " self.State.isEndFunc()\n", " print(\"nxt state\", self.State.state)\n", " print(\"---------------------\")\n", " self.isEnd = self.State.isEnd" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "ag = Agent()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{(0, 0): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (0, 1): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (0, 2): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (0, 3): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (1, 0): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (1, 1): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (1, 2): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (1, 3): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (2, 0): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (2, 1): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (2, 2): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (2, 3): {'up': 0, 'down': 0, 'left': 0, 'right': 0}}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ag.Q_values" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "current position (2, 0) action right\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action up\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action up\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action right\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action down\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action right\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action down\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action down\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action up\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action right\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action down\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action down\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action down\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action right\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action down\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action left\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n" ] } ], "source": [ "ag.play(50)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{(0, 0): {'up': 0.32, 'down': 0.216, 'left': 0.191, 'right': 0.622},\n", " (0, 1): {'up': 0.464, 'down': 0.209, 'left': 0.194, 'right': 0.755},\n", " (0, 2): {'up': 0.339, 'down': 0.042, 'left': 0.262, 'right': 0.871},\n", " (0, 3): {'up': 1, 'down': 1, 'left': 1, 'right': 1},\n", " (1, 0): {'up': 0.379, 'down': 0.107, 'left': 0.038, 'right': 0.187},\n", " (1, 1): {'up': 0, 'down': 0, 'left': 0, 'right': 0},\n", " (1, 2): {'up': 0.167, 'down': 0, 'left': 0.066, 'right': -0.18},\n", " (1, 3): {'up': -1, 'down': -1, 'left': -1, 'right': -1},\n", " (2, 0): {'up': 0.209, 'down': 0.114, 'left': 0.056, 'right': 0.05},\n", " (2, 1): {'up': 0.036, 'down': 0.039, 'left': 0.109, 'right': 0.004},\n", " (2, 2): {'up': 0, 'down': 0.007, 'left': 0.038, 'right': -0.032},\n", " (2, 3): {'up': -0.18, 'down': 0, 'left': 0, 'right': 0}}" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ag.Q_values" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: GridWorld/GridWorld.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Grid Board\n", "---\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 216, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 132, "metadata": {}, "outputs": [], "source": [ "init_reward = np.array([[0.02, 0.03, 0.04, 0], [0.01, 0, 0.02, 0], [0, 0.01, 0.02, 0]])" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "BOARD_ROWS = 3\n", "BOARD_COLS = 4\n", "WIN_STATE = (0, 3)\n", "LOSE_STATE = (1, 3)\n", "START = (2, 0)\n", "DETERMINISTIC = True" ] }, { "cell_type": "code", "execution_count": 192, "metadata": {}, "outputs": [], "source": [ "class State:\n", " def __init__(self, state=START):\n", " self.board = np.zeros([BOARD_ROWS, BOARD_COLS])\n", " self.board[1, 1] = -1\n", " self.state = state\n", " self.isEnd = False\n", " self.determine = DETERMINISTIC\n", " \n", " def giveReward(self):\n", " if self.state == WIN_STATE:\n", " return 1\n", " elif self.state == LOSE_STATE:\n", " return -1\n", " else:\n", " return 0\n", " \n", " def isEndFunc(self):\n", " if (self.state == WIN_STATE) or (self.state == LOSE_STATE):\n", " self.isEnd = True\n", " \n", " def nxtPosition(self, action):\n", " \"\"\"\n", " action: up, down, left, right\n", " -------------\n", " 0 | 1 | 2| 3|\n", " 1 |\n", " 2 |\n", " return next position\n", " \"\"\"\n", " if self.determine:\n", " if action == \"up\":\n", " nxtState = (self.state[0]-1, self.state[1])\n", " elif action == \"down\":\n", " nxtState = (self.state[0]+1, self.state[1])\n", " elif action == \"left\":\n", " nxtState = (self.state[0], self.state[1]-1)\n", " else:\n", " nxtState = (self.state[0], self.state[1]+1)\n", " # if next state legal\n", " if (nxtState[0] >= 0) and (nxtState[0] <= 2):\n", " if (nxtState[1] >= 0) and (nxtState[1] <= 3):\n", " if nxtState != (1, 1):\n", " return nxtState\n", " return self.state\n", " \n", " def showBoard(self):\n", " self.board[self.state] = 1\n", " for i in range(0, BOARD_ROWS):\n", " print('-----------------')\n", " out = '| '\n", " for j in range(0, BOARD_COLS):\n", " if self.board[i, j] == 1:\n", " token = '*'\n", " if self.board[i, j] == -1:\n", " token = 'z'\n", " if self.board[i, j] == 0:\n", " token = '0'\n", " out += token + ' | '\n", " print(out)\n", " print('-----------------') " ] }, { "cell_type": "code", "execution_count": 193, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 0)" ] }, "execution_count": 193, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s = State()\n", "s.state" ] }, { "cell_type": "code", "execution_count": 217, "metadata": {}, "outputs": [], "source": [ "class Agent:\n", " \n", " def __init__(self):\n", " self.states = []\n", " self.actions = [\"up\", \"down\", \"left\", \"right\"]\n", " self.State = State()\n", " self.isEnd = self.State.isEnd\n", " self.lr = 0.2\n", " self.exp_rate = 0.3\n", " \n", " # initial state reward\n", " self.state_values = {}\n", " for i in range(BOARD_ROWS):\n", " for j in range(BOARD_COLS):\n", " self.state_values[(i, j)] = 0 # init_reward[i, j]\n", " \n", " def chooseAction(self):\n", " # choose action with most expected value\n", " mx_nxt_reward = 0\n", " action = \"\"\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " for a in self.actions:\n", " # if the action is deterministic\n", " nxt_reward = self.state_values[self.State.nxtPosition(a)]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " # print(\"current pos: {}, greedy aciton: {}\".format(self.State.state, action))\n", " return action\n", " \n", " def takeAction(self, action):\n", " position = self.State.nxtPosition(action)\n", " return State(state=position) \n", " \n", " def reset(self):\n", " self.states = []\n", " self.State = State()\n", " self.isEnd = self.State.isEnd\n", " \n", " def play(self, rounds=10):\n", " i = 0\n", " while i < rounds:\n", " # to the end of game back propagate reward\n", " if self.State.isEnd:\n", " # back propagate\n", " reward = self.State.giveReward()\n", " # explicitly assign end state to reward values\n", " self.state_values[self.State.state] = reward\n", " print(\"Game End Reward\", reward)\n", " for s in reversed(self.states):\n", " reward = self.state_values[s] + self.lr*(reward - self.state_values[s])\n", " self.state_values[s] = round(reward, 3)\n", " self.reset()\n", " i += 1\n", " else:\n", " action = self.chooseAction()\n", " # append trace\n", " self.states.append(self.State.nxtPosition(action))\n", " print(\"current position {} action {}\".format(self.State.state, action))\n", " # by taking the action, it reaches the next state\n", " self.State = self.takeAction(action)\n", " # mark is end\n", " self.State.isEndFunc()\n", " print(\"nxt state\", self.State.state)\n", " print(\"---------------------\")\n", " self.isEnd = self.State.isEnd\n", " \n", " def showValues(self):\n", " for i in range(0, BOARD_ROWS):\n", " print('----------------------------------')\n", " out = '| '\n", " for j in range(0, BOARD_COLS):\n", " out += str(self.state_values[(i, j)]) + ' | '\n", " print(out)\n", " print('----------------------------------') " ] }, { "cell_type": "code", "execution_count": 218, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action right\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action left\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action up\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action \n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action right\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action left\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action up\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action left\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action right\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action \n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action right\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action up\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action \n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action \n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action down\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action left\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action down\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action down\n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action up\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action \n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action \n", "nxt state (2, 3)\n", "---------------------\n", "current position (2, 3) action up\n", "nxt state (1, 3)\n", "---------------------\n", "Game End Reward -1\n", "current position (2, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action down\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action down\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action up\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action down\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action down\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action down\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action up\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action down\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action up\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action right\n", "nxt state (2, 1)\n", "---------------------\n", "current position (2, 1) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action left\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action down\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action down\n", "nxt state (2, 2)\n", "---------------------\n", "current position (2, 2) action up\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action left\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action down\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action up\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action down\n", "nxt state (1, 2)\n", "---------------------\n", "current position (1, 2) action up\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action down\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action left\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action left\n", "nxt state (2, 0)\n", "---------------------\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n", "current position (2, 0) action up\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action right\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action down\n", "nxt state (1, 0)\n", "---------------------\n", "current position (1, 0) action up\n", "nxt state (0, 0)\n", "---------------------\n", "current position (0, 0) action right\n", "nxt state (0, 1)\n", "---------------------\n", "current position (0, 1) action right\n", "nxt state (0, 2)\n", "---------------------\n", "current position (0, 2) action right\n", "nxt state (0, 3)\n", "---------------------\n", "Game End Reward 1\n" ] } ], "source": [ "ag = Agent()\n", "\n", "ag.play(50)" ] }, { "cell_type": "code", "execution_count": 219, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "----------------------------------\n", "| 0.846 | 0.875 | 0.926 | 1.0 | \n", "----------------------------------\n", "| 0.841 | 0 | 0.332 | -1.0 | \n", "----------------------------------\n", "| 0.759 | 0.063 | -0.054 | -0.526 | \n", "----------------------------------\n" ] } ], "source": [ "ag.showValues()" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: GridWorld/gridWorld.py ================================================ import numpy as np # global variables BOARD_ROWS = 3 BOARD_COLS = 4 WIN_STATE = (0, 3) LOSE_STATE = (1, 3) START = (2, 0) DETERMINISTIC = True class State: def __init__(self, state=START): self.board = np.zeros([BOARD_ROWS, BOARD_COLS]) self.board[1, 1] = -1 self.state = state self.isEnd = False self.determine = DETERMINISTIC def giveReward(self): if self.state == WIN_STATE: return 1 elif self.state == LOSE_STATE: return -1 else: return 0 def isEndFunc(self): if (self.state == WIN_STATE) or (self.state == LOSE_STATE): self.isEnd = True def nxtPosition(self, action): """ action: up, down, left, right ------------- 0 | 1 | 2| 3| 1 | 2 | return next position """ if self.determine: if action == "up": nxtState = (self.state[0] - 1, self.state[1]) elif action == "down": nxtState = (self.state[0] + 1, self.state[1]) elif action == "left": nxtState = (self.state[0], self.state[1] - 1) else: nxtState = (self.state[0], self.state[1] + 1) # if next state legal if (nxtState[0] >= 0) and (nxtState[0] <= (BOARD_ROWS -1)): if (nxtState[1] >= 0) and (nxtState[1] <= (BOARD_COLS -1)): if nxtState != (1, 1): return nxtState return self.state def showBoard(self): self.board[self.state] = 1 for i in range(0, BOARD_ROWS): print('-----------------') out = '| ' for j in range(0, BOARD_COLS): if self.board[i, j] == 1: token = '*' if self.board[i, j] == -1: token = 'z' if self.board[i, j] == 0: token = '0' out += token + ' | ' print(out) print('-----------------') # Agent of player class Agent: def __init__(self): self.states = [] self.actions = ["up", "down", "left", "right"] self.State = State() self.lr = 0.2 self.exp_rate = 0.3 # initial state reward self.state_values = {} for i in range(BOARD_ROWS): for j in range(BOARD_COLS): self.state_values[(i, j)] = 0 # set initial value to 0 def chooseAction(self): # choose action with most expected value mx_nxt_reward = 0 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action for a in self.actions: # if the action is deterministic nxt_reward = self.state_values[self.State.nxtPosition(a)] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward return action def takeAction(self, action): position = self.State.nxtPosition(action) return State(state=position) def reset(self): self.states = [] self.State = State() def play(self, rounds=10): i = 0 while i < rounds: # to the end of game back propagate reward if self.State.isEnd: # back propagate reward = self.State.giveReward() # explicitly assign end state to reward values self.state_values[self.State.state] = reward # this is optional print("Game End Reward", reward) for s in reversed(self.states): reward = self.state_values[s] + self.lr * (reward - self.state_values[s]) self.state_values[s] = round(reward, 3) self.reset() i += 1 else: action = self.chooseAction() # append trace self.states.append(self.State.nxtPosition(action)) print("current position {} action {}".format(self.State.state, action)) # by taking the action, it reaches the next state self.State = self.takeAction(action) # mark is end self.State.isEndFunc() print("nxt state", self.State.state) print("---------------------") def showValues(self): for i in range(0, BOARD_ROWS): print('----------------------------------') out = '| ' for j in range(0, BOARD_COLS): out += str(self.state_values[(i, j)]).ljust(6) + ' | ' print(out) print('----------------------------------') if __name__ == "__main__": ag = Agent() ag.play(50) print(ag.showValues()) ================================================ FILE: GridWorld/gridWorld_Q.py ================================================ import numpy as np BOARD_ROWS = 3 BOARD_COLS = 4 WIN_STATE = (0, 3) LOSE_STATE = (1, 3) START = (2, 0) DETERMINISTIC = False class State: def __init__(self, state=START): self.board = np.zeros([BOARD_ROWS, BOARD_COLS]) self.board[1, 1] = -1 self.state = state self.isEnd = False self.determine = DETERMINISTIC def giveReward(self): if self.state == WIN_STATE: return 1 elif self.state == LOSE_STATE: return -1 else: return 0 def isEndFunc(self): if (self.state == WIN_STATE) or (self.state == LOSE_STATE): self.isEnd = True def _chooseActionProb(self, action): if action == "up": return np.random.choice(["up", "left", "right"], p=[0.8, 0.1, 0.1]) if action == "down": return np.random.choice(["down", "left", "right"], p=[0.8, 0.1, 0.1]) if action == "left": return np.random.choice(["left", "up", "down"], p=[0.8, 0.1, 0.1]) if action == "right": return np.random.choice(["right", "up", "down"], p=[0.8, 0.1, 0.1]) def nxtPosition(self, action): """ action: up, down, left, right ------------- 0 | 1 | 2| 3| 1 | 2 | return next position on board """ if self.determine: if action == "up": nxtState = (self.state[0] - 1, self.state[1]) elif action == "down": nxtState = (self.state[0] + 1, self.state[1]) elif action == "left": nxtState = (self.state[0], self.state[1] - 1) else: nxtState = (self.state[0], self.state[1] + 1) self.determine = False else: # non-deterministic action = self._chooseActionProb(action) self.determine = True nxtState = self.nxtPosition(action) # if next state is legal if (nxtState[0] >= 0) and (nxtState[0] <= 2): if (nxtState[1] >= 0) and (nxtState[1] <= 3): if nxtState != (1, 1): return nxtState return self.state def showBoard(self): self.board[self.state] = 1 for i in range(0, BOARD_ROWS): print('-----------------') out = '| ' for j in range(0, BOARD_COLS): if self.board[i, j] == 1: token = '*' if self.board[i, j] == -1: token = 'z' if self.board[i, j] == 0: token = '0' out += token + ' | ' print(out) print('-----------------') class Agent: def __init__(self): self.states = [] # record position and action taken at the position self.actions = ["up", "down", "left", "right"] self.State = State() self.isEnd = self.State.isEnd self.lr = 0.2 self.exp_rate = 0.3 self.decay_gamma = 0.9 # initial Q values self.Q_values = {} for i in range(BOARD_ROWS): for j in range(BOARD_COLS): self.Q_values[(i, j)] = {} for a in self.actions: self.Q_values[(i, j)][a] = 0 # Q value is a dict of dict def chooseAction(self): # choose action with most expected value mx_nxt_reward = 0 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action for a in self.actions: current_position = self.State.state nxt_reward = self.Q_values[current_position][a] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward # print("current pos: {}, greedy aciton: {}".format(self.State.state, action)) return action def takeAction(self, action): position = self.State.nxtPosition(action) # update State return State(state=position) def reset(self): self.states = [] self.State = State() self.isEnd = self.State.isEnd def play(self, rounds=10): i = 0 while i < rounds: # to the end of game back propagate reward if self.State.isEnd: # back propagate reward = self.State.giveReward() for a in self.actions: self.Q_values[self.State.state][a] = reward print("Game End Reward", reward) for s in reversed(self.states): current_q_value = self.Q_values[s[0]][s[1]] reward = current_q_value + self.lr * (self.decay_gamma * reward - current_q_value) self.Q_values[s[0]][s[1]] = round(reward, 3) self.reset() i += 1 else: action = self.chooseAction() # append trace self.states.append([(self.State.state), action]) print("current position {} action {}".format(self.State.state, action)) # by taking the action, it reaches the next state self.State = self.takeAction(action) # mark is end self.State.isEndFunc() print("nxt state", self.State.state) print("---------------------") self.isEnd = self.State.isEnd if __name__ == "__main__": ag = Agent() print("initial Q-values ... \n") print(ag.Q_values) ag.play(50) print("latest Q-values ... \n") print(ag.Q_values) ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2019 Jeremy Zhang Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: MountainCar/MountainCar.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Mountain Car with gradient SARSA\n", "---\n", "Consider the task of driving an underpowered car up a steep mountain road, as suggested by the diagram. The difficulty is that gravity is stronger than the car’s engine, and even at full throttle the car cannot accelerate up the steep slope. The only solution is to first move away from the goal and up the opposite slope on the left.\n", "\n", "\"drawing\"\n", "\n", "The reward in this problem is -1 on all time steps until the car moves past its goal position at the top of the mountain, which ends the episode. There are three possible actions: full throttle forward (+1), full throttle reverse (01), and zero throttle (0). The car moves according to a simplified physics. Its position, `x_t`, and velocity, `x_ ̇t`, are updated by:\n", "\n", " \"drawing\"\n", "\n", "where the bound operation enforces `-1.2 <= x_t+1 <= 0.5` and `-0.07 <= x_ ̇t+1 <= 0.07`. In addition, when `x_t+1` reached the left bound, `x_ ̇t+1` was reset to zero. When it reached the right bound, the goal was reached and the episode was terminated. Each episode started from a random position `xt` in `[-0.6, -0.4)` and zero velocity.\n", "\n", "---\n", "\n", "# Semi-Gradient SARSA\n", "---\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from TileCoding import *\n", "from mpl_toolkits.mplot3d import Axes3D" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "VELOCITY_BOUND = [-0.07, 0.07]\n", "POSITION_BOUND = [-1.2, 0.5]\n", "ACTIONS = [-1, 0, 1]" ] }, { "cell_type": "code", "execution_count": 120, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "class ValueFunction:\n", " \n", " def __init__(self, stepSize, numOfTilings=8, maxSize=2048):\n", " self.maxSize = maxSize\n", " self.numOfTilings = numOfTilings\n", "\n", " # divide step size equally to each tiling\n", " self.stepSize = stepSize / numOfTilings # learning rate for each tile\n", "\n", " self.hashTable = IHT(maxSize)\n", "\n", " # weight for each tile\n", " self.weights = np.zeros(maxSize)\n", "\n", " # position and velocity needs scaling to satisfy the tile software\n", " self.positionScale = self.numOfTilings / (POSITION_BOUND[1] - POSITION_BOUND[0])\n", " self.velocityScale = self.numOfTilings / (VELOCITY_BOUND[1] - VELOCITY_BOUND[0])\n", "\n", " # get indices of active tiles for given state and action\n", " def getActiveTiles(self, position, velocity, action):\n", " # I think positionScale * (position - position_min) would be a good normalization.\n", " # However positionScale * position_min is a constant, so it's ok to ignore it.\n", " activeTiles = tiles(self.hashTable, self.numOfTilings,\n", " [self.positionScale * position, self.velocityScale * velocity],\n", " [action])\n", " return activeTiles\n", "\n", " # estimate the value of given state and action\n", " def value(self, position, velocity, action):\n", " if position == POSITION_BOUND[1]:\n", " return 0.0\n", " activeTiles = self.getActiveTiles(position, velocity, action)\n", " return np.sum(self.weights[activeTiles])\n", "\n", " # learn with given state, action and target\n", " def update(self, position, velocity, action, target):\n", " activeTiles = self.getActiveTiles(position, velocity, action)\n", " estimation = np.sum(self.weights[activeTiles])\n", " delta = self.stepSize * (target - estimation)\n", " for activeTile in activeTiles:\n", " self.weights[activeTile] += delta\n", "\n", " # get the # of steps to reach the goal under current state value function\n", " def costToGo(self, position, velocity):\n", " costs = []\n", " for action in ACTIONS:\n", " costs.append(self.value(position, velocity, action))\n", " return -np.max(costs)" ] }, { "cell_type": "code", "execution_count": 153, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "class MountainCar:\n", " \n", " def __init__(self, n=1, exp_rate=0.1, gamma=1, debug=True):\n", " self.actions = [-1, 0, 1] # reverse, 0 and forward throttle\n", " self.state = (-0.5, 0) # position, velocity\n", " self.exp_rate = exp_rate\n", " self.gamma = gamma\n", " self.end = False\n", " self.n = n # step of learning\n", " self.debug = debug\n", " \n", " def reset(self):\n", " pos = np.random.uniform(-0.6, -0.4)\n", " self.end = False\n", " self.state = (pos, 0)\n", " \n", " def takeAction(self, action):\n", " pos, vel = self.state\n", " \n", " vel_new = vel + 0.001*action - 0.0025*np.cos(3*pos)\n", " vel_new = min(max(vel_new, VELOCITY_BOUND[0]), VELOCITY_BOUND[1])\n", " \n", " pos_new = pos + vel_new\n", " pos_new = min(max(pos_new, POSITION_BOUND[0]), POSITION_BOUND[1])\n", " \n", " if pos_new == POSITION_BOUND[0]:\n", " # reach leftmost, set speed to 0\n", " vel_new = 0\n", " self.state = (pos_new, vel_new)\n", " return self.state\n", " \n", " def chooseAction(self, valueFunc):\n", " # choose an action based on the current state, \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " # random action\n", " return np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " values = {}\n", " for a in self.actions:\n", " pos, vel = self.state\n", " value = valueFunc.value(pos, vel, a)\n", " values[a] = value\n", " return np.random.choice([k for k, v in values.items() if v==max(values.values())])\n", " \n", " def giveReward(self):\n", " pos, _ = self.state\n", " if pos == POSITION_BOUND[1]:\n", " self.end = True\n", " return 0\n", " return -1\n", " \n", " def play(self, valueFunction, rounds=1):\n", " for rnd in range(1, rounds+1):\n", " self.reset()\n", " t = 0\n", " T = np.inf\n", " action = self.chooseAction(valueFunction)\n", " \n", " actions = [action]\n", " states = [self.state]\n", " rewards = [-1]\n", " while True:\n", " if t < T:\n", " state = self.takeAction(action) # next state\n", " reward = self.giveReward() # next state-reward\n", " \n", " states.append(state)\n", " rewards.append(reward)\n", " \n", " if self.end:\n", " if self.debug:\n", " if rnd % 500 == 0:\n", " print(\"Round {}: End at state {} | number of states {}\".format(rnd, state, len(states)))\n", " T = t+1\n", " else:\n", " action = self.chooseAction(valueFunction)\n", " actions.append(action) # next action\n", " # state tau being updated\n", " tau = t - self.n + 1\n", " if tau >= 0:\n", " G = 0\n", " for i in range(tau+1, min(tau+self.n+1, T+1)):\n", " G += np.power(self.gamma, i-tau-1)*rewards[i]\n", " if tau+self.n < T:\n", " state = states[tau+self.n]\n", " G += np.power(self.gamma, self.n)*valueFunction.value(state[0], state[1], actions[tau+self.n])\n", " # update value function\n", " state = states[tau] # tau is the state to update\n", " \n", "# print(\"update state {} | target {}\".format(state, G))\n", " valueFunction.update(state[0], state[1], actions[tau], G)\n", " \n", " if tau == T-1:\n", " break\n", " \n", " t += 1" ] }, { "cell_type": "code", "execution_count": 131, "metadata": {}, "outputs": [], "source": [ "stepSize = 0.3" ] }, { "cell_type": "code", "execution_count": 138, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Round 500: End at state (0.5, 0.029904315776056498) | number of states 123\n", "Round 1000: End at state (0.5, 0.012319258306671093) | number of states 99\n", "Round 1500: End at state (0.5, 0.024612407508694655) | number of states 117\n", "Round 2000: End at state (0.5, 0.02381792125887026) | number of states 114\n", "Round 2500: End at state (0.5, 0.014565306646017155) | number of states 96\n", "Round 3000: End at state (0.5, 0.027764270870180054) | number of states 155\n", "Round 3500: End at state (0.5, 0.02963349213618522) | number of states 121\n", "Round 4000: End at state (0.5, 0.022014762473616133) | number of states 149\n", "Round 4500: End at state (0.5, 0.030292040531013323) | number of states 149\n", "Round 5000: End at state (0.5, 0.023410524687533383) | number of states 108\n", "Round 5500: End at state (0.5, 0.020164426411566932) | number of states 120\n", "Round 6000: End at state (0.5, 0.020571475244090767) | number of states 154\n", "Round 6500: End at state (0.5, 0.01719074294793684) | number of states 122\n", "Round 7000: End at state (0.5, 0.030770139038505485) | number of states 151\n", "Round 7500: End at state (0.5, 0.020585229878578123) | number of states 116\n", "Round 8000: End at state (0.5, 0.023690062643508175) | number of states 116\n", "Round 8500: End at state (0.5, 0.024026109158524447) | number of states 157\n", "Round 9000: End at state (0.5, 0.02023431926162172) | number of states 115\n" ] } ], "source": [ "valueFunc = ValueFunction(stepSize)\n", "mc = MountainCar()\n", "mc.play(valueFunc, rounds=9000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Visualisation" ] }, { "cell_type": "code", "execution_count": 135, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5,0,'Cost to go')" ] }, "execution_count": 135, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# step 100\n", "grids = 50\n", "\n", "positions = np.linspace(POSITION_BOUND[0], POSITION_BOUND[1], grids)\n", "vels = np.linspace(VELOCITY_BOUND[0], VELOCITY_BOUND[1], grids)\n", "\n", "x = []\n", "y = []\n", "z = []\n", "for p in positions:\n", " for v in vels:\n", " x.append(p)\n", " y.append(v)\n", " z.append(valueFunc.costToGo(p, v))\n", "\n", "fig = plt.figure(figsize=[10, 6])\n", "ax = fig.add_subplot(111, projection='3d')\n", "ax.scatter(x, y, z)\n", "\n", "ax.set_xlabel(\"Position\")\n", "ax.set_ylabel(\"Velocity\")\n", "ax.set_zlabel(\"Cost to go\")" ] }, { "cell_type": "code", "execution_count": 139, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5,0,'Cost to go')" ] }, "execution_count": 139, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# step 9000\n", "grids = 50\n", "\n", "positions = np.linspace(POSITION_BOUND[0], POSITION_BOUND[1], grids)\n", "vels = np.linspace(VELOCITY_BOUND[0], VELOCITY_BOUND[1], grids)\n", "\n", "x = []\n", "y = []\n", "z = []\n", "for p in positions:\n", " for v in vels:\n", " x.append(p)\n", " y.append(v)\n", " z.append(valueFunc.costToGo(p, v))\n", "\n", "fig = plt.figure(figsize=[10, 6])\n", "ax = fig.add_subplot(111, projection='3d')\n", "ax.scatter(x, y, z)\n", "\n", "ax.set_xlabel(\"Position\")\n", "ax.set_ylabel(\"Velocity\")\n", "ax.set_zlabel(\"Cost to go\")" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: MountainCar/MountainCar.py ================================================ import numpy as np import matplotlib.pyplot as plt from TileCoding import * from mpl_toolkits.mplot3d import Axes3D VELOCITY_BOUND = [-0.07, 0.07] POSITION_BOUND = [-1.2, 0.5] ACTIONS = [-1, 0, 1] class ValueFunction: def __init__(self, stepSize, numOfTilings=8, maxSize=2048): self.maxSize = maxSize self.numOfTilings = numOfTilings # divide step size equally to each tiling self.stepSize = stepSize / numOfTilings # learning rate for each tile self.hashTable = IHT(maxSize) # weight for each tile self.weights = np.zeros(maxSize) # position and velocity needs scaling to satisfy the tile software self.positionScale = self.numOfTilings / (POSITION_BOUND[1] - POSITION_BOUND[0]) self.velocityScale = self.numOfTilings / (VELOCITY_BOUND[1] - VELOCITY_BOUND[0]) # get indices of active tiles for given state and action def getActiveTiles(self, position, velocity, action): # I think positionScale * (position - position_min) would be a good normalization. # However positionScale * position_min is a constant, so it's ok to ignore it. activeTiles = tiles(self.hashTable, self.numOfTilings, [self.positionScale * position, self.velocityScale * velocity], [action]) return activeTiles # estimate the value of given state and action def value(self, position, velocity, action): if position == POSITION_BOUND[1]: return 0.0 activeTiles = self.getActiveTiles(position, velocity, action) return np.sum(self.weights[activeTiles]) # learn with given state, action and target def update(self, position, velocity, action, target): activeTiles = self.getActiveTiles(position, velocity, action) estimation = np.sum(self.weights[activeTiles]) delta = self.stepSize * (target - estimation) for activeTile in activeTiles: self.weights[activeTile] += delta # get the # of steps to reach the goal under current state value function def costToGo(self, position, velocity): costs = [] for action in ACTIONS: costs.append(self.value(position, velocity, action)) return -np.max(costs) class MountainCar: def __init__(self, n=1, exp_rate=0.1, gamma=1, debug=True): self.actions = [-1, 0, 1] # reverse, 0 and forward throttle self.state = (-0.5, 0) # position, velocity self.exp_rate = exp_rate self.gamma = gamma self.end = False self.n = n # step of learning self.debug = debug def reset(self): pos = np.random.uniform(-0.6, -0.4) self.end = False self.state = (pos, 0) def takeAction(self, action): pos, vel = self.state vel_new = vel + 0.001 * action - 0.0025 * np.cos(3 * pos) vel_new = min(max(vel_new, VELOCITY_BOUND[0]), VELOCITY_BOUND[1]) pos_new = pos + vel_new pos_new = min(max(pos_new, POSITION_BOUND[0]), POSITION_BOUND[1]) if pos_new == POSITION_BOUND[0]: # reach leftmost, set speed to 0 vel_new = 0 self.state = (pos_new, vel_new) return self.state def chooseAction(self, valueFunc): # choose an action based on the current state, if np.random.uniform(0, 1) <= self.exp_rate: # random action return np.random.choice(self.actions) else: # greedy action values = {} for a in self.actions: pos, vel = self.state value = valueFunc.value(pos, vel, a) values[a] = value return np.random.choice([k for k, v in values.items() if v == max(values.values())]) def giveReward(self): pos, _ = self.state if pos == POSITION_BOUND[1]: self.end = True return 0 return -1 def play(self, valueFunction, rounds=1): for rnd in range(1, rounds + 1): self.reset() t = 0 T = np.inf action = self.chooseAction(valueFunction) actions = [action] states = [self.state] rewards = [-1] while True: if t < T: state = self.takeAction(action) # next state reward = self.giveReward() # next state-reward states.append(state) rewards.append(reward) if self.end: if self.debug: if rnd % 500 == 0: print("Round {}: End at state {} | number of states {}".format(rnd, state, len(states))) T = t + 1 else: action = self.chooseAction(valueFunction) actions.append(action) # next action # state tau being updated tau = t - self.n + 1 if tau >= 0: G = 0 for i in range(tau + 1, min(tau + self.n + 1, T + 1)): G += np.power(self.gamma, i - tau - 1) * rewards[i] if tau + self.n < T: state = states[tau + self.n] G += np.power(self.gamma, self.n) * valueFunction.value(state[0], state[1], actions[tau + self.n]) # update value function state = states[tau] # tau is the state to update valueFunction.update(state[0], state[1], actions[tau], G) if tau == T - 1: break t += 1 if __name__ == "__main__": stepSize = 0.3 valueFunc = ValueFunction(stepSize) mc = MountainCar() mc.play(valueFunc, rounds=100) grids = 50 positions = np.linspace(POSITION_BOUND[0], POSITION_BOUND[1], grids) vels = np.linspace(VELOCITY_BOUND[0], VELOCITY_BOUND[1], grids) x = [] y = [] z = [] for p in positions: for v in vels: x.append(p) y.append(v) z.append(valueFunc.costToGo(p, v)) fig = plt.figure(figsize=[10, 6]) ax = fig.add_subplot(111, projection='3d') ax.scatter(x, y, z) ax.set_xlabel("Position") ax.set_ylabel("Velocity") ax.set_zlabel("Cost to go") ================================================ FILE: MountainCar/TileCoding.py ================================================ """ Tile Coding Software version 3.0beta by Rich Sutton based on a program created by Steph Schaeffer and others External documentation and recommendations on the use of this code is available in the reinforcement learning textbook by Sutton and Barto, and on the web. These need to be understood before this code is. This software is for Python 3 or more. This is an implementation of grid-style tile codings, based originally on the UNH CMAC code (see http://www.ece.unh.edu/robots/cmac.htm), but by now highly changed. Here we provide a function, "tiles", that maps floating and integer variables to a list of tiles, and a second function "tiles-wrap" that does the same while wrapping some floats to provided widths (the lower wrap value is always 0). The float variables will be gridded at unit intervals, so generalization will be by approximately 1 in each direction, and any scaling will have to be done externally before calling tiles. Num-tilings should be a power of 2, e.g., 16. To make the offsetting work properly, it should also be greater than or equal to four times the number of floats. The first argument is either an index hash table of a given size (created by (make-iht size)), an integer "size" (range of the indices from 0), or nil (for testing, indicating that the tile coordinates are to be returned without being converted to indices). """ basehash = hash class IHT: "Structure to handle collisions" def __init__(self, sizeval): self.size = sizeval self.overfullCount = 0 self.dictionary = {} def __str__(self): "Prepares a string for printing whenever this object is printed" return "Collision table:" + \ " size:" + str(self.size) + \ " overfullCount:" + str(self.overfullCount) + \ " dictionary:" + str(len(self.dictionary)) + " items" def count (self): return len(self.dictionary) def fullp (self): return len(self.dictionary) >= self.size def getindex (self, obj, readonly=False): d = self.dictionary if obj in d: return d[obj] elif readonly: return None size = self.size count = self.count() if count >= size: if self.overfullCount==0: print('IHT full, starting to allow collisions') self.overfullCount += 1 return basehash(obj) % self.size else: d[obj] = count return count def hashcoords(coordinates, m, readonly=False): if isinstance(m, IHT): return m.getindex(tuple(coordinates), readonly) if isinstance(m, int): return basehash(tuple(coordinates)) % m if m is None: return coordinates from math import floor, log from six.moves import zip_longest def tiles(ihtORsize, numtilings, floats, ints=[], readonly=False): """returns num-tilings tile indices corresponding to the floats and ints""" qfloats = [floor(f*numtilings) for f in floats] Tiles = [] for tiling in range(numtilings): tilingX2 = tiling*2 coords = [tiling] b = tiling for q in qfloats: coords.append( (q + b) // numtilings ) b += tilingX2 coords.extend(ints) Tiles.append(hashcoords(coords, ihtORsize, readonly)) return Tiles def tileswrap (ihtORsize, numtilings, floats, wrapwidths, ints=[], readonly=False): """returns num-tilings tile indices corresponding to the floats and ints, wrapping some floats""" qfloats = [floor(f*numtilings) for f in floats] Tiles = [] for tiling in range(numtilings): tilingX2 = tiling*2 coords = [tiling] b = tiling for q, width in zip_longest(qfloats, wrapwidths): c = (q + b%numtilings) // numtilings coords.append(c%width if width else c) b += tilingX2 coords.extend(ints) Tiles.append(hashcoords(coords, ihtORsize, readonly)) return Tiles ================================================ FILE: MountainCar(Lambda)/MountainCar(Lambda).ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Sarsa(λ)\n", "---\n", "Very few changes in the ideas already presented in this chapter are required in order to extend eligibility-traces to action-value methods.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from TileCoding import *\n", "from mpl_toolkits.mplot3d import Axes3D" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "VELOCITY_BOUND = [-0.07, 0.07]\n", "POSITION_BOUND = [-1.2, 0.5]\n", "ACTIONS = [-1, 0, 1]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class ValueFunction:\n", " \n", " def __init__(self, stepSize=0.3, numOfTilings=8, maxSize=2048, lam=0.9, gamma=1, method=\"replacing\"):\n", " self.method = method\n", " self.maxSize = maxSize\n", " self.numOfTilings = numOfTilings\n", "\n", " # divide step size equally to each tiling\n", " self.stepSize = stepSize / numOfTilings # learning rate for each tile\n", "\n", " self.hashTable = IHT(maxSize)\n", "\n", " # weight for each tile\n", " self.weights = np.zeros(maxSize)\n", " \n", " # trace vector\n", " self.z = np.zeros(maxSize)\n", " \n", " self.lam = lam\n", " self.gamma = gamma\n", "\n", " # position and velocity needs scaling to satisfy the tile software\n", " self.positionScale = self.numOfTilings / (POSITION_BOUND[1] - POSITION_BOUND[0])\n", " self.velocityScale = self.numOfTilings / (VELOCITY_BOUND[1] - VELOCITY_BOUND[0])\n", "\n", " # get indices of active tiles for given state and action\n", " def getActiveTiles(self, position, velocity, action):\n", " # I think positionScale * (position - position_min) would be a good normalization.\n", " # However positionScale * position_min is a constant, so it's ok to ignore it.\n", " activeTiles = tiles(self.hashTable, self.numOfTilings,\n", " [self.positionScale * position, self.velocityScale * velocity],\n", " [action])\n", " return activeTiles\n", "\n", " # estimate the value of given state and action\n", " def value(self, position, velocity, action):\n", " if position == POSITION_BOUND[1]:\n", " return 0.0\n", " activeTiles = self.getActiveTiles(position, velocity, action)\n", " return np.sum(self.weights[activeTiles])\n", "\n", " # learn with given state, action and target\n", " def update(self, position, velocity, action, target):\n", " activeTiles = self.getActiveTiles(position, velocity, action)\n", " \n", " # update traces\n", " if self.method == \"accumulating\":\n", " self.z *= self.gamma*self.lam\n", " self.z[activeTiles] += 1\n", " \n", " if self.method == \"replacing\":\n", " active = np.isin(range(len(self.z)), activeTiles)\n", " self.z[active] = 1\n", " self.z[~active] *= self.gamma*self.lam\n", " \n", " # update weights\n", " estimation = np.sum(self.weights[activeTiles])\n", " delta = self.stepSize * (target - estimation)\n", " self.weights += self.stepSize*delta*self.z\n", " \n", " # get the # of steps to reach the goal under current state value function\n", " def costToGo(self, position, velocity):\n", " costs = []\n", " for action in ACTIONS:\n", " costs.append(self.value(position, velocity, action))\n", " return -np.max(costs)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "class MountainCar:\n", " \n", " def __init__(self, exp_rate=0.1, debug=True):\n", " self.actions = [-1, 0, 1] # reverse, 0 and forward throttle\n", " self.state = (-0.5, 0) # position, velocity\n", " self.exp_rate = exp_rate\n", " self.end = False\n", " self.debug = debug\n", " \n", " def reset(self):\n", " pos = np.random.uniform(-0.6, -0.4)\n", " self.end = False\n", " self.state = (pos, 0)\n", " \n", " def takeAction(self, action):\n", " pos, vel = self.state\n", " \n", " vel_new = vel + 0.001*action - 0.0025*np.cos(3*pos)\n", " vel_new = min(max(vel_new, VELOCITY_BOUND[0]), VELOCITY_BOUND[1])\n", " \n", " pos_new = pos + vel_new\n", " pos_new = min(max(pos_new, POSITION_BOUND[0]), POSITION_BOUND[1])\n", " \n", " if pos_new == POSITION_BOUND[0]:\n", " # reach leftmost, set speed to 0\n", " vel_new = 0\n", " nxtState = (pos_new, vel_new)\n", " return nxtState\n", " \n", " def chooseAction(self, valueFunc, state):\n", " # choose an action based on given state\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " # random action\n", " return np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " values = {}\n", " for a in self.actions:\n", " pos, vel = state\n", " value = valueFunc.value(pos, vel, a)\n", " values[a] = value\n", " return np.random.choice([k for k, v in values.items() if v==max(values.values())])\n", " \n", " def giveReward(self, state):\n", " # give reward based on state\n", " pos, _ = state\n", " if pos == POSITION_BOUND[1]:\n", " self.end = True\n", " return 0\n", " return -1\n", " \n", " def play(self, valueFunction, rounds=50):\n", " total_steps = 0\n", " for rnd in range(1, rounds+1):\n", " steps = 0\n", " self.reset()\n", " while True:\n", " currentState = self.state\n", " action = self.chooseAction(valueFunction, currentState)\n", " nxtState = self.takeAction(action) # next state\n", " reward = self.giveReward(nxtState) # next state-reward\n", " nxtAction = self.chooseAction(valueFunction, nxtState)\n", " \n", " target = reward + valueFunction.value(nxtState[0], nxtState[1], nxtAction)\n", " valueFunction.update(currentState[0], currentState[1], action, target)\n", " \n", " self.state = nxtState \n", " steps += 1\n", " if self.end:\n", " total_steps += steps\n", " if self.debug: \n", " print(\"number of steps {}\".format(steps))\n", " break\n", " \n", " return total_steps/rounds" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "running alpha 0.25 lambda 0.99\n", "running alpha 0.5 lambda 0.99\n", "running alpha 0.75 lambda 0.99\n", "running alpha 1.0 lambda 0.99\n", "running alpha 1.25 lambda 0.99\n", "running alpha 0.25 lambda 0.95\n", "running alpha 0.5 lambda 0.95\n", "running alpha 0.75 lambda 0.95\n", "running alpha 1.0 lambda 0.95\n", "running alpha 1.25 lambda 0.95\n", "running alpha 0.25 lambda 0.5\n", "running alpha 0.5 lambda 0.5\n", "running alpha 0.75 lambda 0.5\n", "running alpha 1.0 lambda 0.5\n", "running alpha 1.25 lambda 0.5\n", "running alpha 0.25 lambda 0\n", "running alpha 0.5 lambda 0\n", "running alpha 0.75 lambda 0\n", "running alpha 1.0 lambda 0\n", "running alpha 1.25 lambda 0\n" ] } ], "source": [ "rounds = 50\n", "alphas = np.arange(1, 6) / 4.0\n", "lams = [0.99, 0.95, 0.5, 0]\n", "\n", "steps = {}\n", "\n", "# for each lambda\n", "for lam in lams:\n", " steps[lam] = []\n", " for alpha in alphas:\n", " print(\"running alpha {} lambda {}\".format(alpha, lam))\n", " mc = MountainCar(exp_rate=0, debug=False)\n", " valueFunc = ValueFunction(stepSize=alpha, lam=lam, method=\"accumulating\")\n", " avg_step = mc.play(valueFunc, rounds=rounds)\n", " steps[lam].append(avg_step)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "for lam in lams:\n", " plt.plot(alphas, steps[lam], label=\"lambda={}\".format(lam))\n", " \n", "plt.xlabel(\"alpha\")\n", "plt.ylabel(\"number of steps\")\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "rounds = 50\n", "alphas = np.arange(1, 6) / 4.0\n", "lams = [0.99, 0.95, 0.5, 0]\n", "\n", "steps = {}\n", "\n", "# for each lambda\n", "for lam in lams:\n", " steps[lam] = []\n", " for alpha in alphas:\n", " print(\"running alpha {} lambda {}\".format(alpha, lam))\n", " mc = MountainCar(debug=False)\n", " valueFunc = ValueFunction(stepSize=alpha, lam=lam, method=\"replacing\")\n", " avg_step = mc.play(valueFunc, rounds=rounds)\n", " steps[lam].append(avg_step)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "for lam in lams:\n", " plt.plot(alphas, steps[lam], label=\"lambda={}\".format(lam))\n", " \n", "plt.xlabel(\"alpha\")\n", "plt.ylabel(\"number of steps\")\n", "plt.legend()" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: MountainCar(Lambda)/MountainCar.py ================================================ import numpy as np import matplotlib.pyplot as plt from TileCoding import * VELOCITY_BOUND = [-0.07, 0.07] POSITION_BOUND = [-1.2, 0.5] ACTIONS = [-1, 0, 1] class ValueFunction: def __init__(self, stepSize=0.3, numOfTilings=8, maxSize=2048, lam=0.9, gamma=1, method="replacing"): self.method = method self.maxSize = maxSize self.numOfTilings = numOfTilings # divide step size equally to each tiling self.stepSize = stepSize / numOfTilings # learning rate for each tile self.hashTable = IHT(maxSize) # weight for each tile self.weights = np.zeros(maxSize) # trace vector self.z = np.zeros(maxSize) self.lam = lam self.gamma = gamma # position and velocity needs scaling to satisfy the tile software self.positionScale = self.numOfTilings / (POSITION_BOUND[1] - POSITION_BOUND[0]) self.velocityScale = self.numOfTilings / (VELOCITY_BOUND[1] - VELOCITY_BOUND[0]) # get indices of active tiles for given state and action def getActiveTiles(self, position, velocity, action): # I think positionScale * (position - position_min) would be a good normalization. # However positionScale * position_min is a constant, so it's ok to ignore it. activeTiles = tiles(self.hashTable, self.numOfTilings, [self.positionScale * position, self.velocityScale * velocity], [action]) return activeTiles # estimate the value of given state and action def value(self, position, velocity, action): if position == POSITION_BOUND[1]: return 0.0 activeTiles = self.getActiveTiles(position, velocity, action) return np.sum(self.weights[activeTiles]) # learn with given state, action and target def update(self, position, velocity, action, target): activeTiles = self.getActiveTiles(position, velocity, action) # update traces if self.method == "accumulating": self.z *= self.gamma * self.lam self.z[activeTiles] += 1 if self.method == "replacing": active = np.isin(range(len(self.z)), activeTiles) self.z[active] = 1 self.z[~active] *= self.gamma * self.lam # update weights estimation = np.sum(self.weights[activeTiles]) delta = self.stepSize * (target - estimation) self.weights += self.stepSize * delta * self.z # get the # of steps to reach the goal under current state value function def costToGo(self, position, velocity): costs = [] for action in ACTIONS: costs.append(self.value(position, velocity, action)) return -np.max(costs) class MountainCar: def __init__(self, exp_rate=0.1, debug=True): self.actions = [-1, 0, 1] # reverse, 0 and forward throttle self.state = (-0.5, 0) # position, velocity self.exp_rate = exp_rate self.end = False self.debug = debug def reset(self): pos = np.random.uniform(-0.6, -0.4) self.end = False self.state = (pos, 0) def takeAction(self, action): pos, vel = self.state vel_new = vel + 0.001 * action - 0.0025 * np.cos(3 * pos) vel_new = min(max(vel_new, VELOCITY_BOUND[0]), VELOCITY_BOUND[1]) pos_new = pos + vel_new pos_new = min(max(pos_new, POSITION_BOUND[0]), POSITION_BOUND[1]) if pos_new == POSITION_BOUND[0]: # reach leftmost, set speed to 0 vel_new = 0 nxtState = (pos_new, vel_new) return nxtState def chooseAction(self, valueFunc, state): # choose an action based on given state if np.random.uniform(0, 1) <= self.exp_rate: # random action return np.random.choice(self.actions) else: # greedy action values = {} for a in self.actions: pos, vel = state value = valueFunc.value(pos, vel, a) values[a] = value return np.random.choice([k for k, v in values.items() if v == max(values.values())]) def giveReward(self, state): # give reward based on state pos, _ = state if pos == POSITION_BOUND[1]: self.end = True return 0 return -1 def play(self, valueFunction, rounds=50): total_steps = 0 for rnd in range(1, rounds + 1): steps = 0 self.reset() while True: currentState = self.state action = self.chooseAction(valueFunction, currentState) nxtState = self.takeAction(action) # next state reward = self.giveReward(nxtState) # next state-reward nxtAction = self.chooseAction(valueFunction, nxtState) target = reward + valueFunction.value(nxtState[0], nxtState[1], nxtAction) valueFunction.update(currentState[0], currentState[1], action, target) self.state = nxtState steps += 1 if self.end: total_steps += steps if self.debug: print("number of steps {}".format(steps)) break return total_steps / rounds if __name__ == "__main__": rounds = 50 alphas = np.arange(1, 6) / 4.0 lams = [0.99, 0.95, 0.5, 0] steps = {} # for each lambda for lam in lams: steps[lam] = [] for alpha in alphas: print("running alpha {} lambda {}".format(alpha, lam)) mc = MountainCar(exp_rate=0, debug=False) valueFunc = ValueFunction(stepSize=alpha, lam=lam, method="accumulating") avg_step = mc.play(valueFunc, rounds=rounds) steps[lam].append(avg_step) plt.figure(figsize=[10, 6]) for lam in lams: plt.plot(alphas, steps[lam], label="lambda={}".format(lam)) plt.xlabel("alpha") plt.ylabel("number of steps") plt.legend() rounds = 50 alphas = np.arange(1, 6) / 4.0 lams = [0.99, 0.95, 0.5, 0] steps = {} # for each lambda for lam in lams: steps[lam] = [] for alpha in alphas: print("running alpha {} lambda {}".format(alpha, lam)) mc = MountainCar(debug=False) valueFunc = ValueFunction(stepSize=alpha, lam=lam, method="replacing") avg_step = mc.play(valueFunc, rounds=rounds) steps[lam].append(avg_step) plt.figure(figsize=[10, 6]) for lam in lams: plt.plot(alphas, steps[lam], label="lambda={}".format(lam)) plt.xlabel("alpha") plt.ylabel("number of steps") plt.legend() ================================================ FILE: MountainCar(Lambda)/TileCoding.py ================================================ """ Tile Coding Software version 3.0beta by Rich Sutton based on a program created by Steph Schaeffer and others External documentation and recommendations on the use of this code is available in the reinforcement learning textbook by Sutton and Barto, and on the web. These need to be understood before this code is. This software is for Python 3 or more. This is an implementation of grid-style tile codings, based originally on the UNH CMAC code (see http://www.ece.unh.edu/robots/cmac.htm), but by now highly changed. Here we provide a function, "tiles", that maps floating and integer variables to a list of tiles, and a second function "tiles-wrap" that does the same while wrapping some floats to provided widths (the lower wrap value is always 0). The float variables will be gridded at unit intervals, so generalization will be by approximately 1 in each direction, and any scaling will have to be done externally before calling tiles. Num-tilings should be a power of 2, e.g., 16. To make the offsetting work properly, it should also be greater than or equal to four times the number of floats. The first argument is either an index hash table of a given size (created by (make-iht size)), an integer "size" (range of the indices from 0), or nil (for testing, indicating that the tile coordinates are to be returned without being converted to indices). """ basehash = hash class IHT: "Structure to handle collisions" def __init__(self, sizeval): self.size = sizeval self.overfullCount = 0 self.dictionary = {} def __str__(self): "Prepares a string for printing whenever this object is printed" return "Collision table:" + \ " size:" + str(self.size) + \ " overfullCount:" + str(self.overfullCount) + \ " dictionary:" + str(len(self.dictionary)) + " items" def count (self): return len(self.dictionary) def fullp (self): return len(self.dictionary) >= self.size def getindex (self, obj, readonly=False): d = self.dictionary if obj in d: return d[obj] elif readonly: return None size = self.size count = self.count() if count >= size: if self.overfullCount==0: print('IHT full, starting to allow collisions') self.overfullCount += 1 return basehash(obj) % self.size else: d[obj] = count return count def hashcoords(coordinates, m, readonly=False): if isinstance(m, IHT): return m.getindex(tuple(coordinates), readonly) if isinstance(m, int): return basehash(tuple(coordinates)) % m if m is None: return coordinates from math import floor, log from six.moves import zip_longest def tiles(ihtORsize, numtilings, floats, ints=[], readonly=False): """returns num-tilings tile indices corresponding to the floats and ints""" qfloats = [floor(f*numtilings) for f in floats] Tiles = [] for tiling in range(numtilings): tilingX2 = tiling*2 coords = [tiling] b = tiling for q in qfloats: coords.append( (q + b) // numtilings ) b += tilingX2 coords.extend(ints) Tiles.append(hashcoords(coords, ihtORsize, readonly)) return Tiles def tileswrap (ihtORsize, numtilings, floats, wrapwidths, ints=[], readonly=False): """returns num-tilings tile indices corresponding to the floats and ints, wrapping some floats""" qfloats = [floor(f*numtilings) for f in floats] Tiles = [] for tiling in range(numtilings): tilingX2 = tiling*2 coords = [tiling] b = tiling for q, width in zip_longest(qfloats, wrapwidths): c = (q + b%numtilings) // numtilings coords.append(c%width if width else c) b += tilingX2 coords.extend(ints) Tiles.append(hashcoords(coords, ihtORsize, readonly)) return Tiles ================================================ FILE: Multi-ArmBandit/Bandit.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Multi-Arm Bandit\n", "---\n", "**Upper-Confidence-Bound**\n", "\"drawing\"\n", "\n", "where ln t denotes the natural logarithm of t (the number that e = 2.71828 would have to be raised to in order to equal t), Nt(a) denotes the number of times that action a has been selected prior to time t (the denominator in (2.1)), and the number c > 0 controls the degree of exploration. If Nt(a) = 0, then a is considered to be a maximizing action." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "class Bandit:\n", " def __init__(self, k=10, exp_rate=.3, lr=0.1, ucb=False, seed=None, c=2):\n", " self.k = k\n", " self.actions = range(self.k)\n", " self.exp_rate = exp_rate\n", " self.lr = lr\n", " self.total_reward = 0\n", " self.avg_reward = []\n", " \n", " self.TrueValue = []\n", " np.random.seed(seed)\n", " for i in range(self.k):\n", " self.TrueValue.append(np.random.randn()+2) # normal distribution\n", " \n", " self.values = np.zeros(self.k)\n", " # for ucb\n", " self.times = 0\n", " self.action_times = np.zeros(self.k)\n", " \n", " self.ucb = ucb # if select action using upper-confidence-bound\n", " self.c = c\n", " \n", " def chooseAction(self):\n", " # explore\n", " # when ucb is turned on, exp_rate can tune to 0\n", " if np.random.uniform(0, 1) <= self.exp_rate: \n", " action = np.random.choice(self.actions)\n", " else:\n", " # exploit\n", " if self.ucb:\n", " if self.times == 0:\n", " action = np.random.choice(self.actions)\n", " else:\n", " confidence_bound = self.values + self.c*np.sqrt(np.log(self.times)/(self.action_times+0.1)) # c=2\n", " action = np.argmax(confidence_bound)\n", " else:\n", " action = np.argmax(self.values)\n", " return action\n", " \n", " def takeAction(self, action):\n", " self.times += 1\n", " self.action_times[action] += 1\n", " # take action and update value estimates\n", " reward = np.random.randn() + self.TrueValue[action] # add randomness to reward\n", " # using incremental method to propagate\n", " self.values[action] += self.lr * (reward - self.values[action]) # look like fixed lr converges better\n", " \n", " self.total_reward += reward\n", " self.avg_reward.append(self.total_reward/self.times)\n", " \n", " def play(self, n):\n", " for _ in range(n):\n", " action = self.chooseAction()\n", " self.takeAction(action)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "bdt = Bandit(k=5)\n", "bdt.play(2000)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated values [1.95078823 2.93191293 2.95000147 3.21983424 1.59877787]\n", "Actual values [1.5082568528726594, 3.037948384176066, 2.990357118258633, 2.990494170861293, 1.5602678232164846]\n" ] } ], "source": [ "print(\"Estimated values\", bdt.values)\n", "print(\"Actual values\", bdt.TrueValue)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0,0.5,'avg reward')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAELCAYAAAA2mZrgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmcXHWZ7/HP0129b+kknX1pEgJhUSA0DBEXNhFQYFR0UO8gjjOoLx3lOs4MLhcR594ZxzvOiDpy4coVxwWUUWFGmAGVEVECdEKAkASSQEJCtk466X2pqn7uH3WqqHT6dFUnfbo7nO/79apXTp361TlPTlWfp37L+R1zd0RERABKJjsAERGZOpQUREQkR0lBRERylBRERCRHSUFERHKUFEREJEdJQUREcpQUREQkR0lBRERyEpMdwFjNnDnTm5ubJzsMEZFjyurVq/e5e1OhcpElBTOrBB4BKoL93OPuXxxWpgL4HnAmsB/4I3ffOtp2m5ubaW1tjSRmEZHXKjPbVky5KJuPBoAL3P004HTgEjM7Z1iZDwMH3P144B+Br0QYj4iIFBBZUvCM7uBpWfAYPvvelcCdwfI9wIVmZlHFJCIio4u0o9nMSs1sLbAXeMjdHx9WZD6wHcDdU0AHMCPKmEREJFykScHd0+5+OrAAONvMTh1WZKRawWFzeZvZdWbWamatbW1tUYQqIiJM0JBUdz8I/BdwybCXdgALAcwsATQA7SO8/zZ3b3H3lqamgp3nIiJyhCJLCmbWZGbTguUq4CJg47Bi9wEfDJavAn7tuuuPiMikifI6hbnAnWZWSib5/Njd/93MbgZa3f0+4DvAv5jZZjI1hKsjjEdERAqILCm4+zPAGSOsvzFvuR94T1QxRK2jL8n6nZ2sXKq+cRF5bdA0F0foiZfaOe1LD/K+21fx49btkx2OiMi4UFIIseNAL803/ILmG37BgZ7BQ15zd977fx7LPf+re57hF8/sYm9X/0SHKSIyro65uY8myu2PvJhbvmf1Dv7szUtwd/75v7bwrYc3H1b+4z9cA8BXr3o9m/Z209Y1wNfeexr3rt3Jrb/Zwu3XtLBwevWY4xhIpdm0p5vvr9pGQ1UZH37TcQDc8qtNlJjx6OZ9nDKvgY+9ZSn3Pv0KLYunc8HyWZSWvDraNz3kDKaGqCovHfP+RSRe7Fgb7NPS0uITMffRF+9dx52PZaYKecsJTdxx7Vms+PJDdPQlc2Wevelifty6gy//+/qC27tg+SzuuPYstrR18y+PbaN7IMU9q3dwwuxa/uxNS3hPy8JDyncPpCg14+rbV/H09oNjin35nDru/shKXjnQxy2/2sR/PLcbgKdvvJiG6rIxbUtEXhvMbLW7txQsF8ek0NGb5LSbH+Q7H2zhwpNmA7DulQ6S6SFue+RFkmnnlxv2UF1eSu9gOnQ7W//u7QD8pHU7t/x6E9vb+0bd7+cuW87/un/4qNyMPzn3OOqrElxx2jxue+RF7nry0H6KuQ2V7Op4tXnqgysXc96Js9iwu5PNe7v56ZpXDtvmcTNreGlfT+75yXPr+clHV1JToQqiSNwoKYxi3SsdvOMbj3L8rFp++em30Lq1natufeywcnMbKqmpSNDVn2RP5wAA//Ce0+hPpakqK+VdKxYcUv73W/bx/tsfz5X76n8+zz9dfToHe5N89PurD9v+3/zhqdz95HaefaVj1Hhbv3ARM2srgEx/xq6OfuZNqxqxbHrI+dj3V/PIpjaSaefmK0/hnWfM55rvPEHrtgMAfOv9K3j76+cWOEpjl/0u9QymeWj9bpbPqeekufXjvh+RqcLd2dc9SN9gmuTQEGUlJezp6qe0xKivLGPh9CoqEoc326bSQ/QMZs4jezr7qalIUJEooWcwRe9AGrPM33J/cojU0BAHe5Ps6ujj/BNnMau+8ohiVVIYxQt7urj4Hx8B4MnPX8RZ//OXI5a7/ZoWPv+zZ9nblUkIn37rCXzywmWjbrujNwkGDVWHNtNc/o1Hcyf/f//zN3Lq/Ibca99ftY0v/Hxd7nldZYIff2Qlfck0KxY1jv0/GHB3svMLtvcM8t3fb+WWX206pEyixEgNOcvn1PGBP1jEWcdN52dPvcI1K5tZ+/JBmmdWc8q8hkPeM5BKU5EoZW9XP61bDzCYGmJPZz8/bt3OlraeQ8quXDKDU+bVc9/TO1nQWMWSplpm1JbTUFVGR2+SWfWVnN08nfmNVXT3p1g0Y+z9LjK1JNND7DrYz9M7DjKYGqJ5ZjUzayvYvLebjbu76E+mmTetir7BNKUlRmNNOctm1dJYXc7s+goGUkPsONBHZ3+S9u5BOvuTVJeX0tmfYn/3IPVVCXoH0hzoHaSqrJT+VJppVeVUlJUE+3cO9AxSV5lgSVMt02vKmdNQSVmJMbO2gpISoz+ZprMvSWd/is7+JF39KQzYebCPg31JDvYmcRwc5jRUsr29jz1d/aTSQ/QlhzjYO0h7zyBtXQMMpIZCj4UZ1FeWUVNeSmVZKXu7BihPlNAzkBr1fWGufUMzN11xyhF9LkoKo3huZwdvv+VRAM5uns4TWw+bWYPLXjeHf/7AmXzqrqe4d+1O4NXmoiPRN5jm1xv3ctnr5jDaRLD5J/Io7DjQy6Vf/y1d/SkAaisSdA+kRn1PRaKEC0+axf3P7mZGTTn7h43GGu7kufWsXDqDF9u6efyl9lGb4Ib77KXLef8fLKK2IjEux6E/mea5nR0k084Js+uYXlMOZP745zZURnqsj3X9yTRb9/fw0HN7WDSjmoHkEAd6B9nS1s206nIWNlbRWFPOgZ5BaioSrN/ZyTM7Oti4u5PO/tG/U2FKDIbGeEoa63vqKxNFxVeeKMHdSaad8tISZtaWU1lWSl1VGdOqyqirTFBfVcayWbXUV5aRKDUO9iZZOL0K98x1TNvb+2jvGWBv1wDpIWdBYzWD6UwNobaijNTQELPqKkgNOQOpIWrKS6mpSJBKOwPpIWbWlFNaYjRUlVFdnmBmXTlzG0ZuJSik2KQQy8blVPrVb1DYMNLsgf/f7zmNB9bt5i0nHN2cS1XlpUU12UR9klrQWM1T/+OtPPFSOwsaq5nfWEXvYAoz4xu/2sR/Pd/G3GmVzG2o5G2nzOGffrmJtdsPcv+zmc7q/ISwfE4dl546l23tPcypr+QNS2fyxmUzD9nfYGqIJ7e2s7Cxmpl15aSGnC17u1m/q5PZdZXUV5XxwLpdpNLOg+t387cPbORvH9jIgsYqSsxoWdzISXPrWbF4GgOpIabXlNM8o4ay0pLcCCt3xx1eOdjHl/5tPU+8tJ/LXjeXzv4kv9qw95BfZEuaaujqT9EW1P4+8uYlXHXmApbNriOZHsKA0hI75HPo6EuydvtBaisyf8i1lQlm1JTT1Z+irjJBZVm0o7qGhpw9Xf1s3N3F5j3dVJSVsHrbAT507nGcvnBa6Ps27+1mzcsHSKWdBY1VlJWWsHlvF53B/797IMWMmnIqEiU0VJfzyoE+Vr24n5fbeyktsUMGVRSjPFHC6+Y38LZT5nDm4kZOnldPeaKEnQf72Ns5wNJZtZw4p4502tnbNUBTXQX7uwdYt7ODZMpp687EVJEoYfGMamrKEzTVVTCtupyu/iQNVWXMrK2gqz9FdUUpNeUJhtxJlGROxkPBD9wSy5xED/Yl2bq/h/buQfZ2DZAaGmJv5wD7ewaZXlPGnIYq6isT1FdmTvCDqSHmNFTmai/1lWUk00O09wzSFNQw4iCWNYXV29p597cP70PI95mLT+ATF2SaioaGHLPoT9hTUWd/khfbejhtQQNrXj7AqfMbqEiURlKjSaWHeGRTG6u3HeCxLftZ83L4qKuyUmNpUy29g2lebu8dscyMmnLOWNTI3IZKFk2vZv2uTjbu7uJAzyC9g5nqezZhVCRKMIP+ZOb5yiWZq9R3HOwddQBBRaKEJU21nNXcSPOMGk6YXcfze7p4eX8Pf33pcvqTQ9z15MuUmnHyvHrKSkuoq0ywvb2P37zQxqoX99M7mGLR9GrmTauipiLBwd5Bdnf00z2QomcgzSsHw/c/u76CMxc3ZppFzPj1xr0MpNKk0l6wRjdcosQ4Z8kMjp9VS3rImVVXwZyGSmbXV1JXmWBmbQWNNeXUlJdysDfJvu4BBtNDzKip4EDvIEuaakZsP5epQTWFUSTThRNh/giduPxCGEl9ZVnu1+iZi6fn1keRIBOlJVywfDYXLM+MCOvsT7JhZyd9yTTrXulgVn0lncGvv/3dgzywbjfVeddefPiNx/GuFfM5aU49L+zt4vimWhKlo1+f+fst+3jg2d2UJ0oYTA2xfldmNNcLe7py13a8e8UCLj9tLv3JNPu6B1mz7QBD7syur6QvmeaHj7/Mhl2dh237zse2UVpipEPaNszgwuWzqUiU0Lqtna37e+nuTzG3IXMSnl1fSX8yzXknNrG0qZbFM6pZPreeVHqIwdQQd/xuK/u7B3h6e0cucSyaXs38aVW09wxyztIZ/PkFx1ORKGXDrk4MOGFOHdOryykpMeorEwymh+juT9HRl2TetKqiaz2NNeU0Bk1xkGl3l9eGWNYUfrd5Hx/4v4fe7+fbH1jBx36wJvf8hb+5lPKELvieyqLufylWeshxd15u7+WlfT3MaajkuZ2drNl2gPqqMt55xnxm1JSz5uWD7DjQS31VGXUVCVYuncG06vLCOyjClrZu5tRXarixhFJNYRTJ9OG9/tnRQJ+8cBkfP3+pEsIxYCokBCDo2zCWNNWypKkWgFPmNfDeYRckXnLqnMhiWBrsV+RoxTIpvDhs2CTAwunVPP65C5lVVzFlTjYiIhMtlknh5pBpKWYf4UUhIiKvFWojAX70Z+dMdggiIlNCLGsKWddflBlyqpvkiIhkxC4p5HcyX3/RCZMYiYjI1BO75qPslAtfePtJkxyJiMjUE7uk0BckBd1wRkTkcLFLCvt7MnPeVCspiIgcJlZ9Cjf/23ru+N1LADy/u3uSoxERmXpiVVPIJgSAq85cMEpJEZF4ilVSyDejZnzmnBEReS2JbVLI3qVJREReFdszo+Z9FxE5XGyTQmmM75EgIhImlknh7ObphQuJiMRQZEnBzBaa2cNmtsHMnjOzT41Q5jwz6zCztcHjxqjiyadagojIyKK8TiEF/IW7rzGzOmC1mT3k7sPnrf6tu78jwjgOkyhVUhARGUlkNQV33+Xua4LlLmADMD+q/Y1FQjUFEZERTUifgpk1A2cAj4/w8koze9rMHjCzUyYinkI3cxcRiavIp7kws1rgX4Hr3b1z2MtrgMXu3m1mlwE/B5aNsI3rgOsAFi1adNQxqaYgIjKySH8ym1kZmYTwA3f/6fDX3b3T3buD5fuBMjObOUK529y9xd1bmpqajjou1RREREYW5egjA74DbHD3r4WUmROUw8zODuLZH1VMWTsO9Ea9CxGRY1KUzUfnAn8MPGtma4N1nwMWAbj7rcBVwMfMLAX0AVe7u0cYEwBPvXww6l2IiByTIksK7v4oMGrjvbt/E/hmVDGIiMjYqHFdRERylBRERCRHSUFERHJimRTOO/Hoh7WKiLwWxTIpvLdl4WSHICIyJcUyKeiCZhGRkcUyKQTXy4mIyDCxTAolSgoiIiOKaVKY7AhERKammCYFZQURkZHEMinodpwiIiOLTVLIn2dPt+MUERlZjJLCq8vlup+CiMiIYnN2HMrLCmVKCiIiI4rN2TH/Jg1qPhIRGVlskkJ+TaGxunwSIxERmbpikxSyOeGik2Yzb1rV5AYjIjJFxSYpZK1YPG2yQxARmbJilxRERCRcbJJCtvnIRr9ttIhIrMUmKWRphgsRkXCxSQp+yKBUEREZSWySQpYqCiIi4WKTFFwVBRGRgmKTFLLUpyAiEi42SUEVBRGRwmKTFLI0JFVEJFxskoKrU0FEpKDIkoKZLTSzh81sg5k9Z2afGqGMmdktZrbZzJ4xsxVRxfPqPqPeg4jIsSsR4bZTwF+4+xozqwNWm9lD7r4+r8ylwLLg8QfAt4N/x53qCSIihUVWU3D3Xe6+JljuAjYA84cVuxL4nmesAqaZ2dyoYhIRkdFNSJ+CmTUDZwCPD3tpPrA97/kODk8c40JdCiIihUWeFMysFvhX4Hp37xz+8ghvOez0bWbXmVmrmbW2tbUdWSDZCfHUqSAiEirSpGBmZWQSwg/c/acjFNkBLMx7vgDYObyQu9/m7i3u3tLU1HR0MR3Vu0VEXtuiHH1kwHeADe7+tZBi9wHXBKOQzgE63H1XFPFoQjwRkcKiHH10LvDHwLNmtjZY9zlgEYC73wrcD1wGbAZ6gQ9FGA+gIakiIqMJTQpm9g1GGcnp7p8cbcPu/igFWms8c0XZxwvEOC7U0SwiUthozUetwGqgElgBbAoepwPp6EOLhioKIiLhQmsK7n4ngJldC5zv7sng+a3AgxMS3ThSRUFEpLBiOprnAXV5z2uDdcckDUkVEQlXTEfz3wFPmdnDwfO3ADdFFlFENCGeiEhhoyaFYFjpL4EHeHVOohvcfXfUgUVFFQURkXCjJgV3dzP7ubufCdw7QTFFQvUEEZHCiulTWGVmZ0UeyQRRRUFEJFwxfQrnAx8xs21AD5nzqrv76yONbJypS0FEpLBiksKlkUcxkdSpICISqmBScPdtAGY2i8yFbMckzX0kIlJYwT4FM7vCzDYBLwG/AbaSGY10bMlOnT25UYiITGnFdDR/GTgHeMHdjwMuBH4XaVQRUuuRiEi4YpJC0t33AyVmVuLuD5OZ/+iYosYjEZHCiuloPhjcPe0R4AdmthdIRRtWdEwNSCIioYqpKVxJ5l4H/x34D2ALcHmUQUVBQ1JFRAorpqbwR8Bv3X0TcGfE8UROfQoiIuGKSQrNwH8zs2Yy91j4LZkksXaU90w5GpIqIlJYweYjd7/R3S8ATgEeBf6SzM13jkmqKIiIhCtYUzCzL5C533It8BTwGTK1hWOK+hRERAorpvnoXWRGG/2CzMVrq9y9P9KoIqQ+BRGRcMU0H60gc8HaE8BbgWfN7NGoAxtvqiiIiBRWTPPRqcCbyNxxrQXYzjHYfJSl6xRERMIV03z0FTIXrt0CPOnuyWhDioZuxykiUlgxs6S+3cyqgEXHakKAvI5mVRREREIVM0vq5cBaMlczY2anm9l9UQcWFeUEEZFwxUxzcRNwNnAQILhorTm6kEREZLIUkxRS7t4ReSQTxDQmVUQkVDEdzevM7P1AqZktAz4J/D7asMaf+plFRAorpqbw52SmuBgAfgh0ANcXepOZ3WFme81sXcjr55lZh5mtDR43jiXwI6V6gohIuFFrCmZWCnzJ3f8S+PwYt/1d4JvA90Yp81t3f8cYt3tENCGeiEhho9YU3D0NnHkkG3b3R4D2I3lvlNSlICISrpg+haeCIag/AXqyK939p+Ow/5Vm9jSwE/iMuz83UiEzuw64DmDRokVHtCP1KYiIFFZMUpgO7AcuyFvnwNEmhTXAYnfvNrPLgJ8Dy0Yq6O63AbcBtLS0HNXpXTUFEZFwxVzR/KEoduzunXnL95vZP5vZTHffF8n+otioiMhrTDGjjyJhZnMsuGjAzM4OYtkf+X41/khEJFQxzUdHxMx+BJwHzDSzHcAXgTIAd78VuAr4mJmlgD7gao9w1jpNiCciUlhkScHd31fg9W+SGbI6odSnICISrpj7KXx6hNUdwOpgHqRjguoJIiKFFdOn0AJ8FJgfPK4j0yx0u5n9VXShjS+1HomIFFZM89EMYIW7dwOY2ReBe4A3A6uBv48uvPGnCfFERMIVU1NYBAzmPU+Sub6gj8x8SMcIVRVERAoppqbwQ2CVmd0bPL8c+JGZ1QDrI4ssIqoniIiEK+bitS+b2f3AG8mcUz/q7q3Byx+IMrjxpD4FEZHCihl99HXgbnf/+gTEEzl1KYiIhCumT2EN8AUz22xmXzWzlqiDioIqCiIihRVMCu5+p7tfRuY+zS8AXzGzTZFHFhFNcyEiEm4scx8dDywHmoGNkUQTIfUpiIgUVjApmFm2ZnAz8BxwprtfHnlkEVGfgohIuGKGpL4ErIxqSuuJottxiogUVsyQ1FvNrDGY3royb/0jkUYWEVUURETCFTMk9U+BTwELgLXAOcBjHHontilPfQoiIoUV09H8KeAsYJu7nw+cAbRFGlUEsklBfQoiIuGKSQr97t4PYGYV7r4RODHasKKkrCAiEqaYjuYdZjYN+DnwkJkdAHZGG9b4U0eziEhhxXQ0vzNYvMnMHgYagP+INKoIqflIRCTcmG7H6e6/iSqQqKmjWUSksLFc0fyaoIqCiEi42CUFEREJF7ukoNtxioiEi01SUJ+CiEhhsUkKWaoniIiEi01S0HUKIiKFxSYpZKlLQUQkXGySgvoUREQKiywpmNkdZrbXzNaFvG5mdktw7+dnzGxFVLEcut+J2IuIyLEpyprCd4FLRnn9UmBZ8LgO+HaEsahHQUSkCJElheAmPO2jFLkS+J5nrAKmmdncCOMBwDT+SEQk1GT2KcwHtuc93xGsi5ZygohIqMlMCiOdnkds5TGz68ys1cxa29qO7P4+aj4SESlsMpPCDmBh3vMFhNynwd1vc/cWd29pamo6qp2qoiAiEm4yk8J9wDXBKKRzgA533xXVzjQkVUSksDHdT2EszOxHwHnATDPbAXwRKANw91uB+4HLgM1AL/ChqGIZFtdE7EZE5JgUWVJw9/cVeN2Bj0e1/xH2OHG7EhE5RsXmiuYs1RNERMLFJimoT0FEpLDYJIUsdSmIiISLTVJQRUFEpLDYJIUsTXMhIhIuNklBfQoiIoXFKCkEE+KpoiAiEio2SSFLOUFEJFxskoJaj0RECotNUshRVUFEJFRskoI6mkVECotNUsjSkFQRkXCxSQquXgURkYJikxSyNCRVRCRcfJKCKgoiIgXFJykEVFEQEQkXm6SgioKISGGxSQpZuh2niEi42CQFXacgIlJYbJJClioKIiLhYpMUdJ2CiEhh8UkKQU5QRUFEJFxskkKWmo9ERMLFJimo8UhEpLDYJIVXqaogIhImNknBNSZVRKSg2CSFLPUpiIiEi01SUD1BRKSwSJOCmV1iZs+b2WYzu2GE1681szYzWxs8/jTKeEA9CiIio0lEtWEzKwW+BbwV2AE8aWb3ufv6YUXvdvdPRBVHjqoKIiIFRVlTOBvY7O4vuvsgcBdwZYT7K4omxBMRCRdlUpgPbM97viNYN9y7zewZM7vHzBZGFYymuRARKSzKpDDST/LhZ+Z/A5rd/fXAL4E7R9yQ2XVm1mpmrW1tbeMelIiIZESZFHYA+b/8FwA78wu4+353Hwie3g6cOdKG3P02d29x95ampqYjCkaXKYiIFBZlUngSWGZmx5lZOXA1cF9+ATObm/f0CmBDVMHkJsRTVUFEJFRko4/cPWVmnwD+EygF7nD358zsZqDV3e8DPmlmVwApoB24Nqp4skwNSCIioSJLCgDufj9w/7B1N+Ytfxb4bJQx5PY1ETsRETnGxeaK5iw1H4mIhItNUtCEeCIihcUmKYiISGGxSQqqJ4iIFBabpJClPgURkXCxSQrqUhARKSw2SSFL1ymIiISLUVJQVUFEpJAYJYUM9SmIiISLTVJQn4KISGGxSQpZqimIiISLTVJQRUFEpLD4JIXs1NkafSQiEio2SSFLzUciIuFikxQaa8o4u3k6VWWlkx2KiMiUFen9FKaSNyydyRuWzpzsMEREprTY1BRERKQwJQUREclRUhARkRwlBRERyVFSEBGRHCUFERHJUVIQEZEcJQUREckxP8bmlDazNmDbEb59JrBvHMMZL1M1Lpi6sSmusVFcY/NajGuxuzcVKnTMJYWjYWat7t4y2XEMN1Xjgqkbm+IaG8U1NnGOS81HIiKSo6QgIiI5cUsKt012ACGmalwwdWNTXGOjuMYmtnHFqk9BRERGF7eagoiIjCI2ScHMLjGz581ss5ndMMH7XmhmD5vZBjN7zsw+Fay/ycxeMbO1weOyvPd8Noj1eTN7W4SxbTWzZ4P9twbrppvZQ2a2Kfi3MVhvZnZLENczZrYiophOzDsma82s08yun4zjZWZ3mNleM1uXt27Mx8fMPhiU32RmH4worq+a2cZg3z8zs2nB+mYz68s7brfmvefM4PPfHMR+VPcmDIlrzJ/beP+9hsR1d15MW81sbbB+Io9X2Llh8r5j7v6afwClwBZgCVAOPA2cPIH7nwusCJbrgBeAk4GbgM+MUP7kIMYK4Lgg9tKIYtsKzBy27u+BG4LlG4CvBMuXAQ8ABpwDPD5Bn91uYPFkHC/gzcAKYN2RHh9gOvBi8G9jsNwYQVwXA4lg+St5cTXnlxu2nSeAlUHMDwCXRhDXmD63KP5eR4pr2Ov/ANw4Cccr7Nwwad+xuNQUzgY2u/uL7j4I3AVcOVE7d/dd7r4mWO4CNgDzR3nLlcBd7j7g7i8Bm8n8HybKlcCdwfKdwB/mrf+eZ6wCppnZ3IhjuRDY4u6jXbAY2fFy90eA9hH2N5bj8zbgIXdvd/cDwEPAJeMdl7s/6O6p4OkqYMFo2whiq3f3xzxzZvle3v9l3OIaRdjnNu5/r6PFFfzafy/wo9G2EdHxCjs3TNp3LC5JYT6wPe/5DkY/KUfGzJqBM4DHg1WfCKqBd2SriExsvA48aGarzey6YN1sd98FmS8tMGsS4sq6mkP/WCf7eMHYj89kHLc/IfOLMus4M3vKzH5jZm8K1s0PYpmIuMbyuU308XoTsMfdN+Wtm/DjNezcMGnfsbgkhZHa/SZ82JWZ1QL/Clzv7p3At4GlwOnALjJVWJjYeM919xXApcDHzezNo5Sd0ONoZuXAFcBPglVT4XiNJiyOiT5unwdSwA+CVbuARe5+BvBp4IdmVj+BcY31c5voz/N9HPrDY8KP1wjnhtCiITGMW2xxSQo7gIV5zxcAOycyADMrI/Oh/8Ddfwrg7nvcPe3uQ8DtvNrkMWHxuvvO4N+9wM+CGPZkm4WCf/dOdFyBS4E17r4niHHSj1dgrMdnwuILOhjfAXwgaOIgaJ7ZHyyvJtNef0IQV34TUyRxHcHnNpHHKwG8C7g7L94JPV4jnRuYxO9YXJKwkSSgAAAC6UlEQVTCk8AyMzsu+PV5NXDfRO08aLP8DrDB3b+Wtz6/Pf6dQHZkxH3A1WZWYWbHAcvIdHCNd1w1ZlaXXSbTUbku2H929MIHgXvz4romGAFxDtCRreJG5JBfcJN9vPKM9fj8J3CxmTUGTScXB+vGlZldAvw1cIW79+atbzKz0mB5CZnj82IQW5eZnRN8R6/J+7+MZ1xj/dwm8u/1ImCju+eahSbyeIWdG5jM79jR9JwfSw8yvfYvkMn6n5/gfb+RTFXuGWBt8LgM+Bfg2WD9fcDcvPd8Poj1eY5yhMMocS0hM7LjaeC57HEBZgC/AjYF/04P1hvwrSCuZ4GWCI9ZNbAfaMhbN+HHi0xS2gUkyfwa+/CRHB8ybfybg8eHIoprM5l25ex37Nag7LuDz/dpYA1wed52WsicpLcA3yS4oHWc4xrz5zbef68jxRWs/y7w0WFlJ/J4hZ0bJu07piuaRUQkJy7NRyIiUgQlBRERyVFSEBGRHCUFERHJUVIQEZEcJQUREclRUhA5SmZ2s5ldFCxfb2bVkx2TyJHSdQoi48jMtpK5oGjfGN5T6u7p6KISKZ5qCiIjsMyNVjaY2e2WufnJg2ZWFVL2u2Z2lZl9EpgHPGxmDwevXWxmj5nZGjP7STDxWfbmRjea2aPAeybsPyZSgJKCSLhlwLfc/RTgIJnpD0K5+y1kJiE7393PN7OZwBeAizwzE20rmVk3s/rd/Y3uflc04YuMXWKyAxCZwl5y97XB8moyd+Qai3PI3EXrd5l5zygHHst7/e6R3iQymZQURMIN5C2ngRGbj0ZhZO6G9b6Q13uOKCqRCKn5SGR8dZG51y5kbol5rpkdD2Bm1WZ2wqRFJlIEJQWR8XUb8ICZPezubcC1wI/M7BkySWL5ZAYnUoiGpIqISI5qCiIikqOOZpEimdm3gHOHrf66u/+/yYhHJApqPhIRkRw1H4mISI6SgoiI5CgpiIhIjpKCiIjkKCmIiEjO/wf5/Wd1i4h9RwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(bdt.avg_reward)\n", "plt.xlabel(\"n_iter\")\n", "plt.ylabel(\"avg reward\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Epsilon-Greedy with different exploration rate" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated values [2.6600613 0.65143855 3.80596176 2.25201666 1.16469527]\n", "Actual values [2.471435163732493, 0.8090243052935355, 3.432706968426097, 1.6873481039082872, 1.2794112666349884]\n" ] } ], "source": [ "bdt = Bandit(k=5, exp_rate=0.1, seed=1234)\n", "bdt.play(2000)\n", "\n", "print(\"Estimated values\", bdt.values)\n", "print(\"Actual values\", bdt.TrueValue)\n", "\n", "avg_reward1 = bdt.avg_reward" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated values [2.54927187 0.84413741 3.34851036 1.89580542 1.56265398]\n", "Actual values [2.471435163732493, 0.8090243052935355, 3.432706968426097, 1.6873481039082872, 1.2794112666349884]\n" ] } ], "source": [ "bdt = Bandit(k=5, exp_rate=0.3, seed=1234)\n", "bdt.play(2000)\n", "\n", "print(\"Estimated values\", bdt.values)\n", "print(\"Actual values\", bdt.TrueValue)\n", "\n", "avg_reward2 = bdt.avg_reward" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[8, 6])\n", "plt.plot(avg_reward1, label=\"exp_rate=0.1\")\n", "plt.plot(avg_reward2, label=\"exp_rate=0.3\")\n", "\n", "plt.xlabel(\"n_iter\", fontsize=14)\n", "plt.ylabel(\"avg reward\", fontsize=14)\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### UCB" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated values [2.55646074 0.65063447 3.80596236 2.20346295 1.16551876]\n", "Actual values [2.471435163732493, 0.8090243052935355, 3.432706968426097, 1.6873481039082872, 1.2794112666349884]\n" ] } ], "source": [ "bdt = Bandit(k=5, exp_rate=0.1, seed=1234, ucb=True, c=2)\n", "bdt.play(2000)\n", "\n", "print(\"Estimated values\", bdt.values)\n", "print(\"Actual values\", bdt.TrueValue)\n", "\n", "avg_reward3 = bdt.avg_reward" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated values [2.36562833 0.65999917 3.80596156 2.06576659 1.14479614]\n", "Actual values [2.471435163732493, 0.8090243052935355, 3.432706968426097, 1.6873481039082872, 1.2794112666349884]\n" ] } ], "source": [ "bdt = Bandit(k=5, exp_rate=0.1, seed=1234, ucb=True, c=5)\n", "bdt.play(2000)\n", "\n", "print(\"Estimated values\", bdt.values)\n", "print(\"Actual values\", bdt.TrueValue)\n", "\n", "avg_reward4 = bdt.avg_reward" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[8, 6])\n", "plt.plot(avg_reward1, label=\"exp_rate=0.1\")\n", "plt.plot(avg_reward2, label=\"exp_rate=0.3\")\n", "plt.plot(avg_reward3, label=\"ucb, c=2\")\n", "plt.plot(avg_reward4, label=\"ucb, c=5\")\n", "\n", "plt.xlabel(\"n_iter\", fontsize=14)\n", "plt.ylabel(\"avg reward\", fontsize=14)\n", "plt.legend()" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: Multi-ArmBandit/bandit.py ================================================ import numpy as np import matplotlib.pyplot as plt class Bandit: def __init__(self, k=10, exp_rate=.3, lr=0.1, ucb=False, seed=None, c=2): self.k = k self.actions = range(self.k) self.exp_rate = exp_rate self.lr = lr self.total_reward = 0 self.avg_reward = [] self.TrueValue = [] np.random.seed(seed) for i in range(self.k): self.TrueValue.append(np.random.randn() + 2) # normal distribution self.values = np.zeros(self.k) self.times = 0 self.action_times = np.zeros(self.k) self.ucb = ucb # if select action using upper-confidence-bound self.c = c def chooseAction(self): # explore if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # exploit if self.ucb: if self.times == 0: action = np.random.choice(self.actions) else: confidence_bound = self.values + self.c * np.sqrt( np.log(self.times) / (self.action_times + 0.1)) # c=2 action = np.argmax(confidence_bound) else: action = np.argmax(self.values) return action def takeAction(self, action): self.times += 1 self.action_times[action] += 1 # take action and update value estimates # reward = self.TrueValue[action] reward = np.random.randn() + self.TrueValue[action] # add randomness to reward # using incremental method to propagate self.values[action] += self.lr * (reward - self.values[action]) # look like fixed lr converges better self.total_reward += reward self.avg_reward.append(self.total_reward / self.times) def play(self, n): for _ in range(n): action = self.chooseAction() self.takeAction(action) if __name__ == "__main__": bdt = Bandit(k=5, exp_rate=0.1, seed=1234) bdt.play(2000) print("Estimated values", bdt.values) print("Actual values", bdt.TrueValue) avg_reward1 = bdt.avg_reward bdt = Bandit(k=5, exp_rate=0.3, seed=1234) bdt.play(2000) print("Estimated values", bdt.values) print("Actual values", bdt.TrueValue) avg_reward2 = bdt.avg_reward bdt = Bandit(k=5, exp_rate=0.1, seed=1234, ucb=True, c=2) bdt.play(2000) print("Estimated values", bdt.values) print("Actual values", bdt.TrueValue) avg_reward3 = bdt.avg_reward bdt = Bandit(k=5, exp_rate=0.1, seed=1234, ucb=True, c=5) bdt.play(2000) print("Estimated values", bdt.values) print("Actual values", bdt.TrueValue) avg_reward4 = bdt.avg_reward # reward plot plt.figure(figsize=[8, 6]) plt.plot(avg_reward1, label="exp_rate=0.1") plt.plot(avg_reward2, label="exp_rate=0.3") plt.plot(avg_reward3, label="ucb, c=2") plt.plot(avg_reward4, label="ucb, c=5") plt.xlabel("n_iter", fontsize=14) plt.ylabel("avg reward", fontsize=14) plt.legend() ================================================ FILE: README.md ================================================ # Reinforcement Learning Algorithms Implementation --- Reinforcement Learning Examples In each file, there is a jupyter notebook and its corresponding python file. Where in the note book records all the intermediate process and plots, in the python file is the compiled process you can run directly. ## Grid World - [Determnistic Grid World with Value Iteration](https://medium.com/@zhangyue9306/reinforcement-learning-implement-grid-world-from-scratch-c5963765ebff) - [Non-Deterministic Grid World with Q-Learning](https://medium.com/@zhangyue9306/implement-grid-world-with-q-learning-51151747b455) ## Tic Tac Toe - [Tic-Tac-Toe Python Implementation](https://medium.com/@zhangyue9306/reinforcement-learning-implement-tictactoe-189582bea542) ## Muilti-Arm Bandit - [Muilti-Arm Bandit Implementation](https://medium.com/@zhangyue9306/reinforcement-learning-multi-arm-bandit-implementation-5399ef67b24b) ## Blackjack - [Monte Carlo Simulation on Blackjack](https://medium.com/@zhangyue9306/monte-carlo-methods-estimate-blackjack-policy-fcc89df7f029) - [Blackjack Solution](https://towardsdatascience.com/reinforcement-learning-solving-blackjack-5e31a7fb371f) ## Cliff Walking - [Cliff Walking Implementation](https://towardsdatascience.com/reinforcement-learning-cliff-walking-implementation-e40ce98418d4) ## Random Walk(n-step TD method) - [Random Walk Implementation](https://medium.com/@zhangyue9306/n-step-td-method-157d3875b9cb) ## DynaMaze - [DynaMaze Implementation](https://towardsdatascience.com/reinforcement-learning-model-based-planning-methods-5e99cae0abb8) - [DynaMaze Extensions Implementation](https://towardsdatascience.com/reinforcement-learning-model-based-planning-methods-extension-572dfee4cceb) ## Random Walk(General) - [1000-State Random Walk](https://medium.com/@zhangyue9306/reinforcement-learning-generalisation-in-continuous-state-space-df943b04ebfa) ## Tile Coding - [Tile Coding Implementation](https://towardsdatascience.com/reinforcement-learning-tile-coding-implementation-7974b600762b) ## Mountain Car - [On-policy Function Approximation](https://towardsdatascience.com/reinforcement-learning-on-policy-function-approximation-2f47576f772d) ## Server Access - [Generalisation on Continuing Tasks](https://towardsdatascience.com/reinforcement-learning-generalisation-on-continuing-tasks-ffb9a89d57d0) ## Baird Counter Example - [Generalisation of Off-Policy Learning](https://towardsdatascience.com/reinforcement-learning-generalisation-of-off-policy-learning-61468b0bc138) ## TD-Lambda - [Random Walk offline-Lambda](https://towardsdatascience.com/reinforcement-learning-td-%CE%BB-introduction-686a5e4f4e60) - [Random Walk TD(\lambda)](https://medium.com/@zhangyue9306/reinforcement-learning-td-%CE%BB-introduction-2-f0ea427cd395) ## Mountain Car-Lambda - [Sarsa-Lambda](https://towardsdatascience.com/reinforcement-learning-td-%CE%BB-introduction-3-f329bdbf872a) ## Policy Approximation - [Short-Corridor](https://towardsdatascience.com/reinforcement-learning-policy-approximation-f5606ad3d909) ================================================ FILE: RandomWalk/RandomWalk(n-step).ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Randow Walk\n", "---\n", "## n-step TD Method\n", "\n", "\"drawing\"\n", "\n", "In this MRP, all episodes start in the center state, C, then proceed either left or right by one state on each step, with equal probability. Episodes terminate either on the extreme left or the extreme right. When an episode terminates on the right, a reward of +1 occurs; all other rewards are zero.\n", "\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# 19 states (not including the ending state)\n", "NUM_STATES = 19\n", "START = 9\n", "END_0 = 0\n", "END_1 = 20" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [], "source": [ "class RandomWalk:\n", " \n", " def __init__(self, n, start=START, end=False, lr=0.1, gamma=1, debug=False):\n", " self.actions = [\"left\", \"right\"]\n", " self.state = start # current state\n", " self.end = end\n", " self.n = n\n", " self.lr = lr\n", " self.gamma = gamma\n", " self.state_actions = []\n", " self.debug = debug\n", " # init q estimates\n", " self.Q_values = {}\n", " for i in range(NUM_STATES+2): \n", " self.Q_values[i] = {}\n", " for a in self.actions:\n", " if i in [END_0, END_1]:\n", " # explicitly set end state values\n", " if i == END_0:\n", " self.Q_values[i][a] = -1\n", " else:\n", " self.Q_values[i][a] = 1 \n", " else:\n", " self.Q_values[i][a] = 0\n", " \n", " def chooseAction(self): \n", " action = np.random.choice(self.actions)\n", " return action \n", " \n", " def takeAction(self, action):\n", " new_state = self.state\n", " if not self.end:\n", " if action == \"left\":\n", " new_state = self.state-1\n", " else:\n", " new_state = self.state+1\n", " \n", " if new_state in [END_0, END_1]:\n", " self.end = True\n", " self.state = new_state\n", " return self.state\n", " \n", " def giveReward(self):\n", " if self.state == END_0:\n", " return -1\n", " if self.state == END_1:\n", " return 1\n", " # other states\n", " return 0\n", " \n", " def reset(self):\n", " self.state = START\n", " self.end = False\n", " \n", " def play(self, rounds=100):\n", " for _ in range(rounds):\n", " self.reset()\n", " t = 0\n", " T = np.inf\n", " action = self.chooseAction()\n", " \n", " actions = [action]\n", " states = [self.state]\n", " rewards = [0]\n", " while True:\n", " if t < T:\n", " state = self.takeAction(action) # next state\n", " reward = self.giveReward() # next state-reward\n", " \n", " states.append(state)\n", " rewards.append(reward)\n", " \n", " if self.end:\n", " if self.debug:\n", " print(\"End at state {} | number of states {}\".format(state, len(states)))\n", " T = t+1\n", " else:\n", " action = self.chooseAction()\n", " actions.append(action) # next action\n", " # state tau being updated\n", " tau = t - self.n + 1\n", " if tau >= 0:\n", " G = 0\n", " for i in range(tau+1, min(tau+self.n+1, T+1)):\n", " G += np.power(self.gamma, i-tau-1)*rewards[i]\n", " if tau+self.n < T:\n", " state_action = (states[tau+self.n], actions[tau+self.n])\n", " G += np.power(self.gamma, self.n)*self.Q_values[state_action[0]][state_action[1]]\n", " # update Q values\n", " state_action = (states[tau], actions[tau])\n", " self.Q_values[state_action[0]][state_action[1]] += self.lr*(G-self.Q_values[state_action[0]][state_action[1]])\n", " \n", " if tau == T-1:\n", " break\n", " \n", " t += 1" ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "End at state 0 | number of states 128\n", "End at state 20 | number of states 54\n", "End at state 0 | number of states 62\n", "End at state 20 | number of states 78\n", "End at state 20 | number of states 120\n", "End at state 20 | number of states 162\n", "End at state 20 | number of states 28\n", "End at state 20 | number of states 96\n", "End at state 20 | number of states 64\n", "End at state 20 | number of states 22\n", "End at state 20 | number of states 58\n", "End at state 0 | number of states 20\n", "End at state 0 | number of states 112\n", "End at state 20 | number of states 178\n", "End at state 20 | number of states 34\n", "End at state 20 | number of states 94\n", "End at state 20 | number of states 194\n", "End at state 20 | number of states 28\n", "End at state 0 | number of states 32\n", "End at state 20 | number of states 28\n", "End at state 20 | number of states 32\n", "End at state 20 | number of states 196\n", "End at state 0 | number of states 22\n", "End at state 0 | number of states 94\n", "End at state 20 | number of states 270\n", "End at state 0 | number of states 70\n", "End at state 0 | number of states 30\n", "End at state 0 | number of states 20\n", "End at state 0 | number of states 134\n", "End at state 20 | number of states 78\n", "End at state 0 | number of states 146\n", "End at state 0 | number of states 134\n", "End at state 20 | number of states 196\n", "End at state 20 | number of states 18\n", "End at state 0 | number of states 26\n", "End at state 0 | number of states 36\n", "End at state 20 | number of states 94\n", "End at state 0 | number of states 110\n", "End at state 0 | number of states 114\n", "End at state 0 | number of states 64\n", "End at state 20 | number of states 52\n", "End at state 20 | number of states 54\n", "End at state 0 | number of states 26\n", "End at state 0 | number of states 202\n", "End at state 0 | number of states 18\n", "End at state 20 | number of states 64\n", "End at state 0 | number of states 128\n", "End at state 0 | number of states 212\n", "End at state 20 | number of states 26\n", "End at state 20 | number of states 54\n", "End at state 0 | number of states 234\n", "End at state 20 | number of states 56\n", "End at state 0 | number of states 110\n", "End at state 0 | number of states 24\n", "End at state 20 | number of states 154\n", "End at state 0 | number of states 184\n", "End at state 0 | number of states 66\n", "End at state 0 | number of states 46\n", "End at state 0 | number of states 144\n", "End at state 0 | number of states 212\n", "End at state 20 | number of states 388\n", "End at state 20 | number of states 46\n", "End at state 20 | number of states 64\n", "End at state 0 | number of states 42\n", "End at state 20 | number of states 88\n", "End at state 0 | number of states 138\n", "End at state 0 | number of states 104\n", "End at state 20 | number of states 134\n", "End at state 20 | number of states 32\n", "End at state 20 | number of states 24\n", "End at state 20 | number of states 48\n", "End at state 20 | number of states 96\n", "End at state 0 | number of states 50\n", "End at state 0 | number of states 24\n", "End at state 0 | number of states 44\n", "End at state 20 | number of states 252\n", "End at state 20 | number of states 164\n", "End at state 0 | number of states 16\n", "End at state 0 | number of states 38\n", "End at state 0 | number of states 116\n", "End at state 20 | number of states 46\n", "End at state 0 | number of states 36\n", "End at state 20 | number of states 20\n", "End at state 0 | number of states 114\n", "End at state 20 | number of states 36\n", "End at state 20 | number of states 116\n", "End at state 0 | number of states 22\n", "End at state 20 | number of states 106\n", "End at state 20 | number of states 26\n", "End at state 0 | number of states 122\n", "End at state 20 | number of states 148\n", "End at state 0 | number of states 66\n", "End at state 0 | number of states 42\n", "End at state 20 | number of states 196\n", "End at state 0 | number of states 80\n", "End at state 20 | number of states 108\n", "End at state 0 | number of states 32\n", "End at state 20 | number of states 88\n", "End at state 20 | number of states 214\n", "End at state 20 | number of states 20\n" ] } ], "source": [ "rw = RandomWalk(n=3, debug=True)\n", "rw.play(100)" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{0: {'left': -1, 'right': -1},\n", " 1: {'left': -0.9936373145588641, 'right': -0.6123810215862159},\n", " 2: {'left': -0.8392639995764508, 'right': -0.5850253270890091},\n", " 3: {'left': -0.7775947999495476, 'right': -0.43751674286580655},\n", " 4: {'left': -0.6350368351260016, 'right': -0.3913969471231499},\n", " 5: {'left': -0.5208547542814366, 'right': -0.26671115028058673},\n", " 6: {'left': -0.33496288325959034, 'right': -0.26519281995470595},\n", " 7: {'left': -0.3294325408271672, 'right': -0.1591379489070186},\n", " 8: {'left': -0.21027443783034355, 'right': -0.07471736024551187},\n", " 9: {'left': -0.14863075754947244, 'right': 0.07759996622191677},\n", " 10: {'left': -0.07275436059378539, 'right': 0.09562596254321507},\n", " 11: {'left': -0.0698675296380922, 'right': 0.20716635348566195},\n", " 12: {'left': 0.06887198644715165, 'right': 0.3895484529272696},\n", " 13: {'left': 0.22819408930618723, 'right': 0.44686596899342845},\n", " 14: {'left': 0.31824587239368246, 'right': 0.591062882938997},\n", " 15: {'left': 0.49634424181210773, 'right': 0.6454039834460928},\n", " 16: {'left': 0.5352748950821267, 'right': 0.7193959201226887},\n", " 17: {'left': 0.64181501595116, 'right': 0.7755510645002922},\n", " 18: {'left': 0.6539035563316621, 'right': 0.9276963505762654},\n", " 19: {'left': 0.7331358018373108, 'right': 0.9958254420820708},\n", " 20: {'left': 1, 'right': 1}}" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rw.Q_values" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Compute (n, lr) -> state-error" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [], "source": [ "actual_state_values = np.arange(-20, 22, 2) / 20.0\n", "\n", "lr_range = np.linspace(0, 1, 6)\n", "n_range = np.power(2, range(10))\n", "episodes = 100" ] }, { "cell_type": "code", "execution_count": 105, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "running estimation for lr=0.0 and step=1\n", "running estimation for lr=0.2 and step=1\n", "running estimation for lr=0.4 and step=1\n", "running estimation for lr=0.6000000000000001 and step=1\n", "running estimation for lr=0.8 and step=1\n", "running estimation for lr=1.0 and step=1\n", "running estimation for lr=0.0 and step=2\n", "running estimation for lr=0.2 and step=2\n", "running estimation for lr=0.4 and step=2\n", "running estimation for lr=0.6000000000000001 and step=2\n", "running estimation for lr=0.8 and step=2\n", "running estimation for lr=1.0 and step=2\n", "running estimation for lr=0.0 and step=4\n", "running estimation for lr=0.2 and step=4\n", "running estimation for lr=0.4 and step=4\n", "running estimation for lr=0.6000000000000001 and step=4\n", "running estimation for lr=0.8 and step=4\n", "running estimation for lr=1.0 and step=4\n", "running estimation for lr=0.0 and step=8\n", "running estimation for lr=0.2 and step=8\n", "running estimation for lr=0.4 and step=8\n", "running estimation for lr=0.6000000000000001 and step=8\n", "running estimation for lr=0.8 and step=8\n", "running estimation for lr=1.0 and step=8\n", "running estimation for lr=0.0 and step=16\n", "running estimation for lr=0.2 and step=16\n", "running estimation for lr=0.4 and step=16\n", "running estimation for lr=0.6000000000000001 and step=16\n", "running estimation for lr=0.8 and step=16\n", "running estimation for lr=1.0 and step=16\n", "running estimation for lr=0.0 and step=32\n", "running estimation for lr=0.2 and step=32\n", "running estimation for lr=0.4 and step=32\n", "running estimation for lr=0.6000000000000001 and step=32\n", "running estimation for lr=0.8 and step=32\n", "running estimation for lr=1.0 and step=32\n", "running estimation for lr=0.0 and step=64\n", "running estimation for lr=0.2 and step=64\n", "running estimation for lr=0.4 and step=64\n", "running estimation for lr=0.6000000000000001 and step=64\n", "running estimation for lr=0.8 and step=64\n", "running estimation for lr=1.0 and step=64\n", "running estimation for lr=0.0 and step=128\n", "running estimation for lr=0.2 and step=128\n", "running estimation for lr=0.4 and step=128\n", "running estimation for lr=0.6000000000000001 and step=128\n", "running estimation for lr=0.8 and step=128\n", "running estimation for lr=1.0 and step=128\n", "running estimation for lr=0.0 and step=256\n", "running estimation for lr=0.2 and step=256\n", "running estimation for lr=0.4 and step=256\n", "running estimation for lr=0.6000000000000001 and step=256\n", "running estimation for lr=0.8 and step=256\n", "running estimation for lr=1.0 and step=256\n", "running estimation for lr=0.0 and step=512\n", "running estimation for lr=0.2 and step=512\n", "running estimation for lr=0.4 and step=512\n", "running estimation for lr=0.6000000000000001 and step=512\n", "running estimation for lr=0.8 and step=512\n", "running estimation for lr=1.0 and step=512\n" ] } ], "source": [ "sq_errors = {}\n", "\n", "for n in n_range:\n", " ers = []\n", " for lr in lr_range:\n", " print(\"running estimation for lr={} and step={}\".format(lr, n))\n", " rw = RandomWalk(n=n, lr=lr, debug=False)\n", " rw.play(episodes)\n", " # V(s) = 0.5*Q(S, 'left') + 0.5*Q(S, 'right')\n", " estimate_state_values = [np.mean(list(v.values())) for v in rw.Q_values.values()]\n", " \n", " ers.append(np.mean([er**2 for er in actual_state_values - np.array(estimate_state_values)]))\n", " sq_errors[n] = ers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Visualise Error" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 111, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 6])\n", "\n", "for n in n_range:\n", " plt.plot(lr_range, sq_errors[n], label=\"n={}\".format(n))\n", "\n", "plt.xlabel('learning rate')\n", "plt.ylabel('RMS error')\n", "plt.legend()" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: RandomWalk/RandomWalk(n-step).py ================================================ import numpy as np # 19 states (not including the ending state) NUM_STATES = 19 START = 9 END_0 = 0 END_1 = 20 class RandomWalk: def __init__(self, n, start=START, end=False, lr=0.1, gamma=1, debug=False): self.actions = ["left", "right"] self.state = start # current state self.end = end self.n = n self.lr = lr self.gamma = gamma self.debug = debug # init q estimates self.Q_values = {} for i in range(NUM_STATES + 2): self.Q_values[i] = {} for a in self.actions: if i in [END_0, END_1]: # explicitly set end state values if i == END_0: self.Q_values[i][a] = -1 else: self.Q_values[i][a] = 1 else: self.Q_values[i][a] = 0 def chooseAction(self): action = np.random.choice(self.actions) return action def takeAction(self, action): new_state = self.state if not self.end: if action == "left": new_state = self.state - 1 else: new_state = self.state + 1 if new_state in [END_0, END_1]: self.end = True self.state = new_state return self.state def giveReward(self): if self.state == END_0: return -1 if self.state == END_1: return 1 # other states return 0 def reset(self): self.state = START self.end = False def play(self, rounds=100): for _ in range(rounds): self.reset() t = 0 T = np.inf action = self.chooseAction() actions = [action] states = [self.state] rewards = [0] while True: if t < T: state = self.takeAction(action) # next state reward = self.giveReward() # next state-reward states.append(state) rewards.append(reward) if self.end: if self.debug: print("End at state {} | number of states {}".format(state, len(states))) T = t + 1 else: action = self.chooseAction() actions.append(action) # next action # state tau being updated tau = t - self.n + 1 if tau >= 0: G = 0 for i in range(tau + 1, min(tau + self.n + 1, T + 1)): G += np.power(self.gamma, i - tau - 1) * rewards[i] if tau + self.n < T: state_action = (states[tau + self.n], actions[tau + self.n]) G += np.power(self.gamma, self.n) * self.Q_values[state_action[0]][state_action[1]] # update Q values state_action = (states[tau], actions[tau]) self.Q_values[state_action[0]][state_action[1]] += self.lr * ( G - self.Q_values[state_action[0]][state_action[1]]) if tau == T - 1: break t += 1 if __name__ == "__main__": actual_state_values = np.arange(-20, 22, 2) / 20.0 lr_range = np.linspace(0, 1, 6) n_range = np.power(2, range(10)) episodes = 100 sq_errors = {} for n in n_range: ers = [] for lr in lr_range: print("running estimation for lr={} and step={}".format(lr, n)) rw = RandomWalk(n=n, lr=lr, debug=False) rw.play(episodes) # V(s) = 0.5*Q(S, 'left') + 0.5*Q(S, 'right') estimate_state_values = [np.mean(list(v.values())) for v in rw.Q_values.values()] ers.append(np.mean([er ** 2 for er in actual_state_values - np.array(estimate_state_values)])) sq_errors[n] = ers # visualisation import matplotlib.pyplot as plt plt.figure(figsize=[10, 6]) for n in n_range: plt.plot(lr_range, sq_errors[n], label="n={}".format(n)) plt.xlabel('learning rate') plt.ylabel('RMS error') plt.legend() plt.show() ================================================ FILE: RandomWalk(General)/RandomWalk.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "1000 Steps Random Walk\n", "---\n", "Consider a 1000-state version of the random walk task. The states are numbered from `1 to 1000`, left to right, and all episodes begin near the center, in state `500`. State transitions are from the current state to one of the `100` neighboring states to its left, or to one of the `100` neighboring states to its right, all with equal probability. Of course, if the current state is near an edge, then there may be fewer than `100` neighbors on that side of it. In this case, all the probability that would have gone into those missing neighbors goes into the probability of terminating on that side (thus, state 1 has a 0.5 chance of terminating on the left, and state 950 has a 0.25 chance of terminating on the right). As usual, termination on the left produces a reward of `-1`, and termination on the right produces a reward of `+1`. All other transitions have a reward of `zero`.\n", "\n", "\"drawing\"\n", "\n", "For the state aggregation, the 1000 states were partitioned into 10 groups of 100 states each (i.e., states 1–100 were one group, states 101–200 were another, and so on)\n", "\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 133, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 157, "metadata": {}, "outputs": [], "source": [ "NUM_STATES = 1000\n", "START = 500\n", "END_0 = 0\n", "END_1 = 1001\n", "\n", "TRUE_VALUES = np.arange(-1001, 1003, 2) / 1001.0" ] }, { "cell_type": "code", "execution_count": 119, "metadata": {}, "outputs": [], "source": [ "class LinearValueFunction:\n", " \n", " def __init__(self, order, method=\"poly\"):\n", " if method == \"poly\":\n", " self.func = [lambda x, i=i: np.power(x, i) for i in range(0, order+1)] # s^i\n", " if method == \"fourier\":\n", " self.func = [lambda x, i=i: np.cos(np.pi*x*i) for i in range(0, order+1)] # cos(pi*s*i)\n", " self.weights = np.zeros(order+1)\n", " \n", " def value(self, state):\n", " state = state/NUM_STATES\n", " features = np.array([f(state) for f in self.func])\n", " return np.dot(features, self.weights)\n", " \n", " def update(self, delta, state):\n", " state = state/NUM_STATES\n", " dev = np.array([f(state) for f in self.func])\n", " self.weights += delta*dev" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "class AggValueFunction:\n", " \n", " def __init__(self, num_groups=10):\n", " self.num_groups = num_groups\n", " self.group_size = NUM_STATES // self.num_groups\n", " self.values = np.zeros(self.num_groups)\n", " \n", " def value(self, state):\n", " # explicitly set end state value\n", " if state == END_0:\n", " return -1\n", " if state == END_1:\n", " return 1\n", " group = (state - 1) // self.group_size\n", " value = self.values[group]\n", " return value\n", " \n", " def update(self, delta, state):\n", " dev = 1 # derivative is 1 in this case\n", " group = (state - 1) // self.group_size\n", " self.values[group] += delta*dev" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "code_folding": [ 45 ] }, "outputs": [], "source": [ "class RandomWalk:\n", " \n", " def __init__(self, step=1, lr=2e-5, gamma=1, debug=True):\n", " self.state = START\n", " self.actions = [\"left\", \"right\"]\n", " self.end = False\n", " self.n = step\n", " self.lr = lr\n", " self.gamma = gamma\n", " self.debug = debug\n", " \n", " def chooseAction(self):\n", " action = np.random.choice(self.actions)\n", " return action\n", " \n", " def takeAction(self, action):\n", " # choose steps from 1 to 100\n", " steps = np.random.choice(range(1, 101))\n", " if action == \"left\":\n", " state = self.state - steps\n", " else:\n", " state = self.state + steps\n", " # judge if end of game\n", " if state <= END_0 or state >= END_1:\n", " self.end = True\n", " if state <= END_0:\n", " state = END_0\n", " else:\n", " state = END_1\n", " \n", " self.state = state\n", " return state\n", " \n", " def giveReward(self):\n", " if self.state == END_0:\n", " return -1\n", " if self.state == END_1:\n", " return 1\n", " return 0\n", " \n", " def reset(self):\n", " self.state = START\n", " self.end = False\n", " \n", " def play(self, valueFunction, rounds=1e5):\n", " for rnd in range(rounds):\n", " self.reset()\n", " t = 0\n", " T = np.inf\n", " action = self.chooseAction()\n", " \n", " actions = [action]\n", " states = [self.state]\n", " rewards = [0]\n", " while True:\n", " if t < T:\n", " state = self.takeAction(action) # next state\n", " reward = self.giveReward() # next state-reward\n", " \n", " states.append(state)\n", " rewards.append(reward)\n", " \n", " if self.end:\n", " if self.debug:\n", " if (rnd+1) % 5000 == 0:\n", " print(\"Round {}: End at state {} | number of states {}\".format(rnd+1, state, len(states)))\n", " T = t+1\n", " else:\n", " action = self.chooseAction()\n", " actions.append(action) # next action\n", " # state tau being updated\n", " tau = t - self.n + 1\n", " if tau >= 0:\n", " G = 0\n", " for i in range(tau+1, min(tau+self.n+1, T+1)):\n", " G += np.power(self.gamma, i-tau-1)*rewards[i]\n", " if tau+self.n < T:\n", " state = states[tau+self.n]\n", " G += np.power(self.gamma, self.n)*valueFunction.value(state)\n", " # update value function\n", " state = states[tau] \n", " delta = self.lr*(G - valueFunction.value(state))\n", " valueFunction.update(delta, state)\n", " \n", " if tau == T-1:\n", " break\n", " \n", " t += 1" ] }, { "cell_type": "code", "execution_count": 161, "metadata": {}, "outputs": [], "source": [ "def plot_fig(func):\n", " x_value = range(0, 1002)\n", " states_value = []\n", " for i in x_value:\n", " states_value.append(func.value(i))\n", " \n", " plt.figure(figsize=[8, 6])\n", " plt.plot(x_value, states_value, label=\"Approximate Value\")\n", " plt.plot(x_value, TRUE_VALUES, label=\"Actual Value\")\n", " plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Aggregate State" ] }, { "cell_type": "code", "execution_count": 130, "metadata": {}, "outputs": [], "source": [ "rw = RandomWalk(step=1, lr=0.001)\n", "vFunc = AggValueFunction(num_groups=10)" ] }, { "cell_type": "code", "execution_count": 131, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Round 5000: End at state 0 | number of states 22\n", "Round 10000: End at state 0 | number of states 23\n", "Round 15000: End at state 1001 | number of states 51\n", "Round 20000: End at state 0 | number of states 54\n", "Round 25000: End at state 1001 | number of states 44\n", "Round 30000: End at state 1001 | number of states 45\n" ] } ], "source": [ "rw.play(rounds=30000, valueFunction=vFunc)" ] }, { "cell_type": "code", "execution_count": 163, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_fig(vFunc)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### General Linear Function" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Poly" ] }, { "cell_type": "code", "execution_count": 166, "metadata": {}, "outputs": [], "source": [ "rw = RandomWalk(step=1, lr=0.001)\n", "polyFunc = LinearValueFunction(order=5, method=\"poly\")" ] }, { "cell_type": "code", "execution_count": 167, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Round 5000: End at state 0 | number of states 56\n" ] } ], "source": [ "rw.play(rounds=5000, valueFunction=polyFunc)" ] }, { "cell_type": "code", "execution_count": 168, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_fig(polyFunc)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Fourier" ] }, { "cell_type": "code", "execution_count": 169, "metadata": {}, "outputs": [], "source": [ "rw = RandomWalk(step=1, lr=0.001)\n", "fFunc = LinearValueFunction(order=5, method=\"fourier\")" ] }, { "cell_type": "code", "execution_count": 170, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Round 5000: End at state 1001 | number of states 77\n" ] } ], "source": [ "rw.play(rounds=5000, valueFunction=fFunc)" ] }, { "cell_type": "code", "execution_count": 171, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_fig(fFunc)" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [], "source": [ "# you can write to stdout for debugging purposes, e.g.\n", "# print(\"this is a debug message\")\n", "\n", "def solution(S):\n", " # write your code in Python 3.6\n", " S = solution1(S)\n", " print(S)\n", " res = \"\".join([get_s(i) for i in S])\n", " return res\n", " \n", " \n", "def solution1(S):\n", " # write your code in Python 3.6\n", " S = [get_num(s) for s in list(S)]\n", " n = len(S)\n", " \n", " if n <= 1:\n", " return S\n", " \n", " for i in range(n-1):\n", " if abs(S[i] - S[i+1]) == 1:\n", " del S[i:(i+2)]\n", " return solution1(S)\n", " return S\n", " \n", " \n", "def get_num(s):\n", " if type(s) == int:\n", " return s\n", " if s == \"A\":\n", " return 0\n", " if s == \"B\":\n", " return 1\n", " if s == \"C\":\n", " return 5\n", " return 6\n", "\n", "def get_s(n):\n", " if n == 0:\n", " return \"A\"\n", " if n == 1:\n", " return \"B\"\n", " if n == 5:\n", " return \"C\"\n", " if n == 6:\n", " return \"D\"\n", " \n", "def so(S):\n", " res = \"\".join([get_s(i) for i in S])\n", " return res" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[5]\n" ] }, { "data": { "text/plain": [ "'C'" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "solution('CBACD')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "outer S CBACD\n", "n 5\n", "0\n", "1\n", "outer S [5, 5, 6]\n", "n 3\n", "0\n", "1\n", "outer S [5]\n", "n 1\n", "is returned\n" ] }, { "data": { "text/plain": [ "'C'" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = solution('CBACD')\n", "\n", "so(t)" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "outer S CABABD\n", "n 6\n", "0\n", "1\n", "outer S [5, 0, 1, 6]\n", "n 4\n", "0\n", "1\n", "outer S [5, 6]\n", "n 2\n", "0\n", "outer S []\n", "n 0\n", "is returned\n" ] }, { "data": { "text/plain": [ "''" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = solution('CABABD')\n", "\n", "so(t)" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "outer S ACBDACBD\n", "n 8\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n" ] }, { "data": { "text/plain": [ "'ACBDACBD'" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = solution('ACBDACBD')\n", "\n", "so(t)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "l = [1, 2, 3]\n", "del l[1:10]" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: RandomWalk(General)/RandomWalk.py ================================================ import numpy as np import matplotlib.pyplot as plt NUM_STATES = 1000 START = 500 END_0 = 0 END_1 = 1001 TRUE_VALUES = np.arange(-1001, 1003, 2) / 1001.0 class LinearValueFunction: def __init__(self, order, method="poly"): if method == "poly": self.func = [lambda x, i=i: np.power(x, i) for i in range(0, order + 1)] # s^i if method == "fourier": self.func = [lambda x, i=i: np.cos(np.pi * x * i) for i in range(0, order + 1)] # cos(pi*s*i) self.weights = np.zeros(order + 1) def value(self, state): state = state / NUM_STATES features = np.array([f(state) for f in self.func]) return np.dot(features, self.weights) def update(self, delta, state): state = state / NUM_STATES dev = np.array([f(state) for f in self.func]) self.weights += delta * dev class AggValueFunction: def __init__(self, num_groups=10): self.num_groups = num_groups self.group_size = NUM_STATES // self.num_groups self.values = np.zeros(self.num_groups) def value(self, state): # explicitly set end state value if state == END_0: return -1 if state == END_1: return 1 group = (state - 1) // self.group_size value = self.values[group] return value def update(self, delta, state): dev = 1 # derivative is 1 in this case group = (state - 1) // self.group_size self.values[group] += delta * dev class RandomWalk: def __init__(self, step=1, lr=2e-5, gamma=1, debug=True): self.state = START self.actions = ["left", "right"] self.end = False self.n = step self.lr = lr self.gamma = gamma self.debug = debug def chooseAction(self): action = np.random.choice(self.actions) return action def takeAction(self, action): # choose steps from 1 to 100 steps = np.random.choice(range(1, 101)) if action == "left": state = self.state - steps else: state = self.state + steps # judge if end of game if state <= END_0 or state >= END_1: self.end = True if state <= END_0: state = END_0 else: state = END_1 self.state = state return state def giveReward(self): if self.state == END_0: return -1 if self.state == END_1: return 1 return 0 def reset(self): self.state = START self.end = False def play(self, valueFunction, rounds=1e5): for rnd in range(rounds): self.reset() t = 0 T = np.inf action = self.chooseAction() actions = [action] states = [self.state] rewards = [0] while True: if t < T: state = self.takeAction(action) # next state reward = self.giveReward() # next state-reward states.append(state) rewards.append(reward) if self.end: if self.debug: if (rnd + 1) % 5000 == 0: print("Round {}: End at state {} | number of states {}".format(rnd + 1, state, len(states))) T = t + 1 else: action = self.chooseAction() actions.append(action) # next action # state tau being updated tau = t - self.n + 1 if tau >= 0: G = 0 for i in range(tau + 1, min(tau + self.n + 1, T + 1)): G += np.power(self.gamma, i - tau - 1) * rewards[i] if tau + self.n < T: state = states[tau + self.n] G += np.power(self.gamma, self.n) * valueFunction.value(state) # update value function state = states[tau] delta = self.lr * (G - valueFunction.value(state)) valueFunction.update(delta, state) if tau == T - 1: break t += 1 def plot_fig(func): x_value = range(0, 1002) states_value = [] for i in x_value: states_value.append(func.value(i)) plt.figure(figsize=[8, 6]) plt.plot(x_value, states_value, label="Approximate Value") plt.plot(x_value, TRUE_VALUES, label="Actual Value") plt.legend() if __name__ == "__main__": # agg function print("Running agg function") rw = RandomWalk(step=1, lr=0.001) vFunc = AggValueFunction(num_groups=10) rw.play(rounds=5000, valueFunction=vFunc) plot_fig(vFunc) # poly function print("Running poly function") rw = RandomWalk(step=1, lr=0.001) polyFunc = LinearValueFunction(order=5, method="poly") rw.play(rounds=5000, valueFunction=polyFunc) plot_fig(polyFunc) # fourier function print("Running fourier function") rw = RandomWalk(step=1, lr=0.001) fFunc = LinearValueFunction(order=5, method="fourier") rw.play(rounds=5000, valueFunction=fFunc) plot_fig(fFunc) ================================================ FILE: RandomWalk(Lambda)/TD(Lambda).ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Offline Lambda\n", "---\n", "(All can be extended to Q function learning)\n", "\n", "---\n", "The backup digram for `TD(λ)`. If `λ = 0`, then the overall update reduces to its first component, the one-step TD update, whereas if `λ = 1`, then the overall update reduces to its last component, the Monte Carlo update.\n", "Update Rule\n", "---\n", "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "# 19 states (not including the ending state)\n", "NUM_STATES = 19\n", "START = 9\n", "END_0 = 0\n", "END_1 = 20" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class ValueFunction:\n", " def __init__(self, alpha=0.1):\n", " self.weights = np.zeros(NUM_STATES+2)\n", " self.alpha = alpha\n", " \n", " def value(self, state):\n", " v = self.weights[state]\n", " return v\n", " \n", " def learn(self, state, delta):\n", " self.weights[state] += self.alpha*delta" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "class RandomWalk:\n", " \n", " def __init__(self, start=START, end=False, lmbda=0.4, debug=False):\n", " self.actions = [\"left\", \"right\"]\n", " self.state = start # current state\n", " self.end = end\n", " self.lmbda = lmbda\n", " self.states = []\n", " self.reward = 0\n", " self.debug = debug\n", " self.rate_truncate = 1e-3\n", " \n", " def chooseAction(self): \n", " action = np.random.choice(self.actions)\n", " return action \n", " \n", " def takeAction(self, action):\n", " new_state = self.state\n", " if not self.end:\n", " if action == \"left\":\n", " new_state = self.state-1\n", " else:\n", " new_state = self.state+1\n", " \n", " if new_state in [END_0, END_1]:\n", " self.end = True\n", " self.state = new_state\n", " return self.state\n", " \n", " def giveReward(self, state):\n", " if state == END_0:\n", " return -1\n", " if state == END_1:\n", " return 1\n", " # other states\n", " return 0\n", " \n", " def reset(self):\n", " self.state = START\n", " self.end = False\n", " self.states = []\n", " \n", " def gt2tn(self, valueFunc, start, end):\n", " # only the last reward is non-zero\n", " reward = self.reward if end == len(self.states)-1 else 0\n", " state = self.states[end] \n", " res = reward + valueFunc.value(state)\n", " return res\n", " \n", " def play(self, valueFunc, rounds=100):\n", " for _ in range(rounds):\n", " self.reset() \n", " action = self.chooseAction()\n", "\n", " self.states = [self.state]\n", " while not self.end:\n", " state = self.takeAction(action) # next state\n", " self.reward = self.giveReward(state) # next state-reward\n", "\n", " self.states.append(state)\n", "\n", " action = self.chooseAction()\n", " if self.debug:\n", " print(\"total states {} end at {} reward {}\".format(len(self.states), self.state, self.reward))\n", "\n", " # end of game, do forward update\n", " T = len(self.states)-1\n", " for t in range(T):\n", " # start from time t\n", " state = self.states[t]\n", " gtlambda = 0\n", " for n in range(1, T-t):\n", " # compute G_t:t+n\n", " gttn = self.gt2tn(valueFunc, t, t+n)\n", " lambda_power = np.power(self.lmbda, n-1)\n", " gtlambda += lambda_power*gttn\n", " if lambda_power < self.rate_truncate:\n", " break\n", " \n", " gtlambda *= 1 - self.lmbda\n", " if lambda_power >= self.rate_truncate:\n", " gtlambda += lambda_power*self.reward\n", " \n", " delta = gtlambda - valueFunc.value(state)\n", " valueFunc.learn(state, delta)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "valueFunc = ValueFunction(alpha=0.1)\n", "rw = RandomWalk(debug=False, lmbda=0.4)\n", "\n", "rw.play(valueFunc, rounds=50)" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0. , -1.00891022, -1.07904715, -0.87133927, -0.67934023,\n", " -0.47180329, -0.36555315, -0.25592306, -0.17109379, -0.0260043 ,\n", " 0.06907409, 0.17832788, 0.26504299, 0.37300029, 0.49303013,\n", " 0.6947947 , 0.76940524, 0.96562993, 1.1660046 , 1.02847254,\n", " 0. ])" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "valueFunc.weights" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualisation of Offline-Lambda" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0. ,\n", " 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0. ])" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "actual_state_values = np.arange(-20, 22, 2) / 20.0\n", "actual_state_values[0] = actual_state_values[-1] = 0\n", "actual_state_values" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "alphas = np.linspace(0, 1, 6)\n", "lambdas = np.linspace(0, 1, 5)\n", "rounds = 50\n", "\n", "plt.figure(figsize=[10, 6])\n", "for lamb in lambdas:\n", " alpha_erros = []\n", " for alpha in alphas:\n", " valueFunc = ValueFunction(alpha=alpha)\n", " rw = RandomWalk(debug=False, lmbda=lamb)\n", " rw.play(valueFunc, rounds=rounds)\n", " rmse = np.sqrt(np.mean(np.power(valueFunc.weights - actual_state_values, 2)))\n", " alpha_erros.append(rmse)\n", " plt.plot(alphas, alpha_erros, label=\"lambda={}\".format(lamb))\n", "\n", "plt.xlabel(\"alpha\", size=14)\n", "plt.ylabel(\"RMS error\", size=14)\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Semi-gradient TD(λ)\n", "---\n", "\n", "\n", "### TD(λ) improves over the offine λ-return algorithm in three ways \n", "- First it updates the weight vector on every step of an episode rather than only at the end, and thus its estimates may be better sooner. \n", "- Second, its computations are equally distributed in time rather than all at the end of the episode. \n", "- And third, it can be applied to continuing problems rather than just to episodic problems." ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [], "source": [ "class ValueFunctionTD:\n", " def __init__(self, alpha=0.1, gamma=0.9, lmbda=0.8):\n", " self.weights = np.zeros(NUM_STATES+2)\n", " self.z = np.zeros(NUM_STATES+2)\n", " self.alpha = alpha\n", " self.gamma = gamma\n", " self.lmbda = lmbda\n", " \n", " def value(self, state):\n", " v = self.weights[state]\n", " return v\n", " \n", " def updateZ(self, state):\n", " dev = 1\n", " self.z *= self.gamma*self.lmbda\n", " self.z[state] += dev\n", " \n", " def learn(self, state, nxtState, reward):\n", " delta = reward + self.gamma*self.value(nxtState) - self.value(state)\n", " delta *= self.alpha\n", " self.weights += delta*self.z" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [], "source": [ "class RWTD:\n", " \n", " def __init__(self, start=START, end=False, debug=False):\n", " self.actions = [\"left\", \"right\"]\n", " self.state = start # current state\n", " self.end = end\n", " self.reward = 0\n", " self.debug = debug\n", " \n", " def chooseAction(self): \n", " action = np.random.choice(self.actions)\n", " return action \n", " \n", " def takeAction(self, action):\n", " new_state = self.state\n", " if not self.end:\n", " if action == \"left\":\n", " new_state = self.state-1\n", " else:\n", " new_state = self.state+1\n", " \n", " if new_state in [END_0, END_1]:\n", " self.end = True\n", " return new_state\n", " \n", " def giveReward(self, state):\n", " if state == END_0:\n", " return -1\n", " if state == END_1:\n", " return 1\n", " # other states\n", " return 0\n", " \n", " def reset(self):\n", " self.state = START\n", " self.end = False\n", " self.states = []\n", " \n", " def play(self, valueFunc, rounds=100):\n", " for _ in range(rounds):\n", " self.reset() \n", " action = self.chooseAction()\n", " while not self.end:\n", " nxtState = self.takeAction(action) # next state\n", " self.reward = self.giveReward(nxtState) # next state-reward\n", "\n", " valueFunc.updateZ(self.state)\n", " valueFunc.learn(self.state, nxtState, self.reward)\n", " \n", " self.state = nxtState\n", " action = self.chooseAction()\n", " if self.debug:\n", " print(\"end at {} reward {}\".format(self.state, self.reward))" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [], "source": [ "rwtd = RWTD(debug=False)\n", "vf = ValueFunctionTD()\n", "\n", "rwtd.play(vf, rounds=100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## TD(λ) Visualisation" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "lambda 0.0 alpha 0.0 rmse 0.5209880722517277\n", "lambda 0.0 alpha 0.16 rmse 0.27868829232969544\n", "lambda 0.0 alpha 0.32 rmse 0.2705436445111597\n", "lambda 0.0 alpha 0.48 rmse 0.272612438654202\n", "lambda 0.0 alpha 0.64 rmse 0.16074729886536573\n", "lambda 0.0 alpha 0.8 rmse 0.20857192719909906\n", "lambda 0.25 alpha 0.0 rmse 0.5209880722517277\n", "lambda 0.25 alpha 0.16 rmse 0.28264502140659614\n", "lambda 0.25 alpha 0.32 rmse 0.3078414022251214\n", "lambda 0.25 alpha 0.48 rmse 0.25944157134909496\n", "lambda 0.25 alpha 0.64 rmse 0.2554110362815295\n", "lambda 0.25 alpha 0.8 rmse 0.20552111452220595\n", "lambda 0.5 alpha 0.0 rmse 0.5209880722517277\n", "lambda 0.5 alpha 0.16 rmse 0.2793605166697793\n", "lambda 0.5 alpha 0.32 rmse 0.27761252753137183\n", "lambda 0.5 alpha 0.48 rmse 0.21638221771070648\n", "lambda 0.5 alpha 0.64 rmse 0.2617541864066332\n", "lambda 0.5 alpha 0.8 rmse 0.12877757485215544\n", "lambda 0.75 alpha 0.0 rmse 0.5209880722517277\n", "lambda 0.75 alpha 0.16 rmse 0.22982621059660824\n", "lambda 0.75 alpha 0.32 rmse 0.2017180643205702\n", "lambda 0.75 alpha 0.48 rmse 0.3368266053891039\n", "lambda 0.75 alpha 0.64 rmse 0.24909710961015508\n", "lambda 0.75 alpha 0.8 rmse 0.0936369263695325\n", "lambda 1.0 alpha 0.0 rmse 0.5209880722517277\n", "lambda 1.0 alpha 0.16 rmse 0.1627385723567123\n", "lambda 1.0 alpha 0.32 rmse 0.12298586727001526\n", "lambda 1.0 alpha 0.48 rmse 0.2329845610123636\n", "lambda 1.0 alpha 0.64 rmse 0.2481553111364421\n", "lambda 1.0 alpha 0.8 rmse 0.9403604986166473\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "alphas = np.linspace(0, 0.8, 6)\n", "lambdas = np.linspace(0, 1, 5)\n", "rounds = 50\n", "\n", "plt.figure(figsize=[10, 6])\n", "for lamb in lambdas:\n", " alpha_erros = []\n", " for alpha in alphas:\n", " valueFunc = ValueFunctionTD(alpha=alpha, lmbda=lamb)\n", " rw = RWTD(debug=False)\n", " rw.play(valueFunc, rounds=rounds)\n", " rmse = np.sqrt(np.mean(np.power(valueFunc.weights - actual_state_values, 2)))\n", " print(\"lambda {} alpha {} rmse {}\".format(lamb, alpha, rmse))\n", " alpha_erros.append(rmse)\n", " plt.plot(alphas, alpha_erros, label=\"lambda={}\".format(lamb))\n", "\n", "plt.xlabel(\"alpha\", size=14)\n", "plt.ylabel(\"RMS error\", size=14)\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: RandomWalk(Lambda)/TD_Lambda.py ================================================ import numpy as np import matplotlib.pyplot as plt # 19 states (not including the ending state) NUM_STATES = 19 START = 9 END_0 = 0 END_1 = 20 class ValueFunction: def __init__(self, alpha=0.1): self.weights = np.zeros(NUM_STATES + 2) self.alpha = alpha def value(self, state): v = self.weights[state] return v def learn(self, state, delta): self.weights[state] += self.alpha * delta class RandomWalk: def __init__(self, start=START, end=False, lmbda=0.4, debug=False): self.actions = ["left", "right"] self.state = start # current state self.end = end self.lmbda = lmbda self.states = [] self.reward = 0 self.debug = debug self.rate_truncate = 1e-3 def chooseAction(self): action = np.random.choice(self.actions) return action def takeAction(self, action): new_state = self.state if not self.end: if action == "left": new_state = self.state - 1 else: new_state = self.state + 1 if new_state in [END_0, END_1]: self.end = True self.state = new_state return self.state def giveReward(self, state): if state == END_0: return -1 if state == END_1: return 1 # other states return 0 def reset(self): self.state = START self.end = False self.states = [] def gt2tn(self, valueFunc, start, end): # only the last reward is non-zero reward = self.reward if end == len(self.states) - 1 else 0 state = self.states[end] res = reward + valueFunc.value(state) return res def play(self, valueFunc, rounds=100): for _ in range(rounds): self.reset() action = self.chooseAction() self.states = [self.state] while not self.end: state = self.takeAction(action) # next state self.reward = self.giveReward(state) # next state-reward self.states.append(state) action = self.chooseAction() if self.debug: print("total states {} end at {} reward {}".format(len(self.states), self.state, self.reward)) # end of game, do forward update T = len(self.states) - 1 for t in range(T): # start from time t state = self.states[t] gtlambda = 0 for n in range(1, T - t): # compute G_t:t+n gttn = self.gt2tn(valueFunc, t, t + n) lambda_power = np.power(self.lmbda, n - 1) gtlambda += lambda_power * gttn if lambda_power < self.rate_truncate: break gtlambda *= 1 - self.lmbda if lambda_power >= self.rate_truncate: gtlambda += lambda_power * self.reward delta = gtlambda - valueFunc.value(state) valueFunc.learn(state, delta) class ValueFunctionTD: def __init__(self, alpha=0.1, gamma=0.9, lmbda=0.8): self.weights = np.zeros(NUM_STATES + 2) self.z = np.zeros(NUM_STATES + 2) self.alpha = alpha self.gamma = gamma self.lmbda = lmbda def value(self, state): v = self.weights[state] return v def updateZ(self, state): dev = 1 self.z *= self.gamma * self.lmbda self.z[state] += dev def learn(self, state, nxtState, reward): delta = reward + self.gamma * self.value(nxtState) - self.value(state) delta *= self.alpha self.weights += delta * self.z class RWTD: def __init__(self, start=START, end=False, debug=False): self.actions = ["left", "right"] self.state = start # current state self.end = end self.reward = 0 self.debug = debug def chooseAction(self): action = np.random.choice(self.actions) return action def takeAction(self, action): new_state = self.state if not self.end: if action == "left": new_state = self.state - 1 else: new_state = self.state + 1 if new_state in [END_0, END_1]: self.end = True return new_state def giveReward(self, state): if state == END_0: return -1 if state == END_1: return 1 # other states return 0 def reset(self): self.state = START self.end = False self.states = [] def play(self, valueFunc, rounds=100): for _ in range(rounds): self.reset() action = self.chooseAction() while not self.end: nxtState = self.takeAction(action) # next state self.reward = self.giveReward(nxtState) # next state-reward valueFunc.updateZ(self.state) valueFunc.learn(self.state, nxtState, self.reward) self.state = nxtState action = self.chooseAction() if self.debug: print("end at {} reward {}".format(self.state, self.reward)) if __name__ == "__main__": actual_state_values = np.arange(-20, 22, 2) / 20.0 actual_state_values[0] = actual_state_values[-1] = 0 actual_state_values alphas = np.linspace(0, 1, 6) lambdas = np.linspace(0, 1, 5) rounds = 50 # offline-lambda plt.figure(figsize=[10, 6]) for lamb in lambdas: alpha_erros = [] for alpha in alphas: valueFunc = ValueFunction(alpha=alpha) rw = RandomWalk(debug=False, lmbda=lamb) rw.play(valueFunc, rounds=rounds) rmse = np.sqrt(np.mean(np.power(valueFunc.weights - actual_state_values, 2))) alpha_erros.append(rmse) plt.plot(alphas, alpha_erros, label="lambda={}".format(lamb)) plt.xlabel("alpha", size=14) plt.ylabel("RMS error", size=14) plt.legend() # TD lambda alphas = np.linspace(0, 0.8, 6) lambdas = np.linspace(0, 1, 5) rounds = 50 plt.figure(figsize=[10, 6]) for lamb in lambdas: alpha_erros = [] for alpha in alphas: valueFunc = ValueFunctionTD(alpha=alpha, lmbda=lamb) rw = RWTD(debug=False) rw.play(valueFunc, rounds=rounds) rmse = np.sqrt(np.mean(np.power(valueFunc.weights - actual_state_values, 2))) print("lambda {} alpha {} rmse {}".format(lamb, alpha, rmse)) alpha_erros.append(rmse) plt.plot(alphas, alpha_erros, label="lambda={}".format(lamb)) plt.xlabel("alpha", size=14) plt.ylabel("RMS error", size=14) plt.legend() ================================================ FILE: ShortCorridor/ShortCorridor.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Short Corridor with Switched Actions\n", "---\n", "Consider the small corridor grid world shown inset in the graph below. The reward is -1 per step, as usual. In each of the three nonterminal states there are only two actions, right and left. These actions have their usual consequences in the first and third states (left causes no movement in the first state), but in the second state they are reversed, so that right moves to the left and left moves to the right. The problem is difficult because all the states appear identical under the function approximation. In particular, we define `x(s, right) = [1, 0]` and `x(s, left) = [0, 1]`, for all s.\n", "\n", "$$J(\\theta) = V_{\\pi_\\theta}(S)$$\n", "\n", "\n", "\n", "MC Policy Gradient\n", "---\n", "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "class ShortCorridor:\n", " def __init__(self, alpha=0.2, gamma=0.8):\n", " self.actions = [\"left\", \"right\"]\n", " self.x = np.array([[0, 1], [1, 0]]) # left|s, right|s\n", " self.theta = np.array([-1.47, 1.47])\n", " self.state = 0 # initial state 0\n", " self.gamma = gamma\n", " self.alpha = alpha\n", " \n", " def softmax(self, vector):\n", " return np.exp(vector)/sum(np.exp(vector))\n", " \n", " def chooseAction(self):\n", " h = np.dot(self.theta, self.x)\n", " prob = self.softmax(h) # left, right probability for all state\n", " \n", " imin = np.argmin(prob)\n", " epsilon = 0.05\n", " \n", " if prob[imin] < epsilon:\n", " prob[:] = 1 - epsilon\n", " prob[imin] = epsilon\n", " \n", " action = np.random.choice(self.actions, p=prob)\n", " return action\n", " \n", " def takeAction(self, action):\n", " if self.state == 0:\n", " nxtState = 0 if action == \"left\" else 1\n", " elif self.state == 1:\n", " nxtState = 2 if action == \"left\" else 0 # reversed\n", " elif self.state == 2:\n", " nxtState = 1 if action == \"left\" else 3\n", " else:\n", " nxtState = 2 if action == \"left\" else 3\n", " return nxtState\n", " \n", " def giveReward(self):\n", " if self.state == 3:\n", " return 0\n", " return -1\n", " \n", " def reset(self):\n", " self.state = 0\n", " \n", " def run(self, rounds=100):\n", " actions = []\n", " rewards = []\n", " for i in range(1, rounds+1):\n", " reward_sum = 0\n", " while True:\n", " action = self.chooseAction()\n", " nxtState = self.takeAction(action)\n", " reward = self.giveReward()\n", " reward_sum += reward\n", "\n", " actions.append(action)\n", " rewards.append(reward)\n", " \n", " self.state = nxtState\n", " # game end\n", " if self.state == 3:\n", " T = len(rewards)\n", " for t in range(T):\n", " # calculate G\n", " G = 0\n", " for k in range(t+1, T):\n", " G += np.power(self.gamma, k-t-1)*rewards[k]\n", " \n", " j = 1 if actions[t] == \"right\" else 0 # dev on particular state\n", " h = np.dot(self.theta, self.x)\n", " prob = self.softmax(h)\n", " grad = self.x[:, j] - np.dot(self.x, prob)\n", "\n", " self.theta += self.alpha*np.power(self.gamma, t)*G*grad\n", " # reset \n", " self.state = 0\n", " actions = []\n", " rewards = []\n", " \n", " if i % 50 == 0: \n", " print(\"round {}: current prob {} reward {}\".format(i, prob, reward_sum))\n", " reward_sum = 0\n", " break" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "sc = ShortCorridor(alpha=2e-4, gamma=1)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 50: current prob [0.42473803 0.57526197] reward -15\n", "round 100: current prob [0.41771671 0.58228329] reward -8\n", "round 150: current prob [0.40590189 0.59409811] reward -42\n", "round 200: current prob [0.40479147 0.59520853] reward -7\n", "round 250: current prob [0.43495446 0.56504554] reward -5\n", "round 300: current prob [0.39796873 0.60203127] reward -5\n", "round 350: current prob [0.40440231 0.59559769] reward -7\n", "round 400: current prob [0.40185045 0.59814955] reward -7\n", "round 450: current prob [0.38858673 0.61141327] reward -3\n", "round 500: current prob [0.37848939 0.62151061] reward -26\n", "round 550: current prob [0.39928466 0.60071534] reward -23\n", "round 600: current prob [0.36995291 0.63004709] reward -7\n", "round 650: current prob [0.35917078 0.64082922] reward -5\n", "round 700: current prob [0.36502733 0.63497267] reward -3\n", "round 750: current prob [0.37528428 0.62471572] reward -10\n", "round 800: current prob [0.41668482 0.58331518] reward -9\n", "round 850: current prob [0.43119919 0.56880081] reward -8\n", "round 900: current prob [0.43186731 0.56813269] reward -11\n", "round 950: current prob [0.40926894 0.59073106] reward -3\n", "round 1000: current prob [0.41148944 0.58851056] reward -6\n" ] } ], "source": [ "sc.run(1000)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.41148944, 0.58851056])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h = np.dot(sc.theta, sc.x)\n", "sc.softmax(h) # left, right probability for all state" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: ShortCorridor/ShortCorridor.py ================================================ import numpy as np class ShortCorridor: def __init__(self, alpha=0.2, gamma=0.8): self.actions = ["left", "right"] self.x = np.array([[0, 1], [1, 0]]) # left|s, right|s self.theta = np.array([-1.47, 1.47]) self.state = 0 # initial state 0 self.gamma = gamma self.alpha = alpha def softmax(self, vector): return np.exp(vector) / sum(np.exp(vector)) def chooseAction(self): h = np.dot(self.theta, self.x) prob = self.softmax(h) # left, right probability for all state imin = np.argmin(prob) epsilon = 0.05 if prob[imin] < epsilon: prob[:] = 1 - epsilon prob[imin] = epsilon action = np.random.choice(self.actions, p=prob) return action def takeAction(self, action): if self.state == 0: nxtState = 0 if action == "left" else 1 elif self.state == 1: nxtState = 2 if action == "left" else 0 # reversed elif self.state == 2: nxtState = 1 if action == "left" else 3 else: nxtState = 2 if action == "left" else 3 return nxtState def giveReward(self): if self.state == 3: return 0 return -1 def reset(self): self.state = 0 def run(self, rounds=100): actions = [] rewards = [] for i in range(1, rounds + 1): reward_sum = 0 while True: action = self.chooseAction() nxtState = self.takeAction(action) reward = self.giveReward() reward_sum += reward actions.append(action) rewards.append(reward) self.state = nxtState # game end if self.state == 3: T = len(rewards) for t in range(T): # calculate G G = 0 for k in range(t + 1, T): G += np.power(self.gamma, k - t - 1) * rewards[k] j = 1 if actions[t] == "right" else 0 # dev on particular state h = np.dot(self.theta, self.x) prob = self.softmax(h) grad = self.x[:, j] - np.dot(self.x, prob) self.theta += self.alpha * np.power(self.gamma, t) * G * grad # reset self.state = 0 actions = [] rewards = [] if i % 50 == 0: print("round {}: current prob {} reward {}".format(i, prob, reward_sum)) break if __name__ == "__main__": sc = ShortCorridor(alpha=2e-4, gamma=1) sc.run(2000) h = np.dot(sc.theta, sc.x) print(sc.softmax(h)) # left, right probability for all state ================================================ FILE: TicTacToe/tic-tac-toe.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Tic Tac Toe\n", "---\n", "Two players against each other\n", "\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pickle" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "BOARD_ROWS = 3\n", "BOARD_COLS = 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Board State\n", "---\n", "Reflect & Judge the state\n", "\n", "2 players p1 and p2; p1 uses symbol 1 and p2 uses symbol 2, vacancy as 0" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "class State:\n", " def __init__(self, p1, p2):\n", " self.board = np.zeros((BOARD_ROWS, BOARD_COLS))\n", " self.p1 = p1\n", " self.p2 = p2\n", " self.isEnd = False\n", " self.boardHash = None\n", " # init p1 plays first\n", " self.playerSymbol = 1\n", " \n", " # get unique hash of current board state\n", " def getHash(self):\n", " self.boardHash = str(self.board.reshape(BOARD_COLS*BOARD_ROWS))\n", " return self.boardHash\n", " \n", " def winner(self):\n", " # row\n", " for i in range(BOARD_ROWS):\n", " if sum(self.board[i, :]) == 3:\n", " self.isEnd = True\n", " return 1\n", " if sum(self.board[i, :]) == -3:\n", " self.isEnd = True\n", " return -1\n", " # col\n", " for i in range(BOARD_COLS):\n", " if sum(self.board[:, i]) == 3:\n", " self.isEnd = True\n", " return 1\n", " if sum(self.board[:, i]) == -3:\n", " self.isEnd = True\n", " return -1\n", " # diagonal\n", " diag_sum1 = sum([self.board[i, i] for i in range(BOARD_COLS)])\n", " diag_sum2 = sum([self.board[i, BOARD_COLS-i-1] for i in range(BOARD_COLS)])\n", " diag_sum = max(diag_sum1, diag_sum2)\n", " if diag_sum == 3:\n", " self.isEnd = True\n", " return 1\n", " if diag_sum == -3:\n", " self.isEnd = True\n", " return -1\n", " \n", " # tie\n", " # no available positions\n", " if len(self.availablePositions()) == 0:\n", " self.isEnd = True\n", " return 0\n", " # not end\n", " self.isEnd = False\n", " return None\n", " \n", " def availablePositions(self):\n", " positions = []\n", " for i in range(BOARD_ROWS):\n", " for j in range(BOARD_COLS):\n", " if self.board[i, j] == 0:\n", " positions.append((i, j)) # need to be tuple\n", " return positions\n", " \n", " def updateState(self, position):\n", " self.board[position] = self.playerSymbol\n", " # switch to another player\n", " self.playerSymbol = -1 if self.playerSymbol == 1 else 1\n", " \n", " # only when game ends\n", " def giveReward(self):\n", " result = self.winner()\n", " # backpropagate reward\n", " if result == 1:\n", " self.p1.feedReward(1)\n", " self.p2.feedReward(0)\n", " elif result == -1:\n", " self.p1.feedReward(0)\n", " self.p2.feedReward(1)\n", " else:\n", " self.p1.feedReward(0.1)\n", " self.p2.feedReward(0.5)\n", " \n", " # board reset\n", " def reset(self):\n", " self.board = np.zeros((BOARD_ROWS, BOARD_COLS))\n", " self.boardHash = None\n", " self.isEnd = False\n", " self.playerSymbol = 1\n", " \n", " def play(self, rounds=100):\n", " for i in range(rounds):\n", " if i%1000 == 0:\n", " print(\"Rounds {}\".format(i))\n", " while not self.isEnd:\n", " # Player 1\n", " positions = self.availablePositions()\n", " p1_action = self.p1.chooseAction(positions, self.board, self.playerSymbol)\n", " # take action and upate board state\n", " self.updateState(p1_action)\n", " board_hash = self.getHash()\n", " self.p1.addState(board_hash)\n", " # check board status if it is end\n", "\n", " win = self.winner()\n", " if win is not None:\n", " # self.showBoard()\n", " # ended with p1 either win or draw\n", " self.giveReward()\n", " self.p1.reset()\n", " self.p2.reset()\n", " self.reset()\n", " break\n", "\n", " else:\n", " # Player 2\n", " positions = self.availablePositions()\n", " p2_action = self.p2.chooseAction(positions, self.board, self.playerSymbol)\n", " self.updateState(p2_action)\n", " board_hash = self.getHash()\n", " self.p2.addState(board_hash)\n", " \n", " win = self.winner()\n", " if win is not None:\n", " # self.showBoard()\n", " # ended with p2 either win or draw\n", " self.giveReward()\n", " self.p1.reset()\n", " self.p2.reset()\n", " self.reset()\n", " break\n", " \n", " # play with human\n", " def play2(self):\n", " while not self.isEnd:\n", " # Player 1\n", " positions = self.availablePositions()\n", " p1_action = self.p1.chooseAction(positions, self.board, self.playerSymbol)\n", " # take action and upate board state\n", " self.updateState(p1_action)\n", " self.showBoard()\n", " # check board status if it is end\n", " win = self.winner()\n", " if win is not None:\n", " if win == 1:\n", " print(self.p1.name, \"wins!\")\n", " else:\n", " print(\"tie!\")\n", " self.reset()\n", " break\n", "\n", " else:\n", " # Player 2\n", " positions = self.availablePositions()\n", " p2_action = self.p2.chooseAction(positions)\n", "\n", " self.updateState(p2_action)\n", " self.showBoard()\n", " win = self.winner()\n", " if win is not None:\n", " if win == -1:\n", " print(self.p2.name, \"wins!\")\n", " else:\n", " print(\"tie!\")\n", " self.reset()\n", " break\n", "\n", " def showBoard(self):\n", " # p1: x p2: o\n", " for i in range(0, BOARD_ROWS):\n", " print('-------------')\n", " out = '| '\n", " for j in range(0, BOARD_COLS):\n", " if self.board[i, j] == 1:\n", " token = 'x'\n", " if self.board[i, j] == -1:\n", " token = 'o'\n", " if self.board[i, j] == 0:\n", " token = ' '\n", " out += token + ' | '\n", " print(out)\n", " print('-------------') " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class Player:\n", " def __init__(self, name, exp_rate=0.3):\n", " self.name = name\n", " self.states = [] # record all positions taken\n", " self.lr = 0.2\n", " self.exp_rate = exp_rate\n", " self.decay_gamma = 0.9\n", " self.states_value = {} # state -> value\n", " \n", " def getHash(self, board):\n", " boardHash = str(board.reshape(BOARD_COLS*BOARD_ROWS))\n", " return boardHash\n", " \n", " def chooseAction(self, positions, current_board, symbol):\n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " # take random action\n", " idx = np.random.choice(len(positions))\n", " action = positions[idx]\n", " else:\n", " value_max = -999\n", " for p in positions:\n", " next_board = current_board.copy()\n", " next_board[p] = symbol\n", " next_boardHash = self.getHash(next_board)\n", " value = 0 if self.states_value.get(next_boardHash) is None else self.states_value.get(next_boardHash)\n", " # print(\"value\", value)\n", " if value >= value_max:\n", " value_max = value\n", " action = p\n", " # print(\"{} takes action {}\".format(self.name, action))\n", " return action\n", " \n", " # append a hash state\n", " def addState(self, state):\n", " self.states.append(state)\n", " \n", " # at the end of game, backpropagate and update states value\n", " def feedReward(self, reward):\n", " for st in reversed(self.states):\n", " if self.states_value.get(st) is None:\n", " self.states_value[st] = 0\n", " self.states_value[st] += self.lr*(self.decay_gamma*reward - self.states_value[st])\n", " reward = self.states_value[st]\n", " \n", " def reset(self):\n", " self.states = []\n", " \n", " def savePolicy(self):\n", " fw = open('policy_' + str(self.name), 'wb')\n", " pickle.dump(self.states_value, fw)\n", " fw.close()\n", "\n", " def loadPolicy(self, file):\n", " fr = open(file,'rb')\n", " self.states_value = pickle.load(fr)\n", " fr.close()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class HumanPlayer:\n", " def __init__(self, name):\n", " self.name = name \n", " \n", " def chooseAction(self, positions):\n", " while True:\n", " row = int(input(\"Input your action row:\"))\n", " col = int(input(\"Input your action col:\"))\n", " action = (row, col)\n", " if action in positions:\n", " return action\n", " \n", " # append a hash state\n", " def addState(self, state):\n", " pass\n", " \n", " # at the end of game, backpropagate and update states value\n", " def feedReward(self, reward):\n", " pass\n", " \n", " def reset(self):\n", " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Training" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "training...\n", "Rounds 0\n", "Rounds 1000\n", "Rounds 2000\n", "Rounds 3000\n", "Rounds 4000\n", "Rounds 5000\n", "Rounds 6000\n", "Rounds 7000\n", "Rounds 8000\n", "Rounds 9000\n", "Rounds 10000\n", "Rounds 11000\n", "Rounds 12000\n", "Rounds 13000\n", "Rounds 14000\n", "Rounds 15000\n", "Rounds 16000\n", "Rounds 17000\n", "Rounds 18000\n", "Rounds 19000\n", "Rounds 20000\n", "Rounds 21000\n", "Rounds 22000\n", "Rounds 23000\n", "Rounds 24000\n", "Rounds 25000\n", "Rounds 26000\n", "Rounds 27000\n", "Rounds 28000\n", "Rounds 29000\n", "Rounds 30000\n", "Rounds 31000\n", "Rounds 32000\n", "Rounds 33000\n", "Rounds 34000\n", "Rounds 35000\n", "Rounds 36000\n", "Rounds 37000\n", "Rounds 38000\n", "Rounds 39000\n", "Rounds 40000\n", "Rounds 41000\n", "Rounds 42000\n", "Rounds 43000\n", "Rounds 44000\n", "Rounds 45000\n", "Rounds 46000\n", "Rounds 47000\n", "Rounds 48000\n", "Rounds 49000\n" ] } ], "source": [ "p1 = Player(\"p1\")\n", "p2 = Player(\"p2\")\n", "\n", "st = State(p1, p2)\n", "print(\"training...\")\n", "st.play(50000)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "p1.savePolicy()\n", "p2.savePolicy()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "p1.loadPolicy(\"policy_p1\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Human vs Computer" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------\n", "| | | | \n", "-------------\n", "| | x | | \n", "-------------\n", "| | | | \n", "-------------\n", "Input your action row:2\n", "Input your action col:2\n", "-------------\n", "| | | | \n", "-------------\n", "| | x | | \n", "-------------\n", "| | | o | \n", "-------------\n", "-------------\n", "| | | | \n", "-------------\n", "| | x | | \n", "-------------\n", "| | x | o | \n", "-------------\n", "Input your action row:0\n", "Input your action col:1\n", "-------------\n", "| | o | | \n", "-------------\n", "| | x | | \n", "-------------\n", "| | x | o | \n", "-------------\n", "-------------\n", "| | o | x | \n", "-------------\n", "| | x | | \n", "-------------\n", "| | x | o | \n", "-------------\n", "Input your action row:1\n", "Input your action col:1\n", "Input your action row:1\n", "Input your action col:0\n", "-------------\n", "| | o | x | \n", "-------------\n", "| o | x | | \n", "-------------\n", "| | x | o | \n", "-------------\n", "-------------\n", "| | o | x | \n", "-------------\n", "| o | x | | \n", "-------------\n", "| x | x | o | \n", "-------------\n", "computer wins!\n" ] } ], "source": [ "p1 = Player(\"computer\", exp_rate=0)\n", "p1.loadPolicy(\"policy_p1\")\n", "\n", "p2 = HumanPlayer(\"human\")\n", "\n", "st = State(p1, p2)\n", "st.play2()" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------\n", "| | | | \n", "-------------\n", "| | | x | \n", "-------------\n", "| | | | \n", "-------------\n", "Input your action row:2\n", "Input your action col:2\n", "-------------\n", "| | | | \n", "-------------\n", "| | | x | \n", "-------------\n", "| | | o | \n", "-------------\n", "-------------\n", "| | | | \n", "-------------\n", "| | x | x | \n", "-------------\n", "| | | o | \n", "-------------\n", "Input your action row:1\n", "Input your action col:0\n", "-------------\n", "| | | | \n", "-------------\n", "| o | x | x | \n", "-------------\n", "| | | o | \n", "-------------\n", "-------------\n", "| | | | \n", "-------------\n", "| o | x | x | \n", "-------------\n", "| x | | o | \n", "-------------\n", "Input your action row:0\n", "Input your action col:0\n", "-------------\n", "| o | | | \n", "-------------\n", "| o | x | x | \n", "-------------\n", "| x | | o | \n", "-------------\n", "-------------\n", "| o | | x | \n", "-------------\n", "| o | x | x | \n", "-------------\n", "| x | | o | \n", "-------------\n", "computer wins!\n" ] } ], "source": [ "p1 = Player(\"computer\", exp_rate=0)\n", "p1.loadPolicy(\"policy_p1\")\n", "\n", "p2 = HumanPlayer(\"human\")\n", "\n", "st = State(p1, p2)\n", "st.play2()" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: TicTacToe/ticTacToe.py ================================================ import numpy as np import pickle BOARD_ROWS = 3 BOARD_COLS = 3 class State: def __init__(self, p1, p2): self.board = np.zeros((BOARD_ROWS, BOARD_COLS)) self.p1 = p1 self.p2 = p2 self.isEnd = False self.boardHash = None # init p1 plays first self.playerSymbol = 1 # get unique hash of current board state def getHash(self): self.boardHash = str(self.board.reshape(BOARD_COLS * BOARD_ROWS)) return self.boardHash def winner(self): # row for i in range(BOARD_ROWS): if sum(self.board[i, :]) == 3: self.isEnd = True return 1 if sum(self.board[i, :]) == -3: self.isEnd = True return -1 # col for i in range(BOARD_COLS): if sum(self.board[:, i]) == 3: self.isEnd = True return 1 if sum(self.board[:, i]) == -3: self.isEnd = True return -1 # diagonal diag_sum1 = sum([self.board[i, i] for i in range(BOARD_COLS)]) diag_sum2 = sum([self.board[i, BOARD_COLS - i - 1] for i in range(BOARD_COLS)]) diag_sum = max(abs(diag_sum1), abs(diag_sum2)) if diag_sum == 3: self.isEnd = True if diag_sum1 == 3 or diag_sum2 == 3: return 1 else: return -1 # tie # no available positions if len(self.availablePositions()) == 0: self.isEnd = True return 0 # not end self.isEnd = False return None def availablePositions(self): positions = [] for i in range(BOARD_ROWS): for j in range(BOARD_COLS): if self.board[i, j] == 0: positions.append((i, j)) # need to be tuple return positions def updateState(self, position): self.board[position] = self.playerSymbol # switch to another player self.playerSymbol = -1 if self.playerSymbol == 1 else 1 # only when game ends def giveReward(self): result = self.winner() # backpropagate reward if result == 1: self.p1.feedReward(1) self.p2.feedReward(0) elif result == -1: self.p1.feedReward(0) self.p2.feedReward(1) else: self.p1.feedReward(0.1) self.p2.feedReward(0.5) # board reset def reset(self): self.board = np.zeros((BOARD_ROWS, BOARD_COLS)) self.boardHash = None self.isEnd = False self.playerSymbol = 1 def play(self, rounds=100): for i in range(rounds): if i % 1000 == 0: print("Rounds {}".format(i)) while not self.isEnd: # Player 1 positions = self.availablePositions() p1_action = self.p1.chooseAction(positions, self.board, self.playerSymbol) # take action and upate board state self.updateState(p1_action) board_hash = self.getHash() self.p1.addState(board_hash) # check board status if it is end win = self.winner() if win is not None: # self.showBoard() # ended with p1 either win or draw self.giveReward() self.p1.reset() self.p2.reset() self.reset() break else: # Player 2 positions = self.availablePositions() p2_action = self.p2.chooseAction(positions, self.board, self.playerSymbol) self.updateState(p2_action) board_hash = self.getHash() self.p2.addState(board_hash) win = self.winner() if win is not None: # self.showBoard() # ended with p2 either win or draw self.giveReward() self.p1.reset() self.p2.reset() self.reset() break # play with human def play2(self): while not self.isEnd: # Player 1 positions = self.availablePositions() p1_action = self.p1.chooseAction(positions, self.board, self.playerSymbol) # take action and upate board state self.updateState(p1_action) self.showBoard() # check board status if it is end win = self.winner() if win is not None: if win == 1: print(self.p1.name, "wins!") else: print("tie!") self.reset() break else: # Player 2 positions = self.availablePositions() p2_action = self.p2.chooseAction(positions) self.updateState(p2_action) self.showBoard() win = self.winner() if win is not None: if win == -1: print(self.p2.name, "wins!") else: print("tie!") self.reset() break def showBoard(self): # p1: x p2: o for i in range(0, BOARD_ROWS): print('-------------') out = '| ' for j in range(0, BOARD_COLS): if self.board[i, j] == 1: token = 'x' if self.board[i, j] == -1: token = 'o' if self.board[i, j] == 0: token = ' ' out += token + ' | ' print(out) print('-------------') class Player: def __init__(self, name, exp_rate=0.3): self.name = name self.states = [] # record all positions taken self.lr = 0.2 self.exp_rate = exp_rate self.decay_gamma = 0.9 self.states_value = {} # state -> value def getHash(self, board): boardHash = str(board.reshape(BOARD_COLS * BOARD_ROWS)) return boardHash def chooseAction(self, positions, current_board, symbol): if np.random.uniform(0, 1) <= self.exp_rate: # take random action idx = np.random.choice(len(positions)) action = positions[idx] else: value_max = -999 for p in positions: next_board = current_board.copy() next_board[p] = symbol next_boardHash = self.getHash(next_board) value = 0 if self.states_value.get(next_boardHash) is None else self.states_value.get(next_boardHash) # print("value", value) if value >= value_max: value_max = value action = p # print("{} takes action {}".format(self.name, action)) return action # append a hash state def addState(self, state): self.states.append(state) # at the end of game, backpropagate and update states value def feedReward(self, reward): for st in reversed(self.states): if self.states_value.get(st) is None: self.states_value[st] = 0 self.states_value[st] += self.lr * (self.decay_gamma * reward - self.states_value[st]) reward = self.states_value[st] def reset(self): self.states = [] def savePolicy(self): fw = open('policy_' + str(self.name), 'wb') pickle.dump(self.states_value, fw) fw.close() def loadPolicy(self, file): fr = open(file, 'rb') self.states_value = pickle.load(fr) fr.close() class HumanPlayer: def __init__(self, name): self.name = name def chooseAction(self, positions): while True: row = int(input("Input your action row:")) col = int(input("Input your action col:")) action = (row, col) if action in positions: return action # append a hash state def addState(self, state): pass # at the end of game, backpropagate and update states value def feedReward(self, reward): pass def reset(self): pass if __name__ == "__main__": # training p1 = Player("p1") p2 = Player("p2") st = State(p1, p2) print("training...") st.play(50000) # play with human p1 = Player("computer", exp_rate=0) p1.loadPolicy("policy_p1") p2 = HumanPlayer("human") st = State(p1, p2) st.play2() ================================================ FILE: TileCoding/TileCoding.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Tile Coding\n", "\n", "---\n", "\"drawing\"\n", "Tile coding is a form of coarse coding for multi-dimensional continuous spaces that is flexible and computationally efficient. It may be the most practical feature representation for modern sequential digital computers.\n", "\n", "\n", "In tile coding the receptive fields of the features are grouped into partitions of the state space. Each such partition is called a tiling, and each element of the partition is called a tile.\n", "\n", "---\n", "## Tiling Offset\n", "\n", "---\n", "Tilings in all cases are offset from each other by a fraction of a tile width in each dimension. If `w` denotes the tile width and `n` the number of tilings, then `w` is a fundamental `w/n` unit.\n", "\n", "In particular, for a continuous space of dimension `k`, a good choice is to use the first odd integers `(1,3,5,7,...,2k-1)`, with `n (the number of tilings)` set to an integer power of 2 greater than or equal to `4k`. (example: `= 4k>`)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from mpl_toolkits.mplot3d import Axes3D" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For a 2 dimensional space with features `x`, `y`, and `number of tilings = n`, \n", "then \n", "> `for each tiling`:\n", ">> `bins` * `bins`" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def create_tiling(feat_range, bins, offset):\n", " \"\"\"\n", " Create 1 tiling spec of 1 dimension(feature)\n", " feat_range: feature range; example: [-1, 1]\n", " bins: number of bins for that feature; example: 10\n", " offset: offset for that feature; example: 0.2\n", " \"\"\"\n", " \n", " return np.linspace(feat_range[0], feat_range[1], bins+1)[1:-1] + offset" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "feat_range = [0, 1.0]\n", "bins = 10\n", "offset = 0.2\n", "\n", "tiling_spec = create_tiling(feat_range, bins, offset)\n", "\n", "tiling_spec" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def create_tilings(feature_ranges, number_tilings, bins, offsets):\n", " \"\"\"\n", " feature_ranges: range of each feature; example: x: [-1, 1], y: [2, 5] -> [[-1, 1], [2, 5]]\n", " number_tilings: number of tilings; example: 3 tilings\n", " bins: bin size for each tiling and dimension; example: [[10, 10], [10, 10], [10, 10]]: 3 tilings * [x_bin, y_bin]\n", " offsets: offset for each tiling and dimension; example: [[0, 0], [0.2, 1], [0.4, 1.5]]: 3 tilings * [x_offset, y_offset]\n", " \"\"\"\n", " tilings = []\n", " # for each tiling\n", " for tile_i in range(number_tilings):\n", " tiling_bin = bins[tile_i]\n", " tiling_offset = offsets[tile_i]\n", " \n", " tiling = []\n", " # for each feature dimension\n", " for feat_i in range(len(feature_ranges)):\n", " feat_range = feature_ranges[feat_i]\n", " # tiling for 1 feature\n", " feat_tiling = create_tiling(feat_range, tiling_bin[feat_i], tiling_offset[feat_i])\n", " tiling.append(feat_tiling)\n", " tilings.append(tiling)\n", " return np.array(tilings)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(3, 2, 9)\n" ] } ], "source": [ "feature_ranges = [[-1, 1], [2, 5]] # 2 features\n", "number_tilings = 3\n", "bins = [[10, 10], [10, 10], [10, 10]] # each tiling has a 10*10 grid\n", "offsets = [[0, 0], [0.2, 1], [0.4, 1.5]]\n", "\n", "tilings = create_tilings(feature_ranges, number_tilings, bins, offsets)\n", "\n", "print(tilings.shape) # # of tilings X features X bins" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/plain": [ "array([[[-8.00000000e-01, -6.00000000e-01, -4.00000000e-01,\n", " -2.00000000e-01, 0.00000000e+00, 2.00000000e-01,\n", " 4.00000000e-01, 6.00000000e-01, 8.00000000e-01],\n", " [ 2.30000000e+00, 2.60000000e+00, 2.90000000e+00,\n", " 3.20000000e+00, 3.50000000e+00, 3.80000000e+00,\n", " 4.10000000e+00, 4.40000000e+00, 4.70000000e+00]],\n", "\n", " [[-6.00000000e-01, -4.00000000e-01, -2.00000000e-01,\n", " 5.55111512e-17, 2.00000000e-01, 4.00000000e-01,\n", " 6.00000000e-01, 8.00000000e-01, 1.00000000e+00],\n", " [ 3.30000000e+00, 3.60000000e+00, 3.90000000e+00,\n", " 4.20000000e+00, 4.50000000e+00, 4.80000000e+00,\n", " 5.10000000e+00, 5.40000000e+00, 5.70000000e+00]],\n", "\n", " [[-4.00000000e-01, -2.00000000e-01, 1.11022302e-16,\n", " 2.00000000e-01, 4.00000000e-01, 6.00000000e-01,\n", " 8.00000000e-01, 1.00000000e+00, 1.20000000e+00],\n", " [ 3.80000000e+00, 4.10000000e+00, 4.40000000e+00,\n", " 4.70000000e+00, 5.00000000e+00, 5.30000000e+00,\n", " 5.60000000e+00, 5.90000000e+00, 6.20000000e+00]]])" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tilings" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def get_tile_coding(feature, tilings):\n", " \"\"\"\n", " feature: sample feature with multiple dimensions that need to be encoded; example: [0.1, 2.5], [-0.3, 2.0]\n", " tilings: tilings with a few layers\n", " return: the encoding for the feature on each layer\n", " \"\"\"\n", " num_dims = len(feature)\n", " feat_codings = []\n", " for tiling in tilings:\n", " feat_coding = []\n", " for i in range(num_dims):\n", " feat_i = feature[i]\n", " tiling_i = tiling[i] # tiling on that dimension\n", " coding_i = np.digitize(feat_i, tiling_i)\n", " feat_coding.append(coding_i)\n", " feat_codings.append(feat_coding)\n", " return np.array(feat_codings)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[5, 1],\n", " [4, 0],\n", " [3, 0]])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "feature = [0.1, 2.5]\n", "\n", "coding = get_tile_coding(feature, tilings)\n", "coding" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Q table & Tiling combine\n", "---\n", "For each tiling, there is a q table with size ``" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [], "source": [ "class QValueFunction:\n", " \n", " def __init__(self, tilings, actions, lr):\n", " self.tilings = tilings\n", " self.num_tilings = len(self.tilings)\n", " self.actions = actions\n", " self.lr = lr # / self.num_tilings # learning rate equally assigned to each tiling\n", " self.state_sizes = [tuple(len(splits)+1 for splits in tiling) for tiling in self.tilings] # [(10, 10), (10, 10), (10, 10)]\n", " self.q_tables = [np.zeros(shape=(state_size+(len(self.actions),))) for state_size in self.state_sizes]\n", " \n", " def value(self, state, action):\n", " state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ...\n", " action_idx = self.actions.index(action)\n", " \n", " value = 0\n", " for coding, q_table in zip(state_codings, self.q_tables):\n", " value += q_table[tuple(coding)+(action_idx,)]\n", " return value / self.num_tilings\n", " \n", " def update(self, state, action, target):\n", " state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ...\n", " action_idx = self.actions.index(action)\n", " \n", " for coding, q_table in zip(state_codings, self.q_tables):\n", " delta = target - q_table[tuple(coding)+(action_idx,)]\n", " q_table[tuple(coding)+(action_idx,)] += self.lr * delta\n", " \n", " # get the # of steps to reach the goal under current state value function\n", " def costToGo(self, state):\n", " costs = []\n", " for action in self.actions:\n", " costs.append(self.value(state, action))\n", " return -np.max(costs)" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "feature_ranges = [[-1, 1], [2, 5]] # 2 features\n", "number_tilings = 3\n", "bins = [[10, 10], [10, 10], [10, 10]] # each tiling has a 10*10 grid\n", "offsets = [[0, 0], [0.2, 1], [0.4, 1.5]]\n", "\n", "tilings = create_tilings(feature_ranges, number_tilings, bins, offsets)\n", "\n", "q = QValueFunction(tilings, [-1, 0, 3], 0.1)" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(10, 10), (10, 10), (10, 10)]" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "q.state_sizes" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(10, 10, 3)" ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "q.q_tables[0].shape" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "q.update([0.3, 2.4], -1, 2.1)\n", "q.update([0.3, 2.4], -1, -10)\n", "q.value([0.3, 4], -1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Apply on Mountain Car" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "code_folding": [] }, "outputs": [], "source": [ "class MountainCar:\n", " \n", " def __init__(self, n=1, exp_rate=0.1, gamma=1, debug=True):\n", " self.actions = [-1, 0, 1] # reverse, 0 and forward throttle\n", " self.state = (-0.5, 0) # position, velocity\n", " self.exp_rate = exp_rate\n", " self.gamma = 1\n", " self.end = False\n", " self.n = n # step of learning\n", " self.debug = debug\n", " \n", " def reset(self):\n", " pos = np.random.uniform(-0.6, -0.4)\n", " self.end = False\n", " self.state = (pos, 0)\n", " \n", " def takeAction(self, action):\n", " pos, vel = self.state\n", " \n", " vel_new = vel + 0.001*action - 0.0025*np.cos(3*pos)\n", " vel_new = min(max(vel_new, VELOCITY_BOUND[0]), VELOCITY_BOUND[1])\n", " \n", " pos_new = pos + vel_new\n", " pos_new = min(max(pos_new, POSITION_BOUND[0]), POSITION_BOUND[1])\n", " \n", " if pos_new == POSITION_BOUND[0]:\n", " # reach leftmost, set speed to 0\n", " vel_new = 0\n", " self.state = (pos_new, vel_new)\n", " return self.state\n", " \n", " def chooseAction(self, valueFunc):\n", " # choose an action based on the current state, \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " # random action\n", " return np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " values = {}\n", " for a in self.actions:\n", " value = valueFunc.value(self.state, a)\n", " values[a] = value\n", " return np.random.choice([k for k, v in values.items() if v==max(values.values())])\n", " \n", " def giveReward(self):\n", " pos, _ = self.state\n", " if pos == POSITION_BOUND[1]:\n", " self.end = True\n", " return 0\n", " return -1\n", " \n", " def play(self, valueFunction, rounds=1):\n", " for rnd in range(1, rounds+1):\n", " self.reset()\n", " t = 0\n", " T = np.inf\n", " action = self.chooseAction(valueFunction)\n", " \n", " actions = [action]\n", " states = [self.state]\n", " rewards = [-1]\n", " \n", " while True:\n", " if t < T:\n", " state = self.takeAction(action) # next state\n", " reward = self.giveReward() # next state-reward\n", " \n", " states.append(state)\n", " rewards.append(reward)\n", " \n", " if self.end:\n", " if self.debug:\n", " if rnd % 100 == 0:\n", " print(\"Round {}: End at state {} | number of states {}\".format(rnd, state, len(states)))\n", " T = t+1\n", " else:\n", " action = self.chooseAction(valueFunction)\n", " actions.append(action) # next action\n", " # state tau being updated\n", " tau = t - self.n + 1\n", " if tau >= 0:\n", " G = 0\n", " for i in range(tau+1, min(tau+self.n+1, T+1)):\n", " G += np.power(self.gamma, i-tau-1)*rewards[i]\n", " if tau+self.n < T:\n", " state = states[tau+self.n]\n", " G += np.power(self.gamma, self.n)*valueFunction.value(state, actions[tau+self.n])\n", " # update value function\n", " state = states[tau] # tau is the state to update\n", " valueFunction.update(state, actions[tau], G)\n", " \n", " if tau == T-1:\n", " break\n", " \n", " t += 1" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [], "source": [ "VELOCITY_BOUND = [-0.07, 0.07]\n", "POSITION_BOUND = [-1.2, 0.5]\n", "ACTIONS = [-1, 0, 1]" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [], "source": [ "feature_ranges = [POSITION_BOUND, VELOCITY_BOUND] # 2 features\n", "number_tilings = 8\n", "bins = [[16, 16] for _ in range(number_tilings)]\n", "offsets = [[i, j] for i, j in zip(np.linspace(POSITION_BOUND[0], POSITION_BOUND[1], number_tilings), np.linspace(VELOCITY_BOUND[0], VELOCITY_BOUND[1], number_tilings))]\n", "\n", "tilings = create_tilings(feature_ranges=feature_ranges, number_tilings=number_tilings, bins=bins, offsets=offsets)" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tiling shape: \n", " (8, 2, 15)\n", "offsets: \n", " [[-1.2, -0.07], [-0.9571428571428571, -0.05], [-0.7142857142857142, -0.030000000000000006], [-0.4714285714285714, -0.010000000000000009], [-0.22857142857142854, 0.009999999999999995], [0.014285714285714235, 0.03], [0.2571428571428571, 0.04999999999999999], [0.5, 0.07]]\n" ] } ], "source": [ "print(\"tiling shape: \\n\", tilings.shape)\n", "print(\"offsets: \\n\", offsets)" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [], "source": [ "valueFunc = QValueFunction(tilings, ACTIONS, 0.3)\n", "mc = MountainCar() # 1 step sarsa\n", "mc.play(valueFunc, rounds=1)" ] }, { "cell_type": "code", "execution_count": 187, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5,0,'Cost to go')" ] }, "execution_count": 187, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# step 100\n", "grids = 50\n", "\n", "positions = np.linspace(POSITION_BOUND[0], POSITION_BOUND[1], grids)\n", "vels = np.linspace(VELOCITY_BOUND[0], VELOCITY_BOUND[1], grids)\n", "\n", "x = []\n", "y = []\n", "z = []\n", "for p in positions:\n", " for v in vels:\n", " x.append(p)\n", " y.append(v)\n", " z.append(valueFunc.costToGo([p, v]))\n", "\n", "fig = plt.figure(figsize=[10, 6])\n", "ax = fig.add_subplot(111, projection='3d')\n", "ax.scatter(x, y, z)\n", "\n", "ax.set_xlabel(\"Position\")\n", "ax.set_ylabel(\"Velocity\")\n", "ax.set_zlabel(\"Cost to go\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Apply on Random Walk" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "NUM_STATES = 1000\n", "START = 500\n", "END_0 = 0\n", "END_1 = 1001\n", "\n", "TRUE_VALUES = np.arange(-1001, 1003, 2) / 1001.0" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "class RandomWalk:\n", "\n", " def __init__(self, step=1, lr=2e-5, exp_rate=0.2, gamma=1, debug=True):\n", " self.state = START\n", " self.actions = [\"left\", \"right\"]\n", " self.end = False\n", " self.n = step\n", " self.lr = lr\n", " self.gamma = gamma\n", " self.exp_rate = exp_rate\n", " self.debug = debug\n", "\n", " def chooseAction(self, valueFunc):\n", " # choose an action based on the current state, \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " # random action\n", " return np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " values = {}\n", " for a in self.actions:\n", " value = valueFunc.value([self.state], a)\n", " values[a] = value\n", " return np.random.choice([k for k, v in values.items() if v==max(values.values())])\n", "\n", " return action\n", "\n", " def takeAction(self, action):\n", " # choose steps from 1 to 100\n", " steps = np.random.choice(range(1, 101))\n", " if action == \"left\":\n", " state = self.state - steps\n", " else:\n", " state = self.state + steps\n", " # judge if end of game\n", " if state <= END_0 or state >= END_1:\n", " self.end = True\n", " if state <= END_0:\n", " state = END_0\n", " else:\n", " state = END_1\n", "\n", " self.state = state\n", " return state\n", "\n", " def giveReward(self):\n", " if self.state == END_0:\n", " return -1\n", " if self.state == END_1:\n", " return 1\n", " return 0\n", "\n", " def reset(self):\n", " self.state = START\n", " self.end = False\n", "\n", " def play(self, valueFunction, rounds=1e5):\n", " for rnd in range(1, rounds+1):\n", " self.reset()\n", " t = 0\n", " T = np.inf\n", " action = self.chooseAction(valueFunction)\n", "\n", " actions = [action]\n", " states = [self.state]\n", " rewards = [0]\n", " while True:\n", " if t < T:\n", " state = self.takeAction(action) # next state\n", " reward = self.giveReward() # next state-reward\n", "\n", " states.append(state)\n", " rewards.append(reward)\n", "\n", " if self.end:\n", " if self.debug:\n", " if rnd % 100 == 0:\n", " print(\"Round {}: End at state {} | number of states {}\".format(rnd, state,\n", " len(states)))\n", " T = t + 1\n", " else:\n", " action = self.chooseAction(valueFunction)\n", " actions.append(action) # next action\n", " # state tau being updated\n", " tau = t - self.n + 1\n", " if tau >= 0:\n", " G = 0\n", " for i in range(tau + 1, min(tau + self.n + 1, T + 1)):\n", " G += np.power(self.gamma, i - tau - 1) * rewards[i]\n", " if tau + self.n < T:\n", " state = states[tau + self.n]\n", " G += np.power(self.gamma, self.n) * valueFunction.value([state], actions[tau+self.n])\n", " # update value function\n", " state = states[tau]\n", " action = actions[tau]\n", " valueFunction.update([state], action, G)\n", "\n", " if tau == T - 1:\n", " break\n", "\n", " t += 1" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "feature_ranges = [[0, 1000]] # 1 features\n", "number_tilings = 50\n", "bins = [[10] for _ in range(number_tilings)]\n", "offsets = [[i] for i in np.linspace(0, 1000, number_tilings)]\n", "\n", "tilings = create_tilings(feature_ranges=feature_ranges, number_tilings=number_tilings, bins=bins, offsets=offsets)" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Round 100: End at state 1001 | number of states 12\n", "Round 200: End at state 1001 | number of states 12\n", "Round 300: End at state 1001 | number of states 12\n", "Round 400: End at state 1001 | number of states 16\n", "Round 500: End at state 1001 | number of states 15\n", "Round 600: End at state 1001 | number of states 10\n", "Round 700: End at state 1001 | number of states 13\n", "Round 800: End at state 1001 | number of states 10\n", "Round 900: End at state 1001 | number of states 13\n", "Round 1000: End at state 1001 | number of states 16\n" ] } ], "source": [ "rw = RandomWalk()\n", "valueFunc = QValueFunction(tilings, [\"left\", \"right\"], 0.01)\n", "\n", "rw.play(valueFunction=valueFunc, rounds=1000)" ] }, { "cell_type": "code", "execution_count": 215, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "state 1.0 acton left -> value 0.6049475029939985\n", "state 1.0 acton right -> value 0.6996471392154379\n", "state 101.0 acton left -> value 0.605147169175246\n", "state 101.0 acton right -> value 0.6996471392154379\n", "state 201.0 acton left -> value 0.6059455222110735\n", "state 201.0 acton right -> value 0.7031270458181881\n", "state 301.0 acton left -> value 0.6198255204402774\n", "state 301.0 acton right -> value 0.7840937436115838\n", "state 401.0 acton left -> value 0.7133947678730438\n", "state 401.0 acton right -> value 0.9212680233079227\n", "state 501.0 acton left -> value 0.9205986692393625\n", "state 501.0 acton right -> value 0.951930062775746\n", "state 601.0 acton left -> value 0.9382399635494744\n", "state 601.0 acton right -> value 0.9555705571012205\n", "state 701.0 acton left -> value 0.9446024492925028\n", "state 701.0 acton right -> value 0.9601173583971238\n", "state 801.0 acton left -> value 0.9522271081518292\n", "state 801.0 acton right -> value 0.9673228130023039\n", "state 901.0 acton left -> value 0.9668247163642811\n", "state 901.0 acton right -> value 0.9781635701706414\n" ] } ], "source": [ "for s in np.linspace(1, 901, 10):\n", " for a in [\"left\", \"right\"]:\n", " v = valueFunc.value([s], a)\n", " print(\"state {} acton {} -> value {}\".format(s, a, v))" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: TileCoding/tile_coding.py ================================================ import numpy as np def create_tiling(feat_range, bins, offset): """ Create 1 tiling spec of 1 dimension(feature) feat_range: feature range; example: [-1, 1] bins: number of bins for that feature; example: 10 offset: offset for that feature; example: 0.2 """ return np.linspace(feat_range[0], feat_range[1], bins+1)[1:-1] + offset def create_tilings(feature_ranges, number_tilings, bins, offsets): """ feature_ranges: range of each feature; example: x: [-1, 1], y: [2, 5] -> [[-1, 1], [2, 5]] number_tilings: number of tilings; example: 3 tilings bins: bin size for each tiling and dimension; example: [[10, 10], [10, 10], [10, 10]]: 3 tilings * [x_bin, y_bin] offsets: offset for each tiling and dimension; example: [[0, 0], [0.2, 1], [0.4, 1.5]]: 3 tilings * [x_offset, y_offset] """ tilings = [] # for each tiling for tile_i in range(number_tilings): tiling_bin = bins[tile_i] tiling_offset = offsets[tile_i] tiling = [] # for each feature dimension for feat_i in range(len(feature_ranges)): feat_range = feature_ranges[feat_i] # tiling for 1 feature feat_tiling = create_tiling(feat_range, tiling_bin[feat_i], tiling_offset[feat_i]) tiling.append(feat_tiling) tilings.append(tiling) return np.array(tilings) def get_tile_coding(feature, tilings): """ feature: sample feature with multiple dimensions that need to be encoded; example: [0.1, 2.5], [-0.3, 2.0] tilings: tilings with a few layers return: the encoding for the feature on each layer """ num_dims = len(feature) feat_codings = [] for tiling in tilings: feat_coding = [] for i in range(num_dims): feat_i = feature[i] tiling_i = tiling[i] # tiling on that dimension coding_i = np.digitize(feat_i, tiling_i) feat_coding.append(coding_i) feat_codings.append(feat_coding) return np.array(feat_codings) # example Q-function class QValueFunction: def __init__(self, tilings, actions, lr): self.tilings = tilings self.num_tilings = len(self.tilings) self.actions = actions self.lr = lr # /self.num_tilings # learning rate equally assigned to each tiling self.state_sizes = [tuple(len(splits) + 1 for splits in tiling) for tiling in self.tilings] # [(10, 10), (10, 10), (10, 10)] self.q_tables = [np.zeros(shape=(state_size + (len(self.actions),))) for state_size in self.state_sizes] def value(self, state, action): state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ... action_idx = self.actions.index(action) value = 0 for coding, q_table in zip(state_codings, self.q_tables): # for each q table value += q_table[tuple(coding) + (action_idx,)] return value / self.num_tilings def update(self, state, action, target): state_codings = get_tile_coding(state, self.tilings) # [[5, 1], [4, 0], [3, 0]] ... action_idx = self.actions.index(action) for coding, q_table in zip(state_codings, self.q_tables): delta = target - q_table[tuple(coding) + (action_idx,)] q_table[tuple(coding) + (action_idx,)] += self.lr * (delta) ================================================ FILE: WindyGridWorld/Windy_GW.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Windy Grid World\n", "---\n", "\"drawing\"\n", "---\n", "Column specifies wind strength and it always blows the agent up." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class State:\n", " def __init__(self, state=(3, 0), rows=7, cols=10):\n", " self.END_STATE = (3, 7)\n", " self.WIND = [0, 0, 0, 1, 1, 1, 2, 2, 1, 0]\n", " self.ROWS = 7\n", " self.COLS = 10\n", " \n", " self.state = state # starting point\n", " self.isEnd = True if self.state == self.END_STATE else False\n", " \n", " def giveReward(self):\n", " if self.state == self.END_STATE:\n", " return 1\n", " else:\n", " return 0\n", " \n", " def nxtPosition(self, action):\n", " \"\"\"\n", " action: up, down, left, right\n", " ------------------\n", " 0 | 1 | 2| 3| ...\n", " 1 |\n", " 2 |\n", " ...|\n", " return next position on board based on wind strength of that column\n", " (according to the book, the number of steps shifted upward is based on the current state)\n", " \"\"\"\n", " currentWindy = self.WIND[self.state[1]]\n", " \n", " if action == \"up\":\n", " nxtState = (self.state[0]-1-currentWindy, self.state[1])\n", " elif action == \"down\":\n", " nxtState = (self.state[0]+1-currentWindy, self.state[1])\n", " elif action == \"left\":\n", " nxtState = (self.state[0]-currentWindy, self.state[1]-1)\n", " else:\n", " nxtState = (self.state[0]-currentWindy, self.state[1]+1)\n", " \n", " # if next state is legal\n", " positionRow, positionCol = 0, 0\n", " if (nxtState[0] >= 0) and (nxtState[0] <= (self.ROWS - 1)):\n", " positionRow = nxtState[0]\n", " else:\n", " positonRow = self.state[0]\n", " \n", " if (nxtState[1] >= 0) and (nxtState[1] <= (self.COLS - 1)):\n", " positionCol = nxtState[1]\n", " else:\n", " positionCol = self.state[1]\n", " # if bash into walls\n", " return (positionRow, positionCol)\n", " \n", " def showBoard(self):\n", " self.board = np.zeros([self.ROWS, self.COLS])\n", " self.board[self.state] = 1\n", " self.board[self.END_STATE] = -1\n", " \n", " for i in range(self.ROWS):\n", " print('-----------------------------------------')\n", " out = '| '\n", " for j in range(self.COLS):\n", " if self.board[i, j] == 1:\n", " token = 'S'\n", " if self.board[i, j] == -1:\n", " token = 'G'\n", " if self.board[i, j] == 0:\n", " token = '0'\n", " out += token + ' | '\n", " print(out)\n", " print('-----------------------------------------') " ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| S | 0 | 0 | 0 | 0 | 0 | 0 | G | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n" ] } ], "source": [ "s = State()\n", "s.showBoard()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | S | 0 | 0 | 0 | 0 | 0 | G | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n", "| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | \n", "-----------------------------------------\n" ] } ], "source": [ "s.state = s.nxtPosition(\"right\")\n", "s.showBoard()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "class Agent:\n", " \n", " def __init__(self, lr=0.2, exp_rate=0.3):\n", " self.END_STATE = (3, 7)\n", " self.START_STATE = (3, 0)\n", " self.ROWS = 7\n", " self.COLS = 10\n", " \n", " self.states = [] # record position and action taken at the position\n", " self.actions = [\"up\", \"down\", \"left\", \"right\"]\n", " self.State = State()\n", " self.lr = lr\n", " self.exp_rate = exp_rate\n", "\n", " # initial Q values\n", " self.Q_values = {}\n", " for i in range(self.ROWS):\n", " for j in range(self.COLS):\n", " self.Q_values[(i, j)] = {}\n", " for a in self.actions:\n", " self.Q_values[(i, j)][a] = 0 # Q value is a dict of dict \n", " \n", " def chooseAction(self):\n", " # choose action with most expected value\n", " mx_nxt_reward = 0\n", " action = \"\"\n", " \n", " if np.random.uniform(0, 1) <= self.exp_rate:\n", " action = np.random.choice(self.actions)\n", " else:\n", " # greedy action\n", " for a in self.actions:\n", " current_position = self.State.state\n", " nxt_reward = self.Q_values[current_position][a]\n", " if nxt_reward >= mx_nxt_reward:\n", " action = a\n", " mx_nxt_reward = nxt_reward\n", " # print(\"current pos: {}, greedy aciton: {}\".format(self.State.state, action))\n", " return action\n", " \n", " def takeAction(self, action):\n", " position = self.State.nxtPosition(action)\n", " # update State\n", " return State(state=position) \n", " \n", " def reset(self):\n", " self.states = []\n", " self.State = State()\n", " \n", " def play(self, rounds=10):\n", " i = 0\n", " while i < rounds:\n", " # to the end of game back propagate reward\n", " if self.State.isEnd:\n", " if i % 5 == 0:\n", " print(\"round\", i)\n", " # back propagate\n", " reward = self.State.giveReward()\n", " for a in self.actions:\n", " self.Q_values[self.State.state][a] = reward\n", " print(\"Game End Reward\", reward)\n", " for s in reversed(self.states):\n", " current_q_value = self.Q_values[s[0]][s[1]]\n", " reward = current_q_value + self.lr*(reward - current_q_value)\n", " self.Q_values[s[0]][s[1]] = round(reward, 3)\n", " self.reset()\n", " i += 1\n", " else:\n", " action = self.chooseAction()\n", " # append trace\n", " self.states.append([(self.State.state), action])\n", " # print(\"current position {} action {}\".format(self.State.state, action))\n", " # by taking the action, it reaches the next state\n", " self.State = self.takeAction(action)\n", " \n", " # print(\"nxt state\", self.State.state)\n", " # print(\"---------------------\")" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "round 0\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 5\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 10\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 15\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 20\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 25\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 30\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 35\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 40\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "round 45\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n", "Game End Reward 1\n" ] } ], "source": [ "ag = Agent(exp_rate=0.3)\n", "ag.play(50)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Find the best route\n", "\"drawing\"" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "current state (3, 0), action right\n", "current state (3, 1), action right\n", "current state (3, 2), action right\n", "current state (3, 3), action right\n", "current state (2, 4), action right\n", "current state (1, 5), action right\n", "current state (0, 6), action right\n", "current state (0, 7), action right\n", "current state (0, 8), action right\n", "current state (0, 9), action down\n", "current state (1, 9), action down\n", "current state (2, 9), action down\n", "current state (3, 9), action down\n", "current state (4, 9), action left\n", "current state (4, 8), action left\n" ] } ], "source": [ "ag_op = Agent(exp_rate=0)\n", "ag_op.Q_values = ag.Q_values\n", "\n", "while not ag_op.State.isEnd:\n", " action = ag_op.chooseAction()\n", " print(\"current state {}, action {}\".format(ag_op.State.state, action))\n", " ag_op.State = ag_op.takeAction(action)" ] }, { "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: WindyGridWorld/windyGridWorld.py ================================================ import numpy as np class State: def __init__(self, state=(3, 0), rows=7, cols=10): self.END_STATE = (3, 7) self.WIND = [0, 0, 0, 1, 1, 1, 2, 2, 1, 0] self.ROWS = 7 self.COLS = 10 self.state = state # starting point self.isEnd = True if self.state == self.END_STATE else False def giveReward(self): if self.state == self.END_STATE: return 1 else: return 0 def nxtPosition(self, action): """ action: up, down, left, right ------------------ 0 | 1 | 2| 3| ... 1 | 2 | ...| return next position on board based on wind strength of that column (according to the book, the number of steps shifted upward is based on the current state) """ currentWindy = self.WIND[self.state[1]] if action == "up": nxtState = (self.state[0] - 1 - currentWindy, self.state[1]) elif action == "down": nxtState = (self.state[0] + 1 - currentWindy, self.state[1]) elif action == "left": nxtState = (self.state[0] - currentWindy, self.state[1] - 1) else: nxtState = (self.state[0] - currentWindy, self.state[1] + 1) # if next state is legal positionRow, positionCol = 0, 0 if (nxtState[0] >= 0) and (nxtState[0] <= (self.ROWS - 1)): positionRow = nxtState[0] else: positonRow = self.state[0] if (nxtState[1] >= 0) and (nxtState[1] <= (self.COLS - 1)): positionCol = nxtState[1] else: positionCol = self.state[1] # if bash into walls return (positionRow, positionCol) def showBoard(self): self.board = np.zeros([self.ROWS, self.COLS]) self.board[self.state] = 1 self.board[self.END_STATE] = -1 for i in range(self.ROWS): print('-----------------------------------------') out = '| ' for j in range(self.COLS): if self.board[i, j] == 1: token = 'S' if self.board[i, j] == -1: token = 'G' if self.board[i, j] == 0: token = '0' out += token + ' | ' print(out) print('-----------------------------------------') class Agent: def __init__(self, lr=0.2, exp_rate=0.3): self.END_STATE = (3, 7) self.START_STATE = (3, 0) self.ROWS = 7 self.COLS = 10 self.states = [] # record position and action taken at the position self.actions = ["up", "down", "left", "right"] self.State = State() self.lr = lr self.exp_rate = exp_rate # initial Q values self.Q_values = {} for i in range(self.ROWS): for j in range(self.COLS): self.Q_values[(i, j)] = {} for a in self.actions: self.Q_values[(i, j)][a] = 0 # Q value is a dict of dict def chooseAction(self): # choose action with most expected value mx_nxt_reward = 0 action = "" if np.random.uniform(0, 1) <= self.exp_rate: action = np.random.choice(self.actions) else: # greedy action for a in self.actions: current_position = self.State.state nxt_reward = self.Q_values[current_position][a] if nxt_reward >= mx_nxt_reward: action = a mx_nxt_reward = nxt_reward # print("current pos: {}, greedy aciton: {}".format(self.State.state, action)) return action def takeAction(self, action): position = self.State.nxtPosition(action) # update State return State(state=position) def reset(self): self.states = [] self.State = State() def play(self, rounds=10): i = 0 while i < rounds: # to the end of game back propagate reward if self.State.isEnd: if i % 5 == 0: print("round", i) # back propagate reward = self.State.giveReward() for a in self.actions: self.Q_values[self.State.state][a] = reward print("Game End Reward", reward) for s in reversed(self.states): current_q_value = self.Q_values[s[0]][s[1]] reward = current_q_value + self.lr * (reward - current_q_value) self.Q_values[s[0]][s[1]] = round(reward, 3) self.reset() i += 1 else: action = self.chooseAction() # append trace self.states.append([(self.State.state), action]) # by taking the action, it reaches the next state self.State = self.takeAction(action) if __name__ == "__main__": print("training ...") ag = Agent(exp_rate=0.3) ag.play(50) print("playing ...") ag_op = Agent(exp_rate=0) ag_op.Q_values = ag.Q_values while not ag_op.State.isEnd: action = ag_op.chooseAction() print("current state {}, action {}".format(ag_op.State.state, action)) ag_op.State = ag_op.takeAction(action)