Kural 110, bazı ilginç özelliklere sahip bir hücresel otomat. Hedefiniz bir kuralı 110 mümkün olduğunca az karakterle simüle etmektir.

Bilmeyenler için, kural 110 bir şebekede satır satır simüle edilir. Izgaradaki her kare, hangi hücrenin olması gerektiğini belirlemek için yukarıdaki, sol üst ve sağ üst karelere bakar.

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

Giriş: herhangi bir makul biçimde (virgülle ayrılmış dize, liste, işlev argümanları) giriş karesini en üst satırda temsil eden 0 ila 39 arasındaki sayılar. 1 indeksli dilleri barındırmak için, sayılar 1 indeksli olabilir ve bu nedenle 1 ila 40 arasındadır.

Örnek giriş:

38,39

Çıktı: İlk satır dahil olmak üzere çalışan otomatları temsil eden 40 x 40 ızgara. 0 olarak boş bırakmalısınız ve görünür bir karakter olarak 1 yazmalısınız. Gerçek ızgara makul bir şekilde ayırt edilebildiği sürece iz bırakma alanlarına izin verilir. Kılavuzun alt kısmında yeni bir çizgi olabilir, ancak ızgara çizgileri arasında boş çizgiler olmamalıdır.

Örnek çıktı:

                                  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

vb.

Not: 1D hücresel otomatlar hakkında benzer bir soru zaten sorulmuştur, ancak umarım, sadece bir kural kullanarak daha kısa cevaplar yazılabilir.

CJam - 47

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

!"1" hücreler için kullanır .

Http://cjam.aditsu.net/ adresinde deneyin

Açıklama:

S40*40 boşluklu bir dize (dizi)
l',/bir satır okur ve virgülle böler
{…}/(her öğe için bloğu çalıştırır (dize biçimindeki sayılar)
- i'!tsayıyı tamsayıya dönüştürür ve öğeyi önceki dizede bu konumda ayarlar (başlangıçta 40 boşluk) ) '!'
Bu noktada ilk çizgiyi elde ettik.
{…}39*bloğu 39 kez çalıştırır
- Nyeni bir satır ekler
- 40,[0 1… 39] dizisini yapar
- S3$S++önceki satırı kopyalar (yığında konum 3) ve bunu her tarafta bir boşlukla doldurur
- f{…}bloğu {0 için her sayıdan çalıştırır 39} ve {yastıklı çizgi}
- >3<geçerli numaradan başlayan yastıklı satırdan 3 maddelik bir dilim alır
- 2b2 tabanından dönüştürür; dilimlemekte olduğumuz öğeler baz-2 rakam değildir, ancak karakterler ASCII değerlerine dönüştürülür ve '' mod 8 0 ve '!' mod 8 1'dir
- 137Yb137'yi baz 2'ye ( Y= 2) dönüştürür, [1 0 0 0 1 0 0 1] değerini alır, bu değer 110 tersine çevrilir ve reddedilir (8 bit üzerinde)
- ='!^karşılık gelen taban-2 basamağını alır ( dizi etrafında sarar, böylece dizin mod 8'e alınır ve xor 'ile!' ! 'ile sonuçlanan karakter 0 için ve '' 1 için

Yakut, 113 karakter

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'de girdi alır. Farklı bir kural kullanmak için 110, son satırdakileri denemek istediğiniz kuralla değiştirin.

Örnek:

$ 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

Mathematica, 122 bayt

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

Evet, kötüye olarak görmekteyiz olabilir bu kaçamak ama) mazgal oldukça tartışmalı olduğunu, b) Hücresel otomat soru ihtiyacı I yani don, bir Mathematica cevap (Kural 110) ve c) Ventero Ruby cevabı zaten kısadır konusunda özellikle birini herhangi bir zarar yapıldığını sanmıyorum.

Karakterlerin çoğu giriş ayrıştırma ve çıkış formatlama için kullanılır. Gerçek otomat kullanılarak simüle

CellularAutomaton[110,initialGrid,39]

Bu periyodik sınır koşullarını kullanır (yani ızgara etrafına sarılır).

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

Örneğin çalıştır python 110.py <<< 38,39

q, 67 62 58 bayt

Etrafta sarmalanmadığını varsayar:

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

Eski versiyon

{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;~:]}

Python, 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]

İyi ama muhtemelen en uygun değil.

Girişin nasıl alındığını belirtmediniz, ben de bir işlev yaptım.

Örnek kullanın:

R ([38,39])

Çıktı:

                                      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

Mathematica, 113 karakter

Başka bir Mathematica cevabı kullanarak CellularAutomaton.

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

C - 178

Bu kod, bir matristeki her satırın bitişik bellekte saklanmasına bağlıdır. Ayrıca, ilk satırı yazdırmaz, ancak kurallar yalnızca bir 40x40 ızgarası belirttiğinden sonraki 40 olanı yazdırır.

Yalnızca okunabilirlik için girintili, bayt sayısı yalnızca gerekli kodu içerir.

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

Lua - 351

Golf için ideal bir dil değil.

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

Haskell , 175 170 169 136 127 124 bayt

@Bmo sayesinde −9 bayt

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

Çevrimiçi deneyin!

Haskell , 135 131 130 bayt

^{Ørjan Johansen ( -1 düzenleme take 40) sayesinde -1 bayt}

FrownyFrog'un cevabına tamamen farklı bir yaklaşım, ancak yaklaşık aynı uzunluk:

(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$

açıklama

$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])

(?)Operatör çözümün en ilginç parçasıdır: Daha önce bir Boole bir Karnaugh haritası ile oluşturulan kural, ancak kullanılan dışarı döner daha da özlü bir yolu vardır:

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

Husk , 31 28 bayt

Hah, Husk Jelly'i dövüyor!

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

Çevrimiçi deneyin!

Açıklama ve Ungolfed

Bir açıklama eklemeden önce, bunu biraz ungolf edeyim .. Önce çeşitli bileşimleri kaldıralım, açık parantezler ekleyelim ve ¨↑¨dizgeyi açalım . Ayrıca daha okunaklı bir açıklama için 40ile değiştirelim 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"]

Java, 321 karakter

Giriş, örneğin komut satırından argüman olarak geçti java R 38,39

Asla daha karışık Java kodu yazmamıştım :-)

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

Güncelleme: Burada çıktı örneğini düzeltin (50 satır değil 50 satırla): Yeni çıktı (aşağıda bir kısalık kaldırıldı):

                                      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

Başka bir bilmece yaparak php'deki döngüler için ifadeleri yerleştirme hakkında ilginç bir şey öğrendim ve aniden sandığımdan çok daha karmaşıklar. Zamanım geldiğinde sanırım bu puanı çok fazla yenebilirim. Şimdilik rekabetçi olmayan bir 408'de değişmeden kalmasına rağmen.

Benim php versiyonum 408 karakter:

Bu harika bir bilmeceydi. Ayrıca, söylenmeleri gereken büyüleyici şeyler olduğu için girdilerle oynayarak yaşlarımı harcadım. Her neyse, işte PHP sürümüm (yayınlanan hiçbir cevap kadar iyi değil ama hiçbir yerde bu kadar iyi değil. benim versiyonum:

<?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;}?>

Onu görebilir ve burada çalıştırabilirsiniz: http://codepad.org/3905T8i8

Giriş, başlangıçta $ a = '38, 39 ';

Çıkış aşağıdaki gibidir:

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

Umarım beğenirsin!!!

PS Koda birkaç satır sonu eklemek zorunda kaldım, böylece hepsini görebiliyordunuz ve sayfa boyunca bir kaydırma çubuğu ile esnetmiyordum.

Stax , 24 bayt ^CP437

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

Çevrimiçi çalıştırın ve hata ayıklayın!

"1" hücreleri için CP437'deki kod noktası 1'i kullanır.

Bu dilin gücünü göstermek için mükemmel durum.

açıklama

Açıklanacak paketi (29 byte) kullanır.

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 bayt

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

Çevrimiçi deneyin!

{ } argümanlı fonksiyon x

!40 0 - 39 arası hesapların listesi

x?endekslerini bul x, kullan 0N(için "integer null") kullan

^hangisi boş? Bu bize girdi verir, olumsuzladı

39{ }\ Bir listedeki ara sonuçları toplayarak, 39 kez uygulayın

1,x,1 Listeyi 1s ile çevreleyin (0s ile olumsuzlandı)

3' ardışık öğelerin üçlü sayısı

2/' her biri ikili kod çözme

@ endeksleri olarak kullanmak ...

2\145 ikili kod 145 (kodlanmış 110)

"X "Son olarak, 40x40 matrisini dizgideki indeksler olarak kullanın "X "( @burada örtük)

Jöle , 29 bayt

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

Çevrimiçi deneyin!