O xadrez hexagonal descreve uma família de variantes de xadrez jogadas em um tabuleiro em que as células são hexágonos em vez dos quadrados tradicionais. Existem muitas dessas variantes; neste desafio, focaremos na variante de Gliński, que é a mais comum.

O tabuleiro é composto de três cores (para que a mesma cor não compartilhe uma borda), com as bordas dos hexágonos voltadas para os jogadores. O quadro possui 11 arquivos, marcados com letras aa l(carta jnão é usada) e 11 fileiras (que dobram 60 ° no arquivo f). As classificações 1em 6cada uma contêm 11 células, a classificação 7possui 9 células, a classificação 8possui 7 e assim por diante. A classificação 11contém exatamente uma célula: f11 . (Se ajudar, pense em cada classificação como formando um "V" muito amplo.)

Aqui está um exemplo de quadro do quadro, com o cavaleiro na célula central. As células marcadas com um ponto são os movimentos legais desse cavaleiro em particular. O cavaleiro se move de maneira semelhante ao xadrez "normal", dois para baixo e um para cima. Em termos de xadrez hexagonal, é um movimento ortogonal (através de uma aresta), depois um movimento diagonal na mesma direção (o movimento mais próximo da mesma cor). Por exemplo, com o cavaleiro abaixo, um movimento ortogonal "para cima" para o marrom claro é então acompanhado por um movimento diagonal "para cima e para a direita" ou "para cima e para a esquerda" para o marrom mais próximo.

_{Do domínio público via https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Este cavaleiro está posicionado em f6 e os movimentos legais são assim

c4, c5, d3, d7, e3, e8, g3, g8, h3, h7, i4, i5

Entrada

Uma única entrada dando a célula inicial do nosso cavaleiro. Pode ser como uma única sequência "b6", como duas "b", "6", etc., em qualquer formato conveniente . As letras de entrada podem ser maiúsculas ou minúsculas - sua escolha.

Resultado

Uma lista dos movimentos válidos que um cavaleiro nesse local pode fazer. Pode ser como uma matriz de seqüências de caracteres, uma única sequência com um delimitador inequívoco e consistente, sequências separadas por novas linhas etc., o que for mais conveniente. A saída não precisa necessariamente estar em ordem classificada e pode estar em maiúscula ou minúscula - sua escolha.

Regras

• Suponha que não haja outras peças no tabuleiro ou interfira nos movimentos. Estamos nos concentrando apenas no cavaleiro.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

b6
a3, c4, d5, d9, e7, e8

f6
c4, c5, d3, d7, e3, e8, g3, g8, h3, h7, i4, i5

f11
d8, e8, g8, h8

i1
f2, f3, g4, h4, l2, k3

JavaScript (ES6), 184 bytes

Pega o arquivo Fcomo um caractere e a classificação Rcomo um inteiro na sintaxe de curry (F)(R). Retorna uma matriz de seqüências de caracteres.

F=>R=>[...'100124566542'].map((X,i)=>(X-=3-(x=(s='abcdefghikl').search(F)))-7<(Y=('9641001469'[i]||10)-(A=Math.abs)(x-5)+17-2*R)&X+Y>3&X+16>Y&X+Y<27&&s[X]+(22-Y-A(X-5))/2).filter(n=>n)

Quão?

Etapa 1: converter arquivo / classificação em coordenadas cartesianas

Convertemos as coordenadas hexagonais do xadrez em coordenadas cartesianas (x, y) com x em [0 .. 10] e y em [0 .. 20] :

      00 01 02 03 04 05 06 07 08 09 10
   +----------------------------------
00 |                f11                     F = file (letter)
01 |             e10   g10                  R = rank in [1 .. 11]
02 |          d09   f10   h09               
03 |       c08   e09   g09   i08            F | a b c d e f g h i k l
04 |    b07   d08   f09   h08   k07         --+-----------------------
05 | a06   c07   e08   g08   i07   l06      x | 0 1 2 3 4 5 6 7 8 9 10
06 |    b06   d07   f08   h07   k06         
07 | a05   c06   e07   g07   i06   l05      y = 22 - |x - 5| - 2R
08 |    b05   d06   f07   h06   k05   
09 | a04   c05   e06   g06   i05   l04
10 |    b04   d05   f06   h05   k04   
11 | a03   c04   e05   g05   i04   l03
12 |    b03   d04   f05   h04   k03   
13 | a02   c03   e04   g04   i03   l02
14 |    b02   d03   f04   h03   k02   
15 | a01   c02   e03   g03   i02   l01
16 |    b01   d02   f03   h02   k01   
17 |       c01   e02   g02   i01      
18 |          d01   f02   h01         
19 |             e01   g01            
20 |                f01               

Etapa 2: aplicar os vetores de movimentação

Abaixo está a lista dos vetores de movimento no sistema cartesiano:

(-2, +4), (-1, -5), (+3, +1),
(-3, +1), (+1, -5), (+2, +4),
(-3, -1), (+2, -4), (+1, +5),
(-2, -4), (+3, -1), (-1, +5)

Aplicamos cada uma delas às coordenadas de origem (x, y) e obtemos uma lista de coordenadas de destino (X, Y) .

Etapa 3: testar as coordenadas de destino

Agora precisamos verificar quais coordenadas alvo estão realmente localizadas dentro do quadro. Isso é feito testando X + Y e X - Y :

As coordenadas são válidas se todas as seguintes comparações forem verdadeiras:

• X + Y> 3
• X + Y <27
• X - Y <7
• X - Y> -17

Também devemos verificar se X está em [0 .. 10] . Isso não é feito explicitamente porque s[X]é indefinido, se não for, o que eventualmente resulta em um valor falso que é filtrado.

Etapa # 4: converter novamente em coordenadas hexagonais de xadrez

Finalmente, as coordenadas alvo válidas são convertidas novamente em coordenadas hexagonais de xadrez, usando o inverso das fórmulas descritas na etapa 1.

Casos de teste

let f =

F=>R=>[...'100124566542'].map((X,i)=>(X-=3-(x=(s='abcdefghikl').search(F)))-7<(Y=('9641001469'[i]||10)-(A=Math.abs)(x-5)+17-2*R)&X+Y>3&X+16>Y&X+Y<27&&s[X]+(22-Y-A(X-5))/2).filter(n=>n)

console.log(JSON.stringify(f('b')(6)))
console.log(JSON.stringify(f('f')(6)))
console.log(JSON.stringify(f('f')(11)))
console.log(JSON.stringify(f('i')(1)))

Lote. 403 bytes

@echo off
set j=a b c d e f g h i k l
set f=0
for %%f in (%j%)do set/af+=1&if %%f==%1 goto l
:l
set j=j%j: =%
set/a"r=6-f,r*=r>>31,r+=%2
for %%s in ("-3 -2" "-3 -1" "-2 1" "2 -1" "3 1" "3 2")do call:c %%~s
exit/b
:c
call:l %2 %1
:l
set/ag=f+%1,s=r+%2,t=g-s
if %g% geq 1 if %g% leq 11 if %s% geq 1 if %s% leq 11 if %t% geq -5 if %t% leq 5 set/a"t=6-g,s-=t*=t>>31"&call echo %%j:~%g%,1%%%%s%%

Ajusta o sistema de coordenadas, embora de uma maneira diferente da resposta de @ Arnauld. A csub-rotina aproveita a simetria tentando o reflexo no espelho de cada movimento. (Eu também tentei girar, mas isso levou muitos bytes.)

JavaScript (ES6), 184 bytes

(s,t,j=' abcdefghikl',f=j.search(s),r=f<6?t:t+f-6)=>[...'120405..162645'].map((c,i)=>[(i>>1)-3+f,c-3+r]).filter(([f,r])=>f>0&f<12&r>0&r<12&f-r<6&r-f<6).map(([f,r])=>j[f]+(f<6?r:r+6-f))

Pensei em portar minha solução Batch para o ES6 para ver como ela se comparava ... não esperava que fosse tão perto ...

CJam, 77

1Z2W2Z]_Wf*+2/_Wf%+[r('a-_9>-_6-We>@~+]f.+{_~m5++B,-!},{~1$6-We>-\_8>+'a+\S}/

Experimente online

Visão geral:

Estou usando um sistema de coordenadas que se parece com a..f e 1..6 no lado esquerdo, estendido sem dobrar, com letras substituídas por números e alterado para ser baseado em 0 (b3 → [1 2], g1 → [6 1], k3 → [9 6]). Os movimentos relativos neste sistema são [1 3], [2 -1], [2 3] e seus reflexos (negativos e trocados, por exemplo, [1 3] → [-1 -3], [3 1], [- 3 -1]). Uma posição [xy] resultante é válida se [xyz] ⊂ [0 1 .. 10] em que z = x-y + 5.

Dyalog APL, 72 bytes

(6=|×/t,-/t←↑j[a⍳⊂⍞]-j←⊃,/i,¨¨↓∘i¨i-6)/a←⊃,/(11⍴⎕a~'J'),∘⍕¨¨⍳¨5+i⌊⌽i←⍳11

experimentar

cria uma lista ade todas as células válidas:'A1' 'A2' ... 'L6'

a é usado para entrada e saída

constrói uma lista jdas coordenadas correspondentes aem um sistema em que o eixo x está ao A6-L1longo de y ao longoF1-F11

uma terceira coordenada imaginária é a diferença dos dois primeiros

se a célula de entrada é convertida em cordas 0 0 0, um cavaleiro pode se mover para aquelas células cujo produto das cordas é 6 ou -6

Python 3.6, 149

H='abcdefghikl'
lambda f,r:[H[i]+str(j)for i,j in[(H.find(f)+p%4*s,int(r)+p//4)for p in[9,6,-1,-5,-11,-10]for s in(1,-1)]if 0<i<11if 0<j<12-abs(6-i)]

Uma função anônima chamada com duas strings para o arquivo e a classificação; retorna uma lista de strings.

Ungolfed:

def h(f,r):
    H='abcdefghikl'

    A = []
    for p in[9,6,-1,-5,-11,-10]:
        for s in(1,-1):
            i = H.find(f) + p%4*s
            j = int(r) + p//4
            A.append(i, j)

    B = []
    for i,j in A:
        if 0 < i < 11 and 0 < j < 12 - abs(6 - i):
            B.append(H[i] + str(j))

    return B