알코올의 영향을받는 격자 위의 사람은 모든 방향으로 갈 가능성이 동일하다는 것은 잘 알려져 있습니다. 그러나이 상식적인 진술은 아주 작은 술꾼 의 영역에는 적용되지 않으며 , 그 행동은 마치 한 번에 모든 가용 경로를 취하는 것처럼 행동 하며 가능한 경로가 서로 간섭 할 수 있습니다. 당신의 임무는 n단계 후 이러한 양자 취한 사람의 가능한 위치를 표시하는 것 입니다.

사양

문제의 음주는 정사각형 격자를 차지하며 다음과 같은 간단한 규칙을 따르는 Von Neumann (플러스 모양) 이웃을 사용하는 3 상태 셀룰러 오토 마톤으로 간주 될 수 있습니다.

• Empty가는 Awake정확히 하나에 인접한 경우 Awake와 그렇지 않은 경우로 이동Empty
• Awake 로 이동 Sleeping
• Sleeping 로 이동 Sleeping

보드의 초기 상태 Awake는 Emptys 의 무한 필드로 둘러싸인 단일 입니다.

도전

음이 아닌 정수가 주어지면 단계 n후 술고래의 ASCII 표현을 작성 n하십시오. 각 상태는 다른 문자로 표시되어야하며 솔루션은 어떤 문자가 어떤 상태를 의미 하는지를 명시해야합니다. 에 공백을 사용 Empty하는 경우 줄 끝에 공백 을 포함 할 필요가 없습니다.

이것은 code-golf 이므로 가장 짧은 답변이 이깁니다. 표준 허점 적용, 선행 및 후행 공백 허용, 문자열 배열 / 2d 문자 배열 출력 허용 등

예

이 예제 는 Empty, @for Awake및 #for에 사용 Sleeping합니다.

n=0
@

n = 1
 @
@#@
 @

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

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

n=6

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

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

재미있는 메모

OEIS에서 점유 된 세포의 수의 서열을 조사함으로써, 양자 술고래가 훨씬 더 잘 연구 된 이쑤시개 서열 과 동형이라는 것을 발견했다 . 그 지식을 더 나은 골프에 포함시킬 수 있다면 나는 감명받을 것입니다.

Wolfram Language (Mathematica) , 92 91 바이트

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

Mathematica의 내장 기능을 사용하는 완벽한 도전 CellularAutomaton!

온라인으로 사용해보십시오!

비어 있음 = 0, 깨우기 = 1, 수면 = 2

처음 256 개의 반복 애니메이션 (흰색 = 비어 있음, 회색 = 깨어 있음, 검은 색 = 잠자기) :

설명

CellularAutomaton[ ... ]

CellularAutomaton사양으로 실행 ...

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

Von Neumann 이웃과 함께 3 색 전체 규칙 7049487784884를 적용하십시오 ...

{j={{1}},0}

중간에 단일 1이 있고 0의 배경이있는 보드에서 ...

{j#}

반복 <input>횟수 (로 {j#}평가 {{{#}}}) 테두리 외부의 셀이 배경과 같지 않으면 배열이 자동으로 확장됩니다.

7049487784884

이 규칙은 밑이 3 인 숫자에서 나옵니다 220221220221220221220221220. 이는 "모두 1또는 2로 2변경 0하고 1그 1주위에 홀수가있는 경우에만 변경 "을 의미 합니다.

Print@@@

배열을 인쇄하십시오.

" 'odd 1s'의 반증 명은 '정확하게 하나 1' '와 같습니다.

이 5x5 격자 픽셀을 고려하십시오. 흰색은 셀 0또는 2깨어 있지 않은 픽셀이고 회색은 1셀입니다.

1셀이 세 개의 0셀 주위에서 생성 된 경우 그리드는 다음과 같이 표시되어야합니다. 셀은 다음과 같이 1U 자형 (또는 회전 된 버전)으로 정렬됩니다.

이 세포 성 오토 마톤의 자기 유사성으로 인해, 세포 성 오토 마톤에 나타나는 임의의 패턴은 (유도에 의해) 대각선에 나타나야한다. 그러나이 패턴은 대각선 대칭이 아닙니다. 즉, 대각선에서는 발생할 수 없으며 셀룰러 오토 마톤의 어느 곳에 나 나타날 수 없습니다.

깨어 / 잠자는 동등

• 그래도 참고 0셀이 정확히으로 1 년 또는 3 둘러싸여 할 수없는 2세포를 휴식 0그 전에 몇 가지 단계가, 셀이 1 년 또는 3의 이웃 한 것을 의미하는 것이기 때문에, 세포 1와로 전환해야합니다 - 세포를 1이미 (모순). 따라서, 구별 무시 괜찮다 1하고 2그리고 상태 "모든 변경 1을 1하고, 0(A)에 1있는 경우에만이 제로 이웃 홀수가 있으면한다. '

그 결과로 생성 된 셀룰러 오토 마톤은 실제로 원래와 동일하지만, 유일한 차이점은 "깨어있는"및 "자고있는"술취한 사람 사이에 구별이 없다는 것입니다. 이 패턴은 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,#}}]&

온라인으로 사용해보십시오!

파이썬 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]

온라인으로 사용해보십시오!

Xcoder 덕분에 -17 바이트
Jonathan의 출력 형식을 사용하는 -9 바이트 -Lynn 덕분에
-11 바이트
ovs 덕분에 -3 바이트

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줄 바꿈은 여기에 표시하기위한 것이므로 계산에 포함되지 않습니다. 래퍼 함수를 ​​포함 했으므로 함수가 계산되지 않고 n다른 곳에서 온 것으로 가정하면 -6 (313) 입니다. q(10)출력 :

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

사용하여 빈을 위해 ", 그리고 수면을 위해 !깨어을 위해.

이것은 다음과 같이 작동합니다.

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

• n 세대 후 보드는 2 n + 1 평방입니다.

• 보드의 대칭으로 인해 오른쪽 하단 사분면 만 시뮬레이션하면되므로 나중에 이웃 조회를 위해 1 행 및 열의 패딩을 가진 n + 1 정사각형 행렬을 할당합니다 ( n + 2).

• 로 할당 calloc하면 동시에 너비에 높이를 곱하고 보드를 0비 웁니다 (빈).

• 좌표 ( C및 D) 로 셀을 찾을 때 행과 열의 절대 값 ( W)을 사용하여 좌표를 자동으로 미러링합니다.

• 보드는 현재 세대와 이전 세대를 나타내는 정수 쌍의 배열로 저장됩니다. 문제의 정수 char는 피할 수 있습니다 sizeof.

• (주변 테스트에 의해) 가장 자주 조회 된 세대는 과거 세대이므로 인덱스 0에 쌍으로 배치되어로 액세스 할 수 있습니다 *.

• 각 세대 ( g)에서 현재 세대는 B루프를 사용하여 이전 세대에 복사 된 다음 새 세대는 이전 세대 에서 생성됩니다.

• 각 셀은 0비우기, 1깨우기 및 2잠자기 용도로 사용됩니다. 네이버 링 카운트는 원래 4 개의 네이버 가 슬립 (sleep N)에 사용하여 플래그 ( ) 로 시프트 및 OR 될 때 셀의 하위 4 비트에 설정된 비트 수의 계산이었습니다 16. 그러나 홀수의 이웃이 정확히 1 이웃에 해당한다는 것을 관찰하면 1의 마스크를 사용하여 여러 문자를 저장할 수 있습니다.

• 마지막으로 보드는 동일한 절대 값 좌표 트릭, 마이너스 패딩을 사용하여 오른쪽 아래 사분면을 반복하여 완전히 인쇄되어 보드에 외부 패딩을 인쇄하지 않습니다. 이것이 B외부 루프에 여분의 줄 바꿈 명령문이 있기 때문에 루프에 여는 중괄호가 포함 된 이유이기도합니다 .

• ASCII 코드는 0 + 32 (비어 있음)를 공백에, 2 + 32 (sleeping) ~ "에, 1 + 32 (wake) ~에 편리하게 매핑 합니다 !.

전체적으로 나는 이것이 문제의 좋은 구조로 인해 놀랍도록 읽기 쉬운 골프라고 생각합니다.

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

비 펀지, 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 값이 클수록 기하 급수적으로 느려집니다 . 따라서 최대 약 127 (Befunge의 7 비트 메모리 셀 제한)까지 모든 n에서 작동 할 수는 있지만 실제로 결과를 기다리는 데 관심을 잃을 수는 없습니다. TIO에서는 약 6 초 (최고) 이상이면 60 초 시간 초과가 발생합니다. 컴파일러는 훨씬 더 잘 수행하지만, 심지어 10보다 훨씬 더 높은 것을 원하지 않을 것입니다.

아직도, 나는 그것이 Befunge에서 재귀적인 "함수"를 실제로 보여주기 때문에 제출할 가치가 있다고 생각했습니다.

파이썬 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. 2 차원 문자 (한 길이의 문자열) 목록을 인쇄합니다.
음수가 아닌 정수를받는 함수를 정의합니다 n. 원하는 상태에 도달 할 때까지 셀룰러 오토 마톤을 계속 진행합니다. 마지막으로, 내부 정수 값과 실제 문자 사이의 변환이 적용됩니다.

루아 , 251 242 239 238 바이트

추가 선행 공백을 희생하여 배열 이니셜 라이저를 단순화하여 -8 바이트.
변경함으로써 -1 바이트 c=i==2+...and print(s)로 c=i~=2+...or print(s).
완전한 문자열을 먼저 작성하고 마지막에 한 번 인쇄하여 -3 바이트.
-1 바이트 감사 조나단 FRECH 재 작성함으로써 or(g(...)==1 and로 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)

온라인으로 사용해보십시오!

비우기 = 공간
깨우기 = 1
수면 =0

명령 행에서 입력을 가져 와서 stdout으로 인쇄합니다.

상태를 false/ nil로 표시 1하고 0내부적으로 "빈"감지는 코드가 필요하지 않으며 "정확하게 하나의 깨어"확인을 추가로 수행 할 수 있습니다.

APL (Dyalog) , 38 바이트

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

온라인으로 사용해보십시오!

Adám 에게 -4 감사합니다 . ngn
덕분에 -8 .

젤리 , 39 29 바이트

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

온라인으로 사용해보십시오!

사용 0, 1및 2빈 깨어 있고 자합니다. 링크의 바닥 글은 이것을 , @및 로 변환합니다 #.

• ṬŒḄ대신에 -1 바이트를 사용하십시오 ḤḶ=¹.
• -대신에 -2 바이트를 사용하십시오 1N. 또한 ¤불필요합니다.
• S대신에 -1 바이트를 사용하십시오 +/.
• Ḃ+Ḃ+대신에 -6 바이트를 사용하십시오 %3=1+=1Ḥ$+. 이제 2대신에 수면을 위해 사용 합니다 3.

설명이 온다 ...

APL (Dyalog Classic) , 38 바이트

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

온라인으로 사용해보십시오!

Erik the Outgolfer의 솔루션을 기반으로

⍪1 1을 포함하는 1x1 행렬입니다.

⎕ 평가 된 입력

( )⍣⎕ 여러 번 적용

• (⌽0,⍉)⍣40으로 둘러싸십시오. 즉 4 번 수행합니다. 조옮김 ( ⍉), 왼쪽에 0을 추가 ( 0,), 가로로 반전 ( ⌽)

• g←3+/0,,∘0 수평 트리플을 합산하는 함수 g

• ⍉∘g∘⍉수직 트리플을 합산하는 함수- g조옮김

• 2 | ⍉∘g∘⍉ + g←3+/0,,∘0 두 합의 합 모듈로 2

• ⌈ 그 사이에 더 큰 ...

• 2∘∧ LCM 2와 원래 행렬-이것은 1과 2를 유지하면서 1을 2로 바꿉니다.

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를 사용합니다.

루비 , ₁₆₄₁₅₃ 바이트

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

온라인으로 사용해보십시오!

비어있는 경우 ""를 사용하고, 깨어있는 경우 "@", 잠자는 경우 "#"을 사용합니다 (예와 같이). 대신 숫자를 사용하여 6 바이트를 절약 할 수 있다고 생각하지만 다음과 같이 보입니다.

핍 , 69 61 바이트

60 바이트의 코드, -l플래그의 경우 +1

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

소요 n명령 줄 인수로. 사용 0, 빈에 대한 1깨어에 대한, 그리고 2자고합니다. (도전의 예 에서처럼 더 나은 ASCII 아트를 얻으려면 final을 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플래그는 중첩 된리스트가 각각의 행의 내용을 연결 개행으로 행을 구분하여 출력되는 것을 의미한다.

자바 (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

저장

• Jonathan S 덕분에 29 바이트가 절약되었습니다.
• Jonathan S. 덕분에 다른 캐릭터와 문자를 교환하고 "소수점 및 모듈 식 산술로 마술을 수행"함으로써 9 바이트 더

Python, 199192 바이트

이 코드는 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

비우기 = 0
깨우기 = 1
수면 = 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)))

질문에 주어진 것과 동일한 문자를 사용하여 인쇄합니다.