Simula la regola 110

27

La Regola 110 è un automa cellulare con alcune proprietà interessanti. Il tuo obiettivo è simulare una regola 110 nel minor numero di caratteri possibile.

Per chi non lo sapesse, la regola 110 viene simulata riga per riga in una griglia. Ogni quadrato in una linea della griglia guarda i quadrati sopra, sopra a sinistra e sopra a destra per determinare quale cella dovrebbe essere.

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

Input: numeri da 0 a 39 che rappresentano la riga superiore dell'ennesimo quadrato di input, in qualsiasi formato ragionevole (stringa, elenco, argomenti di funzione separati da virgola). Per ospitare le lingue con 1 indice, i numeri possono anche essere 1 e quindi vanno da 1 a 40.

Esempio di input:

38,39

Output: una griglia 40 x 40 che rappresenta gli automi in esecuzione inclusa la prima riga. Dovresti lasciare 0 vuoto e 1 come qualsiasi carattere di stampa visibile. Sono consentiti spazi finali, purché la griglia effettiva possa ragionevolmente essere distinta. La parte inferiore della griglia potrebbe avere una nuova riga ma non dovrebbero esserci linee vuote tra le linee della griglia.

Esempio di output:

                                  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

eccetera.

Nota: una domanda simile sugli automi cellulari 1D è già stata posta, ma spero che, usando solo una regola, si possano scrivere risposte più brevi.

code-golf  cellular-automata 
— QWR
fonte
4
I motivi si avvolgono (ovvero la cella più a sinistra controlla la cella più a destra nella linea sopra di essa)?
— Ventero,
4
Se è singolare, allora è un automa cellulare .
— ClickRick
1
Le risposte possono essere leggermente più brevi rispetto a Simulare qualsiasi automa cellulare 1D perché la regola è hardcoded anziché dover essere analizzata dall'input, ma a parte questo le risposte saranno le stesse. Se si trattasse di una regola diversa, allora ci sarebbe un potenziale di risparmio, ma come mai la custodia speciale di una regola potente di Turing risparmierebbe qualcosa su un'implementazione generale?
— Peter Taylor,
1
@Ventero Non lo fanno in questa versione.
— qwr,
1
@BMO questa è una vecchia domanda, ma dato che al giorno d'oggi il consenso è di consentire formati di input flessibili, modificherò la domanda per permetterlo
— qwr

Risposte:

8

CJam - 47

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

Utilizza !per "1" celle.

Provalo su http://cjam.aditsu.net/

Spiegazione:

S40*crea una stringa (matrice) di 40 spazi
l',/legge una riga e si divide per virgola
{…}/esegue il blocco per ogni elemento (i numeri in forma di stringa)
- i'!tconverte il numero in numero intero e imposta l'elemento in quella posizione nella stringa precedente (inizialmente 40 spazi ) a '!'
A questo punto abbiamo ottenuto la prima riga.
{…}39*esegue il blocco 39 volte
- Naggiunge una nuova riga
- 40,crea l'array [0 1… 39]
- S3$S++copia la riga precedente (posizione 3 nello stack) e la riempie con uno spazio su ciascun lato
- f{…}esegue il blocco per {ogni numero da 0 a 39} e {la linea imbottita}
: >3<prende una porzione di 3 elementi dalla linea imbottita a partire dal numero corrente
- 2bconverte dalla base 2; gli elementi che abbiamo diviso non sono cifre di base 2, ma i caratteri vengono convertiti nei loro valori ASCII e '' mod 8 è 0 e '!' mod 8 è 1
- 137Ybconverte 137 in base 2 ( Y= 2), ottenendo [1 0 0 0 1 0 0 1], che è 110 invertito e negato (su 8 bit)
- ='!^ottiene la corrispondente cifra base-2 (il l'array si avvolge in modo che l'indice sia preso mod 8) e xo lo è con '!' carattere, risultante in "!" per 0 e '' per 1

— aditsu
fonte
17

Rubino, 113 caratteri

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

Accetta input su stdin. Per usare una regola diversa, sostituisci semplicemente 110l'ultima riga con qualunque regola tu voglia provare.

Esempio:

$ 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
fonte
8

Mathematica, 122 byte

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

Sì, potresti considerare questo come un abuso di questa scappatoia , ma a) che la scappatoia è piuttosto contestata, b) una domanda di Automaton cellulare ha bisogno di una risposta di Mathematica (specialmente una relativa alla Regola 110) ec) la risposta di Ruby di Ventero è comunque più breve, quindi io pensa che non sia fatto alcun danno.

La maggior parte dei caratteri viene utilizzata per l'analisi dell'input e la formattazione dell'output. L'automa reale viene simulato utilizzando

CellularAutomaton[110,initialGrid,39]

Questo utilizza condizioni al contorno periodiche (quindi la griglia si avvolge).

— Martin Ender
fonte
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)

Esegui come ad es python 110.py <<< 38,39

— Alex L
fonte
3
['X',' ']potrebbe essere modificato in 'X 'per salvare 5 caratteri.
— Calvin's Hobbies,
16
Il mio frutto preferito è orao=range()
— kitcar2000 il
7

q, 67 62 58 byte

Non presuppone alcun avvolgimento:

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

Vecchia versione

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

Decente ma probabilmente non ottimale.

Non hai specificato come si ottiene l'input, quindi ho appena creato una funzione.

Usa esempio:

r ([38,39])

Produzione:

                                      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
— Hobby di Calvin
fonte
Ho specificato l'input: nel tuo caso dovresti usare input () e formattare l'input come specificato nel post originale.
— qwr,
5

Mathematica, 113 caratteri

Un'altra risposta di Mathematica che utilizza CellularAutomaton.

Print@@" "["X"][[#]]&/@CellularAutomaton[110,SparseArray[#+1->1&/@ImportString[InputString[],"CSV"][[1]],40],39];
— alephalpha
fonte
Interessante, come " "["X"][[#]]&funziona?
— Martin Ender,
@ m.buettner " "["X"][[1]]è "X". " "["X"][[0]]restituisce il capo di " "["X"], vale a dire " ".
— alephalpha,
Oh, capisco. Quindi, in genere questo è solo il salvataggio di un personaggio per le liste. È davvero intelligente. Immagino che potresti aggiungerlo a codegolf.stackexchange.com/questions/12900/…
— Martin Ender
4

C - 178

Questo codice dipende dal fatto che ogni riga in una matrice è memorizzata nella memoria contigua. Inoltre, non stampa la prima riga, ma stampa le successive 40, poiché le regole specificano solo una griglia 40x40.

Indentato per sola leggibilità, il conteggio dei byte include solo il codice necessario.

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
fonte
3

Lua - 351

Non è la lingua ideale per giocare a 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
fonte
1
do u(n,i,'x')è intenzionale, no?
— Stan Strum
3

Haskell , 175 170 169 136 127 124 byte

−9 byte grazie a @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

Provalo online!

— FrownyFrog
fonte
3

Haskell , 135 131 130 byte

-1 byte grazie a Ørjan Johansen (riordino take 40)

Approccio completamente diverso alla risposta di FrownyFrog ma della stessa lunghezza:

(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

Spiegazione

4101

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

40

    take 40$              iterate r

01

            map(" o"!!)<$>

r110zipWith3(?)

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

L' (?)operatore è la parte più interessante della soluzione: in precedenza avevo usato una regola booleana generata con una mappa di Karnaugh, ma risulta che esiste un modo ancora più conciso:

(a?b)r=mod(b+r+b*r+a*b*r)2
— ბიმო
fonte
1
Salvare un byte inserendo take 40$prima map(" o"!!)<$>.
— Ørjan Johansen,
3

Buccia , 31 28 byte

Ah, Husk sta battendo Jelly!

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

Provalo online!

Spiegazione e Ungolfed

Prima di aggiungere una spiegazione, deselezionalo un po '. Rimuoviamo le varie composizioni, aggiungiamo parentesi esplicite e decomprimiamo la ¨↑¨stringa. Sostituiamo anche 40con 4per una spiegazione più leggibile:

†!"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"]
— ბიმო
fonte
2

Java, 321 caratteri

Input passato come argomento dalla riga di comando, ad esempio java R 38,39

Non ho mai scritto codice java più offuscato :-)

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
fonte
2

Aggiornamento: esempio di output corretto qui (con 40 righe non 50): nuovo output di seguito (rimosso il precedente per brevità):

                                      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

Facendo un altro enigma ho imparato qualcosa di interessante sulle istruzioni di nidificazione per i loop in php, e improvvisamente sono molto più complessi di quanto pensassi inizialmente. Quando ho tempo, credo di poter battere questo punteggio considerevolmente. Per ora però rimane invariato a un 408 non competitivo.

I miei caratteri php versione 408:

Questo è stato un grande enigma. Ho anche passato anni a giocare con gli input in quanto sono cose affascinanti che bisogna dire. Ad ogni modo, ecco la mia versione di PHP (che non è affatto buona come alcune delle risposte postate ma è completa. In posizione 7 prendi solo sopra e sopra a destra, in posizione 39 prendi solo sopra e sopra a sinistra, cioè senza avvolgimento. Quindi qui è la mia versione:

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

Puoi vederlo ed eseguirlo qui: http://codepad.org/3905T8i8

L'input è una stringa di input all'inizio come $ a = '38, 39 ';

L'output è il seguente:

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

Spero ti piaccia!!!

PS Ho dovuto aggiungere alcune interruzioni di riga al codice in modo da poter vedere tutto e non allungarlo attraverso la barra di scorrimento.

— Paul Drewett
fonte
Il tuo output ha 50 righe
— aditsu,
Ah, era perché ci stavo giocando dopo aver finito e visto cosa è successo. Modificare leggermente le regole ha effetti così interessanti. Comunque ora l'ho cambiato in 40 e mi dispiace per averlo perso.
— Paul Drewett,
Potresti voler modificare anche l'output: p
— aditsu,
Correzione dell'output e aggiunta di un nuovo collegamento al codepad con valore corretto. Grazie ancora.
— Paul Drewett,
2

Stax , 24 byte CP437

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

Esegui ed esegui il debug online!

Utilizza il punto di codice 1 in CP437 per le celle "1".

Ottimo caso per mostrare il potere di questa lingua.

Spiegazione

Utilizza la versione decompressa (29 byte) per spiegare.

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
fonte
1

K (ngn / k) , 44 35 byte

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

Provalo online!

{ } funzione con argomento x

!40 elenco di ints da 0 a 39

x?trova i loro indici in x, usa 0N(il "numero intero nullo") per non trovato

^quali di questi sono null? questo ci dà l'input, negato

39{ }\ applicare 39 volte, raccogliendo risultati intermedi in un elenco

1,x,1 circonda la lista con 1s (0s negati)

3' triple di elementi consecutivi

2/' decodifica binaria ciascuno

@ usa come indici in ...

2\145 codifica binaria 145 (bit negati di 110)

"X "infine, usa la matrice 40x40 come indici nella stringa "X "( @qui è implicito)

— NGN
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.