アルコールの影響下にあるグリッド上の人が、利用可能な方向に進む可能性があることはよく知られています。ただし、この常識的な声明は非常に小さな酔っぱらいの領域には当てはまらず、その行動はまるで利用可能なすべてのパスを一度に取るかのようであり、可能なパスが互いに干渉する可能性があります。あなたの仕事は、nステップの後にそのような量子酔っぱらいの可能な位置を表示することです。

仕様

問題の酔っぱらいは正方形のグリッドを占有し、これらの単純な規則に従うフォンノイマン（プラス型）近傍を使用する3状態セルオートマトンと見なすことができます。

• Empty行くAwake、それは正確に一つに隣接している場合はAwake、それ以外に行きますEmpty
• Awake に行く Sleeping
• Sleeping に行く Sleeping

ボードの初期状態は、sのAwake無限フィールドに囲まれた単一の状態ですEmpty。

チャレンジ

非負の整数nを指定すると、nステップの後に酔っぱらいのASCII表現を作成します。各状態は異なる文字で表される必要があり、ソリューションはどの文字がどの状態を意味するかを示す必要があります。にスペースを使用する場合Empty、行末にそれらの実行を含める必要はありません。

これはcode-golfなので、最短の回答が勝ちます。標準の抜け穴が適用され、先頭および末尾の空白が許可され、文字列配列/ 2d文字配列出力が許可されます。

例

これらの例では、for Empty、@for Awake、および#for を使用していSleepingます。

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

興味深いメモ

OEISで占有されているセルの数のシーケンスを調べると、量子酔っぱらいは、よりよく研究された爪tooth枝のシーケンスと同型であることがわかりました。その知識をより良いゴルフに取り入れることができれば、私は適切に感銘を受けるでしょう。

Wolfram言語（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}

バックグラウンドが0である、中央に1が1つあるボード上...

{j#}

繰り返し<input>回数（に{j#}評価されます{{{#}}}）。境界の外側のセルが背景と同じでない場合、配列は自動的に展開されます

7049487784884

このルールは、ベース3の数値220221220221220221220221220に基づいています。これは、「すべて1または2に2変更0し1、1周囲に奇数のs がある場合にのみ変更する」ことを意味します。

Print@@@

配列を印刷します。

"'odd 1s'の半証明は、 'exactly one 1' と同等です：

このピクセルの5x5グリッドを考えてください。白はセル0または2非アウェイクピクセルであり、グレーは1セルです。

1セルが3つの0セルの周囲に生成された場合、グリッドは1次のようになります。次のように、U字型（または回転型）に配置された3つのsがあります。

このセルラオートマトンの自己相似性により、セルラオートマトンに表示されるパターンはすべて（対角線上に）表示される必要があります。ただし、このパターンは対角線対称ではありません。つまり、対角線上では発生せず、セルオートマトンのどこにも表示されません。

覚醒/睡眠は同等です

0セルを正確に1つまたは3つの2セルと残りの0セルで囲むことはできないことに注意してください。これは、いくつかのステップの前に、セルに1つまたは3つの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回の繰り返しの並列比較：

2つの連続した反復を追加すると、チャレンジ仕様（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]

オンラインでお試しください！

Mr Xcoderのおかげで-17バイト
ジョナサンの出力形式を使用して-9バイト
リンのおかげで-11バイト
ovsのおかげで-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はここでの表示用であるため、カウントされません。ラッパー関数を含めたので、関数がカウントされずn、他の場所から来たと仮定すると、-6（313）になります。q(10)出力：

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

使用して、空のために"睡眠のため、そして!目を覚ましのために。

これは次のように機能します。

• A(i,b,e)「∀i∈[b、e）。」、B(b,e)「∀r∈[b、e）.∀c∈[b、e）」です。

• n世代後、ボードは2 n + 1平方になることに注意してください。

• ボードの対称性のため、これは右下の象限をシミュレートするだけでよいので、後の隣接ルックアップのために1行と1列のパディングでn + 1正方行列を割り当てます（したがってn + 2）。

• withを割り当てるとcalloc、幅と高さを同時に乗算し、ボードを0空にすることができます。

• 座標（CおよびD）でセルを検索する場合、行と列の絶対値（W）を使用して座標を自動的にミラーリングします。

• ボードは、現在および前の世代を表す整数のペアの配列として保存されます。問題の整数charは回避できるためsizeofです。

• （ネイバーテストによって）最も頻繁にルックアップされる世代は過去の世代であるため、ペアのインデックス0に配置されるため、でアクセスできます*。

• 各世代（g）で、Bループを使用して現在の世代が前の世代にコピーされ、古い世代から新しい世代が生成されます。

• 各セルは0、空、1目覚め、および2睡眠を使用して表されます。近隣をカウントすることは、もともと、スリープNに使用16して、4つの近隣がフラグ（）としてシフトおよび論理和されるときに、セルの下位4ビットに設定されたビット数の計算でした。しかし、奇数の隣人がちょうど1人の隣人に等しいという観察により、1のマスクを使用するだけでいくつかの文字を保存できます。

• 最後に、同じ絶対値座標のトリックを使用して右下の象限を反復処理することにより、ボードが完全に印刷されます。ボード上の外側のパディングは印刷されません。これはB、外側のループに余分な改行ステートメントがあるため、ループに開き中括弧が含まれる理由でもあります。

• ASCIIコードは0 + 32（空）をスペースに、2 + 32（スリーピング）を"、1 + 32（アウェイク）を便利にマップし!ます。

全体として、問題の構造が素晴らしいため、これは驚くほど読みやすいゴルフだと思います。

MATL、39バイト

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

これが表示されます

• Emptyas （スペース）
• Awake なので #
• Sleepingとして!。

オンラインでお試しください！また、ASCIIアートで、またはグラフィカルに（変更されたコード）パターンが成長するのを見ることができます。

説明

コードは複素数を使用して0、1、jそれぞれ寝て、空、ウェイク：3つの状態を表現するために。

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の値が大きくなると指数関数的に遅くなります。そのため、潜在的には約127（Befungeの7ビットメモリセルの制限）までのnで動作する可能性がありますが、実際には結果を待っている興味を失うことは避けられません。TIOでは、約6を超える（最高でも）60秒のタイムアウトに達します。コンパイラーの方がはるかに優れていますが、それでも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)]

オンラインでお試しください！

説明

0for empty、1for sleepingおよび2forを使用しawakeます。2次元の文字（長さ1の文字列）リストを出力します。
負でない整数を受け取る関数を定義しますn。セルオートマトンを目的の状態に達するまで連続的に進めます。最後に、内部整数値と実際の文字間の変換が適用されます。

Luaの、251の 242 239 238バイト

追加の先頭の空白を追加して、配列初期化子を単純化することにより、-8バイト
-1バイトに変更c=i==2+...and print(s)してc=i~=2+...or print(s)。
最初に完全な文字列を作成し、最後に1回印刷することにより、-3バイト。
-1バイト、Jonathan Frechにを書き直し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

オンラインでお試しください！

-4Adámに感謝します。
-8 ngnに感謝します。

ゼリー、39 29バイト

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

オンラインでお試しください！

使用し0、1そして2空の目覚めと睡眠のため。リンクのフッターは、これをに変換@し#ます。

• のṬŒḄ代わりに-1バイトを使用しますḤḶ=¹。
• -の-代わりにを使用して-2バイト1N。また、¤不要になります。
• のS代わりに-1バイトを使用します+/。
• のḂ+Ḃ+代わりにを使用して-6バイト%3=1+=1Ḥ$+。の2代わりにスリープに使用するようになりました3。

説明が来る...

APL（Dyalog Classic）、38バイト

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

オンラインでお試しください！

Erik the Outgolferのソリューションに基づく

⍪1 1を含む1x1行列です

⎕ 評価された入力

( )⍣⎕ 何回も適用する

• (⌽0,⍉)⍣40で囲む、つまり4回行う：転置（⍉）、左側に0を追加（0,）、水平方向に反転（⌽）

• g←3+/0,,∘0 水平トリプルを合計する関数、それを呼び出す g

• ⍉∘g∘⍉垂直トリプルを合計する関数- g転置中

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 2を法とする2つの合計の合計

• ⌈ との間の大きい...

• 2∘∧ 2のLCMと元の行列-これは1を2に変え、0と2を保持します

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を使用します。

ルビー、₁₆₄₁₅₃バイト

->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バイト、-lフラグの場合は+1 。

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

テイクnコマンドライン引数として。0空、1目覚め、2睡眠に使用します。（チャレンジの例のようにASCIIアートを良くするには、final 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

ループの後、単にautoprintし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

保存する

• ジョナサンSのおかげで29バイト節約
• ジョナサンSのおかげで、文字を他のものと交換し、「素数とモジュラー演算で魔法をかける」ことにより、さらに9バイト

Python、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)))

質問で指定されたものと同じ文字を使用して印刷します。