Gli scacchi esagonali descrivono una famiglia di varianti di scacchi giocate su una scacchiera in cui le celle sono esagoni invece dei quadrati tradizionali. Esistono molte varianti del genere; in questa sfida ci concentreremo sulla variante di Gliński, che è la più comune.

Il tabellone è composto da tre colori (in modo che lo stesso colore non condivida un bordo), con i bordi degli esagoni rivolti verso i giocatori. La scheda dispone di 11 file, contrassegnate da lettere atramite l(lettera jnon viene utilizzato), e 11 gradi (che piegano 60 ° al di file f). Ranghi 1attraverso 6contengono ciascuno 11 celle, rango 7ha 9 cellule, rango 8ha 7, e così via. Il grado 11contiene esattamente una cella: f11 . (Se aiuta, pensa ad ogni rango come a formare una "V" molto ampia.)

Ecco un'immagine di esempio della scacchiera, con il cavaliere sulla cella centrale. Le celle contrassegnate da un punto sono le mosse legali di questo particolare cavaliere. Il cavaliere si muove in modo simile agli scacchi "normali", due volte in giù. In termini di scacchi esagonali, è una mossa ortogonale (attraverso un bordo), quindi una mossa diagonale nella stessa direzione (la mossa più vicina allo stesso colore). Ad esempio con il cavaliere in basso, una mossa ortogonale "su" verso il marrone chiaro è quindi accompagnata da una mossa diagonale "su e destra" o "su e sinistra" verso il marrone chiaro più vicino.

_{Dal pubblico dominio tramite https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Questo cavaliere è posizionato su f6 e le mosse legali sono così

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

Ingresso

Un singolo input che dà la cella di partenza del nostro cavaliere. Questo può essere come una singola stringa "b6", come due stringhe "b", "6", ecc., In qualsiasi formato conveniente . Le lettere di input possono essere maiuscole o minuscole - a scelta.

Produzione

Un elenco delle mosse valide che un cavaliere in quella posizione può fare. Questo può essere come una matrice di stringhe, una singola stringa con un delimitatore inequivocabile e coerente, stringhe separate per newline, ecc., Qualsiasi cosa sia più conveniente. L'output non deve necessariamente essere in ordine, e può essere in maiuscolo o in minuscolo - la tua scelta.

Regole

• Supponiamo che non ci siano altri pezzi sul tabellone o che interferiscano con le mosse. Ci stiamo concentrando solo sul cavaliere.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un link a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

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 byte

Prende il file Fcome carattere e il rango Rcome numero intero nella sintassi del curry (F)(R). Restituisce una matrice di stringhe.

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)

Come?

Step # 1: converti file / classifica in coordinate cartesiane

Convertiamo le coordinate esagonali degli scacchi in coordinate cartesiane (x, y) con x in [0 .. 10] e y in [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               

Passaggio 2: applicare i vettori di spostamento

Di seguito è riportato l'elenco dei vettori di movimento nel 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)

Applichiamo ciascuno di essi alle coordinate di origine (x, y) e otteniamo un elenco di coordinate target (X, Y) .

Passaggio 3: testare le coordinate del target

Ora dobbiamo controllare quali coordinate target si trovano effettivamente all'interno del tabellone. Questo viene fatto testando X + Y e X - Y :

Le coordinate sono valide se tutti i seguenti confronti sono veri:

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

Dovremmo anche verificare che X sia in [0 .. 10] . Questo non viene fatto esplicitamente perché nons[X] è definito se non lo è, il che alla fine si traduce in un valore errato che viene filtrato.

Passaggio n. 4: riconvertire in coordinate di scacchi esagonali

Infine, le coordinate del bersaglio valide vengono riconvertite in coordinate di scacchi esagonali, usando l'inverso delle formule descritte al punto 1.

Casi test

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

Lotto. 403 byte

@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%%

Regola il sistema di coordinate, sebbene in modo diverso dalla risposta di @ Arnauld. La csubroutine sfrutta la simmetria provando il riflesso speculare di ogni mossa. (Ho anche provato a ruotare ma ci sono voluti troppi byte.)

JavaScript (ES6), 184 byte

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

Ho pensato di portare la mia soluzione Batch su ES6 per vedere come si confronta ... Non mi aspettavo che fosse così vicino ...

CJam, 77

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

Provalo online

Panoramica:

Sto usando un sistema di coordinate che assomiglia a..f e 1..6 sul lato sinistro, esteso senza piegarsi, con lettere sostituite con numeri e modificato in base a 0 (b3 → [1 2], g1 → [6 1], k3 → [9 6]). Le mosse relative in questo sistema sono [1 3], [2 -1], [2 3] e i loro riflessi (negativi e scambiati, ad esempio [1 3] → [-1 -3], [3 1], [- 3 -1]). Una posizione [xy] risultante è valida sef [xyz] ⊂ [0 1 .. 10] dove z = x-y + 5.

Dyalog APL, 72 byte

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

provare

crea un elenco adi tutte le celle valide:'A1' 'A2' ... 'L6'

a è usato sia per input che per output

crea un elenco jdelle coordinate corrispondenti ain un sistema in cui l'asse x è lungo A6-L1e y lungoF1-F11

una terza coordinata immaginaria è la differenza delle prime due

se la cella di input viene tradotta in coords 0 0 0, un cavaliere può spostarsi in quelle celle il cui prodotto di coords è 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 funzione anonima chiamata con due stringhe per il file e il rango; restituisce un elenco di stringhe.

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