인생의 가장 짧은 게임


59

Conway의 Game of Life 는 셀룰러 자동화의 전형적인 예입니다. 세포는 정사각형 격자를 형성하며 각각은 살아 있거나 죽은 두 가지 상태가 있습니다. 매 차례마다 각 셀은 해당 상태와 8 개 이웃의 상태에 따라 동시에 업데이트됩니다.

  • 라이브 셀에 정확히 2 개 또는 3 개의 라이브 이웃이있는 경우 라이브 셀은 계속 남아 있습니다.
  • 정확히 3 개의 살아있는 이웃이 있으면 죽은 세포가 살아납니다

당신의 임무는 당신이 그것을 받아들이기로 선택한다면, 가장 짧은 Game of Life 구현을 당신이 선호하는 언어로 코딩하는 것입니다.

규칙:

  • 그리드는 20x20 이상이어야합니다
  • 그리드는 감싸 야합니다 (그리드는 토러스의 표면과 같습니다)
  • 구현시 사용자는 자신의 시작 패턴을 입력 할 수 있어야합니다
  • 무슨 일이 일어나고 있는지 알 수 없다면 GoL은 무의미합니다. 따라서 오토 마톤의 시각적 출력이 있어야합니다.

8
이전의 스택 오버플로 : Code Golf : Conway 's Game of Life 에서 주석의 APL 구현 링크를 확인하십시오.
dmckee

1
아, 나는 그것을 보지 못했다. 그러나이 더 약간 차이가 없습니다 (내가 함께 도전을 넣는 작업을 삭제 저장?
그리핀

6
문제가되지 않습니다. 이미 스택 오버플로에서 실행되는 많은 퍼즐이 여기에서도 이루어졌지만 사람들은 비슷한 과제에 연결하는 것에 대해 강박 관념을 말할 것입니다.
dmckee

@Griffin : s ;이전 }의 모든 것을 제거 할 수 있습니다 . 또한 var코드를 손상시키지 않으면 s를 때때로 제거 할 수 있습니다. 그리고 한 줄을 위해 forS, ifS 등, 당신은 제거 할 수 있습니다 { }완전히를 : for(...) for(...) dosomething().
pimvdb

@pimvdb, 건배, 나는 아직 완전히 골프하지 않았고, 시간이 없었습니다. 그냥 도전을 설정하기보다는 나도 가고 있음을 보여주고 싶었습니다. 곧 최대로 골프 것입니다.
그리핀

답변:


27

자바 스크립트와 HTML5 캔버스, 940 639 586 519 자

<html><body onload="k=40;g=10;b=[];setInterval(function(){c=[];for(y=k*k;y--;){n=0;for(f=9;f--;)n+=b[(~~(y/k)+k+f%3-1)%k*k+(y+k+~~(f/3)-1)%k];c[y]=n==3||n-b[y]==3;r.fillStyle=b[y]?'red':'tan';r.fillRect(y%k*g,~~(y/k)*g,g-1,g-1)}if(v.nextSibling.checked)b=c},1);v=document.body.firstChild;v.width=v.height=g*k;v.addEventListener('click',function(e){b[~~((e.pageY-v.offsetTop)/g)*k+~~((e.pageX-v.offsetLeft)/g)]^=1},0);r=v.getContext('2d');for(y=k*k;y--;)b[y]=0"><canvas></canvas><input type="checkbox"/>Run</body></html>

나는 항상 canvas로 무언가를하고 싶었으므로 여기 내 시도 (original version online )가 있습니다. (실행 모드에서도 가능)을 클릭하여 셀을 토글 할 수 있습니다.

이제 새 버전을 사용해 볼 수도 있습니다 .

불행히도 아직 해결할 수없는 문제가 있습니다. jsFiddle이 캔버스 바로 앞에 텍스트 노드를 배치하기 때문에 온라인 버전은 11 자 더 길었습니다 (이유?). 따라서 캔버스가 더 이상 첫 번째 자식이 아닙니다.

편집 1 : 많은 최적화 및 구조 조정.

편집 2 : 몇 가지 작은 변경 사항.

편집 3 : 완전한 스크립트 블록과 약간의 변경 사항이 인라인되었습니다.


멋지지만 간격 지연을 변경하여 1느린 스테핑보다 내 속도만큼 빠릅니다. 또한 각 사각형을 클릭하지 않고 그리기를 구현하려는 경우 마우스 위치를 가장 가까운 블록 크기로 반올림하고 해당 지점에서 사각형을 채울 수 있습니다. 더 많은 캐릭터이지만 더 많은 포인트.
그리핀

당신은 대체 할 수 있습니다 new Array('#FFF','#800')['#FFF','#800'].
Lowjacker

내 초 골프는 그림을 그리는 것에 대해 말하지만, 그림을 허용하지 않으며 죄와 같이 추악합니다. 하하. 당신은 당신의 두 가지 색상을 설정할 수 있습니다 s에 배열 tan하고 red그들은 짧은 표현과 함께 두 가지 색상이기 때문에 - 당신에게 두 개의 문자를 저장합니다. 또한 가능하면 리터럴 버전을 j간격에 넣으십시오 . 나는 짜낼 것이 더 많이 있다고 확신합니다.
그리핀

@Griffin and Lowjacker : 대단히 감사합니다. 나는 또한 당신이 이것보다 훨씬 더 골프를 할 수 있다고 확신합니다 (그리고 이미 아이디어가 있습니다). 불행히도 나는 그렇게 할 시간을 찾지 못했습니다. 더 나은 골프 버전은 내일 따를 것입니다-희망합니다
Howard

2
html 및 body 태그를 제거 할 수 있습니다. 그것은 동일하게 작동 할 것입니다
arodebaugh

32

파이썬, 219 자

나는 질문을 만족시키기에 충분한 인터페이스로 최대한의 골프를 갔다.

import time
P=input()
N=range(20)
while 1:
 for i in N:print''.join(' *'[i*20+j in P]for j in N)
 time.sleep(.1);Q=[(p+d)%400 for d in(-21,-20,-19,-1,1,19,20,21)for p in P];P=set(p for p in Q if 2-(p in P)<Q.count(p)<4)

다음과 같이 실행하십시오.

echo "[8,29,47,48,49]" | ./life.py

목록의 숫자는 시작 셀의 좌표를 나타냅니다. 첫 번째 행은 0-19이고 두 번째 행은 20-39입니다.

21 행의 터미널에서 실행하면 꽤 멋지게 보입니다.


1
이것은 완전히 승리했을 것입니다. 나는 '입력의 용이함'이 상당히 높은 가중치를 가졌다 고 생각합니다.
primo

@primo 나는 심지어 mma가 별도의 경쟁을해야한다고 제안하기까지 갔다.
luser droog

2
그렇다면이 Py의 삶은?
Christopher Wirt

항상 하나 이상의 char ... 2-(p in P)==을 저장할 수 있습니다 2-({p}<P). 그러나 당신은 당신의 입력을 변경해야 할 것입니다 {8,29,47,48,49}:)
JBernardo

21

TI-BASIC, 96 바이트 (비경쟁 항목의 경우 87)

TI-84 시리즈 그래프 계산기 (!) 용. 이이 버퍼 그래픽 루틴 (내장 확실히 아무것도를) 쓸 수있는 쉬운 방법입니다, 그래프 화면이 네 개의 관련 그래픽 명령을 가지고 있기 때문에, 매우 도전이었다 : Pxl-On(), Pxl-Off(), Pxl-Change(),와 pxl-Test().

화면에서 액세스 가능한 모든 픽셀을 사용하고 올바르게 줄 바꿈합니다. 각 셀은 하나의 픽셀이며 프로그램은 화면을 가로 질러 오른쪽으로 한 줄씩 업데이트합니다. 계산기에는 15MHz z80 프로세서 만 있고 BASIC은 느리게 해석되는 언어이므로 코드는 5 분마다 한 프레임 만 가져옵니다.

사용자 입력이 쉽습니다. 프로그램을 실행하기 전에 펜 도구를 사용하여 그래프 화면에 도형을 그리십시오.

계산기 포럼 Omnimaga코드 골프 콘테스트에 참가했습니다 .

0
While 1
For(X,0,94
Ans/7+49seq(pxl-Test(remainder(Y,63),remainder(X+1,95)),Y,62,123
For(Y,0,62
If 1=pxl-Test(Y,X)+int(3fPart(3cosh(fPart(6ֿ¹iPart(sum(Ans,Y+1,Y+3
Pxl-Change(Y,X
End
End
End

옴니 마가 버전 (87 바이트)

이 코드에는 추가 기능이 있습니다. 처음 실행 중인지 여부와 화면 상태를 무작위로 지정하는지 여부를 감지합니다. 후속 실행에서 프레임이 완료된 후 정지되면 시뮬레이션이 자동으로 계속됩니다. 그러나 화면을 감싸지 않기 때문에 경쟁 항목이 아닙니다. 그래프 화면이 미리 지워지면 바깥 쪽 경계에있는 셀은 항상 죽은 것으로 간주됩니다.

0
While 1
For(X,0,93
Ans/7+49seq(pxl-Test(Y,X+1),Y,0,62
For(Y,1,61
If 2rand>isClockOn=pxl-Test(Y,X)+int(3fPart(3cosh(fPart(6ֿ¹iPart(sum(Ans,Y,Y+2
Pxl-Change(Y,X
End
End
ClockOff
End

이 버전은 아마도 내가 작성한 것 중 가장 골프 코드 일 것입니다. 정말로 불쾌한 난독 화 최적화가 포함되어 있습니다.

  • 시계 상태를 플래그로 사용합니다. 프로그램 시작시 날짜 / 시간 시계가 활성화되고 전역 isClockOn 플래그 값을 사용하여 첫 번째 반복인지 여부를 결정합니다. 첫 번째 프레임이 그려진 후 시계를 끕니다. 가장 짧은 다른 방법보다 1 바이트를 절약하고 명백한 방법보다 약 4 바이트를 절약합니다.

  • 기본 7 숫자의 63 요소 배열로 업데이트되는 열 옆에 세 열의 상태를 저장합니다. 49의 장소는 열을 오른쪽으로, 7의 장소는 중간 열을, 단위 장소는 왼쪽 셀 -1을 살아있는 셀의 경우 0, 죽은 셀의 경우 0을 유지합니다. 그런 다음 수정 된 셀 주위의 세 숫자의 합계의 나머지 mod 6을 사용하여 라이브 이웃 셀의 총 수를 찾습니다 (9의 트릭으로 나눌 수있는 것과 같습니다)-나머지 7은 나머지 7과 같습니다 숫자). 자체적으로 약 10 바이트를 절약하고 다음 두 가지 최적화를 사용할 수있는 기회를 제공합니다. 다이어그램 예 (Y = 45의 특정 열을 중심으로 글라이더가 있다고 가정 해 봅시다)

    Row # | Cell State       | Stored number | Mod 6 = cell count
    ...
    44      Live, Live, Live   49+7+1 = 57     3
    45      Dead, Dead, Live   49+0+0 = 49     1
    46      Dead, Live, Dead   0+7+0  = 7      1
    ...
    

    센터 셀은 정확히 5 개의 라이브 셀로 둘러싸여 있기 때문에 죽은 상태로 유지됩니다.

  • 각 행이 완료되면 기존 숫자를 7로 나누고 소수 부분을 버리고 새 열의 셀 값을 49 배 더하여 배열의 숫자가 업데이트됩니다. 셀을 업데이트하기 전에 각 행의 셀 값을 저장해야하므로 매번 세 열을 모두 저장하면 속도가 훨씬 느리고 우아하며 최소 20 바이트 이상을 차지하며 1이 아닌 3 개의 목록을 사용합니다. 이것은 셀 위치를 저장하는 가장 작은 방법입니다.

  • 스 니펫 int(3fPart(3cosh(1입력이 3/6 일 2때, 4/6 일 0때 및 0, 1/6, 2/6 또는 5/6 일 때 제공합니다. 약 6 바이트를 절약합니다.


19

매스 매 티카-333

풍모:

  • 대화식 인터페이스 : 셀을 클릭하여 패턴 만들기

  • 멋진 그리드

  • 버튼 : RUN, PAUSE, CLEAR

코드는 다음과 같습니다.

Manipulate[x=Switch[run,1,x,2,CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},
{1,1}},x],3,Table[0,{k,40},{j,40}]];EventHandler[Dynamic[tds=Reverse[Transpose[x]];
ArrayPlot[tds,Mesh->True]],{"MouseClicked":>(pos=Ceiling[MousePosition["Graphics"]];
x=ReplacePart[x,pos->1-x[[Sequence@@pos]]];)}],{{run,3,""},{1->"||",2->">",3->"X"}}]

여기에 이미지 설명을 입력하십시오

이것이 어떻게 작동하는지 느끼고 싶다면 이 블로그의 두 번째 예는 위 코드의보다 정교한 버전 (실제 푸리에 분석, 더 나은 인터페이스)입니다. 무료 플러그인 다운로드 후 브라우저에서 예제가 바로 실행됩니다.


2
+1, 좋은 일입니다. 예, 그것은이 사이트의 문제입니다. 놓치기 쉬운 오래된 질문이 많이 있습니다.
그리핀

전혀 알아 차리지에 대한 @Griffin 감사)
비탈리 Kaurov

15

C 1063 자

도전 과제로 C에서 실시간 IO에 친숙하지 않은 Windows API를 사용하여이 작업을 수행했습니다. Capslock이 켜져 있으면 시뮬레이션이 실행됩니다. Capslock이 꺼져 있으면 여전히 유지됩니다. 마우스로 패턴을 그립니다. 왼쪽 클릭은 셀을 부활시키고 오른쪽 클릭은 셀을 죽입니다.

#include <windows.h>
#include<process.h>
#define K ][(x+80)%20+(y+80)%20*20]
#define H R.Event.MouseEvent.dwMousePosition
#define J R.Event.MouseEvent.dwButtonState
HANDLE Q,W;char*E[3],O;Y(x,y){return E[0 K;}U(x,y,l,v){E[l K=v;}I(){E[2]=E[1];E[1]=*E;*E=E[2];memset(E[1],0,400);}A(i,j,k,l,P){while(1){Sleep(16);for(i=0;i<20;++i)for(j=0;j<20;++j){COORD a={i,j};SetConsoleCursorPosition(Q,a);putchar(E[0][i+j*20]==1?'0':' ');}if(O){for(i=0;i<20;++i)for(j=0;j<20;++j){for(k=i-1,P=0;k<i+2;++k)for(l=j-1;l<j+2;++l){P+=Y(k,l);}U(i,j,1,P==3?1:Y(i,j)==1&&P==4?1:0);}I();}}}main(T,x,y,F,D){for(x=0;x<21;++x)puts("#####################");E[0]=malloc(800);E[1]=E[0]+400;I();I();W=GetStdHandle(-10);Q=GetStdHandle(-11);SetConsoleMode(W,24);INPUT_RECORD R;F=D=O=0;COORD size={80,25};SetConsoleScreenBufferSize(Q,size);_beginthread(A,99,0);while(1){ReadConsoleInput(W,&R,1,&T);switch(R.EventType){case 1:O=R.Event.KeyEvent.dwControlKeyState&128;break;case 2:switch(R.Event.MouseEvent.dwEventFlags){case 1:x=H.X;y=H.Y;case 0:F=J&1;D=J&2;}if(F)U(x,y,0,1);if(D)U(x,y,0,0);}}}

컴파일 된 EXE는 여기 에서 찾을 수 있습니다

편집 : 나는 소스를 주석했다. 그것은 가능한 여기에


댓글이 달린 버전을보고 싶습니다!
luser droog

1
물론, 내가 생각했던 것을 기억할 수 있다면 ... = p
Kaslai

1
@luserdroog 여기에 pastebin.com/BrX6wgUj
Kaslai가

이것은 굉장합니다.
rayryeng-복원 모니카

12

J (39 자)

l=:[:+/(3 4=/[:+/(,/,"0/~i:1)|.])*.1,:]

이 APL 버전 (동일한 알고리즘, 토 로이드 컨볼 루션)을 기반으로 합니다 .

사용법 예 :

   r =: (i.3 3) e. 1 2 3 5 8
   r
0 1 1          NB. A glider!
1 0 1
0 0 1

   R =: _1 _2 |. 5 7 {. r
   R
0 0 0 0 0 0 0  NB. Test board
0 0 0 1 1 0 0
0 0 1 0 1 0 0
0 0 0 0 1 0 0
0 0 0 0 0 0 0

   l R
0 0 0 0 0 0 0  NB. Single step
0 0 0 1 1 0 0
0 0 0 0 1 1 0
0 0 0 1 0 0 0
0 0 0 0 0 0 0

10

Mathematica, 123 자

Mathematica의 내장 CellularAutomaton 기능을 사용하지 않는 초보적인 구현입니다.

ListAnimate@NestList[ImageFilter[If[3<=Total@Flatten@#<=3+#[[2]][[2]],1,0]&,#,1]&,Image[Round/@RandomReal[1,{200,200}]],99]

8

루비 1.9 + SDL (380 325 314)

편집 : 314 자, 첫 번째 반복에서 추가 셀이 나타나는 버그가 수정되었습니다. 색상 루틴이 가장 낮은 8 비트 만 보이므로 그리드 크기를 56으로 올렸습니다.

편집 : 325 자로 줄었습니다. 값을 배경색으로 사용하면서 28 * 9가 가능한 최대 크기이므로 그리드 너비 / 높이는 28입니다. 또한 현재 반복마다 하나의 SDL 이벤트 만 처리하므로 내부 루프가 완전히 사라집니다. 꽤 꽉 생각합니다!

모든 셀이 죽은 상태에서 시뮬레이션이 일시 중지됩니다. 아무 키나 눌러 일시 정지 / 일시 정지 상태를 토글하고 셀을 클릭하여 활성 상태와 죽은 상태 사이를 전환 할 수 있습니다. 1/10 초마다 반복을 실행합니다.

포장은 약간 기이합니다.

require'sdl'
SDL.init W=56
R=0..T=W*W
b=[]
s=SDL::Screen.open S=W*9,S,0,0
loop{r="#{e=SDL::Event.poll}"
r['yU']?$_^=1:r[?Q]?exit: r['nU']?b[e.y/9*W+e.x/9]^=1:0
b=R.map{|i|v=[~W,-W,-55,-1,1,55,W,57].select{|f|b[(i+f)%T]}.size;v==3||v==2&&b[i]}if$_
R.map{|i|s.fillRect i%W*9,i/W*9,9,9,[b[i]?0:S]*3}
s.flip
sleep 0.1}

다음과 같습니다 :

실행중인 앱의 스크린 샷

재미있는 도전! 누구나 볼 수있는 개선 사항을 환영합니다.


시도는 좋았지 만 당신이 잘못되었음을 바로 알 수 있습니다. GoL에서는 이와 같은 패턴을 가질 수 없습니다. 규칙을 다시 읽으십시오. en.wikipedia.org/wiki/Conway%27s_Game_of_Life#Rules
Griffin

@Griffin 필자는 일부 셀을 일시 중지하고 수동으로 전환 한 후 스크린 샷을 찍은 것으로 생각합니다. 규칙을 다시 확인하겠습니다. 감사!
Paul Prestidge

7
@Griffin 시드 패턴을 구성 할 수 없습니까?
ardnew

7

스칼라, 1181 1158 1128 1063 1018 1003 999 992 987 자

import swing._
import event._
object L extends SimpleSwingApplication{import java.awt.event._
import javax.swing._
var(w,h,c,d,r)=(20,20,20,0,false)
var x=Array.fill(w,h)(0)
def n(y:Int,z:Int)=for(b<-z-1 to z+1;a<-y-1 to y+1 if(!(a==y&&b==z)))d+=x((a+w)%w)((b+h)%h)
def top=new MainFrame with ActionListener{preferredSize=new Dimension(500,500)
menuBar=new MenuBar{contents+=new Menu("C"){contents+={new MenuItem("Go/Stop"){listenTo(this)
reactions+={case ButtonClicked(c)=>r= !r}}}}}
contents=new Component{listenTo(mouse.clicks)
reactions+={case e:MouseClicked=>var p=e.point
x(p.x/c)(p.y/c)^=1
repaint}
override def paint(g:Graphics2D){for(j<-0 to h-1;i<-0 to w-1){var r=new Rectangle(i*c,j*c,c,c)
x(i)(j)match{case 0=>g draw r
case 1=>g fill r}}}}
def actionPerformed(e:ActionEvent){if(r){var t=x.map(_.clone)
for(j<-0 to h-1;i<-0 to w-1){d=0
n(i,j)
x(i)(j)match{case 0=>if(d==3)t(i)(j)=1
case 1=>if(d<2||d>3)t(i)(j)=0}}
x=t.map(_.clone)
repaint}}
val t=new Timer(200,this)
t.start}}

언 골프 드 :

import swing._
import event._

object Life extends SimpleSwingApplication
{
    import java.awt.event._
    import javax.swing._
    var(w,h,c,d,run)=(20,20,20,0,false)
    var x=Array.fill(w,h)(0)
    def n(y:Int,z:Int)=for(b<-z-1 to z+1;a<-y-1 to y+1 if(!(a==y&&b==z)))d+=x((a+w)%w)((b+h)%h)
    def top=new MainFrame with ActionListener
    {
        title="Life"
        preferredSize=new Dimension(500,500)
        menuBar=new MenuBar
        {
            contents+=new Menu("Control")
            {
                contents+={new MenuItem("Start/Stop")
                {
                    listenTo(this)
                    reactions+=
                    {
                        case ButtonClicked(c)=>run= !run
                    }
                }}
            }
        }
        contents=new Component
        {
            listenTo(mouse.clicks)
            reactions+=
            {
                case e:MouseClicked=>
                    var p=e.point
                    if(p.x<w*c)
                    {
                        x(p.x/c)(p.y/c)^=1
                        repaint
                    }
            }
            override def paint(g:Graphics2D)
            {
                for(j<-0 to h-1;i<-0 to w-1)
                {
                    var r=new Rectangle(i*c,j*c,c,c)
                    x(i)(j) match
                    {
                        case 0=>g draw r
                        case 1=>g fill r
                    }
                }
            }
        }
        def actionPerformed(e:ActionEvent)
        {
            if(run)
            {
                var t=x.map(_.clone)
                for(j<-0 to h-1;i<-0 to w-1)
                {
                    d=0
                    n(i,j)
                    x(i)(j) match
                    {
                        case 0=>if(d==3)t(i)(j)=1
                        case 1=>if(d<2||d>3)t(i)(j)=0
                    }
                }
                x=t.map(_.clone)
                repaint
            }
        }
        val timer=new Timer(200,this)
        timer.start
    }
}

이 코드의 큰 부분은 Swing GUI입니다. 게임 자체는에 actionPerformed의해 트리거되는 방법 Timern이웃을 계산 하는 도우미 기능 에 있습니다.

용법:

로 컴파일 scalac filename한 다음로 실행하십시오 scala L.
사각형을 클릭하면 사각형이 실시간으로 바뀌고 메뉴 옵션이 시작되고 게임이 중지됩니다. 격자의 크기를 변경하려면 선의 처음 세 값을 변경하십시오. var(w,h,c,d,r)=(20,20,20,0,false)너비, 높이 및 셀 크기는 각각 픽셀 단위입니다.


: 나는이 골프 - 개선 사항을 발견 import java.awt.event._하고 contents+=m("Go",true)+=m("Stop",false)}}1093 자에 이르는.
사용자가 알 수 없음

@user unknown 감사합니다. 나는 지금 1063까지 몇 가지 개선점을 발견했습니다.
Gareth

당신이 바빴어 젠장. 유지하십시오! 더 많은 사람들이 게시하면 답변을 테스트 할 것입니다.
Griffin

7

순수 배쉬, 244 바이트

토 로이드로 감싼 36x24 유니버스에서 작동합니다.

mapfile a
for e in {0..863};{
for i in {0..8};{
[ "${a[(e/36+i/3-1)%24]:(e+i%3-1)%36:1}" == O ]&&((n++))
}
d=\ 
c=${a[e/36]:e%36:1}
[ "$c" == O ]&&((--n==2))&&d=O
((n-3))||d=O
b[e/36]+=$d
n=
}
printf -vo %s\\n "${b[@]}"
echo "$o"
exec $0<<<"$o"

이것은 쉘 스크립트이기 때문에 입력 방법은 다른 쉘 명령과 일치합니다 (예 : stdin).

$ ./conway.sh << EOF

   O 
    O 
  OOO 

EOF


  O O                                                       
   OO                                                       
   O                                                        

















    O                                                       
  O O                                                       
   OO                                                       

... 등

tr필터를 통해 파이프 된 모든 텍스트 소스의 입력을 리디렉션 하여 흥미로운 초기 세대를 얻을 수 있습니다.

man tr | tr [:alnum:] O | ./conway.sh

6

자바 스크립트, 130

도전에 완전히 응답하지는 않지만 레코드에 대해서는 2013 년 Subzey와 I가 만든 130 바이트의 Game of Life 엔진이 있습니다.

http://xem.github.io/miniGameOfLife/

/* Fill an array with 0's and 1's, and call g(array, width, height) to iterate */
g=function(f,c,g,d,e,b,h){g=[];e=[c+1,c,c-1,1];for(b=c*c;b--;g[b]=3==d||f[b]&&2==d,d=0)for(h in e)d+=f[b+e[h]]+f[b-e[h]];return g}

이것은 첫 번째 행에 문제가있는 것 같습니다. 예를 들어 설정 @@\n@@(왼쪽 상단에 2x2 정사각형) 또는 .@\n.@\n.@. (1 x 3 열)
Annan

5

C #-675 자

나는 항상이 프로그램의 버전을 만들고 싶었다. 빠르고 더러운 버전의 경우 30 분만 게으 르면된다는 것을 결코 알지 못했습니다. (골프는 물론 더 오래 걸립니다.)

using System.Windows.Forms;class G:Form{static void Main(){new G(25).ShowDialog();}
public G(int z){var g=new Panel[z,z];var n=new int [z,z];int x,y,t;for(int i=0;i<z;
i++)for(int j=0;j<z;j++){var p=new Panel{Width=9,Height=9,Left=i*9,Top=j*9,BackColor
=System.Drawing.Color.Tan};p.Click+=(s,a)=>p.Visible=!p.Visible;Controls.Add(g[i,j]=
p);}KeyUp+=(s,_)=>{for(int i=0;i<99;i++){for(x=0;x<z;x++)for(y=0;y<z;y++){t=0;for(int 
c=-1;c<2;c++)for(int d=-1;d<2;d++)if(c!=0||d!=0){int a=x+c,b=y+d;a=a<0?24:a>24?0:a;b=
b<0?24:b>24?0:b;t+=g[a,b].Visible?0:1;}if(t==3||t>1&&!g[x,y].Visible)n[x,y]=1;if(t<2
||t>3)n[x,y]=0;}for(x=0;x<z;x++)for(y=0;y<z;y++)g[x,y].Visible=n[x,y]<1;Update();}};}}

용법

  • 셀을 클릭하여 활성화 (시작)하여 시작 패턴을 입력하십시오.
  • 키보드 키를 눌러 게임을 시작하십시오.
  • 키를 누를 때마다 99 세대 동안 게임이 실행됩니다 (문자를 저장하기 위해 9 개를 만들 수는 있지만 너무 절름발이했습니다).

골프 타협

  • 마우스를 사용하여 셀을 켜고 끌 수는 없습니다. 실수를 한 경우 프로그램을 다시 시작해야합니다.
  • 그리드 라인은 없지만 재생 능력을 크게 손상시키지 않습니다.
  • 업데이트 속도는 CPU 속도에 비례하므로 매우 빠른 컴퓨터에서는 흐려질 수 있습니다.
  • "검은 색"은 2자를 더 사용하기 때문에 살아있는 세포는 빨간색입니다.
  • 셀의 크기가 작고 모든 폼 공간을 다 사용하지 않는다는 사실도 문자 절약의 타협입니다.

5

GW-BASIC, 1086 1035 바이트 (토큰 화)

토큰 화 된 형식에서 이것은 1035 바이트입니다. (ASCII 형식은 물론 약간 더 깁니다.) 인터프리터에 SAVE"life추가하지 않고 명령 을 사용하여 토큰 화 된 형식을 얻을 수 ",a있습니다.

10 DEFINT A-Z:DEF SEG=&HB800:KEY OFF:COLOR 7,0:CLS:DEF FNP(X,Y)=PEEK((((Y+25)MOD 25)*80+((X+80)MOD 80))*2)
20 X=0:Y=0
30 LOCATE Y+1,X+1,1
40 S$=INKEY$:IF S$=""GOTO 40
50 IF S$=CHR$(13)GOTO 150
60 IF S$=" "GOTO 130
70 IF S$=CHR$(0)+CHR$(&H48)THEN Y=(Y-1+25)MOD 25:GOTO 30
80 IF S$=CHR$(0)+CHR$(&H50)THEN Y=(Y+1)MOD 25:GOTO 30
90 IF S$=CHR$(0)+CHR$(&H4B)THEN X=(X-1+80)MOD 80:GOTO 30
100 IF S$=CHR$(0)+CHR$(&H4D)THEN X=(X+1)MOD 80:GOTO 30
110 IF S$="c"THEN CLS:GOTO 20
120 GOTO 40
130 Z=PEEK((Y*80+X)*2):IF Z=42 THEN Z=32ELSE Z=42
140 POKE(Y*80+X)*2,Z:GOTO 40
150 LOCATE 1,1,0:ON KEY(1)GOSUB 320:KEY(1) ON
160 V!=TIMER+.5:FOR Y=0 TO 24:FOR X=0 TO 79:N=0
170 Z=FNP(X-1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
180 Z=FNP(X,Y-1):IF Z=42 OR Z=46 THEN N=N+1
190 Z=FNP(X+1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
200 Z=FNP(X-1,Y):IF Z=42 OR Z=46 THEN N=N+1
210 Z=FNP(X+1,Y):IF Z=42 OR Z=46 THEN N=N+1
220 Z=FNP(X-1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
230 Z=FNP(X,Y+1):IF Z=42 OR Z=46 THEN N=N+1
240 Z=FNP(X+1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
250 Z=PEEK((Y*80+X)*2):IF Z=32 THEN IF N=3 THEN Z=43
260 IF Z=42 THEN IF N<2 OR N>3 THEN Z=46
270 POKE(Y*80+X)*2,Z:NEXT:NEXT:FOR Y=0 TO 24:FOR X=0 TO 79:Z=PEEK((Y*80+X)*2):IF Z=46 THEN Z=32
280 IF Z=43 THEN Z=42
290 POKE(Y*80+X)*2,Z:NEXT:NEXT
300 IF TIMER<V!GOTO 300
310 IF INKEY$=""GOTO 160
320 SYSTEM

이것은 최대 골프 버전이지만 여전히 기능적입니다. 시작할 때 커서 키로 이동할 수있는 편집기가 제공됩니다. space는 현재 필드에서 박테리아를 켜거나 끄고 c, 화면을 지우고, Return은 게임 모드를 시작합니다.

다음은 난독 화 버전으로, 두 가지 구조 (원형 회전 물체 및 글라이더)로 초기 게임 보드를 설정합니다.

1000 REM Conway's Game of Life
1001 REM -
1002 REM Copyright (c) 2012 Thorsten "mirabilos" Glaser
1003 REM All rights reserved. Published under The MirOS Licence.
1004 REM -
1005 DEFINT A-Z:DEF SEG=&hB800
1006 KEY OFF:COLOR 7,0:CLS
1007 DEF FNP(X,Y)=PEEK((((Y+25) MOD 25)*80+((X+80) MOD 80))*2)
1010 PRINT "Initial setting mode, press SPACE to toggle, RETURN to continue"
1020 PRINT "Press C to clear the board, R to reset. OK? Press a key then."
1030 WHILE INKEY$="":WEND
1050 CLS
1065 DATA 3,3,4,3,5,3,6,3,7,3,8,3,3,4,4,4,5,4,6,4,7,4,8,4
1066 DATA 10,3,10,4,10,5,10,6,10,7,10,8,11,3,11,4,11,5,11,6,11,7,11,8
1067 DATA 11,10,10,10,9,10,8,10,7,10,6,10,11,11,10,11,9,11,8,11,7,11,6,11
1068 DATA 4,11,4,10,4,9,4,8,4,7,4,6,3,11,3,10,3,9,3,8,3,7,3,6
1069 DATA 21,0,22,1,22,2,21,2,20,2,-1,-1
1070 RESTORE 1065
1080 READ X,Y
1090 IF X=-1 GOTO 1120
1100 POKE (Y*80+X)*2,42
1110 GOTO 1080
1120 X=0:Y=0
1125 LOCATE Y+1,X+1,1
1130 S$=INKEY$
1140 IF S$="" GOTO 1130
1150 IF S$=CHR$(13) GOTO 1804
1160 IF S$=" " GOTO 1240
1170 IF S$=CHR$(0)+CHR$(&h48) THEN Y=(Y-1+25) MOD 25:GOTO 1125
1180 IF S$=CHR$(0)+CHR$(&h50) THEN Y=(Y+1) MOD 25:GOTO 1125
1190 IF S$=CHR$(0)+CHR$(&h4B) THEN X=(X-1+80) MOD 80:GOTO 1125
1200 IF S$=CHR$(0)+CHR$(&h4D) THEN X=(X+1) MOD 80:GOTO 1125
1210 IF S$="c" THEN CLS:GOTO 1120
1220 IF S$="r" GOTO 1050
1225 IF S$=CHR$(27) THEN END
1230 GOTO 1130
1240 Z=PEEK((Y*80+X)*2)
1250 IF Z=42 THEN Z=32 ELSE Z=42
1260 POKE (Y*80+X)*2,Z
1270 GOTO 1130
1804 LOCATE 1,1,0
1900 ON KEY(1) GOSUB 2300
1910 KEY(1) ON
2000 V!=TIMER+.5
2010 FOR Y=0 TO 24
2020  FOR X=0 TO 79
2030   N=0
2040   Z=FNP(X-1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
2050   Z=FNP(X  ,Y-1):IF Z=42 OR Z=46 THEN N=N+1
2060   Z=FNP(X+1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
2070   Z=FNP(X-1,Y  ):IF Z=42 OR Z=46 THEN N=N+1
2080   Z=FNP(X+1,Y  ):IF Z=42 OR Z=46 THEN N=N+1
2090   Z=FNP(X-1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
2100   Z=FNP(X  ,Y+1):IF Z=42 OR Z=46 THEN N=N+1
2110   Z=FNP(X+1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
2120   Z=PEEK((Y*80+X)*2)
2130   IF Z=32 THEN IF N=3 THEN Z=43
2140   IF Z=42 THEN IF N<2 OR N>3 THEN Z=46
2150   POKE (Y*80+X)*2,Z
2160  NEXT X
2170 NEXT Y
2200 FOR Y=0 TO 24
2210  FOR X=0 TO 79
2220   Z=PEEK((Y*80+X)*2)
2230   IF Z=46 THEN Z=32
2240   IF Z=43 THEN Z=42
2250   POKE (Y*80+X)*2,Z
2260  NEXT X
2270 NEXT Y
2280 IF TIMER<V! GOTO 2280
2290 IF INKEY$="" GOTO 2000
2300 SYSTEM

나는 지루하고 친구를 기다리는 동안 15 분 안에 이것을 썼다. 친구는 Conway의 Game of Life에 대한 그의“견습생”과 동시에 코드 골프를하고 있었다.

다음과 같이 작동합니다. 80x25 텍스트 모드 화면 버퍼를 즉시 사용합니다 ( Hercules 그래픽 카드 DEF SEG를 사용하는 &hB000경우 이니셜 을 변경하십시오 . 이러한 설정은 Qemu 및 (느린) 도스 박스에서 작동 함). 별표 *는 박테리아입니다.

그것은 두 단계로 작동합니다 : 첫째, 출생지에는 표시가 +있고 사망 표시 는로 표시 됩니다 .. 두 번째 패스, +.치환되고 *그리고 각각.

TIMER것은 그것이 각 라운드 후 0.5 초를 기다릴 수 있도록하는 것입니다, 경우에 당신의 Qemu 호스트는 매우 빠른 ☺입니다

나는 여기에서 가장 짧은 가격을 기대하지 않고 특히 초기 보드 설정을 고려할 때 시원한 가격을 원합니다. 또한 관심이있는 경우 게임 엔진이 어셈블리 코드로 대체 된 버전도 있습니다.


골프가 아닌 버전에서 라벨을 1 씩 늘렸다는 것을 고려할 때 골프 버전에서도 동일한 작업을 수행 할 수 있습니까? (즉, 1, 2, 3, 등) 또는 행 번호가 포함되지 않습니다?
Zacharý

완전히 실수하지 않은 경우 줄 번호는 토큰으로 표시 될 때 단어 (16 비트)로 계산됩니다.
mirabilos

그렇다면 다른 기본 방언을 생각했을 것입니다.
Zacharý

@ Zacharý “GW-BASIC 토큰 화 된 프로그램 형식”을 클릭 한 후 여기에서“프로그램 형식”을 클릭 하면 실제로 줄 번호가 2 바이트이며 토큰 형식에 대한 자세한 내용을 볼 수 있습니다.
mirabilos

5

Mathematica, 115 바이트

여기에 대한 쉬운 대처 방법이 있습니다.

ListAnimate[ArrayPlot/@CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},
{2,2,2}}},{1,1}},{RandomInteger[1,{9,9}],0},90]]

1
Mathematica는 괜찮지 만 규칙에 따라 프로그램은 사용자가 자신의 패턴을 입력 할 수 있도록해야합니다. 이 규칙은 일부 언어는 이와 같은 짧은 구현을 허용하지만 사용자 상호 작용은 없기 때문에 의도적입니다. 물론 거기에 자신의 배열을 넣을 수는 있지만 이길 수는 없습니다.
Griffin

Mathematica의 "입력"은 대부분 노트북 인터페이스를 통해 이루어 지므로 "사용자 상호 작용"이 실제로 가능하다고 생각하지 않습니다. RandomInteger 인수를 CellularAutomaton 함수로 원하는 것으로 바꾸고 코드를 다시 평가하면됩니다.
JeremyKun

3
사용자 상호 작용이 가능합니다. 내가 지금 생각할 수있는 가장 간단한 방법은 버튼 배열입니다. 가자.
그리핀

4

Java (OpenJDK 8) -400 388 367 바이트

두 번째와 (아마도) 최종 편집 : 골프 관리는이 (IMO) 발견 후 추가로 21 바이트 광산 - 확실히 (자바를 사용하여 이러한 문제 중 일부를 시도하는거야 특히 경우) 다음을 읽고 새로운 사람들을 추천합니다.

결과 코드 (아마도 이중 중첩 for 루프를 줄이는 방법을 찾으면 골프를 더 많이 끝낼 것입니다 ...) :

u->{int w=u.length,h=u[0].length,x,y,i,j,n;Stack<Point>r=new Stack<Point>();for(;;){for(Point c:r)u[c.x][c.y]=1;r.clear();for(x=0;x<w;++x)for(y=0;y<h;++y){boolean o=u[x][y]>0;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]>0)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]+(y>h-2?"\n":""));}for(int[]t:u)Arrays.fill(t,0);}}

온라인으로 사용해보십시오!

(원본 게시물은 여기서 시작합니다.)

실제로 Java 롤에 대한 (아마도 제한적 인) 지식으로 적어도 최고의 Python 답변에 도전 할 수있을 것이라고 생각했습니다. 조금 늦었다 ...)

그다지 중요하지는 않습니다-기본 설명은 다음과 같습니다 (ungolfed).

/*
 * Explanation of each variable's usage:
 * w=height* of array
 * h=width* of array
 * x=y* coord of point in array
 * y=x* coord of point in array
 * i and j are counters for calculating the neighbours around a point in the array
 * n=neighbour counter
 * r=temporary array to store the cells from the current generation
 * u=the 2d array used for all the calculations (parameter from lambda expression)
 * c=temporary variable used to help populate the 2d array
 * o=boolean variable that stores the value of whether the cell is alive or not
 */
u-> // start of lambda statement with u as parameter (no need for brackets as it's only one parameter being passed)
{
    int w=u.length,h=u[0].length,x,y,i,j,n; // defines all the necessary integer variables;
    Stack<Point>r=new Stack<Point>(); // same with the only array list needed (note how I only use two data structures);
    for(;;) // notice how this is still an infinite loop but using a for loop;
    {
        for(Point c:r)u[c.x][c.y]=1; //for every point in the "previous" generation, add that to the 2D array as a live (evil?) cell;
        r.clear(); // clears the array list to be populated later on
        for(x=0;x<w;++x) // a pair of nested for loops to iterate over every cell of the 2D array;
        {
            for(y=0;y<h;++y)
            {
                // sets o to be the presence of a live cell at (x,y) then uses said value in initialising the neighbour counter;
                boolean o=u[x][y]>1;n=o?-1:0;
                for(i=-2;++i<2;) // another pair of nested for loops - this one iterates over a 3x3 grid around *each* cell of the 2D array;
                {                // this includes wrap-around (note the modulus sign in the if statement below);
                    for(j=-2;++j<2;)
                    {
                        if(u[(w+x+i)%w][(h+y+j)%h]>0)++n; // this is where the first interesting thing lies - the bit which makes wrap-around a reality;
                    }
                }
                if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y)); // this is the second interesting bit of my code - perhaps more so as I use bitwise operators to calculate the number of neighbours (x,y) has;
                                                            // (since I'm technically dealing with 0s and 1s, it's not a total misuse of them imo);
                System.out.print(u[x][y]+(y>h-2?"\n":""));  // that extra part of the print statement adds a newline if we reached the end of the current 'line';
            }
        }
        // since the information about the new generation is now in the array list, this array can be emptied out, ready to receive said info on the new generation;
        for(int[]t:u)Arrays.fill(t,0);
    }
} // end of lambda statement

(자바 8의 람다 문에 대한 자세한 정보는 여기 )

예, 접근 방식에 문제가 있습니다.

대부분의 사람들이 알고 있듯이 현재 골프 코드는 영원히 반복됩니다. 이를 방지하기 위해 맨 위에 카운터를 도입하고 while 루프에서 n다음과 같이 반복 만 표시 (이 경우 5) 할 수 있습니다 ( b추가 된 새 변수에 주목 ).

u->{int b=0,w=u.length,h=u[0].length,x,y,i,j,n;Stack<Point>r=new Stack<Point>();for(;++b<6;){for(Point c:r)u[c.x][c.y]=1;r.clear();for(x=0;x<w;++x)for(y=0;y<h;++y){boolean o=u[x][y]>0;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]>0)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]+(y>h-2?"\n":""));}for(int[]t:u)Arrays.fill(t,0);}}

또한 언급 할만한 몇 가지 사항이 있습니다. 이 프로그램은 입력이 올바른지 확인하지 않으므로 ArrayOutOfBoundsException; 따라서 배열의 일부를 완전히 채워 입력이 유효한지 확인하십시오 (꼬치 배열은 위에서 언급 한 예외를 발생시킵니다). 또한 현재 보드는 '유체'처럼 보입니다. 즉, 한 세대와 다음 세대 사이에 분리가 없습니다. 생산중인 세대가 실제로 유효한지 다시 확인 System.out.println();하기 위해 추가하려면 추가하기 전에 추가 해야합니다 for(int[]t:u)Arrays.fill(t,0);( 명확성을 위해 온라인으로 사용해보십시오! 참조 ). 그리고 마지막으로 이것이 내 첫 번째 코드 골프라는 점을 감안할 때 모든 의견을 크게 높이 평가합니다. :)

이전 388 바이트 답변의 이전 코드 :

u->{int w=u.length,h=u[0].length,x,y,i,j,n;ArrayList<Point>r=new ArrayList<Point>();while(true){for(Point c:r)u[c.x][c.y]=1;r.clear();for(x=0;x<w;++x){for(y=0;y<h;++y){boolean o=u[x][y]==1;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]==1)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]);}System.out.println();}for(int[]t:u)Arrays.fill(t,0);}}

그리고 초기 400 바이트 답변에서 :

int w=35,h=20,x,y,i,j,n;ArrayList<Point>l=new ArrayList<Point>(),r;while(true){int[][]u=new int[w][h];for(Point c:l)u[c.x][c.y]=1;r=new ArrayList<Point>();for(x=0;x<w;++x){for(y=0;y<h;++y){boolean o=u[x][y]==1;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]==1)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]);}System.out.println();}l.clear();l.addAll(r);}

놀라운 첫 번째 게시물, PPCG에 오신 것을 환영합니다!
Zacharý

고마워, 나는 확실히 더 많은 일을 할거야-그들은 재미있어 :)
NotBaal

우리와 함께 데니스가 있습니다. 또한 이것은 완전한 프로그램이나 기능이 아니며 IIRC 여야합니다.
Zacharý

오 '프로그램'부분을 잊어 버렸습니다 : P 조금 편집하십시오.
NotBaal

그냥 기능 일 수도 있습니다.
Zacharý

4

스텐실 , 6 바이트

아니 내가 좋아하는 언어는, 그러나 입니다 짧은 ...

4 코드 바이트와 nlist 및 Torus 플래그.

3me

온라인으로 사용해보십시오!

...인가
3 3
 의 멤버 m의 자신이나와 oore - 이웃 카운트  무어의 전자 자기없이 -neighbourhood 카운트 ...?
m
e


3

스칼라-799 자

스크립트로 실행하십시오. 사각형을 마우스로 클릭하면 사각형이 켜지거나 꺼지고 아무 키나 생성을 시작하거나 중지합니다.

import java.awt.Color._
import swing._
import event._
import actors.Actor._
new SimpleSwingApplication{var(y,r,b)=(200,false,Array.fill(20,20)(false))
lazy val u=new Panel{actor{loop{if(r){b=Array.tabulate(20,20){(i,j)=>def^(i:Int)= -19*(i min 0)+(i max 0)%20
var(c,n,r)=(0,b(i)(j),-1 to 1)
for(x<-r;y<-r;if x!=0||y!=0){if(b(^(i+x))(^(j+y)))c+=1}
if(n&&(c<2||c>3))false else if(!n&&c==3)true else n}};repaint;Thread.sleep(y)}}
focusable=true
preferredSize=new Dimension(y,y)
listenTo(mouse.clicks,keys)
reactions+={case e:MouseClicked=>val(i,j)=(e.point.x/10,e.point.y/10);b(i)(j)= !b(i)(j)case _:KeyTyped=>r= !r}
override def paintComponent(g:Graphics2D){g.clearRect(0,0,y,y);g.setColor(red)
for(x<-0 to 19;y<-0 to 19 if b(x)(y))g.fillRect(x*10,y*10,9,9)}}
def top=new Frame{contents=u}}.main(null)

3

J, 45

나는 J에게 시험해 보겠다고 생각했다. 아직 골프를 잘하지는 않았지만 곧 다시 시도하겠습니다.

(]+.&(3&=)+)+/((4&{.,(_4&{.))(>,{,~<i:1))&|.

예:

   f =: 5 5 $ 0 1 0 0 0   0 0 1 0 0   1 1 1 0 0   0 0 0 0 0    0 0 0 0 0
   f
0 1 0 0 0
0 0 1 0 0
1 1 1 0 0
0 0 0 0 0
0 0 0 0 0
   f (]+.&(3&=)+)+/((4&{.,(_4&{.))(>,{,~<i:1))&|. f
0 0 0 0 0
1 0 1 0 0
0 1 1 0 0
0 1 0 0 0
0 0 0 0 0

3

처리 536 532

int h=22,t=24,i,j;int[][]w=new int[t][t],b=new int[t][t];int[]q={1,0,-1};void draw(){if(t<9){clear();for(i=2;i<h;i++){for(j=2;j<h;j++)w[i][j]=b[i][j];w[i][1]=w[i][21];w[i][h]=w[i][2];w[1][i]=w[21][i];w[h][i]=w[2][i];}for(i=1;i<23;i++)for(j=1;j<23;j++){t=-w[i][j];for(int s:q)for(int d:q)t+=w[i+s][j+d];b[i][j]=w[i][j]>0&(t<2|t>3)?0:t==3?1:b[i][j];}a();}}void keyPressed(){t=0;}void mousePressed(){int i=mouseX/5+2,j=mouseY/5+2;w[i][j]=b[i][j]=1;a();}void a(){for(i=0;i<h-2;i++)for(j=0;j<h-2;j++)if(w[i+2][j+2]==1)rect(i*5,j*5,5,5);}

나는 이것이 모든 요구 사항을 만족한다고 생각합니다.

언 골프 드 :

int h=22,t=24,i,j;
int[][]w=new int[t][t],b=new int[t][t];
int[]q={1,0,-1};
void draw(){
  if(t<9){
  clear();
  for(i=2;i<h;i++){
    for(j=2;j<h;j++)
      w[i][j]=b[i][j];  
    w[i][1]=w[i][21];
    w[i][h]=w[i][2];
    w[1][i]=w[21][i];
    w[h][i]=w[2][i];
  }
  for(i=1;i<23;i++)
    for(j=1;j<23;j++){
      t=-w[i][j];
      for(int s:q)
        for(int d:q)
          t+=w[i+s][j+d];        
      b[i][j]=w[i][j]>0&(t<2|t>3)?0:t==3?1:b[i][j];  
  }
  a();
}
}
void keyPressed(){
  t=0;
}
void mousePressed(){
  int i=mouseX/5+2,j=mouseY/5+2;
  w[i][j]=b[i][j]=1;
  a();
}
void a(){
  for(i=0;i<h-2;i++)
    for(j=0;j<h-2;j++)
      if(w[i+2][j+2]==1)
        rect(i*5,j*5,5,5);
  }  

3

MATLAB (152)

b=uint8(rand(20)<0.2)
s=@(m)imfilter(m,[1 1 1;1 0 1;1 1 1],'circular')
p=@(m,n)uint8((n==3)|(m&(n==2)))
while 1
imshow(b)
drawnow
b=p(b,s(b))
end

나는 그것을 테스트하기 위해 Matlab을 지금 설치하지 않았으며, 몇 년 전에 작성한 코드를 골랐다.
언 골프 드 :

%% initialize
Bsize = 20;
nsteps = 100;
board = uint8(rand(Bsize)<0.2); % fill 20% of the board
boardsum = @(im) imfilter(im,[1 1 1; 1 0 1; 1 1 1], 'circular');
step = @(im, sumim) uint8((sumim==3) | (im & (sumim==2)) );

%% run
for i = 1:nsteps
    imshow(kron(board,uint8(ones(4))), [])
    drawnow
    ss(p,i) = sum(board(:));
    board = step(board, boardsum(board));
end
  • 보드 크기는 하드 코딩되어 있지만 무엇이든 가능
  • 사용자 입력의 경우 다른 매트릭스를 하드 코딩하거나 변수 편집기를 사용하여 초기 보드를 변경할 수 있습니다. 예쁘지 않지만 작동합니다.
  • 그래픽 출력을 건너 뛰면 20 개의 문자를 저장할 수 있으며, 반복 할 때마다 보드는 여전히 텍스트로 인쇄됩니다. 밀리 초마다 바뀌는 1 픽셀 셀은 그다지 유용하지 않습니다

R2014a에서 작동, 방금 테스트
masterX244

3

218 216 211 202 바이트

$,=$/;$~=AX3AAAx76;$b=pack('(A79)23',<>)x6;{print unpack'(a79)23a0',$b;select$v,$v,$v,0.1;$b=pack'(A)*',unpack'((x7a/(x13)X4Ax!18)1817@0)4',pack'((a*)17xx!18)*',unpack"x1737(AA$~Ax$~AA$~@)2222",$b;redo}

이 코드 끝에 줄 바꿈이 없습니다.

라이브 셀이로 표시되고 1데드 셀이 공백으로 표시되고 줄이 개행으로 구분되는 텍스트 파일로 표준 입력에서 시작 패턴을 읽습니다 . 입력에는이 이외의 문자가 없어야합니다. 줄 길이는 가변적 일 수 있으며 정확히 79 너비로 채워지거나 잘립니다. 입력 예는 글라이더 건입니다.

                                  1
                                1 1
                      11      11            11
                     1   1    11            11
          11        1     1   11
          11        1   1 11    1 1
                    1     1       1
                     1   1
                      11









                                         11
                                         1
                                          111
                                            1

프로그램이 Game of Life를 실행하면 모든 상태가 입력과 유사한 형식으로 표준 출력에 덤프 된 다음 0.1 초 지연됩니다. 선택 호출의 네 번째 인수를 변경하여 지연을 사용자 정의 할 수 있습니다.

게임 보드는 79x23 크기로 하드 코딩되어 있습니다. 그것은 원환 체에 싸여있다 : 만약 당신이 바닥에 보드를 남겨두면, 당신은 상단에있게된다; 오른쪽에두면 왼쪽에 있지만 한 줄 아래로 이동합니다.

다음은 입력을 읽지 않고 임의의 보드에서 시작하는 대체 버전입니다.

$,=$/;$/=AX3AAAx76;$b=pack("(A)*",map{rand 3<1}0..1816)x6;{print unpack'(a79)23a0',$b;select$v,$v,$v,0.1;$b=pack'(A)*',unpack'((x7a/(x13)X4Ax!18)1817@0)4',pack'((a*)17xx!18)*',unpack"x1737(AA$/Ax$/AA$/@)2222",$b;redo}

이 코드는 내가 몇 년 전에 쓴 펄 프로그램의 난독 화 된 게임 에서 파생 되었습니다 . 보드를 토 로이드로 만들고 코드를 골프로 만들기 위해 많이 변경했습니다.

이것은 아마도 Perl에서 Game of Life를 구현하는 가장 짧은 방법은 아니지만 이해하기 어려운 방법 중 하나입니다.

이 보드에 저장되는 $b문자열로 '1'하고 ' ', 각 셀에 대한 하나, 단지 모든 것은 적어도 세 번 반복한다. 세 번째 압축 해제 호출은 각 셀에 대해 17 개의 값을 추출합니다. 셀 자체에 대한 값 하나와 인접한 8 개의 셀 각각에 대해 2 개의 값이 임의의 순서로 있으며 각 값은 '1'빈 문자열입니다. 셀은 '1'다음 17 개의 값 중 5, 6 또는 7 인 경우 다음 반복에 존재해야합니다 . 세 번째 팩 호출은이 17 개의 값을 왼쪽으로 정렬되고 오른쪽에 널 바이트로 채워진 18 자 너비의 필드로 연결합니다. . 두 번째 압축 풀기 호출은 18 개의 넓은 필드를 가져 와서 위치 7에서 캐릭터를 디스패치합니다.'1'그렇지 않으면 위치 4에서 캐릭터의 압축을 풉니 다. 이 결과는 셀이 다음 세대에 가져야 할 가치입니다.


2

파이썬, 589 바이트

마우스 버튼 : 왼쪽-셀 배치, 오른쪽-셀 제거, 중간-시작 / 중지.

Tkinter 가져 오기에서 *
가져 오기 사본
z = 범위
F = 50
T = Tk ()
S = 9
f = [F * [0] i에서 '7'* F]
c = 캔버스 (T, 너비 = S * F, 높이 = S * F)
c.pack ()
데프 p (x, y, a) : f [y] [x] = f [y] [x] 또는 c.create_oval (x * S, y * S, x * S + S, y * S + S) 다른 경우 c.delete (f [y] [x])
r = 1
데프 R (e) : 전역 r; r = 1-r
exec ( "c.bind ( '<Button- % i>', lambda e : p (ex / S, ey / S, % i));"* 2 % (1,1,3,0))
c. 바인드 ( '<버튼 -2>', R)
데프 L () :
 T. 후 (99, L)
 r : return 인 경우
 g = 복사. 심도 (f)
 z (F)에서 y의 경우 :
	z (F)에서 x의 경우 :
	 n = 8
	 z (-1,2)에서 j의 경우 :
		z (-1,2)에서 i의 경우 :
		 i 또는 j 인 경우 : n- = g [[y + j) % F] [(x + i) % F]
	 1 <n <4 인 경우 :
		n == 3이고 g [y] [x]가 아닌 경우 : p (x, y, 1)
	 else : p (x, y, 0)
엘()
T. 메인 루프 ()

여기 마우스를 끌어서 그릴 수있는 버전이 있습니다. 그래픽이 좀 더 즐겁습니다.

from Tkinter import*
import copy
z=range
F=50
T=Tk()
S=9
f=[F*[0]for i in'7'*F]
c=Canvas(T,bg='white',width=S*F,height=S*F)
c.pack()
def p(x,y,a):f[y][x]=f[y][x]or c.create_rectangle(x*S,y*S,x*S+S,y*S+S,fill='gray')if a else c.delete(f[y][x])
r=1
def R(e):global r;r=1-r
exec("c.bind('<Button-%i>',lambda e:p(e.x/S,e.y/S,%i));c.bind('<B%i-Motion>',lambda e:p(e.x/S,e.y/S,%i));"*2%(1,1,1,1,3,0,3,0))
c.bind('<Button-2>',R)
def L():
 T.after(99,L)
 if r:return
 g=copy.deepcopy(f)
 for y in z(F):
  for x in z(F):
   n=8
   for j in z(-1,2):
    for i in z(-1,2):
     if i or j:n-=not g[(y+j)%F][(x+i)%F]
   if 1<n<4:
    if n==3and not g[y][x]:p(x,y,1)
   else:p(x,y,0)
L()
T.mainloop()

이것은 삶의 규칙을 올바르게 따르지 않습니다.
Steven Rumbalski

1
@StevenRumbalski : 아 진짜 요?
Oleh Prypin

2
정말. 두 번째 버전에서 들여 쓰기 오류가 있습니다. 시작 부분 if 1<n<4:은 다음과 같은 수준으로 들여 쓰기해야합니다.for j in z(-1,2):
Steven Rumbalski

2

파이썬 2, 456 바이트

나는 이것이 오래된 게시물이라는 것을 알고 있지만, 나는 그것을 쏘는 것을 도울 수 없었다. 초기 보드는 주변에 테두리를 그리고 마지막 줄에 여분의 공간이있는 한 어떤 크기라도 될 수 있습니다.

Golf.py

import time,itertools as w,sys;t,q=map(lambda x:list(x[:-1]),sys.stdin.readlines()),list(w.product(range(-1,2),range(-1,2)));del q[4];n=map(lambda x:x[:],t[:])
while time.sleep(0.1)==None:
 for j in range(1,len(t)-1):
  for i in range(1,len(t[j])-1):x=sum(map(lambda s:1 if t[j+s[0]][i+s[1]]in'@'else 0,q));f=t[j][i];n[j][i]='@'if(f=='@'and(x==3 or x==2))or(f==' 'and x==3)else' '
 t=map(lambda x:x[:],n[:]);print'\n'.join(list(map(lambda x:''.join(x),t)))

Input.txt (마지막 줄에 여분의 공간이 있음)

+----------------------------------------+
|                    @                   |
|                     @                  |
|                   @@@                  |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
+----------------------------------------+ 

실행하는 방법

python Golf.py < input.txt

time.sleep(0.1)==None=> not time.sleep(.1), (f=='@'and(x==3 or x==2)) 또는 (f == ''and x == 3) =>x==3or f=='@'and x==2
CalculatorFeline

^, 하나를 잊어 버렸습니다 1 if=> 1if.
Zacharý

2

가공 270,261 249 바이트

격자는 100 * 100 픽셀의 화면이며 입력은 png 그림의 형태로 나타납니다

void setup(){image(loadImage("g.png"),0,0);}void draw(){loadPixels();int n,i=0,j,l=10000;int[]a=new int[l],p=pixels;for(;i<l;a[i]=n==5?-1<<24:n==6?p[i]:-1,i++)for(j=n=0;j<9;j++)n+=j!=4?p[(i+l-1+j%3+100*(j/3-1))%l]&1:0;arrayCopy(a,p);updatePixels();}

언 골프

void setup() {
  image(loadImage("g.png"), 0, 0);
}
void draw() {
  loadPixels();
  int c=100, i=0, n, l=c*c, b=color(0);
  int[]a=new int[l], p=pixels;
  for (; i<l; i++) {
    n=p[(i+l-101)%l]&1;
    n+=p[(i+l-100)%l]&1;
    n+=p[(i+l-99)%l]&1;
    n+=p[(i+l-1)%l]&1;
    n+=p[(i+1)%l]&1;
    n+=p[(i+99)%l]&1;
    n+=p[(i+100)%l]&1;
    n+=p[(i+101)%l]&1;
    a[i]=n==5?b:p[i]==b&&n==6?b:-1;
  }
  arrayCopy(a, pixels, l);
  updatePixels();
}

스크린 샷


2

루아 + LÖVE / Love2D , 653 바이트

l=love f=math.floor t={}s=25 w=20 S=1 for i=1,w do t[i]={}for j=1,w do t[i][j]=0 end end e=0 F=function(f)loadstring("for i=1,#t do for j=1,#t[i]do "..f.." end end")()end function l.update(d)if S>0 then return end e=e+d if e>.2 then e=0 F("c=0 for a=-1,1 do for b=-1,1 do if not(a==0 and b==0)then c=c+(t[((i+a-1)%w)+1][((j+b-1)%w)+1]>0 and 1 or 0)end end end g=t[i][j]t[i][j]=(c==3 or(c==2 and g==1))and(g==1 and 5 or-1)or(g==1 and 4 or 0)")F("t[i][j]=t[i][j]%2")end end function l.draw()F("l.graphics.rectangle(t[i][j]==1 and'fill'or'line',i*s,j*s,s,s)")end function l.mousepressed(x,y)S=0 o,p=f(x/s),f(y/s)if t[o]and t[o][p]then t[o][p]=1 S=1 end end

또는 간격 :

l=love
f=math.floor
t={}s=25
w=20
S=1
for i=1,w do
    t[i]={}
    for j=1,w do
        t[i][j]=0
    end
end
e=0
F=function(f)
    loadstring("for i=1,#t do for j=1,#t[i] do  "..f.." end end")()
end
function l.update(d)
    if S>0 then
        return
    end
    e=e+d
    if e>.2 then
        e=0
        F([[
        c=0
        for a=-1,1 do
            for b=-1,1 do
                if not(a==0 and b==0)then
                    c=c+(t[((i+a-1)%w)+1][((j+b-1)%w)+1]>0 and 1 or 0)
                end
            end
        end
        g=t[i][j]
        t[i][j]=(c==3 or(c==2 and g==1))and(g==1 and 5 or-1) or (g==1 and 4 or 0)]])
        F("t[i][j]=t[i][j]%2")
    end
end
function l.draw()
    F("l.graphics.rectangle(t[i][j]==1 and'fill'or'line',i*s,j*s,s,s)") end
function l.mousepressed(x,y)
    S=0
    o,p=f(x/s),f(y/s)
    if t[o]and t[o][p] then
        t[o][p]=1
        S=1
    end
end

살아있는 세포를 추가하려면 필드를 클릭하십시오. 필드 외부를 클릭하여 실행하십시오.

온라인으로 사용해보십시오!

여기에 이미지 설명을 입력하십시오


1

추신 529 515

Rosetta Code 의 예제로 시작했습니다 . gs -- gol.ps pulsar20 * 20 이진수 (공백으로 구분)를 포함하는 파일 이름 인수 ( )를 호출 하십시오. 무한 루프 : 보드 그리기, 엔터 기다림, 차세대 계산.

[/f ARGUMENTS 0 get(r)file/n 20>>begin[/m
n 1 sub/b[n{[n{f token pop}repeat]}repeat]/c 400
n div/F{dup 0 lt{n add}if dup n ge{n sub}if}>>begin{0
1 m{dup 0 1 m{2 copy b exch get exch get 1 xor setgray
c mul exch c mul c c rectfill dup}for pop pop}for
showpage/b[0 1 m{/x exch def[0 1 m{/y exch def 0
y 1 sub 1 y 1 add{F dup x 1 sub 1 x
1 add{F b exch get exch get 3 2 roll add exch
dup}for pop pop}for b x get y get sub b x get y get
0 eq{3 eq{1}{0}ifelse}{dup 2 eq exch 3 eq
or{1}{0}ifelse}ifelse}for]}for]def}loop

몇 개의 스택 주석 (필요한 주석)이 있습니다.

[
/f ARGUMENTS 0 get(r)file
/n 20
/sz 400
%/r{rand 2147483647 div}
>>begin
[
/m n 1 sub
/b[
%n{[n{r .15 le{1}{0}ifelse}repeat]}repeat
 n{[n{f token pop}repeat]}repeat
]
/c sz n div
/F{dup 0 lt{n add}if dup n ge{n sub}if}
>>begin
{
    0 1 m{dup % y y
    0 1 m{ % y y x
        2 copy b exch get exch get 1 xor setgray
        c mul exch c mul c c rectfill
        dup 
    }for pop pop}for
    pstack
    showpage
    /b[0 1 m{/x exch def
      [0 1 m{/y exch def
          0   
          y 1 sub 1 y 1 add{F dup %s y y
          x 1 sub 1 x 1 add{F %s y y x
              b exch get exch get %s y bxy
              3 2 roll add exch %s+bxy y
              dup %s y y
          }for pop pop}for
          b x get y get sub
          b x get y get
          0 eq{3 eq{1}{0}ifelse}{dup 2 eq exch 3 eq or{1}{0}ifelse}ifelse
      }for]
      }for]def
}loop

펄서 데이터 파일 :

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 1 1 1 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 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 0 0 1 1 1 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 1 1 1 0 0 0 1 1 1 0 0 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 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 1 1 1 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 0 0 0 0 0 0 0 0 0

1

자바 스크립트 676

미안 그리핀, 난 그냥 당신의 코드를보고 약간 다시 작성하지 못했습니다 ... 두 문자를 면도해야하지만 그만한 가치가 있었다!

b=[];r=c=s=20;U=document;onload=function(){for(z=E=0;z<c;++z)for(b.push(t=[]),j=0;j<r;j++)with(U.body.appendChild(U.createElement("button")))t.push(0),id=z+"_"+j,style.position="absolute",style.left=s*j+"px",style.top=s*z+"px",onclick=a}; ondblclick=function(){A=E=E?clearInterval(A):setInterval(function(){Q=[];for(z=0;z<c;++z){R=[];for(j=0;j<r;)W=(c+z-1)%c,X=(c+z+1)%c,Y=(r+j-1)%r,Z=(r+j+1)%r,n=b[W][Y]+b[z][Y]+b[X][Y]+b[W][j]+b[X][j]+b[W][Z]+b[z][Z]+b[X][Z],R.push(b[z][j++]?4>n&&1<n:3==n);Q.push(R)}b=Q.slice();d()})};function a(e){E?0:P=e.target.id.split("_");b[P[0]][P[1]]^=1;d()}function d(){for(z=0;z<c;++z)for(j=0;j<r;)U.getElementById(z+"_"+j).innerHTML=b[z][j++]-0}

그러나 그들이 말하는 것처럼 허가보다 용서를 구하는 것이 더 쉽습니다 ...;)


1

옥타브 (153)

Shortest Game of Life의 DenDenDo의 Matlab과 동일 하지만 imshow 를 imagesc로 변경해야했습니다.

b=uint8(rand(20)<0.2)
s=@(m)imfilter(m,[1 1 1;1 0 1;1 1 1],'circular')
p=@(m,n)uint8((n==3)|(m&(n==2)))
while 1
imagesc(b)
drawnow
b=p(b,s(b))
end

1

파이썬 2 : 334 바이트

겨우 6 년.

import time
s='';s=map(list,iter(raw_input,s));k=len(s);l=(-1,0,1);n=int;z=range
while 1:
 r=[[0]*k for i in z(k)]
 for i in z(k*k):
  a,b=i//k,i%k
  m,g=sum([n(s[(a+c)%k][(b+d)%k])for c in l for d in l if c|d]),n(s[a][b])
  r[a][b]=n((m==2)&g or m==3)
  print'*'if r[a][b]else' ',
  if b-k+1==0:print
 s=r;time.sleep(.2);print"\033c"

다음과 같이 실행할 수 있습니다.

python gol.py
0000000
0001000
0000100
0011100
0000000
0000000
0000000

0과 1이 죽은 세포와 살아있는 세포를 나타내는 경우 끝에 줄 바꿈이 추가로 실행됩니다.

격자는 정사각형이어야합니다.

가장 짧은 파이썬보다 실행하기 쉽고 모든 크기의 그리드를 지원하며 실행하면 예쁘게 보입니다.

또한 100 바이트 더 많으므로 그 결과가 있습니다.


0

PHP, 201 바이트 (테스트되지 않음)

for($s=file(f);print"\n";$s=$t)foreach($s as$y=>$r)for($x=-print"
";"
"<$c=$s[$y][++$x];print$t[$y][$x]=" X"[$n<4&$n>2-$a])for($n=-$a=$c>A,$i=$x-!!$x-1;$i++<=$x;)for($k=$y-2;$k++<=$y;)$n+=$s[$k][$i]>A;

로 실행하십시오 -nr.

고장

for($s=file(f);                         # import input from file "f"
    print"\n";                              # infinite loop: 1. print newline
    $s=$t)                                  # 3. copy target to source, next iteration
    foreach($s as$y=>$r)                    # 2. loop through lines
        for($x=-print"\n";"\n"<$c=$s[$y][++$x]; # print newline, loop $x/$c through line characters (before line break)
            print                                   # 5. print new cell
                $t[$y][$x]=" X"[$n>2-$a&$n<4])      # 4. new cell is alive if neighbour count<4 and >2 (>1 if alive)
            for($n=-                                # 2. init neighbour count: exclude self
                $a=$c>A,                            # 1. $a=cell is alife
                $i=$x-!!$x-1;$i++<=$x;)             # 3. loop $i from one left to one right of current position
                for($k=$y-2;$k++<=$y;)                  # loop $k from one above to one below current position
                    $n+=$s[$k][$i]>A;                       # increase neighbor count if neighbour is alife
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.