标签: conways-game-of-life

我试图用加速器V2写在F#的生活,但对于一些奇怪的原因,我的输出是不是尽管我所有的数组是方方 - 看起来一切,但一个矩形区域的矩阵的左上角被设置为假.我不知道这是怎么发生的,因为我的所有操作都应该平等对待整个阵列.有任何想法吗？

open Microsoft.ParallelArrays
open System.Windows.Forms
open System.Drawing
type IPA = IntParallelArray
type BPA = BoolParallelArray
type PAops = ParallelArrays
let RNG = new System.Random()
let size = 1024
let arrinit i = Array2D.init size size (fun x y -> i)
let target = new DX9Target()
let threearr = new IPA(arrinit 3)
let twoarr =   new IPA(arrinit 2)
let onearr =   new IPA(arrinit 1)
let zeroarr =  new IPA(arrinit 0)
let shifts = [|-1;-1|]::[|-1;0|]::[|-1;1|]::[|0;-1|]::[|0;1|]::[|1;-1|]::[|1;0|]::[|1;1|]::[]
let progress (arr:BPA) = let …

在哈希生活中,该场通常被视为理论上无限的网格,其中所讨论的图案集中在原点附近.四叉树用于表示场.给定一个2 ^(2k)个单元的平方,一侧为2k,在树的第k级,哈希表在中心存储2 ^(k-1)乘2 ^(k-1)个单元的单元,未来2 ^(k-2)代.例如,对于4x4平方,它存储2x2中心,1代前进; 对于一个8x8的正方形,它存储了4x4中心,前进了2代.

因此,给定一个8x8的初始配置,我们得到一个4x4平方1代正向中心,8x8平方和2x2平方2代正向(1代向前,4x4平方),居中于8x8平方.随着每一代新生代我们对网格的看法减少,反过来我们得到了自动机的下一个状态.在获得最内部的2x2平方2 ^(k-2)代后,我们可以继续前进.

那么Golly的哈希生活将如何永远持续下去？此外,它对该领域的看法似乎从未减少.它似乎显示了2 ^(k-2)代后整个自动机的状态.更多的是,如果随着时间的推移而扩展的起始配置,算法的视图似乎会增加.网格视图缩小以显示不断扩大的自动机？

我过几天再谈。我必须参考蜂窝状原子。我想在幻灯片中显示一些gif，其中显示了细胞自动机的演变，所以我的问题是：如何将模式和通过生活中的愚蠢游戏创建的演变转换为动画gif？

在这次PyCon演讲中,杰克迪德里奇展示了康威生命游戏的这种"简单"实现.我对GoL或半高级Python并不熟悉,但代码似乎很容易掌握,如果不是两件事:

1. 使用yield.我之前已经看到使用yield来创建生成器,但是它们中的8个是新的...它是否返回了8个生成器的列表,或者这个是如何工作的？
2. set(itertools.chain(*map(neighbors, board))).这个明星将结果列表(？)从将邻居应用到董事会中解压缩,并且...我的思绪刚刚爆发.

是否有人试图为程序员解释这两个部分,这些程序员习惯于使用map,filter和reduce将一些python代码混合在一起,但是每天都不使用Python？:-)

import itertools

def neighbors(point):
    x, y = point
    yield x + 1, y
    yield x - 1, y
    yield x, y + 1
    yield x, y - 1
    yield x + 1, y + 1
    yield x + 1, y - 1
    yield x - 1, y + 1
    yield x - 1, y - 1

def advance(board):
    newstate = set()
    recalc = board | set(itertools.chain(*map(neighbors, board)))
    for …

我正在制作一个生活游戏,我用这种方法找到附近的邻居

private int getNeighbours(LifeBoard board, int row, int col){
    if(board.get(row+1, col)){
        neighbours++;
    }
    if(board.get(row-1, col)){
        neighbours++;
    }
    if(board.get(row, col+1)){
        neighbours++;
    }
    if(board.get(row, col-1)){
        neighbours++;
    }
    if(board.get(row+1, col+1)){
        neighbours++;
    }
    if(board.get(row-1, col-1)){
        neighbours++;
    }
    if(board.get(row+1, col-1)){
        neighbours++;
    }
    if(board.get(row-1, col+1)){
        neighbours++;
    }

    return neighbours;
}

我觉得它好像编码严重并且畏缩,所以我的问题是..有没有办法让这更好？现在,它"有点"可行,但我在想是否可以用循环代替它.

谢谢.

这是一个有点理论性的问题。在编程作业中，约翰康威告诉我们要实现生命游戏。作为一项附加任务，我们被要求修改程序，以便它可以检测最多四代的模式重复。例如，给定这个特定的游戏“种子”，程序应该像这样：

 --------
|        | 
|   OOO  |  
|        | 
|        |
|        |
 --------

 --------
|    0   | 
|    1   |  
|    0   | 
|        |
|        |
 --------

 --------
|        | 
|   O2O  |  
|        | 
|        |
|        |
 --------
Repetition detected (2): exiting

表明该程序重复自身并且周期为 2 代。

我的问题是这个。是否有可能真正知道程序何时只是一遍又一遍地重复相同的模式？我听说过“停机问题”。这和那个有关吗？

现在，如果确实有可能，那么教师似乎正在运行的程序如何在重复一次后似乎能够检测到它？其次，期望基础编程课程的学生编写一个程序来检测生命游戏中的重复模式真的合理吗？我有一种感觉，他们的意思是“修改您的程序以在第 4 代窗口内两次达到相同状态时退出”，这在我看来与检测模式是否真的会永远重复完全不同.

编辑：

这是规范所说的：您将修改程序以检测先前模式的重复。您的程序应该能够检测到长达四代的重复模式。当发现这样的重复时，程序应该以不同的消息退出：

Period detected (4): exiting

用括号中的数字表示的周期长度替换“完成”消息。退出前应打印重复的图案。

我已经实现了康威的生命游戏：

def neighbors(point):
    x, y = point
    for i, j in itertools.product(range(-1, 2), repeat=2):
        if any((i, j)):
            yield (x + i, y + j)

def advance(board):
    newstate = set()
    recalc = board | set(itertools.chain(*map(neighbors, board)))

    for point in recalc:
        count = sum((neigh in board)
                for neigh in neighbors(point))
        if count == 3 or (count == 2 and point in board):
            newstate.add(point)

    return newstate

我想可视化结果，所以我尝试修改Matplotlib 动画示例中给定的示例：

glider = set([(0, 0), (1, 0), (2, 0), (0, 1), (1, 2)])

fig, …

我正在关注Rust-wasm教程,我希望能够在生命游戏中轻松地向宇宙中添加一艘船(真正的形状).

作为第一步,我想将形状0或1表示形状的二维数组转换为表示宇宙中形状坐标的索引向量.

我有一段工作代码,但我想让它更方便用户:

const WIDTH: u32 = 64;
const HEIGHT: u32 = 64;

/// glider: [[0, 1, 0], [0, 0, 1], [1, 1, 1]]
fn make_ship(shape: Vec<Vec<u32>>) -> Vec<u32> {
    let mut ship: Vec<u32> = Vec::new();

    for row_idx in 0..shape.len() {
        for col_idx in 0..shape[row_idx].len() {
            let cell = shape[row_idx][col_idx];
            if cell == 1 {
                ship.push(col_idx as u32 + row_idx as u32 * WIDTH);
            }
        }
    }

    ship
}

#[test]
fn glider() {
    let …

我正在研究 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 rows;

    }

    public int numberOfColumns() {
        int countColumns=0;
          for(int i=0;i<1;i++){
             for(int j=0;j<grid[i].length;j++)
                countColumns++;
                columns=countColumns;
          }
          return …

好吧,我正在尝试编写Conway的生活游戏,我从概念上不理解它,即使它看起来很简单.所以:

- 根据我在网上找到的模拟器,这就是Gilder的成就(请原谅我糟糕的油漆)

但我不太明白.让我解释一下:考虑以下网格:

如果我按行继续,我应用规则:

第1区 - >有两个活的邻居(4,5)没有变化.第2区 - >有三个活的邻居(4,5,6)再现和生活.第3区 - >现在有三个活着的邻居(2,5,6),所以他活着.现在情况已经变为:

第二排:第4区 - >有三个住在附近(2,5,7).第5区 - >有五个活的邻居(2,3,4,6,7)死亡.第6区 - >有两个住在附近(2,3)

所以:

第7区 - >在第8区有两个住的邻居(4,11) - >有4个住的邻居(4,6,7,11)没有变化.第9块 - >有2个住的邻居(6,11)没有变化.第10块 - >有2个活的邻居(7,11)没有改变.第11区 - >有1个住在附近(7)死亡.12区 - >没有邻居.不改变.

所以它改为:

请告诉我错误的是什么!:PI疯了!