Peg Solitaire Puzzles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Goal of this Notebook: Use graph search algorithms to solve Peg Solitaire: https://en.wikipedia.org/wiki/Peg_solitaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "from IPython.display import clear_output\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.ticker as plticker\n",
    "import networkx as nx\n",
    "import random\n",
    "from collections import namedtuple\n",
    "import heapq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Problem():\n",
    "    def __init__(self, problem_mapping):\n",
    "        self._problem = problem_mapping\n",
    "        self.states = self._problem.keys()\n",
    "    \n",
    "    def result(self, state, action):\n",
    "        abstract\n",
    "        \n",
    "    def cost(self, action):\n",
    "        abstract\n",
    "        \n",
    "    def available(self, state):\n",
    "        assert state in self._problem\n",
    "        return self._problem[state]\n",
    "    \n",
    "    def goal_test(self, state):\n",
    "        abstract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Node():\n",
    "    def __init__(self, state, parent, action, path_cost):\n",
    "        self.state = state\n",
    "        self.parent = parent\n",
    "        self.action = action\n",
    "        self.path_cost = path_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def child_node(problem, parent, action):\n",
    "    '''return a node that is a child of given node'''\n",
    "    new_state = problem.result(parent.state, action)\n",
    "    this_cost = parent.path_cost + problem.cost(action)\n",
    "    return Node(new_state, parent, action, this_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def breadth_first_search(problem, start_node):\n",
    "    if problem.goal_test(start_node.state):\n",
    "        return start_node\n",
    "    frontier = [start_node]\n",
    "    frontier_states = {start_node.state}\n",
    "    explored = set([])\n",
    "    while(1):\n",
    "        if len(frontier) == 0:\n",
    "            return 'FAILURE'\n",
    "        this_node = frontier.pop(0)\n",
    "        frontier_states.remove(this_node.state)\n",
    "        explored.add(this_node.state)\n",
    "        #print explored\n",
    "        for action in problem.available(this_node.state):\n",
    "            this_child = child_node(problem, this_node, action)\n",
    "            if (this_child.state not in explored) and (this_child.state not in frontier_states):\n",
    "                if problem.goal_test(this_child.state):\n",
    "                    return this_child\n",
    "                frontier.append(this_child)\n",
    "                frontier_states.add(this_child.state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def uniform_cost_search(problem, start_node):\n",
    "    if problem.goal_test(start_node.state):\n",
    "        return start_node\n",
    "\n",
    "    frontier = []\n",
    "    heapq.heappush(frontier, (0, start_node))\n",
    "    \n",
    "    frontier_states = {start_node.state:start_node.path_cost}\n",
    "    explored = set([])\n",
    "    \n",
    "    while(1):\n",
    "        try:\n",
    "            this_node = heapq.heappop(frontier)[1]\n",
    "        except IndexError:\n",
    "            return 'FAILURE' #heap was empty\n",
    "                \n",
    "        del frontier_states[this_node.state]\n",
    "        if problem.goal_test(this_node.state):\n",
    "            print this_node\n",
    "            return this_node\n",
    "        explored.add(this_node.state)\n",
    "        for action in problem.available(this_node.state):\n",
    "            this_child = child_node(problem, this_node, action)\n",
    "            if (this_child.state not in explored) and (this_child.state not in frontier_states.keys()):\n",
    "                heapq.heappush(frontier, (this_child.path_cost, this_child))\n",
    "                frontier_states[this_child.state] = this_child.path_cost\n",
    "            elif (this_child.state in frontier_states.keys()):\n",
    "                if frontier_states[this_child.state] > this_child.path_cost:\n",
    "                    frontier_states[this_child.state] = this_child.path_cost\n",
    "                    heapq.heappush(frontier, (this_child.path_cost, this_child))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def solution(node):\n",
    "    if node == 'FAILURE':\n",
    "        print node\n",
    "    else:\n",
    "        path = []\n",
    "        this_node = node\n",
    "        while(this_node is not None):\n",
    "            path.append(this_node.state)\n",
    "            this_node = this_node.parent\n",
    "        path.reverse()\n",
    "        print path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def recursive_dls(this_node, problem, limit):\n",
    "    if problem.goal_test(this_node.state):\n",
    "        return this_node\n",
    "    if limit == 0:\n",
    "        return 'CUTOFF'\n",
    "    cutoffp = False\n",
    "    for action in problem.available(this_node.state):\n",
    "        this_child = child_node(problem, this_node, action)\n",
    "        result = recursive_dls(this_child, problem, limit-1)\n",
    "        if result == 'CUTOFF':\n",
    "            cutoffp = True\n",
    "        elif result != 'FAILURE':\n",
    "            return result\n",
    "    if cutoffp:\n",
    "        return 'CUTOFF'\n",
    "    else:\n",
    "        return 'FAILURE'\n",
    "    \n",
    "def depth_limited_search(problem, limit, start_node):\n",
    "    return recursive_dls(start_node, problem, limit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def iterative_deepening_search(this_problem, start_node):\n",
    "    depth = 0\n",
    "    while(1):\n",
    "        result = depth_limited_search(this_problem, depth, start_node)\n",
    "        if result != 'CUTOFF':\n",
    "            return result\n",
    "        depth += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Peg Solitaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Define a state as a mapping from (row, column) coordinates to boolean indicating presence of peg\n",
    "#Define an action via the initial location and final locations of the moving peg\n",
    "\n",
    "#What must we check to ensure a proposed move is valid?\n",
    "# Start, end are on board\n",
    "# Start, end are one jump apart\n",
    "# Peg in start\n",
    "# No peg in end\n",
    "# Peg in between"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#What is required to define the problem?\n",
    "\n",
    "#A function that takes a state and returns available actions\n",
    "#A function that takes a state and action and returns the resulting state\n",
    "#A function that tests if the goal is reached"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Site():\n",
    "    def __init__(self, index):\n",
    "        self.index = index # Index of site\n",
    "        self.neighbors = [] # List of sites that are nearest neighbors\n",
    "        self.jumps = [] # List of potential jumps\n",
    "        self.occupied = False\n",
    "        \n",
    "    @property\n",
    "    def coords(self):\n",
    "        '''Coordinates of geometric representation of site. For square lattice this is just indices'''\n",
    "        return self.index\n",
    "    \n",
    "class TriSite(Site):\n",
    "    @property\n",
    "    def coords(self):\n",
    "        '''Coordinates of geometric representation of site. Triangular lattice.'''\n",
    "        xx, yy = self.index\n",
    "        x_pt = -0.5 * (yy - 1) + xx\n",
    "        return (x_pt, yy)\n",
    "    \n",
    "    def display(self):\n",
    "        xx, yy = self.coords\n",
    "        plt.plot(xx, yy, '*', color='yellow', markersize=10)\n",
    "    \n",
    "    def display_neighbors(self):\n",
    "        for site in self.neighbors:\n",
    "            if site is not None:\n",
    "                xx, yy = site.coords\n",
    "                plt.plot(xx, yy, 'o', color='green', markersize=10)\n",
    "                \n",
    "    def display_jumps(self):\n",
    "        for jump in self.jumps:\n",
    "            xx, yy = jump.end.coords\n",
    "            plt.plot(xx, yy, 'o', color='blue', markersize=10)  \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Jump():\n",
    "    def __init__(self, start, mid, end):\n",
    "        self.start = start\n",
    "        self.mid = mid\n",
    "        self.end = end\n",
    "        \n",
    "    def describe(self):\n",
    "        print 'Move peg in %s over %s into %s'%(self.start.index, self.mid.index, self.end.index)\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "   \n",
    "class Board(object):\n",
    "    def __init__(self):\n",
    "        self.sites = [] # List of sites on the board\n",
    "        self.indices = [] # List of valid indices\n",
    "        self.index_map = {} # Mapping from indices to sites\n",
    "        \n",
    "    def display(self):\n",
    "        exes = []\n",
    "        wyes = []\n",
    "        for site in self.sites:\n",
    "            xx, yy = site.coords\n",
    "            exes.append(xx)\n",
    "            wyes.append(yy)\n",
    "            if site.occupied:\n",
    "                color = 'red'\n",
    "            else:\n",
    "                color = 'black'\n",
    "            plt.plot(xx, yy, 'o', color=color, markersize=10)\n",
    "        plt.xlim(0, max(exes)+1)\n",
    "        plt.ylim(0, max(wyes)+1)\n",
    "        \n",
    "    def set_state(self, state):\n",
    "        for entry in state:\n",
    "            index, occupation = entry\n",
    "            assert index in self.indices\n",
    "            self.index_map[index].occupied = occupation\n",
    "            \n",
    "    @property\n",
    "    def state(self):\n",
    "        state = []\n",
    "        for site in self.sites:\n",
    "            site_state = (site.index, site.occupied)\n",
    "            state.append(site_state)\n",
    "        return tuple(state)\n",
    "            \n",
    "    @property\n",
    "    def allowed_moves(self):\n",
    "        moves = []\n",
    "        start_sites = filter(lambda x: x.occupied, self.sites)\n",
    "        for site in start_sites:\n",
    "            allowed_jumps = filter(lambda x: x.mid.occupied and not x.end.occupied, site.jumps)\n",
    "            moves.extend(allowed_jumps)\n",
    "        return moves\n",
    "    \n",
    "    def list_moves(self):\n",
    "        for move in self.allowed_moves:\n",
    "            move.describe()\n",
    "    \n",
    "    def apply_move(self, jump):\n",
    "        assert jump.start in self.sites\n",
    "        assert jump.mid in self.sites\n",
    "        assert jump.end in self.sites\n",
    "        assert jump in jump.start.jumps\n",
    "        assert jump.start.occupied\n",
    "        assert not jump.end.occupied\n",
    "        assert jump.mid.occupied\n",
    "        \n",
    "        jump.start.occupied = False\n",
    "        jump.mid.occupied = False\n",
    "        jump.end.occupied = True\n",
    "    \n",
    "    @property\n",
    "    def score(self):\n",
    "        return len(filter(lambda x: x.occupied, self.sites))\n",
    "    \n",
    "class TriBoard(Board):\n",
    "    '''Board with Triangular Lattice'''\n",
    "    def __init__(self, nrows):\n",
    "        super(TriBoard, self).__init__()\n",
    "        for ii in range(1, nrows+1):\n",
    "            for jj in range(1, ii+1):\n",
    "                this_site = TriSite((ii, jj))\n",
    "                self.sites.append(this_site)\n",
    "                self.indices.append((ii, jj))\n",
    "                self.index_map.update({(ii,jj):this_site})\n",
    "\n",
    "        for site in self.sites:\n",
    "            ii, jj = site.index\n",
    "            neighbor_indices = [(ii-1, jj), (ii, jj+1), (ii+1, jj+1), (ii+1, jj), (ii, jj-1), (ii-1, jj-1)]\n",
    "            for index in neighbor_indices:\n",
    "                if index in self.indices:\n",
    "                    this_neighbor = self.index_map[index]\n",
    "                    site.neighbors.append(this_neighbor)\n",
    "                else:\n",
    "                    site.neighbors.append(None)\n",
    "\n",
    "        for site in self.sites:\n",
    "            for ii in range(len(site.neighbors)):\n",
    "                neighbor_ii = site.neighbors[ii]\n",
    "                if neighbor_ii is not None:\n",
    "                    nn_neighbor_ii = neighbor_ii.neighbors[ii]\n",
    "                    if nn_neighbor_ii is not None:\n",
    "                        this_jump = Jump(site, neighbor_ii, nn_neighbor_ii)\n",
    "                        site.jumps.append(this_jump)\n",
    "                        \n",
    "        for site in self.sites:\n",
    "            if site.index != (3,1):\n",
    "                site.occupied = True\n",
    "                \n",
    "    def repopulate(self):\n",
    "        for site in self.sites:\n",
    "            if site.index != (3,1):\n",
    "                site.occupied = True\n",
    "            else:\n",
    "                site.occupied = False\n",
    "        \n",
    "        \n",
    "## Build a triangular board\n",
    "this_board = TriBoard(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEMpJREFUeJzt3W+IZXd9x/H3/pNktjERdwzGuCQYI0WpfRA2MUPMFZKM\nVkJoYCFPbDYoCC0IvYhFS5vJA7FSKhWUFjKmKXnQDpEk1Sc6lzg3m2TNzooUDRhjMplsqCKupAbm\nptyxmT44Z7qzszP3nJl77jnf39z3Cw57Zu/Zcz7cnfnsOb9zz/5AkiRJkiRJkiRJkiRJkiTt0n7g\nIeAZ4CTwgWbjSJLWfRyYy9dvA77dYBZJGiv7C15/E7gc2Jf/2h95IklSKQeBLvBz4BzwkUbTSJL+\n35eAL+frVwMvAm9rLo4kjY+DBa8fBt7I118HDgEHNm3zEvC+inNJ0l73MnDdMDu4AngceBp4Drhn\ni23WhjlAjWaaDlDSTNMBSpppOkBJM00HKGGm6QAlzTQdoKSZpgOUVNidRWfQ/w38aTVZJEk7UfQp\nDklSQ8apoLtNByip23SAkrpNByip23SAErpNByip23SAkrpNB4gklTFoSYqksDvH6QxakpJiQUtS\nUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0\nJAVlQUtSUBa0JAVVNGkswL3AiXz9UuDDwJXAGyPKJA1rYhJuuRaOH4Gj5+DsK/Dob7LZ6XtNh5NG\n5RvAZzb9nlNeKYwpmGvDUgf6K7C2BmsrsNaBfhuWpmCu6YxSrtLuvAFYGPVBpCFMtGFpLS/mrZa/\nhFeAiaaDSlTcnY8Bt476INJuTcJ0B/qDCnoe+pMw3XRWiQq78wrg+VEfRBrGMZhdGVDO68Mdx2C2\n6awSJbqzzE1CgI8CTw54fWbDejdfpFodgaNFYxcT+XZ15JE2aeVL5T4PfG6b1zyDVgieQSsxtXSn\nBa0QHINWYixojRU/xaGUFHanTxJqL+mdhjNtWO7A6voTKT2gA6ttWF6ERXxYRYnYV8E+1iraj1QV\nnyRUCmrpToc4JGnnHOKQpFRZ0JIUlAUtSUFZ0JIUlAUtSUFZ0JIUlAUtSUFZ0JIUlAUtSUFZ0JIU\nlAUtSUFZ0JIUlAUtSUFZ0JIUlAUtSUGVndVbGpVU/nP9VHJqzHwROAWcAe7d4nX/w37tyhTMtWGp\nA/2VDbNud6DfhqUpmGs6I6STU8kZujtbwHfy9cPAA6M4iMZSKhO8ppJT6Rl6RpU7gJ8CTwDf5XxZ\nS0OZhFs+AVcP2uYT8J5JuKWuTFtJJafG04PA98jGqq8HXthiG8+gtWPHYHZlwFnp+jDCMZg1p/ao\nwu4sukl4DvgZ8HvgReB/gCP57280s2G9my/Sto7A0aIxgYl8uzrybCeVnEpCK18q80lgPl+/CvgF\nF08T7hm0diyVM9NUcipJlXTnV4FF4EfA7aM6iMbLJEx3oD+o+OahPwnT5tQeVUt3WtDajVQ+HZFK\nTqVn6E9xSKPSOw1n2rDcgdX1Jz16QAdW27C8mF25Nf0QSCo5tQdtHk/ejbWK9qPxlMoTeqnkVDpq\n6U6HOCRp5xzikKRUWdCSFJQFLUlBWdCSFJQFLUlBWdCSFJQFLUlBWdCSFJQFLUlBWdCSFJQFLUlB\nWdCSFJQFLUlBWdCSFJQFLUlBWdCSFNTBpgMoKanMKpJCzhQyKgE/Bhby5VtbvO6MKmNgCubasNSB\n/ko+WeoKrHWg34alKZhrOiOkkTOFjKrF0N15CVlBj/QgCi+Vma1TyJlCRtVj6O68EXgB+D7wZP51\n5QdRbJMw3YH+oFKZh/4kTJsz/YyqzdDd+SHg0/n6+4GXuPjGogW9xx2D2ZUBhbJ+iX4MZs2ZfkbV\nprA7i24SvkhWygC/AH4LvBv4r03bzWxY7+aL9ogjcLToensi366OPNtJIWcKGTUyrXwpraig7wP+\nCPgL4Crg7cCvtthuZicHVVrOwdkegwdFe/l2NUXaUgo5U8iokely4cnr/cPu8CDwCHAyX27aYhuH\nOPa4VMZNU8iZQkbVppbutKD3vlQ+eZBCzhQyqh6F3emThCqjdxrOtGG5A6vrT1H0gA6stmF5ERZp\n/gGLFHKmkFFB7KtgH2sV7UfxpfL0Wwo5U8io0aqlOx3ikKSdc4hDklJlQUtSUBa0JAVlQUtSUBa0\nJAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUEWzeitd\nqczYYc7qpJBRI/Au4DXg+i1ec0aVYKZgrg1LHeiv5BORrsBaB/ptWJqCuaYzgjnHLaMuUkl3HgIe\nB17Agk5BKrNGm3O8MupilXTnPwJ3AAtY0OFNwnQH+oN+WOehPwnT5twbOVPIqC0NPSfhCeA3wHz+\ntbN3B3ctHL85u+rZ1hQcuhaO15VpK+asTgoZtTtFNwnvI2v524A/Bv4VuAv49abtZjasd/NFDTgC\nR4uuYyfy7erIsx1zVieFjAKglS+lFRX0rRvWF4DPcnE5w4UFrQadg7M9Bg829vLtaoq0JXNWJ4WM\nAi4+eb2/6A/4Oeg95hV49BSsDtrmWVh9BR6tK9NWzFmdFDKqOd4kjCWVO/rmHK+MutjQNwmVnt5p\nONOG5Q6srj+d0AM6sNqG5UVYpPkHF8w5Xhm1C1V8KmOtov2oWqk8VWbO6qSQUefV0p0OcUjSzjnE\nIUmpsqAlKSgLWpKCsqAlKSgLWpKCsqAlKSgLWpKCsqAlKSgLWpKCsqAlKSgLWpKCsqAlKSgLWpKC\nsqAlKSgLWpKCsqAlKaiiWb1Vj1RmwjBndVLICOnkHFsHgIeAZ8j+Uj646XVnVBnCFMy1YakD/ZV8\ngs8VWOtAvw1LUzDXdEYw57hlhHRyJqyS7rwLmM3XbwWeGMVBxlQqszGbc7wyppQzZZV154H813uB\nfxnVQcbNJEx3oD/oh2Ae+pMwbc69kTOFjCnlTFyl3fkw8Dvg9lEeZJwcg9mVAT8A65eUx85fwZgz\n8ZwpZEwpZ+IKu3MnNwlPAH8FnAb+EHhzw2szG9a7+aICR+Bo0fXhRL5dHXm2Y87qpJAR0smZmFa+\nlFamoD8FXA18hayU38qXjWZ2clBlzsHZHoMH8Xr5djVF2pI5q5NCRkgnZ2K6XHjyen8VO72U7G7t\nU8Ap4M5NrzvEsUupjPOZc7wyppQzcbV0pwW9e6ncKTfneGVMKWfKCrvTJwmb1TsNZ9qw3IHV9U/9\n94AOrLZheREWaf6BAHOOV0ZIJ+eetq+CfaxVtJ9xlsrTWuasTgoZIZ2cKaqlOx3ikKSdc4hDklJl\nQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtSUBa0JAVlQUtS\nUBa0JAVlQUtSUGVm9daFUplhwpzVSiFnChkhnZzhHQIeAU4Cp7l4Rm8YoxlVpmCuDUsd6K/kE2eu\nwFoH+m1YmspmP2+cOauVQs4UMkI6OWsydHeeAL6Wr78DeHUUB0lEKrMcm3P8cqaQMaWcdRm6Ow8D\nf5CvvxN4eRQHScEkTHegP+ibax76kzBtTnOaMd2cNaqsOy8DfgDcM8qDRHYMZlcGfGOtX6odg1lz\nmtOM6easUWF3lrlJ+F7gMeCbwL9vs83MhvVuvuwpR+Bo0XXXRL5dHXm2Y85qpZAzhYyQTs4RauVL\naUUFfSUwD/w5sDBgu5mdHDRF5+Bsj8GDY718u5oibcmc1UohZwoZIZ2cI9TlwpPX+4fd4deBX5KV\n8/pyyaZtxmKII5XxM3OOX84UMqaUs0a1dOdYFDTp3IE25/jlTCFjSjnrUtidByo4yAzwQAX7iW51\nP9z8PBzeD4ffDQcOkV2SdWH1m/DaIiy+Bv9mTnOaMemcdZmhoDv3VXCQtYr2k4pUnoIyZ7VSyJlC\nRkgn56jV0p3jMsQhSVUq7E7/syRJCsqClqSgLGhJCsqClqSgLGhJCsqClqSgLGhJCsqClqSgLGhJ\nCsqClqSgLGhJCsqClqSgLGhJCsqClqSgLGhJCsqClqSgimb13uxG4O+Aj40gyyikMnNDMjmBW4Dj\nwFGy2ZcfJWDOBN7PFDKCOZPxBeAnwKlNvx9yRpUpmGvDUgf6K/mElCuw1oF+G5amYK7pjJBOTrIc\nS0Cf7O98fennvx8iZwrvZwoZwZw1qLQ77wauA344yoNUJJXZg5PJSVbCawOWEDkTeD9TyGjOelTe\nndeQQEFPwnQH+oP+0uahPwnT5ixlmovPnDcvfXw/90RGc9ZmPOckvBaO3wyHBm0zBYeuzcZSG5NK\nTrLjD8yZv+77WSCFjGDOKHZ6k3A7MxvWu/nSmCNwtOh6ZiLfro4820klJ+WP7/tZIIWMYM4RaeVL\nabsp6K1Oy2d2sZ+ROQdnewwedOrl29UUaUup5KT88X0/C6SQEcw5Il0uPHm9v46DOga9x3PiGPRY\nZTRnbWrpznAFTTp3dpPJiZ/iGKeM5qzHeN4kBHqn4Uwbljuwuv4p9R7QgdU2LC/CIs1/gD2ZnMAZ\nYBlY3fTaav77IXIm8H6mkBHMGcK+CvaxVtF+RiGVp4uSyYlPElYlhYxgzlGqpTsjDnFIUnRjO8Qh\nScmzoCUpKAtakoKyoCUpKAtakoKyoCUpKAtakoKyoCUpKAtakoKyoCUpKAtakoKyoCUpKAtakoKy\noCUpKAtakoKyoCUpqDIFvR/4Z+AUsAC8b6SJJEml3Q08lK/fCDyx6fVUZlRpNR2gpFbTAUpqNR2g\npFbTAUpoNR2gpFbTAUpqNR2gpEpmVJkCvpevnwZuGCZRg1pNByip1XSAklpNByip1XSAElpNByip\n1XSAklpNB6hKmYJ+O/DGhq//t+SfkyQNoUzRvgFctunPvDWaOJKkdWWm/L4buBO4D7gJ+Bvgkxte\nfwlvHErSTr0MXDfsTvYB/wQ8my/XD7tDSZIkSZKkOFJ7gOVGspxRHQIeAU6SfZzxzmbjbOkA2Wfi\nnwGeBj7YbJxC7wJeI/aw3I/Jvi8XgG81nGWQL5L9rJ8B7m04y3bu5fx7+RzwJtmn0KLZz/mfo5PA\nB0ZxkKIHWCL5AvATsm+wqE4AX8vX3wG82lyUbd0FzObrtxL77/wQ8DjwAnEL+hKygo6uBXwnXz8M\nPNBclNK+AXym6RDb+Dgwl6/fBnx7uw2H+TxzSg+wvET2D0qZT6005VHgb/P1/cDvG8yynf8APpuv\nXwO83lyUQn9PdnP7V00HGeDDwATwfeBJshOdiO4Afkr2D/J3OV/WUd1AdnU3W7RhQ94ELifro8uB\n/igO8iDZvwTrXiX2AyzXAD9sOkQJlwE/AO5pOsgADwO/A25vOMd2TgB/na8vMKJLyAp8CPh0vv5+\nshOJiD9DD5KdjB0kuxp5odk4hR4ju8KL6iDQBX4OnAM+MoqD/ANwfMPXr43iIBW6hvgF/V6yMb4T\nDeco40pgGbi04RxbeYrsB2CB7Cz/ObK80byNbJhj3WngPQ1lGeQrQHvD1/8JHGkoS5ErgOebDlHg\nS8CX8/WrgRfJvhcuMsy/1s8Cf5Kv30Q2xqvduxKYJxsvf7jZKNv6FNnNIsgu094i5lOlt5KNm36M\nrEz+DPh1k4G2cR/ZiQ7AVWQ3tCIOyTzD+avlq8jGoX/bXJyBPko2XBTZYc7/9xmvk90vOVD1QVJ7\ngOUaYt8k/DrwS87fhV7gwrOrCC4lu7nxFNl7GfGTJpstEPd78yDnP7lzkuxEJ6qvAovAj4g7tAXw\neeBzTYcocAXZDeynya7uIg9nSpIkSZIkSZIkSZIkSZIkSZIkaS/4P6WoN5fBoslQAAAAAElFTkSu\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c8c1250>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "this_board.display()\n",
    "#print this_board.sites[NN].index\n",
    "#this_board.sites[NN].display()\n",
    "#this_board.sites[NN].display_neighbors()\n",
    "#this_board.sites[NN].display_jumps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move peg in (1, 1) over (2, 1) into (3, 1)\n",
      "Move peg in (3, 3) over (3, 2) into (3, 1)\n",
      "Move peg in (5, 1) over (4, 1) into (3, 1)\n",
      "Move peg in (5, 3) over (4, 2) into (3, 1)\n"
     ]
    }
   ],
   "source": [
    "this_board.list_moves()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(((1, 1), True), ((2, 1), True), ((2, 2), True), ((3, 1), False), ((3, 2), True), ((3, 3), True), ((4, 1), True), ((4, 2), True), ((4, 3), True), ((4, 4), True), ((5, 1), True), ((5, 2), True), ((5, 3), True), ((5, 4), True), ((5, 5), True), ((6, 1), True), ((6, 2), True), ((6, 3), True), ((6, 4), True), ((6, 5), True), ((6, 6), True), ((7, 1), True), ((7, 2), True), ((7, 3), True), ((7, 4), True), ((7, 5), True), ((7, 6), True), ((7, 7), True))\n"
     ]
    }
   ],
   "source": [
    "print this_board.state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUZQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c870050>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "first_move = this_board.allowed_moves[0]\n",
    "this_board.apply_move(first_move)\n",
    "this_board.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move peg in (3, 3) over (2, 2) into (1, 1)\n",
      "Move peg in (4, 1) over (3, 1) into (2, 1)\n",
      "Move peg in (4, 3) over (3, 2) into (2, 1)\n"
     ]
    }
   ],
   "source": [
    "this_board.list_moves()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([   9.,   22.,   92.,  144.,    0.,  102.,   24.,    2.,    3.,    2.]),\n",
       " array([ 1. ,  1.8,  2.6,  3.4,  4.2,  5. ,  5.8,  6.6,  7.4,  8.2,  9. ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD/CAYAAADsfV27AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c3644d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Get some idea of the performance of a random solver\n",
    "\n",
    "numruns = 400\n",
    "final_scores = []\n",
    "\n",
    "for ii in range(numruns):\n",
    "    this_board = TriBoard(6)\n",
    "    while len(this_board.allowed_moves) > 0:\n",
    "        this_move = np.random.choice(this_board.allowed_moves)\n",
    "        #this_move.describe()\n",
    "        this_board.apply_move(this_move)\n",
    "        #this_board.display()\n",
    "    final_scores.append(this_board.score)\n",
    "plt.hist(final_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "\n",
      "success rate:\n",
      "0.0225\n"
     ]
    }
   ],
   "source": [
    "print np.min(final_scores)\n",
    "print \"\\nsuccess rate:\"\n",
    "print float(len(filter(lambda x: x == 1, final_scores))) / numruns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Question I don't know how to answer: What is the distribution of final scores when moves are at random?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#Set up Peg Solitaire for graph search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class PegSolitaire(Problem):\n",
    "    def __init__(self, board):\n",
    "        self.board = board\n",
    "    \n",
    "    def result(self, state, action):\n",
    "        self.board.set_state(state)\n",
    "        assert action in self.board.allowed_moves\n",
    "        self.board.apply_move(action)\n",
    "        return self.board.state\n",
    "        \n",
    "        \n",
    "    def cost(self, action):\n",
    "        return 1\n",
    "        \n",
    "    def available(self, state):\n",
    "        self.board.set_state(state)\n",
    "        return self.board.allowed_moves\n",
    "    \n",
    "    def goal_test(self, state):\n",
    "        score = len(filter(lambda x: x, [ss[1] for ss in state]))\n",
    "        return score == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "this_board = TriBoard(5)\n",
    "this_start_state = this_board.state\n",
    "this_start_node = Node(this_start_state, None, None, 0)\n",
    "this_solitaire = PegSolitaire(this_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(((1, 1), True), ((2, 1), True), ((2, 2), True), ((3, 1), False), ((3, 2), True), ((3, 3), True), ((4, 1), True), ((4, 2), True), ((4, 3), True), ((4, 4), True), ((5, 1), True), ((5, 2), True), ((5, 3), True), ((5, 4), True), ((5, 5), True))\n",
      "(((1, 1), True), ((2, 1), True), ((2, 2), True), ((3, 1), False), ((3, 2), True), ((3, 3), True), ((4, 1), True), ((4, 2), True), ((4, 3), True), ((4, 4), True), ((5, 1), True), ((5, 2), True), ((5, 3), True), ((5, 4), True), ((5, 5), True))\n",
      "(((1, 1), True), ((2, 1), True), ((2, 2), True), ((3, 1), False), ((3, 2), True), ((3, 3), True), ((4, 1), True), ((4, 2), True), ((4, 3), True), ((4, 4), True), ((5, 1), True), ((5, 2), True), ((5, 3), True), ((5, 4), True), ((5, 5), True))\n"
     ]
    }
   ],
   "source": [
    "print this_board.state\n",
    "print this_start_state\n",
    "print this_start_node.state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def solution_ps(node):\n",
    "    if node == 'FAILURE':\n",
    "        print node\n",
    "    else:\n",
    "        path = []\n",
    "        this_node = node\n",
    "        while(this_node is not None):\n",
    "            path.append(this_node.action)\n",
    "            this_node = this_node.parent\n",
    "        path.reverse()\n",
    "        return path[1:]\n",
    "    \n",
    "def describe_solution(node):\n",
    "    path = solution_ps(node)\n",
    "    for jump in path:\n",
    "        jump.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "peg_solution = breadth_first_search(this_solitaire, this_start_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<__main__.Jump instance at 0x7f648c55a2d8>, <__main__.Jump instance at 0x7f648c4a80e0>, <__main__.Jump instance at 0x7f648c55a878>, <__main__.Jump instance at 0x7f648c4a87e8>, <__main__.Jump instance at 0x7f648c55a758>, <__main__.Jump instance at 0x7f648c4a8f38>, <__main__.Jump instance at 0x7f648c4a8320>, <__main__.Jump instance at 0x7f648c4a8e18>, <__main__.Jump instance at 0x7f648c4a8098>, <__main__.Jump instance at 0x7f648c4a8d40>, <__main__.Jump instance at 0x7f648c55ac68>, <__main__.Jump instance at 0x7f648c55ad40>, <__main__.Jump instance at 0x7f648c4a86c8>]\n"
     ]
    }
   ],
   "source": [
    "print solution_ps(peg_solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move peg in (1, 1) over (2, 1) into (3, 1)\n",
      "Move peg in (3, 3) over (2, 2) into (1, 1)\n",
      "Move peg in (3, 1) over (3, 2) into (3, 3)\n",
      "Move peg in (4, 4) over (3, 3) into (2, 2)\n",
      "Move peg in (1, 1) over (2, 2) into (3, 3)\n",
      "Move peg in (5, 3) over (4, 2) into (3, 1)\n",
      "Move peg in (4, 1) over (3, 1) into (2, 1)\n",
      "Move peg in (5, 5) over (5, 4) into (5, 3)\n",
      "Move peg in (5, 2) over (5, 3) into (5, 4)\n",
      "Move peg in (5, 4) over (4, 3) into (3, 2)\n",
      "Move peg in (3, 3) over (3, 2) into (3, 1)\n",
      "Move peg in (2, 1) over (3, 1) into (4, 1)\n",
      "Move peg in (5, 1) over (4, 1) into (3, 1)\n"
     ]
    }
   ],
   "source": [
    "describe_solution(peg_solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSZIkSZIkSZIkSZIkSZIkSZIkRfP/UtsbL7vFPF0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c79f910>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkiRJkiRJkiRJkiRF838kOdbzqaXWWQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648bb83b10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSZIkSZIkSZIkSZIkSZIkSZKkaP4P0rGTAOK/F7kAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c0b9d10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSZIkSZIkKZr/B057YOgaxOf4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c2f69d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSZIkSZIkRfN/jkIozC/pv9sAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648beb9490>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEmSJEmSJEmSJEmSJEmSJElSNP8HF73ZjU8dCwAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c6b7550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c325190>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648bd89090>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n839zpfcilJyyMAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648bbfc150>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nDjIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648c0b2e50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAADVBJREFUeJzt3F+IHeUZx/Hv6m6raxWkUSHRJdY/pShtLwqxhuARqmmR\nIAQWeiNGvBDai9JAFZHW7ZUVqeCFWDBVizddAtW2lGrEZjUam0Sk6IWhjZu6EqVoEaVuy4n19GJm\nm93NZs/ZnJnzPvOe7wdenD3nzczzZGd/zr5zJiBJkiRJkiRJkiRJkiRJkvpwN7AfOATcmrgWSRoa\nZ3R5vwV8E7i23P5SzfVIkkqjXd6/EXgDeBo4D/hR7RVJknryKPAMRZBfCRxOW44kDY9uV9AfAG8C\nnwJ/Bf4DrCtflyTVqFtAvwT8AHgQWA+cA/xz2ZwjwGXVlyZJWXsLuLzfndwPHAReBW5Y4f1OvwcI\nbip1ATWbSl1AzaZSF1CjqdQF1GwqdQE165qd3a6gAe6qoBBJ0hp1+5idJCkRA7q7mdQF1GwmdQE1\nm0ldQI1mUhdQs5nUBeQg9zVoSapD1+z0ClqSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKg\nJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSko\nA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSmo0R7mvAZ8VG7PArfXV45UiXFgCzAJTABzwG5gHzCf\nsC6pUmdRBPRqOoMoROrRNMWFRJvi3FwY7fL16XSlSUv0nZ2bgMPAs8Dz5deVH0SqyDhFCHdWGUfL\neVJqfWfn1ZxY0rgCOMLJ69YGtKLYyslXzstHu5wnpdZ3dn6OYpljwQFgQ9UHkSqyi9XDeWHsSlWg\ntEjX7Ox2k/A24KvA94H1wHnAeyvMm1q0PVMOadAmKp4nValVjsqMAk8CL5bjmhXmeAWtKLyCVpMM\nJDsNaEXhGrSaxIDWUPFTHGqSvtegpSaZBw4BIxQ3s8cWvXccOAYcxIdV1BAjFeyjU9F+pKr4JKGa\nYCDZ6RKHJK1d1+z0H0uSpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkK\nyoCWpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkKyoCWpKAMaEkKyoCW\npKAMaEkKyoCWpKBGUxegoTAObAEmgQlgDtgN7APmE9ZVhZx7U0NcCLwDXLnCe50B16JmmQZmgTbF\nubIw2uXr0+lK61vOval+lWTnGPAUcBgDWmszThFUnVXG0XJe0+Tcmwaja3b2sgb9APAI8F7f5WjY\nbAEu7jJnQzmvaXLuTUF0C+gdwPvAnvLrkVqrUW4mKX4DW81YOa9pcu5NQXS7SXgbxWX4t4CvA78C\nbgb+sWze1KLtmXJIExXPiyTn3lSPVjlqsRfXoLU2u1h9jXZh7EpVYB9y7k2DUckatHS6dgPHu8w5\nXs5rmpx7U0a8gtap5PxJh5x702B0zU4fVFGd5oFDFDeXN7D0ptpx4BhwkGY+0JFzbwqiik9ldCra\nj/KV89N2Ofemeg0kO13ikKS18yahJDWVAS1JQRnQkhSUAS1JQRnQkhSUAS1JQRnQkhSUAS1JQRnQ\nkhSUAS1JQRnQkhSUAS1JQRnQkhSUAS1JQRnQkhSUAS1JQRnQkhSUAS1JQRnQkhSUAS1JQRnQkhSU\nAS1JQRnQkhSUAS1JQRnQkhTUaOoClMQ4sAWYBCaAOWA3sA+YT1hXVXLuL+fedBrOBB4DXqI4Ca5a\n9n5n4BWpH9PALNCm+N4tjHb5+nS60iqRc3859zaMKsnOm4Fd5fZ1wNN1HEQDMU7xg9xZZRwt5zVR\nzv3l3Nuwqiw7zyz/eyvweF0HUe22cvLV1/LRLuc1Uc795dzbsKo0O58APgJuqPMgqtUuVv8BXxi7\nTrWD4HLuL+fehlXX7FzLTcIdwF3AAeArwL8XvTe1aHumHIpnouJ50eTcX869DYtWOXrWS0DfAlwM\n3EcRyp+VY7GptRxUycxVPC+anPvLubdhMcPSi9d7q9jp2RR3h18A9gPblr3vEkdz5L6OmXN/Ofc2\nrAaSnQZ0c+T+SYCc+8u5t2FV6Rq0mm8eOASMABuAsUXvHQeOAQdp7gMPOfeXc286hZEK9tGpaD8a\nnNyfRsu5v5x7GzYDyU6XOCRp7bpmp/9YkiQFZUBLUlAGtCQFZUBLUlAGtCQFZUBLUlAGtCQFZUBL\nUlAGtCQFZUBLUlAGtCQFZUBLUlAGtCQFZUBLUlAGtCQFZUBLUlAGtCQFZUBLUlAGtCQFZUBLUlAG\ntCQFZUBLUlAGtCQFZUBLUlAGtCQFNZq6AAEwDmwBJoEJYA7YDewD5hPWVZWc+8u5N8i/v0YbA54E\nXgQOANtWmNMZaEX5mQZmgTbF3+XCaJevT6crrRI595dzb5B/f6n1nZ07gAfL7fOBt+s4yBAbpzjR\nO6uMo+W8Jsq5v5x7g/z7i6Dv7DwH+EK5/UXgrToOMsS2cvLVyfLRLuc1Uc795dwb5N9fBF2zs9tN\nwk+AfwHnUqw73VNBUTphkmIZaTVj5bwmyrm/nHuD/PtrhF5uEl4C/AZ4GPj1KeZMLdqeKYe6m6h4\nXjQ595dzb5B/fym0ytGzbgF9EbAH+B6wd5V5U2s5qP5vruJ50eTcX869Qf79pTDD0ovXe/vd4UPA\nuxThvDDOWjbHNejTl/s6X8795dwb5N9fBAPJTgP69OV+pzzn/nLuDfLvL4Ku2emDKmnNA4eAEWAD\nS2/KHAeOAQdp7gMBOfeXc2+Qf3+NMFLBPjoV7WeY5f60Vs795dwb5N9fSgPJTpc4JGnt+v4ctCQp\nEQNakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANa\nkoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIyoCUpKANakoIa\nXeP8TcDPgOtrqCWScWALMAlMAHPAbmAfMJ+wrqqMXwBbLoXJdTDxAcwdhd3v218TeG5qRXcCrwP7\nl73eSVBLnaaBWaBN0dvCaJevT6crrX+bYXonzD4H7U+g04HOJ9B5Dto7YXaz/UXmuZmXSrNzO3A5\n8EqdB0lsnOJE76wyjpbzmmh8J8x2ypN/pfFD+4vKc7PZ/a2k8uzcSN4BvZWTr06Wj3Y5r3EugK3P\nQXu1H4I90L7A/iLy3Gzu9+5UumanNwmXmgTGuswZK+c1zqUweW2X/jbD2KX2F5HnZnO/d6dtrTcJ\nT2Vq0fZMOZpoouJ5oayDiW6/H46X8wZRT9Uy789zk8Z+7xa0ytGz0wnolS7Lp05jPxHNVTwvlA9g\nbp7VF/Hmy3kDKqlSmffnuUljv3cLZlh68XrvIA7qGnRD5L7Ol3l/npvN/d6dykCyM6eA9k65/UXl\nudns/lbSNTurWoPOxTxwCBgBNrD0psVx4BhwkOZ+YH7+ABzaCSPfgQ2bYWycopmX4fgf4dhB+4vK\nc7PZ/Z2WkQr20aloP5H4tFaz5dyf52Y+BpKdOS1xSNKg+DloSWoqA1qSgjKgJSkoA1qSgjKgJSko\nA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qS\ngjKgJSkoA1qSgjKgJSkoA1qSgjKgJSkoA1qSgjKgJSmoXgL6DOAXwH5gL3BZrRVJknq2HXis3N4E\nPL3s/c5gyxm4VuoCatZKXUDNWqkLqFErdQE1a6UuoGZds7OXK+jNwDPl9gHgG/1U1ECt1AXUrJW6\ngJq1UhdQo1bqAmrWSl1Aar0E9HnAx4u+/m+Pf06S1IdegvZj4Nxlf+azesqRJC0Y6WHOdmAbcBtw\nDfBj4KZF7x/BG4eStFZvAZf3u5MR4BHg5XJc2e8OJUmSJEmS4hiWB1g2UfSXkzHgSeBFio9Obktb\nTuXOpPjs/kvAPuCqtOXU5kLgHfJcdnyN4uduL/DLxLXU4W6K7DwE3FrHAbo9wJKDO4HXKf4ic7ID\neLDcPh94O10ptbgZ2FVuX0ee5+YY8BRwmPwC+iyKgM5VC/hduX0O8NNTTezn88zD8ADLEYr/EfXy\naZcm2Q38pNw+A/g0YS11+C1wR7m9EfgwXSm1eYDi5v17qQupwdeAceBZ4HmKC8Cc3Ai8QXHh8HtO\nhHWlHgW+vejrt8nzAZaNwCupi6jJucCfgO+mLqQmTwAfATckrqNqO4B7yu29wJfTlVKLq4Hby+0r\nKC6UcsqWRykubkcpfvs5XMdBfg5MLvr6nToOEsBG8gzoSyjWv3YkrqNuFwF/B85OXEeVXgBmKML5\nQ+DPFH3m4nMUyxwLDgAbEtVSh/uAnYu+/guwruqDbAceL7evAf5Q9QGC2Eh+AX0R8CZwfepCanIL\nxU0YKP6pglng8+nKqdVe8luDvgN4uNxeT3Gu5nQFfROwp9xeD/yNGpZRh+UBlo3kd5PwIeBdTtwl\n38vSK5amOxuYprjS3E9+n1JZLMeAHuXEp4xepLgAzM39wEHgVfJbgpMkSZIkSZIkSZIkSZIkSZIk\nSVI0/wPjEYDOZ3NIAwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648bc57e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648be9b8d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAD/CAYAAADc8UyaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f648bc85c10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "this_board.repopulate()\n",
    "for jump in solution_ps(peg_solution):\n",
    "    #jump.describe()\n",
    "    this_board.apply_move(jump)\n",
    "    plt.figure()\n",
    "    this_board.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}