La règle 110 est un automate cellulaire avec des propriétés intéressantes. Votre objectif est de simuler une règle 110 avec le moins de caractères possible.

Pour ceux qui ne le savent pas, la règle 110 est simulée ligne par ligne dans une grille. Chaque carré d'une ligne de la grille examine les carrés au-dessus, au-dessus de la gauche et au-dessus de la droite pour déterminer quelle cellule il doit être.

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

Entrée: nombres de 0 à 39 représentant la nième carré d'entrée de la ligne supérieure, dans n'importe quel format raisonnable (chaîne séparée par des virgules, liste, arguments de fonction). Pour prendre en charge les langues indexées 1, les nombres peuvent également être indexés 1 et vont donc de 1 à 40.

Exemple d'entrée:

38,39

Sortie: une grille 40 x 40 représentant les automates en cours d'exécution, y compris la première ligne. Vous devez laisser 0 vide et 1 tout caractère d'impression visible. Les espaces de fin sont autorisés, tant que la grille réelle peut être raisonnablement distinguée. Le bas de la grille peut avoir une nouvelle ligne mais il ne doit pas y avoir de lignes vides entre les lignes de la grille.

Exemple de sortie:

                                  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

etc.

Remarque: Une question similaire sur les automates cellulaires 1D a déjà été posée, mais j'espère qu'en utilisant une seule règle, des réponses plus courtes pourront être écrites.

CJam - 47

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

Il utilise !pour les cellules "1".

Essayez-le sur http://cjam.aditsu.net/

Explication:

S40*crée une chaîne (tableau) de 40 espaces
l',/lit une ligne et se divise par une virgule
{…}/exécute le bloc pour chaque élément (les nombres sous forme de chaîne)
- i'!tconvertit le nombre en entier et définit l'élément à cette position dans la chaîne précédente (initialement 40 espaces ) à '!'
À ce stade, nous avons obtenu la première ligne.
{…}39*exécute le bloc 39 fois
- Najoute une nouvelle ligne
- 40,crée le tableau [0 1… 39]
- S3$S++copie la ligne précédente (position 3 sur la pile) et la remplit d'un espace de chaque côté
- f{…}exécute le bloc pour {chaque numéro à partir de 0 à 39} et {la ligne matelassée}
- >3<prend une tranche de 3 éléments de la ligne matelassée en commençant par le nombre actuel
- 2bconvertit à partir de la base 2; les éléments que nous avons découpés ne sont pas des chiffres de base 2, mais les caractères sont convertis en leurs valeurs ASCII et '' mod 8 est 0 et '!' le mod 8 est 1
- 137Ybconvertit 137 en base 2 ( Y= 2), obtenant [1 0 0 0 1 0 0 1], qui est 110 inversé et annulé (sur 8 bits)
- ='!^obtient le chiffre de base 2 correspondant (le le tableau s'enroule donc l'index est pris mod 8) et xor avec le '!' caractère, résultant en «!» pour 0 et '' pour 1

Ruby, 113 caractères

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

Prend une entrée sur stdin. Pour utiliser une règle différente, remplacez simplement le 110dans la dernière ligne par la règle que vous souhaitez essayer.

Exemple:

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

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

Oui, vous pourriez considérer cela comme abusant de cette échappatoire , mais a) cette échappatoire est assez contestée, b) une question de l'automate cellulaire a besoin d' une réponse Mathematica (en particulier une sur la règle 110) et c) la réponse Ruby de Ventero est plus courte de toute façon, donc je ne pense pas qu'il y ait de mal.

La plupart des caractères sont utilisés pour l'analyse syntaxique d'entrée et le formatage de sortie. L'automate réel est simulé en utilisant

CellularAutomaton[110,initialGrid,39]

Cela utilise des conditions aux limites périodiques (de sorte que la grille s'enroule).

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)

Exécuter comme par exemple python 110.py <<< 38,39

q, 67 62 58 octets

Ne suppose aucun bouclage:

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

Ancienne version

{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]

Décent mais probablement pas optimal.

Vous n'avez pas précisé comment les entrées sont obtenues, je viens de créer une fonction.

Exemple d'utilisation:

r ([38,39])

Sortie:

                                      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 caractères

Une autre réponse Mathematica utilisant CellularAutomaton.

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

C - 178

Ce code dépend du fait que chaque ligne d'une matrice est stockée dans une mémoire contiguë. De plus, il n'imprime pas la première ligne, mais il imprime les 40 suivantes, car les règles ne spécifiaient qu'une grille 40x40.

Indenté pour la lisibilité uniquement, le nombre d'octets comprend uniquement le code nécessaire.

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

Pas la langue idéale pour jouer au golf.

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 , 175170169136136127124 octets

−9 octets grâce à @bmo

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

Essayez-le en ligne!

Haskell , 135 131 130 octets

^{-1 octet grâce à Ørjan Johansen (réarrangement take 40)}

Approche complètement différente de la réponse de FrownyFrog mais à peu près de la même longueur:

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

Explication

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

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

$40$

    take 40$              iterate r

$\texttt{0}$ et$\texttt{1}$ à un certain caractère de fantaisie:

            map(" o"!!)<$>

La fonction rqui applique la$\texttt{110}$-rule est assez simple: en utilisant zipWith3et un peu de remplissage, nous pouvons externaliser la décision réelle pour la cellule suivante pour (?):

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

le (?) opérateur est la partie la plus intéressante de la solution: Auparavant, j'utilisais une règle booléenne générée avec une carte de Karnaugh, mais il s'avère qu'il existe un moyen encore plus concis:

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

Husk , 31 28 octets

Hah, Husk bat Jelly!

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

Essayez-le en ligne!

Explication et non golfé

Avant d'ajouter une explication, permettez-moi de dissiper un peu cela. Supprimons d'abord les différentes compositions, ajoutons des parenthèses explicites et décompressons la ¨↑¨chaîne. Remplaçons également 40par 4pour une explication plus lisible:

†!"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 caractères

Entrée passée comme argument à partir de la ligne de commande, par exemple java R 38,39

Je n'ai jamais écrit de code java plus obscur :-)

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

Mise à jour: exemple de sortie correct ici (avec 40 lignes et non 50): Nouvelle sortie ci-dessous (supprimée la précédente pour plus de brièveté):

                                      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

En faisant un autre casse-tête, j'ai appris quelque chose d'intéressant sur l'imbrication des instructions pour les boucles en php, et soudain, elles sont beaucoup plus complexes que je ne le pensais à l'origine. Quand j'aurai le temps, je pense que je peux battre ce score considérablement. Pour l'instant, il reste inchangé à un 408 non compétitif.

Ma version php 408 caractères:

Ce fut un grand puzzle. J'ai aussi passé beaucoup de temps à jouer avec les entrées car ce sont des choses fascinantes, il faut le dire. Quoi qu'il en soit, voici ma version PHP (qui est loin d'être aussi bonne que certaines des réponses publiées mais est complète. En 0ème position, ne prenez que ci-dessus et au-dessus à droite, en 39ème position, prenez uniquement au-dessus et au-dessus à gauche, c'est-à-dire sans emballage. Donc ici est ma version:

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

Vous pouvez le voir et l'exécuter ici: http://codepad.org/3905T8i8

Input est une chaîne d'entrée au début sous la forme $ a = '38, 39 ';

La sortie est la suivante:

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

J'espère que vous aimez!!!

PS J'ai dû ajouter quelques sauts de ligne au code pour que vous puissiez voir tout cela et ne pas le faire s'étendre sur la page avec une barre de défilement.

Stax , 24 octets ^CP437

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

Exécutez et déboguez en ligne!

Utilise le point de code 1 dans CP437 pour les cellules "1".

Excellent cas pour montrer la puissance de cette langue.

Explication

Utilise la version non compressée (29 octets) pour expliquer.

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 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

!40 liste d'entiers de 0 à 39

x?trouver leurs indices dans x, utiliser 0N(le "null entier") pour non trouvé

^lesquels sont nuls? cela nous donne l'entrée, niée

39{ }\ appliquer 39 fois, en recueillant les résultats intermédiaires dans une liste

1,x,1 entourer la liste de 1s (0 négatif)

3' triplets d'articles consécutifs

2/' décodage binaire chacun

@ utiliser comme indices dans ...

2\145 encodage binaire 145 (bits niés de 110)

"X "enfin, utilisez la matrice 40x40 comme indices dans la chaîne "X "(l' @ici est implicite)

Gelée , 29 octets

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

Essayez-le en ligne!