DouKaku?

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 = -1; y <= 1; y++)
                {
                    if (x == 0 && y == 0)
                        continue;
                    yield return Manager.Get(this, x, y);
                }
            }
        }
    }
    public int AroundAliveCount
    {
        get
        {
            return Around.Count(cell => cell.IsAlive);
        }
    }
    public bool Next
    {
        get
        {
            return IsAlive ?
                AroundAliveCount == 2 || AroundAliveCount == 3 :
                AroundAliveCount == 3;
        }
    }
}