我被分配了这个项目，其中包含以下说明：
生命游戏是为无限大小的网格定义的。在第2章中，我们将Life Grid ADT定义为使用固定大小的网格，用户在其中指定网格的宽度和高度。这足以说明使用二维阵列来实现生命游戏。但是完整的实现应该允许无限大小的网格。使用类似于用于实现稀疏矩阵的方法实现稀疏生命网格ADT。
说实话，我真的不太了解这个概念。能否请一位外行人能理解的简短描述（如果不是简短的代码）？我很感激。
Sparselifegrid.py
""" 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 & column as a list.
"""
pass
def maxRange(self):
"""
Returns the maximum row & 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
这是我的主要文件
""" 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 <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()
答案 0 :(得分：3)
稀疏矩阵是矩阵的表示，其中只有不等于默认值（通常为0）的值的位置存储在存储器中。在Python中表示这样一个矩阵的一种简单方法是使用一个字典，其中键是坐标(x, y)的元组，值是矩阵值。
例如，这个矩阵：
0 0 0 0
0 0 0 0
0 1 0 0
0 0 0 0
可以有以下表示：
matrix = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0]]
sparse_matrix = {(1, 2): 1}
你可以访问这样的值：
for x in xrange(4):
for y in xrange(4):
assert matrix[y][x] == sparse_matrix.get((x, y), 0)
这应该足以让你入门。你的练习要求你在一个类中包含这样一个稀疏矩阵，使它具有与传统矩阵相同的接口。
有更高级的方法可以存储这样的sparse matrix，每个方法在复杂性，内存使用，...之间做出不同的权衡。
答案 1 :(得分：1)
这是Python 2.x中基于简单稀疏矩阵的生命解决方案游戏。您可以将大小设置为系统可以处理的大小。它在x和y方向都包裹着：
class Cell():
def __init__(self, x, y, live=True):
self.x, self.y = x, y
self.live = live
self.around = 0
def __eq__(self, other):
return (self.x, self.y) == (other.x, other.y)
def spawn(self):
self.live = True
self.around = 0
return self
class Grid():
def __init__(self, width, height):
self.xMax = width
self.yMax = height
self.cells = []
self.deltas = [(-1, -1), (0, -1), (1, -1), (1, 0),
(1, 1), (0, 1), (-1, 1), (-1, 0)]
def tick(self):
newCells = self.cells[:]
''' create potential new cells '''
for cell in self.cells:
for dx, dy in self.deltas:
newCell = Cell((cell.x+dx)%self.xMax,
(cell.y+dy)%self.yMax, live=False)
if newCell not in newCells:
newCells.append(newCell)
newCells[newCells.index(newCell)].around += 1
''' spawn new cells for next grid '''
self.cells = []
for cell in newCells:
if (cell.live and cell.around in [2, 3]
or not cell.live and cell.around == 3):
self.cells.append(cell.spawn())
def show(self):
for y in range(self.yMax):
print ''.join('X|' if Cell(x, y) in self.cells
else ' |' for x in range(self.xMax))
print
用法：
>>> glider = [Cell(2,0), Cell(2,1), Cell(2,2), Cell(1,2), Cell(0,1)]
>>> g = Grid(7, 7)
>>> glider = [Cell(2,0), Cell(2,1), Cell(2,2), Cell(1,2), Cell(0,1)]
>>> g.cells = glider
>>> g.show()
| |X| | | | |
X| |X| | | | |
|X|X| | | | |
| | | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
>>> g.tick()
>>> g.tick()
>>> g.show()
| |X| | | | |
| | |X| | | |
|X|X|X| | | |
| | | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
>>> g.tick()
>>> g.tick()
>>> g.show()
| | | | | | |
| | |X| | | |
|X| |X| | | |
| |X|X| | | |
| | | | | | |
| | | | | | |
| | | | | | |