Powszechnie wiadomo, że osoba na siatce pod wpływem alkoholu ma równe szanse pójścia we wszystkich dostępnych kierunkach. Jednak to rozsądne stwierdzenie nie dotyczy królestwa bardzo małych pijaków, których zachowanie jest tak, jakby podejmowali oni każdą dostępną ścieżkę naraz, a możliwe ścieżki, które podążają, mogą kolidować ze sobą. Twoim zadaniem jest wyświetlenie możliwych pozycji takiego kwantowego pijaka po wykonaniu nkroków.

Specyfikacja

Wspomniany pijak zajmuje kwadratową siatkę i może być uważany za 3-stanowy automat komórkowy wykorzystujący sąsiedztwo von Neumanna (w kształcie plus), które przestrzega tych prostych zasad:

• Emptyidzie do, Awakejeśli przylega do dokładnie jednego Awake, a w przeciwnym razie idzie doEmpty
• Awake idzie do Sleeping
• Sleeping idzie do Sleeping

Początkowy stan planszy to pojedynczy Awakeotoczony nieskończonym polem Emptys.

Wyzwanie

Biorąc pod uwagę nieujemną liczbę całkowitą n, po nkroku utwórz reprezentację ASCII pijaka . Każdy stan powinien być reprezentowany przez inny charakter, a rozwiązania powinny określać, który znak oznacza, który stan. Jeśli używasz spacji do Empty, nie musisz dołączać ich na końcu linii.

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź. Obowiązują standardowe luki , dozwolone są początkowe i końcowe spacje, dozwolone są dane wyjściowe z tablicy znaków / tablicy znaków 2d itp.

Przykłady

Te przykłady używają dla Empty, @dla Awakei #dla Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

Ciekawa uwaga

Analizując sekwencję liczby zajętych komórek w OEIS, odkryłem, że pijak kwantowy jest izomorficzny w stosunku do znacznie lepiej zbadanej sekwencji wykałaczek . Jeśli potrafisz włączyć tę wiedzę do lepszego golfa, będę pod wrażeniem.

Wolfram Language (Mathematica) , 92 91 bajtów

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

Idealne wyzwanie do korzystania z wbudowanego Mathematica CellularAutomaton!

Wypróbuj online!

Pusty = 0, Przebudź = 1, Spanie = 2

Animacja pierwszych 256 iteracji (biały = pusty, szary = przebudzony, czarny = spanie):

Wyjaśnienie

CellularAutomaton[ ... ]

Uruchom CellularAutomatonze specyfikacjami ...

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

Zastosuj 3-kolorową regułę totalistyczną 7049487784884 z sąsiedztwem von Neumanna ...

{j={{1}},0}

Na planszy z pojedynczym 1 na środku, z tłem 0 ...

{j#}

Powtórz <input>czasy ( {j#}ocenia na {{{#}}}). Macierz automatycznie się rozwija, jeśli komórka poza ramką nie jest taka sama jak tło

7049487784884

Ta reguła pochodzi od liczby podstawowej 3 220221220221220221220221220, co oznacza „zmień wszystko 1lub 2na 2i zmień 0na 1i tylko wtedy, gdy 1wokół niej jest nieparzysta liczba s”.

Print@@@

Wydrukuj tablicę.

Pół-dowód „nieparzystych 1” jest równoważny z „dokładnie jednym 1”:

Rozważ tę siatkę pikseli 5x5. Biały to komórka 0lub 2(nie obudzone piksele), a szary to 1komórka.

Jeśli 1komórka została wygenerowana wokół trzech 0komórek, siatka musi wyglądać następująco: ma trzy 1s ułożone w kształcie litery U (lub wersji obróconej) w następujący sposób:

Ze względu na samopodobieństwo tego automatu komórkowego, każdy wzór pojawiający się w automacie komórkowym musi pojawić się na przekątnej (przez indukcję). Jednak ten wzór nie jest ukośnie symetryczny. tzn. nie może wystąpić na przekątnej i nie może pojawić się nigdzie w automacie komórkowym.

Przebudzenie / spanie są równoważne

Zauważ, że 0komórka nie może być otoczona dokładnie jedną lub trzema 2komórkami i komórkami spoczynkowymi 0, ponieważ oznaczałoby to, że kilka kroków wcześniej komórka miała sąsiada z jedną lub trzema 1komórkami - i musiała zmienić się w 1już (sprzeczność). W związku z tym, że jest w porządku, aby ignorować różnicy między 1i 2a stan "zmienić wszystko 1, aby 1i 0do 1wtedy i tylko wtedy, gdy ma nieparzystą liczbę niezerowych sąsiadów.

Powstały automat komórkowy jest rzeczywiście identyczny z oryginałem, jedyną różnicą jest to, że nie ma rozróżnienia między „przebudzonymi” i „uśpionymi” pijakami. Ten wzór jest opisany w OEIS A169707 .

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

Wypróbuj online!

Bezpośrednie porównanie pierwszych 16 iteracji:

Dodanie dwóch kolejnych iteracji daje wynik zgodny ze specyfikacją wyzwania (94 bajty):

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

Wypróbuj online!

Python 2 , 192 bajty

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]

Wypróbuj online!

-17 bajtów dzięki Mr. Xcoder
-9 bajtów przy użyciu formatu wyjściowego Jonathana
-11 bajtów dzięki Lynn
-3 bajtów dzięki 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("");}}

Nowe #definelinie po nieliniach są tutaj tylko do prezentacji, więc nie są liczone. Dołączyłem funkcję otoki, więc jest to -6 (313), jeśli funkcja nie jest liczona i zakładasz, że npochodzi ona z innego miejsca. q(10)wyjścia:

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

Używanie do pustych, "do spania i !do przebudzenia.

Działa to tak:

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

• Zauważ, że po n pokoleniach plansza ma 2 n + 1 kwadrat.

• Ze względu na symetrię planszy, musi to tylko symulować prawą dolną ćwiartkę, więc przydzielamy macierz kwadratową n + 1 z 1 rzędem i kolumną wypełnienia dla późniejszego wyszukiwania sąsiada (więc n + 2).

• Przydział za pomocą callocpozwala nam jednocześnie pomnożyć szerokość przez wysokość i wyczyścić planszę 0(pusta).

• Podczas wyszukiwania komórki według jej współrzędnych ( Ci D) używa bezwzględnej wartości wiersza i kolumny ( W) do automatycznego odzwierciedlenia współrzędnych.

• Tablica jest przechowywana jako tablica par liczb całkowitych reprezentujących obecne i poprzednie generacje. Liczby, o których mowa, są char, abyśmy mogli uniknąć sizeof.

• Generacja najczęściej sprawdzana (test sąsiada) to generacja poprzednia, więc jest umieszczona w indeksie 0 w parze, aby można było uzyskać do niej dostęp *.

• Przy każdej generacji ( g) bieżąca generacja jest kopiowana z poprzedniej generacji za pomocą Bpętli, a następnie nowa generacja jest generowana ze starej.

• Każda komórka jest reprezentowana za pomocą 0pustych, 1przebudzonych i 2do spania. Zliczanie sąsiadów było pierwotnie obliczeniem liczby bitów ustawionych w niskich 4 bitach komórki, gdy 4 sąsiadów przesunięto i OR skasowano razem jako flagi ( N), używając 16do spania. Ale z obserwacją, że nieparzysta liczba sąsiadów odpowiada dokładnie 1 sąsiadowi, możemy zapisać kilka postaci, używając tylko maski z 1.

• Na końcu plansza jest drukowana w całości przez iterację w prawym dolnym kwadrancie przy użyciu tej samej sztuczki współrzędnych wartości bezwzględnej, bez dopełniania, aby nie drukować zewnętrznego dopełniania na planszy. Z tego powodu Bpętla zawiera otwierający nawias klamrowy, ponieważ mamy dodatkową instrukcję nowego wiersza w zewnętrznej pętli.

• Kody ASCII dogodnie mapują 0 + 32 (puste) na spację, 2 + 32 (spanie) na "i 1 + 32 (przebudzenie) na !.

Podsumowując, myślę, że jest to zaskakująco czytelny golf ze względu na ładną strukturę problemu.

MATL , 39 bajtów

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

Wyświetla się

• Emptyjako (spacja)
• Awake tak jak #
• Sleepingjak !.

Wypróbuj online! Możesz także obserwować, jak wzorzec rośnie w sztuce ASCII lub graficznie (zmodyfikowany kod).

Wyjaśnienie

Kod wykorzystuje liczb zespolonych 0, 1, jaby reprezentować trzy stany: pusta, budzenie, spanie odpowiednio.

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 bajty

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

Wypróbuj online!

Problemem przy próbie zaimplementowania tego rodzaju funkcji w Befunge jest ograniczony rozmiar pamięci (2000 bajtów zarówno dla danych, jak i kodu). Musiałem więc użyć algorytmu, który oblicza poprawny znak dla dowolnej współrzędnej bez odniesienia do poprzednich obliczeń. Osiąga to poprzez rekurencyjne spoglądanie w przeszłość na wszystkie możliwe ścieżki, którymi pijak mógł podążać, aby osiągnąć ten punkt.

Niestety nie jest to szczególnie wydajne rozwiązanie. Działa, ale jest niesamowicie wolny i staje się wykładniczo wolniejszy wraz ze wzrostem wartości n . Więc chociaż może potencjalnie działać dla dowolnego n do około 127 (7-bitowy limit komórek pamięci Befunge), w praktyce nieuchronnie stracisz zainteresowanie czekaniem na wynik. W TIO osiągnie 60 sekundowy limit czasu na czymkolwiek większym niż około 6 (co najwyżej). Kompilator poradzi sobie znacznie lepiej, ale nawet wtedy prawdopodobnie nie chciałbyś iść dużo wyżej niż 10.

Mimo to pomyślałem, że warto go przesłać, ponieważ jest to całkiem niezła demonstracja rekurencyjnej „funkcji” w Befunge.

Python 2 , 214 bajtów

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

Wypróbuj online!

Wyjaśnienie

Zastosowania 0dla empty, 1dla sleepingi 2dla awake. Drukuje dwuwymiarową listę znaków (ciągi o jednej długości).
Definiuje funkcję, która przyjmuje nieujemną liczbę całkowitą n. Sukcesywnie przesuwa automat komórkowy do osiągnięcia pożądanego stanu. Na koniec stosowana jest konwersja między wewnętrznymi wartościami całkowitymi a rzeczywistymi znakami.

Lua , 251 242 239 238 bajtów

-8 bajtów poprzez uproszczenie inicjalizatora tablicy kosztem dodatkowych wiodących białych znaków.
-1 bajt, zmieniając c=i==2+...and print(s)na c=i~=2+...or print(s).
-3 bajty, budując najpierw kompletny ciąg i drukując raz na końcu.
-1 bajt dzięki Jonathan Frech przepisując or(g(...)==1 andjako 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)

Wypróbuj online!

Empty = Space
Awake = 1
Sleeping =0

Pobiera dane z wiersza poleceń i drukuje na standardowe wyjście.

Reprezentując stany jak false/ nil, 1i 0wewnętrznie, wykrywanie „pusty” nie potrzeba żadnego kodu i „dokładnie jeden przebudzony” Kontrola może odbywać się tylko z dodatkiem.

APL (Dyalog) , 38 bajtów

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

Wypróbuj online!

-4 dzięki Adámowi .
-8 dzięki ngn .

Galaretka , 39 29 bajtów

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

Wypróbuj online!

Używa 0, 1a 2do pustego czuwania i spania. Stopka w linku konwertuje to na , @i #.

• -1 bajt przy użyciu ṬŒḄzamiast ḤḶ=¹.
• -2 bajty przy użyciu -zamiast 1N. Również czyni ¤niepotrzebnym.
• -1 bajt przy użyciu Szamiast +/.
• -6 bajtów przy użyciu Ḃ+Ḃ+zamiast %3=1+=1Ḥ$+. Teraz używa 2do spania zamiast 3.

Wyjaśnienie nadchodzi ...

APL (Dyalog Classic) , 38 bajtów

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

Wypróbuj online!

oparty na rozwiązaniu Erika the Outgolfer

⍪1 to matryca 1x1 zawierająca 1

⎕ ewaluowane dane wejściowe

( )⍣⎕ zastosuj to wiele razy

• (⌽0,⍉)⍣4surround 0s, czyli 4 razy do: transpose ( ⍉), dodaj 0 po lewej stronie ( 0,), odwróć w poziomie ( ⌽)

• g←3+/0,,∘0 nazywamy to funkcją sumującą potrójne poziome g

• ⍉∘g∘⍉funkcja sumująca potrójne pionowe - gpodlegająca transpozycji

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 suma dwóch sum modulo 2

• ⌈ tym większy między tym a ...

• 2∘∧ LCM 2 i oryginalnej matrycy - zamienia 1s w 2s, zachowując 0s i 2s

Perl 5 , 192 + 1 ( -n) = 193 bajtów

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

Wypróbuj online!

Używa 0 dla pustych, 1 dla obudzonych i 2 dla uśpienia.

Rubin , ₁₆₄ 153 bajty

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

Wypróbuj online!

Używa „” dla pustego, „@” dla wybudzania i „#” dla uśpienia (jak w przykładzie). Przypuszczam, że mógłbym zaoszczędzić 6 bajtów, używając liczb, ale wygląda to lepiej.

Pip , 69 61 bajtów

60 bajtów kodu, +1 dla -lflagi.

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

Przyjmuje njako argument wiersza polecenia. Używa 0pustego, 1przebudzonego i 2do spania. (Aby uzyskać ładniejszy ASCII-art jak w przykładach Wyzwaniem jest, wymień końcowy yz " @#"@y).

Wypróbuj online!

Wyjaśnienie

Ustawiać:

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

Główna pętla:

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

gdzie treść funkcji to:

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

Po zakończeniu pętli po prostu drukujemy automatycznie y. -lFlaga oznacza, że lista jest zagnieżdżona drukowane przez złączenie zawartość każdego rzędu i oddzielenia rzędów ze znakami nowej linii.

Java (OpenJDK 8) , 220 bajtów

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

Wypróbuj online!

Uwaga: zwrócona tablica zawiera ramkę lub '\0'znaki. Ponieważ samolot ma być nieskończony, używana jest tylko granica.

Mapowanie postaci:

• Pusty: (spacja)
• Obudzić: =
• Spanie: 0

Oszczędza

• 29 bajtów zaoszczędzonych dzięki Jonathanowi S.
• 9 kolejnych bajtów dzięki Jonathanowi S. poprzez zamianę postaci na innych i „magię za pomocą liczb pierwszych i arytmetyki modułowej”

Python, 199 192 bajtów

Ten kod działa zarówno w Pythonie 2, jak i Pythonie 3, ale używa popularnej biblioteki Numpy innej firmy do obsługi tablicy.

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

Pusty = 0
Przebudzony = 1
Śpiący = 2

print(f(6)) wyjścia

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

Jeśli chcesz ładniejszego drukowania, możesz to nazwać w ten sposób:

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

który drukuje przy użyciu tych samych znaków, jakie podano w pytaniu.