규칙 110은 몇 가지 흥미로운 속성을 가진 셀룰러 오토 마톤입니다. 목표 는 가능한 한 적은 문자로 규칙 110을 시뮬레이션하는 것 입니다.

모르는 사람들을 위해 규칙 110은 그리드에서 한 줄씩 시뮬레이션됩니다. 격자 선의 각 사각형은 위, 왼쪽 및 오른쪽 위의 사각형을보고 어떤 셀이되어야하는지 결정합니다.

current pattern  111 110 101 100 011 010 001 000
new cell          0   1   1   0   1   1   1   0

입력 : 임의의 적절한 형식 (쉼표로 구분 된 문자열, 목록, 함수 인수)으로 맨 위 행 n 번째 입력 사각형을 나타내는 0에서 39 사이의 숫자. 1- 인덱스 언어를 수용하기 위해 숫자도 1- 인덱싱 될 수 있으며 1에서 40까지의 범위입니다.

입력 예 :

38,39

출력 : 첫 번째 행을 포함하여 오토마타 달리기를 나타내는 40 x 40 격자. 0은 공백으로, 1은 보이는 인쇄 문자로 남겨 두어야합니다. 실제 그리드를 합리적으로 구별 할 수있는 한 후행 공백이 허용됩니다. 그리드의 맨 아래에 줄 바꿈이있을 수 있지만 그리드 선 사이에 빈 줄이 없어야합니다.

출력 예 :

                                  XX
                                 XXX
                                XX X
                               XXXXX
                              XX   X
                             XXX  XX
                            XX X XXX
                           XXXXXXX X
                          XX     XXX
                         XXX    XX X
                        XX X   XXXXX
                       XXXXX  XX   X
                      XX   X XXX  XX
                     XXX  XXXX X XXX

기타

참고 : 1D 셀룰러 오토마타에 대한 비슷한 질문이 이미 요청되었지만 하나의 규칙 만 사용하면 더 짧은 답변을 작성할 수 있기를 바랍니다.

CJam-47

S40*l',/{i'!t}/{N40,S3$S++f{>3<2b137Yb='!^}}39*

그것은 사용 !"1"세포.

http://cjam.aditsu.net/ 에서 시도 하십시오

설명:

S40*40 칸의 문자열 (배열)이
l',/한 줄을 읽고 쉼표로 분할
{…}/하면 각 항목에 대한 블록을 실행합니다 (문자열 형식의 숫자)
- i'!t숫자를 정수로 변환하고 이전 문자열의 해당 위치에 항목을 설정합니다 (처음 40 공백) )를 '!'
이 시점에서 첫 번째 줄을 얻었습니다.
{…}39*블록을 39 번 실행
- N개행 추가
- 40,배열을 [0 1… 39]
- S3$S++이전 라인을 복사하고 (스택의 위치 3) 각 측면에 공백으로 채 웁니다
- f{…}{각 숫자는 0부터 시작합니다. ~ 39} 및 {패딩 된 줄}
- >3<현재 숫자부터 시작하여 패딩 된 줄에서 3 개의 항목 조각을 가져옵니다.
- 2b밑이 2에서 변환됩니다. 우리가 슬라이스 한 항목은 기본 2 자리가 아니지만 문자는 ASCII 값으로 변환되고 ''mod 8 is 0 and '!' 개조 8 1
- 137Yb베이스 (2) ((137)로 변환 Y(110) 및 반전 (8 비트에) 니 게이트 획득 = 2), (1) 0 0 0 1 0 0 1]
- ='!^해당베이스 2 자리합니다 (도착 배열은 주위를 감싸서 인덱스가 mod 8)이고 xor는 '!' 문자, '!' 0의 경우 및 ''의 경우 1

루비, 113 자

c=[0]*41
eval"[#{gets}].map{|i|c[i]=1}"+'
c=(0..39).map{|x|putc" X"[u=c[x]]
110[4*c[x-1]+2*u+c[x+1]]}<<0;puts'*40

stdin에 입력을받습니다. 다른 규칙을 사용하려면 110마지막 줄에서를 원하는 규칙으로 바꾸십시오 .

예:

$ ruby 110.rb <<< 38,39
                                      XX
                                     XXX
                                    XX X
                                   XXXXX
                                  XX   X
                                 XXX  XX
                                XX X XXX
                               XXXXXXX X
                              XX     XXX
                             XXX    XX X
                            XX X   XXXXX
                           XXXXX  XX   X
                          XX   X XXX  XX
                         XXX  XXXX X XXX
                        XX X XX  XXXXX X
                       XXXXXXXX XX   XXX
                      XX      XXXX  XX X
                     XXX     XX  X XXXXX
                    XX X    XXX XXXX   X
                   XXXXX   XX XXX  X  XX
                  XX   X  XXXXX X XX XXX
                 XXX  XX XX   XXXXXXXX X
                XX X XXXXXX  XX      XXX
               XXXXXXX    X XXX     XX X
              XX     X   XXXX X    XXXXX
             XXX    XX  XX  XXX   XX   X
            XX X   XXX XXX XX X  XXX  XX
           XXXXX  XX XXX XXXXXX XX X XXX
          XX   X XXXXX XXX    XXXXXXXX X
         XXX  XXXX   XXX X   XX      XXX
        XX X XX  X  XX XXX  XXX     XX X
       XXXXXXXX XX XXXXX X XX X    XXXXX
      XX      XXXXXX   XXXXXXXX   XX   X
     XXX     XX    X  XX      X  XXX  XX
    XX X    XXX   XX XXX     XX XX X XXX
   XXXXX   XX X  XXXXX X    XXXXXXXXXX X
  XX   X  XXXXX XX   XXX   XX        XXX
 XXX  XX XX   XXXX  XX X  XXX       XX X
XX X XXXXXX  XX  X XXXXX XX X      XXXXX
XXXXXX    X XXX XXXX   XXXXXX     XX   X

수학, 122 바이트

f[a_]:=Riffle[CellularAutomaton[110,Array[If[MemberQ[ToExpression["{"<>a<>"}"],#-1],1,0]&,40],39]/.0->" "/.1->"X","
"]<>""

예, 이 허점 을 남용하는 것으로 볼 수도 있지만 a) 허점은 상당히 논쟁의 여지가 있습니다 .b) 셀룰러 자동 완성 질문 에는 수학 답변 (특히 규칙 110에 관한 질문)이 필요 합니다 .c) Ventero의 Ruby 답변은 더 짧습니다. 어떤 피해도 없다고 생각합니다.

대부분의 문자는 입력 구문 분석 및 출력 형식에 사용됩니다. 실제 오토 마톤은

CellularAutomaton[110,initialGrid,39]

이것은 주기적 경계 조건을 사용합니다 (그리드가 줄 바꿈됩니다).

파이썬-141

i=input()
o=range(40)
l=''.join(' X'[c in i]for c in o)
for r in o:print l;l=''.join('X '[l[c-1:c+2]in('XXX','   ','X  ','','  ')]for c in o)

예를 들어 실행 python 110.py <<< 38,39

q, 67 62 58 바이트

랩 어라운드가 없다고 가정합니다.

{40{not(2 sv'flip 1 0 -1 xprev\:x)in 0 4 7}\@[40#0b;x;~:]}

구 버전

{40{not(flip(prev;::;next)@\:x)in 3 cut 111100000b}\@[40#0b;x;not]}
{40{not(flip 1 0 -1 xprev\:x)in 3 3#111100000b}\@[40#0b;x;~:]}

파이썬, 186

def r(s,m=range(40)):
 s=[int(i in s)for i in m]
 for g in m:print''.join([' X'[i]for i in s]);s=[int(not''.join(map(str,s[i-1:i+2]if i else s[:2]))in'111 100 000 00'.split())for i in m]

괜찮지 만 아마도 최적은 아닙니다.

입력을받는 방법을 지정하지 않았으므로 방금 함수를 만들었습니다.

사용 예 :

r ([38,39])

산출:

                                      XX
                                     XXX
                                    XX X
                                   XXXXX
                                  XX   X
                                 XXX  XX
                                XX X XXX
                               XXXXXXX X
                              XX     XXX
                             XXX    XX X
                            XX X   XXXXX
                           XXXXX  XX   X
                          XX   X XXX  XX
                         XXX  XXXX X XXX
                        XX X XX  XXXXX X
                       XXXXXXXX XX   XXX
                      XX      XXXX  XX X
                     XXX     XX  X XXXXX
                    XX X    XXX XXXX   X
                   XXXXX   XX XXX  X  XX
                  XX   X  XXXXX X XX XXX
                 XXX  XX XX   XXXXXXXX X
                XX X XXXXXX  XX      XXX
               XXXXXXX    X XXX     XX X
              XX     X   XXXX X    XXXXX
             XXX    XX  XX  XXX   XX   X
            XX X   XXX XXX XX X  XXX  XX
           XXXXX  XX XXX XXXXXX XX X XXX
          XX   X XXXXX XXX    XXXXXXXX X
         XXX  XXXX   XXX X   XX      XXX
        XX X XX  X  XX XXX  XXX     XX X
       XXXXXXXX XX XXXXX X XX X    XXXXX
      XX      XXXXXX   XXXXXXXX   XX   X
     XXX     XX    X  XX      X  XXX  XX
    XX X    XXX   XX XXX     XX XX X XXX
   XXXXX   XX X  XXXXX X    XXXXXXXXXX X
  XX   X  XXXXX XX   XXX   XX        XXX
 XXX  XX XX   XXXX  XX X  XXX       XX X
XX X XXXXXX  XX  X XXXXX XX X      XXXXX
XXXXXX    X XXX XXXX   XXXXXX     XX   X

매스 매 티카, 113 자

를 사용하는 또 다른 Mathematica 답변 CellularAutomaton.

Print@@" "["X"][[#]]&/@CellularAutomaton[110,SparseArray[#+1->1&/@ImportString[InputString[],"CSV"][[1]],40],39];

C-178

이 코드는 행렬의 각 행이 연속 메모리에 저장되어 있다는 사실에 따라 다릅니다. 또한 규칙은 40x40 격자 만 지정했기 때문에 첫 번째 행은 인쇄하지 않지만 다음 40 행을 인쇄합니다.

가독성을 위해 들여 쓰기 된 바이트 수에는 필요한 코드 만 포함됩니다.

a[41][42],i,j,*t;
main(){
    while(scanf("%d,",&j)>0)
        a[i][j]=1;
    for(;i<40;i++,puts(""))
        for(j=0;++j<40;)
            t=&a[i][j],
            putchar((*(t+42)=1&(110>>(*(t+1)?1:0)+(*t?2:0)+(*(t-1)?4:0)))?88:32);
}

루아-351

골프에 이상적인 언어는 아닙니다.

s,n,t,u=arg[1],{},table.remove,table.insert
for i=1,40 do u(n,i,'.') end
for i in s:gmatch("%d+")do u(n,i,'x');t(n)end
function a(b) c="";for i=1,40 do c=c..b[i] end;print(c);return c end
for i=1,40 do z= n[40]..a(n)..n[1];for k=2,41 do y=string.sub(z,k-1,k+1);if y=="xxx"or y=="x.." or y=="..." then u(n,k-1,'.')else u(n,k-1,'x')end;t(n)end end

하스켈 , 175170169136127124 바이트

@bmo 덕분에 −9 바이트

t(a:b:r:_)=mod(b+r+b*r+a*b*r)2
w%a=take 40.map w.iterate a
d l=t%tail$0:l++[0]
f l=map(" #"!!)%d$(fromEnum.(`elem`l))%succ$0

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

하스켈 , 135131130 바이트

^{Ørjan Johansen 덕분에 -1 바이트 (재정렬 take 40)}

FrownyFrog의 답변에 대한 완전히 다른 접근법 이지만 길이는 같습니다.

(a?b)r=mod(b+r+b*r+a*b*r)2
r x=0:(zipWith3(?)x=<<tail$tail x++[0])
f y=take 40$map(" o"!!)<$>iterate r[sum[1|elem i y]|i<-[0..40]]

$1$

설명

$41$$\texttt{0}$$\texttt{1}$

f y=                               [sum[1|elem i y]|i<-[0..40]]

$40$

    take 40$              iterate r

$\texttt{0}$$\texttt{1}$

            map(" o"!!)<$>

r$\texttt{110}$zipWith3(?)

r x=0:(zipWith3(?)x=<<tail$tail x++[0])

(?)운영자는 솔루션의 가장 흥미로운 부분입니다 : 이전에 내가 부울 카르노지도 생성 규칙 만 사용 밝혀를 더욱 간결 방법이있다 :

(a?b)r=mod(b+r+b*r+a*b*r)2

껍질 , 31 28 바이트

허 스크가 젤리를 때리고 있어요!

†!¨↑¨↑40¡ȯẊȯ!ḋ118ḋėΘ`:0M#ŀ40

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

설명 및 언 골프

설명을 추가하기 전에이 부분의 압축을 해제하겠습니다. 먼저 다양한 컴포지션을 제거하고 괄호를 추가하고 ¨↑¨문자열을 압축 해제 합니다. 또한의 교체하자 40로 4보다 읽기 쉬운 설명을 위해 :

†!"t "↑4¡(Ẋ(!ḋ118ḋė)Θ`:0)M#ŀ4  -- example input: [3]
                           ŀ4  -- lower range of 4: [0,1,2,3]
                         M     -- map over left argument
                          #    -- | count in list
                               -- : [0,0,0,1]
        ¡(              )      -- iterate the following indefinitely (example with [0,1,1,1])
                     `:0       -- | append 0: [0,1,1,1,0]
                    Θ          -- | prepend 0: [0,0,1,1,1,0]
          Ẋ(       )           -- | map over adjacent triples (example with  1 1 0
                  ė            -- | | create list: [1,1,0]
                 ḋ             -- | | convert from base-2: 6
                               -- | | convert 118 to base-2: [1,1,1,0,1,1,0]
                               -- | | 1-based index: 1
                               -- | : [1,1,0,1]
                               -- : [[0,0,0,1],[0,0,1,1],[0,1,1,1],[1,1,0,1],[1,1,1,1],[1,0,0,1],...]
      ↑4                       -- take 4: [[0,0,0,1],[0,0,1,1],[0,1,1,1],[1,1,0,1]]
†                              -- deep map the following (example with [1,1,0,1])
 !"t "                         -- | use each element to index into "t ": "tt t"
                               -- : ["   t","  tt"," ttt","tt t"]

자바, 321 자

명령 행에서 인수로 전달 된 입력 (예 : java R 38,39

나는 더 난독 화 된 자바 코드를 작성하지 않았다 :-)

class R{public static void main(String[]a) {
Integer s=40;boolean[]n,o=new boolean[s];
for(String x:a[0].split(","))o[s.valueOf(x)]=s>0;
for(Object b:o){n=o.clone();
for(int j=0;j<s;j++){
boolean l=j>1&&o[j-1],r=o[j],c=j+1<s&&o[j+1];
n[j]=!(l&c&r|l&!c&!r|!(l|c|r));
System.out.print((r?"X":" ")+(j>s-2?"\n":""));
}o=n;}}}

업데이트 : 여기에 올바른 출력 예 (50 줄이 아닌 40 줄) : 아래 새 출력 (간결하게하기 위해 이전 출력 제거) :

                                      xx
                                     xxx
                                    xx x
                                   xxxxx
                                  xx   x
                                 xxx  xx
                                xx x xxx
                               xxxxxxx x
                              xx     xxx
                             xxx    xx x
                            xx x   xxxxx
                           xxxxx  xx   x
                          xx   x xxx  xx
                         xxx  xxxx x xxx
                        xx x xx  xxxxx x
                       xxxxxxxx xx   xxx
                      xx      xxxx  xx x
                     xxx     xx  x xxxxx
                    xx x    xxx xxxx   x
                   xxxxx   xx xxx  x  xx
                  xx   x  xxxxx x xx xxx
                 xxx  xx xx   xxxxxxxx x
                xx x xxxxxx  xx      xxx
               xxxxxxx    x xxx     xx x
              xx     x   xxxx x    xxxxx
             xxx    xx  xx  xxx   xx   x
            xx x   xxx xxx xx x  xxx  xx
           xxxxx  xx xxx xxxxxx xx x xxx
          xx   x xxxxx xxx    xxxxxxxx x
         xxx  xxxx   xxx x   xx      xxx
        xx x xx  x  xx xxx  xxx     xx x
       xxxxxxxx xx xxxxx x xx x    xxxxx
      xx      xxxxxx   xxxxxxxx   xx   x
     xxx     xx    x  xx      x  xxx  xx
    xx x    xxx   xx xxx     xx xx x xxx
   xxxxx   xx x  xxxxx x    xxxxxxxxxx x
  xx   x  xxxxx xx   xxx   xx        xxx
 xxx  xx xx   xxxx  xx x  xxx       xx x
xx x xxxxxx  xx  x xxxxx xx x      xxxxx
xxxxxx    x xxx xxxx   xxxxxx     xx   x

다른 퍼즐을 사용하면 PHP에서 for 루프의 중첩 문에 대해 흥미로운 것을 배웠고 갑자기 원래 생각했던 것보다 훨씬 복잡합니다. 내가 시간을 얻을 때 나는이 점수를 상당히 이길 수 있다고 생각합니다. 현재로서는 비 경쟁적 408에서 변하지 않고 남아있다.

내 PHP 버전 408 자 :

이것은 큰 퍼즐이었다. 나는 또한 말해야 할 매혹적인 것들이기 때문에 입력을 가지고 놀아 보았습니다. 어쨌든, 여기에 내 PHP 버전이 있습니다 (이것은 게시 된 답변의 일부만큼 좋지는 않지만 완료되었습니다. 0 번째 위치에서는 오른쪽 위, 오른쪽 위, 39 위 위치는 왼쪽 위 또는 위, 즉 포장은 없습니다) 내 버전입니다 :

<?php $a='38,39';$b='';$d=explode(',',$a);for($i=0;$i<40;++$i){$c=' ';
foreach($d as $k=>$v){if($v == $i){$c='x';}}$b.=$c;}echo $b."\n";
for($x=1;$x<41;++$x){$o='';for($i=1;$i<41;++$i){if(($i>1)AND(substr($b,$i-2,1)=='x')){
$l=1;}else{$l=0;}if((substr($b,$i-1,1))=='x'){$v=1;}else{$v=0;}if((substr($b,$i,1))=='x'){
$r=1;}else{$r=0;}if((($l+$v+$r)==2)OR(($v+$r)==1)){$o.='x';}else{$o.=' ';}}
echo $o."\n";$b=$o;}?>

당신은 그것을보고 여기에서 실행할 수 있습니다 : http://codepad.org/3905T8i8

입력은 $ a = '38, 39 '와 같이 시작시 입력 문자열입니다.

출력은 다음과 같습니다.

xx removed as was too long originally - had 50 lines, not 40 xx

너가 좋아하길 바래!!!

추신 : 나는 코드에 몇 줄 바꿈을 추가하여 모든 것을 볼 수 있고 스크롤 막대로 페이지에 걸쳐 늘어나지 않도록했습니다.

Stax , 24 바이트 ^CP437

╦♥µ╤u{£┬íQ<;▀ΦΣ╢╕╚äZ↕áû↑

온라인으로 실행하고 디버그하십시오!

"1"셀에 CP437의 코드 포인트 1을 사용합니다.

이 언어의 힘을 보여주는 훌륭한 사례.

설명

압축을 푼 버전 (29 바이트)을 사용하여 설명합니다.

0]40X*,1&xDQ0]|S3B{:b^374:B@m
0]40X*                           Prepare a tape with 40 cells
      ,1&                        Assign 1 to the cells specified by the input
         xD                      Repeat the rest of the program 40 times
           Q                     Output current tape
            0]|S                 Prepend and append a 0 cell to it
                3B               All runs of length 3
                  {         m    Map each run with block
                   :b            Convert from binary
                     ^           Increment (call this value `n`)
                      374:B      The binary representation of 374
                                 [1,0,1,1,1,0,1,1,0]
                                 which is `01101110` reversed and prepended a 1
                           @     Element at 0-based index `n`

K (ngn / k) , 44 35 바이트

{"X "39{(2\145)@2/'3'1,x,1}\^x?!40}

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

{ } 인수 기능 x

!40 0에서 39까지의 정수 목록

x?에서 색인을 찾고 찾을 수없는 x경우 0N( "정수 null")을 사용하십시오.

^그들 중 어느 것이 null입니까? 이것은 우리에게 부정적인 의견을 준다

39{ }\ 39 회 적용, 목록에서 중간 결과 수집

1,x,1 목록을 1로 둘러싸십시오 (음수 0).

3' 3 배 연속 아이템

2/' 이진 디코딩 각각

@ 지수로 사용 ...

2\145 이진 인코딩 145 (110의 음수 비트)

"X "마지막으로 40x40 행렬을 문자열의 인덱스로 사용하십시오 "X "( @여기서는 암시적임)

젤리 , 29 바이트

‘;41ṬṖŻ;0Ḅe“¢£¤¦©‘Ɗ3ƤƊ39СYo⁶

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