Добре відомо, що людина на сітці під впливом алкоголю має рівний шанс піти в будь-якому доступному напрямку. Однак це твердження здорового глузду не належить до царства дуже маленьких п'яниць, поведінка яких дуже схожа на те, що вони беруть одразу кожен доступний шлях, і можливі шляхи, які вони проходять, можуть заважати один одному. Ваше завдання - відобразити можливі позиції такого квантового п’яниці після nкроків.

Специфікація

Пияцтво, про яке йде мова, займає квадратну сітку, і його можна вважати 3-штатним стільниковим автоматом, що використовує сусідство фон Неймана (плюс-у формі), яке дотримується цих простих правил:

• Emptyпереходить до, Awakeякщо він суміжний точно з одним Awake, інакше переходить доEmpty
• Awake йде на Sleeping
• Sleeping йде на Sleeping

Початковий стан дошки - це єдине Awakeоточене нескінченним полем Emptys.

Виклик

Давши негативне ціле число n, створіть подання ASCII п'яниці після nкроків. Кожен стан повинен бути представлений різним характером, а рішення повинні визначати, який символ означає, який стан. Якщо ви використовуєте пробіли для Empty, вам не потрібно включати запуск їх у кінці рядка.

Це код-гольф , тому найкоротша відповідь виграє. Застосовуються стандартні лазівки , дозволена пробільна та кінцева пробіли, дозволено вихід масиву рядків / двовимірний масив тощо.

Приклади

Ці приклади використовуються для Empty, @для Awakeта #для Sleeping.

n=0
@

n = 1
 @
@#@
 @

n = 2
  @
  #
@###@
  #
  @

n = 3
   @
  @#@
 @ # @
@#####@
 @ # @
  @#@
   @

n=6

      @
      # 
    @###@
     @#@  
  @  ###  @
  #@# # #@#
@###########@
  #@# # #@#
  @  ###  @
     @#@
    @###@
      #
      @

n=10
          @
          #
        @###@
         @#@
         ###
        # # #
       #######
      #  ###  #
  @  ##  ###  ##  @
  #@# ### # ### #@#
@###################@
  #@# ### # ### #@#
  @  ##  ###  ##  @
      #  ###  #
       #######
        # # #
         ###
         @#@
        @###@
          #
          @

Цікава примітка

Переглянувши послідовність кількості окупованих клітин в ОЕІС, я виявив, що квантовий п'яницю ізоморфний набагато краще вивченій послідовності зубочисток . Якщо ви зможете включити ці знання в кращий гольф, я буду вражений відповідним чином.

Мова Вольфрама (Mathematica) , 92 91 байт

Print@@@CellularAutomaton[{7049487784884,{3,{a={0,3,0},3-2a/3,a}},{1,1}},{j={{1}},0},{j#}]&

Ідеальний виклик для використання вбудованої програми Mathematica CellularAutomaton!

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

Порожній = 0, Прокидається = 1, спить = 2

Анімація перших 256 ітерацій (білий = порожній, сірий = неспаний, чорний = сплячий):

Пояснення

CellularAutomaton[ ... ]

Виконати CellularAutomatonіз специфікаціями ...

{7049487784884,{3,{a={0,3,0},3-2a/3,a}},{1,1}}

Застосуйте 3-кольорове тоталістичне правило 7049487784884 із сусідством Фон Нойман ...

{j={{1}},0}

На дошці з одинарним 1 посередині, з фоном 0 ...

{j#}

Повторити <input>часи ( {j#}оцінюється до {{{#}}}). Масив автоматично розширюється, якщо комірка поза межами кордону не є такою ж, як фон

7049487784884

Це правило походить від номера base-3 220221220221220221220221220, що означає "змінити все 1або 2на 2, і змінити 0на, 1якщо і лише тоді, коли 1навколо нього є непарна кількість s".

Print@@@

Друк масиву.

Напівдоказ "" непарних 1"еквівалентно" точно одному 1":

Розглянемо цю сітку пікселів 5x5. Білий - це 0або 2клітина (неспані пікселі), а сірий - 1клітина.

Якщо 1комірка була сформована навколо трьох 0комірок, то сітка повинна мати такий вигляд: вона має три 1s, розташовані у формі U (або повернутий варіант) таким чином:

Через самоподібність цього стільникового автомата будь-яка картина, що з’являється в стільниковому автоматі, повинна з’являтися на діагоналі (шляхом індукції). Однак ця закономірність не є діагонально симетричною. тобто він не може виникати по діагоналі і не може з’являтися ніде на стільниковому автоматі.

Пробудження / сон - рівноцінні

Зауважте, що 0клітина не може бути оточена рівно однією або трьома 2клітинками та клітинами спокою 0, оскільки це означає, що кілька кроків до цього клітина мала сусідом одну чи три 1клітини - і, мабуть, перетворилася на 1вже (суперечність). Тому добре ігнорувати відмінність між 1і 2та державою "змінити все 1на 1, а 0на" а "на" 1якщо "та" лише ", якщо у нього є непарна кількість ненульових сусідів".

Отриманий стільниковий автомат справді ідентичний оригіналу, єдиною різницею є відсутність різниці між "сплячими" та "сплячими" п'яними. Ця модель описана в OEIS A169707 .

Print@@@CellularAutomaton[{750,{2,{a={0,2,0},2-a/2,a}},{1,1}},{j={{1}},0},{j#}]&

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

Побічне порівняння перших 16 ітерацій:

Додавання двох послідовних ітерацій дає результат, що відповідає специфікаціям виклику (94 байти):

Print@@@Plus@@CellularAutomaton[{750,{2,{a={0,2,0},2-a/2,a}},{1,1}},{{{1}},0},{Ramp@{#-1,#}}]&

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

Python 2 , 192 байти

x=input()
o=c={x+x*1j}
R=range(x-~x)
exec"n=[C+k for k in-1j,1j,-1,1for C in c];n={k for k in n if(k in o)<2-n.count(k)};o|=c;c=n;"*x
print[[`(X+Y*1jin c)+(X+Y*1jin o|c)`for Y in R]for X in R]

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

-17 байт завдяки містеру Xcoder
-9 байт, використовуючи вихідний формат Джонатана
-11 байт завдяки Лінну
-3 байти завдяки овам

C, 360 354 343 319

#define A(i,b,e)for(int i=b;i<e;++i)
#define B(b,e)A(r,b,e){A(c,b,e)
#define W(n)(n<0?-(n):n)
#define C(r,c)b[W(r)*s+W(c)]
#define D C(r,c)

q(n){char N,s=n+2,(*b)[2]=calloc(s,2*s);C(0,0)
[1]=1;A(g,0,n+1){B(0,s)*D=D[1];}B(0,g+2){N=(*C
(r-1,c)+*C(r+1,c)+*C(r,c-1)+*C(r,c+1))&1;D[1]=
*D?2:N;}}}B(2-s,s-1)putchar(*D+32);puts("");}}

Нові #defineрядки після не рядків - лише для презентації, тому вони не враховуються. Я включив функцію обгортки, тож це −6 (313), якщо функція не рахується, і ви припускаєте, що nпоходить з інших місць. q(10)Виходи:

          !          
          "          
        !"""!        
         !"!         
         """         
        " " "        
       """""""       
      "  """  "      
  !  ""  """  ""  !  
  "!" """ " """ "!"  
!"""""""""""""""""""!
  "!" """ " """ "!"  
  !  ""  """  ""  !  
      "  """  "      
       """""""       
        " " "        
         """         
         !"!         
        !"""!        
          "          
          !          

Використання для порожнього, "для сну та !для пробудження.

Це працює так:

• A(i,b,e)є “∀i∈ [b, e).”, B(b,e)є “∀r∈ [b, e) .∀c∈ [b, e)”.

• Зауважте, що після n поколінь дошка становить 2 n + 1 квадрат.

• Через симетрію дошки для цього потрібно лише імітувати нижній правий квадрант, тому ми виділяємо n + 1 квадратну матрицю з 1 рядком та стовпцем набивання для подальшого пошуку сусідів (так n + 2).

• Виділення за callocдопомогою дозволяє одночасно помножити ширину на висоту і очистити дошку 0(порожньо).

• Під час пошуку комірки за її координатами ( Cі D) вона використовує абсолютне значення рядка та стовпця ( W) для автоматичного відображення координат.

• Дошка зберігається як масив пар цілих чисел, що представляють поточне та попереднє покоління. Цілі числа, про які йдеться, charтому ми можемо уникати sizeof.

• Покоління, яке найчастіше шукали (за допомогою сусіда), - це минуле покоління, тому воно розміщується в парі з індексом 0, щоб отримати доступ до нього *.

• У кожному поколінні ( g) поточне покоління копіюється над попереднім поколінням за допомогою Bциклу, потім нове покоління генерується зі старого.

• Кожна клітина представлена ​​як 0для порожнього 1, так і 2для сну. Підрахунок сусідів спочатку був обчисленням кількості бітів, встановлених у низьких 4 бітах комірки, коли чотири сусіди зміщуються & OR'd разом як прапори ( N), використовуючи 16для сну. Але зауваживши, що непарна кількість сусідів еквівалентна рівно 1 сусідові, ми можемо зберегти кілька символів, просто використовуючи маску з 1.

• Зрештою, дошка друкується в повному обсязі шляхом повторення в нижньому правому квадранті, використовуючи той самий фокус координати абсолютного значення, за вирахуванням прокладки, щоб ми не друкували зовнішню прокладку на дошці. Це також, чому Bцикл містить відкриту фігурну дужку, оскільки у нас є додатковий вислів нового рядка у зовнішньому циклі.

• Коди ASCII зручно відображати 0 + 32 (порожній) у простір, 2 + 32 (спальний) до "та 1 + 32 (неспаний) на !.

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

MATL , 39 байт

QtE:=&*G:"tt0=w1Y6Z+Xj1=*w|gJ*+]Q|U31+c

Це відображається

• Emptyяк (пробіл)
• Awake як #
• Sleepingяк !.

Спробуйте в Інтернеті! Ви також можете спостерігати, як закономірність зростає в мистецтві ASCII або графічно (модифікований код).

Пояснення

Код використовує комплексні числа 0, 1, jщоб представити три стану: порожні, поминки, спати відповідно.

Q         % Implicitly input n. Add 1
tE        % Duplicate and multiply by 2
:         % Range [1 2 ... 2*n]
=         % Test for equalty. Gives [0 ... 0 1 0... 0], with 1 at position n
&*        % Matrix of all pairwise products. Gives square matrix of size 2*n
          % filled with 0, except a 1 at position (n,n). This is the grid
          % where the walk will take place, initiallized with an awake cell
          % (value 1). The grid is 1 column and row too large (which saves a
          % byte)
G:"       % Do n times
  tt      %   Duplicate current grid state twice
  0=      %   Compare each entry with 0. Gives true for empty cells, false
          %   for the rest
  w       %   Swap: moves copy of current grid state to top
  1Y6     %   Push 3×3 matrix with Von Neumann's neighbourhood
  Z+      %   2D convolution, maintaining size
  Xj      %   Real part
  1=      %   Compare each entry with 1. This gives true for cells that
          %   have exactly 1 awake neighbour
  *       %   Multiply, element-wise. This corresponds to logical "and": 
          %   cells that are currently empty and have exactly one awake
          %   neighbour. These become 1, that is, awake
  w       %   Swap: moves copy of current grid state to top
  |g      %   Absolute value, convert to logical: gives true for awake or
          %   sleeping cells, false for empty cells
  J*+     %   Mulltiply by j and add, element-wise. This sets awake and 
          %   sleeping cells to sleeping. The grid is now in its new state
]         % End
Q         % Add 1, element-wise. Transforms empty, awake, sleeping 
          % respectively from 0, 1, j into 1, 2, 1+j
|U        % Abolute value and square, element-wose. Empty, awake, sleeping 
          % respectively give 1, 4, 2
31+c      % Add 31 element-wise and convert to char. Empty, awake, sleeping 
          % respectively give characters ' ' (codepoint 32), '#' (codepoint 
          % 35) and '!' (codepoint 33). Implicitly display

Befunge, 384 304 байт

&:00p->55+,000g->>00g30p:40p\:50p\5>>40g!50g!*vv0g05g04p03-<
@,+55_^#`g00:+1$_^>p:4+4g5%2-50g+5#^0#+p#1<v03_>30g:!#v_:1>^
#v_>$99g,1+:00g`^ ^04+g04-2%5g4:\g05\g04\p<>g!45*9+*3+v>p:5-
 >\50p\40p\30p:#v_>>0\99g48*`!>v >30g:1-30^>>**\!>#v_>v^9 9<
$0\\\\0$        >\99g88*-!+\:4->#^_\>1-!48>^       >$3>48*+^

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

Проблема з спробою впровадити подібну річ у Befunge - обмежений об'єм пам'яті (2000 байт як для даних, так і для коду). Тому мені довелося використовувати алгоритм, який обчислює правильний символ для будь-якої заданої координати без посилання на попередні обчислення. Це досягається шляхом рекурсивного огляду назад у часі на всі можливі шляхи, які, можливо, пропив би п'яниця, щоб досягти цієї точки.

На жаль, це не особливо ефективне рішення. Це працює, але це неймовірно повільно, і воно стає експоненціально повільніше, чим більше значення n . Тож, хоча це потенційно може працювати для будь-яких n до приблизно 127 (7-бітний ліміт комірки Befunge), на практиці ви неминуче втрачаєте інтерес, чекаючи результату. У TIO воно спричинить 60-секундний тайм-аут, що перевищує 6 (в кращому випадку). Компілятор зробить набагато краще, але навіть тоді ви, мабуть, не хотіли б набагато перевищувати 10.

І все-таки я подумав, що це варто подати, адже це насправді досить приємна демонстрація рекурсивної "функції" в Befunge.

Python 2 , 214 байт

def f(n):k=n-~n;N=k*k;A=[0]*N;A[N/2]=2;exec"A=[[2*([j%k>0and A[j-1],j%k<k-1and A[j+1],j/k>0and A[j-k],j/k<k-1and A[j+k]].count(2)==1),1,1][v]for j,v in enumerate(A)];"*n;print[map(str,A)[k*x:][:k]for x in range(k)]

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

Пояснення

Використовує 0для empty, 1для sleepingі 2для awake. Виводить список двовимірних символів (рядки на одну довжину).
Визначає функцію, яка приймає невід'ємне ціле число n. Послідовно просуває стільниковий автомат до досягнення бажаного стану. Нарешті, застосовується перетворення між внутрішніми цілими значеннями та фактичними символами.

Луа , 251 242 239 238 байт

-8 байт шляхом спрощення ініціалізатора масиву за рахунок додаткової провідної пробільної області.
-1 байт, перейшовши c=i==2+...and print(s)на c=i~=2+...or print(s).
-3 байти, спочатку побудувавши повний рядок і надрукувавши один раз в кінці.
-1 байт завдяки Джонатану Фреху , переписавши or(g(...)==1 andяк or(1==g(...)and.

function g(x,y)return(a[x]or{})[y]or 0 end a={{1}}for i=2,2+...do n={}s=""for x=-i,i do n[x]=n[x]or{}q=a[x]or{}for y=-i,i do n[x][y]=q[y]and 0or(1==g(x+1,y)+g(x,y+1)+g(x-1,y)+g(x,y-1)and 1)s=s..(q[y]or" ")end s=s.."\n"end a=n end print(s)

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

Порожній =
Пробіг у космосі = 1
Сон =0

Здійснює введення з командного рядка і друкує до stdout.

Представляючи стану , як false/ nil, 1і 0внутрішньо, виявляючи «порожній» не потребує в який - або код , і «точно один не спить» перевірка може бути зроблено тільки з додаванням.

APL (Dyalog) , 38 байт

((2∘∧⌈1={2⊃+/1=⍵,⍉⍵}⌺3 3)(⌽0,⍉)⍣4)⍣⎕⍪1

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

-4 завдяки Адаму .
-8 завдяки ngn .

Желе , 39 29 байт

-,1ṙ@€Sµ+Z
‘ṬŒḄ×þ`µÇ׬Ḃ+Ḃ+µ³¡

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

Використовує 0, 1і 2для порожнього неспання і сну. Нижній колонтитул у посиланні перетворює це на , @і #.

• -1 байт, використовуючи ṬŒḄзамість ḤḶ=¹.
• -2 байти, використовуючи -замість 1N. Також робить ¤непотрібним.
• -1 байт, використовуючи Sзамість +/.
• -6 байт, використовуючи Ḃ+Ḃ+замість %3=1+=1Ḥ$+. Тепер використовує 2для сну замість 3.

Пояснення надходить ...

APL (Dyalog Classic) , 38 байт

((2∘∧⌈2|⍉∘g∘⍉+g←3+/0,,∘0)(⌽0,⍉)⍣4)⍣⎕⍪1

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

на основі рішення Еріка Атгольфера

⍪1 являє собою матрицю 1x1, що містить 1

⎕ eval'ed введення

( )⍣⎕ застосовувати це багато разів

• (⌽0,⍉)⍣4оточіть 0, тобто 4 рази зробіть: транспоніруйте ( ⍉), додайте 0 зліва ( 0,), поверніть горизонтально ( ⌽)

• g←3+/0,,∘0 функція, яка підсумовує горизонтальні трійки, назвіть її g

• ⍉∘g∘⍉функція, яка підсумовує вертикальні трійки - перебуває gпід транспозицією

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 сума двох сум за модулем 2

• ⌈ тим більше між цим і ...

• 2∘∧ LCM 2 і оригінальна матриця - це перетворює 1s на 2s, зберігаючи 0s і 2s

Perl 5 , 192 + 1 ( -n) = 193 байт

for$i(1..2*$_+1){push@a,[()x$_]}$a[$_][$_]=1;map{@b=();for$i(0..$#a){map$b[$i][$_]=$a[$i][$_]?2:$a[$i-1][$_]+($_&&$a[$i][$_-1])+$a[$i+1][$_]+$a[$i][$_+1]==1?1:0,0..$#a}@a=@b}1..$_;say@$_ for@a

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

Використовує 0 для порожнього, 1 для пробудження і 2 для сну.

Рубі , ₁₆₄ 153 байт

->n{(r=([e=' ']*(l=2*n+1)<<"
")*l)[n+n*l+=1]=a=?@
n.times{r=r.map.with_index{|c,i|c==a ??#:c==e ?r.values_at(i-1,i+1,i-l,i+l).one?{|v|v==a}?a:e:c}}
r*""}

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

Використовує "" для порожнього, "@" для пробудження та "#" для сну (як у прикладі). Я міг би зберегти 6 байтів, використовуючи замість них числа, але це виглядає краще так.

Піп , 69 61 байт

60 байт коду, +1 для -lпрапора.

YZG2*a+1y@a@a:1LaY{y@a@b?2oN(y@(a+_)@(b+B)MP[0o0v0])=1}MC#yy

Вважається nаргументом командного рядка. Використовує 0для порожнього, 1для пробудження та 2для сну. ( Для того, щоб отримати більш хороший ASCII-арт , як в прикладах на виклик, в заміні фіналі yз " @#"@y.)

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

Пояснення

Налаштування:

YZG2*a+1y@a@a:1

                 Implicit: a is 1st cmdline arg; o is 1; v is -1
 ZG2*a+1         Square grid (i.e. nested list) of 0's, with side length 2*a+1
Y                Yank into y variable
        y@a@a:1  Set the element at coordinates (a,a) to 1

Основна петля:

LaY{...}MC#y

La            Loop (a) times:
          #y  Len(y) (i.e. 2*a+1)
   {   }MC    Map this function to the coordinate pairs in a 2*a+1 by 2*a+1 grid
  Y           and yank the resulting nested list back into y

де тіло функції:

y@a@b?2oN(y@(a+_)@(b+B)MP[0o0v0])=1

                                     The function args, representing the coords of the
                                     current cell, are a and b
y@a@b?                               Is the cell at these coords 0 or nonzero?
      2                              If nonzero (1 or 2), make it 2
                                     Else, if zero, we need to check the neighbors
                         [0o0v0]     List of [0; 1; 0; -1; 0]
                       MP            Map this function to each adjacent pair of values--
                                     i.e. call it four times with args (0; 1), (1; 0),
                                     (0; -1), and (-1; 0)
          y                           Index into the grid using
           @(a+_)                     a + the 1st item in the pair as the row and
                 @(b+B)               b + the 2nd item in the pair as the column
                                     The result of MP is a list of the values of the cells
                                     in the Von Neumann neighborhood
       oN(                      )    Get the number of 1's in that list
                                 =1  and test if it equals 1
                                     If so, the new value of this cell is 1; if not, it's 0

Після циклу ми просто автодрукуємо y. -lПрапор означає , що вкладений список друкується шляхом конкатенації вмісту кожного рядка і розділяючи рядки з символами нового рядка.

Java (OpenJDK 8) , 220 байт

n->{int s=n*2+3,i=0,x,y;char[][]a=new char[s][s],b;for(a[s/2][s--/2]=61;i++<n;a=b)for(b=new char[s+1][s+1],x=0;++x<s;)for(y=0;++y<s;)b[x][y]=a[x][y]>32?'0':(a[x][y-1]+a[x][y+1]+a[x-1][y]+a[x+1][y])%8==5?61:' ';return a;}

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

Примітка: повернутий масив містить рамку або '\0'символи. Оскільки літак повинен бути нескінченним, використовується лише безкордонний.

Відображення символів:

• Порожньо: (пробіл)
• Прокинься: =
• Сон: 0

Економить

• 29 байт збережено завдяки Джонатану С.
• Ще 9 байт завдяки Джонатану С. шляхом обміну персонажами з іншими та "магією з праймерами та модульною арифметикою"

Пітон, 199 192 байт

Цей код працює як на Python 2, так і на Python 3, але для обробки масиву використовується популярна стороння бібліотека Numpy.

from numpy import*
def f(n):
 m=2*n+1;g=zeros((m+2,)*2,'i');g[n+1,n+1]=1
 while n:a=g[1:-1,1:-1];a[:]=(a<1)*(sum(g[r:r+m,c:c+m]&1for r,c in((0,1),(1,0),(1,2),(2,1)))==1)+(a>0)*2;n-=1
 return g

Порожній = 0
Пробудись = 1
Сплячий = 2

print(f(6)) виходи

[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 2 0 0 0 0 0 0 0]
 [0 0 0 0 0 1 2 2 2 1 0 0 0 0 0]
 [0 0 0 0 0 0 1 2 1 0 0 0 0 0 0]
 [0 0 0 1 0 0 2 2 2 0 0 1 0 0 0]
 [0 0 0 2 1 2 0 2 0 2 1 2 0 0 0]
 [0 1 2 2 2 2 2 2 2 2 2 2 2 1 0]
 [0 0 0 2 1 2 0 2 0 2 1 2 0 0 0]
 [0 0 0 1 0 0 2 2 2 0 0 1 0 0 0]
 [0 0 0 0 0 0 1 2 1 0 0 0 0 0 0]
 [0 0 0 0 0 1 2 2 2 1 0 0 0 0 0]
 [0 0 0 0 0 0 0 2 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Якщо ви хочете кращого друку, ви можете назвати це так:

n=6;print('\n'.join(''.join(' @#'[v]for v in u)for u in f(n)))

який друкує, використовуючи ті самі символи, що й у запитанні.