Les échecs hexagonaux décrivent une famille de variantes d'échecs jouées sur un plateau où les cellules sont des hexagones au lieu des carrés traditionnels. Il existe de nombreuses variantes de ce type; dans ce défi, nous nous concentrerons sur la variante de Gliński, qui est la plus courante.

Le plateau est composé de trois couleurs (pour que la même couleur ne partage pas de bord), les bords des hexagones faisant face aux joueurs. La carte a 11 fichiers, marqués par des lettres à atravers l(la lettre jn'est pas utilisée), et 11 rangs (qui se plient à 60 ° au fichier f). Les rangs 1dans 6chacun contiennent 11 cellules, le rang 7a 9 cellules, le rang 8a 7, etc. Le rang 11contient exactement une cellule: f11 . (Si cela peut aider, pensez à chaque rang comme faisant une forme de "V" très large.)

Voici un exemple d'image du tableau, avec le chevalier sur la cellule centrale. Les cellules marquées d'un point sont les mouvements légaux de ce chevalier particulier. Le chevalier se déplace d'une manière similaire aux échecs "normaux", deux-en-un et un-dessus. En termes d'échecs hexagonaux, c'est un mouvement orthogonal (à travers un bord), puis un mouvement diagonal dans la même direction (le mouvement le plus proche de la même couleur). Par exemple avec le chevalier ci-dessous, un mouvement orthogonal "vers le haut" au brun clair est alors accompagné d'un mouvement diagonal "vers le haut et vers la droite" ou "vers le haut et vers la gauche" vers le brun clair le plus proche.

_{Depuis le domaine public via https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Ce chevalier est positionné à f6 et les mouvements légaux sont donc

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

Contribution

Une seule entrée donnant la cellule de départ de notre chevalier. Cela peut être une chaîne unique "b6", deux chaînes "b", "6", etc., dans n'importe quel format pratique . Les lettres d'entrée peuvent être en majuscules ou en minuscules - votre choix.

Production

Une liste des mouvements valides qu'un chevalier à cet endroit peut effectuer. Cela peut être un tableau de chaînes, une chaîne unique avec un délimiteur sans ambiguïté et cohérent, des chaînes séparées par des sauts de ligne, etc., selon ce qui est le plus pratique. La sortie n'a pas nécessairement besoin d'être triée et peut être en majuscule ou en minuscule - votre choix.

Règles

• Supposons qu'aucune autre pièce ne se trouve sur le plateau ou n'interfère avec les mouvements. Nous nous concentrons uniquement sur le chevalier.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

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 octets

Prend le fichier Fcomme un caractère et le rang Rcomme un entier dans la syntaxe de curry (F)(R). Renvoie un tableau de chaînes.

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)

Comment?

Étape # 1: convertir le fichier / rang en coordonnées cartésiennes

Nous convertissons les coordonnées d'échecs hexagonales en coordonnées cartésiennes (x, y) avec x dans [0 .. 10] et y dans [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               

Étape # 2: appliquez les vecteurs de déplacement

Ci-dessous la liste des vecteurs de déplacement dans le système cartésien:

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

Nous appliquons chacun d'eux aux coordonnées source (x, y) et obtenons une liste de coordonnées cibles (X, Y) .

Étape # 3: tester les coordonnées cibles

Nous devons maintenant vérifier quelles coordonnées cibles sont réellement situées à l'intérieur du plateau. Cela se fait en testant X + Y et X - Y :

Les coordonnées sont valides si toutes les comparaisons suivantes sont vraies:

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

Nous devons également vérifier que X est dans [0 .. 10] . Cela n'est pas fait explicitement car s[X]n'est pas défini si ce n'est pas le cas, ce qui entraîne finalement une valeur falsifiée qui est filtrée.

Étape # 4: reconvertissez en coordonnées d'échecs hexagonales

Enfin, les coordonnées cibles valides sont reconverties en coordonnées d'échecs hexagonales, en utilisant l'inverse des formules décrites à l'étape # 1.

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

Lot. 403 octets

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

Ajuste le système de coordonnées, bien que d'une manière différente de la réponse de @ Arnauld. Le csous-programme profite de la symétrie en essayant la réflexion miroir de chaque mouvement. (J'ai également essayé de faire tourner mais cela prenait trop d'octets.)

JavaScript (ES6), 184 octets

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

J'ai pensé porter ma solution Batch sur ES6 pour voir comment elle se comparait ... Je ne m'attendais pas à ce qu'elle soit aussi proche ...

CJam, 77

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

Essayez-le en ligne

Aperçu:

J'utilise un système de coordonnées qui ressemble à a..f et 1..6 sur le côté gauche, étendu sans flexion, avec des lettres remplacées par des chiffres et changé pour être basé sur 0 (b3 → [1 2], g1 → [6 1], k3 → [9 6]). Les mouvements relatifs dans ce système sont [1 3], [2 -1], [2 3] et leurs réflexions (négatives et inversées, par exemple [1 3] → [-1 -3], [3 1], [- 3 -1]). Une position [xy] résultante est valide si [xyz] ⊂ [0 1 .. 10] où z = x-y + 5.

Dyalog APL, 72 octets

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

essayer

construit une liste ade toutes les cellules valides:'A1' 'A2' ... 'L6'

a est utilisé pour l'entrée et la sortie

construit une liste jdes coordonnées correspondantes à adans un système où l'axe x est le long A6-L1et y le longF1-F11

une troisième coordonnée imaginaire est la différence des deux premiers

si la cellule d'entrée est traduite en coordonnées 0 0 0, un chevalier peut se déplacer vers les cellules dont le produit des coordonnées est 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)]

Une fonction anonyme appelée avec deux chaînes pour le fichier et le rang; renvoie une liste de chaînes.

Non 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