Sześciokątne szachy opisuje rodzinę wariantów szachów granych na planszy, gdzie komórki są sześciokątami zamiast tradycyjnych kwadratów. Istnieje wiele takich wariantów; w tym wyzwaniu skupimy się na wariancie Glińskiego, który jest najczęstszy.

Plansza składa się z trzech kolorów (aby ten sam kolor nie dzielił krawędzi), z krawędziami sześciokątów skierowanymi w stronę graczy. Na płycie znajduje się 11 plików oznaczonych literami aod l(litera jnie jest używana) i 11 stopni (które wyginają się o 60 ° w pliku f). Ranga 1przez 6każdą zawiera 11 komórek, ranga 7ma 9 komórek, ranga 8ma 7 i tak dalej. Ranga 11zawiera dokładnie jedną komórkę: f11 . (Jeśli to pomoże, pomyśl o każdej randze jako o bardzo szerokim kształcie „V”).

Oto przykładowe zdjęcie planszy z rycerzem na środkowej celi. Komórki oznaczone kropką to legalne ruchy tego konkretnego rycerza. Rycerz porusza się w podobny sposób jak „normalne” szachy, dwa w dół i jeden nad drugim. W szachach sześciokątnych jest to ruch ortogonalny (przez krawędź), a następnie ruch po przekątnej w tym samym kierunku (najbliższy ruch do tego samego koloru). Na przykład z rycerzem poniżej ruchowi ortogonalnemu „w górę” do jasnobrązowego towarzyszy następnie ruch po przekątnej „w górę i w prawo” lub „w górę i w lewo” do najbliższego jasnobrązowego.

_{Z domeny publicznej za pośrednictwem https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Ten rycerz jest ustawiony na f6, a tym samym legalne ruchy

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

Wejście

Pojedyncze wejście, które daje komórkę początkową naszego rycerza. Może to być pojedynczy ciąg "b6", dwa ciągi "b", "6"itd. W dowolnym dogodnym formacie . Wprowadzane litery mogą być wielkie lub małe - twój wybór.

Wynik

Lista ważnych ruchów, które rycerz może wykonać w tej lokalizacji. Może to być tablica ciągów, pojedynczy ciąg znaków z jednoznacznym i spójnym ogranicznikiem, oddzielne ciągi znaków nowej linii itp., Cokolwiek jest najwygodniejsze. Dane wyjściowe niekoniecznie muszą być posortowane i mogą być pisane wielkimi lub małymi literami - twój wybór.

Zasady

• Zakładaj, że na planszy nie ma innych elementów ani nie zakłócają ruchów. Koncentrujemy się tylko na rycerzu.
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Jeśli to możliwe, dołącz link do internetowego środowiska testowego, aby inni mogli wypróbować Twój kod!
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Przykłady

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 bajty

Pobiera plik Fjako znak, a rangę Rjako liczbę całkowitą w składni curry (F)(R). Zwraca tablicę ciągów.

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)

W jaki sposób?

Krok # 1: Konwertuj plik / pozycję na współrzędne kartezjańskie

Konwertujemy sześciokątne szachowego współrzędnych kartezjańskich współrzędnych (x, y), z X w [0 .. 10] i Y w [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               

Krok # 2: zastosuj wektory ruchu

Poniżej znajduje się lista wektorów ruchu w systemie kartezjańskim:

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

Każdą z nich stosujemy do współrzędnych źródłowych (x, y) i otrzymujemy listę współrzędnych docelowych (X, Y) .

Krok # 3: Sprawdź współrzędne celu

Teraz musimy sprawdzić, które współrzędne celu faktycznie znajdują się na planszy. Odbywa się to poprzez testowanie X + Y i X - Y :

Współrzędne są poprawne, jeśli spełnione są wszystkie następujące porównania:

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

Powinniśmy również sprawdzić, czy X jest w [0 .. 10] . Nie dzieje się tak wyraźnie, ponieważs[X] jest niezdefiniowane, jeśli nie jest, co ostatecznie skutkuje falsyną wartością, która zostaje odfiltrowana.

Krok # 4: Konwertuj z powrotem na sześciokątne współrzędne szachowe

Na koniec prawidłowe współrzędne docelowe są przekształcane z powrotem w sześciokątne współrzędne szachowe, przy użyciu odwrotności wzorów opisanych w kroku # 1.

Przypadki testowe

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

Partia. 403 bajtów

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

Dostosowuje układ współrzędnych, choć w inny sposób niż odpowiedź @ Arnauld. cPodprogram wykorzystuje symetrii próbując odbicie lustrzane każdego ruchu. (Próbowałem także obracać, ale zajęło to zbyt wiele bajtów).

JavaScript (ES6), 184 bajty

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

Myślałem, że przeniosę moje rozwiązanie Batch do ES6, aby zobaczyć, jak to się porównuje ... Nie spodziewałem się, że będzie tak blisko ...

CJam, 77

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

Wypróbuj online

Przegląd:

Używam układu współrzędnych, który wygląda jak a..fi 1..6 po lewej stronie, rozszerzony bez zginania, z literami zamienionymi na liczby i zmienionymi na 0 (b3 → [1 2], g1 → [6 1], k3 → [9 6]). Względne ruchy w tym systemie to [1 3], [2 -1], [2 3] i ich odbicia (ujemne i zamienione, np. [1 3] → [-1 -3], [3 1], [- 3 -1]). Wynikowa pozycja [xy] jest poprawna iff [xyz] ⊂ [0 1 .. 10] gdzie z = x-y + 5.

Dyalog APL, 72 bajty

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

próbować

buduje listę awszystkich prawidłowych komórek:'A1' 'A2' ... 'L6'

a służy zarówno do wejścia, jak i wyjścia

buduje listę jodpowiednich współrzędnych aw układzie, w którym oś x jest wzdłuż, A6-L1ay wzdłużF1-F11

wyimaginowana trzecia współrzędna jest różnicą dwóch pierwszych

jeśli komórka wejściowa zostanie przetłumaczona na współrzędne 0 0 0, rycerz może przejść do tych komórek, których iloczyn współrzędnych wynosi 6 lub -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)]

Wywołana anonimowa funkcja z dwoma łańcuchami dla pliku i rangi; zwraca listę ciągów znaków.

Nie golfowany:

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