title: Infinite Board: Conway's Game of Life - Python
body: <p>I was assigned this project with instructions below:</p>
  
  <blockquote>
    <p>The game of Life is defined for an infinite-sized grid. In Chapter 2, we defined the Life Grid ADT to use a fixed-size grid in which the user specified the width and height of the grid. This was sufficient as an illustration of the use of a 2-D array for the implementation of the game of Life. But a full implementation should allow for an infinite-sized grid. Implement the Sparse Life Grid ADT using an approach similar to the one used to implement the sparse matrix.</p>
  </blockquote>
  
  <p>I honestly don't really understand the concept that well. Could you please give me a brief description (if not brief code) that a layman can understand? I would appreciate it.</p>
  
  <p>Sparselifegrid.py</p>
  
  <pre><code>""" My initial GameOfLife code
      Feb 27, 2013
      Sparse Matrix code specially designed for Game of Life
  """
  class SparseLifeGrid:
  
      def __init__(self):
          """
          "pass" just allows this to run w/o crashing.
          Replace it with your own code in each method.
          """
          pass 
  
      def minRange(self):
          """
          Return the minimum row &amp; column as a list.
          """
          pass
  
      def maxRange(self):
          """
          Returns the maximum row &amp; column as a list.
          """
          pass 
  
      def configure(self,coordList):
          pass 
  
      def clearCell(self,row, col):
          pass 
  
      def setCell(self,row, col):
          pass 
  
      def isValidRowCol(val1,val2):
          pass 
  
      def isLiveCell(self,row, col):
          pass 
  
      def numLiveNeighbors(self, row,col):
          pass 
  
  
      def __getitem__(self,ndxTuple):
          pass 
  
      def __setitem__(self,ndxTuple, life):
          """
          The possible values are only true or false:
          True says alive, False for dead.
          """
          pass 
  
      def _findPosition(self,row,col):
          pass 
  
      def __repr__(self):
          pass 
  
      def __str__(self):
          """
          This method will only print the non-empty values,
          and a row and column outside the non-empty values.
          """
          pass 
  
      def evolve(self):
          """
          Return the next generation state.
          """
          pass 
  
      def hasOccurred(self):
          """
          Check whether  this current state has already occured.
          If not, return False.  If true, return which generation number (1-10).
          """
          pass 
  
      def __eq__(self,other):
          """
          This is good method if we want to compare two sparse matrices.
          You can just use sparseMatrixA == sparseMatrixB because of this method. 
          """
          pass
  
      def printLifeGrid(lifeGrid):
          """
          Print a column before and after the live cells
          """
          s=""
          maxRange=lifeGrid.maxRange()
          minRange=lifeGrid.minRange()
          for i in range(minRange[0]-1,maxRange[0]+2):
              for j in range(minRange[1]-1,maxRange[1]+2):
                  s+=" "+str(lifeGrid[i,j])
              s+="\n"
          print(s)
  
  
  class _GoLMatrixElement:
      """
      Storage class for one cell
      """
      def __init__(self,row,col):
          pass 
  
      def __str__self(self):
          pass 
  
      def __eq__(self,other):
          pass 
  </code></pre>
  
  <p>Here's my main file</p>
  
  <pre><code>""" Marcus Brown's  initial GameOfLife code
      Feb 27, 2013
  """
  from SparseLifeGrid_Key import SparseLifeGrid
  import sys
  
  
  # You'll probably need to add some other stuff like global variables
  
  
  """ ####################################################
          Don't change anything below this line: readPoints or main
  """ ####################################################
  
  def readPoints(lifeGrid):
      """
      Reads the locations of life and set to the SparseMatrix
      """
      print("1. Enter positions of life with row,col format (e.g., 2,3).")
      print("2. Enter empty line to stop.")
  
      life=input()
      coordList=[]
      while life:
          points=life.split(",")
          try:    
              coord=[int(points[0]),int(points[1])]
              coordList.append(coord)
          except ValueError:
              print("Ignored input:" + life+ ", row, col not valid numbers")
          except:
                  print("Unexpected error:", sys.exc_info()[0])
          print("added, keep entering or enter empty line to stop.")
          life=input()
      print("Thanks, finished entering live cells")
      lifeGrid.configure(coordList)
  
  
  
  
  def main():
      """
      Runs for ten generations if a stable (repeating) state is not found.
      """
      lifeGrid= SparseLifeGrid()
      readPoints(lifeGrid)
      lifeGrid.printLifeGrid()
      patterns=0
      i=0
      while i &lt;10 and patterns == 0:
          """
          Evolve to the next generation
          """
          lifeGrid.evolve()
          """
          Check whether this generation is a repetition of any of the
          previous states.
          If yes return the previous matching generation (1-10).
          """
          patterns=lifeGrid.hasOccurred()
          if patterns != -1:
              break
          i+=1
          lifeGrid.printLifeGrid()
  
      if i==10:
          print("No pattern found")
      else: 
  
          print("Pattern found at: " + str(i)+ " of type: " + str(patterns))
  
  main()
  </code></pre>