天道酬勤,学无止境

康威的人生游戏没有正确计算邻居(Conway's Game of Life not counting neighbors correctly)

问题

我正在使用 Python 执行标准的康威生命游戏程序。 我在遍历数组时尝试计算邻居时遇到问题。 我创建了打印语句来打印 if 语句的连续性,以及每个语句的计数值。

这是我的代码:(我在整个代码中的 # 中有问题)

import random

numrows = 10
numcols = 10
def rnd():
    rn = random.randint(0,1)
    return rn

def initial():
    grid = []
    count = 0
    for x in range(numrows):
        grid.append([])
        for y in range(numcols):
            rand=random.randrange(1,3)
            if(rand == 1):
                grid[x].append('O')
            else:
                grid[x].append('-')
    for x in grid:    
        print(*x, sep=' ',end="\n") #this prints the random 2d array 

    print("")
    print("")

    answer = 'y'
    newgrid = []
    count = 0

    while(answer == 'y'): # I believe I am going through, checking neighbors
                          # and moving onto the next index inside these for 
                          #loops below
        for r in range(0,numrows):
            grid.append([])
            for c in range(0,numcols):

                if(r-1 > -1 and c-1 > -1): #I use this to check out of bound
                    if(newgrid[r-1][c-1] == 'O'):#if top left location is O
                        count = count + 1        #should get count += 1
                    else:
                        count = count
                print("top left check complete")
                print(count)
                if(r-1 > -1):
                    if(newgrid[r-1][c] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("top mid check complete")
                print(count)
                if(r-1 > -1 and c+1 < numcols):
                    if(newgrid[r-1][c+1] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("top right check complete")
                print(count)
                if(c-1 > -1 and r-1 > -1):
                    if(newgrid[r][c-1] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("mid left check complete")
                print(count)
                if(r-1 > -1 and c+1 < numcols): 
                    if(newgrid[r][c+1] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("mid right check complete")
                print(count)
                if(r+1 < numrows and c-1 > -1):
                    if(newgrid[r+1][c-1] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("bot left check complete")
                print(count)
                if(r+1 < numrows and c-1 > -1):
                    if(newgrid[r+1][c] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("bot mid check complete")
                print(count)
                if(r+1 < numrows and c+1 < numcols):
                    if(newgrid[r+1][c+1] == 'O'):
                        count = count + 1
                    else:
                        count = count
                print("bot right check complete")
                print(count)

# I am not sure about the formatting of the code below, how do I know that
# the newgrid[r][c] location is changing? should it be according to the for-
# loop above? Or should it get it's own? If so, how could I construct it as
# to not interfere with the other loops and items of them?


            if(newgrid[r][c] == '-' and count == 3):
                newgrid[r][c] ='O'

            elif(newgrid[r][c] == 'O' and count < 2):
                newgrid[r][c] = '-'

            elif(newgrid[r][c] == 'O' and (count == 2 or count == 3)):
                newgrid[r][c] = 'O'

            elif(newgrid[r][c] == 'O' and count > 3):
                newgrid[r][c] = '-'

# I'm also confused how to go about printing out the 'new' grid after each
# element has been evaluated and changed. I do however know that after the
# new grid prints, that I need to assign it to the old grid, so that it can
# be the 'new' default grid. How do I do this? 


        for z in newgrid:
            print(*z, sep=' ',end="\n")


        answer = input("Continue? y or n( lower case only): ")

        newgrid = grid

        if(answer != 'y'):
            print(" Hope you had a great life! Goodbye!")

initial()

这是当前的输出和错误消息:

>>> initial() - O - - O - - O - - - O - - O - - - OO - O - - O - OO - O O - - O - - OOOO O - OO - - - OO - O - O - O - O - O - O - OOOO - - O - - - - - OOO - - O OO - O - - O - - - - - OOO - O - - - top left check complete 0 top mid check complete 0 top right check complete 0 mid left check complete 0 mid right check complete 0 bot left check complete 0 bot mid check complete 0 Traceback (most recent call last): File "<pyshell#68>", line 1, in <module> initial() File "C:\Users\Ted\Desktop\combined.py", line 86, in initial if(newgrid[r+1][c+1] == 'O'): IndexError: list index out of range

当我遍历随机数组以查看邻居是什么时,它似乎很好,直到它在检查机器人右邻居时移到 [0][1] 为止。

此外,中间的右邻居应该 + 1 来计数,因为它是活着的。 但是,即使有 if 语句的继承,count 仍然是 0?

问题 1:我怎么可能知道我的 if 条件对于数组所有边的 [r][c] 的每个实例都足够了?

问题 2:我目前的出界检查方法是否最适合我的情况? 在我检查值之前,有没有办法“检查所有超出范围”?

在这一点上,我已经无计可施了。 提前感谢您抽出时间帮助回答我的问题

回答1

您收到该索引错误是因为您的newgrid仅包含一个空行。 并且您在newgrid而不是在grid对邻居进行测试(如 Blckknght 在评论中提到的)。 我已经进行了一些修复,但是还有很多工作可以改进此代码。 看起来它现在可以工作了,但是当你使用随机生命形式时很难说。 :) 我建议给你的程序一些使用已知生活模式的方法,比如闪光灯和滑翔机,看看它们的行为是否正确。

确保newgrid有效的最简单方法是从grid复制它。 如果我们只是做newgrid = grid ,那只会让newgrid成为grid对象的另一个名字。 要正确复制列表列表,我们需要复制每个内部列表。 我的新代码使用copy_grid函数做到了这copy_grid

我已经修复了您在计算邻居部分的if测试中遇到的几个小错误,并且我简化了根据邻居计数更新单元格的逻辑。 我还压缩了制作随机网格的代码,并添加了一个简单的函数,该函数可以从字符串中读取生活模式并从中构建网格。 这让我们可以使用 Glider 测试代码。 我还添加了一个创建空网格的函数。 尽管我在测试期间使用了该功能,但该程序目前并未使用该功能,我想这是一个有用的示例。 :)

import random

# Set a seed so that we get the same random numbers each time we run the program
# This makes it easier to test the program during development
random.seed(42)

numrows = 10
numcols = 10

glider = '''\
----------
--O-------
---O------
-OOO------
----------
----------
----------
----------
----------
----------
'''

# Make an empty grid
def empty_grid():
    return [['-' for y in range(numcols)]
        for x in range(numrows)]

# Make a random grid
def random_grid():
    return [[random.choice('O-') for y in range(numcols)]
        for x in range(numrows)]

# Make a grid from a pattern string
def pattern_grid(pattern):
    return [list(row) for row in pattern.splitlines()]

# Copy a grid, properly!
def copy_grid(grid):
    return [row[:] for row in grid]

# Print a grid
def show_grid(grid):
    for row in grid:
        print(*row)
    print()

def run(grid):
    show_grid(grid)

    # Copy the grid to newgrid.
    newgrid = copy_grid(grid)
    while True:
        for r in range(numrows):
            for c in range(numcols):
                # Count the neighbours, making sure that they are in bounds
                count = 0
                # Above this row
                if(r-1 > -1 and c-1 > -1): 
                    if(grid[r-1][c-1] == 'O'):
                        count += 1
                if(r-1 > -1):
                    if(grid[r-1][c] == 'O'):
                        count += 1
                if(r-1 > -1 and c+1 < numcols):
                    if(grid[r-1][c+1] == 'O'):
                        count += 1

                # On this row
                if(c-1 > -1):
                    if(grid[r][c-1] == 'O'):
                        count += 1
                if(c+1 < numcols): 
                    if(grid[r][c+1] == 'O'):
                        count += 1

                # Below this row
                if(r+1 < numrows and c-1 > -1):
                    if(grid[r+1][c-1] == 'O'):
                        count += 1
                if(r+1 < numrows):
                    if(grid[r+1][c] == 'O'):
                        count += 1
                if(r+1 < numrows and c+1 < numcols):
                    if(grid[r+1][c+1] == 'O'):
                        count += 1

                # Update the cell in the new grid
                if grid[r][c] == '-':
                    if count == 3:
                        newgrid[r][c] ='O'
                else:
                    if count < 2 or count> 3:
                        newgrid[r][c] = '-'

        # Copy the newgrid to grid
        grid = copy_grid(newgrid)
        show_grid(grid)

        answer = input("Continue? [Y/n]: ")
        if not answer in 'yY':
            print(" Hope you had a great life! Goodbye!")
            break

#grid = random_grid()
grid = pattern_grid(glider)
run(grid)

这段代码确实可以正常工作,但仍有很大的改进空间。 例如,这是run()的改进版本,它通过使用几个循环来压缩邻居计数部分。

def run(grid):
    show_grid(grid)

    # Copy the grid to newgrid.
    newgrid = copy_grid(grid)
    while True:
        for r in range(numrows):
            for c in range(numcols):
                # Count the neighbours, making sure that they are in bounds
                # This includes the cell itself in the count
                count = 0
                for y in range(max(0, r - 1), min(r + 2, numrows)):
                    for x in range(max(0, c - 1), min(c + 2, numcols)):
                        count += grid[y][x] == 'O'

                # Update the cell in the new grid
                if grid[r][c] == '-':
                    if count == 3:
                        newgrid[r][c] ='O'
                else:
                    # Remember, this count includes the cell itself
                    if count < 3 or count > 4:
                        newgrid[r][c] = '-'

        # Copy the newgrid to grid
        grid = copy_grid(newgrid)
        show_grid(grid)

        answer = input("Continue? [Y/n]: ")
        if not answer in 'yY':
            print(" Hope you had a great life! Goodbye!")
            break
回答2

要计算邻居,只需遵循这个简单的规则。 您将拥有当前单元格的行和列。 使用这种形式的两个数组,一个用于行,另一个用于列。 下面是你的逻辑。

您可以在此处通过演示视频找到详细的实现。

this.neibhours = function() {
  var rows = [row-1, row, row+1];
  var cols = [col-1, col, col+1];
  neibhourCells = [];

  for(var i=0; i < rows.length; i++) {
    for(var j=0; j < cols.length; j++) {
      if(!(col === cols[j] && row === rows[i])) {
        var cell = new Cell(rows[i], cols[j])
        if(cell.isOnGrid()) {
          neibhourCells.push(cell);
        }
      }
    }
  }

  return neibhourCells;
}

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 康威的生命游戏,计算邻居[关闭](Conway's Game of Life, counting neighbors [closed])
    问题 这个问题不太可能对任何未来的访客有帮助; 它只与一个小的地理区域、一个特定的时间点或一个非常狭窄的情况相关,通常不适用于互联网的全球受众。 如需帮助使此问题更广泛地适用,请访问帮助中心。 8 年前关闭。 我的代码中某处有错误,我想我进入了一个无限循环。 基本上我得到一个矩阵和两个索引,i,j,我需要计算 [i][j] 周围有多少邻居的值为 1 或 2。 这是我的代码: int number_of_living_neighbors(matrix mat,int i, int j, int n,int m) { int counter=0,row_index=0,column_index=0; for(row_index=i-1;row_index<=i+1;row_index++) { for(column_index=j-1;column_index=j+1;column_index++) { if((row_index>=0)&&(row_index<n)&&(column_index>=0)&&(column_index<m)) { if((mat[row_index][column_index]==1)||(mat[row_index][column_index]==2)) counter++; if((row_index==i)&&(column_index==j)&
  • 包装在康威的生命游戏 C++(Wrapping in Conway's Game of Life C++)
    问题 我正在尝试编写一个在 20x60 单元板上实现康威生命游戏的程序。 网格将环绕,因此左侧将连接到(相邻)右侧,顶部将连接到底部。 因此,任何位置为(1, col)单元格都将在(maxRow, col)处有一个邻居。 任何位置为(row, 1)单元格都将在(row, maxCol)处有一个邻居。 以下函数应该计算相邻单元格的数量。 它适用于不在边缘的坐标,但不适用于边缘的坐标。 例如,如果在(1, 10) 、 (1, 11)和(1, 12)和(1, 10)处有点被传递到函数中,它将返回一个高数作为邻居计数而不是1 . { int i, j; int count = 0; for (i = row - 1; i <= row + 1; i++) for (j = col - 1; j <= col + 1; j++) count += grid[i][j]; } if (row==maxrow-1 || row==0) count = count+ grid [(row-(maxrow-1))*-1][col-1]+grid[(row-(maxrow-1))*-1][col]+grid[(row-(maxrow-1))*-1][col+1]; if (col==0 || col==maxcol-1) count=count +grid[row-1][(col-(maxcol-1)
  • 计算邻居时康威的生活游戏越界 - java(Conway's game of life out of boundaries when counting neighbours - java)
    问题 我正在尝试用 Java 创建生命游戏,但我很难编写检查邻居数量的部分。 我知道问题是当程序到达网格的边缘时它不会工作,因为索引大于/小于数组的边界。 所以问题出在我的 Neighbours() 上。 我不知道如何修复它,我尝试扩展 if 语句,并且还尝试将整个语句集放入 while 循环中。 除非网格边缘有活细胞,否则该程序似乎正在运行。 对此有何建议? 提前致谢。 import java.io.*; import java.util.Scanner; public class LifeGrid { public int[][] grid; public int[][] newgrid; public int getX() { return grid[0].length; } public int getY() { return grid.length; } public int getcurrentgen() { return currentgen; } public int currentgen=0; // modify neighbours out of boundary problem. int Neighbours(int x, int y) { int neighbours = 0; if (grid[y][x-1] == 1) { neighbours++; }
  • javascript中的康威生活游戏(最佳溶胶[关闭](Conway game of life in javascript( best sol [closed])
    问题 很难说出这里问的是什么。 这个问题模棱两可、含糊不清、不完整、过于宽泛或言辞激烈,无法以目前的形式合理回答。 如需帮助澄清此问题以便重新打开它,请访问帮助中心。 8 年前关闭。 我正在为康威生命游戏编写代码......我正在使用 2> 阵列一个 fr 老一代。 和第 2 代之一。 **规则是:生命游戏的宇宙是一个无限的二维正交方格网格,每个方格都处于两种可能的状态之一,生或死。 每个单元格与其八个相邻单元格相互作用,这些单元格是水平、垂直或对角相邻的单元格。 在每一步,都会发生以下转变: **1. 任何具有少于两个活邻居的活细胞都会死亡,好像是由人口不足造成的。 2.任何有两个或三个活邻居的活细胞都会传给下一代。 3.任何有超过三个活邻居的活细胞都会死亡,就像过度拥挤一样。 4.任何只有三个活邻居的死细胞都会变成活细胞,就像通过繁殖一样。** 初始模式构成了系统的种子。 第一代是通过将上述规则同时应用于种子中的每个细胞来创建的——出生和死亡同时发生,发生这种情况的离散时刻有时称为滴答(换句话说,每一代都是前一个)。 规则继续重复应用以创造更多世代。** 这是代码 我得到了一个解决方案,但我想它没有给我正确的解决方案,因为它没有检查角落的邻居。 我已经标记了那部分 ** window.conway = { }; window.conway.maingame = { }
  • 康威的生命游戏更新(下一代)(Conway's Game of Life Update(Next Generation))
    问题 我正在研究 Conway 的生命游戏 Java 代码,并且我在我的更新方法(也称为下一代创建者)方面遇到了困难。 我将发布我到目前为止编写的代码,请让我知道我可以做些什么来修复更新方法。 如果在时间 T 1 没有一个细胞并且它的三个邻居正好活着,那么一个细胞就会诞生。 如果在时间 T 1 有两个或三个邻居,则现有单元格保持活动状态 如果在时间 T 1 的邻居少于两个,则细胞会因孤立而死亡。 如果在时间 T 1 有三个以上的邻居,一个细胞会因过度拥挤而死亡。 public class GameOfLife { private char [][] grid; private int rows; private int columns; public GameOfLife(int rows, int columns) { grid=new char[rows][columns]; for(int i=0;i<grid.length;i++) { for(int j=0;j<grid[i].length;j++) grid[i][j]=' '; } } public int numberOfRows() { int countRows=0; for(int i=0;i<grid.length;i++){ countRows++; rows=countRows; } return
  • 为什么康威的生命游戏可以归类为通用机器?(Why can Conway’s Game of Life be classified as a universal machine?)
    问题 我最近阅读了有关人造生命的文章,并看到了这样的说法:“康威的生命游戏展示了足够的复杂性,可以归类为通用机器。” 我对什么是通用机器只有一个粗略的理解,而维基百科只是让我像维基百科一样接近理解。 我想知道是否有人可以对这个非常性感的声明有所了解? 对我来说,康威的人生游戏似乎是一种可爱的分散注意力的东西,具有一些巨大的影响:我无法在计算器和计算器之间实现飞跃? 这甚至是我应该做出的飞跃吗? 回答1 你可以用康威的生活建造一台图灵机——尽管这会非常可怕。 关键在于滑翔机(和相关模式)——它们沿着运动场(缓慢)移动,因此可以表示比特流(滑翔机的存在代表 1,不存在代表 0)。 可以构建其他模式以接收两个滑翔机流(以直角)并发出与原始两个流的 AND/OR/etc 相对应的另一个比特流。 编辑:LogiCell 网站上有更多相关内容。 回答2 Paul Rendell 在 Life 中实现了图灵机。 滑翔机代表信号,它们之间的交互是门和逻辑,它们一起可以创建实现图灵机的更大组件。 基本上,任何可以实现 AND、OR 和 NOT 的自动机器都可以以足够复杂的方式组合在一起,以实现图灵完备。 这不是一种有用的计算方式,但它符合标准。 回答3 康威的“生命”可以走得更远:不仅可以构建一个实现通用图灵机的生命模式,还可以构建一个冯诺依曼“通用构造函数”:http://conwaylife
  • 优化Conway的“生活游戏”(Optimizing Conway's 'Game of Life')
    问题 为了进行实验,我(很久以前)实现了Conway的《人生游戏》(并且我知道这个相关问题!)。 我的实现通过保留2个布尔数组来表示“最后状态”和“状态正在更新”(每次迭代都会交换2个数组)而起作用。 虽然这相当快,但是我经常想知道如何优化它。 例如,一种想法是在迭代N处预先计算可以在迭代(N + 1)处修改的区域(这样,如果一个单元格不属于这样的区域,则甚至不考虑在该区域进行修改)迭代(N + 1))。 我知道这很模糊,而且我从来没有花时间去研究细节…… 您是否有关于如何优化(速度)生命游戏迭代的想法(或经验!)? 回答1 我将引用另一个问题的答案,因为我提到的各章提供了一些非常有趣且经过微调的解决方案。 是的,一些实现细节是用c和/或汇编语言编写的,是的,但是在大多数情况下,算法可以在任何语言下工作: 迈克尔·阿布拉什(Michael Abrash)的《图形程序员的黑皮书》的第17章和第18章是我有过的最有趣的读物之一。 这是跳出框框思考的课程。 整本书确实很棒,但是对生命游戏的最终优化解决方案是令人难以置信的编程工作。 回答2 有一些超快的实现(从内存中)将8个或更多相邻正方形的单元表示为位模式,并使用它作为一大批预先计算的值的索引,以在单个机器指令中确定单元是活的还是死的。 在这里查看: http://dotat.at/prog/life/life.html 还有XLife
  • Code Golf:康威的人生游戏(Code Golf: Conway's Game of Life)
    问题 已锁定。 该问题及其答案被锁定,因为该问题是题外话,但具有历史意义。 它目前不接受新的答案或互动。 挑战:编写最短的程序来实现John H. Conway的《生命游戏》细胞自动机。 [关联] 编辑:经过大约一周的比赛,我选择了一个胜利者: pdehaan ,他们设法用perl击败了Matlab解决方案一个角色。 对于那些还没有听说过“生命游戏”的人,您可以选择一个正方形(最好是无限大)的方格网格。 细胞可以是活的(填充的)或死亡的(空的)。 通过应用以下规则,我们可以确定在下一个步骤中哪些细胞还活着: 任何具有少于两个活邻居的活细胞都会死亡,好像是由于人口不足造成的。 任何具有三个以上活邻居的活细胞都会死亡,就像人满为患一样。 任何有两个或三个活邻居的活细胞都可以存活到下一代。 具有正好三个活邻居的任何死细胞都将变成一个活细胞,就像通过繁殖一样。 您的程序将读取指定为命令行参数的40x80字符ASCII文本文件,以及要执行的迭代次数(N)。 最后,它将在N次迭代后将系统状态输出到ASCII文件out.txt。 这是运行相关文件的示例: in.txt: ................................................................................
  • 生命游戏 ArrayIndexOutofBounds(Game of Life ArrayIndexOutofBounds)
    问题 我正在做康威的生活游戏。 我很确定我Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1 at game.of.life.GameOfLife.generation(GameOfLife.java:77) at game.of.life.GameOfLife.main(GameOfLife.java:32) Java Result: 1完成了,但是当我运行它时,我Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1 at game.of.life.GameOfLife.generation(GameOfLife.java:77) at game.of.life.GameOfLife.main(GameOfLife.java:32) Java Result: 1得到Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1 at game.of.life.GameOfLife.generation(GameOfLife.java:77) at game.of.life.GameOfLife.main
  • 请帮助我对康威生命游戏的基本java实现(Please help with my basic java implementation of Conway's game of life)
    问题 我花了很长时间试图编写一个程序来实现康威的生活游戏 - 链接更多信息。 . 我正在遵循一些在线指南,并获得了大部分功能。 我编写了如下所示的“next”和“neighbors”方法。 谁能告诉我这些是否是好的实现,以及如何使它们变得更好? 练习的重点是不要修改或更改任何其他方法,只需编写下一个方法! :) import java.io.*; import java.util.Random; public class Life { private boolean[][] cells; public static void main( String[] args ) { Life generation = new Life( ); for (int i = 0; i != 10; i++) { System.out.println( generation ); generation.next( ); } } // Constructors public void next (){ int SIZE; SIZE=cells.length; boolean[][] tempCells = new boolean [SIZE] [SIZE]; for( int i=0; i<SIZE; i++ ) { for( int j=0; j<SIZE; j++ ) { tempCells[i]
  • HDLbits答案更新系列10(3.2 Sequential Logic 3.2.4 More Circuits)
    目录 前言 3.2.4 More Circuits 3.2.4.1 Rule 90(Rule90) 3.2.4.2 Rule 110(Rule110) 3.2.4.3 Conway's Game of Life 16x16(Conwaylife) 结语 HDLbits网站链接 前言 今天更新一个小节内容,这个小节内容总共有三道题,题目很少,但是有很强的技巧性,下面我们就开始吧。 3.2.4 More Circuits 3.2.4.1 Rule 90(Rule90) module top_module( input clk, input load, input [511:0] data, output [511:0] q ); always@(posedge clk)begin if(load)begin q <= data; end else begin q <= {1'b0, q[511:1]} ^ {q[510:0], 1'b0}; end end /* //second way reg [513:0] q_com; integer i; always@(posedge clk)begin if(load)begin q_com <= {1'b0, data, 1'b0}; end else begin for(i = 0; i <= 511; i = i + 1)begin
  • 另一个生命游戏问题(无限网格)?(another Game of Life question (infinite grid)?)
    问题 我一直在玩 Conway 的生命游戏,最近发现了一些惊人的快速实现,例如 Hashlife 和 Golly。 (在此处下载 Golly - http://golly.sourceforge.net/) 我无法理解的一件事是编码人员如何实现无限网格? 我们不能保持任何东西的无限阵列,如果你运行 golly 并让几架滑翔机飞过边缘,等待几分钟然后缩小,你会看到仍然在太空中的滑翔机逃跑,那么,以上帝的名义,这个无穷大的概念是如何以编程方式处理的呢? 是否有记录良好的模式或什么? 非常感谢 回答1 在这种情况下,可以用某种类型的稀疏矩阵来表示活节点。 例如,如果我们存储一个(LivingNode, Coordinate)对的列表,而不是一个Nodes数组,其中每个Nodes要么是活的要么是死的,我们只是在改变Coordinates而不是增加数组的大小。 因此,为此所需的空间与LivingNodes的数量LivingNodes 。 此解决方案不适用于活动节点数量不断增加的状态,但它对滑翔机非常有效。 编辑:所以这是我的头顶。 事实证明,维基百科有一篇文章展示了一个经过深思熟虑的解决方案。 那好吧! :) 享受。 回答2 维基百科对此进行了解释。 基本思想是康威的生命游戏表现出局部性,因为与图案大小相比,信息以缓慢的速度传播,并且填充单元格的最大密度约为任何区域中单元格的 1/2。
  • 数据结构与程序设计——C++语言描述(Data Structures & Program Design in C++) by Robert L.Kruse & Alexander J.Ryba
    第1章程序设计原理 率章首先慨述良好程序设计的重要原理,特别是它们在大型项目中的应用;然后介绍用 于发现有救算法的方法,如面向对象的设计和白顶向下的设计。在此过程中,我们提出将在 后继章节中论述的程序设计和数据存储方法方面的问题,并通过使用c'+编写程序,复习一 下这门语言的一些基本特性。 1 1简介 编写大型计算机程序的最大困难不在于确定此程序的目标是什么,也不在于找出达到 此目标的方法。某个企业的总裁可能会说:“让我们用一台计算机来记录所有的存货信息、 账目报告和人事文件,并让它告诉我们何时需要再次订购存货,以及何时花费超出了预算 线,并且还可以让它处理工资单。”花上充足的时间和精力,系统分析和程序设计员就可以确 定企业的各个职员现在是如何完成这些任务的,然后就编写程序用同样的方式来完成这些 工作, …大型程序的问题 然而,这种方法几乎必定是灾难性的失败。当系统分析员去谛』查职员时,他会发现某 些工作可必轻易地放Iijj算机七去执行,于是他就这样做了。然后,当他们将其他工作移 到计算机上时,往往发现它依赖于最初的那些任务。遗憾的是,这些f务的输出却或多或 少地没有采用正确的格式,因此他们需要更多的程序设计,以将数椐从一个任务给定的格 式转换成另一个任务需要的格式。这个程序设计项目开始变得像是一床由各色布片拼缀 成的被子,其中一些布片较牢,而另一些布片较弱
  • 为什么我的生命游戏(使用处理)中的世代乱序?(Why are the generations in my Game of Life (using Processing) out of order?)
    问题 import processing.core.PApplet; import static java.lang.System.out; public class GoL2 extends PApplet { int rectSideLength = 25; // rectSideLength = length of each side of the rectangles drawn that represent cells int generation = 0; int windowWidth = 1920; int windowHeight = 950; int[][] currentGeneration = new int[windowWidth][windowHeight]; // currentGeneration = 2D array to gold cell values of current generation int[][] nextGeneration = new int[windowWidth][windowHeight]; // nextGeneration = 2D array to hold cell values of next generation int sumOfNeighbors; int temporarySumOfNeighbors
  • 流免费游戏的求解算法(Algorithm for solving Flow Free Game)
    问题 我最近开始玩Flow Free Game。 将匹配的颜色与管道连接以创建流。 配对所有颜色,并覆盖整个电路板,以解决Flow Free中的每个难题。 但是请注意,如果管道交叉或重叠,管道将断裂! 我意识到这只是给定点对之间的寻路游戏,条件是没有两条路径重叠。 我有兴趣为游戏编写解决方案,但不知道从哪里开始。 我曾考虑过使用回溯功能,但是对于很大的电路板尺寸来说,时间复杂度很高。 有没有合适的算法可以有效地解决游戏问题。 使用试探法解决问题可以帮助吗? 请给我一个提示,从哪里开始,我将从那里开始。 我在大多数董事会中观察到 对于最远的点,您需要沿着边沿。 对于彼此最接近的点,如果有一条,则遵循直接路径。 这是正确的观察,可以有效地解决吗? 回答1 减免SAT 基本思路 将问题简化为SAT 使用现代的SAT求解器解决问题利润 复杂 NP中的问题很明显:如果您猜出一个电路板的星座,很容易(多次)检查它是否可以解决问题。 它是否是NP困难的(意味着与NP中的其他所有问题一样困难,例如SAT),尚不清楚。 当然,现代的SAT求解器无论如何都不会关心和解决大型实例(我想最大可达100x100)。 有关数字链接的文献 在这里,我只是将Nuclearman的评论复制到OP: 搜索“数字链接的SAT公式”和“数字链接的NP完整性”会产生一些参考。 毫不奇怪,两个最有趣的是日语。
  • Java 中的生命游戏,人口过剩但不知道为什么(Game of Life in Java, Overpopulation but can't figure out why)
    问题 这是家庭作业。 我在底部包含了相关代码。 问题:为了让用户调整网格的大小,现在绘制的网格严重过度。 屏幕截图: “人口过剩” - http://i.imgur.com/zshAC6n.png “预期人口” - http://i.imgur.com/5Rf6P42.png 背景:这是康威生命游戏的一个版本。 在课堂上,我们完成了 3 个类:处理游戏逻辑的 LifeState、包含游戏的 JPanel 的 LifePanel,以及创建 JFrame 并添加 LifePanel 的驱动程序。 任务是将其开发为具有各种要求的完整 GUI 应用程序。 我的解决方案是扩展 JFrame 并在该类中完成我的大部分工作。 在 actionlistener 之外初始化 LifePanel 会产生正常人口,但在 actionlistener 中初始化 LifePanel 会“过度填充”网格。 问题:为什么会出现人口过剩? 生活面板类 import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.util.Random; public class LifePanel extends JPanel implements MouseListener { private int row; private int
  • 【元胞自动机】元胞自动机之生命游戏【Matlab 595期】
    一、简介 1 元胞自动机CA 元胞自动机(cellular automata,CA) 是一种时间、空间、状态都离散,空间相互作用和时间因果关系为局部的网格动力学模型,具有模拟复杂系统时空演化过程的能力。其中,元胞自动机又称为细胞自动机,而生命游戏(Game of Life)又是一种十分典型的CA。 以下是我做的笔记,CA一共有四个要点: 2 生命游戏 The Game of Life (生命游戏) ,是由英国数学家 John Horton Conway于1970年提出的。作为元胞自动机系统,生命游戏是一个零玩家游戏,用户确定初始状态与演变的规则后,无须其他操作,便可模拟得到形态的演变过程。 元胞自动机的基本思想可以追溯到上世纪Von Neumann在“Theory of Self-Reproducing Automata”提出的“机器繁殖”一概念:由一群细胞构成的小机器根据一些简单规则和初始图形进行演化的动力系统,机器可以不断自我进化和延续。 3 生命游戏的MatLab实现 我认为网上大多数代码都没有考虑到边界问题,所以我进行了一定的改进。 游戏规则在注释有详细解释,一共有三条。 下面这个表格帮助大家理解:(想象一下左下角是原点坐标) 二、源代码 %元胞自动机之生命游戏 %规则:假设元胞只有生和死两种状态 %1. 如果一个活细胞周围(包括对角相邻)有2或3个细胞为生
  • 你见过或做过的最酷的黑客攻击是什么? [关闭](What's the coolest hack you've seen or done? [closed])
    问题 就目前而言,这个问题不适合我们的问答形式。 我们希望答案得到事实、参考或专业知识的支持,但这个问题可能会引起辩论、争论、投票或扩展讨论。 如果您认为此问题可以改进并可能重新打开,请访问帮助中心以获取指导。 9年前关闭。 作为程序员,我们都编写了一个非常酷的程序或以有趣的方式拼凑一些硬件来解决问题。 今天我在思考这些 hack 以及它们中的一些是如何被现代技术弃用的(例如,您不再需要 hack 您的 Tivo 来添加网络端口)。 在软件世界中,我们现在认为在网页上拖放之类的事情是理所当然的,但不久前这也是一个非常令人兴奋的黑客攻击。 我见过的最巧妙的硬件黑客之一是几年前由一家电信公司的前同事完成的。 他的办公室里有一台小型便携式电视,他会在工作时整天看它。 为了摆脱它,他将一个开关连接到通过他桌子底下的脚启动的开/关。 您个人见过或做过的最酷的硬件或软件黑客攻击是什么? 你现在在做什么黑客? 回答1 我记得这个 hack 是 Bob Smith 写的,他做了一个名为 386MAX(或“386 to the Max”)的旧 DOS 时代内存管理器。 它不是产品的一部分,而是一个他制作并张贴在某处的小实用程序。 但是,在网络上,我能找到的对这种技术的唯一参考是 Robert Collins 于 1996 年 11 月的 DDJ Undocumented Corner 专栏。 问题
  • HDLBits刷题合集—14 More Circuits
    HDLBits刷题合集—14 More Circuits HDLBits-117 Rule90 Problem Statement Rule90是一个具有有趣性质的一维元胞自动机。 规则很简单。有一个一维的元胞阵列(开或关)。在每个时间步中,每个单元的下一个状态是单元的两个当前相邻单元的异或。更详细的表达这个规则的方法是下表,其中一个单元格的下一个状态是它自己和它的两个邻居的函数: LeftCenterRightCenter’s next state11101101101010010111010000110000 名称“Rule90”来自于读取“下一个状态”列:01011010是十进制90。 在这个电路中,创建一个512单元的系统(q[511:0]),并在每个时钟周期中前进一个时间步长。load输入表明系统状态应该载入data[511:0]。假设边界(q[-1]和q[512])都为零(off)。 代码如下: module top_module( input clk, input load, input [511:0] data, output [511:0] q ); always @(posedge clk) begin if (load) q <= data; else q <= {q[511:1]} ^ {q[510:0], 1'b0}; end endmodule
  • 解决游戏“Globs”/flood fill/“FloodIt”的算法和数据结构(Algorithm and data structure for solving the game “Globs”/flood fill/“FloodIt”)
    问题 提出解决游戏 Glob 的算法和数据结构 (http://www.deadwhale.com/play.php?game=131)。 它以一种极客的方式非常有趣。 用 N 表示您的方法的时空复杂度(大 O) ,即网格的大小 (N>=14)。 低复杂度的足够好的高效算法是首选。 (MatrixFrog 正确地指出这个游戏也被称为 FloodIt,Smashery 在 3 个月前在他下面引用的链接中给出了一个解决方案。所有你们这些家伙建议只用 1 个前瞻进行修剪/贪婪,这给出了次优的解决方案。) 游戏生成一个由 nxn 个节点组成的随机方形网格,其中每个节点的颜色为六种颜色之一(Grn=1、Ylw=2、Red=3、Blu=4、Pur=5、Orn=6)。 级别 1 有 9x9 网格,然后 n 增加每个级别,最多 14。每个级别您最多可以进行 25 回合,否则您将失败。 在每一轮你选择哪种颜色将左上角的节点更改为例如 Grn->Red,这样新颜色的任何连接的相邻(水平/垂直)节点都会被同化成一个形状,并且每个同化的节点 1 pt 被添加到你的分数。 评分目标是在尽可能少的回合内完成每个网格,例如,如果您在 16 回合内完成,那么您的 9 个未使用的动作 => 2*9 乘以您的总累积分数。 显然有很多方法可以分解它,默认选择使用 14x14 网格的递归回溯是一个可行的竞争者;