Sechseckiges Schach beschreibt eine Familie von Schachvarianten, die auf einem Brett gespielt werden, bei dem die Felder Sechsecke anstelle der traditionellen Felder sind. Es gibt viele solcher Varianten; Bei dieser Herausforderung konzentrieren wir uns auf die am häufigsten verwendete Variante von Gliński.

Das Brett besteht aus drei Farben (so dass die gleiche Farbe keine Kante hat), wobei die Kanten der Sechsecke den Spielern zugewandt sind. Das Board verfügt über 11 Dateien, gekennzeichnet durch die Buchstaben adurch l(Letter jnicht verwendet wird ), und 11 Reihen (die 60 ° biegen bei Datei f). Ränge 1durch 6enthalten jeweils 11 Zellen, Rang 7hat 9 Zellen, Rang 8hat 7, und so weiter. Der Rang 11enthält genau eine Zelle: f11 . (Wenn es hilft, stellen Sie sich vor, dass jeder Rang eine sehr breite "V" -Form hat.)

Hier ist ein Beispielbild des Bretts mit dem Ritter in der mittleren Zelle. Die mit einem Punkt markierten Felder sind die erlaubten Züge dieses bestimmten Ritters. Der Springer bewegt sich ähnlich wie "normales" Schach, Two-Down-and-One-Over. In hexagonalen Schachbegriffen handelt es sich um eine orthogonale Bewegung (über eine Kante) und dann um eine diagonale Bewegung in dieselbe Richtung (die Bewegung, die der gleichen Farbe am nächsten kommt). Zum Beispiel mit dem Ritter unten, wird eine orthogonale Bewegung "auf" zu dem hellbraunen dann von einer diagonalen Bewegung "auf und rechts" oder "auf und links" zu dem nächsten hellbraunen begleitet.

_{Aus dem öffentlichen Bereich über https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Dieser Springer steht bei f6 und die legalen Züge sind somit

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

Eingang

Eine einzige Eingabe, die die Startzelle unseres Ritters angibt. Dies kann eine einzelne Zeichenfolge "b6", zwei Zeichenfolgen "b", "6"usw. in einem beliebigen geeigneten Format sein . Die eingegebenen Buchstaben können Groß- oder Kleinbuchstaben sein - Sie haben die Wahl.

Ausgabe

Eine Liste der gültigen Züge, die ein Ritter an diesem Ort ausführen kann. Dies kann ein Array von Zeichenfolgen sein, eine einzelne Zeichenfolge mit einem eindeutigen und konsistenten Trennzeichen, getrennte Zeichenfolgen durch Zeilenumbrüche usw., je nachdem, was am bequemsten ist. Die Ausgabe muss nicht unbedingt in sortierter Reihenfolge erfolgen und kann entweder in Groß- oder Kleinbuchstaben erfolgen - Sie haben die Wahl.

Regeln

• Angenommen, keine anderen Teile sind auf dem Brett oder stören die Bewegungen. Wir konzentrieren uns nur auf den Ritter.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

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

Nimmt die Datei Fals Zeichen und den Rang Rals Ganzzahl in der aktuellen Syntax (F)(R). Gibt ein Array von Zeichenfolgen zurück.

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)

Wie?

Schritt 1: Konvertieren Sie die Datei / den Rang in kartesische Koordinaten

Wir konvertieren die hexagonalen Schachkoordinaten in kartesische Koordinaten (x, y) mit x in [0 .. 10] und 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               

Schritt 2: Übernehmen Sie die Bewegungsvektoren

Unten ist die Liste der Bewegungsvektoren im kartesischen System:

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

Wir wenden jede auf die Quellkoordinaten (x, y) an und erhalten eine Liste der Zielkoordinaten (X, Y) .

Schritt 3: Testen Sie die Zielkoordinaten

Wir müssen jetzt überprüfen, welche Zielkoordinaten sich tatsächlich innerhalb der Tafel befinden. Dies erfolgt durch Testen von X + Y und X - Y :

Die Koordinaten sind gültig, wenn alle folgenden Vergleiche zutreffen:

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

Wir sollten auch sicherstellen, dass X in [0 .. 10] ist . Dies wird nicht explizit gemacht , weil s[X]ist nicht definiert , wenn es nicht ist, was schließlich in einem falsy Wert führt , die herausgefiltert wird.

Schritt # 4: Konvertieren Sie zurück in hexagonale Schachkoordinaten

Schließlich werden die gültigen Zielkoordinaten unter Verwendung der Umkehrung der in Schritt 1 beschriebenen Formeln zurück in hexagonale Schachkoordinaten umgewandelt.

Testfälle

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

Stapel. 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%%

Passt das Koordinatensystem an, allerdings anders als bei @ Arnauld. Die cSubroutine nutzt die Symmetrie aus, indem sie die Spiegelreflexion jeder Bewegung versucht. (Ich habe auch versucht zu drehen, aber das hat zu viele Bytes gekostet.)

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

Ich dachte, ich würde meine Batch-Lösung auf ES6 portieren, um zu sehen, wie es verglichen wird ... Ich hätte nicht erwartet, dass es so eng wird ...

CJam, 77

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

Probieren Sie es online aus

Überblick:

Ich verwende ein Koordinatensystem, das wie folgt aussieht: a..f und 1..6 auf der linken Seite, ohne Biegung verlängert, Buchstaben durch Zahlen ersetzt und in 0-basiert geändert (b3 → [1 2], g1) → [6 1], k3 → [9 6]). Die relativen Bewegungen in diesem System sind [1 3], [2 -1], [2 3] und ihre Reflexionen (negativ und vertauscht, zB [1 3] → [-1 -3], [3 1], [- 3 -1]). Eine resultierende [xy] -Position ist gültig, wenn [xyz] ⊂ [0 1 .. 10] ist, wobei 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

Versuchen

erstellt eine Liste aaller gültigen Zellen:'A1' 'A2' ... 'L6'

a wird sowohl für die Eingabe als auch für die Ausgabe verwendet

Erstellt eine Liste jder entsprechenden Koordinaten ain einem System, in dem die x-Achse entlang A6-L1und die y- Achse entlang istF1-F11

eine imaginäre dritte Koordinate ist die Differenz der ersten beiden

Wenn die Eingabezelle in Koordinaten übersetzt wird 0 0 0, kann sich ein Ritter zu den Zellen bewegen, deren Produkt aus Koordinaten 6 oder -6 ist

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

Eine anonyme Funktion, die mit zwei Zeichenfolgen für die Datei und den Rang aufgerufen wird. gibt eine Liste von Zeichenketten zurück.

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