เป็นที่ทราบกันดีว่าคนบนกริดภายใต้อิทธิพลของแอลกอฮอล์มีโอกาสเท่าเทียมกันในการไปในทิศทางใด ๆ อย่างไรก็ตามคำสั่งทั่วไปความรู้สึกนี้ไม่ได้ถืออยู่ในดินแดนของขนาดเล็กมากขี้เมาที่มีพฤติกรรมเป็นอย่างมากเช่นถ้าพวกเขาใช้เวลาทุกเส้นทางใช้ได้ในครั้งเดียวและเส้นทางที่เป็นไปได้ที่พวกเขาใช้อาจรบกวนกับแต่ละอื่น ๆ งานของคุณคือการแสดงตำแหน่งที่เป็นไปได้ของควอนตัมขี้เมาหลังจากnขั้นตอน

สเปค

คำถามที่ขี้เมาตรงบริเวณตารางสี่เหลี่ยมและอาจได้รับการพิจารณาว่าเป็นหุ่นยนต์เซลลูล่าร์ 3 รัฐโดยใช้ย่าน Von Neumann (บวกรูป) ซึ่งเป็นไปตามกฎง่าย ๆ เหล่านี้:

• Emptyไปที่Awakeถ้าอยู่ติดกับที่หนึ่งAwakeและไปที่อื่นEmpty
• Awake ไปที่ Sleeping
• Sleeping ไปที่ Sleeping

สถานะเริ่มต้นของคณะกรรมการเป็นหนึ่งเดียวAwakeล้อมรอบด้วยสนามไม่มีที่สิ้นสุดของEmptys

ท้าทาย

รับจำนวนเต็มที่ไม่ติดลบnสร้าง ASCII ที่เป็นตัวแทนของคนขี้เมาหลังจากnทำตามขั้นตอน แต่ละรัฐควรแสดงด้วยอักขระที่แตกต่างกันและวิธีแก้ปัญหาควรระบุว่าอักขระหมายถึงสถานะใด หากคุณใช้ช่องว่างEmptyคุณไม่จำเป็นต้องรวมช่องว่างไว้ท้ายบรรทัด

นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดจึงชนะ ใช้ช่องว่างมาตรฐานนำช่องว่างนำหน้าและต่อท้ายอนุญาตให้ใช้อาร์เรย์ของสตริง / เอาท์พุทอาเรย์ของถ่าน 2d เป็นต้น

ตัวอย่าง

ตัวอย่างเหล่านี้ใช้สำหรับEmpty, @สำหรับAwake, และสำหรับ#Sleeping

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

หมายเหตุที่น่าสนใจ

โดยดูได้ลำดับของจำนวนของเซลล์ครอบครองใน OEIS ผมพบว่าคนขี้เมาควอนตัมคือ isomorphic ไปมากดีกว่าการศึกษาลำดับไม้จิ้มฟัน หากคุณสามารถรวมความรู้นั้นไว้ในกอล์ฟที่ดีกว่าฉันจะต้องประทับใจอย่างเหมาะสม

ภาษา Wolfram (Mathematica) , 92 91 ไบต์

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

ความท้าทายที่สมบูรณ์แบบในการใช้งานของ Mathematica CellularAutomaton!

ลองออนไลน์!

Empty = 0, Awake = 1, Sleeping = 2

แอนิเมชันของการวนซ้ำ 256 ครั้งแรก (white = empty, grey = awake, black = sleep):

คำอธิบาย

CellularAutomaton[ ... ]

ทำงานCellularAutomatonด้วยข้อกำหนด ...

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

ใช้กฎการรวมสี 3 สี 7049487784884 กับย่าน Von Neumann ...

{j={{1}},0}

บนกระดานที่มีซิงเกิล 1 ตรงกลางที่มีพื้นหลังเป็น 0s ...

{j#}

ทำซ้ำ<input>ครั้ง ( {j#}ประเมินเป็น{{{#}}}) อาร์เรย์จะขยายโดยอัตโนมัติหากเซลล์ที่อยู่นอกเส้นขอบไม่เหมือนกับพื้นหลัง

7049487784884

กฎนี้มาจากเลขฐาน -3 220221220221220221220221220ซึ่งหมายความว่า "เปลี่ยนทั้งหมด1หรือ2เป็น2และเปลี่ยน0เป็น1ถ้าหากมีจำนวนคี่1ล้อมรอบ"

Print@@@

พิมพ์อาร์เรย์

Semi-proof ของ "'คี่1s' เทียบเท่ากับ 'one one 1'":

พิจารณาพิกเซลกริด 5x5 นี้ สีขาวเป็นเซลล์0หรือ2(ไม่ใช่พิกเซลที่ตื่นตัว) และสีเทาคือ1เซลล์

หาก1เซลล์ถูกสร้างขึ้นประมาณสาม0เซลล์ตารางจะต้องมีลักษณะดังนี้: มันมีสาม1s จัดเรียงในรูปตัวยู (หรือรุ่นที่หมุน) ดังต่อไปนี้:

เนื่องจากความคล้ายคลึงตนเองของหุ่นยนต์เซลลูลาร์นี้รูปแบบใด ๆ ที่ปรากฏในหุ่นยนต์เซลลูล่าร์จะต้องปรากฏบนเส้นทแยงมุม (โดยการเหนี่ยวนำ) อย่างไรก็ตามรูปแบบนี้ไม่ได้เป็นแนวทแยงมุมสมมาตร นั่นคือมันไม่สามารถเกิดขึ้นได้ในแนวทแยงมุมและไม่สามารถปรากฏที่ใดก็ได้บนหุ่นยนต์อัตโนมัติ

การตื่น / นอนนั้นเทียบเท่ากัน

โปรดทราบว่า0เซลล์ไม่สามารถล้อมรอบด้วย2เซลล์หนึ่งหรือสามเซลล์อย่างแน่นอนและเซลล์ที่เหลือ0เนื่องจากนั่นจะบอกเป็นนัย ๆ ว่าบางขั้นตอนก่อนหน้าเซลล์มีเพื่อนบ้านหนึ่งหรือสาม1เซลล์ - และต้องกลายเป็นเซลล์ที่1ขัดแย้งกันแล้ว ดังนั้นจึงไม่เป็นไรที่จะเพิกเฉยต่อความแตกต่างระหว่าง1และ2กับ 'การเปลี่ยนแปลงทั้งหมด1เป็น1และ0a 1หากa และถ้าหากมีจำนวนเพื่อนบ้านที่ไม่ใช่ศูนย์เท่านั้น

หุ่นยนต์เซลลูล่าร์ที่ได้รับนั้นเหมือนกันกับของแท้ดั้งเดิมสิ่งที่แตกต่างกันเพียงอย่างเดียวคือไม่มีความแตกต่างระหว่างคนที่ "ตื่น" และ "หลับ" รูปแบบนี้จะอธิบายใน 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 ไบต์ขอบคุณ Mr. Xcoder
-9 ไบต์โดยใช้รูปแบบเอาต์พุตของ Jonathan
-11 ไบต์ขอบคุณ Lynn
-3 ไบต์ขอบคุณ ovs

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บรรทัดเป็นเพียงการนำเสนอที่นี่ดังนั้นจึงไม่ถูกนับ ฉันรวมฟังก์ชั่น wrapper ดังนั้นมันคือ −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 บิตเมื่อ 4 เพื่อนบ้านถูกเลื่อน & OR จะรวมกันเป็นธง ( N) โดยใช้16สำหรับการนอนหลับ แต่ด้วยการสังเกตว่าเพื่อนบ้านจำนวนคี่เทียบเท่ากับ 1 เพื่อนบ้านอย่างแน่นอนเราสามารถบันทึกอักขระได้หลายตัวโดยใช้มาสก์ที่มี 1

• ในตอนท้ายบอร์ดจะพิมพ์เต็มโดยวนซ้ำทางด้านขวาล่างโดยใช้เคล็ดลับการประสานค่าค่าสัมบูรณ์เดียวกันลบด้วยการแพ็ดดิ้งดังนั้นเราจึงไม่พิมพ์การเติมด้านนอกบนกระดาน นี่คือสาเหตุที่Bลูปมีวงเล็บปีกกาเปิดเนื่องจากเรามีคำสั่ง newline เพิ่มเติมในลูปด้านนอก

• รหัส ASCII ในทำเลที่สะดวก map 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เลื่อนตำแหน่งหุ่นยนต์อัตโนมัติอย่างต่อเนื่องจนกว่าจะถึงสถานะที่ต้องการ ในที่สุดการแปลงระหว่างค่าจำนวนเต็มภายในและอักขระจริงจะถูกนำไปใช้

Lua , 251 242 239 238 ไบต์

-8 ไบต์โดยทำให้อาเรย์ของ initializer ง่ายขึ้นด้วยค่าใช้จ่ายของ whitespace นำหน้าเพิ่มเติม
ไบต์ -1 โดยการเปลี่ยนเข้าสู่c=i==2+...and print(s) -3 ไบต์โดยการสร้างสตริงที่สมบูรณ์ก่อนและพิมพ์ครั้งเดียวในตอนท้าย -1 ไบต์ขอบคุณที่โจนาธาน Frechโดยการเขียนใหม่เป็นc=i~=2+...or print(s)

or(g(...)==1 andor(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)

ลองออนไลน์!

ว่างเปล่า = Space
Awake = 1
Sleeping =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Ḥ$+ตอนนี้ใช้สำหรับการนอนหลับแทน23

คำอธิบายมา ...

APL (Dyalog Classic) , 38 ไบต์

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

ลองออนไลน์!

อ้างอิงจากวิธีแก้ปัญหาของ Erik the Outgolfer

⍪1 คือเมทริกซ์ 1x1 ที่มี 1

⎕ อินพุต eval'ed

( )⍣⎕ ใช้ได้หลายครั้ง

• (⌽0,⍉)⍣4ล้อมรอบด้วย 0s นั่นคือ 4 ครั้งทำ: transpose ( ⍉), เพิ่ม 0s ที่ด้านซ้าย ( 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*""}

ลองออนไลน์!

ใช้ "" for Empty, "@" for Awake และ "#" สำหรับ Sleeping (ดังตัวอย่าง) ฉันสามารถบันทึกได้ 6 ไบต์โดยใช้ตัวเลขแทนฉันคิดว่า แต่มันดูดีกว่านี้

Pip , 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นอนหลับ (ในการรับ nicer ASCII-art ดังในตัวอย่างของความท้าทายให้แทนที่ขั้นสุดท้าย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 ไบต์ขอบคุณ Jonathan 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

Empty = 0
Awake = 1
Sleeping = 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)))

ซึ่งพิมพ์โดยใช้อักขระเดียวกับที่ระบุในคำถาม