Alkol etkisi altında olan bir ızgaradaki bir kişinin, mevcut herhangi bir yöne gitme konusunda eşit şansa sahip olduğu iyi bilinmektedir. Bununla birlikte, bu sağduyu ifadesi , davranışları mevcut olan her yolu bir seferde izliyormuş gibi davranan çok küçük sarhoşlar alanında geçerli değildir ve aldıkları olası yollar birbiriyle karışabilir. Göreviniz, böyle bir kuantum sarhoşunun olası pozisyonlarını adımlardan sonra göstermektir .n

Şartname

Söz konusu sarhoş kare bir ızgara kaplar ve bu basit kuralları izleyen bir Von Neumann (artı şekilli) mahallesi kullanarak 3 durumlu bir hücresel otomat olarak kabul edilebilir:

• Emptygider Awaketam olarak birine bitişik ise Awake, aksi takdirde giderEmpty
• Awake gider Sleeping
• Sleeping gider Sleeping

Kurulun başlangıçtaki durumu Awakesonsuz bir Emptys alanıyla çevrilidir .

Meydan okuma

Negatif olmayan bir tamsayı verildiğinde n, nadımların ardından sarhoşun ASCII temsilini oluşturun . Her durum farklı bir karakterle temsil edilmeli ve çözümler hangi karakterin hangi durum olduğunu ifade etmelidir. Bunun için boşluk kullanırsanız Empty, satırın sonuna bir satır eklemeniz gerekmez.

Bu kod golf , bu yüzden en kısa cevap kazanır. Standart boşluklar uygulanır, öncü ve takip eden boşluklara izin verilir, string array / 2d char array output, vb. İzin verilir.

Örnekler

Bu örnekler kullanmak için Empty, @için Awake, ve #için Sleeping.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

İlginç Not

OEIS'teki işgal edilmiş hücre sayısının dizilimine bakarak, kuantum sarhoşluğunun çok daha iyi çalışılan kürdan dizisine izomorfik olduğunu buldum . Bu bilgiyi daha iyi bir golf ile birleştirebilirseniz, çok etkileneceğim.

Wolfram Dili (Mathematica) , 92 91 bayt

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

Mathematica yerleşik yapısını kullanmak için mükemmel bir meydan okuma CellularAutomaton!

Çevrimiçi deneyin!

Boş = 0, Uyanık = 1, Uyuyan = 2

İlk 256 yinelemenin animasyonu (beyaz = boş, gri = uyanık, siyah = uyku):

açıklama

CellularAutomaton[ ... ]

Özellikleri ile çalıştırın CellularAutomaton...

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

Von Neumann mahallesi ile, 3-renk toplamcı kural 7049487784884'ü uygulayın ...

{j={{1}},0}

Ortada tek bir 1 bulunan bir tahtada, 0'lı bir geçmişi olan ...

{j#}

Tekrarlanan <input>zamanlar ( {j#}değerlendirir {{{#}}}). Kenarlığın dışındaki bir hücre arka planla aynı değilse, dizi otomatik olarak genişler.

7049487784884

Bu kural tabanı-3 numaradan geliyor 220221220221220221220221220demektir, "bütün değiştirebilir 1veya 2hiç 2ve değiştirmek 0için 1bir tek sayı olduğu ve ancak eğer 1onun etrafında s."

Print@@@

Diziyi yazdır.

'' Tekler 1' ' in yarı kanıtı 'tamamen bir 1' 'e eşittir :

Bu 5x5 piksel ızgarasını göz önünde bulundurun. Beyaz 0bir 2hücredir (uyanık olmayan pikseller) ve gri bir 1hücredir.

1Üç 0hücre etrafında bir hücre oluşturulmuşsa , ızgara şöyle görünmelidir: 1U şeklinde (veya döndürülmüş bir versiyonda) düzenlenmiş üç s aşağıdaki gibidir:

Bu hücresel otomatın kendi kendine benzerliğinden dolayı, hücresel otomatta görünen herhangi bir desen diyagonal üzerinde görünmelidir (indüksiyonla). Bununla birlikte, bu model çapraz olarak simetrik değildir. yani, diyagonal üzerinde gerçekleşemez ve hücresel otomatın hiçbir yerinde görünemez.

Uyanık / Uyku eşdeğerdir

Bir 0hücrenin tam olarak bir veya üç 2hücre ile çevrili olamayacağına ve 0hücreleri dinleyemeyeceğine dikkat edin, çünkü bu, bazı adımların, hücrenin bir veya üç 1hücrenin komşusuna sahip olduğunu ve 1zaten bir (çelişki) haline gelmesi gerektiğini ima eder . Bu nedenle, 1ve 2ile devlet arasındaki ayrımı görmezden gelmek tamamdır 'hepsini 1değiştir 1, a'yı 0bir 1if ile ve eğer tek sayıda sıfır komşusu yoksa'.

Elde edilen hücresel otomat gerçekten de orjinali ile aynıdır, tek fark "uyanık" ve "uykuda" ayyaşlar arasında bir fark yoktur. Bu model OEIS A169707'de açıklanmaktadır .

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

Çevrimiçi deneyin!

İlk 16 yinelemenin yan yana karşılaştırması:

Ardışık iki yineleme eklemek, meydan okuma özelliklerini takip eden bir sonuç verir (94 bayt):

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

Çevrimiçi deneyin!

Python 2 , 192 bayt

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]

Çevrimiçi deneyin!

-17 bayt, Bay Xcoder sayesinde
-9 bayt, Jonathan'ın çıkış formatını kullanarak
-11 bayt, Lynn sayesinde-
3 bayt

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

Çizgilerden sonraki yeni #definesatırlar burada sadece sunum içindir, bu nedenle sayılmaz. Bir sarmalayıcı işlevi ekledim, bu yüzden işlev sayılmazsa ewhere6 (313) olur ve nbaşka bir yerden geldiğini varsayarsınız . q(10)çıktılar:

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

Boş kullanmak , "uyumak ve !uyanık olmak için.

Bu böyle çalışır:

• A(i,b,e)“∀i∈ [b, e).”, B(b,e)“∀r∈ [b, e) .∀c∈ [b, e)” şeklindedir.

• N nesiller sonra tahta 2 n + 1 kare olduğunu gözlemleyin .

• Tahtanın simetrisi nedeniyle, bunun sadece sağ alt kadranı simüle etmesi gerekir, bu yüzden n + 1 kare matrisini daha sonra komşu arama için 1 sıra ve dolgu sütunu ile tahsis ediyoruz (yani n + 2).

• İle tahsis etmek calloceşzamanlı olarak yüksekliği genişliği ile çarpmamıza ve tahtayı temizlememize izin verir 0.

• Bir hücreyi koordinatlarına ( Cve D) göre ararken, koordinatları Wotomatik olarak yansıtmak için satır ve sütunun ( ) mutlak değerini kullanır .

• Tahta, mevcut ve önceki nesilleri temsil eden bir çift tam sayı dizisi olarak depolanır. Söz konusu tamsayılar charkaçınabilmemiz için sizeof.

• Kuşak en çok aranan (komşu testine göre) geçmiş kuşaktır, bu yüzden erişilebilmesi için parite 0 dizinine yerleştirilir *.

• Her nesilde ( g), mevcut nesil bir Bdöngü kullanılarak önceki nesile kopyalanır , daha sonra yeni nesil eskiden üretilir.

• Her hücre 0boş, 1uyanık ve 2uyumak için kullanılır. Komşuları saymak başlangıçta, 4 komşu kaydırıldığında ve uyumak için bayraklar ( N) olarak bir araya getirildiğinde hücrelerin düşük 4 bitinde ayarlanan bit sayısının bir hesaplamasıydı 16. Ancak, tek sayıda komşunun tam olarak 1 komşuya eşdeğer olduğu gözlemiyle, sadece 1'li bir maske kullanarak birkaç karakter kaydedebiliriz.

• Sonunda, tahta, aynı mutlak değer koordinat numarası, eksi dolguyu kullanarak sağ alt kadran üzerinde yinelenerek tam olarak yazdırılır, böylece dış dolguyu tahtaya basmayız. Bu aynı zamanda Bdöngünün kıvrımlı bir ayraç içerme nedeni de budur , çünkü dış çevrede extra newline ifadesine sahibiz.

• ASCII kodları, uygun bir şekilde 0 + 32 (boş), 2 + 32 (uyku) "ve 1 + 32 (uyanık) alanlarını eşler !.

Sonuçta bu sorunun güzel yapısı nedeniyle şaşırtıcı bir şekilde okunabilir bir golf olduğunu düşünüyorum.

MATL , 39 bayt

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

Bu görüntüler

• Emptyolarak (boşluk)
• Awake gibi #
• Sleepingolarak !.

Çevrimiçi deneyin! Desenin ASCII sanatında veya grafiksel olarak (değiştirilmiş kod) büyümesini de izleyebilirsiniz.

açıklama

Kod karmaşık sayıları kullanır 0, 1, jsırasıyla uyku, boş, uyandırma: Üç durumlarını temsil etmesi için.

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 bayt

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

Çevrimiçi deneyin!

Befunge'de bu tür bir şeyi uygulamaya çalışırken sorun sınırlı bellek boyutudur (hem veri hem de kod için 2000 bayt). Bu yüzden önceki hesaplamalara referans vermeden herhangi bir koordinat için doğru karakteri hesaplayan bir algoritma kullanmak zorunda kaldım. Bunu, sarhoşluğun bu noktaya ulaşmak için izlemiş olabileceği tüm olası yollar boyunca tekrar tekrar geriye bakarak bakarak başarır.

Maalesef, bu özel bir verimli çözüm değil. Çalışıyor, ama inanılmaz derecede yavaş ve n'in değeri büyüdükçe üssel olarak yavaşlıyor . O potansiyel olarak herhangi için işe yarayabilir süre Yani , n yaklaşık 127 (Befunge en 7 bit bellek hücresi sınırı) için yukarı, uygulamada kaçınılmaz sonucu bekliyor ilgi kaybedersiniz. TIO'da, 60 saniyelik zaman aşımına 6'dan daha yüksek herhangi bir şeyle (en iyi ihtimalle) vuracaktır. Bir derleyici daha iyi iş çıkarır, ancak o zaman bile muhtemelen 10'dan daha yükseğe çıkmak istemezsiniz.

Yine de göndermeye değer olduğunu düşündüm, çünkü aslında Befunge'de özyinelemeli bir "işlev" in güzel bir göstergesi.

Python 2 , 214 bayt

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

Çevrimiçi deneyin!

açıklama

Kullanımları 0için empty, 1için sleepingve 2için awake. İki boyutlu bir karakter (bir uzunluk dizesi) listesini yazdırır.
Negatif olmayan bir tam sayı alan bir işlevi tanımlar n. İstenilen duruma ulaşılıncaya kadar hücresel otomatiği art arda ilerletir. Son olarak, dahili tamsayı değerleri ile gerçek karakterler arasında bir dönüşüm uygulanır.

Lua , 251 242 239 238 bayt

-8 bayt, bazı ek öncü boşlukların maliyeti karşılığında dizi başlatıcısını basitleştirerek.
Değiştirerek -1 bayt c=i==2+...and print(s)içine c=i~=2+...or print(s).
Önce tam bir dize oluşturarak ve sonunda bir kez yazdırarak -3 bayt.
-1 bayt sayesinde Jonathan Frech yeniden ile or(g(...)==1 andolduğu gibi 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)

Çevrimiçi deneyin!

Boş = Boşluk
Uyanık = 1
Uyku =0

Komut satırından girdi alır ve stdout'a yazdırır.

Olarak durumlarını temsil ederek false/ ' nil, 1ve 0tespit, içten "boş" herhangi bir kod gerekmez ve "tam olarak bir uyanık" onay sadece bir ek ile yapılabilir.

APL (Dyalog) , 38 bayt

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

Çevrimiçi deneyin!

-4 Adám'a teşekkürler .
-8 ngn sayesinde .

Jöle , 39 29 bayt

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

Çevrimiçi deneyin!

Kullanır 0, 1ve 2boş uyanık ve uyku için. Bağlantıdaki altbilgi bunu , @ve ' ye dönüştürür #.

• -1 bayt ṬŒḄyerine kullanarak ḤḶ=¹.
• -2 bayt -yerine kullanarak 1N. Ayrıca ¤gereksiz yapar .
• -1 bayt Syerine kullanarak +/.
• -6 bayt Ḃ+Ḃ+yerine kullanarak %3=1+=1Ḥ$+. Şimdi 2yerine uyumak için kullanır 3.

Açıklama geliyor ...

APL (Dyalog Klasik) , 38 bayt

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

Çevrimiçi deneyin!

Outgolfer’ın çözümüne dayanan Erik

⍪1 1'i içeren 1x1'lik bir matristir

⎕ değerlendirilmiş girdi

( )⍣⎕ bunu birçok kez uygula

• (⌽0,⍉)⍣40s ile surround, yani 4 kez yapın: transpose ( ⍉), solda 0s ekleyin ( 0,), yatay olarak ters çevirin ( ⌽)

• g←3+/0,,∘0 Yatay üçlüleri toplayan bir işlev, onu çağır g

• ⍉∘g∘⍉Düşey üçlüleri toplayan bir fonksiyon - bu gtranspozisyonun altında

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 iki toplamın toplamı

• ⌈ bununla daha büyük ...

• 2∘∧ 2'nin LCM'si ve orijinal matris - bu 0s ve 2s'yi korurken 1s'yi 2s'ye dönüştürür

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

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

Çevrimiçi deneyin!

Boş için 0, uyanık için 1 ve uykuda için 2 kullanır.

Ruby , ₁₆₄ 153 bayt

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

Çevrimiçi deneyin!

Boş için "", Uyanık için "@" ve Uyuma için "#" kullanır (örnekte olduğu gibi). Sanırım sayıları kullanarak 6 bayt tasarruf edebilirim, sanırım, ama daha iyi gözüküyor.

Pip , 69 61 bayt

60 baytlık kod, -lbayrak için +1 .

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

Alır nbir komut satırı bağımsız değişken olarak. Kullanımları 0, boş için 1uyanık için, ve 2uyumak için. (Meydandaki örneklerde olduğu gibi ASCII sanatını daha iyi hale getirmek için finali yile değiştirin " @#"@y.)

Çevrimiçi deneyin!

açıklama

Kurmak:

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

Ana döngü:

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

işlev gövdesi nerede:

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

Döngüden sonra, sadece otomatik olarak yazdırırız y. -lBayrak iç içe liste, her satırın içeriğini bitiştirme ve yeni satır ile satır ayırarak basılı olduğu anlamına gelir.

Java (OpenJDK 8) , 220 bayt

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

Çevrimiçi deneyin!

Not: döndürülen dizi bir kenarlık veya '\0'karakter içeriyor . Uçağın sonsuz olması gerektiğinden, sadece sınır dışı kullanılır.

Karakter haritalama:

• Boş: (boşluk)
• Uyanık: =
• Uyuyor: 0

kaydeder

• Jonathan S. sayesinde 29 byte kurtarıldı
• 9 karakter daha, karakterleri başkalarıyla değiştirerek ve "asal ve modüler aritmetik ile büyü yaparak" Jonathan S. sayesinde

Python, 199 192 bayt

Bu kod hem Python 2 hem de Python 3'te çalışır, ancak dizi işlemesi yapmak için popüler 3. parti Numpy kütüphanesini kullanır.

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

Boş = 0
Uyanık = 1
Uyuma = 2

print(f(6)) çıktılar

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

Daha güzel baskı istiyorsanız, bu şekilde arayabilirsiniz:

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

soruda verilenle aynı karakterleri kullanarak yazdırır.