체스에서 기사는 현재 위치를 기준으로 X로 표시된 위치, ♞로 표시된 위치로만 이동할 수 있습니다.

---

기사의 그래프는 체스 판에 나이트 체스 조각의 모든 법적 움직임을 나타내는 그래프입니다. 이 그래프의 각 정점은 체스 판의 정사각형을 나타내며 각 모서리는 기사의 이동 거리 인 두 정사각형을 연결합니다.

표준 8 x 8 보드의 그래프는 다음과 같습니다.

---

도전:

정수 주어진 N , 여기서 3 ≤ N ≤ (8) , 출력 할 N-N-의해 각각의 위치에서 이동 가능한 횟수를 도시하는 보드를 나타내는 행렬. 들면 N = 8 개의 출력은 상기 그래프의 각 정점의 값을 나타내는 행렬 것이다.

출력 형식은 유연합니다. 목록의 목록 또는 평평한 목록 등도 허용되는 형식입니다.

---

전체 테스트 사례 세트 :

--- N = 3 ---
2 2 2
2 0 2
2 2 2
--- N = 4 ---
2 3 3 2
3 4 4 3
3 4 4 3
2 3 3 2
--- N = 5 ---
2 3 4 3 2
3 4 6 4 3
4 6 8 6 4
3 4 6 4 3
2 3 4 3 2
--- N = 6 ---
2 3 4 4 3 2
3 4 6 6 4 3
4 6 8 8 6 4
4 6 8 8 6 4
3 4 6 6 4 3
2 3 4 4 3 2
--- N = 7 ---
2 3 4 4 4 3 2
3 4 6 6 6 4 3
4 6 8 8 8 6 4
4 6 8 8 8 6 4
4 6 8 8 8 6 4
3 4 6 6 6 4 3
2 3 4 4 4 3 2
--- N = 8 ---
2 3 4 4 4 4 3 2
3 4 6 6 6 6 4 3
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
3 4 6 6 6 6 4 3
2 3 4 4 4 4 3 2

---

이것은 코드 골프 이므로 각 언어에서 가장 짧은 솔루션이 승리합니다. 설명이 권장됩니다!

MATL , 17 16 바이트

t&l[2K0]B2:&ZvZ+

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

(@Luis Mendo 덕분에 1 바이트)

코드의 주요 부분은 컨볼 루션을위한 행렬 를 만드는 것입니다 .$K$

$$\mathbf{K} = \begin{pmatrix}0&1&0&1&0\\1&0&0&0&1\\0&0&0&0&0\\1&0&0&0&1\\0&1&0&1&0\end{pmatrix}$$

(행렬의 중심과 관련하여 각 1은 유효한 기사의 이동입니다.)

t&l-모든 1의 nxn 행렬을 형성하십시오 (여기서 n은 입력입니다). 이것을 M으로하자.

[2K0] -스택에 [2, 4, 0]을 포함하는 배열을 푸시

B -필요에 따라 0으로 채워진 이진으로 모두 변환

0 1 0
1 0 0
0 0 0

2:&Zv-최종 행 / 열을 반복하지 않고 두 차원 모두에서 미러링합니다 ( "대칭 범위 인덱싱"). 이것은 우리에게 필요한 행렬 K를 제공합니다.

0 1 0 1 0
1 0 0 0 1
0 0 0 0 0
1 0 0 0 1
0 1 0 1 0

Z+ -이전 행렬 M에 대해 K의 2D 컨벌루션 수행 (conv2(M, K, 'same') )에 하여 각 위치의 합법적 기사 이동 목표에서 1을 합산

결과 행렬이 암시 적으로 표시됩니다.

파이썬 2 , 81 바이트

lambda n:[sum(2==abs((i/n-k/n)*(i%n-k%n))for k in range(n*n))for i in range(n*n)]

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

자바 스크립트 (ES6), 88 바이트

문자열을 반환합니다.

n=>(g=k=>--k?[n>3?'-2344-6-6'[(h=k=>k*2<n?~k:k-n)(k%n)*h(k/n|0)]||8:k-4&&2]+g(k):2)(n*n)

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

방법?

$n=3$

$2$$0$

$$\pmatrix{2 & 2 & 2\\ 2 & 0 & 2\\ 2 & 2 & 2}$$

$3<n\le 8$

$(x,y)$$0\le x<n$$0\le y<n$$i_{x,y}$

$$i_{x,y}=\min(x+1,n-x)\times \min(y+1,n-y)$$

$n=8$

$$\pmatrix{1 & 2 & 3 & 4 & 4 & 3 & 2 & 1\\ 2 & 4 & 6 & 8 & 8 & 6 & 4 & 2\\ 3 & 6 & 9 & 12 & 12 & 9 & 6 & 3\\ 4 & 8 & 12 & 16 & 16 & 12 & 8 & 4\\ 4 & 8 & 12 & 16 & 16 & 12 & 8 & 4\\ 3 & 6 & 9 & 12 & 12 & 9 & 6 & 3\\ 2 & 4 & 6 & 8 & 8 & 6 & 4 & 2\\ 1 & 2 & 3 & 4 & 4 & 3 & 2 & 1}$$

The lookup table $T$ is defined as:

$$T = [0,2,3,4,4,0,6,0,6]$$

where $0$ represents an unused slot.

We set each cell $(x,y)$ to:

$$\begin{cases}T(i_{x,y})&\text{if }i_{x,y} \le 8\\8&\text{otherwise}\end{cases}$$

---

JavaScript (ES7), 107 bytes

A naive implementation which actually tries all moves.

n=>[...10**n-1+''].map((_,y,a)=>a.map((k,x)=>~[...b=i='01344310'].map(v=>k-=!a[x-v+2]|!a[y-b[i++&7]+2])+k))

Try it online!

Jelly,  23 22 14  10 bytes

²ḶdðạP€ċ2)

A monadic link yielding a flat list - uses the idea first used by KSab in their Python answer - knight's moves have "sides" 1 and 2, the only factors of 2.

Try it online! (footer calls the program's only Link and then formats the result as a grid)

Alternatively, also for 10 bytes, ²Ḷdðạ²§ċ5) (knight's moves are all of the possible moves with distance $\sqrt{5}$)

How?

²ḶdðạP€ċ2) - Link: integer, n (any non-negative) e.g. 8
²          - square n                                 64
 Ḷ         - lowered range                            [0,    1,    2,    3,    4,    5,    6,    7,    8,    9,    10,   11,   12,   13,   14,   15,   16,   17,   18,   19,   20,   21,   22,   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,   38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,   56,   57,   58,   59,   60,   61,   62,   63]
  d        - divmod (vectorises) i.e. x->[x//n,x%n]   [[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],[4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],[5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],[6,0],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],[7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7]]
   ð     ) - new dyadic chain for each - call that L ( & e.g. R = [1,2] representing the "2nd row, 3rd column" ...-^ )
    ạ      -   absolute difference (vectorises)       [[1,2],[1,1],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[0,2],[0,1],[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[1,2],[1,1],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[2,2],[2,1],[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[3,2],[3,1],[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[4,2],[4,1],[4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[5,2],[5,1],[5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[6,2],[6,1],[6,0],[6,1],[6,2],[6,3],[6,4],[6,5]]
     P€    -   product of €ach                        [2,    1,    0,    1,    2,    3,    4,    5,    0,    0,    0,    0,    0,    0,    0,    0,    2,    1,    0,    1,    2,    3,    4,    5,    4,    2,    0,    2,    4,    6,    8,    10,   6,    3,    0,    3,    6,    9,    12,   15,   8,    4,    0,    4,    8,    12,   16,   20,   10,   5,    0,    5,    10,   15,   20,   25,   12,   6,    0,    6,    12,   18,   24,   30]
       ċ2  -   count 2s                          6:    ^-...1                  ^-...2                                                                  ^-...3                  ^-...4                        ^-...5      ^-...6
           - )                                                                                                     v-...that goes here
           -   ->                                  -> [2,    3,    4,    4,    4,    4,    3,    2,    3,    4,    6,    6,    6,    6,    4,    3,    4,    6,    8,    8,    8,    8,    6,    4,    4,    6,    8,    8,    8,    8,    6,    4,    4,    6,    8,    8,    8,    8,    6,    4,    4,    6,    8,    8,    8,    8,    6,    4,    3,    4,    6,    6,    6,    6,    4,    3,    2,    3,    4,    4,    4,    4,    3,    2]

---

Previous 22 byter

2RżN$Œp;U$+,ḟ€³R¤Ẉ¬Sðþ

A full program (due to ³).

Try it online! (footer calls the program's only Link and then formats the result as a grid)

Finds all moves and counts those which land on the board probably definitely beatable by calculating (maybe beatable by changing the "land on the board" logic).

APL (Dyalog Classic), 18 bytes

+/+/2=×/¨|∘.-⍨⍳2⍴⎕

Try it online!

⎕ evaluated input N

2⍴⎕ two copies of N

⍳2⍴⎕ the indices of an N×N matrix - a matrix of length-2 vectors

∘.-⍨ subtract each pair of indices from each other pair, get an N×N×N×N array

| absolute value

×/¨ product each

2= where are the 2s? return a boolean (0/1) matrix

Note that a knight moves ±1 on one axis and ±2 on the other, so the absolute value of the product of those steps is 2. As 2 can't be factored in any other way, this is valid only for knight moves.

+/+/ sum along the last dimension, twice

RAD, 51 46 39 bytes

{+/(⍵∘+¨(⊖,⊢)(⊢,-)(⍳2)(1¯2))∊,W}¨¨W←⍳⍵⍵

Try it online!

How?

Counts the number of valid knight moves for each square by seeing which knight moves would land on the board:

{+/(⍵∘+¨(⊖,⊢)(⊢,-)(⍳2)(1¯2))∊,W}¨¨W←⍳⍵⍵
 +/                                     - The number of ...
                            ∊,W         - ... in-bounds ...
        (⊖,⊢)(⊢,-)(⍳2)(1¯2)             - ... knight movements ...
   (⍵∘+¨                   )            - ... from ...
{                              }¨¨W←⍳⍵⍵ - ... each square

Brachylog, 65 40 33 bytes

This breaks down for N bigger then 9. So I'm happy N can be only go to 8 =)

⟦₅⟨∋≡∋⟩ᶠ;?z{{hQ&t⟦₅↰₁;Qz-ᵐ×ȧ2}ᶜ}ᵐ

• -25 bytes by switching to KSab's formula
• -7 bytes by flattening the array thanks to sundar

Try it online!

---

Brachylog, 44 36 bytes

This one also works for number higher then 9

gP&⟦₅⟨∋≡∋⟩ᶠ;z{{hQ&t⟦₅↰₁;Qz-ᵐ×ȧ2}ᶜ}ᵐ

• -8 bytes by flattening the array thanks to sundar

Try it online!

Retina, 161 bytes

.+
*
L$`_
$=
(?<=(¶)_+¶_+)?(?=(?<=(¶)_*¶_*)__)?(?<=(¶)__+)?(?=(?<=(¶)_*)___)?_(?=(?<=___)_*(¶))?(?=__+(¶))?(?=(?<=__)_*¶_*(¶))?(?=_+¶_+(¶))?
$.($1$2$3$4$5$6$7$8)

Try it online! Link includes test cases. Explanation:

.+
*

Convert to unary.

L$`_
$=

List the value once for each _ in the value, i.e. create a square.

(?<=(¶)_+¶_+)?
(?=(?<=(¶)_*¶_*)__)?
(?<=(¶)__+)?
(?=(?<=(¶)_*)___)?
_
(?=(?<=___)_*(¶))?
(?=__+(¶))?
(?=(?<=__)_*¶_*(¶))?
(?=_+¶_+(¶))?

Starting at the _ in the middle of the regex, try to match enough context to determine whether each of the eight knight's moves is possible. Each pattern captures a single character if the match succeeds. I tried using named groups so that the number of captures directly equals the desired result but that cost 15 bytes.

$.($1$2$3$4$5$6$7$8)

Concatenate all the successful captures and take the length.

Wolfram Language (Mathematica), 34 bytes

Yet another Mathematica built-in.

VertexDegree@KnightTourGraph[#,#]&

Returns a flattened list.

Try it online!

Python 2, 114 103 92 bytes

lambda n:[sum((d*c>d)+(d*c>c)for d in(y%n,n-y%n-1)for c in(y/n,n-y/n-1))for y in range(n*n)]

Try it online!

C (gcc), 133 125 bytes

This solution should work on any size board.

#define T(x,y)(x<3?x:2)*(y<3?y:2)/2+
a,b;f(i){for(a=i--;a--;)for(b=i+1;b--;)printf("%i ",T(a,b)T(i-a,b)T(a,i-b)T(i-a,i-b)0);}

Try it online!