Правило 110 - це стільниковий автомат з деякими цікавими властивостями. Ваша мета - імітувати правило 110 якомога менше символів.

Для тих, хто не знає, правило 110 моделюється по рядку в сітці. Кожен квадрат у рядку сітки дивиться на квадрати вгорі, вліво та вгорі праворуч, щоб визначити, якою вона повинна бути.

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

Введення: числа від 0 до 39, що представляють n-й вхідний квадрат верхнього ряду, у будь-якому розумному форматі (рядок, розділений комами, список, аргументи функції). Для розміщення 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} та {padded line}
- >3<дістає фрагмент із 3-х елементів із прокладеного рядка, починаючи з поточного числа
- 2bперетворює з бази 2; Елементи, які ми нарізали, не є двома цифрами базового рівня, але символи перетворюються на їх значення ASCII і '' mod 8 - 0 і '!' mod 8 є 1
- 137Ybперетворює 137 в базу 2 ( Y= 2), отримуючи [1 0 0 0 1 0 0 1], що повертається на 110 і заперечується (на 8 біт)
- ='!^отримує відповідну цифру бази-2 ( масив обертається навколо, так що індекс береться за модуль 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","
"]<>""

Так, ви можете розцінити це як зловживання цією лазівкою , але а) що лазівка ​​досить суперечлива, б) на запитання Cellular Automaton потрібна відповідь Mathematica (особливо, це стосується правила 110) і c) відповідь Рубі на Вентеро в будь-якому випадку коротший, тому я не вважаю Я не думаю, що якась шкода зроблена.

Більшість символів використовується для розбору входу та форматування виводу. Фактичний автомат моделюється за допомогою

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

С - 178

Цей код залежить від того, що кожен рядок у матриці зберігається у суміжній пам'яті. Крім того, він не друкує перший рядок, але друкує 40 наступних, оскільки правила лише задали сітку 40х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

Haskell , 175 170 169 136 127 124 байт

−9 байт завдяки @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

Спробуйте в Інтернеті!

Haskell , 135 131 130 байт

^{-1 байт завдяки Ørjan Johansen (перестановка 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"]

Java, 321 символ

Наприклад, введення передається як аргумент з командного рядка java R 38,39

Я більше ніколи не писав більш прихованого коду Java :-)

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

Оновлення: Приклад коректного виводу тут (40 рядків не 50): Новий вихід нижче (видалений попередній для стислості):

                                      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, і раптом вони набагато складніші, ніж я спочатку думав. Коли я отримую час, я думаю, я можу значно побити цей рахунок. Наразі він залишається незмінним на неконкурентному рівні 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

Input - рядок введення на початку як $ a = '38, 39 ';

Вихід такий:

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

Сподіваюся, вам сподобається!!!

PS Мені довелося додати до коду кілька перерв рядків, щоб ви могли бачити все це і не мати його на протязі сторінки за допомогою смуги прокрутки.

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`

К (нг / к) , 44 35 байт

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

Спробуйте в Інтернеті!

{ } функція з аргументом x

!40 список вводів від 0 до 39

x?знайти свої індекси в x, використати0N ("ціле число нуль") для не знайдено

^хто з них є нулями? це дає нам вхід, заперечуючи

39{ }\ застосовувати 39 разів, збираючи проміжні результати у списку

1,x,1 оточити список 1s (заперечені 0s)

3' трійки послідовних предметів

2/' двійкове декодування кожного

@ використовувати як індекси у ...

2\145 двійковий кодування 145 (заперечені біти 110)

"X "нарешті, використовуйте матрицю 40x40 як індекси в рядку "X "( @тут неявно)

Желе , 29 байт

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

Спробуйте в Інтернеті!