ProgramingTip

코드 골프 : Conway의 삶의 게임

bestdevel 2020. 10. 15. 08:06
반응형

코드 골프 : Conway의 삶의 게임

과제 : John H. Conway의 Game of Life 셀룰러 자동화 를 구현하는 가장 짧은 프로그램을 작성하십시오 . [ 링크 ]

편집 : 약한 경기 승리 경쟁 후, 나는 펄로 Matlab 솔루션을 한 캐릭터 만큼 이길 수 있는 자 pdehaan을 선택했습니다 .

생명의 게임은 본 적이없는 사람들을 위해 사각형 셀 격자 (이상적으로는 무한함)를 사용합니다. 세포는 살아 있거나 (채워짐) 죽거나 (비어 있음) 수 있습니다. 다음 규칙을 적용하여 다음 단계에서 어떤 세포가 살아 있는지 확인합니다.

  1. 2 개 미만의 인구 부족으로 인한 것처럼 죽습니다.
  2. 세 개 이상의 수많은 이웃이있는 세포는 마치 과밀로 죽는 것처럼 죽습니다.
  3. 2 ~ 3 명의 명의 사람들이있는 모든 외장 세포는 다음 세대를 위해 살아갑니다.
  4. 정확히 세 개의 일치하는 이웃이있는 죽은 세포는 마치 번식에 의한 것처럼 보입니다.

프로그램은 명령 줄 인수로 지정된 40x80 문자 ASCII 텍스트 파일과 수행 할 반복 횟수 (N)를 읽습니다. 마지막으로, N 회 반복 후 시스템 상태를 ASCII 파일 out.txt로 출력합니다.

다음은 관련 파일로 실행되는 예제입니다.

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) 다룰 필요
  • 편집 : 출력 파일에 줄 바꿈 이 필요 합니다.

우승자는 캐릭터 수에 따라 결정됩니다.

행운을 빕니다!

펄 127 개 129 135 문자

몇 가지 더 많은 캐릭터를 제거했습니다 ...

$/=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

티카 - 179 개 163 154 151 문자


    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]

생기 :

대체 텍스트

시간에 따른 평균 모집단의 그래프를 얻을 수도 있습니다.

대체 텍스트

Wikipedia 에서 글라이더를 생성하기위한 좋은 패턴

aa

AFAIK Mathematica는 Cellular Automaton을 사용하여 규칙 30을 사용하여 난수를 생성 합니다.

MATLAB 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 문자

함수 구문 : (124 자)

다음은 읽기 쉬운 버전입니다 (더 나은 서식 지정을 위해 불필요한 줄 바꿈과 공백이 추가됨).

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 자)

명령 구문을 사용하여 함수를 호출 하는 방법에 대한 설명을 듣고 좀 더 자세히 살펴본 결과 MATLAB 함수 가 실제로 명령 줄 형식 (일부 제한 있음) 으로 호출 될 수 있음을 알게되었습니다 . 당신은 매일 새로운 것을 배라고합니다!

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는 한 번만 반복됩니다. 아마도 이것은 최신 버전의 MATLAB에서 수정 된 버그 일 수 있습니다. 따라서 애니메이션을 더 오래 지속하고 진화하는 단계를 더 쉽게 볼 수 있습니다 프레임 지연을 두었습니다 (약 0.5 초). 다음은 Gosper Glider Gun 패턴을 점화 GIF 출력 입니다.

대체 텍스트

개량

  • 업데이트 1 :b몇 가지 변환을 제거하기 위해 대규모를 논리 (예 : "부울") 유형에서 숫자 유형으로 변경했습니다.
  • 업데이트 2 : 파일을로드하기위한 코드를 줄이고 MAGIC 함수를 트릭으로 사용하여 더 적은 문자로 컨볼 루션 커널을 생성했습니다.
  • 업데이트 3 : 인덱싱 논리를 단순화 교체 ~~b+0와 함께 b/42, 교체 'same'와 함께 's'인수로 CONV2 (역할 놀랍게도 여전히했다!).
  • Update 4 : The MathWorks의 Loren 이 골프와 Game of Life에 대해 블로그를 게시하기 먼저 온라인으로 검색해야 할 초 . 나는 거기에서 논의 된 기술 중 일부를 통합 b하여 논리 규모로 다시 전환해야했습니다.
  • 업데이트 5 : 언급 한 블로그 게시물에 대한 Aslak Grinsted 의 의견 은 논리와 컨볼 루션 수행 (함수 FILTER2 사용 ) 모두에 대해 더 짧은 알고리즘을 제안 하여 그의 제안을 "통합"( "복사"읽기)했습니다. ;)
  • 업데이트 6 : 초기화에서 두 문자를 잘라 b내고 루프의 논리를 재 작업하여 추가 문자 1 개를 저장했습니다.
  • 7 업데이트 : 에릭 샘슨 내가 대체 할 수 있음을 전자 메일로 지적 cell2mat와 char4 개 문자를 저장. 감사합니다 에릭!

루비 1.9 - (189 개) 178 159 155 153 문자

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 자 이하로 줄 바꿈을 처리합니다. 라이브 셀이 가장자리에 도달 할 때 줄 바꿈을 방해하도록 허용하면
7 개를 더 제거 할 수 있습니다 v<?.?v:.

Python-282 자

공이 굴러가는 게 좋을지도 ...

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')

이 코드를 복사하여 넣습니다. Latin-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 소스 파일입니다. 파이썬 소스 코드에서 압축을 사용하는 것입니다. 진짜 속임수는 결과적으로 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))

가로 스크롤에 대해 죄송합니다. 위의 모든 줄 바꿈이 필요하며 한 문자로 계산했습니다.

나는 골프 코드를받을려고하지 않습니다. 변수 이름은 최상의 압축을 위해 무작위로 선택됩니다. 네, 진심입니다. 더 나은 형식과 주석이 달린 버전은 다음과 달라집니다.

# 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))

Pythonistas, C-ish 대괄호 형식화에 죄송합니다.

하스켈 - 284 개 (272) 232 문자

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 : 178175 자

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

줄 바꿈은 중요합니다 (세미콜론으로 모두 바꿀 수 있음).

편집 : 개행 문제를 수정하고 3 개의 문자를 사용합니다.

자바, 441 ... 346

  • 업데이트 1 내부 if 및 더 추함 제거
  • 업데이트 2 버그 수정 및 캐릭터 금액
  • 업데이트 3 일부 경계 문제를 무시하면서 더 많은 메모리와 배열을 사용합니다. 아마도 몇 개의 문자를 사용할 수 있습니다.
  • 업데이트 4 몇 문자를 저장했습니다. BalusC 감사합니다.
  • 업데이트 5 몇 가지 사소한 변경 사항이 400 이하로 내려서 조금 더 추하게 만듭니다.
  • 업데이트 6 이제 너무 하드 코딩되어있어 한 번에 정확한 양을 읽을 수 있습니다. 또한 몇 가지 더 절약 할 수 있습니다.
  • 업데이트 7 문자를 저장하려는 파일에 쓰기를 연결하십시오. 그리고 약간의 이상한 비트.

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();
 }
}

스칼라-467 개 364 339 문자

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이라고 부르는 고유 한 사용자 지정 도메인 별 프로그래밍 언어를 사용합니다. 

3499538

이것이 어떻게 작동하는지 궁금한 경우 : 내 언어는 프로그램 당 하나의 문장으로 만 구성됩니다. 이 문은 코드 골프라고 말하는 경우에도 StackOverflow ID를 나타냅니다. 내 컴파일러는 개발자 SO API로 최고의 자바 펼쳐 솔루션을 찾고 다운로드하여 웹 브라우저에서 실행하는 프로그램으로 준비합니다.

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

내 자바 솔루션이 C에서 얼마나 작고 못 생겼는지 궁금했습니다. 전 처리기 비트에 대한 줄 바꿈을 포함하여 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);
}

MUMPS : 314 자

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 문자

  • 업데이트 1 : 1st를 StringBuffer로 Appendable, 2nd를 char[]. 24 튼 저장했습니다.

  • 업데이트 2 : 파일을 char[]. 15 보존했습니다.

  • 업데이트 3 : 하나 if/else를 ?:병합 char[]하고 int선언합니다. 21 튼튼 저장했습니다.

  • 업데이트 4 : 대체 (int)f.length()와 c.length에 의해 s. 24 튼 저장했습니다.

  • 업데이트 5 : Molehill의 힌트에 따라 개선되었습니다. 주요한 내가 제거 할 수있는 길이를 하드 코딩하는 제거 File. 39 튼 저장했습니다.

  • 업데이트 6 : 사소한 리팩토링. 6. 튼튼 저장했습니다.

  • 업데이트 7 : for 루프 로 대체 Integer#valueOf()되고 new Integer()리팩터링되었습니다. 8 튼 저장했습니다.

  • 업데이트 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 잠재적 인 더 절약했을 것입니다.

또한 46대신 사용할 때 사용할 문자를 하나 더 절약 할 수 있습니다 . '.'javac와 Eclipse 컴파일 오류가 모두 있습니다 . 정밀도 가 떨어질 수 있습니다 . 이상한 것들.

참고 : 윈도우 기본적으로 사용에서하는 \n것이 \r\n아니라 줄 바꿈 이있는 입력 입력 파일이 필요 합니다!

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에서 어떻게 보일지 궁금했습니다. 아마도 이것은 코드 골프 경험이 더 많은 사람에게 영감을 줄 것입니다.

  • 두 인수 모두에 대해 $ var = $ _SERVER [ "argv"] 대신 list () 사용을 업데이트 했습니다 . 좋은 돈
  • 업데이트 된 + = 및-= 이것이 나를 / facepalm heh 내가 놓쳤다는 것을 믿을 수 없게되었습니다.
  • 돈의 또 다른 좋은 캐치 file_put_contents를 () 사용하도록 파일를 출력을 업데이트 했습니다.
  • 사용되지 않는 $ q 및 $ w vars의 제거 된 초기화 업데이트

R 340 자

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 자

아직 펄 항목이 없습니까? 

$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

또 다른 자바 시도, 361 자

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꽤 긴 이름이며 파일 액세스 모드를 통과해야합니다.

RUST-469 문자가 내가 여기에 게시 해야하는지 모르겠지만 (이 게시물은 3 년) 어쨌든, 내 시도는 rust (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과 시작 및 vars도 있습니다. 주 루틴에는 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>

고전적인 패턴 중 하나

***
..*
.*

내 아바타는이 패턴과 규칙을 사용하여 내 버전의 Game of Life를 사용하여 생성합니다 (23/3이 아님).

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

IMHO-Conway의 Game of Life를 배웠을 때 요령은 짧은 코드가 아니라 복잡한 생명체를 빠른 수있는 코드를 작성하는 것이 었습니다. 위의 고전적인 패턴과 594,441 개의 세포 패턴으로 이루어진 세계를 사용했을 때 제가 할 수있는 최선은 약 1,000 세대 / 초였습니다.

또 다른 간단한 패턴

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

그리고 글라이더

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

참고 URL : https://stackoverflow.com/questions/3499538/code-golf-conways-game-of-life

반응형

'ProgramingTip' 카테고리의 다른 글

OSX Mavericks에 Elasticsearch 설치  (0) 2020.10.15
나만의 방법에 대한 사용자 지정 완료 블록  (0) 2020.10.15
이니셜 라이저는 비 정적 필드, 메서드 또는 속성을 참조 할 수 없습니다.  (0) 2020.10.14
Babel 6.x에서 기본 내보내기 값을 필요로합니다.  (0) 2020.10.14
무한 이미지를 찾기위한 알고리즘  (0) 2020.10.14

'ProgramingTip'의 다른글

  • 현재글코드 골프 : Conway의 삶의 게임

관련글

댓글

티스토리툴바