tictactoe3

2da5e001 · Wade Fagen-Ulmschneider (waf) · c6474aa3 · 2da5e001
Commit 2da5e001 authored 8 years ago by Wade Fagen-Ulmschneider (waf)
--- a/demo_tictactoe/py/tictactoe-day3.ipynb
+++ b/demo_tictactoe/py/tictactoe-day3.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tic-tac-toe\n",
+    "\n",
+    "Using graphs, we will explore the state space of a game of tic-tac-toe!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "import networkx as nx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "def isWinningState(state):\n",
+    "    winningIndexes = [\n",
+    "        # Horz\n",
+    "        [0, 1, 2],\n",
+    "        [3, 4, 5],\n",
+    "        [6, 7, 8],\n",
+    "        \n",
+    "        # Vert\n",
+    "        [0, 3, 6],\n",
+    "        [1, 4, 7],\n",
+    "        [2, 5, 8],\n",
+    "        \n",
+    "        # Diag\n",
+    "        [0, 4, 8],\n",
+    "        [2, 4, 6]\n",
+    "    ]\n",
+    "    \n",
+    "    for i in range(len(winningIndexes)):\n",
+    "        win_index1 = winningIndexes[i][0]\n",
+    "        win_index2 = winningIndexes[i][1]\n",
+    "        win_index3 = winningIndexes[i][2]\n",
+    "        \n",
+    "        if state[win_index1] == state[win_index2] and \\\n",
+    "        state[win_index2] == state[win_index3]:\n",
+    "                if state[win_index1] == \"X\":\n",
+    "                    # X is the winner\n",
+    "                    return \"X\"\n",
+    "                elif state[win_index1] == \"O\":\n",
+    "                    # O is the winner\n",
+    "                    return \"O\"\n",
+    "                    \n",
+    "    return \"-\"\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def getNextPlayer(state):\n",
+    "    x_ct = 0\n",
+    "    o_ct = 0\n",
+    "    for i in range(len(state)):\n",
+    "        if state[i] == \"X\":\n",
+    "            x_ct += 1\n",
+    "        if state[i] == \"O\":\n",
+    "            o_ct += 1\n",
+    "            \n",
+    "    if x_ct == o_ct:\n",
+    "        return \"X\"\n",
+    "    else:\n",
+    "        return \"O\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def getNextMoves(state):\n",
+    "    nextStates = []\n",
+    "    if isWinningState(state) == \"X\" or isWinningState(state) == \"O\":\n",
+    "        return nextStates\n",
+    "    \n",
+    "    nextPlayer = getNextPlayer(state)\n",
+    "    for i in range(len(state)):\n",
+    "        if state[i] == \"-\":\n",
+    "            nextState = list(state)  # makes a copy of the list\n",
+    "            nextState[i] = nextPlayer\n",
+    "            nextStates.append(nextState)\n",
+    "    return nextStates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "def makeNextMoves(state, nodeId):\n",
+    "    global nextId\n",
+    "    nextMoves = getNextMoves(state)\n",
+    "    for nextMove in nextMoves:\n",
+    "        nextId += 1\n",
+    "        G.add_node(nextId, state = nextMove)\n",
+    "        G.add_edge(nodeId, nextId)\n",
+    "        makeNextMoves(nextMove, nextId)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "G = nx.DiGraph()\n",
+    "nextId = 1\n",
+    "\n",
+    "initState = [\"X\", \"-\", \"-\", \"-\", \"O\", \"-\", \"-\", \"-\", \"-\"]\n",
+    "G.add_node(nextId, state = initState)\n",
+    "makeNextMoves(initState, nextId)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "with open(\"../res/tree.json\", \"w\") as f:\n",
+    "    from networkx.readwrite import json_graph\n",
+    "    data = json_graph.tree_data(G, root=1)\n",
+    "    json.dump(data, f, indent=2)"
+   ]
+  },
+  {
+   "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.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
+%% Cell type:markdown id: tags:
+
+## Tic-tac-toe
+
+Using graphs, we will explore the state space of a game of tic-tac-toe!
+
+%% Cell type:code id: tags:
+
+``` python
+import networkx as nx
+```
+
+%% Cell type:code id: tags:
+
+``` python
+def isWinningState(state):
+    winningIndexes = [
+        # Horz
+        [0, 1, 2],
+        [3, 4, 5],
+        [6, 7, 8],
+
+        # Vert
+        [0, 3, 6],
+        [1, 4, 7],
+        [2, 5, 8],
+
+        # Diag
+        [0, 4, 8],
+        [2, 4, 6]
+    ]
+
+    for i in range(len(winningIndexes)):
+        win_index1 = winningIndexes[i][0]
+        win_index2 = winningIndexes[i][1]
+        win_index3 = winningIndexes[i][2]
+
+        if state[win_index1] == state[win_index2] and \
+        state[win_index2] == state[win_index3]:
+                if state[win_index1] == "X":
+                    # X is the winner
+                    return "X"
+                elif state[win_index1] == "O":
+                    # O is the winner
+                    return "O"
+
+    return "-"
+
+```
+
+%% Cell type:code id: tags:
+
+``` python
+def getNextPlayer(state):
+    x_ct = 0
+    o_ct = 0
+    for i in range(len(state)):
+        if state[i] == "X":
+            x_ct += 1
+        if state[i] == "O":
+            o_ct += 1
+
+    if x_ct == o_ct:
+        return "X"
+    else:
+        return "O"
+```
+
+%% Cell type:code id: tags:
+
+``` python
+def getNextMoves(state):
+    nextStates = []
+    if isWinningState(state) == "X" or isWinningState(state) == "O":
+        return nextStates
+
+    nextPlayer = getNextPlayer(state)
+    for i in range(len(state)):
+        if state[i] == "-":
+            nextState = list(state)  # makes a copy of the list
+            nextState[i] = nextPlayer
+            nextStates.append(nextState)
+    return nextStates
+```
+
+%% Cell type:code id: tags:
+
+``` python
+def makeNextMoves(state, nodeId):
+    global nextId
+    nextMoves = getNextMoves(state)
+    for nextMove in nextMoves:
+        nextId += 1
+        G.add_node(nextId, state = nextMove)
+        G.add_edge(nodeId, nextId)
+        makeNextMoves(nextMove, nextId)
+```
+
+%% Cell type:code id: tags:
+
+``` python
+G = nx.DiGraph()
+nextId = 1
+
+initState = ["X", "-", "-", "-", "O", "-", "-", "-", "-"]
+G.add_node(nextId, state = initState)
+makeNextMoves(initState, nextId)
+```
+
+%% Cell type:code id: tags:
+
+``` python
+import json
+with open("../res/tree.json", "w") as f:
+    from networkx.readwrite import json_graph
+    data = json_graph.tree_data(G, root=1)
+    json.dump(data, f, indent=2)
+```
+
+%% Cell type:code id: tags:
+
+``` python
+```