El ajedrez hexagonal describe una familia de variantes de ajedrez que se juegan en un tablero donde las celdas son hexágonos en lugar de los cuadrados tradicionales. Hay muchas variantes de este tipo; En este desafío nos centraremos en la variante de Gliński, que es la más común.

El tablero está compuesto de tres colores (para que el mismo color no comparta un borde), con los bordes de los hexágonos hacia los jugadores. El tablero tiene 11 archivos, marcados por las letras aa través de l(carta jno se utiliza), y 11 filas (que se doblan 60 ° en el archivo f). Los rangos a 1través de 6cada uno contienen 11 celdas, el rango 7tiene 9 celdas, el rango 8tiene 7, y así sucesivamente. El rango 11contiene exactamente una celda: f11 . (Si ayuda, piense en cada rango como una forma de "V" muy amplia).

Aquí hay una foto de ejemplo del tablero, con el caballero en la celda central. Las celdas marcadas con un punto son los movimientos legales de este caballero en particular. El caballero se mueve de manera similar al ajedrez "normal", dos abajo y uno encima. En términos de ajedrez hexagonal, es un movimiento ortogonal (a través de un borde), luego un movimiento diagonal en la misma dirección (el movimiento más cercano al mismo color). Por ejemplo, con el caballero de abajo, un movimiento ortogonal "hacia arriba" al marrón claro se acompaña de un movimiento diagonal "hacia arriba y hacia la derecha" o "hacia arriba y hacia la izquierda" hacia el marrón claro más cercano.

_{Desde el dominio público a través de https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Este caballero está posicionado en f6 y los movimientos legales son así

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

Entrada

Una sola entrada que da la celda inicial de nuestro caballero. Esto puede ser como una sola cadena "b6", como dos cadenas "b", "6", etc., en cualquier formato conveniente . Las letras de entrada pueden ser mayúsculas o minúsculas: usted elige.

Salida

Una lista de los movimientos válidos que puede hacer un caballero en esa ubicación. Esto puede ser como un conjunto de cadenas, una sola cadena con un delimitador inequívoco y consistente, cadenas separadas por líneas nuevas, etc., lo que sea más conveniente. La salida no necesariamente tiene que estar en orden, y puede estar en mayúsculas o minúsculas, según su elección.

Reglas

• Suponga que no hay otras piezas en el tablero o que interfieren con los movimientos. Nos estamos centrando solo en el caballero.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

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

Toma el archivo Fcomo un personaje y el rango Rcomo un entero en la sintaxis de curry (F)(R). Devuelve una matriz de cadenas.

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)

¿Cómo?

Paso # 1: convierte el archivo / rango a coordenadas cartesianas

Convertimos las coordenadas hexagonales de ajedrez en coordenadas cartesianas (x, y) con x en [0 .. 10] e y en [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               

Paso # 2: aplica los vectores de movimiento

A continuación se muestra la lista de los vectores de movimiento en el 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 uno de ellos a las coordenadas de origen (x, y) y obtenemos una lista de coordenadas de destino (X, Y) .

Paso # 3: prueba las coordenadas del objetivo

Ahora necesitamos verificar qué coordenadas de objetivo se encuentran realmente dentro del tablero. Esto se hace probando X + Y y X - Y :

Las coordenadas son válidas si todas las comparaciones siguientes son verdaderas:

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

También debemos verificar que X esté en [0 .. 10] . Esto no se hace explícitamente porque nos[X] está definido si no lo está, lo que finalmente da como resultado un valor falso que se filtra.

Paso # 4: convierte de nuevo a coordenadas hexagonales de ajedrez

Finalmente, las coordenadas de objetivo válidas se convierten de nuevo en coordenadas de ajedrez hexagonales, utilizando el inverso de las fórmulas descritas en el paso 1.

Casos de prueba

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 el sistema de coordenadas, aunque de manera diferente a la respuesta de @ Arnauld. La csubrutina aprovecha la simetría al intentar el reflejo espejo de cada movimiento. (También intenté rotar pero eso tomó demasiados 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))

Pensé en portar mi solución Batch a ES6 para ver cómo se comparaba ... No esperaba que estuviera tan cerca ...

CJam, 77

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

Pruébalo en línea

Visión general:

Estoy usando un sistema de coordenadas que se ve como a..f y 1..6 en el lado izquierdo, extendido sin doblar, con letras reemplazadas por números, y cambiado para ser basado en 0 (b3 → [1 2], g1 → [6 1], k3 → [9 6]). Los movimientos relativos en este sistema son [1 3], [2 -1], [2 3] y sus reflejos (negativos e intercambiados, p. Ej. [1 3] → [-1 -3], [3 1], [- 3 -1]). Una posición [xy] resultante es válida si f [xyz] ⊂ [0 1 .. 10] donde 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

tratar

construye una lista ade todas las celdas válidas:'A1' 'A2' ... 'L6'

a se usa tanto para entrada como para salida

construye una lista jde las coordenadas correspondientes aen un sistema donde el eje x está a lo largo de A6-L1y a lo largo de yF1-F11

una tercera coordenada imaginaria es la diferencia de las dos primeras

si la celda de entrada se traduce a coords 0 0 0, un caballero puede moverse a aquellas celdas cuyo producto de coords es 6 o -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)]

Una función anónima llamada con dos cadenas para el archivo y rango; devuelve una lista de cadenas.

Sin golf:

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