Người ta biết rằng một người trên lưới dưới ảnh hưởng của rượu có cơ hội đi ngang nhau theo bất kỳ hướng nào. Tuy nhiên, tuyên bố thông thường này không giữ được cảnh giới của những người say rượu rất nhỏ , hành vi của họ rất giống như họ đi mọi con đường có sẵn cùng một lúc, và những con đường có thể họ đi có thể can thiệp lẫn nhau. Nhiệm vụ của bạn là hiển thị các vị trí có thể có của một người say lượng tử như vậy sau ncác bước.

Đặc điểm kỹ thuật

Người say trong câu hỏi chiếm một ô vuông và có thể được coi là một máy tự động di động 3 trạng thái sử dụng vùng lân cận Von Neumann (hình cộng) theo các quy tắc đơn giản sau:

• Emptyđi đến Awakenếu nó liền kề với chính xác một Awake, và nếu không đi đếnEmpty
• Awake đi đến Sleeping
• Sleeping đi đến Sleeping

Trạng thái ban đầu của bảng là một Awaketrường được bao quanh bởi một trường vô hạn của Emptys.

Thử thách

Cho một số nguyên không âm n, tạo một đại diện ASCII của người say sau ncác bước. Mỗi trạng thái nên được đại diện bởi một nhân vật khác nhau và các giải pháp nên nêu rõ nhân vật đó có nghĩa là trạng thái nào. Nếu bạn sử dụng khoảng trắng cho Empty, bạn không cần bao gồm một chuỗi chúng ở cuối dòng.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng. Các lỗ hổng tiêu chuẩn được áp dụng, khoảng trắng hàng đầu và dấu được cho phép, cho phép chuỗi mảng / đầu ra mảng char 2d, v.v.

Ví dụ

Những ví dụ này sử dụng cho Empty, @cho Awakevà #cho Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

Lưu ý thú vị

Bằng cách tìm kiếm chuỗi số lượng tế bào bị chiếm đóng trong OEIS, tôi thấy rằng người say rượu lượng tử là đẳng cấu với trình tự tăm được nghiên cứu tốt hơn nhiều . Nếu bạn có thể kết hợp kiến ​​thức đó vào một sân golf tốt hơn, tôi sẽ rất ấn tượng.

Ngôn ngữ Wolfram (Mathicala) , 92 91 byte

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

Một thử thách hoàn hảo để sử dụng nội dung của Mathicala CellularAutomaton!

Hãy thử trực tuyến!

Trống = 0, Thức = 1, Ngủ = 2

Hoạt hình của 256 lần lặp đầu tiên (trắng = trống, xám = thức, đen = ngủ):

Giải trình

CellularAutomaton[ ... ]

Chạy CellularAutomatonvới thông số kỹ thuật ...

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

Áp dụng quy tắc tổng thể 3 màu 7049487784884, với vùng lân cận Von Neumann ...

{j={{1}},0}

Trên một bảng có 1 số duy nhất ở giữa, với nền là 0s ...

{j#}

Lặp lại <input>thời gian ( {j#}ước tính {{{#}}}). Mảng tự động mở rộng nếu một ô bên ngoài đường viền không giống với nền

7049487784884

Quy tắc này xuất phát từ số cơ sở 3 220221220221220221220221220, có nghĩa là "thay đổi tất cả 1hoặc 2thành 2và thay đổi 0thành 1nếu và chỉ khi có một số lẻ 1s xung quanh nó."

Print@@@

In mảng.

Bán bằng chứng "'lẻ 1s' tương đương với 'chính xác một 1'":

Hãy xem xét lưới 5x5 pixel này. Màu trắng là một 0hoặc một 2ô (các pixel không thức) và màu xám là một 1ô.

Nếu một 1ô được tạo xung quanh ba 0ô, thì lưới phải trông như thế này: nó có ba ô 1được sắp xếp theo hình chữ U (hoặc phiên bản xoay) như sau:

Do sự giống nhau của thiết bị tự động di động này, bất kỳ mẫu nào xuất hiện trong thiết bị tự động di động phải xuất hiện trên đường chéo (theo cảm ứng). Tuy nhiên, mẫu này không đối xứng theo đường chéo. tức là nó không thể xuất hiện trên đường chéo và không thể xuất hiện ở bất cứ đâu trên thiết bị tự động di động.

Thức / Ngủ là tương đương

Lưu ý rằng một 0ô không thể được bao quanh bởi chính xác một hoặc ba 2ô và các ô còn lại 0, vì điều đó có nghĩa là một số bước trước đó, ô có hàng xóm của một hoặc ba 1ô - và phải biến thành một 1(đã mâu thuẫn). Do đó, bạn có thể bỏ qua sự khác biệt giữa 1và 2trạng thái 'thay đổi tất cả 1thành 1, và 0thành một 1nếu và chỉ khi nó có số lượng hàng xóm khác không.'

Kết quả là thiết bị tự động di động thực sự giống hệt với bản gốc, điểm khác biệt duy nhất là không có sự phân biệt giữa người say rượu "thức" và "ngủ". Mẫu này được mô tả trong OEIS A169707 .

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

Hãy thử trực tuyến!

So sánh cạnh nhau của 16 lần lặp đầu tiên:

Thêm hai lần lặp liên tiếp sẽ cho kết quả tuân theo thông số kỹ thuật thử thách (94 byte):

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

Hãy thử trực tuyến!

Python 2 , 192 byte

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]

Hãy thử trực tuyến!

-17 byte nhờ vào ông Xcoder
-9 byte sử dụng định dạng đầu ra của Jonathan
-11 byte nhờ vào Lynn
-3 byte nhờ các lò nướng

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("");}}

Các dòng mới sau các #definedòng không phải chỉ để trình bày ở đây, vì vậy chúng không được tính. Tôi đã bao gồm một hàm bao bọc, vì vậy, −6 (313) nếu hàm này không được tính và bạn cho rằng nđến từ nơi khác. q(10)đầu ra:

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

Sử dụng cho trống, "để ngủ và !cho tỉnh táo.

Điều này hoạt động như vậy:

• A(i,b,e)là ∀i∈ [b, e) B(b,e).và , là ∀r∈ [b, e) .∀c∈ [b, e).

• Quan sát rằng sau n thế hệ, bảng là 2 n + 1 vuông.

• Do tính đối xứng của bảng, điều này chỉ cần mô phỏng góc phần tư phía dưới bên phải, vì vậy chúng tôi phân bổ một ma trận vuông n + 1 với 1 hàng & cột đệm cho tra cứu hàng xóm sau (vì vậy n + 2).

• Phân bổ calloccho phép chúng ta đồng thời nhân chiều rộng với chiều cao và xóa bảng thành 0(trống).

• Khi tra cứu một ô theo tọa độ của nó ( Cvà D), nó sử dụng giá trị tuyệt đối của hàng và cột ( W) để tự động phản chiếu tọa độ.

• Bảng được lưu trữ dưới dạng một loạt các cặp số nguyên đại diện cho các thế hệ hiện tại và trước đó. Các số nguyên trong câu hỏi là charvì vậy chúng ta có thể tránh sizeof.

• Thế hệ được tra cứu thường xuyên nhất (bởi thử nghiệm hàng xóm) là thế hệ trước, vì vậy nó được đặt ở chỉ số 0 trong cặp để có thể truy cập được *.

• Ở mỗi thế hệ ( g), thế hệ hiện tại được sao chép qua thế hệ trước bằng cách sử dụng Bvòng lặp, sau đó thế hệ mới được tạo từ thế hệ cũ.

• Mỗi ô được biểu diễn bằng cách sử dụng 0cho trống, 1để thức và 2ngủ. Đếm hàng xóm ban đầu là phép tính số bit được đặt trong 4 bit thấp của ô khi 4 hàng xóm được dịch chuyển & OR'd với nhau dưới dạng cờ ( N), sử dụng 16để ngủ. Nhưng với quan sát rằng một số lượng lân cận lẻ tương đương với chính xác 1 hàng xóm, chúng ta có thể lưu một vài ký tự chỉ bằng cách sử dụng mặt nạ với 1.

• Cuối cùng, bảng được in đầy đủ bằng cách lặp qua góc phần tư phía dưới bên phải bằng cách sử dụng thủ thuật tọa độ giá trị tuyệt đối tương tự, trừ phần đệm để chúng tôi không in phần đệm bên ngoài lên bảng. Đây cũng là lý do tại sao Bvòng lặp bao gồm một dấu ngoặc nhọn mở, bởi vì chúng ta có thêm câu lệnh mới trong vòng lặp bên ngoài.

• Các mã ASCII ánh xạ thuận tiện 0 + 32 (trống) vào một khoảng trắng, 2 + 32 (ngủ) "và 1 + 32 (thức) để !.

Tất cả trong tất cả tôi nghĩ rằng đây là một golf đáng ngạc nhiên có thể đọc được vì cấu trúc tốt đẹp của vấn đề.

MATL , 39 byte

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

Màn hình này

• Emptynhư (không gian)
• Awake như #
• Sleepingnhư !.

Hãy thử trực tuyến! Bạn cũng có thể xem mô hình phát triển trong nghệ thuật ASCII hoặc đồ họa (mã sửa đổi).

Giải trình

Mã này sử dụng số phức 0, 1, jđể đại diện cho ba trạng thái: trống, trỗi dậy, ngủ tương ứng.

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 byte

&: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*+^

Hãy thử trực tuyến!

Vấn đề với việc cố gắng thực hiện loại điều này trong Befunge là kích thước bộ nhớ hạn chế (2000 byte cho cả dữ liệu và mã). Vì vậy, tôi đã phải sử dụng một thuật toán tính toán ký tự chính xác cho bất kỳ tọa độ đã cho nào mà không cần tham khảo các tính toán trước đó. Nó đạt được điều này bằng cách đệ quy ngược thời gian trên tất cả các con đường có thể mà người say rượu có thể đã đi theo để đạt đến điểm đó.

Thật không may, đây không phải là một giải pháp hiệu quả cụ thể. Nó hoạt động, nhưng nó cực kỳ chậm, và nó trở nên chậm hơn theo cấp số nhân, giá trị của n càng lớn . Vì vậy, trong khi nó có khả năng có thể hoạt động cho bất kỳ n nào lên tới khoảng 127 (giới hạn ô nhớ 7 bit của Befunge), trong thực tế, bạn chắc chắn sẽ mất hứng thú chờ đợi kết quả. Trên TIO, nó sẽ đạt thời gian chờ 60 giây ở bất cứ thứ gì cao hơn khoảng 6 (tốt nhất). Trình biên dịch sẽ làm tốt hơn rất nhiều, nhưng thậm chí sau đó bạn có thể không muốn tăng cao hơn 10.

Tuy nhiên, tôi nghĩ rằng nó đáng để gửi bởi vì nó thực sự là một minh chứng khá hay về "chức năng" đệ quy trong Befunge.

Python 2 , 214 byte

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

Hãy thử trực tuyến!

Giải trình

Sử dụng 0cho empty, 1cho sleepingvà 2cho awake. In ra một danh sách ký tự hai chiều (chuỗi một chiều dài).
Xác định hàm lấy số nguyên không âm n. Liên tiếp tiến bộ tự động tế bào cho đến khi đạt được trạng thái mong muốn. Cuối cùng, một chuyển đổi giữa các giá trị số nguyên bên trong và các ký tự thực tế được áp dụng.

Lua , 251 242 239 238 byte

-8 byte bằng cách đơn giản hóa trình khởi tạo mảng với chi phí của một số khoảng trắng hàng đầu bổ sung.
-1 byte bằng cách thay đổi c=i==2+...and print(s)thành c=i~=2+...or print(s).
-3 byte bằng cách xây dựng một chuỗi hoàn chỉnh trước và in một lần ở cuối.
-1 byte nhờ Jonathan Frech bằng cách viết lại or(g(...)==1 andthành 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)

Hãy thử trực tuyến!

Trống = Không gian
tỉnh táo = 1
Ngủ =0

Đưa đầu vào từ dòng lệnh và in ra thiết bị xuất chuẩn.

Bằng cách đại diện cho tiểu bang như false/ nil, 1và 0nội bộ, phát hiện "trống rỗng" không cần bất kỳ mã và "chính xác một thức" kiểm tra có thể được thực hiện chỉ với một sự bổ sung.

APL (Dyalog) , 38 byte

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

Hãy thử trực tuyến!

-4 cảm ơn Adám .
-8 cảm ơn ngn .

Thạch , 39 29 byte

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

Hãy thử trực tuyến!

Sử dụng 0, 1và 2cho trống rỗng thức và ngủ. Chân trang trong liên kết chuyển đổi này thành , @và #.

• -1 byte bằng cách sử dụng ṬŒḄthay vì ḤḶ=¹.
• -2 byte bằng cách sử dụng -thay vì 1N. Cũng làm cho ¤không cần thiết.
• -1 byte bằng cách sử dụng Sthay vì +/.
• -6 byte bằng cách sử dụng Ḃ+Ḃ+thay vì %3=1+=1Ḥ$+. Bây giờ sử dụng 2để ngủ thay vì 3.

Giải thích sắp tới ...

APL (Dyalog Classic) , 38 byte

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

Hãy thử trực tuyến!

dựa trên giải pháp của Erik the Outgolfer

⍪1 là ma trận 1x1 chứa 1

⎕ đầu vào đánh giá

( )⍣⎕ áp dụng nhiều lần

• (⌽0,⍉)⍣4bao quanh với 0s, tức là 4 lần: transpose ( ⍉), thêm 0s ở bên trái ( 0,), đảo ngược theo chiều ngang ( ⌽)

• g←3+/0,,∘0 một hàm tính tổng ba lần ngang, gọi nó g

• ⍉∘g∘⍉một hàm tính tổng ba lần theo chiều dọc - đó là gdưới sự hoán vị

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 tổng của hai khoản tiền modulo 2

• ⌈ càng lớn giữa điều đó và ...

• 2∘∧ LCM của 2 và ma trận gốc - điều này biến 1s thành 2 giây, trong khi bảo toàn 0 và 2 giây

Perl 5 , 192 + 1 ( -n) = 193 byte

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

Hãy thử trực tuyến!

Sử dụng 0 cho trống, 1 cho tỉnh táo và 2 cho ngủ.

Ruby , ₁₆₄ 153 byte

->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*""}

Hãy thử trực tuyến!

Sử dụng "" cho sản phẩm nào, "@" cho Tỉnh táo và "#" cho Ngủ (như trong ví dụ). Tôi có thể tiết kiệm 6 byte bằng cách sử dụng các số thay vào đó, tôi cho rằng, nhưng nó trông tốt hơn như thế này.

Pip , 69 61 byte

60 byte mã, +1 cho -lcờ.

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

Đưa ra nnhư một đối số dòng lệnh. Sử dụng 0cho trống rỗng, 1cho thức và 2ngủ. (Để có được nghệ thuật ASCII đẹp hơn như trong các ví dụ của thử thách, hãy thay thế trận chung kết ybằng " @#"@y.)

Hãy thử trực tuyến!

Giải trình

Thiết lập:

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

Vòng lặp chính:

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

cơ quan chức năng là:

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

Sau vòng lặp, chúng tôi chỉ đơn giản là tự động in y. Các -llá cờ có nghĩa là danh sách lồng nhau được in bằng cách ghép các nội dung của mỗi hàng và tách các hàng với dòng mới.

Java (OpenJDK 8) , 220 byte

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

Hãy thử trực tuyến!

Lưu ý: mảng trả về chứa đường viền hoặc '\0'ký tự. Vì máy bay được coi là vô hạn, nên chỉ sử dụng phi biên giới.

Ánh xạ nhân vật:

• Trống: (dấu cách)
• Thức giấc: =
• Ngủ: 0

Tiết kiệm

• 29 byte được lưu nhờ Jonathan S.
• 9 byte nữa nhờ Jonathan S. bằng cách hoán đổi các ký tự với người khác và "làm phép thuật với số nguyên tố và số học mô-đun"

Python, 199 192 byte

Mã này chạy trên cả Python 2 và Python 3, nhưng nó sử dụng thư viện Numpy của bên thứ 3 phổ biến để xử lý mảng.

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

Trống = 0
Thức = 1
Ngủ = 2

print(f(6)) đầu ra

[[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ếu bạn muốn in đẹp hơn, bạn có thể gọi nó theo cách này:

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

mà in bằng cách sử dụng các ký tự giống như được đưa ra trong câu hỏi.