コードゴルフ：コンウェイの人生のゲーム

https://stackoverflow.com/questions/3499538

29-09-2019
|

質問

チャレンジ： ジョン・H・コンウェイを実装する最短のプログラムを書く 人生のゲーム セルラーオートマトン。 [リンク]

編集： 約1週間の競争の後、私は勝利者を選びました： Pdehaan, 、Matlabソリューションを倒すことを管理します 1 Perlのキャラクター。

ゲームオブライフのことを聞いたことがない人のために、あなたは正方形のセルのグリッド（理想的には無限）を服用します。細胞は生きている（埋められた）または死んでいる（空）。次のルールを適用することにより、次の時間の段階でどのセルが生きているかを決定します。

2人未満の生きている隣人のライブセルは、不十分な人口によって引き起こされるかのように死にます。
3つ以上のライブネイバーが亡くなったライブセルは、あたかも過密で亡くなります。
2〜3人のライブネイバーがいるライブセルは、次世代に暮らしています。
正確に3つの生きている隣人を持つ死んだセルは、まるで再生のようにライブセルになります。

プログラムは、コマンドライン引数として指定された40x80文字ASCIIテキストファイルと、実行する反復数（n）で読み取ります。最後に、ASCIIファイルに出力されます。TXTn反復後のシステムの状態。

関連するファイルを使用して実行する例を次に示します。

in.txt：

................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
..................................XX............................................
..................................X.............................................
.......................................X........................................
................................XXXXXX.X........................................
................................X...............................................
.................................XX.XX...XX.....................................
..................................X.X....X.X....................................
..................................X.X......X....................................
...................................X.......XX...................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................

100回繰り返します：

Q:\>life in.txt 100

結果の出力（out.txt）

................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
..................................XX............................................
..................................X.X...........................................
....................................X...........................................
................................XXXXX.XX........................................
................................X.....X.........................................
.................................XX.XX...XX.....................................
..................................X.X....X.X....................................
..................................X.X......X....................................
...................................X.......XX...................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................
................................................................................

ルール：

ファイルI/Oを使用してファイルを読み書きする必要があります。
入力ファイルと反復数を引数として受け入れる必要があります
指定された形式でout.txt（存在する場合は上書き）を生成する必要があります
君 しないでください ボードの端に対処する必要があります（ラップアラウンド、無限のグリッド.etc）
編集：あなた行う出力ファイルにnewlinesが必要です。

勝者は文字カウントによって決定されます。

幸運を！

解決

Perl、127 129 135 chars

さらに数人のキャラクターを取り除くことができました...

$/=pop;@b=split'',<>;map{$n=-1;@b=map{++$n;/
/?$_:($t=grep/X/,@b[map{$n+$_,$n-$_}1,80..82])==3|$t+/X/==3?X:'.'}@b}1..$/;print@b

他のヒント

Mathematica- 179 163 154 151 chars

    a = {2, 2, 2};
    s = Export["out.txt", 
       CellularAutomaton[{224, {2, {a, {2, 1, 2}, a}}, {1,1}}, 
                (ReadList[#1, Byte, RecordLists → 2>1] - 46)/ 42, #2]〚#2〛
       /. {0 → ".", 1 → "X"}, "Table"] &

読みやすさのために追加されたスペース

一緒に呼び出します

    s["c:\life.txt", 100]

アニメーション：

alt text

また、時間の経過とともに平均母集団のグラフを取得することもできます。

alt text

からグライダーを生成するための素晴らしいパターンウィキペディア

私の知る限り Mathematicaは、セルラーオートマトンを使用して乱数を生成します使用ルール30。

Matlab 7.8.0（R2009A） - 174 171 161 150 138 131 128 124文字

関数構文：（124文字）

読みやすいバージョンは次のとおりです（より良いフォーマットのために不必要なNewlinesとWhitespaceが追加されています）：

function l(f,N),
  b=char(importdata(f))>46;
  for c=1:N,
    b=~fix(filter2(ones(3),b)-b/2-3);
  end;
  dlmwrite('out.txt',char(b*42+46),'')

そして、これがMATLABコマンドウィンドウからプログラムの実行方法を示します。

l('in.txt',100)

コマンド構文：（130文字）

コマンド構文で関数を呼び出すことについてのコメントの後、私はもう少し深く掘りました できる 実際にコマンドライン形式で呼び出されました（いくつかの制限付き）。あなたは毎日何か新しいことを学びます！

function l(f,N),
  b=char(importdata(f))>46;
  for c=1:eval(N),
    b=~fix(filter2(ones(3),b)-b/2-3);
  end;
  dlmwrite('out.txt',char(b*42+46),'')

そして、これがMATLABコマンドウィンドウからプログラムの実行方法を示します。

l in.txt 100

追加の課題：ツイート可能なGIFメーカー-136文字

キャラクターを140未満に保ちながら、テキストファイルの代わりに出力をGIFファイルにダンプできるかどうかを確認してください。これがうまくフォーマットされたコードです：

function l(f,N),
  b=char(importdata(f))>46;
  k=ones(3);
  for c=1:N+1,
    a(:,:,:,c)=kron(b,k);
    b=~fix(filter2(k,b)-b/2-3);
  end;
  imwrite(~a,'out.gif')

それでも imwrite デフォルトで無限にループするGIFを作成することになっています。GIFは1回だけループしています。おそらく、これはMATLABの新しいバージョンで修正されたバグです。したがって、アニメーションを長持ちさせ、進化のステップを見やすくするために、フレームの遅延をデフォルトの値（約0.5秒と思われる）を残しました。以下は、を使用したGIF出力ですゴスパーグライダーガンパターン：

alt text

改善

更新1： マトリックスを変更しました b 論理的な（つまり「ブール」）タイプから数値のタイプまで、いくつかの変換を取り除きます。
更新2： ファイルをロードするためのコードを短縮し、機能を使用しました魔法より少ない文字で畳み込みカーネルを作成するためのトリックとして。
更新3： インデックス作成ロジックを簡素化し、置き換えました ~~b+0 と b/42, 、および交換します 'same' と 's' の議論として Conv2 （そして驚くべきことにまだ機能していました！）。
更新4： 私は最初にオンラインで検索するべきだったと思います。ローレン数学からゴルフと人生のゲームについてブログを書いています今年の初め。私はそこで議論されているいくつかのテクニックを組み込みました、それが私が変える必要がありました b 論理マトリックスに戻ります。
更新5： a Aslak Grinstedからのコメント上記のブログ投稿では、ロジックと畳み込みの実行の両方のさらに短いアルゴリズムを示唆しています（関数を使用してフィルター2）、だから私は彼の提案を「取り込んだ」（「コピー」」と述べた。 ;）
更新6： の初期化から2つの文字をトリミングしました b 1つの追加の文字を保存するために、ループでロジックを作り直しました。
更新7： エリック・サンプソンは電子メールで私が交換できると指摘しました cell2mat と char, 、4文字を保存します。エリックに感謝します！

ルビー1.9- 189 178 159 155 153 chars

f,n=$*
c=IO.read f
n.to_i.times{i=0;c=c.chars.map{|v|i+=1
v<?.?v:('...X'+v)[[83,2,-79].map{|j|c[i-j,3]}.to_s.count ?X]||?.}*''}
File.new('out.txt',?w)<<c

編集：4枚のcharでnewlinesを処理します。
さらに7を削除できます（v<?.?v:）ライブセルがエッジに到達したときに、それをclobberニューラインに許可する場合。

Python -282 Chars

ボールを転がすかもしれません...

import sys
_,I,N=sys.argv;R=range(3e3);B=open(I).read();B=set(k for k in R if'A'<B[k])
for k in R*int(N):
 if k<1:b,B=B,set()
 c=sum(len(set((k+o,k-o))&b)for o in(1,80,81,82))
 if(c==3)+(c==2)*(k in b):B.add(k)
open('out.txt','w').write(''.join('.X\n'[(k in B)-(k%81<1)]for k in R))

Python 2.x -210/234文字

さて、210文字のコードは一種の不正行為です。

#coding:l1
exec'xÚ=ŽA\nÂ@E÷sŠº1ƒÆscS‰ØL™Æª··âî¿GÈÿÜ´1iÖ½;Sçu.~H®J×Þ-‰Ñ%ª.wê,šÖ§J®dê˜²>cÉZË¢Vä€»Eîa¿,vKAËÀåÌƒ<»Gce‚ÿ‡ábUt¹)G%£êŠ…óbÒüíÚ¯GÔ/n×Xši&Ä‡:})äðtÏÄJÎòDˆÐÿG¶'.decode('zip')

おそらく、このコードをコピーして貼り付けて動作させることはできません。ラテン-1（ISO-8859-1）であるはずですが、途中でどこかにWindows-1252に倒錯したと思います。さらに、ブラウザはASCII以外の文字の一部を飲み込む場合があります。

したがって、それが機能しない場合は、普通の7ビット文字からファイルを生成できます。

s = """
23 63 6F 64 69 6E 67 3A 6C 31 0A 65 78 65 63 27 78 DA 3D 8E 41 5C 6E C2
40 0C 45 F7 73 8A BA 31 13 AD 83 15 11 11 C6 73 08 63 17 05 53 89 D8 4C
99 C6 AA B7 B7 AD E2 EE BF 47 C8 FF DC B4 31 69 D6 BD 3B 53 E7 75 2E 7E
48 AE 4A D7 DE 90 8F 2D 89 AD D1 25 AA 2E 77 16 EA 2C 9A D6 A7 4A AE 64
EA 98 B2 3E 63 C9 5A CB A2 56 10 0F E4 03 80 BB 45 16 0B EE 04 61 BF 2C
76 0B 4B 41 CB C0 E5 CC 83 03 3C 1E BB 47 63 65 82 FF 87 E1 62 55 1C 74
B9 29 47 25 A3 EA 03 0F 8A 07 85 F3 62 D2 FC ED DA AF 11 47 D4 2F 6E D7
58 9A 69 26 C4 87 3A 7D 29 E4 F0 04 74 CF C4 4A 16 CE F2 1B 44 88 1F D0
FF 47 B6 27 2E 64 65 63 6F 64 65 28 27 7A 69 70 27 29
"""

with open('life.py', 'wb') as f:
    f.write(''.join(chr(int(i, 16)) for i in s.split()))

これの結果は、有効な210文字のPythonソースファイルです。ここでやったのは、元のPythonソースコードでzip圧縮を使用することだけです。本当のチートは、結果の文字列でASCII以外の文字を使用しているということです。それはまだ有効なコードであり、それはただ面倒です。

非抑制バージョンの重量は234文字であり、これはまだ立派なと思います。

import sys
f,f,n=sys.argv
e=open(f).readlines()
p=range
for v in p(int(n)):e=[''.join('.X'[8+16*(e[t][i]!='.')>>sum(n!='.'for v in e[t-1:t+2]for n in v[i-1:i+2])&1]for i in p(80))for t in p(40)]
open('out.txt','w').write('\n'.join(e))

水平スクロールについては申し訳ありませんが、上記のすべての新しいラインが必要であり、私はそれらをそれぞれ1つのキャラクターとして数えました。

ゴルフコードを読んでみません。変数名は、最高の圧縮を実現するためにランダムに選択されます。そうです。私は本気です。より良いフォーマットとコメントされたバージョンが次のとおりです。

# get command-line arguments: infile and count
import sys
ignored, infile, count = sys.argv

# read the input into a list (each input line is a string in the list)
data = open(infile).readlines()

# loop the number of times requested on the command line
for loop in range(int(count)):
    # this monstrosity applies the rules for each iteration, replacing
    # the cell data with the next generation
    data = [''.join(

                # choose the next generation's cell from '.' for
                # dead, or 'X' for alive
                '.X'[

                    # here, we build a simple bitmask that implements
                    # the generational rules.  A bit from this integer
                    # will be chosen by the count of live cells in
                    # the 3x3 grid surrounding the current cell.
                    #
                    # if the current cell is dead, this bitmask will
                    # be 8 (0b0000001000).  Since only bit 3 is set,
                    # the next-generation cell will only be alive if
                    # there are exactly 3 living neighbors in this
                    # generation.
                    #
                    # if the current cell is alive, the bitmask will
                    # be 24 (8 + 16, 0b0000011000).  Since both bits
                    # 3 and 4 are set, this cell will survive if there
                    # are either 3 or 4 living cells in its neighborhood,
                    # including itself
                    8 + 16 * (data[y][x] != '.')

                    # shift the relevant bit into position
                    >>

                    # by the count of living cells in the 3x3 grid
                    sum(character != '.' # booleans will convert to 0 or 1
                        for row in data[y - 1 : y + 2]
                        for character in row[x - 1 : x + 2]
                    )

                    # select the relevant bit
                    & 1
                ]

               # for each column and row
                for x in range(80)
            )
            for y in range(40)
    ]

# write the results out
open('out.txt','w').write('\n'.join(data))

申し訳ありませんが、C-ishブラケットのフォーマットについてはPythonistasですが、各ブラケットが閉じているものを明確にしようとしていました。

Haskell- 284 272 232 chars

import System
main=do f:n:_<-getArgs;s<-readFile f;writeFile"out.txt"$t s$read n
p '\n'_='\n'
p 'X'2='X'
p _ 3='X'
p _ _='.'
t r 0=r
t r n=t[p(r!!m)$sum[1|d<-1:[80..82],s<-[1,-1],-m<=d*s,m+d*s<3240,'X'==r!!(m+d*s)]|m<-[0..3239]]$n-1

F＃、496

私はこれを大いに減らすことができましたが、それはまだ球場にあり、かなり読みやすいので、私はこれが好きです。

open System.IO
let mutable a:_[,]=null
let N y x=
 [-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1]
 |>Seq.sumBy(fun(i,j)->try if a.[y+i,x+j]='X' then 1 else 0 with _->0)
[<EntryPoint>]
let M(r)=
 let b=File.ReadAllLines(r.[0])
 a<-Array2D.init 40 80(fun y x->b.[y].[x])
 for i=1 to int r.[1] do 
  a<-Array2D.init 40 80(fun y x->
   match N y x with|3->'X'|2 when a.[y,x]='X'->'X'|_->'.')
 File.WriteAllLines("out.txt",Array.init 40(fun y->
  System.String(Array.init 80(fun x->a.[y,x]))))
 0

編集

428

リクエストに応じて、これが私の次の刺し傷です：

open System
let mutable a,k=null,Array2D.init 40 80
[<EntryPoint>]
let M r=
 a<-k(fun y x->IO.File.ReadAllLines(r.[0]).[y].[x])
 for i=1 to int r.[1] do a<-k(fun y x->match Seq.sumBy(fun(i,j)->try if a.[y+i,x+j]='X'then 1 else 0 with _->0)[-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1]with|3->'X'|2 when a.[y,x]='X'->'X'|_->'.')
 IO.File.WriteAllLines("out.txt",Array.init 40(fun y->String(Array.init 80(fun x->a.[y,x]))))
 0

これは、基本的なゴルフで14％の削減です。私は1D配列ではなく2Dアレイ/配列を使用して負けていると感じずにはいられませんが、今はその変革をしたくないと感じています。アレイを初期化するために3200回エレガントにファイルを読む方法に注意してください:)

ルビー1.8： ~~178~~ 175 chars

f,n=$*;b=IO.read f
n.to_i.times{s=b.dup
s.size.times{|i|t=([82,1,-80].map{|o|b[i-o,3]||''}*'').count 'X'
s[i]=t==3||b[i]-t==?T??X:?.if s[i]>13};b=s}
File.new('out.txt','w')<<b

ニューラインは重要です（ただし、すべてはセミコロンで交換できます。）

編集： Newlineの問題を修正し、3つのcharをトリミングしました。

ジャワ、 441... 346

更新1 内側を削除しました
更新2 バグを修正し、キャラクターを獲得しました
更新3 いくつかの境界の問題を無視しながら、より多くのメモリと配列を使用します。おそらくいくつかのcharを保存することができます。
更新4 いくつかのcharを節約しました。 Baluscに感謝します。
更新5 400を下回って、その余分なビットをugるのに、いくつかの小さな変更を加えます。
更新6 今では、物事が非常にハードコーディングされていることも、一度に正確な量で読むことができます。さらに、さらにいくつかの節約。
更新7 文字をファイルにチェーンして、charを保存します。さらに、いくつかの奇数ビット。

Baluscのソリューションで遊んでいるだけです。限られた評判は、私が彼にコメントとして何も追加できなかったことを意味します。

class M{public static void main(String[]a)throws Exception{int t=3240,j=t,i=new Integer(a[1])*t+t;char[]b=new char[i+t],p={1,80,81,82};for(new java.io.FileReader(a[0]).read(b,t,t);j<i;){char c=b[j],l=0;for(int n:p)l+=b[j+n]/88+b[j-n]/88;b[j+++t]=c>10?(l==3|l+c==90?88:'.'):c;}new java.io.FileWriter("out.txt").append(new String(b,j,t)).close();}}

より読みやすい（？）バージョン：

class M{
 public static void main(String[]a)throws Exception{
  int t=3240,j=t,i=new Integer(a[1])*t+t;
  char[]b=new char[i+t],p={1,80,81,82};
  for(new java.io.FileReader(a[0]).read(b,t,t);j<i;){
    char c=b[j],l=0;
    for(int n:p)l+=b[j+n]/88+b[j-n]/88;
    b[j+++t]=c>10?(l==3|l+c==90?88:'.'):c;
  }
  new java.io.FileWriter("out.txt").append(new String(b,j,t)).close();
 }
}

Scala- ~~467~~ ~~364~~ 339 chars

object G{def main(a:Array[String]){val l=io.Source.fromFile(new java.io.File(a(0)))getLines("\n")map(_.toSeq)toSeq
val f=new java.io.FileWriter("out.txt")
f.write((1 to a(1).toInt).foldLeft(l){(t,_)=>(for(y<-0 to 39)yield(for(x<-0 to 79)yield{if(x%79==0|y%39==0)'.'else{val m=t(y-1)
val p=t(y+1);val s=Seq(m(x-1),m(x),m(x+1),t(y)(x-1),t(y)(x+1),p(x-1),p(x),p(x+1)).count('X'==_)
if(s==3|(s==2&t(y)(x)=='X'))'X'else'.'}})toSeq)toSeq}map(_.mkString)mkString("\n"))
f.close}}

改善の余地がたくさんあると思います...

編集はい、そうです：

object G{def main(a:Array[String]){var l=io.Source.fromFile(new java.io.File(a(0))).mkString
val f=new java.io.FileWriter("out.txt")
var i=a(1).toInt
while(i>0){l=l.zipWithIndex.map{case(c,n)=>if(c=='\n')'\n'else{val s=Seq(-83,-82,-81,-1,1,81,82,83).map(_+n).filter(k=>k>=0&k<l.size).count(l(_)=='X')
if(s==3|(s==2&c=='X'))'X'else'.'}}.mkString
i-=1}
f.write(l)
f.close}}

編集そして、私はまだ絞り出すためにもっとあると感じています...

object G{def main(a:Array[String]){val f=new java.io.FileWriter("out.txt")
f.write(((1 to a(1).toInt):\(io.Source.fromFile(new java.io.File(a(0))).mkString)){(_,m)=>m.zipWithIndex.map{case(c,n)=>
val s=Seq(-83,-82,-81,-1,1,81,82,83)count(k=>k+n>=0&k+n<m.size&&m(k+n)=='X')
if(c=='\n')c else if(s==3|s==2&c=='X')'X'else'.'}.mkString})
f.close}}

次のソリューションでは、NULLと呼ばれる独自のカスタムドメイン固有のプログラミング言語を使用しています。

これがどのように機能するのか疑問に思っている場合：私の言語は、プログラムごとに1つの統計のみで構成されています。ステートメントは、コードゴルフスレッドに属するStackOverFlowスレッドIDを表します。私のコンパイラは、これを最高のJavaScriptソリューション（SO APIを使用して）を探すプログラムにコンパイルし、ダウンロードしてWebブラウザーで実行します。

ランタイムは、新しいスレッドの方が良い場合があります（最初の上昇したJavaScriptの回答が表示されるまでには時間がかかる場合があります）が、利点にはコーディングスキルはほとんど必要ありません。

JavaScript/node.js -233 236 文字

a=process.argv
f=require('fs')
m=46
t=f.readFileSync(a[2])
while(a[3]--)t=[].map.call(t,function(c,i){for(n=g=0;e=[-82,-81,-80,-1,1,80,81,82][g++];)t[i+e]>m&&n++
return c<m?c:c==m&&n==3||c>m&&n>1&&n<4?88:m})
f.writeFile('out.txt',t)

C -300

私のJavaソリューションがCでどれほど小さくug ugになるのか疑問に思いました。PReprocessorBitsのNewlinesを含めて、300に減少します。メモリをOSに解放することを残します！ OSがファイルを閉じてフラッシュすると仮定することで、〜20を節約できます。

#include<stdio.h>
#include<stdlib.h>
#define A(N)j[-N]/88+j[N]/88

int main(int l,char**a){
  int t=3240,i=atoi(a[2])*t+t;
  char*b=malloc(i+t),*j;
  FILE*f;
  fread(j=b+t,1,t,fopen(a[1],"r"));
  for(;j-b-i;j++[t]=*j>10?l==3|l+*j==90?88:46:10)
      l=A(1)+A(80)+A(81)+A(82);
  fwrite(j,1,t,f=fopen("out.txt","w"));
  fclose(f);
}

マンプス：314 Chars

L(F,N,R=40,C=80)
    N (F,N,R,C)
    O F:"RS" U F D  C F
    .F I=1:1:R R L F J=1:1:C S G(0,I,J)=($E(L,J)="X")
    F A=0:1:N-1 F I=1:1:R F J=1:1:C D  S G(A+1,I,J)=$S(X=2:G(A,I,J),X=3:1,1:0)
    .S X=0 F i=-1:1:1 F j=-1:1:1 I i!j S X=X+$G(G(A,I+i,J+j))
    S F="OUT.TXT" O F:"WNS" U F D  C F
    .F I=1:1:R F J=1:1:C W $S(G(N,I,J):"X",1:".") W:J=C !
    Q

ジャワ、 556 532 517 496 472 433 428 420 418 381 chars

更新1: ：1番目を置き換えました StringBuffer に Appendable そして2番目 char[]. 。節約しました24文字。
更新2： ファイルを読むためのより短い方法を見つけました char[]. 。 15枚を節約しました。
更新3： 1つを交換しました if/else に ?: そしてマージされました char[] と int 宣言。 21枚を節約しました。
更新4： 交換 (int)f.length() と c.length に s. 。節約しました24文字。
更新5： Molehillのヒントに従って改善を行いました。メジャーワンは、私が取り除くことができるように、チャーの長さをハードコードしていました File. 。 39枚を節約しました。
更新6： マイナーリファクタリング。 6枚を節約しました。
更新7： 交換 Integer#valueOf() に new Integer() ループのリファクタリング。節約しました。
更新8： 隣人の計算が改善されました。 2文字を節約しました。
更新9： ファイルの長さがすでにハードコードされているため、最適化されたファイル読み取り。 37枚を節約しました。

 import java.io.*;class L{public static void main(String[]a)throws Exception{int i=new Integer(a[1]),j,l,s=3240;int[]p={-82,-81,-80,-1,1,80,81,82};char[]o,c=new char[s];for(new FileReader(a[0]).read(c);i-->0;c=o)for(o=new char[j=s];j-->0;){l=0;for(int n:p)l+=n+j>-1&n+j<s?c[n+j]/88:0;o[j]=c[j]>13?l==3|l+c[j]==90?88:'.':10;}Writer w=new FileWriter("out.txt");w.write(c);w.close();}}

より読みやすいバージョン：

import java.io.*;
class L{
 public static void main(String[]a)throws Exception{
  int i=new Integer(a[1]),j,l,s=3240;
  int[]p={-82,-81,-80,-1,1,80,81,82};
  char[]o,c=new char[s];
  for(new FileReader(a[0]).read(c);i-->0;c=o)for(o=new char[j=s];j-->0;){
   l=0;for(int n:p)l+=n+j>-1&n+j<s?c[n+j]/88:0;
   o[j]=c[j]>10?l==3|l+c[j]==90?88:'.':10;
  }
  Writer w=new FileWriter("out.txt");w.write(c);w.close();
 }
}

書き込み後に閉じることは絶対に必須であり、そうでなければファイルは空のままです。そうでなければ、さらに21枚の請求を節約していたでしょう。

さらに、使用するときにもう1つのチャーを節約することもできます 46 それ以外の '.', 、しかし、編集エラーがあるJavacとEclipseの両方 精度の損失の可能性. 。奇妙なもの。

注：これにより、入力ファイルが予想されます \n ニューライン、そうではありません \r\n デフォルトでWindowsが使用するように！

PHP- 365 328 322文字。

list(,$n,$l) = $_SERVER["argv"];
$f = file( $n );
for($j=0;$j<$l;$j++){   
    foreach($f as $k=>$v){  
        $a[$k]="";      
        for($i=0;$i < strlen( $v );$i++ ){
            $t = 0;
            for($m=-1;$m<2;$m++){
                for($h=-1;$h<2;$h++){
                    $t+=ord($f[$k + $m][$i + $h]);
                }
            }
            $t-=ord($v[$i]);          
            $a[$k] .= ( $t == 494 || ($t == 452 && ord($v[$i])==88)) ?  "X" : "." ;
        }
    }
    $f = $a;
}       
file_put_contents("out.txt", implode("\n", $a ));

これは改善できると確信していますが、PHPでどのように見えるか興味がありました。たぶん、これはもう少しコードゴルフ体験をしている人を刺激するでしょう。

更新しました 両方のargで$ var = $ _server ["argv"]の代わりにリスト（）を使用します。 素敵なドン
更新しました += and - =これは私 /facepalmになりました私はそれを逃したとは信じられません
更新しました file_put_contents（）を使用するファイル出力 ドンによるもう一つの良いキャッチ
更新しました vars $ qと$ wの初期化を削除していませんでしたそれらは使用されていませんでした

R 340 Chars

cgc<-function(i="in.txt",x=100){
    require(simecol)
    z<-file("in.txt", "rb")
    y<-matrix(data=NA,nrow=40,ncol=80)
    for(i in seq(40)){
        for(j in seq(80)){
            y[i,j]<-ifelse(readChar(z,1) == "X",1,0)
        }
        readChar(z,3)
    }
    close(z)
    init(conway) <- y
    times(conway)<-1:x
    o<-as.data.frame(out(sim(conway))[[100]])
    write.table(o, "out.txt", sep="", row.names=FALSE, col.names=FALSE)
}
cgc()

あなたのために実際のオートマトンを行うパッケージを追加することは少し不正行為だと感じていますが、私はそれを使用して、1ではなく「x」でファイルを読むためにマトリックやものを叩き続けなければなりませんでした。

これは私の最初の「コードゴルフ」です、興味深い...

C ++ - 492 454 386

私の最初のコードゴルフ;）

#include<fstream>
#define B(i,j)(b[i][j]=='X')
int main(int i,char**v){for(int n=0;n<atoi(v[2]);++n){std::ifstream f(v[1]);v[1]="out.txt";char b[40][83];for(i=0;i<40;++i)f.getline(b[i],83);std::ofstream g("out.txt");g<<b[0]<<'\n';for(i=1;i<39;++i){g<<'.';for(int j=1;j<79;++j){int k=B(i-1,j)+B(i+1,j)+B(i,j-1)+B(i,j+1)+B(i-1,j-1)+B(i+1,j+1)+B(i+1,j-1)+B(i-1,j+1);(B(i,j)&&(k<2||k>3))?g<<'.':(!B(i,j)&&k==3)?g<<'X':g<<b[i][j];}g<<".\n";}g<<b[0]<<'\n';}}

ロジックの一部をテーブルルックアップ+他のマイナーなトリックに置き換えると、やや改訂されたバージョン：

#include<fstream>
#define B(x,y)(b[i+x][j+y]=='X')
int main(int i,char**v){for(int n=0;n<atoi(v[2]);++n){std::ifstream f(v[1]);*v="out.txt";char b[40][83], O[]="...X.....";for(i=0;i<40;++i)f>>b[i];std::ofstream g(*v);g<<b[0]<<'\n';for(i=1;i<39;++i){g<<'.';for(int j=1;j<79;++j){O[2]=b[i][j];g<<O[B(-1,0)+B(1,0)+B(0,-1)+B(0,1)+B(-1,-1)+B(1,1)+B(1,-1)+B(-1,1)];}g<<".\n";}g<<b[0]<<'\n';}}

Perl - 214 Chars

何、PERLエントリはありませんか？

$i=pop;@c=<>;@c=map{$r=$_;$u='';for(0..79)
{$K=$_-1;$R=$r-1;$u.=((&N.(&N^"\0\W\0").&N)=~y/X//
|(substr$c[$r],$_,1)eq'X')==3?'X':'.';}$u}keys@c for(1..$i);
sub N{substr$c[$R++],$K,3}open P,'>','out.txt';$,=$/;print P@c

実行：

conway.pl infile #times

別のJavaの試み、361 Chars

class L{public static void main(final String[]a)throws Exception{new java.io.RandomAccessFile("out.txt","rw"){{int e=88,p[]={-1,1,-80,80,-81,81,-82,82},s=3240,l=0,i=new Byte(a[1])*s+s,c;char[]b=new char[s];for(new java.io.FileReader(a[0]).read(b);i>0;seek(l=++l%s),i--){c=b[l];for(int n:p)c+=l+n>=0&l+n<s?b[l+n]/e:0;write(c>13?(c==49|(c|1)==91?e:46):10);}}};}}

そしてもう少し読みやすい

class L {
    public static void main(final String[]a) throws Exception {
        new java.io.RandomAccessFile("out.txt","rw"){{
            int e=88, p[]={-1,1,-80,80,-81,81,-82,82},s=3240,l=0,i=new Byte(a[1])*s+s,c;
            char[] b = new char[s];
            for (new java.io.FileReader(a[0]).read(b);i>0;seek(l=++l%s),i--) {
                c=b[l];
                for (int n:p)
                    c+=l+n>=0&l+n<s?b[l+n]/e:0;
                write(c>13?(c==49|(c|1)==91?e:46):10);
            }
        }};
    }
}

Molehillのバージョンに非常によく似ています。別のFileWriterを使用し、追加の変数なしでセルの隣人を数えようとしました。不運にも、 RandomAccessFile かなり長い名前であり、ファイルアクセスモードを渡す必要があります。

錆 -469文字これをここに投稿する必要があるかどうかはわかりません（この投稿は3歳です）が、とにかく、これについて試してみてください（0.9）：

use std::io::fs::File;fn main(){
let mut c=File::open(&Path::new(std::os::args()[1])).read_to_end();
for _ in range(0,from_str::<int>(std::os::args()[2]).unwrap()){
let mut b=c.clone();for y in range(0,40){for x in range(0,80){let mut s=0;
for z in range(x-1,x+2){for t in range(y-1,y+2){
if z>=0&&t>=0&&z<80&&t<40&&(x !=z||y !=t)&&c[t*81+z]==88u8{s +=1;}}}
b[y*81+x]=if s==3||(s==2&&c[y*81+x]==88u8){88u8} else {46u8};}}c = b;}
File::create(&Path::new("out.txt")).write(c);}

興味のある人のために、ここにいくつかの攻撃的なゴルフの前のコードがあります：

use std::io::fs::File;
fn main() {
    let f = std::os::args()[1];
    let mut c = File::open(&Path::new(f)).read_to_end();    
    let n = from_str::<int>(std::os::args()[2]).unwrap();   
    for _ in range(0,n)
    {
        let mut new = c.clone();
        for y in range(0,40) {
            for x in range(0,80) {
                let mut sum = 0;
                for xx in range(x-1,x+2){
                    for yy in range(y-1,y+2) {
                        if xx >= 0 && yy >= 0 && xx <80 && yy <40 && (x != xx || y != yy) && c[yy*81+xx] == 88u8
                        { sum = sum + 1; }
                    }
                }
                new[y*81+x] = if sum == 3 || (sum == 2 && c[y*81+x] == 88u8) {88u8} else {46u8};                    
            }
        }
        c = new;
    }
    File::create(&Path::new("out.txt")).write(c);
}

このHTMLファイルを使用することをお勧めします。ファイル入力はありませんが、ジョブを行うテキストアレアです！ HTMLと開始とVARもいくつかあります。メインルーチンには235文字しかありません。それは手作業のJSです。

<!DOCTYPE html>
<html><body><textarea id="t" style="width:600px;height:600px;font-family:Courier">
</textarea></body><script type="text/javascript">var o,c,m=new Array(3200),
k=new Array(3200),y,v,l,p;o=document.getElementById("t");for(y=0;y<3200;y++)
{m[y]=Math.random()<0.5;}setInterval(function(){p="";for(y=0;y<3200;y++){c=0;
for(v=-1;v<2;v+=2){c+=m[y-1*v]?1:0;for(l=79;l<82;l++)c+=m[y-l*v]?1:0;}
k[y]=c==3||m[y]&&c==2;}p="";for(y=0;y<3200;y++){p+=(y>0&&y%80==0)?"\n":"";
m[y]=k[y];p+=(m[y]?"O":"-");}o.innerHTML=p;},100);</script></html>

古典的なパターンの1つ

***
..*
.*

私のアバターは、このパターンとルールを使用して私のバージョンの人生のゲームを使用して作成されました（23/3ではないことに注意してください）：

#D Thanks to my daughter Natalie
#D Try at cell size of 1
#R 8/1
#P -29 -29
.*********************************************************
*.*******************************************************.*
**.*****************************************************.**
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
****************************.*.****************************
***********************************************************
****************************.*.****************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
***********************************************************
**.*****************************************************.**
*.*******************************************************.*
.*********************************************************

IMHO-コンウェイの人生のゲームを学んだように、トリックは短いコードを書くのではなく、複雑な生命体を迅速に行う可能性のあるコードを書いていませんでした。上記の古典的なパターンと594,441セルの包まれた世界を使用して、私がこれまでにできる最善のセルは、約1,000世代 /秒でした。

別の単純なパターン

**********
.
................*
.................**
................**.......**********

とグライダー

........................*...........
......................*.*...........
............**......**............**
...........*...*....**............**
**........*.....*...**..............
**........*...*.**....*.*...........
..........*.....*.......*...........
...........*...*....................
............**......................

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow