LadouceurFinalProject.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving a Fun Puzzle using Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background and Motivation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puzzles and inquires in math can be just simply fun to solve, or unlock new ways to learn about how to approach problems and expand the knowledge of mathematics, which can be used to solve new problems in the future. This problem, which I have never known the answer to, is one I came up with a couple years ago. It is a fun problem to attempt to solve by hand and comparing personal bests with friends, but I wanted to know the best solution.\n",
    "   \n",
    "The problem or game, which is called stepping stones, goes as following: Start with an empty square grid that hypothetically goes on forever. The player starts by added 2 ones anywhere they want, although they have to be relatively close to each other, as you will see in a moment. Then from that point on the player adds numbers to the grid sequential starting with two, ie 2,3,4,5,6,7 etc. Each number can only be placed where the 8 surrounding numbers currently on the board sum to equal that number. So to add the first two, it has to touch both the original ones, either diagonally or adjacently. Try once before seeing the best answers and try to get as far as you can. Below is an example of a possible board, although not a great example.\n",
    "   \n",
    "After I solve this problem and see what the best solution is, I would then like to see what the best is start with 3 ones instead of 2. I imagine it would grow a lot the more ones you start with, but how this growth occurs is the question I would like to answer, but I would imagine it would be too computational hard to add too many ones, so this might not be the best way to answer that later question. \n"
   ]
  },
  {
   "attachments": {
    "Screen%20Shot%202019-12-01%20at%203.25.26%20PM.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screen%20Shot%202019-12-01%20at%203.25.26%20PM.png](attachment:Screen%20Shot%202019-12-01%20at%203.25.26%20PM.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methodology"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This problem will require a lot of recursion and the changing of some grid, which will be the board. I will go through every unique board, checking every one to find the best board. It seems natural to me to represent this board as a 2d numpy array, as left, right, up, and down are well defined and printing it out just naturally froms a grid of numbers. So I set up numpy, and matplotlib to display the complete boards, and anytree, to store all the values of possible grids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from IPython.display import display, clear_output\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import anytree\n",
    "from anytree import Node, RenderTree\n",
    "from anytree.exporter import DotExporter\n",
    "import time\n",
    "from IPython.display import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First I set up a way to initialize the board, an empty board with a single one in the center"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_board(size = 7):\n",
    "    board = np.zeros((size,size))\n",
    "    board[int(size/2),int(size/2)] = 1\n",
    "    return board"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then I make a function to set up the 'roots' of the tree, which are the last one placed. This is a simple function, but will be useful to change later if I want to add more one. There are only 5 places for the next one to be placed as their are symmetries that can be ignored, simplifying the calculation as a whole. Each node display name is in relation to the initial, how much lower and how much to the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_roots(start):\n",
    "    #Creates 5 nodes for the 5 unique starting positions of ones, with each being children of the start (0,0) node\n",
    "    #Each is named a unique number, but displayed as the position that it is placed at\n",
    "    roots = [Node('1',parent=start, display_name='(0,-1)'),Node('2',parent=start, display_name='(0,-2)'),Node('3',parent=start, display_name='(-1,-1)'),Node('4',parent=start, display_name='(-1,-2)'),Node('5',parent=start, display_name='(-2,-2)')]\n",
    "    newRoots = roots\n",
    "    return newRoots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then I need a function to add numbers in the future, by taking in where they are on the tree of nodes, and creating the board from there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Takes in spot, which is a string which looks like a tuple of ints\n",
    "def place_found(board, spot, lookingFor):\n",
    "    #Makes the spot into a tuple of strings\n",
    "    spot = tuple(spot[1:-1].split(','))\n",
    "    #Turns the string into an int, which the number changed into the actual spot of the board, from its relation to the center\n",
    "    i = int(spot[0])+int(len(board[0])/2)\n",
    "    j = int(spot[1])+int(len(board[0])/2)\n",
    "    newBoard = board\n",
    "    #Places the number at the spot\n",
    "    newBoard[i,j] = lookingFor\n",
    "    return newBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Takes the directory of whereOnTree and returns the exact node of the tree the machine are currently on.\n",
    "def current_spot(whereOnTree, roots):\n",
    "    #Starts at the root node\n",
    "    currentNode = roots[whereOnTree[0]]\n",
    "    #For each of the next spots of the directory move to that number node of the children\n",
    "    for i in whereOnTree[1:]:\n",
    "        currentNode = currentNode.children[i]\n",
    "    return currentNode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prevent issues, I create the board from scratch each time, which may be computational more difficult, but prevents errors, such as multiple numbers or numbers not being successfully erased later in the board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_board(roots, whereOnTree = [0], size = 7):\n",
    "    #Creates the new board from scratch\n",
    "    newBoard = make_board(size)\n",
    "    #places the second one\n",
    "    newBoard = place_found(newBoard, roots[whereOnTree[0]].display_name, 1)\n",
    "    #Places all of the following numbers, starting with 2\n",
    "    for i in range(1,len(whereOnTree)+1):\n",
    "        place = current_spot(whereOnTree[0:i], roots).display_name #Defines the spot of that number\n",
    "        newBoard = place_found(newBoard, place, i) #Places it\n",
    "    return newBoard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I define the variables I will be using through the process of creating all the boards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Unchanging Variables\n",
    "\n",
    "size = 7 #Start with a size 7 board\n",
    "start = Node('0', display_name='(0,0)') #Creates the root node of the tree, at the center\n",
    "roots = set_roots(start) #Sets the roots, the last '1' of each board\n",
    "\n",
    "#Changing Variables\n",
    "recordBoard = np.array([]) #To store the record boards\n",
    "record = 0 #To define the current highest number found\n",
    "\n",
    "nodeNum = 6 #To name each node individually, so they arent confused with each other later\n",
    "lookingFor = 2 #The current number that is being looked for on the board\n",
    "whereOnTree = [0] #The directory of where we are on the tree\n",
    "board = make_board(size) #Creates the board\n",
    "board = set_board([roots[0]], size=size) #Adds the second one to start\n",
    "\n",
    "#Statistic Variables\n",
    "leafs = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since many of the boards are symmetrical of each other, either rotated or flipped of another one, they are essentially the same board, so to prevent the computer from needing to compute all of these this finds and eliminates any symmetries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_symmetries(board, spots):\n",
    "    newSpots = [] #What the function will return\n",
    "    newSpots = spots #initially set it to the spots with duplicates\n",
    "    \n",
    "    #There cant be duplicates if only one exists\n",
    "    if len(spots) > 1:\n",
    "        \n",
    "        test = np.copy(board) #Creates a copy of the board to change\n",
    "\n",
    "        #Removes all the unnecessary ones on the outer parts of the board\n",
    "        moves = [0,0,0,0] #Records how many rows and column of ones were removed\n",
    "        #Removes top rows if only zeros\n",
    "        while all(test[0] == 0):\n",
    "            test = np.delete(test,0,0)\n",
    "            moves[0] += 1\n",
    "        #Removes bottom rows if only zeros\n",
    "        while all(test[-1] == 0):\n",
    "            test = np.delete(test,-1,0)\n",
    "            moves[1] += 1\n",
    "        #Removes left columns if only zeros\n",
    "        while all(test[:,0] == 0):\n",
    "            test = np.delete(test,0,1)\n",
    "            moves[2] += 1\n",
    "        #Removes right columns if only zeros\n",
    "        while all(test[:,-1] == 0):\n",
    "            test = np.delete(test,-1,1)\n",
    "            moves[3] += 1\n",
    "\n",
    "        #defines the center of the new board to be rotated and fliped over\n",
    "        dy = (len(board[0])-1+moves[0]-moves[1])/2\n",
    "        dx = (len(board[0])-1+moves[2]-moves[3])/2\n",
    "\n",
    "        #All eight possible symmetries of the board\n",
    "        possibles = np.array([('-x','y'),('-y','-x'),('x','-y'),('x','y'),('y','-x'),('-x','-y'),('-y','x')])\n",
    "        #True false value of whether the board has that symmetry\n",
    "        isSym = [False,False,False,False,False,False,False]\n",
    "\n",
    "        #Tests all eight of the symmetries\n",
    "        if np.array_equal(np.rot90(test),test):\n",
    "            isSym[0] = True\n",
    "        if np.array_equal(np.rot90(np.rot90(test)),test):\n",
    "            isSym[1] = True\n",
    "        if np.array_equal(np.rot90(np.rot90(np.rot90(test))),test):\n",
    "            isSym[2] = True\n",
    "        if np.array_equal(test.T,test):\n",
    "            isSym[3] = True\n",
    "        if np.array_equal(np.rot90(test.T),test):\n",
    "            isSym[4] = True\n",
    "        if np.array_equal(np.rot90(np.rot90(test.T)),test):\n",
    "            isSym[5] = True\n",
    "        if np.array_equal(np.rot90(np.rot90(np.rot90(test.T))),test):\n",
    "            isSym[6] = True\n",
    "        \n",
    "        #If the board contains any of the symmetries\n",
    "        if any(isSym):\n",
    "            #Creates a tuple to see if it a symmetry of any of the current spots\n",
    "            check = (0,0)\n",
    "            for spot in spots:\n",
    "                #Turns the current spots into the actual integer tuple of the (y,x) values of the spot on the board\n",
    "                spotT = spot\n",
    "                spotT = tuple(spotT[1:-1].split(','))\n",
    "                spotT = (float(spotT[0])+int(len(board[0])/2),float(spotT[1])+int(len(board[0])/2))\n",
    "                #For each of the symmetries for each of the spots\n",
    "                for s in possibles[isSym]:\n",
    "                    #Turns check into the symmetrical spot on the board\n",
    "                    if s[0] == 'x':\n",
    "                        check = (spotT[1]-dx+dy-int(len(board[0])/2),check[1])\n",
    "                    elif s[0] == '-x':\n",
    "                        check = (-(spotT[1]-dx)+dy-int(len(board[0])/2),check[1])\n",
    "                    elif s[0] == 'y':\n",
    "                        check = (spotT[0]-int(len(board[0])/2),check[1])\n",
    "                    elif s[0] == '-y':\n",
    "                        check = (-spotT[0]+2*dy-int(len(board[0])/2),check[1])\n",
    "                    if s[1] == 'x':\n",
    "                        check = (check[0],spotT[1]-int(len(board[0])/2))\n",
    "                    elif s[1] == '-x':\n",
    "                        check = (check[0],-spotT[1]+2*dx-int(len(board[0])/2))\n",
    "                    elif s[1] == 'y':\n",
    "                        check = (check[0],spotT[0]-dy+dx-int(len(board[0])/2))\n",
    "                    elif s[1] == '-y':\n",
    "                        check = (check[0],-(spotT[0]-dy)+dx-int(len(board[0])/2))\n",
    "                    #Make sure check is a whole number then converts it into an int\n",
    "                    if np.floor(check[0]) == check[0] and np.floor(check[1]) == check[1]:\n",
    "                        check = (int(check[0]),int(check[1]))\n",
    "                    #If the symmetry actually changed the spot\n",
    "                    if \"{}\".format(check) != spot:\n",
    "                        #Remove all instances of the symmetrical spot, only left with unique spots\n",
    "                        newSpots[:] = [x for x in newSpots if x != \"{}\".format(check)]\n",
    "    return newSpots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I need to be able to find the spots on the board cuurently available to place the next number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_available(board, lookingFor):\n",
    "    spots = [] #The spot that the function will return\n",
    "    #Goes through all the spots excluding the edges as that will cause an issue because there would not be 8 values surrounding it\n",
    "    for i in range(1,len(board[0])-1):\n",
    "        for j in range(1,len(board[0])-1):\n",
    "            if board[i,j] == 0: #Cant place a number if another one is already there\n",
    "                #Sum up all 8 surrounding values\n",
    "                surrsum = board[i-1,j-1]\n",
    "                surrsum += board[i,j-1]\n",
    "                surrsum += board[i+1,j-1]\n",
    "                surrsum += board[i-1,j]\n",
    "                surrsum += board[i+1,j]\n",
    "                surrsum += board[i-1,j+1]\n",
    "                surrsum += board[i,j+1]\n",
    "                surrsum += board[i+1,j+1]\n",
    "                #If it is a spot that the nxt number can be placed, add it to the list\n",
    "                if surrsum == lookingFor:\n",
    "                    spots.append('{}'.format((i-int(len(board[0])/2),j-int(len(board[0])/2))))\n",
    "    spots = find_symmetries(board, spots) #Remove duplicates\n",
    "    return spots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order for the directory, whereOnTree, to be useful the tree as a whole needs to be save, using nodes and children, which would allow us to look at it later too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_tree_spot(whereOnTree, lookingFor, spots, roots, nodeNum):\n",
    "    #Defines the current node\n",
    "    currentNode = current_spot(whereOnTree, roots)\n",
    "    #For each of the spots available make them children of the current node\n",
    "    for spot in spots:\n",
    "        Node(str(nodeNum), parent=currentNode, display_name=\"{}\".format(spot))\n",
    "        nodeNum += 1\n",
    "    return nodeNum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the board expands near the edge of the board, it will need to be expanded, so its not constrained to the limits of the current board, but could go on forever."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_edge(board, spot):\n",
    "    #Current spot\n",
    "    spot = tuple(spot[1:-1].split(','))\n",
    "    #If it is near the edge, one away\n",
    "    iTooFar = int(spot[0])+int(len(board[0])/2) <= 1 or int(spot[0])+int(len(board[0])/2) >= len(board[0])-2\n",
    "    jTooFar = int(spot[1])+int(len(board[0])/2) <= 1 or int(spot[1])+int(len(board[0])/2) >= len(board[0])-2\n",
    "    #If it is return true\n",
    "    if iTooFar or jTooFar:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Expands the board\n",
    "def expand_board(board):\n",
    "    #returns the same board surrounded by ones\n",
    "    return np.pad(board, [(1, 1), (1, 1)], mode=\"constant\", constant_values=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it has to iterate through all the options, building the tree until it runs out of places to go"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#While it hasnt exausted all the options\n",
    "while len(whereOnTree) > 0:\n",
    "    #Defines the available places to put the next number\n",
    "    spots = find_available(board, lookingFor)\n",
    "    #If there is a spot available\n",
    "    if len(spots) > 0:\n",
    "        #Adds it to the tree\n",
    "        nodeNum = make_tree_spot(whereOnTree, lookingFor, spots, roots, nodeNum)\n",
    "        #Adds the first new spot to our directory\n",
    "        whereOnTree.append(0)\n",
    "        #Places the number on the new spot\n",
    "        board = place_found(board, spots[0], lookingFor)\n",
    "        #Now looking for next number\n",
    "        lookingFor += 1\n",
    "        #Makes board bigger if it is close to the edge, to prevent boundary issues\n",
    "        if on_edge(board,spots[0]):\n",
    "            board = expand_board(board)\n",
    "    else:\n",
    "        #Add the value to array of endpoints\n",
    "        leafs.append(len(whereOnTree))\n",
    "        #If its a record record it\n",
    "        if len(whereOnTree)>record:\n",
    "            recordBoard = list([np.copy(board)])\n",
    "            record = len(whereOnTree)\n",
    "        elif len(whereOnTree)==record:\n",
    "            recordBoard.append(list(np.copy(board)))\n",
    "        #Make sure it hasn't exhausted all the possibilities and it goes back one step if it cannot move horizontatlly\n",
    "        while len(whereOnTree) > 0 and len(current_spot(whereOnTree, roots).siblings)-1 < whereOnTree[-1] and len(whereOnTree) != 1:\n",
    "            #Removes current spot\n",
    "            currSpot = tuple(current_spot(whereOnTree, roots).display_name[1:-1].split(','))\n",
    "            \n",
    "            board[int(currSpot[0])+int(len(board[0])/2),int(currSpot[1])+int(len(board[0])/2)] = 0\n",
    "            #Removes it from the current directory\n",
    "            if len(whereOnTree) > 1 or whereOnTree[0] >= len(roots)-1:\n",
    "                whereOnTree.pop()\n",
    "                #Changes to the next lowest number\n",
    "                lookingFor -= 1\n",
    "    \n",
    "        #Make sure it hasn't exhausted all the possibilities and all the roots\n",
    "        if len(whereOnTree) > 0 and (len(whereOnTree) > 1 or whereOnTree[0] < len(roots)-1):\n",
    "            #Removes it from the board\n",
    "            currSpot = tuple(current_spot(whereOnTree, roots).display_name[1:-1].split(','))\n",
    "            board[int(currSpot[0])+int(len(board[0])/2),int(currSpot[1])+int(len(board[0])/2)] = 0\n",
    "            #Moves horizontally on the tree\n",
    "            whereOnTree[-1] += 1\n",
    "            #Places it on board\n",
    "            size = len(board[0])\n",
    "            board = set_board(roots, whereOnTree, size=size)\n",
    "        else:\n",
    "            #if it has exhausted all the possibilities end the game\n",
    "            whereOnTree = []\n",
    "print('There were {} total nodes on the tree'.format(nodeNum)) #How many total nodes are on the tree, ie possible boards in total\n",
    "print('The highest number possible is {}'.format(record))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will save the tree created as a png of a Dot File to show the results later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "DotExporter(start, nodeattrfunc=lambda node:'label=\"{}\"'.format(node.display_name)).to_picture(\"TotalTree.png\")\n",
    "DotExporter(roots[2], nodeattrfunc=lambda node:'label=\"{}\"'.format(node.display_name)).to_picture(\"root2.png\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that it successfully went through all the results for 2 ones quite quickly, I can adapt it to take more than one one initally, by changing the roots function and the set board function. The root is still the last 1 added, but is the descendant of the other ones placed. The set_board function now places all the anscestors of the root, allowing all the ones to be placed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_roots(board, extraones, size, start):\n",
    "    #Keep track of the number of the node\n",
    "    nodeNum = 6\n",
    "    #Makes a copy of the board\n",
    "    newBoard = np.copy(board)\n",
    "    #Creates 5 nodes for the 5 unique starting positions of ones, with each being children of the start (0,0) node\n",
    "    #Each is named a unique number, but displayed as the position that it is placed at\n",
    "    roots = [Node('1',parent=start, display_name='(0,-1)'),Node('2',parent=start, display_name='(0,-2)'),Node('3',parent=start, display_name='(-1,-1)'),Node('4',parent=start, display_name='(-1,-2)'),Node('5',parent=start, display_name='(-2,-2)')]\n",
    "    newRoots = roots\n",
    "    #For each new one added\n",
    "    for i in range(extraones):\n",
    "        newRoots = []\n",
    "        #For each new root make a board with that root\n",
    "        for r in roots:\n",
    "            spots = []\n",
    "            newBoard = set_board([r], size = size)\n",
    "            for i in range(len(newBoard[0])):\n",
    "                for j in range(len(newBoard[0])):\n",
    "                    #Create a root with a one at each of the spots on the board\n",
    "                    if newBoard[i,j] == 0:\n",
    "                        spots.append('{}'.format((i-int(size/2),j-int(size/2))))\n",
    "            #Get rid of the symmetries\n",
    "            spots = find_symmetries(newBoard, spots)\n",
    "            #Add those spots and make them the new roots\n",
    "            for spot in spots:\n",
    "                newRoots.append(Node(nodeNum,parent=r, display_name=spot))\n",
    "                nodeNum += 1\n",
    "            newBoard = np.copy(board)\n",
    "        roots = newRoots\n",
    "    return newRoots\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_board(roots, whereOnTree = [0], size = 7):\n",
    "    #Creates the new board from scratch\n",
    "    newBoard = make_board(size)\n",
    "    #places the second one\n",
    "    newBoard = place_found(newBoard, roots[whereOnTree[0]].display_name, 1)\n",
    "    \n",
    "    #Places all the ancestors of the root, which are ones\n",
    "    for an in roots[whereOnTree[0]].ancestors:\n",
    "        newBoard = place_found(newBoard, an.display_name, 1)\n",
    "     \n",
    "    #Places all of the following numbers, starting with 2\n",
    "    for i in range(1,len(whereOnTree)+1):\n",
    "        place = current_spot(whereOnTree[0:i], roots).display_name #Defines the spot of that number\n",
    "        newBoard = place_found(newBoard, place, i) #Places it\n",
    "    return newBoard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By changing the variables slightly, using the new functions, with an extra one, and a bigger board to allow every possibility of starts, we can use the old bulk of code to find the highest board with 3 ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Unchanging Variables\n",
    "size = 15 #Start with a size 15 board\n",
    "start = Node('0', display_name='(0,0)') #Creates the root node of the tree, at the center\n",
    "board = make_board(size) #Creates the board\n",
    "roots = set_roots(board, 2, size, start=start) #Sets the roots, the last '1' of each board\n",
    "board = set_board([roots[0]], size=size ) #Adds the ones to start\n",
    "\n",
    "#Changing Variables\n",
    "\n",
    "nodeNum2 = 6 #The number of the nodes\n",
    "lookingFor = 2 #Which number is currently being looked for\n",
    "whereOnTree = [0] #The start of the directory\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tree resulting from every possibility is large, but smaller than expected, with 537 nodes in total. Each node represents a placement of numbers, and can be easily visualized in a chart. Below is an image of all possible boards, starting the the second one being placed at (-1,-1) or one diagonal from the initial 1. With that starting position the deepest you can get is 15, which is only one away from optimal. Most random ways, which is what I was doing by hand end around 7, so it is difficult to pick the exact way to get the optimal board. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(\"root2.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A function to show a board in a cool way\n",
    "def draw_board(grid, record):\n",
    "    \n",
    "    #Creates a copy\n",
    "    test = grid\n",
    "    \n",
    "    #Removes all the excess ones on the side\n",
    "    while all(test[0] == 0):\n",
    "        test = np.delete(test,0,0)\n",
    "    while all(test[-1] == 0):\n",
    "        test = np.delete(test,-1,0)\n",
    "    while all(test[:,0] == 0):\n",
    "        test = np.delete(test,0,1)\n",
    "    while all(test[:,-1] == 0):\n",
    "        test = np.delete(test,-1,1)\n",
    "        \n",
    "    grid = test\n",
    "    #Creates a figure\n",
    "    fig = plt.figure(figsize=(5,5))\n",
    "    #Adds grid lines to show the actual grid\n",
    "    plt.grid()\n",
    "    #For each number in the board\n",
    "    for r in range(1,record+1):\n",
    "        #Only true where the spot equals the value we are looking for\n",
    "        tf = (grid == r)\n",
    "        for i in range(len(grid[0])):\n",
    "            for j in range(len(grid[:,0])):\n",
    "                #Goes through each value looking for the correct spot\n",
    "                if tf[j,i] == True:\n",
    "                    #Sets the limits of the grid, which is the numbers on the array\n",
    "                    plt.ylim(len(grid[:,0])+1,1)\n",
    "                    plt.xlim(1,len(grid[0])+1)\n",
    "                    #Gets rid of the numbers of the axis'\n",
    "                    plt.xticks(np.arange(1,len(grid[0])+1),[])\n",
    "                    plt.yticks(np.arange(1,len(grid[:,0])+1),[])\n",
    "                    #Places the number in the center of the correct square\n",
    "                    plt.text(i + 1.5, j+1.55,'{}'.format(r), horizontalalignment='center', verticalalignment='center', fontsize = 30)\n",
    "                    #Waits to place the next number\n",
    "                    clear_output(wait=True)\n",
    "                    display(fig)\n",
    "                    #time.sleep(.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1244865c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1243552b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x124811780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x12486e630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x121bcfba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x121c38550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1241f4390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASwAAAElCAYAAABect+9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJztnXdUVNfa/780AREbRQgC9oINRbGggogUIRpRvBaQcjFoxBL52a7Jq141XBOjxpLYwRYlXsTXBgEpiiU2xBKVoiAKKig2BhCY2b8/eDlrkGHqmZkzsD9rsdYeZs/e3zkz55lz9nnO89UihIBCoVA0AW11C6BQKBRpoQGLQqFoDDRgUSgUjYEGLAqFojHQgEWhUDQGGrAoFIrGQAMWhULRGGjAolAoGgMNWBQKRWOgAYtCoWgMupI6aGlpfQ3gawAwMDBwsLGxUbooeREIBNDW5mYM5rI2oKE+Pp+P8vJylJeX49OnT6iqqmL66OrqwtDQEG3atIGBgUGjY75//x6vXr2SWYuhoSGsra3F6uMaVJ9iZGdnvyaEmEnsSAiR+q9Hjx6Ey6SmpqpbQqNwWRsh9fVt2LCB6OvrEwAS//z9/QmPxxM5ZlRUlFRjfP4XHBwsVh8XofoUA8BNIkUMkniERWl+ZGdn49OnTwCALl26wM3NDfb29jA1NcXbt2+RnJyM2NhY8Pl8HD58GMXFxYiPj2/wC+7q6oq4uDiJ8wkEAvj7+6OiogIAEBwczP6bojQJaMCiNEBLSwve3t5YsmQJRo8eDS0trXrPf/3110hPT8f48eNRVlaGxMREHDhwoEGgsbGxgTRLCAkJCUyw6tatG0aNGsXem6E0Kbh7UktRGz/++CPOnDkDZ2fnBsGqjlGjRiEyMpJ5HB0dLfd8+/fvZ9r06IoiDhqwKA1o166dVP38/PyY9r179+Saq7S0FKdOnQIA6OjoIDAwUK5xKM0DGrAocmNsbMy0607pZOXIkSPMepm7uzusrKxY0UZpmtCARZGb+/fvM21bW1u5xoiKimLaISEhCmuiNG1owKLIze7du5m2t7e3zK+/c+cObt++DQAwNTXFhAkTWNNGaZrQgEWRiytXrjBHRwYGBli0aJHMYwgvts+cORMtWrRgTR+laUIDFkVmXr58ialTp0IgEAAA1q5d2yAzXRJVVVU4cuQI85ieDlKkgQYsikzweDxMnDgRhYWFAGpPBSMiImQe59SpU3jz5g0AwMHBAf3792dVJ6VpQgMWRWoqKysxYcIEXL9+HQDg5OSEmJiYRnO1xCF8OkiPrijSQgMWRSqqqqrg6+uLlJQUAICjoyPOnTsHIyMjmccqKipCYmIigNr1rxkzZrCqldJ0oQGLIpHq6mr4+fkhPj4eADBw4EAkJCSgdevWco134MAB8Pl8AMCkSZPQtm1b1rRSmjY0YFHEUlNTg+nTpzPZ6P369UNSUpLU2fCiEL6Nh54OUmSBBixKo/D5fAQEBCA2NhYAYGdnh/Pnz8PExETuMS9duoTs7GwAtcmmY8eOZUUrpXlAAxZFJAKBACEhITh27BgAoEePHkhOToa5ublC4wpntgcFBcm1YE9pvtCARWkAIQRhYWE4ePAggNqSL6mpqbCwsFBoXB6Phz/++ANAbQmboKAgRaVSmhm0HhalAStXrsTevXsBAHp6eliwYAGTyiAOd3d3tGzZstHnjx8/jrKyMgC1xf06derEil5K84EGLEoDrly5wrSrq6uxYMECqV6Xl5cnNgjR3CuKotBTQopKyM3NRXp6OgCgTZs28PX1VbMiiiZCj7AoDUhLS2N9zG7duqHWa4BCkR96hEWhUDQGLUm/esK+hGZmZg51V3m4SFlZGVq1aqVuGSLhsjagoT4+n4+CggJkZWUhOzsbWVlZePz4MVMdNDAwUOGrfBs3bsTZs2eZx+LGVJa+7OxsPHz4EI8ePUJeXh7evXuH9+/fg8/nw9jYGLa2thg8eDA8PT3Rvn37Rsf5XF9ZWRlu3LiBzMxMZGdno6ioCDweD4aGhjA3N0ffvn3h5eWFXr16SdQozOPHj5GUlIRbt26hpKQE5eXlaNOmDUxNTdG3b18MHjwYQ4cOlaiPa4wZM+YWIWSwxI7SeIER6kuoMFzWRkhDfb6+vmK9A1etWqXwfFpaWlKPqSx9HTp0kMorsVWrVmTXrl1S6WPL11EYHo9HwsLCiLa2ttjx2rRpI1EfFwH1JaQoQt29fnW0b98eJiYmyMnJUXjsiooKzJ49G4QQGBkZgcfjqVWfqakphg0bhj59+sDS0hIWFhbg8/nIzc3FyZMncfv2bZSVlSEsLAy6uroSr3Cy5etYR1lZGXx8fHDhwgUAgLm5OSZPnoxBgwahdevWePHiBQoKCpCUlIRnz57J/P41CRqwKCJxdHRE79694eDgAAcHB3Tu3BnR0dGs2HCtXr0aubm5sLKywtSpU7F582a16UtOToadnV2jGff/8z//g8jISPzrX/8CAERERGDmzJnQ19dvdEy2fB3rmDNnDhOsAgICsGPHjnoGIMI8f/5c4nvWZGjAooikbgdlm4yMDPz8888AgK1bt+Lu3btyjcOWvj59+kjss2LFChw7dgx3797Fu3fvcPnyZbi6ujba/8cff5R4c3idr+P8+fMBoNFgm5CQwFRm9fLywoEDB8TeztSxY0eJ70eToVcJKSqjpqYGoaGh4PP5mDBhgkblYtnZ2THtly9fiu3Lpq/jTz/9BADQ1tbGtm3bmv29lzRgUVTGxo0bcfv2bbRq1Qrbt29XtxyZePz4MdNW9J7KOiT5Oj59+hSpqakAABcXF3Tt2pWVeTUZGrAoKiEnJwdr1qwBAKxbt05m0wp1snPnTty4cQMA0KFDBzg5ObEyriRfx/T0dCbZtu4U9NixY3B3d0eHDh1gYGCAjh07wtfXF//973+bRWIuXcOiKB1CCEJDQ1FZWYnBgwcjPDxc3ZJEcvHiRZSWlgIAPn36hPz8fJw5cwaXLl0CABgaGiIqKkrsgrssSPJ1vHnzJtPu1KkTxo8fz1R9raOwsBBxcXGIi4uDi4sLYmNjxeaLaTo0YFGUzu7du3Hx4kXo6Ohg9+7d0NHRUbckkSxduhTXrl1r8H8dHR24ubkhMjISAwcOZGUuaXwdhdfK6q6s6uvrIzAwEE5OTtDR0cHNmzexd+9elJWVIS0tDV5eXkhPT2+yHo80YFGUSmFhIZYuXQoAWLhwIWs7vCqxtbWFu7s7bGxsWBlPWl/Hd+/eMe3c3Fy0a9cOycnJ9bbhzJkzER4eDmdnZxQWFuL69evYsmULs82bGnQNi6JUvvnmG3z48AE2Njb497//rW45Yvnrr7+YjOqysjLcunULy5cvR1FRESIiImBvb49bt24pNIcsvo51Aa2ODRs2iAz4Xbt2xc6dO5nHW7duVUgjl6EBi6I0/vjjD8a8YseOHXJZgqkLIyMjDBo0CJGRkbhy5QqMjY3x/PlzuLm5oaioSK4xZfV1FL6KaGBggICAgEbH9vb2hpWVFYDao9qHDx/KpZHr0IBFUQqlpaVM4T8/Pz/4+PioWZH8DBw4kDnFevfuHX755ReZx5DH11HY/qx3794wMDBotK+Wlla9oy/hNIymBF3DoiiF06dP49WrVwAAMzMzrFu3TmS/ixcv1mvX9Rs6dCjGjRunfKFS4unpie+//x6A7PXC5PV17NmzJ9Nu06aNxHmE+7x//14mjZoCDVgUpSCcE/Trr79K9ZrU1FQmUXLhwoWcCljCp2fCi+GSUMTXsX///kz7w4cPEvsLBylpApwmQk8JKRQpyM3NZdqmpqZSvUZRX0dnZ2fmlPHBgweorKxstC8hBLdv32Ye9+jRQ6o5NA0asChKISgoSKoaa6tWrWJes2rVKub/W7ZsUaP6hggneY4YMUJifzZ8HQ0NDTFhwgQAtQv2hw4darTv2bNnmSuPnTt3pgGLQmlqREdHIzExUewtLVVVVYiIiGBO6Vq0aIHQ0FCx4xIWfR1XrVoFXd3alZtly5YhMzOzQZ8nT55g7ty5zOMlS5bIPI+mQNewKCLJy8vDvn376v1PuBRMSkoKampq6j0/efJklSWGsqEvMzMTwcHB6NixI9zd3dG/f3+YmZmhRYsWKC0txd27dxEXF1cvjWHjxo31FsNFwaavY8+ePbF+/XosW7YMb9++xbBhwxAUFFQv033Pnj2M36OHhwfCwsIkzqWxSHPYXvdHSyTLD5e1EdJQX2pqqlQlfoX/oqKiZJ531apVcpVIZkPfwoULpX6tubk5OXr0qFT6nJ2dZdYGgOTl5TU6/g8//ED09PTEvn7KlCmNllvm+vcPtEQyhSKeH374AT4+PkhLS8PVq1dRWFiI4uJifPz4EUZGRrC0tIS9vT28vLwwefJktSa+rlixAhMnTsTu3buRmJiI58+fo7q6GhYWFnByckJISIjYooJNBRqwKCJxcXFRSbmS1atXY/Xq1TK/jg19LVu2hJubG9zc3BQa53OU4esI1F5l5NrFCFVDF90pFIrGQAMWhULRGKiRqorgsjag6epThSGsKH1szfvp0yfcunULt2/fxqNHj/D8+XOUlZWhRYsWMDU1hZ2dHdzc3ODg4CCTPq5BjVQ5Bpe1EdJ09SnbELYxfWzMe/jwYdKqVSuprjB6enqS4uJiqfVxDdCrhBSKcg1hlT1vXl4ek19laWmJcePGYciQITA3NwePx0N6ejqOHj2KyspKJCQkwM3NDVevXm2Qy9WUoAGL0qRRpiGsKuZ1cnLC8uXL4eXl1aC0dHBwMP7f//t/cHNzw4sXL3D37l1s2LCBMftoitCARWnSKMsQVhXzzps3D999953YPnZ2dti9eze+/PJLALW3GzXlgEWvElIoHEVaQ1YvLy8mqbWgoECqUjSaCg1YFIqGo6OjU2/dSpQpa1OBBiwKRcMpLi5GSUkJgNrsfTMzMzUrUh40YFEoGo5wrS5PT09oazfd3brpvjMKpRnw5MkTREZGMo+XL1+uRjXKhwYsCkVD4fF4mDRpEsrLywHUXlUcMmSImlUpFxqwKBQNhM/nY8aMGUzRwkGDBmHjxo1qVqV8aMCiUDQMgUCAoKAgpmxzz549ER8fL9a3sKlAAxaFokGQ/6sXf/jwYQC1NvWymltoMjRgUSgaRHh4OFMv3tbWFikpKYxFfXOABiwKRUNYtGgRY0rbsWNHpKSkwMbGRs2qVAsNWBSKBrB06VL88ssvAGorN6SkpKBLly5qVqV6aMCiUDjOd999h59++gkA0KFDB6SkpKB79+5qVqUeaMCiUDjMunXrsH79egCAmZkZkpOT0atXLzWrUh+0vAylSaMuQ1g25t2zZw++//575nF4eDhycnIkFgEcOXIkTE1NFZHPWWjAojRpnj59yhyhiCI9PR3p6en1/tetWzeFAxYb816+fLne86tWrZJq7tTUVLi4uEgvVoOgp4QUCkVjoEdYlCaNqgxhlTFvdHQ0oqOj2RHURKBHWBQKRWOgAYtCoWgM1EhVRXBZG6A8I1Bhrl+/jvj4eDx8+BClpaUwMjKClZUVnJ2d4ePjA0NDQ5XrI4Tg+fPnzBjZ2dnIyclhSrZ4eHhIVWNK0z5frkGNVDkGl7URohwj0DoqKyvJ9OnTxY7XtWtXcufOHZXrW7x4sdhxAgMDpRpH0z5frgEpjVTpKSFFJKKMQOXNrg4MDMTRo0cBACYmJlixYgV+//13bN26FY6OjgCAx48fw9PTE8+ePVOpvs/HMTY2hp2dnczjUFQDvUpIEQlbRqD/+7//i5iYGACAjY0N0tPT692wO2/ePISGhiIqKgovXrzA4sWLcfz4cZXps7Ozw7fffgsHBwcMHjwYPXr0wIULFzBmzBiZxqGoBhqwKCJhy4B09erVTPu3335rUF1AW1sbO3bsQHJyMgoKCvDf//4X9+/fR9++fVWi7+uvv2ZlHIpqoKeEFKWRk5ODzMxMAED37t0xfvx4kf0MDQ0xe/Zs5jGXL+xQ1AsNWBSl8eeffzJtDw8PsX09PT2ZdkJCgtI0UTQbGrAoSuP+/ftM28HBQWxfe3t76OjoAAAePHiglux0CvehAYuiNLKzs5l2p06dxPbV1dVlSv3yeDwUFhYqUxpFQ6EBi6I03r17x7SlKXdiYmIi8rUUSh00YFGURllZGdOWxoJKONP948ePStFE0WxowKKoBC0tLXVLoDQBaMCiKA3he9cqKiok9hfuY2xsrBRNFM2GBiyK0mjbti3TfvPmjcT+wn2EX0uh1EEDFkVp9OjRg2nn5+eL7VtTU8NcGayr4kChfA4NWBSlIXx7zc2bN8X2zczMZG5EtrOzo2teFJHQgEVRGsLZ7cJZ76IQzm4XznqnUIShAYuiNLp37864wOTk5CA+Pl5kv8rKSuzZs4d5PHXqVJXoo2geNGBRlIqwNdXcuXNRUFBQ73mBQIB58+Yx/58yZYrESg2U5gstL0MRCVsGpBMnTsQ//vEPxMTE4OnTp3BwcEBYWBj69u2LN2/e4ODBg7h+/ToAwNLSEps2bVKpvnfv3mHjxo31/vf06VOmffv2bXz33Xf1nnd1dYWrq6tUOiksI01ZUkJLJCsMl7UR0lBfamqq2NLBov6ioqJEjl1ZWUmmTZsmsURyZmamyvXl5eXJPI6o8sua9vlyDdASyRSuoK+vj6NHjyI+Ph5+fn6wtraGvr4+TE1NMXz4cGzatAl37tzBgAED1C2VwnHoKSFFJMowIPX09GTtCiBb+jp16kRL2WgQ9AiLQqFoDNSXUEVwWRtA9SkK1acYKvElfPfuHYmJiSFz5swhjo6OpH379kRXV5e0bduW9O/fn8ydO5dcv35d4oLbrVu3yK+//kqCg4PJ4MGDia2tLTEyMiL6+vrEwsKCuLq6ksjISPLixQux43y+sFhTU0Pu3btHoqKiSHh4OBk2bBgxNDSUy1uPEEJycnLI0qVLiaOjI2nXrh3R1dUlxsbGpGfPnsTf35+cPXtWam3ykJGRQcLCwkivXr2IsbExMTQ0JF26dCGzZs1SeHyuL8p+ro+t755AICBZWVnk999/J4sXLybOzs7E2NiY+hKqGEi56C53wNqwYQPR19eX6qqKv78/4fF4jYrt0KGDVOO0atWK7Nq1q9FxlGkGGhkZSfT09CRqdHV1JW/evJGoTRaqqqpIeHi4xLmDgoJIVVWVXHNw/QstrI/N7x41UuUG0gYsuRfds7OzGVvwLl26wM3NDfb29jA1NcXbt2+RnJyM2NhY8Pl8HD58GMXFxYiPj4e2tuhlM1NTUwwbNgx9+vSBpaUlLCwswOfzkZubi5MnT+L27dsoKytDWFgYdHV1ERISIlGjKLNNExMT5OTkyPRet2zZghUrVjCPR48eDW9vb1hbW+Pt27e4ffs2Dh06hE+fPiElJQXe3t64dOkSU6NcUb7++mtER0cDAPT09DBjxgw4OzvD0NAQjx49wv79+/Hs2TNER0ejqqoKR44cYWVersLmd0+Ukaq1tTUePHigkvdCkRFpohoRcYQVGhpKvL29SVpaGhEIBCKj5sWLF0mrVq2YX6v9+/eL7Hf//v1Gx6jjhx9+YMZp27YtqaysbNDn81+R9evXk+XLl5Pjx4+TJ0+eEEIIiYqKkukIi8fj1XsP+/btE9nvyZMnxMrKiukXFxcnVpu0nDlzhhnT2NiYXLt2rUGfjx8/EhcXF6bfiRMnZJ6H67/AwvrY/O7t2rWLfPvtt+Tw4cPk0aNHRCAQ1MvxokdYqgHKPiUsLS2VSsi2bduYD3/06NEKvan+/fszYyUnJzd4XpoPRdaAlZSUxPQfMmSI2L7C73Xx4sUyaxOFh4cHM+a2bdsa7ffixQtiYGBAABA7OzuZ5+H6F1pYn7K/ezRgqR5pA5bcaQ3t2rWTqp+fnx/TvnfvnrzTAagtO1LHy5cvFRpLWoqLi5l29+7dxfYVrv/E4/EUnpvP5+PChQsAaksMz5w5s9G+FhYWTHWEBw8e1LtNpamhju8ehRsoPQ9LuNStNGVyxfH48WOmbWFhodBY0tKhQwemLWntS/j53r17Kzz3mzdvUFlZCQAwNzeXuKP27NmTaZ87d07h+TUdNr97FG6g9IAlbKZpa2sr9zg7d+7EjRs3ANQGEScnJ4W1SYOTkxNjUXXjxg1ERUWJ7Jefn4/IyEgAtXZV/v7+KtEnDBHKqaNHFOx99yjcQem35uzevZtpe3t7S+x/8eJFlJaWAgA+ffqE/Px8nDlzBpcuXQJQawUVFRUFfX195Qj+DAMDA+zcuRPTpk1DTU0NQkJCEB0dDR8fH+YqYUZGBnOV0MrKCidOnKjnsScv7du3h56eHqqrq1FSUoJ3796JrXUufISXlZWl8PyajqzfPYoGIM1CFxGx6C4Nly9fJtra2gQAMTAwIAUFBRJfM3ToUJH5MDo6OsTDw4NkZGQ0+lplLLrXcf78edK7d+9G83WMjIzIxo0bReZgSatNFKNGjWLm2L59e6P9Xr58WS8ptmvXrjLNw/VFWVn1yfPdE54LdNFdpUDd1RpevnyJqVOnQiAQAADWrl0La2truceztbWFu7s7bGxs2JIoE2PGjMHWrVvrLfwLw+PxsGnTJuzdu5fVm2lnz57NtP/1r3/h1q1bIueeMWNGvXWa5mxEyvZ3j8IdlBKweDweJk6cyLigeHt7IyIiQqrX/vXXX0w0LSsrw61bt7B8+XIUFRUhIiIC9vb2IndaZVJSUgIXFxeMGzcOJSUl2LFjB54+fYqqqiqUlJQgNjYWAwYMQFFREZYtW4aAgABmZ1GUGTNmYNy4cQCADx8+YMSIEQgJCcGBAwcQExODNWvWwM7ODikpKejUqRPzusYSdJs6inz3KBqANIdhRIZTwoqKCuLq6socUjs5OZGysjKFDxkzMjKYe7zatm1LCgsLG/RRxilhWVkZ6dGjBwFATExMmATUz6moqCDDhw9v9PRNkUPy9+/fky+//FLsLSRdu3YlFy5cYB737t1bpjm4fsogjT62vnv0lFD1QB2nhFVVVfD19UVKSgoAwNHREefOnYORkZHCYw8cOBBLly4FUFvW9pdfflF4TGnYsWMHsrOzAQBLlixB586dRfYzMDCoV95327ZtrGlo3bo1Tp06hYSEBEybNg22trYwMDCAsbExBg0ahMjISNy5cwcGBgbMa1SV9sEVlPndo3AH1q4SVldXw8/Pj3FGGThwIBISEtC6dWu2poCnpye+//57AEBaWhpr44rj7NmzTNvNzU1s36FDh6JVq1YoKytDVlYW3r9/jzZt2rCmxcPDo5511ufUpX0AwODBkit1NBVU8d2jcANWjrBqamowffp0nDp1CgDQr18/JCUlSZ2RLC3CiYDv3r1jdezGKCoqYtqSdgAtLa16fcrLy5WmSxTC3n6jRo1S6dzqQlXfPQo3UDhg8fl8BAQEIDY2FkDt7TPnz59nJQ/pc3Jzc5l2XTKnshEOQM+ePRPbt6KiAiUlJczj9u3bK03X5zx79owJWJaWlvDy8lLZ3OpCld89CjdQKGAJBAKEhITg2LFjAGrvpUtOToa5uTkr4j5HOBFwxIgRSpnjc4Q98ureZ2PExsaiuroaQO0vvaqSWwkhWLBgAWNrtWjRIujqNu1y/ar+7lG4gdwBixCCsLAwHDx4EADQrVs3pKamyrzYGx0djcTERLG5S1VVVYiIiGAO+1u0aIHQ0FB5pcvE9OnTmfa+fftw+PBhkf3u3LmDRYsWMY8DAgJY0/DXX38x9Z8+p6KiAnPmzMHJkycB1K7fLF68mLW5uQhb3z2K5iH3z/DKlSuxd+9eALVF5RYsWMAYYorD3d0dLVu2ZB5nZmYiODgYHTt2hLu7O/r37w8zMzO0aNECpaWluHv3LuLi4uqtJW3cuLHejb6NwYbZpqenJ7766iucPHkSAoEAAQEBOHToEHx8fGBpaYkPHz7gwoULiImJYYLKgAEDEB4eLlGftKxbtw5Xr16Ft7c3hgwZAgsLC/B4PNy/fx8xMTF4/vw5AKBz586Ii4tr8kdXbH33AGqkqnFIk/tARORhOTs7S1Wi9vO/vLy8evkXCxculPq15ubm5OjRo43mcijLbLO8vJz4+/tL9foxY8aIrD2vSB6Mt7e3xHk9PDzIs2fP5J6D63k6wvrY+u4RQo1UuQKUXSKZLX744Qf4+PggLS0NV69eRWFhIYqLi/Hx40cYGRnB0tIS9vb28PLywuTJk9WSV2NoaIhDhw5h/vz5OHDgAK5cuYL8/Hx8/PgRhoaG+OKLLzB06FBMnz4dnp6e0NLSYnX+f//73xg8eDAuXLiAvLw8FBcXQ1dXF5aWlhg5ciSmTZvGZMNTKE0ZuQMWW3lQLVu2hJubm8QcJ3lg2wzU0dERjo6OrI0nLYMGDcKgQYNUPi9XYTMHjxqpahbN84YzCoWikTR7I9VFixbhzp07UvXt0KGDxNSGxlCGkeWSJUtw8+ZN5vGyZcvktoLnutEm1acYXNenEiNVriHPwqIsC7i2trYq1SaO6OhoqS4YSAvXF2WpPsXguj5oyqI7l4iLixP7/OeXxNVFcXExk2tlZGTEiuEFhaIJ0IAlxFdffaVuCVIxf/58lJaWwt7eHn379m00mZVCaWrQRXcN49SpU/jjjz+gra2N3bt3s+YuTaFoAjRgaRAfPnzAN998AwAIDw/HkCFD1KyIQlEtNGBpEEuXLkVhYSE6duyIdevWqVsOhaJyaMASwtvbG5aWlmjRogVMTExgb2+P+fPnIzMzU93ScPHiRaZaxbZt2+rVBqNQmgs0YAlx7tw5vHz5EtXV1SgtLcWdO3ewfft2DBw4ECEhIWpzD66srMTs2bNBCMGkSZM05uIAhcI29Cohap2aPTw84ODggC+++AKEEMbA9cqVKwCAqKgoFBQUICEhQeXVENasWYPs7GwYGxuzWiueQtE0mn3AioyMxODBg6Gnp9fguRUrViAuLg7+/v4oLy9HcnIyNmzYgJUrV6pMX2ZmJlP+ZP369bCyslLZ3BQK12j2p4TDhw8XGazqmDRpEvbs2cM8/umnnxotpsc2fD4f//znP1FTU4MhQ4Zg3rx5KpmXQuEqzT5gScOMGTOYgoHv37/H5csTgAlxAAAgAElEQVSXVTLvzz//jIyMDOjq6mL37t3N1hyVQqmD7gFS4uLiwrSzsrKUPl9ubi5Wr14NAPj2229hb2+v9DkpFK7T7NewpEXYieXt27dKn+/IkSOoqKiAlpYWdHV1G827Ei75fPr0aaZcsru7u1pqd1EoyoQGLCl58+YN027btq3S5yP/V/aHEILIyEipXnPixAmcOHECANCqVSsasChNDnpKKCUXLlxg2j169FCjEgql+UIDlhQcPXoUjx49AlDrPj1y5Eilz7l69WqpapQFBgYyr4mKimL+L2w5RqE0FZp1wNq6dSuuXbsmts/JkyfreSBGRETAwMBA2dIoFIoImvUaVkpKChYuXIiePXti7Nix6NOnD0xMTJhM99OnTzOZ7gAwZswYrFixQo2KKZTmTbMOWHVkZWWJTVXQ0tLC7NmzsXnzZrRo0UKFyigUijDNOmD9/PPP8PHxwdWrV3H37l0UFxfj9evXqKmpQdu2bdGjRw+MHDkSwcHBdKGdQuEAzTpgde3aFV27dq23RqVpREdHIzo6Wt0yKBSV0KwX3SkUimZBAxaFQtEYFDJSLSsrw40bN5CZmYns7GwUFRWBx+PB0NAQ5ubm6Nu3L7y8vNCrVy+xc/znP//Bn3/+KbXo1NRUkf/nslmkvNr4fD4KCgqQlZWF7OxsZGVl4fHjx0zFiMDAQAQFBalFHyEE9+/fR1ZWFh49eoSCggK8e/cO79+/h5aWFoyNjdGlSxcMGzYM48aNU+iz4fJnCzTUx9a+UUdhYSHOnDmDzMxMFBYWory8HPr6+jAxMUGvXr3g6uqKYcOGSa2PayjdSHXDhg1EX19fKgNSf39/wuPxGjVRDAwMlNrMtFayaLhsFimvNl9fX7HbYtWqVWrTV1FRIfVnZmZmRk6ePKlSfapEWB+b+wYhhERGRhI9PT2JY7m6upI3b95I1MdFoGwj1ezsbOZXvkuXLnBzc4O9vT1MTU3x9u1bJCcnIzY2Fnw+H4cPH0ZxcTHi4+MllkjZtWsXzM3N5ZXV5ODz+fUet2/fHiYmJsjJyVGTooZYWVlh6NCh6N27NywsLGBubo5Pnz7h0aNHOH78OHJyclBSUoLJkycjPj4e48aNU7dkpcLmvrFly5Z6uX+jR4+Gt7c3rK2t8fbtW9y+fRuHDh3Cp0+fkJKSAm9vb1y6dKnp2r9JE9WIiCOs0NBQ4u3tTdLS0ohAIBAZNS9evEhatWrF/ALs379fZD/hI6y8vDy5ozSXf0Xk1bZ+/XqyfPlycvz4cfLkyRNCCCFRUVGcOMLi8/nk77//FtunpqaGzJ07l9Hbq1cvlelTJcL62No3eDxevT779u0TOdaTJ0+IlZUV0y8uLk6sPi4CKY+w5A5YpaWlUgnZtm0bsyFHjx4tsg8NWLLBlYAlLVVVVcTExITR/PjxY5nH4PJnS0h9fWztG0lJSczzQ4YMkXqsxYsXi9XHRaQNWHJfJWzXrp1U/fz8/Jj2vXv35J2OosHo6emhe/fuzOOXL1+qUY3yYWvfKC4uZtrC208UwonNPB5Pqvk1EaWnNQj756nLJouiXgQCAfLz85nHFhYW6hPDISTtGx06dGDaktYshZ/v3bs3C+q4idID1v3795m2ra2txP6zZ8+GjY0N9PX10bZtW9jZ2WH27Nm4ePGiMmVSlAQhBN999x1zVGVvb48uXbqoWRU3kLRvODk5wdTUFABw48YNREVFiRwnPz+fKfJoYmICf39/JajlBkq/NafOrRiodVaWxPnz55l2VVUV3r9/j4cPH2Lv3r3w9vbGwYMH0b59e6VopShGQkICKisrAQDl5eXIzc3FiRMncOfOHQC1O9O+ffvUKZFTSNo3DAwMsHPnTkybNg01NTUICQlBdHQ0fHx8mKuEGRkZzFVCKysrnDhxol4576aGUgPWlStXmF8FAwMDsUXljI2NMW7cODg6OsLa2ho6Ojp4/vw5EhMTkZiYCAA4e/YsnJ2dcfnyZbRu3VqZ0ilyEBQUhFevXjX4f4sWLTBhwgT8+OOP6Ny5sxqUcQ9p943JkycjISEB8+fPx8OHD3Hx4sUGZxtGRkZYv349goODm/yPudIC1suXLzF16lQIBAIAwNq1a2FtbS2y7/z587Fjxw4YGRk1eC4iIgLp6emYMmUKiouLcf/+fURERNTzCqRwm169esHNzY3m1/0fsuwbQG0dtq1bt2LhwoV48OBBg+d5PB42bdoEPp+PJUuWQEtLS2na1Y1S1rB4PB4mTpyIwsJCALWHuxEREY32d3BwEBms6hg1ahROnDjBfBBRUVHM2BTu8PLlSxBCIBAIGP/GuXPn4u+//8acOXMwdOhQPH78WN0y1Yqs+0ZJSQlcXFwwbtw4lJSUYMeOHXj69CmqqqpQUlKC2NhYDBgwAEVFRVi2bBkCAgKYQNgkkSb3gYjIw2qMiooK4urqyuSEODk5kbKyMlZyNTw8PMQm0XE516Q552ElJCQQHR0dAoB07txZru8Dlz9bQqTTJ+u+UVZWRnr06EEAEBMTEyZxWNS4w4cPZ8bdvn27XPrUCZSdhyWKqqoq+Pr6IiUlBQDg6OiIc+fOiT16kgVVm5lS2MHDw4O5QTsvLw8HDx5UryA1IM++sWPHDmRnZwMAlixZ0uj6n4GBATZt2sQ83rZtG4vKuQVrAau6uhp+fn6Ij48HAAwcOBAJCQmsLo6r2syUwh6enp5MOy0tTX1C1IC8+8bZs2eZtpubm9i+Q4cOZaoxZGVl4f379wqq5iasBKyamhpMnz4dp06dAgD069cPSUlJUmf8SouqzUwp7CGcJPnu3Ts1KlEtiuwbRUVFTFtScNPS0qrXp7y8XE7F3EbhgMXn8xEQEIDY2FgAgJ2dHc6fP6+UXBBqZqq55ObmMu26ZMimjqL7hnAAevbsmdi+FRUVKCkpYR431fQGhQKWQCBASEgIjh07BqA2iCQnJyvl8vWVK1eYIn/a2trw8PBgfQ6KchAIBPUSRkeMGKFGNaqBjX2jb9++TLtunMaIjY1FdXU1gNqjOH19fTlUcx+5AxYhBGFhYcwCardu3ZCamirzfWIHDx5EUlJSbemIRrh06RImTZrE9Jk1a5bYvBWKatiyZQv++usvsX0+fvwIf39/3L59G0DtL/+0adNUIU9tsLVvTJ8+nWnv27cPhw8fFtnvzp079RJPAwIC5FCtGcidOLpy5Urs3bsXQO3d+AsWLMD169clvs7d3R0tW7ZkHmdkZOCXX36BtbU1PDw80K9fP5iZmTXIdK8LVn369MHmzZvlla1x5OXlNbid5e7du0w7JSUFNTU19Z6fPHkyBg4cqHRtaWlp+Pbbb9G9e3eMHTsWffv2hYmJCXR0dFBSUoKMjAzExcWhtLQUAKCrq4u9e/c26VtHAPb2DU9PT3z11Vc4efIkBAIBAgICcOjQIfj4+MDS0hIfPnzAhQsXEBMTwxQMHDBgAMLDw5XzxriANLkPREQelrOzs0xljev+Pq93tXDhQqlfO2nSJPL69etGczm4nGsir7bU1FSZt3FUVJRK9E2cOFFqTV26dCFJSUkyz6GIPlUirI+tfYMQQsrLy4m/v79Urx8zZgx58eKFRH1cBMoukcwWS5YsgYODA/766y9kZGTg1atXeP36NSorK9GmTRt07twZI0aMwKxZszBo0CB1y6UIceDAAaSnpyMtLQ3Xr1/HixcvUFxcjPLychgbG8Pa2hoDBw7EhAkT4OPjQ12z5cDQ0BCHDh3C/PnzceDAAVy5cgX5+fn4+PEjDA0N8cUXX2Do0KGYPn06PD09m/RtOYACp4Rs5dJYWVkhICCgSZ93K4KLi4vY9T110qZNG/j4+MDHx0fdUjiFMvLMHB0d4ejoyPq4mgb1JaRQKBqDQr6EXIPL3mtc1gZQfYpC9SmG0n0JucjnC4vv3r0jMTExZM6cOcTR0ZG0b9+e6OrqkrZt25L+/fuTuXPnkuvXr8s0R3x8PJk6dSqxsbEh+vr6xMzMjIwYMYJs2rRJ7I2sXF/0lFefMrYxm/o+59KlS2TevHmkT58+pF27dsTAwIDY2NgQJycnsmLFCpKenq5WfcpCWftGeXk5OXXqFFm0aBFxcnIiZmZmRE9PjxgbG5NevXqRoKAgcv78eYnjQNmuOVxEmWaWlZWVZPr06WLH6dq1K7lz545EbVxEHn1sb2O29QlTUlJCpkyZIlHngAED1KJP2Shj3zh8+HA9GzJxf56enqS4uLhRfdIGLLVfJVQWbBu9BgYGIiYmBkDtTdhff/01+vXrh9evX+Pw4cO4fv06Hj9+DE9PT1y7dq1ZJLYqy0yXbV69eoWxY8fi77//BlBbP33KlCno06cPWrZsicLCQuTl5SEhIUGlutQFW59bXl4eysrKAACWlpYYN24chgwZAnNzc/B4PKSnp+Po0aOorKxEQkIC3NzccPXq1Xq5ZjIjTVQjGniExabR68mTJ5k+NjY25OnTp/We5/P5JDg4mOkzZcoUsdq4iDz62NzGytBHCCECgYCMHj2amX/p0qXk06dPjfYvKChQqT5VoYx9Y+3atcTJyYmcPn2a1NTUiBzn77//JpaWlsw4//M//yOyH5r7KSGbRq/29vZMn7Nnz4rsU15eTmxsbJh+9+7da1QbF5FHH5vbWBLybr/ffvuNmXvOnDlyjSENmvT5svW5STvO6dOn6/3gi0LagNVk0xrYMrPMyclBZmYmgFozy/Hjx4scx9DQELNnz2Yec/lqKltw3UyXEIKff/4ZANCqVSts2LBBZXNzGbY+N2nH8fLyYgoVFhQU4MOHD1K9ThRNNmBJiyQzy7oKEQAkVogQLlLXXNZDpEFdZrrp6elMWZupU6dSpyUZYetz09HRqbdupchYzT5gSTKzFH7ewcFB7Fj29vbQ0dEBADx48ICzGeqqRlYzXbYQtsNydXVFTU0Ndu3ahZEjR8LExASGhobo1KkTZs6cWc8Pk1ILW59bcXExU6urZcuWMDMzk3usJnuVUFokmVnW1dQGgE6dOokdS1dXF1ZWVigoKACPx0NhYSE6duzImlZNRVYzXba4efMm0zY1NcWIESNw48aNen2ePn2Kp0+f4vfff8c//vEPREVFwdDQUGUauQxbn5vwOJ6engpdJW7WAUsaM0vhcr7SVMo0MTFBQUEB89rmHrBkMdNlm5cvXzLt8PBw5ObmonXr1ggNDYWDgwNqamqQnp6OAwcOoLq6GjExMaiqqsKJEydUppGrsPW5PXnyBJGRkczj5cuXK6Sr2QYsac0s6/JMgNoPThLCv84fP35kQanmIqthKNsI/9jk5uaiU6dOSEtLq3d6M2vWLHz99ddwc3PDhw8fEBcXhz/++ANTp05VmU6uwdbnxuPxMGnSJKa+/Lx58zBkyBCFtDXLNSxZzSzraOqlO9hE3m3MJp8biu7evVvkWsyQIUOwfv165vEvv/yidG1cha3Pjc/nY8aMGUyxyUGDBmHjxo0K62t2AauyshITJkxgKkA6OTkhJiam0WAkfMOoNFc3hPsIX2VpTsi6jZWF8Pa3tbXFuHHjGu0bHBwMPT09AMC1a9fqHVk3F9j63AQCAYKCghinoJ49eyI+Pl6qMxRJNKuAJY+ZpbCdmLDNWGM0dysyZZvpyoLw9pdU/NHIyAg9e/YEUHt0kJ+fr0xpnIOtz438Xz37uvrzXbt2ZdWYptkELHnNLIXtxCR9iWtqaphDaSMjI1hZWSkmWsNQhZmuLNQFIKC22KAkhPs0VSNSUbD5uYWHhzP17G1tbZGSksLqftAsApYiZpbCVkvCl8lFkZmZCT6fD6DWg645rXmpykxXFvr378+0pcmuFg5S0gS4pgCbn9uiRYvw66+/AgA6duyIlJQU2NjYsKq3yQcsRc0shbPbhbPeRSGc3S6c9d7UUaWZrix4eXkx7YyMDLF9eTwesrKyANQ63XTu3Fmp2rgAm5/b0qVLmYsVlpaWSElJQZcuXVjVC6Dp3vxMSG0VhVmzZjE3Xvbo0aNRVxFxDBw4kBnj3LlzIvtUVFQ0u5ufCWFvG0tCXn3Dhw9ntCUmJjbaT/hG3zFjxqhMn6pQ1r5BCCErV65kxunQoQN5+PChzGOguVdrEAgEJDQ0lNmQ3bp1I4WFhXKNK1xextbWVmR5mZCQkGZXXobNbSwJebdfcnIyo69Tp04kPz+/QZ8bN26Q1q1bS/xRUoY+VaGsfWPt2rXMOGZmZuT+/ftyjSNtwGqyiaNsmVkCwMSJE/GPf/wDMTExePr0KRwcHBAWFoa+ffvizZs3OHjwIDO2paUlNm3axP4b4iBsbmNl4erqirlz5+K3335Dfn4++vfvj9DQUAwePLhepntVVRUAYPbs2fVOJZsibH1ue/bswffff888Dg8PR05ODnJycsSOM3LkSKnuGhGJNFGNaOARFptmloTUlkieNm2a2Nd27dqVZGZmStTGReTRx/Y2ZltfHXw+n8yfP59oaWmJ1RUeHk6qq6vlmkOTPl+2PrfAwEC5xhG1rdDc62Gxjb6+Po4ePYr4+Hj4+fnB2toa+vr6MDU1xfDhw7Fp0ybcuXMHAwYMULdUymdoa2tj69atuHLlCkJDQ9GtWze0bNkSLVu2RPfu3REaGopbt25h27Zt0NVtsicdTYIm++kow8wSqL3615yuAIpDWdtYWQwbNgzDhg1Ttwy1w9bnFh0djejoaFbGkhZ6hEWhUDQGaqSqIkRp4/P5KCgoQFZWFrKzs5GVlYXHjx8zjiaBgYEICgqSeo7CwkKcPHkSGRkZePXqFaqqqtC+fXv07NkT48aNw8iRI2XSxyXk1cf2NmZTX3R0NA4cOCDzXB4eHjKXaflcH1vb5T//+Y/E/ERhUlNTRf6fGqlyDFHafH19xS5Orlq1SqqxBQIBWb9+PdHR0RE7npeXF3n//r3U+riEvPrY2sbK0Ldq1Sq5Fq3XrFmjsD62tousC++Ngeae1qAJ1N3GU0f79u1hYmIi8bLw56xZswZr1qwBUFsCx9fXFx4eHmjTpg2ePHmCgwcP4uHDh4iPj8fEiRORmJjIVCZo6rC1jZXBtGnTYG9vL7Hf+/fvmaMdLS0tBAYGKjy3MrbLrl27WLvJuTFowFIjjo6O6N27NxwcHODg4IDOnTsjOjoawcHBUo9x//59rF27FkBtiea4uDj4+PjU6xMREYFZs2bh2LFjSEtLw/bt2/Htt9+y+l64ChvbWFn06tULvXr1kthv586dTHvs2LGs1MVXxnZxd3eXWEZcUWjAUiP/+te/FB5j+/btTKG6hQsXNghWQG1y4P79+3HhwgW8ePEC69atwzfffAN9fX2F5+c6bGxjdbN//36mzVag1dTtQq8Sajh19YsAICAgoNF+hoaGTNnf0tJSmRZKKerj77//Zowz2rZtC19fXzUrUi80YGk4z58/Z9rC9Z9EIfz8uXPnlKaJwh7CR1fTp09npWqnJkMDVjOCCKWwqNKBmSIfNTU1TOVOAAgJCVGjGsnMnj0bNjY20NfXR9u2bWFnZ4fZs2fX84dUFBqwNBwLCwumLeyhKArhK0B1tZ8o3OXMmTMoLi4GUFtYb/BgyWlK6uT8+fN49uwZqqqq8P79ezx8+BB79+6Fs7MzfHx8UFpaqvAcdNFdwxk5ciTy8vIAAIcOHcJPP/0ksl9lZSWEk36FLbAo3KTOFxDg9tGVsbExxo0bB0dHR1hbW0NHRwfPnz9HYmIiEhMTAQBnz56Fs7MzLl++rFDJbBqwNJzZs2fj0KFDAIAtW7bA1dW1QXmUmpoahIaGoqioiPkfn89HRUUFdTnmKK9evWLWGVu0aAF/f381KxLN/PnzsWPHDpFmFREREUhPT8eUKVNQXFyM+/fvIyIiAnv27JF7PnpKqOGMGjWK+fWtqamBj48Ppk6dir179+L48ePYsGEDBgwYgCNHjsDExKSe9ZUiluEU5XLo0CHU1NQAAL788kv560cpGQcHB7HOOqNGjcKJEycYf4OoqCjGqEUe6BFWE+C3336DtrY29u7dC4FAgOPHj+P48eP1+pibmyMuLg5jx44FUJvm0BzysDQVTTkdlAYnJye4u7vjzz//BJ/Px59//in3e6I/sU2AFi1aYM+ePbh69SqCg4Pr1Xvq06cPVq5cib///hvdunVDZWUlgPqL9RRuce3aNTx48AAA8MUXX9QzQtFUXFxcmLYiF3zoEVYTQlK9p7NnzzJtrl9xas4I514FBgZCR0dHjWrYQdiJ5+3bt3KPQ4+wmhHCNmSjRo1SoxJKY1RUVCAmJoZ5zIV7HtmALUd0GrCaCWVlZTh69CgAwMDAADNmzFCzIoooYmNjGUPXUaNGoXv37mpWxA4XLlxg2sJu6rJCA1Yz4bvvvmN+5YKDg9VuckoRTVNabK/jypUrzL2r2traCq3J0YDVBMjIyEBZWZnI5/h8PtasWcO48nbs2BGRkZGqlEeRkvz8fKYip7GxMfz8/NSsSDwHDx5EUlJSvVu+PufSpUuYNGkS02fWrFmwtraWe0666K5G8vLysG/fvnr/u3v3LtNOSUlhcnHqmDx5MgYOHFjvf/v378eBAwfg6emJ4cOHo2PHjvj06ROys7Pxxx9/MLfsmJiY4NSpU2jTpo2S3hH3YGsbq4Lo6Ghmx546darY/CZFYWO7ZGRk4JdffoG1tTU8PDzQr18/mJmZNch0r3tPffr0webNmxUTLk1ZUkJLJCuMKG2pqakyl8eNiopqMM68efMkvm7IkCFiXXm5vO0IkV8fW9tYWfrqEAgEpFOnToyGy5cvKzTe53yuj43tsnDhQqlfO2nSJPL69etG9YGWSG4+zJ8/Hx07dkRaWhpycnLw6tUrALW5VoMHD4afnx8mTZpEM9s5TEpKCvLz8wHUlgEaMWKEegVJwZIlS+Dg4IC//vqLMT55/fo1Kisr0aZNG3Tu3BkjRozArFmzMGjQIFbmpAFLjbi4uIg9/5eWnj17Yvny5TI7qTQH2NrGymbs2LEq1cnGdrGyskJAQIDYwpFsQ39yKRSKxkADFoVC0RiokaqK4LI2QDlGmwkJCdiwYYPMWgYMGIAtW7YoXZ8oHj9+jKSkJNy6dQslJSUoLy9HmzZtYGpqir59+2Lw4MEYOnRog9cp8vnm5ubi3LlzuHfvHl68eMGU/enQoQN69+7NXIFTBK5//6iRKsfgsjZClGO0GRUVJZdRaHBwsEr0CcPj8UhYWBjR1tYWO26bNm1Evl6ez5fP55MFCxYQLS0tidtk2rRppKKiQuY5FNGnSkCvElIUgQ2jTVdXV8TFxUnsJxAI4O/vj4qKCgDS3T/HphFoWVkZfHx8mNtHzM3NMXnyZAwaNAitW7fGixcvUFBQgKSkJDx79kzm8Rtj8eLF2Lp1K/P4yy+/hIuLC7744gsUFxfj6tWrOH78OPh8Po4dOwY+nw8un+GoAhqwKCJhw2jTxsYGNjY2EvslJCQwwapbt25S3ZjNphHonDlzmGAVEBCAHTt21Ct0KIywS5Ei5OfnY9u2bQAAHR0dnDt3Du7u7vX6LFiwAEuWLIGzszPKyspw/PhxZGZmSuUW3VShAYsiElUabcpjFMqWvoSEBBw5cgQA4OXlhQMHDjDVMUXRsWNHVuY9f/48Y4Dr6+vbIFjVMWjQIISFheHnn38GAKSnpzfrgEWvElLUSmlpKU6dOgWg9kgjMDBQpfPXmXZoa2tj27ZtYoMVm9S54QCQWJFBuLoBj8dTmiZNgAYsilo5cuQIc2XP3d0dVlZWKpv76dOnzM3GLi4u6Nq1q8rm7tChA9OWtO4m/Hzv3r2VpkkToAGLolbUWU4lPT2dyfZ2dXUFABw7dgzu7u7o0KEDDAwM0LFjR/j6+uK///0vq5noXl5eaNGiBQDgxIkTSEpKEtkvIyMDu3btAlB7JDZ+/HjWNGgidA2Lojbu3LmD27dvAwBMTU0xYcIElc5/8+ZNpt2pUyeMHz8e8fHx9foUFhYiLi4OcXFxcHFxQWxsLNq3b6/w3F988QV+/PFHLFq0CHw+H+7u7vjyyy8xZswY5irhlStXmKuEdnZ2OHnyJPT09BSeW5OhAYuiNoQX22fOnMkccaiKly9fMu3Vq1cjNzcX+vr6CAwMhJOTE3R0dHDz5k3s3bsXZWVlSEtLg5eXF9LT01nRunDhQnTo0AHLli1DQUEBTp8+jdOnT9frY2ZmhvXr12PmzJlo2bKlwnNqOvSUkKIWqqqqmKtzgHqqawq7X+fm5qJdu3a4evUqdu3ahVmzZmHmzJnYvHkzMjMzmbW169evN8jCV4TJkydj8+bNja7dlZSU4Mcff6xX5705QwMWRS2cOnWKKdns4OCA/v37q1xDXVpBHRs2bBBZuK9r167YuXMn81g42VMRHj9+DHt7e0yePBktWrTAwYMH8eLFC1RVVeHFixc4ePAgOnfujNzcXISEhGDFihWszKvJ0IBFUQvCp4Pqql0unBxqYGAgtkyKt7c3cxRUWFiIhw8fKjR3UVERhg0bhgcPHqBbt264efMmAgICYGFhAT09PVhYWCAgIAA3b95krl7+5z//qWfV1hyhAYuicoqKipCYmAhAvQ4+wnZTvXv3hoGBQaN9tbS06h19PX78WKG5161bh9evXzPtxhby27dvj3Xr1jGP67Ljmys0YFFUzoEDB5h7ASdNmqSQT50i9OzZk2lLU+deuE+dFZe8CB8pubm5ie0r/Pz169cVmlfToQGLonKio6OZtjqtrITXzT58+CCxv3CQUtTIo6ioiGm3bt1abF/huWimO4WiQi5dusS4+Nja2mLs2LFq0+Ls7Mw40zx48ACVlZWN9iWEMDljgGJmoED9ICWpAsTTp0+ZdnP3k6QBi6JShDPbg4KCVHbvnigMDQ2ZZNXKykocOnSo0b5nz55FYWEhAKBz584KB6y+ffsy7WPHjontK/z84MGSa9w1ZWjAoqgMHo/H1HPS0p2CxccAAAXnSURBVNKSqyIo26xatQq6urX508uWLUNmZmaDPk+ePMHcuXOZx0uWLFF43unTpzPttWvXIjk5WWS/5ORkrF+/nnmsSsMHLkIz3SkiUYYB6fHjxxmHaldXV3Tq1Ent+nr27In169dj2bJlePv2LYYNG4agoKB6me579uxhdHt4eCAsLExu3XX885//xP79+3Hjxg1UVlbC3d0dX331Fdzd3WFiYoI3b94gMTERJ0+eZPLFPD09MWXKFIXn1mikKUtKaIlkheGyNkKUY7T5OaNGjWL6HjlyhFP6fvjhB6Knpyf29VOmTCE8Hk8qfdLw+vVr4uHhIZV2Pz8/8vHjR5nnUESfKgEtkUzhErm5uUhPTwdQe9XL19dXzYrqs2LFCkycOBG7d+9GYmIinj9/jurqalhYWMDJyQkhISFMRQe2MDExQUJCAs6fP4/ff/8d165dw/Pnz8Hj8WBkZAQbGxsMHz6cubeRQk8JKY3AtgFpt27dWB1PGQapdnZ2rN4nKC1ubm4Sc7EotdBFdwqFojHQgEWhUDQGaqSqIrisDaD6FOVzfWVlZbhx4wYyMzORnZ2NoqIi8Hg8GBoawtzcHH379oWXlxd69eol95wbN26sd4uPOPNYrm8/aqTKMbisjRCqT1GE9W3YsIHo6+tLdfXP39+/0SuPkub73IBVnHks17cf6FVCCkU9ZGdnM8YaXbp0gZubG+zt7WFqaoq3b98iOTkZsbGx4PP5OHz4MIqLixEfHw9tbelWaCoqKjB79mwQQmBkZNSs7i+kAYtCYRktLS14e3tjyZIlGD16dIPbj77++mukp6dj/PjxKCsrQ2JiIg4cOCC1J2NdOWcrKytMnToVmzdvVsbb4CR00Z1CYZkff/wRZ86cgbOzc6P3So4aNQqRkZHMY+EKFuLIyMhgTFW3bt0qsdJDU4MGLAqFZdq1aydVPz8/P6Z97949if1ramoQGhoKPp+PCRMmcC75VhXQgEWhqAnhEs0VFRUS+2/cuBG3b99Gq1atsH37dmVK4yw0YFEoauL+/ftM29bWVmzfnJwcrFmzBkBtSWVra2ulauMqNGBRKGpi9+7dTNvb27vRfoQQhIaGorKyEoMHD0Z4eLgq5HESGrAoFDVw5coVppihgYEBFi1a1Gjf3bt34+LFi9DR0cHu3buho6OjKpmcgwYsCkXFvHz5ElOnTmXqXK1du7bRU7zCwkIsXboUQK1TtLh6Y80BGrAoFBXC4/EwceJEptyyt7c3IiIiGu3/zTff4MOHD7CxscG///1vVcnkLDRgUSgqorKyEhMmTGCsupycnBATE9NortYff/yBU6dOAQB27NjBGGY0Z2jAolBUQFVVFXx9fZGSkgIAcHR0xLlz5xoNQqWlpViwYAGA2nwtHx8flWnlMvTWHApFyVRXV8PPzw/x8fEAgIEDByIhIUFslvrp06fx6tUrAICZmVk992dhLl68WK9d12/o0KEYN24cW2+BM9CARaEokZqaGkyfPp05tevXrx+SkpIkZsMTobJPv/76q1RzpaamIjU1FUDtAn1TDFj0lJBCURJ8Ph8BAQGIjY0FUFuC+fz5883eDFURaMCiUJSAQCBASEgIY4Lao0cPJCcnw9zcXKrXBwUFSVWjbtWqVcxrVq1axfxfHbXpVQENWBQKyxBCEBYWhoMHDwKoNeBITU2FhYWFmpVpPnQNi0JhmZUrV2Lv3r0AAD09PSxYsIBJZRCHu7s7WrZsqWx5Gg0NWBQKy1y5coVpV1dXM+kJksjLy1PIDbs5QE8JKRSKxkCPsCgUlklLS1PZXKtXr8bq1atVNp+6oUdYFApFY5DoS1ivs5bWRwBZypOjMKYAXqtbRCNwWRtA9SkK1acYtoQQM0mdZD0lzCLSmB2qCS0trZtc1cdlbQDVpyhUn2qgp4QUCkVjoAGLQqFoDLIGrN2Su6gVLuvjsjaA6lMUqk8FyLToTqFQKOqEnhJSKBSNgQYsCoWiMdCARaFQNAYasCgUisZAAxaFQtEY/j8zq5faDb8MlQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x123edb4e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Draws the ideal boards, if there is more than one\n",
    "for r in recordBoard:\n",
    "    draw_board(r,record)\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On average a random person will end at 12.451303128159964\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1259b9d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(leafs, bins=range(17, 30, 1))\n",
    "plt.xlabel('Final Number')\n",
    "plt.ylabel('Possible Boards')\n",
    "print('On average a random person will end at {}'.format(np.mean(leafs)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The calculation starting with three ones took significantly longer, about 10 minutes, and the results revealed why, instead of there being 537 nodes, there were 408709 nodes in total. The optimal board result with 3 ones was 28, which is not significantly more than 2 ones, with a lot more computation. Since it took so much longer, I think 4 ones would be take for too much time, it would take days to compute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discussion and Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the recursion through every possible board, I was suprised how few possible boards there actually are. For this simulation, I learned how big this problem grows. Starting with only 2 ones, it is shown optimal board is 16, and for 3 ones, the optimal board is 28. How this would grow for then on is hard to see, as it computationally grows drastically. While creating the recursion I ran into a lot of errors, and next time I would not recreate the whole board each time, as this may be very computationally expensive, so I could just modify it slightly when needed. I learned the ideal solutions for the first two problems, but the second one took 731 times as many calculations to compute, so it could be optimized better. Not every third 1 used when I computed the second problem actaully affected the outcome, so to make this better I could use only the position of ones where they can be reached by the other numbers, no in some distant spot unreachable, so not making the final number any larger. The solutions were satisfying in finally knowing, and are well defined in this problem."
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}