Diketahui bahwa seseorang yang berada di grid di bawah pengaruh alkohol memiliki peluang yang sama untuk pergi ke arah yang tersedia. Namun, pernyataan yang masuk akal ini tidak berlaku di ranah pemabuk yang sangat kecil , yang perilakunya sangat banyak seolah-olah mereka mengambil setiap jalur yang tersedia sekaligus, dan kemungkinan jalur yang mereka ambil dapat saling mengganggu. Tugas Anda adalah menampilkan posisi yang memungkinkan pemabuk kuantum setelah nlangkah-langkah tersebut.

Spesifikasi

Pemabuk yang bersangkutan menempati kotak persegi, dan dapat dianggap sebagai otomat seluler 3-negara menggunakan lingkungan Von Neumann (berbentuk-tambah) yang mengikuti aturan sederhana ini:

• Emptypergi ke Awakejika berdekatan dengan tepat satu Awake, dan sebaliknya pergi keEmpty
• Awake pergi ke Sleeping
• Sleeping pergi ke Sleeping

Keadaan awal papan adalah satu Awakedikelilingi oleh bidang tak terbatas Emptys.

Tantangan

Dengan bilangan bulat negatif n, buat representasi ASCII dari pemabuk setelah nlangkah-langkah. Setiap negara harus diwakili oleh karakter yang berbeda, dan solusi harus menyatakan karakter mana yang berarti negara mana. Jika Anda menggunakan spasi untuk Empty, Anda tidak perlu menyertakan runnya di akhir baris.

Ini kode-golf , jadi jawaban tersingkat menang. Celah standar berlaku, spasi spasi jejak terdepan dan jejak diizinkan, output array string / 2d char diizinkan, dll.

Contohnya

Contoh-contoh ini digunakan untuk Empty, @untuk Awake, dan #untuk Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

Catatan Menarik

Dengan mencari urutan jumlah sel yang ditempati di OEIS, saya menemukan bahwa pemabuk kuantum adalah isomorfik dengan urutan tusuk gigi yang jauh lebih banyak dipelajari . Jika Anda bisa memasukkan pengetahuan itu ke dalam golf yang lebih baik, saya akan terkesan.

Bahasa Wolfram (Mathematica) , 92 91 byte

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

Tantangan sempurna untuk menggunakan bawaan Matematika CellularAutomaton!

Cobalah online!

Kosong = 0, Sedar = 1, Tidur = 2

Animasi 256 iterasi pertama (putih = kosong, abu-abu = bangun, hitam = tidur):

Penjelasan

CellularAutomaton[ ... ]

Jalankan CellularAutomatondengan spesifikasi ...

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

Terapkan aturan totalistik 3 warna 7049487784884, dengan lingkungan Von Neumann ...

{j={{1}},0}

Di papan tulis dengan 1 tunggal di tengah, dengan latar belakang 0s ...

{j#}

Ulangi <input>kali ( {j#}dievaluasi ke {{{#}}}). Array secara otomatis mengembang jika sel di luar perbatasan tidak sama dengan latar belakang

7049487784884

Aturan ini berasal dari angka dasar-3 220221220221220221220221220, yang berarti "ubah semua 1atau 2menjadi 2, dan ubah 0menjadi 1jika dan hanya jika ada angka ganjil 1s di sekitarnya."

Print@@@

Cetak array.

Semi-bukti "aneh 1s 'setara dengan' tepat satu 1'":

Pertimbangkan kisi piksel 5x5 ini. Putih adalah sel 0atau 2(piksel non-bangun), dan abu-abu adalah 1sel.

Jika sebuah 1sel dihasilkan sekitar tiga 0sel, maka kisi-kisi harus terlihat seperti ini: ia memiliki tiga 1s yang disusun dalam bentuk-U (atau versi yang dirotasi) sebagai berikut:

Karena kemiripan otomatis dari otomat seluler ini, pola apa pun yang muncul dalam otomat seluler harus muncul pada diagonal (melalui induksi). Namun, pola ini tidak simetris secara diagonal. yaitu tidak dapat terjadi pada diagonal dan tidak dapat muncul di mana saja pada otomat seluler.

Sedar / Tidur adalah setara

Perhatikan bahwa 0sel tidak dapat dikelilingi oleh tepat satu atau tiga 2sel dan sel istirahat 0, karena itu akan menyiratkan bahwa beberapa langkah sebelumnya, sel memiliki tetangga satu atau tiga 1sel - dan harus telah berubah menjadi 1sudah (kontradiksi). Oleh karena itu, boleh saja mengabaikan perbedaan antara 1dan 2dan menyatakan 'ubah semua 1menjadi 1, dan 0menjadi 1jika dan hanya jika negara itu memiliki jumlah ganjil dari tetangga yang bukan nol.'

Otomat seluler yang dihasilkan memang identik dengan aslinya, satu-satunya perbedaan adalah tidak ada perbedaan antara pemabuk "terjaga" dan "tertidur". Pola ini dijelaskan dalam OEIS A169707 .

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

Cobalah online!

Perbandingan berdampingan dari 16 iterasi pertama:

Menambahkan dua iterasi berurutan memberikan hasil yang mengikuti spesifikasi tantangan (94 byte):

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

Cobalah online!

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]

Cobalah online!

-17 byte terima kasih kepada Tn. Xcoder
-9 byte menggunakan format output Jonathan
-11 byte terima kasih kepada Lynn
-3 byte terima kasih kepada 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("");}}

Baris baru setelah non- #definebaris hanya untuk presentasi di sini, sehingga tidak dihitung. Saya menyertakan fungsi wrapper, jadi −6 (313) jika fungsi tersebut tidak dihitung dan Anda menganggap nberasal dari tempat lain. q(10)output:

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

Gunakan untuk kosong, "untuk tidur, dan !untuk bangun.

Ini berfungsi seperti ini:

• A(i,b,e)adalah "∀i∈ [b, e).", B(b,e)adalah "∀r∈ [b, e) .∀c∈ [b, e)."

• Perhatikan bahwa setelah n generasi, papan adalah 2 n + 1 persegi.

• Karena simetri papan, ini hanya perlu mensimulasikan kuadran kanan bawah, jadi kami mengalokasikan n + 1 matriks persegi dengan 1 baris & kolom padding untuk pencarian tetangga nanti (jadi n + 2).

• Mengalokasikan dengan callocmemungkinkan kita secara bersamaan mengalikan lebar dengan ketinggian dan menghapus papan untuk 0(kosong).

• Saat mencari sel dengan koordinatnya ( Cdan D), ia menggunakan nilai absolut dari baris dan kolom ( W) untuk secara otomatis mencerminkan koordinat.

• Papan disimpan sebagai array pasang bilangan bulat yang mewakili generasi saat ini dan sebelumnya. Bilangan bulat yang dimaksud adalah charagar kita dapat menghindari sizeof.

• Generasi yang paling sering dicari (dengan tes tetangga) adalah generasi yang lalu, sehingga ditempatkan pada indeks 0 pada pasangan sehingga dapat diakses dengan *.

• Pada setiap generasi ( g), generasi saat ini disalin dari generasi sebelumnya menggunakan Bloop, kemudian generasi baru dihasilkan dari yang lama.

• Setiap sel direpresentasikan menggunakan 0untuk kosong, 1untuk bangun, dan 2untuk tidur. Menghitung tetangga awalnya perhitungan jumlah bit yang ditetapkan dalam 4 bit sel yang rendah ketika 4 tetangga digeser & ATAU bersama-sama sebagai flag ( N), gunakan 16untuk tidur. Tetapi dengan pengamatan bahwa jumlah ganjil tetangga setara dengan tepat 1 tetangga, kita dapat menyimpan beberapa karakter hanya menggunakan topeng dengan 1.

• Pada akhirnya, papan dicetak penuh dengan mengulangi kuadran kanan bawah menggunakan trik koordinat nilai absolut yang sama, dikurangi bantalan sehingga kami tidak mencetak lapisan luar pada papan. Ini juga mengapa Bloop menyertakan braket keriting pembuka, karena kami memiliki pernyataan baris baru ekstra di loop luar.

• Kode ASCII dengan mudah memetakan 0 + 32 (kosong) ke spasi, 2 + 32 (tidur) ke ", dan 1 + 32 (bangun) ke !.

Secara keseluruhan saya pikir ini adalah golf yang bisa dibaca karena struktur masalah yang bagus.

MATL , 39 byte

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

Ini menampilkan

• Emptysebagai (ruang)
• Awake sebagai #
• Sleepingsebagai !.

Cobalah online! Anda juga dapat melihat pola tumbuh dalam seni ASCII, atau secara grafis (kode yang dimodifikasi).

Penjelasan

Kode menggunakan bilangan kompleks 0, 1, juntuk mewakili tiga negara: kosong, bangun, tidur masing-masing.

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

Cobalah online!

Masalah dengan mencoba mengimplementasikan hal semacam ini di Befunge adalah ukuran memori yang terbatas (2000 byte untuk data dan kode). Jadi saya harus menggunakan algoritma yang menghitung karakter yang benar untuk setiap koordinat yang diberikan tanpa referensi ke perhitungan sebelumnya. Mencapai ini dengan secara rekursif melihat ke masa lalu di semua jalur yang mungkin pemabuk mungkin ikuti untuk mencapai titik itu.

Sayangnya ini bukan solusi efisien tertentu. Ini bekerja, tetapi ini sangat lambat, dan itu menjadi lambat secara eksponensial semakin besar nilai n . Jadi sementara itu berpotensi dapat bekerja untuk n hingga sekitar 127 (batas sel memori 7-bit Befunge), dalam praktiknya Anda pasti akan kehilangan minat menunggu hasilnya. Pada TIO, itu akan mencapai batas waktu 60 detik pada sesuatu yang lebih tinggi dari sekitar 6 (paling-paling). Kompiler akan melakukan jauh lebih baik, tetapi bahkan Anda mungkin tidak ingin pergi jauh lebih tinggi dari 10.

Namun, saya pikir itu layak diajukan karena itu sebenarnya demonstrasi yang cukup bagus dari "fungsi" rekursif di 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)]

Cobalah online!

Penjelasan

Penggunaan 0untuk empty, 1untuk sleepingdan 2untuk awake. Mencetak daftar karakter dua dimensi (string satu-panjang).
Menentukan fungsi yang mengambil bilangan bulat non-negatif n. Berhasil memajukan automaton seluler sampai keadaan yang diinginkan tercapai. Akhirnya, konversi antara nilai integer internal dan karakter aktual diterapkan.

Lua , 251 242 239 238 byte

-8 byte dengan menyederhanakan inisialisasi array dengan mengorbankan beberapa spasi tambahan terkemuka.
-1 byte dengan mengubah c=i==2+...and print(s)menjadi c=i~=2+...or print(s).
-3 byte dengan membangun string lengkap terlebih dahulu dan mencetak sekali di akhir.
-1 byte terima kasih kepada Jonathan Frech dengan menulis ulang or(g(...)==1 andsebagai 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)

Cobalah online!

Kosong = Spasi
Terjaga = 1
Tidur =0

Mengambil input dari baris perintah dan mencetak ke stdout.

Dengan menyatakan status sebagai false/ nil, 1dan secara 0internal, mendeteksi "kosong" tidak memerlukan kode apa pun dan pemeriksaan "tepat sekali bangun" dapat dilakukan hanya dengan tambahan.

APL (Dyalog) , 38 byte

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

Cobalah online!

-4 Terima kasih kepada Adám .
-8 Terima kasih kepada ngn .

Jelly , 39 29 byte

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

Cobalah online!

Penggunaan 0, 1dan 2untuk bangun dan tidur kosong. Footer di tautan mengonversi ini menjadi , @dan #.

• -1 byte dengan menggunakan ṬŒḄbukan ḤḶ=¹.
• -2 byte dengan menggunakan -bukan 1N. Juga membuat ¤tidak perlu.
• -1 byte dengan menggunakan Sbukan +/.
• -6 byte dengan menggunakan Ḃ+Ḃ+bukan %3=1+=1Ḥ$+. Sekarang digunakan 2untuk tidur, bukan 3.

Penjelasan datang ...

APL (Dyalog Classic) , 38 byte

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

Cobalah online!

berdasarkan solusi Erik the Outgolfer

⍪1 adalah matriks 1x1 yang berisi 1

⎕ masukan yang telah dievaluasi

( )⍣⎕ terapkan itu berkali-kali

• (⌽0,⍉)⍣4mengelilingi dengan 0s, yaitu 4 kali lakukan: transpose ( ⍉), tambahkan 0s di sebelah kiri ( 0,), mundur secara horizontal ( ⌽)

• g←3+/0,,∘0 sebuah fungsi yang menjumlahkan tiga kali lipat horisontal, sebut saja g

• ⍉∘g∘⍉sebuah fungsi yang menjumlahkan tiga kali lipat vertikal - yang gberada di bawah transposisi

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 jumlah dari kedua jumlah modulo 2

• ⌈ semakin besar antara itu dan ...

• 2∘∧ LCM dari 2 dan matriks asli - ini mengubah 1s menjadi 2s, sambil mempertahankan 0s dan 2s

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

Cobalah online!

Menggunakan 0 untuk kosong, 1 untuk bangun, dan 2 untuk tidur.

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

Cobalah online!

Gunakan "" untuk Kosong, "@" untuk Sedarlah, dan "#" untuk Tidur (seperti dalam contoh). Saya bisa menghemat 6 byte dengan menggunakan angka saja, saya kira, tetapi terlihat lebih baik seperti ini.

Pip , 69 61 byte

60 byte kode, +1 untuk -lbendera.

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

Dibawa nsebagai argumen baris perintah. Penggunaan 0untuk kosong, 1untuk bangun, dan 2untuk tidur. (Untuk mendapatkan seni ASCII yang lebih bagus seperti pada contoh tantangan, ganti final ydengan" @#"@y .)

Cobalah online!

Penjelasan

Mempersiapkan:

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

Loop utama:

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

di mana fungsi tubuh adalah:

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

Setelah loop, kami cukup cetak otomatis y. The -lbendera berarti bahwa daftar bersarang dicetak dengan menggabungkan isi dari setiap baris dan memisahkan baris dengan baris baru.

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

Cobalah online!

Catatan: array yang dikembalikan berisi perbatasan atau '\0' karakter. Karena pesawat seharusnya tak terbatas, hanya non-perbatasan yang digunakan.

Pemetaan karakter:

• Kosong: (spasi)
• Bangun: =
• Tidur: 0

Menghemat

• 29 byte disimpan berkat Jonathan S.
• 9 byte lebih lanjut berkat Jonathan S. dengan bertukar karakter dengan orang lain dan "melakukan sihir dengan bilangan prima dan aritmatika modular"

Python, 199 192 byte

Kode ini berjalan di kedua Python 2 dan Python 3, tetapi menggunakan perpustakaan Numpy pihak ke-3 yang populer untuk melakukan penanganan array.

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

Kosong = 0
Sedar = 1
Tidur = 2

print(f(6)) output

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

Jika Anda ingin mencetak lebih cantik, Anda dapat menyebutnya dengan cara ini:

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

yang dicetak menggunakan karakter yang sama seperti yang diberikan dalam pertanyaan.