DouKaku?

using System;

public class LifeGame {
    private int time_ = 0;
    private readonly bool[][] matrix_;

    public LifeGame(int rows, int cols) {
        Random random = new Random();
        matrix_ = new bool[rows][];
        for (int rowIndex = 0; rowIndex < rows; rowIndex++) {
            matrix_[rowIndex] = new bool[cols];
            for (int index = 0; index < cols; index++) {
                if (random.NextDouble() < 0.3) {
                    matrix_[rowIndex][index] = true;
                }
            }
        }
    }

    public int Time {
        get {
            return time_;
        }
    }
    public String GetDisplayMatrix() {
        System.Text.StringBuilder builder = new System.Text.StringBuilder();
        foreach (bool[] row in matrix_) {
            foreach (bool cell in row) {
                builder.AppendFormat("[{0}]", cell? "*": " ");
            }
            builder.Append('\n');
        }
        return builder.ToString();
    }


    public void NextStep() {
        bool[][] oldMatrix = CopyMatrix(matrix_);
        for (int rowIndex = 0; rowIndex < matrix_.Length; rowIndex++) {
            for (int colIndex = 0; colIndex < matrix_[rowIndex].Length; colIndex++) {
                matrix_[rowIndex][colIndex] = Next(rowIndex, colIndex, oldMatrix);
            }
        }
        time_++;
    }
    private bool[][] CopyMatrix(bool[][] matrix) {
        bool[][] result = new bool[matrix.Length][];
        for (int index = 0; index < matrix.Length; index++) {
            result[index] = new bool[matrix[index].Length];
            matrix[index].CopyTo(result[index], 0);
        }
        return result;
    }
    private bool Next(int row, int col, bool[][] matrix) {
        bool now = matrix[row][col];
        int count = GetCell(matrix, row - 1, col - 1)
                + GetCell(matrix, row - 1, col)
                + GetCell(matrix, row - 1, col + 1)
                + GetCell(matrix, row, col - 1)
                + GetCell(matrix, row, col + 1)
                + GetCell(matrix, row + 1, col - 1)
                + GetCell(matrix, row + 1, col)
                + GetCell(matrix, row + 1, col + 1);
        if (now) {
            return (count == 2 || count == 3);
        } else {
            return (count == 3);
        }
    }
    private int GetCell(bool[][] matrix, int rowIndex, int colIndex) {
        int y = rowIndex;
        while (y < 0) y += matrix.Length;
        while (y >= matrix.Length) y -= matrix.Length;

        bool[] row = matrix[y];
        int x = colIndex;
        while (x < 0) x += row.Length;
        while (x >= row.Length) x -= row.Length;

        return row[x]? 1: 0;
    }


    [STAThread]
    static void Main(string[] args) {
        LifeGame game = new LifeGame(10, 10);

        Console.WriteLine("t={0}", game.Time);
        Console.WriteLine(game.GetDisplayMatrix());
        game.NextStep();
        Console.WriteLine("t={0}", game.Time);
        Console.WriteLine(game.GetDisplayMatrix());

        Console.ReadLine();
    }
}

//http://ja.doukaku.org/126/ 投稿用

//Wikipediaライフゲーム
//http://ja.wikipedia.org/wiki/%E3%83%A9%E3%82%A4%E3%83%95%E3%82%B2%E3%83%BC%E3%83%A0

using System;
using System.Collections.Generic;
class LifeGame {
    const int SIZE = 10;//変更したらCellクラスのSIZEも要変更
    static void Main(string[] args) {
        string start =
@"
□■□□□□■□□□
■□□□□■□□□□
■■■□□■■■□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□";//SIZE * SIZEの文字列
        start = start.TrimStart(new char[] { '\n', '\r' });//最初の改行を取り除く
        char[][] field = new char[SIZE][];//ライフゲームテーブル
        List<Cell> cells = new List<Cell>();//セル

        //startをfieldにセットする
        for(int y = 0; y < SIZE; y++) {//行でループ
            field[y] = start.Split(new char[] { '\n' })[y].ToCharArray();//改行で分割して文字配列にしてセット
        }

        //fieldからCellを生成
        for(int y = 0; y < SIZE; y++) {//field縦ループ
            for(int x = 0; x < SIZE; x++) {//field横ループ
                cells.Add(new Cell(field, x, y, field[y][x] == '■'));//Cellに座標をセットしてcellsに追加
            }
        }

        //メインループ
        while(true) {
            //出力
            Console.Clear();
            foreach(char[] str in field) {
                Console.WriteLine(str);
            }

            System.Threading.Thread.Sleep(300);//ウェイト            

            //次回の生死を判定、セット
            foreach(Cell cell in cells) {
                cell.SetNextLife();
            }

            //判定した生死をfieldに反映
            foreach(Cell cell in cells) {
                cell.SetField();
            }
        }
    }
}

//各セルのデータ
class Cell {
    const int SIZE = 10;//変更したらLifeGameクラスのSIZEも要変更
    char[][] Field;

    //位置
    int X;
    int Y;

    bool Life;//状態
    bool NextLife;//次回の状態(一時保存用)

    public Cell(char[][] field, int x, int y, bool life) {
        Field = field;
        X = x;
        Y = y;
        Life = life;
    }

    //次回の生死を判定
    public void SetNextLife() {
        switch(GetCount()) {
        case 3://誕生、維持
            NextLife = true;
            break;
        case 2://維持
            NextLife = Life;
            break;
        default://死亡
            NextLife = false;
            break;
        }
    }

    //判定した生死をfieldに反映
    public void SetField() {
        Field[Y][X] = NextLife ? '■' : '□';
        Life = NextLife;
    }

    //セル周囲の生きているセルをカウント
    private int GetCount() {
        int count = 0;
        for(int y_ = -1; y_ <= 1; y_++) {
            for(int x_ = -1; x_ <= 1; x_++) {
                if(!(x_ == 0 && y_ == 0)) {
                    int locationX = GetRoopLocation(X, x_);
                    int locationY = GetRoopLocation(Y, y_);
                    if(Field[locationY][locationX] == '■') count++;
                }
            }
        }
        return count;
    }

    //fieldの端と端を繋ぐ
    private int GetRoopLocation(int location, int direction) {
        switch(location + direction) {
        case -1:
            return SIZE - 1;
        case SIZE:
            return 0;
        default:
            return location + direction;
        }
    }
}

//http://ja.doukaku.org/126/ 投稿用

//Wikipediaライフゲーム
//http://ja.wikipedia.org/wiki/%E3%83%A9%E3%82%A4%E3%83%95%E3%82%B2%E3%83%BC%E3%83%A0

using System;
using System.Collections.Generic;
class LifeGame {
    const int SIZE = 10;//変更したらCellクラスのSIZEも要変更
    static void Main(string[] args) {
        string start =
@"
□■□□□□■□□□
■□□□□■□□□□
■■■□□■■■□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□
□□□□□□□□□□";//SIZE * SIZEの文字列
        start = start.TrimStart(new char[] { '\n', '\r' });//最初の改行を取り除く
        char[][] field = new char[SIZE][];//ライフゲームテーブル
        List<Cell> cells = new List<Cell>();//セル

        //startをfieldにセットする
        //for(int y = 0; y < SIZE; y++) {//行でループ
        //    field[y] = start.Split(new char[] { '\n' })[y].ToCharArray();//改行で分割して文字配列にしてセット
        //}

        //ランダムにfieldを生成
        Random rnd = new Random();
        for(int j = 0 ;j<SIZE;j++) {
            field[j] = new char[SIZE];
            for(int i = 0; i < SIZE;i++ ) {
                field[j][i] = rnd.Next(0, 100) <= 30 ? '■' : '□';
            }
        }

        //fieldからCellを生成
        for(int y = 0; y < SIZE; y++) {//field縦ループ
            for(int x = 0; x < SIZE; x++) {//field横ループ
                cells.Add(new Cell(field, x, y, field[y][x] == '■'));//Cellに座標をセットしてcellsに追加
            }
        }

        //メインループ
        while(true) {
            //出力
            Console.Clear();
            foreach(char[] str in field) {
                Console.WriteLine(str);
            }

            System.Threading.Thread.Sleep(300);//ウェイト            

            //次回の生死を判定、セット
            foreach(Cell cell in cells) {
                cell.SetNextLife();
            }

            //判定した生死をfieldに反映
            foreach(Cell cell in cells) {
                cell.SetField();
            }
        }
    }
}

//各セルのデータ
class Cell {
    const int SIZE = 10;//変更したらLifeGameクラスのSIZEも要変更
    char[][] Field;

    //位置
    int X;
    int Y;

    bool Life;//状態
    bool NextLife;//次回の状態(一時保存用)

    public Cell(char[][] field, int x, int y, bool life) {
        Field = field;
        X = x;
        Y = y;
        Life = life;
    }

    //次回の生死を判定
    public void SetNextLife() {
        switch(GetCount()) {
        case 3://誕生、維持
            NextLife = true;
            break;
        case 2://維持
            NextLife = Life;
            break;
        default://死亡
            NextLife = false;
            break;
        }
    }

    //判定した生死をfieldに反映
    public void SetField() {
        Field[Y][X] = NextLife ? '■' : '□';
        Life = NextLife;
    }

    //セル周囲の生きているセルをカウント
    private int GetCount() {
        int count = 0;
        for(int y_ = -1; y_ <= 1; y_++) {
            for(int x_ = -1; x_ <= 1; x_++) {
                if(!(x_ == 0 && y_ == 0)) {
                    int locationX = GetRoopLocation(X, x_);
                    int locationY = GetRoopLocation(Y, y_);
                    if(Field[locationY][locationX] == '■') count++;
                }
            }
        }
        return count;
    }

    //fieldの端と端を繋ぐ
    private int GetRoopLocation(int location, int direction) {
        switch(location + direction) {
        case -1:
            return SIZE - 1;
        case SIZE:
            return 0;
        default:
            return location + direction;
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        LifeGame lg = new LifeGame(10, 10, 0.3, true);
        short i = 1;
        while (i != 0)
        {
            Console.Clear();
            Console.WriteLine("t = {0}", i++);
            lg.outputConsole();
            lg.scanField();

            System.Threading.Thread.Sleep(100);
        }
    }
}

class LifeGame
{
    public const int DEAD = 0;
    public const int ALIVE = 1;
    //横の長さ
    private int width_;
    public int Width{get{return width_;}}
    //縦の長さ
    private int height_;
    public int Height{get{return height_;}}
    //フィールド
    private int[,] field;
    //間引きのON(true)、OFF(false)
    private bool skipPixelFlag;

    public LifeGame(int w, int h, double rate, bool flag)
    {
        width_ = w;
        height_ = h;
        skipPixelFlag = flag;
        field = new int[w, h];
        createField(rate);
        //デバッグ用
        //width_ = 10;
        //height_ = 10;
        //field = new int[10, 10]
        //{
        //    {0,1,0,0,0,0,0,0,0,0},
        //    {0,0,1,0,0,0,0,0,0,0},
        //    {1,1,1,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0},
        //    {0,0,0,0,0,0,0,0,0,0}
        //};
    }

    //ランダム生成
    private void createField(double rate)
    {
        int count = (int) (Width * Height * rate);
        Random random = new Random();
        do
        {
            int w = random.Next(Width), h = random.Next(Height);
            if (field[w, h] == DEAD) field[w, h] = ALIVE; else continue;
            count--;
        } while (count > 0);
    }

    //次の世代作成
    public void scanField()
    {
        int[,] temp = new int[Width, Height];
        for (int i = 0; i < Width; i++)
            for (int j = 0; j < Height; j++)
            {
                int value = aroundField(i, j);

                if (value == 3) temp[i, j] = ALIVE;
                else if (value == 2) temp[i, j] = field[i, j];
                else temp[i, j] = DEAD;
            }

        field = (int[,]) (temp.Clone());
        if (skipPixelFlag) skipPixelField();//間引き
    }

    //間引き
    //といっても、これでいいのか不明。
    //周りに4個以上ALIVEがあったらその枡をDEADにする
    private void skipPixelField()
    {
        for (int i = 0; i < Width; i++)
            for (int j = 0; j < Height; j++)
            {
                int value = aroundField(i, j);
                if (value > 4) field[i, j] = DEAD;
            }

    }

    //周りの生きてる枡の数
    private int aroundField(int w, int h)
    {
        int sum = 0;
        for (int i = w - 1; i <= w + 1; i++)
            for (int j = h - 1; j <= h + 1; j++)
                if (i != w || j != h)
                    sum += field[getIndex(i, Width), getIndex(j, Height)];
        return sum;
    }

    //ループインデックス作成
    private int getIndex(int n, int max)
    {
        return (n + max) % max;
    }

    //出力
    public void outputConsole()
    {
        for (int i = 0; i < Width; i++)
        {
            for (int j = 0; j < Height; j++)
            {
                Console.Write((field[i, j] == ALIVE) ? "■" : "□");
            }
            Console.WriteLine();
        }
        Console.WriteLine();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data.Linq;
using System.Drawing;
using System.Diagnostics;

public class LifeGame
{
    static void Main(string[] args)
    {
Start:
        Setting.Size = 10;      //格子サイズ
        Setting.InitRandomRate = 0.3; //人口密度
        Setting.Log = LogType.All;

        CellManager cm;

        Console.Clear();
        Console.WriteLine("seed = ?");
        int seed=0, wait = 50;
        int.TryParse(Console.ReadLine(), out seed);

        //---------------------------------------------------------------------
        cm = new CellManager(seed);
        int step = 0, step2 = 0;
        string last = string.Empty;//こうちゃくしたら止めるため
        while (true)
        {
            Console.WriteLine("seed = {0}---間引きなし:step={1}---間引きあり:step={2}", seed, step, step2);
            WriteSet(cm);
            step++;
            System.Threading.Thread.Sleep(wait);
            cm.ToNext();
            Console.Clear();
            if (cm.AliveCount == 0 || last == cm.EqualFlag)
                break;
            last = cm.EqualFlag;
        };

        Console.WriteLine("間引きあり : M/手動, M以外/自動");
        bool manual = Console.ReadKey().Key == ConsoleKey.M;
        Console.Clear();

        cm = new CellManager(seed);
        while (true)
        {
            Console.WriteLine("seed = {0}---間引きなし:step={1}---間引きあり:step={2}", seed, step, step2);
            cm.Cull_2();//間引き
            WriteSet(cm);
            step2++;
            if (manual)
                Console.ReadKey();
            else
                System.Threading.Thread.Sleep(wait);
            cm.ToNext();
            Console.Clear();
            if (cm.AliveCount == 0 || last == cm.EqualFlag)
                break;
            last = cm.EqualFlag;
        };
        Console.WriteLine("seed = {0}---間引きなし:step={1}---間引きあり:step={2}", seed, step, step2);

        //-----間引きしたときの生存数up率のn回の平均値を出してみるテスト。-------
        //int n = 100;
        //Setting.InitRandomRate = 0.3; //人口密度
        //Setting.Log = LogType.All;

        //Console.WriteLine("回数 = ?");
        //int.TryParse(Console.ReadLine(), out n);

        //var avg = Enumerable.Range(seed, n).Select(
        //    (seedValue, idx) =>
        //    {
        //        WriteState(string.Format("seed={0}", seedValue));
        //        WriteState("non cull");
        //        cm = new CellManager(seedValue);
        //        double nonCull = Test(cm);
        //        WriteState("cull");
        //        cm = new CellManager(seedValue);
        //        cm.Cull_2();
        //        double cull = Test(cm);

        //        var up = nonCull != 0 ? ((cull / nonCull) - 1.0d) * 100 : cull;
        //        WriteSimple(string.Format("間引きすると生存数は{0}% up", up));
        //        WriteState("**************************************************");
        //        if (double.IsInfinity(up))
        //            throw new InvalidOperationException();
        //        WriteNon(idx.ToString());
        //        return up;
        //    }
        //).Average();
        //WriteSimple(string.Format("平均 = {0}% up", avg));
        //---------------------------------------------------------------------

        Console.WriteLine("もう一度? y/n");
        if (Console.ReadKey().Key == ConsoleKey.Y)
            goto Start;
    }
    static int Test(CellManager cm)
    {
        WriteSet(cm);

        cm.ToNext();
        WriteState("next");
        WriteSet(cm);
        WriteState("-------------------");
        return cm.AliveCount;
    }
    static void WriteSet(CellManager cm)
    {
        WriteFigure(cm.CellLines);
        WriteState(string.Format("生存数={0} ", cm.AliveCount));
    }

    static void WriteFigure(IEnumerable<IGrouping<int,Cell>> data)
    {
        if ((Setting.Log & LogType.All) != LogType.All)
            return;
        foreach (var group in data)
        {
            var lineString = new string(group.Select(c => c.IsAlive ? '■' : '□').ToArray());
            Console.WriteLine(lineString);
        }
    }
    static void WriteNon(string text)
    {
        if (Setting.Log == LogType.Non) 
            Console.WriteLine(text);
    }
    static void WriteState(string text)
    {
        if((Setting.Log & LogType.State) == LogType.State)
            Console.WriteLine(text);
    }
    static void WriteSimple(string text)
    {
        if((Setting.Log & LogType.Simple) == LogType.Simple)
            Console.WriteLine(text);
    }
}

[Flags]
public enum LogType
{
    Non     = 0x000 ,   //表示しない（進捗のみ）
    Simple  = 0x001 ,   //最低限の数値
    State   = 0x011 ,   //詳細な数値
    All     = 0x111     //詳細な数値と図形
}
static public class Setting
{
    static public int Size { get; set; }
    static public int MatrixSize
    {
        get { return Size * Size; }
    }
    static public LogType Log { get; set; }
    static public double InitRandomRate { get; set; }
}
static public class CorrectExtension
{
    static public int CorrectValue;
    static public int Correct(this int a)
    {
        while (a < 0) a += Setting.Size;
        return a % Setting.Size;
    }
}
public class CellManager
{
    Random rand;
    List<Cell> data;

    public int AliveCount { get { return data.Count(cell => cell.IsAlive); } }
    public IEnumerable<Cell> Cells
    {
        get
        {
            return data.AsEnumerable();
        }
    }
    public IEnumerable<IGrouping<int, Cell>> CellLines
    {
        get
        {
            return Cells.GroupBy(c => Get(c).Y).OrderBy(gp => gp.Key);
        }
    }
    public string EqualFlag
    {
        get
        {
            return new string(data.Select(c => c.IsAlive ? '1' : '0').ToArray());
        }
    }

    public Cell newCell(bool alive)
    {
        return new Cell { Manager = this,IsAlive = alive };
    }

    public CellManager(int seed)
    {
        rand = new Random(seed);
        data = new List<Cell>();
        for (int i = 0; i < Setting.MatrixSize; i++)
        {
            data.Add(newCell(rand.NextDouble() < Setting.InitRandomRate));
        }
    }
    public CellManager(IEnumerable<bool> initData)
    {
        if (initData.Count() != Setting.MatrixSize)
            throw new ArgumentException();
        data = new List<Cell>(initData.Select(isAlive => newCell(isAlive )));
    }

    public void ToNext()
    {
        var nextData = data.Select(d => d.Next).ToArray();
        for (int i = 0; i < nextData.Length; i++)
        {
            data[i].IsAlive = nextData[i];
        }
    }

    // 間引き
    public void Cull_2()
    {
        //生きているやつをリストアップする。
        var aliveNoList = data.Where(cell => cell.IsAlive).Select(cell => data.IndexOf(cell)).ToArray();
        foreach (var no in aliveNoList)
        {
            //自分は次回生きてるか。
            var nextMe = data[no].Next;
            //現在の自分の回りの生存数
            var nowAround = data[no].AroundAliveCount;
            //次回の回りの生存数。
            var nowNext = data[no].Around.Count(c => c.Next);
            //死んでみる
            data[no].IsAlive = false;
            //自分が死んだ場合の次回の回りの生存数
            var testNext = data[no].Around.Count(c => c.Next);
            //回りの生存するが増えるなら死ぬ
            if (testNext > (nowNext + (nextMe ? 1 : 0)))
                continue;
            ////減らない（＝同じ）で、4つ以上いたらどうせ死ぬから先に死ぬ
            // ※これやると、人口率0.3では下がりますが、人口率0.9ではこれがないと↑の間引きだけじゃうまくできない。
            //if (testNext == (nowNext + (nextMe ? 1 : 0)) && !nextMe)
            //    continue;
            data[no].IsAlive = true;
        }
    }

    // 間引き
    // 全パターンを調べてみる。遅すぎて論外でした。そもそも動くのかわかりません。
    public void Cull_1()
    {
        //生きているやつをリストアップする。
        var aliveNoList = data.Where(cell => cell.IsAlive).Select(cell => data.IndexOf(cell)).ToArray();
        int min = int.MaxValue;
        UInt64 minPattern = 0;//64個より多いとダメだけど、とりあえず気にしない。

        for (UInt64 patten = 0; patten <= UInt64.MaxValue; patten++)
        {
            //パターン対象を殺してみる
            for (int i = 0; i < aliveNoList.Count(); i++)
            {
                if ((patten&(((UInt64)1) << i)) != 0)
                {
                    data[aliveNoList[i]].IsAlive = false;
                }
            }
            //次回死んでいる数を調べ、最小ならパターン番号を覚える
            var a = data.Count(c => !c.Next);
            if (data.Count(c => !c.Next) < min)
            {
                min = a;
                minPattern = patten;
            }
            //パターン対象を戻す。
            for (int i = 0; i < aliveNoList.Count(); i++)
            {
                if ((patten & ((UInt64)1 << i)) != 0)
                {
                    data[aliveNoList[i]].IsAlive = true;
                }
            }
            //人数分のパターンが終わったので辞める。
            if ((patten & (((UInt64)1) << aliveNoList.Count())) != 0)
                break;
        }
        //最小パターンで殺す。
        for (int i = 0; i < aliveNoList.Count(); i++)
        {
            if ((minPattern & (((UInt64)1) << i)) != 0)
            {
                data[aliveNoList[i]].IsAlive = false;
            }
        }
    }

    public Point Get(Cell target)
    {
        int idx = data.IndexOf(target);
        if (idx < 0)
            throw new ArgumentException();

        return new Point(idx % Setting.Size, idx / Setting.Size);
    }
    public Cell Get(int x, int y)
    {
        return data[y.Correct() * Setting.Size + x.Correct()];
    }

    public Cell Get(Cell target, int offsetX, int offsetY)
    {
        var pos = Get(target);
        return Get(pos.X + offsetX, pos.Y + offsetY);
    }
}


public class Cell
{
    public CellManager Manager { get; set; }
    public bool IsAlive { get; set; }
    
    public IEnumerable<Cell> Around
    {
        get
        {
            for (int x = -1; x <= 1; x++)
            {
                for (int y