삶과 피로의 게임

10

Stewie의 Game of Life and Fatigue는 유명한 Conway의 Game of Life 와 매우 유사합니다 .

Stewie 's Game of Life and Fatigue (GoLF)의 우주는 무한한 2 차원 직교 그리드 셀로, 살아 있거나 죽거나 피곤한 3 가지 상태 중 하나에 속합니다. 모든 셀은 가로, 세로 또는 대각선으로 인접한 셀인 8 개의 이웃과 상호 작용합니다. 각 단계에서 다음과 같은 전환이 발생합니다.

  • 인구 집단으로 인한 것처럼 두 개 미만의 이웃이있는 살아있는 세포는 죽습니다.
  • 2 ~ 3 명의 라이브 이웃이있는 모든 라이브 셀은 다음 세대까지 계속됩니다.
  • 인구가 3 명 이상인 것처럼 살아있는 이웃이 3 명 이상인 살아있는 세포는 모두 죽습니다.
  • 정확히 3 개의 살아있는 이웃을 가진 죽은 세포는 마치 생식에 의한 것처럼 살아있는 세포가됩니다.
  • 2 세대 연속 생존 한 모든 세포는 마치 피로에 의해 죽습니다. 다음 세대까지 다시 깨어날 수 없습니다
  • 입력 그리드의 경계 밖에있는 셀은 마치 절벽에서 떨어진 것처럼 죽었습니다.

도전:

당신의 도전은 GoLF의 초기 상태와 정수 p를 나타내는 n-m 단위 의 그리드를 취하고 p 생성 후 게임의 상태를 출력하는 것 입니다.

규칙 :

  • 입력 및 출력 형식은 선택 사항이지만 입력 / 출력 그리드는 동일한 표현을 가져야합니다
  • 라이브 및 죽은 셀을 나타내는 인쇄 가능한 기호를 선택할 수 있습니다 ( 1라이브 셀 및 0죽은 셀에 사용하겠습니다 ).
  • 0 또는 1 인덱싱 된 경우 선택할 수 있습니다. 예에서, p=1한 단계 후 상태를 의미합니다.
  • 각 언어에서 가장 짧은 코드가 승리합니다
  • 셀룰러 자동화를위한 내장 기능 허용

테스트 사례 :

이 예제에서는 p가 아닌 입력 격자 만 입력에 포함 시켰습니다 . 다양한 p- 값에 대한 출력을 제공했습니다 . 주어진 입력 p 와 함께가는 그리드 만 출력해야합니다 .

Input:
0   0   0   0   0
0   0   1   0   0
0   0   1   0   0
0   0   1   0   0
0   0   0   0   0

--- Output ---
p = 1
0   0   0   0   0
0   0   0   0   0
0   1   1   1   0
0   0   0   0   0
0   0   0   0   0

p = 2
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0

p = 3 -> All dead
---

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

--- Output ---
p = 1
0   0   0   0   0   0
1   0   1   0   0   0
0   1   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

p = 2
0   0   0   0   0   0
0   0   0   0   0   0
1   0   0   0   0   0
0   1   1   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 3
0   0   0   0   0   0
0   0   0   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

p = 4 -> All dead
Input
0   1   1   0   1   1   0
1   1   0   1   1   1   1
0   1   0   0   0   1   0
0   0   0   1   1   0   1
1   0   0   1   0   1   1
0   0   1   1   0   1   1
1   1   0   0   0   0   1

--- Output ---
p = 1
1   1   1   0   0   0   1
1   0   0   1   0   0   1
1   1   0   0   0   0   0
0   0   1   1   0   0   1
0   0   0   0   0   0   0
1   0   1   1   0   0   0
0   1   1   0   0   1   1

p = 2
1   0   0   0   0   0   0
0   0   0   0   0   0   0
1   0   0   1   0   0   0
0   1   1   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   1   1   0   0   0   

p = 3
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   1   0   0   0   0
1   1   0   0   0   0   0
0   1   1   0   0   0   0
0   0   1   0   0   0   0
0   0   0   0   0   0   0

p = 4
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   1   0   0   0   0
1   0   0   0   0   0   0
1   0   1   0   0   0   0
0   1   1   0   0   0   0
0   0   0   0   0   0   0

p = 5
0   0   0   0   0   0   0
0   1   0   0   0   0   0
1   0   0   0   0   0   0
0   0   1   0   0   0   0
1   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0

p = 6
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
0   1   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 7
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   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 8
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 9 -> All dead

예, 모든 초기 씨앗이 모든 세포가 죽는 것으로 끝나는 것은 아니라는 것을 알고 있습니다.

code-golf  grid  matrix  cellular-automata  game-of-life 
— 스튜이 그리핀
소스
전환 항목 5가 항목 1-4와 "동시에"적용된다는 것을 분명히해야합니다. 즉, 1-4를 적용하기 전의 상태를 기반으로합니다.
— Luis Mendo
2
" 각각 살아 있거나 죽은 두 가지 가능한 상태 중 하나 인 세포 "는 각 세포가 세 가지 상태를 가지게함으로써 표준 피로 오토 마톤에서만 표현 될 수 있다는 점을 고려할 때 의도적으로 왜곡 된 정의처럼 보인다 살아 있음, 두 세대 연속 살아
— Peter Taylor
1
누군가 원한다면 이것에 대한 Golly 규칙이 있습니다.
— CalculatorFeline
6
신을 연주?
— Adám

답변:

3

MATL , 34 30 25 바이트

@CalculatorFeline 의 제안으로 5 바이트가 제거되었습니다 !

0ii:"wy*~wt3Y6QZ+5:7mb*]&

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

입력 값은 행렬과 숫자입니다. 행렬은 ;행 구분 기호로 사용 됩니다. 세 가지 테스트 사례에 대한 행렬은 다음과 같이 입력됩니다.

[0 0 0 0 0; 0 0 1 0 0; 0 0 1 0 0; 0 0 1 0 0;0 0 0 0 0]
[0 1 0 0 0 0; 0 0 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 1 1 0 1 1 0; 1 1 0 1 1 1 1; 0 1 0 0 0 1 0; 0 0 0 1 1 0 1; 1 0 0 1 0 1 1; 0 0 1 1 0 1 1; 1 1 0 0 0 0 1]

설명

0     % Push 0. This represents the generation previous to the input one. Actually
      % This should be an array of zeros, but thanks to broadcasting it is
      % equivalent (and saves bytes)
i     % Input: array with starting generation
i     % Input: number of iterations, p.
      % STACK (bottom to top): 0, array with initial generation, p
:"    % Do the following p times
      %   STACK: previous gen, current gen
  wy  %   Swap, duplicate from below
      %   STACK: current gen, previous gen, current gen
  *~  %   Multiply element-wise, negate. This creates a mask of cells that do not 
      %   die of fatigue (they were 0 in the current or in the previous generation)
      %   STACK: current gen, fatigue mask
  wt  %   Swap, duplicate
      %   STACK: Fatigue mask, current gen, current gen
  3Y6 %   Push predefined literal: 8-neighbourhood: [1 1 1; 1 0 1; 1 1 1]
      %   STACK: Fatigue mask, current gen, current gen, 8-neighbourhood
  Q   %   Add 1 element-wise. This gives [2 2 2; 2 1 2; 2 2 2], which will be
      %   used as convolution kernel. Active cells with 2 neighbours will give 5;
      %   inactive cells with 3 neighbours will give 6; and active cells with 3
      %   neighbours will give 7
      %   STACK: Fatigue mask, current gen, current gen, convolution kernel
  Z+  %   2D convolution, keeping size
      %   STACK: Fatigue mask, current gen, convolution result
  5:7 %   Push array [5 6 7]
  m   %   Ismember, element-wise. Cells that give true will survive, unless fatigued
      %   STACK: Fatigue mask, current gen, cells that can survive
  b   %   Bubble up
      %   STACK: Current gen, cells that can survive, fatigue mask
  *   %   Multiply element-wise. This tells which cells survive considering fatigue.
      %   The result is the new generation
      %   STACK: "Current" gen which now becomes old, "new" gen which now becomes
      %   current
]     % End 
&     % Specify that implicit display will show only top of the stack
— 루이스 멘도
소스
1
3Y6더 자세히 설명해 주시겠습니까? 또한 커널의 중간 요소가이면 .5CGOL을 그냥 확인할 수 있습니다 2<value<4. 도움이 될 수 있습니다.
— CalculatorFeline
@CalculatorFeline 정말 좋은 제안입니다, 감사합니다! 마스크를 두 번 사용하여 5 바이트를 절약 한 다음 테스트했습니다 5<=value<=7. 에 관해서 3Y6는 미리 정의 된 리터럴 일뿐입니다. 또한 1Y64 인이 있습니다
— Luis Mendo
1
허. 실제로 효과가있었습니다. 산뜻한.
— CalculatorFeline
3

APL (Dyalog Classic 16.0) , 59 바이트

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⎕U233A 3 3⍣⎕⊢⎕

온라인으로 사용해보십시오! (클래식 15.0에서 에뮬레이트 됨)

APL (Dyalog Unicode 16.0) , 85 바이트

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⌺3 3⍣⎕⊢⎕

온라인으로 사용해보십시오! (유니 코드 15.0에서 에뮬레이트 됨)

그리드를 프롬프트 한 다음 p 를 프롬프트합니다 . p 생성 후 새 그리드를 인쇄합니다 .

⌺클래식 문자 세트에 포함되지 않은 새로운 (스텐실) 프리미티브를 사용하므로 더 짧은 버전과 더 적은 바이트 버전입니다.

따라야 할 설명…

— 아담
소스
APL의 표시 형식은 훌륭합니다 :-)
— Luis Mendo
@LuisMendo 실제로 "APL"은 아니지만, 인터프리터는 출력을 원할 때이 APL 함수에 대한 콜백을 수행 합니다 . 그런 다음 함수는 우리가 출력하고자하는 것을 분석하고 그에 따라 수정합니다. display기능에 대한 설명 은 여기에 있습니다 .
— Adám
3

Golly RuleLoader, 295 바이트

@RULE Y
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var z={1,2}
var y=z
var x=z
var w=z
var u=z
var a={0,z}
var b=a
var c=a
var d=a 
var e=a
var f=a
var g=a 
var h=a
0,z,y,x,0,0,0,0,0,1
z,a,0,0,0,0,0,0,0,0
z,y,x,w,u,a,b,c,d,0
2,a,b,c,d,e,f,g,h,0
1,a,b,c,d,e,f,g,h,2
@COLORS
2 255 0 0

입력 그리드를 붙여 넣어야하고 경계는 규칙 이름에 있습니다 (예 : 5* 3is Y:P5,3).

— 계산기
소스
2

자바 8, 333 바이트

int[][]G(int p,int[][]s){for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],i=0;i++<2*p;)for(y=0;y<h;++y)for(x=0;x<w;++x)if(i%2>0){for(n=0,a=y-2;++a<y+2;)for(b=x-2;++b<x+2;)n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;}else s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];return s;}

설명:

int[][]G(int p,int[][]s){
    for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],       //height, width, vars, temp array
            i=0;i++<2*p;)                                                 //for 2*generations: 1. calculate in temporary t, 2. copying to s
        for(y=0;y<h;++y)                                                  //for each row
            for(x=0;x<w;++x)                                              //for each column
                if(i%2>0){                                                //1. calculate
                    for(n=0,a=y-2;++a<y+2;)                               //n = number of alive cells around [y][x]. row above, at and below y
                        for(b=y-2;++b<y+2;)                               //column left, at and right of x
                            n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;    //if within bounds and not the cell itself, add 1 if alive.
                    t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;     //save next state in temporary, depending on rules. alive cells become 2.
                }
                else                                                      //2. copy temporary t to s
                    s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];                   //if last generation, replace 2 by 1
    return s;
}
— 세바스찬 마트 슈케
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.