Simuler la règle 110

27

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.

qwr
la source
4
Les motifs s'enroulent-ils (c'est-à-dire que la cellule la plus à gauche vérifie la cellule la plus à droite dans la ligne au-dessus)?
Ventero
4
Si c'est singulier, c'est un automate cellulaire .
ClickRick
1
Les réponses peuvent être fractionnellement plus courtes que Simuler n'importe quel automate cellulaire 1D car la règle est codée en dur plutôt que d'avoir à être analysée à partir de l'entrée, mais à part cela, les réponses seront les mêmes. S'il s'agissait d'une règle différente, il y aurait un potentiel d'économies, mais comment diable un boîtier spécial une règle puissante de Turing sauverait-il quoi que ce soit par rapport à une implémentation générale?
Peter Taylor
1
@Ventero Ils ne le font pas dans cette version.
qwr
1
@BMO c'est une vieille question, mais comme de nos jours le consensus est d'autoriser des formats d'entrée flexibles, je vais modifier la question pour l'autoriser
qwr

Réponses:

8

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

aditsu
la source
17

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
Ventero
la source
8

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

Martin Ender
la source
8

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

Alex L
la source
3
['X',' ']pourrait être modifié 'X 'pour enregistrer 5 caractères.
Calvin's Hobbies
16
Mon fruit préféré est maintenant uno=range()
kitcar2000
7

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;~:]}
skeevey
la source
5

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
Loisirs de Calvin
la source
J'ai spécifié l'entrée: dans votre cas, vous devrez utiliser input () et formater l'entrée comme spécifié dans le message d'origine.
qwr
5

Mathematica, 113 caractères

Une autre réponse Mathematica utilisant CellularAutomaton.

Print@@" "["X"][[#]]&/@CellularAutomaton[110,SparseArray[#+1->1&/@ImportString[InputString[],"CSV"][[1]],40],39];
alephalpha
la source
Intéressant, comment ça " "["X"][[#]]&marche?
Martin Ender
@ m.buettner " "["X"][[1]]est "X". " "["X"][[0]]renvoie la tête de " "["X"], à savoir " ".
alephalpha
Oh je vois. Il s'agit donc généralement de sauvegarder un caractère pour les listes. C'est vraiment intelligent. Je suppose que vous pouvez l'ajouter à codegolf.stackexchange.com/questions/12900/…
Martin Ender
4

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);
}
Allbeert
la source
3

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
AndoDaan
la source
1
do u(n,i,'x')c'est intentionnel, non?
Stan Strum
3

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!

FrownyFrog
la source
3

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

4101

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

40

    take 40$              iterate r

0 et1 à un certain caractère de fantaisie:

            map(" o"!!)<$>

La fonction rqui applique la110-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
ბიმო
la source
1
Enregistrez un octet en le mettant take 40$avant map(" o"!!)<$>.
Ørjan Johansen
3

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"]
ბიმო
la source
2

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;}}}
Tomáš Dvořák
la source
2

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.

Paul Drewett
la source
Votre sortie a 50 lignes
Aditsu
Ah, c'était parce que je jouais avec après avoir fini et vu ce qui s'était passé. Modifier légèrement les règles a des effets si intéressants. Quoi qu'il en soit, il est passé à 40 maintenant et désolé de l'avoir manqué.
Paul Drewett
Vous pouvez également changer la sortie: p
aditsu
Correction de la sortie et ajout d'un nouveau lien de codepad avec la valeur correcte. Merci encore.
Paul Drewett
2

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`
Weijun Zhou
la source
1

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)

ngn
la source