Гексагональные шахматы описывают семейство шахматных вариантов, играемых на доске, где ячейки представляют собой шестиугольники вместо традиционных квадратов. Есть много таких вариантов; В этой задаче мы сосредоточимся на варианте Глински, который является наиболее распространенным.

Доска состоит из трех цветов (чтобы один и тот же цвет не разделял ребро), причем края шестиугольников обращены к игрокам. Плата имеет 11 файлов, помеченных буквами aчерез l(буква jне используется), и 11 рангов (которые изгибом 60 ° в файле f). Ранги 1в 6каждом содержат 11 ячеек, ранг 7имеет 9 ячеек, ранг 8имеет 7 и т. Д. Ранг 11содержит ровно одну ячейку: f11 . (Если это помогает, думайте о каждом ранге как о создании очень широкой буквы "V".)

Вот пример изображения доски с рыцарем в центре клетки. Клетки, отмеченные точкой, являются законными ходами этого конкретного рыцаря. Рыцарь движется аналогично «нормальным» шахматам, два вниз и один за. В гексагональных шахматных терминах это ортогональное движение (через ребро), затем диагональное движение в том же направлении (ближайшее движение к тому же цвету). Например, с рыцарем ниже, ортогональное движение «вверх» к светло-коричневому цвету затем сопровождается диагональным движением «вверх и вправо» или «вверх и влево» к ближайшему светло-коричневому цвету.

_{Из открытого домена через https://commons.wikimedia.org/wiki/File:Glinski_Chess_Knight.svg}

Этот рыцарь расположен на f6, и законные ходы, таким образом,

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

вход

Единственный вход, дающий стартовую ячейку нашего рыцаря. Это может быть как одна строка "b6", так и две строки "b", "6"и т. Д. В любом удобном формате . Вводимые буквы могут быть прописными или строчными - на ваш выбор.

Выход

Список действительных ходов, которые может сделать рыцарь в этом месте. Это может быть массив строк, одна строка с однозначным и непротиворечивым разделителем, отдельные строки с помощью новых строк и т. Д. - все, что наиболее удобно. Вывод не обязательно должен быть в отсортированном порядке, и может быть в верхнем или нижнем регистре - ваш выбор.

правила

• Предположим, что на доске нет других фигур или они не мешают ходам. Мы ориентируемся только на рыцаря.
• Либо полная программа или функция приемлемы. Если функция, вы можете вернуть вывод, а не распечатать его.
• Если возможно, укажите ссылку на среду онлайн-тестирования, чтобы другие люди могли опробовать ваш код!
• Стандартные лазейки запрещены.
• Это код-гольф, поэтому применяются все обычные правила игры в гольф, и выигрывает самый короткий код (в байтах).

Примеры

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 байта

Принимает файл Fкак символ и ранг Rкак целое число в синтаксисе карри (F)(R). Возвращает массив строк.

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)

Как?

Шаг № 1: преобразовать файл / ранг в декартовы координаты

Мы преобразуем гексагональные шахматные координаты в декартовы (x, y) с x в [0 .. 10] и y в [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               

Шаг № 2: применить векторы движения

Ниже приведен список векторов движения в декартовой системе:

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

Мы применяем каждую из них к исходным координатам (x, y) и получаем список целевых координат (X, Y) .

Шаг № 3: проверить координаты цели

Теперь нам нужно проверить, какие координаты цели на самом деле находятся внутри доски. Это делается путем тестирования X + Y и X - Y :

Координаты действительны, если все следующие сравнения верны:

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

Мы также должны проверить, что X находится в [0 .. 10] . Это не сделано явно, потому что s[X]не определено, если это не так, что в конечном итоге приводит к ложному значению, которое отфильтровывается.

Шаг № 4: преобразовать обратно в шестиугольные шахматные координаты

Наконец, действительные координаты цели преобразуются обратно в гексагональные шахматные координаты с использованием обратной формулы, описанной на шаге 1

Контрольные примеры

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

Batch. 403 байта

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

Корректирует систему координат, хотя и по-другому, чем ответ @ Arnauld. cПодпрограмма использует симметрию, пытаясь зеркальным отражением каждого хода. (Я также пробовал вращаться, но это заняло слишком много байтов.)

JavaScript (ES6), 184 байта

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

Я думал , что я порт моего Пакетное решение ES6 , чтобы посмотреть , как он по сравнению ... Я не ожидал , что это будет что близко ...

CJam, 77

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

Попробуйте онлайн

Обзор:

Я использую систему координат, которая выглядит как a..f и 1..6 с левой стороны, вытянутая без изгиба, с буквами, замененными на числа, и измененная на 0, основанная на (b3 → [1 2], g1 → [6 1], k3 → [9 6]). Относительные движения в этой системе: [1 3], [2 -1], [2 3] и их отражения (отрицательные и поменялись местами, например, [1 3] → [-1 -3], [3 1], [- 3 -1]). Результирующая позиция [xy] действительна тогда и только тогда, когда [xyz] ⊂ [0 1 .. 10] где z = x-y + 5.

Dyalog APL, 72 байта

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

пытаться

строит список aвсех допустимых ячеек:'A1' 'A2' ... 'L6'

a используется как для ввода, так и для вывода

строит список jсоответствующих координат aв системе, где ось х находится вдоль, A6-L1а у - вдольF1-F11

мнимая третья координата - это разность первых двух

если входная ячейка переведена в координаты 0 0 0, рыцарь может перейти к тем ячейкам, чье произведение координат равно 6 или -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)]

Вызывается анонимная функция с двумя строками для файла и ранга; возвращает список строк.

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