Я недавно играл в « The Weaver », и я думаю, что это представляет интересную проблему для code-golf .

Предпосылка:

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

   Как это: это обмен: это не

Входные данные:

3 массива:

• Верхние ленты (слева направо)
• Левые ленты (сверху вниз)
• Координаты перекрестков для обмена

Выход:

2 массива:

• Нижние ленты (слева направо)
• Правые ленты (сверху вниз)

Примеры:

Я буду использовать приведенное выше изображение в качестве первого примера:

Входные данные: [r, y, b], [r, y, b], [(0, 1), (2, 1), (2, 2)]

Что происходит:

   r   y   b
   r   y   b
r r r r•y y y y
   r   r   b
y y y y y y y y
   r   r   b
b b b b•r r•b b
   r   b   r
   r   b   r

Где •представляет собой своп.

Выход: [r, b, r], [y, y, b]

Входные данные: [a, b, c], [d, e, f], [(0, 0), (2, 1)]

Что происходит:

   a   b   c
   a   b   c
d d•a a a a a a
   d   b   c
e e e e e e e e
   d   b   c
f f f f•b b b b
   d   f   c
   d   f   c

Выход: [d, f, c], [a, e, b]

Входные данные: [a, b], [a, b, c], [(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1)]

Что происходит:

   a   b
   a   b
a a a a•b b
   a   a
b b•a a•a a
   b   a
c c•b b•a a
   c   b
   c   b

Выход: [c, b], [b, a, a]

Примечания:

• Примеры показывают координаты, как (row, column)если бы вы могли принять их как (column, row).
• Верхний ряд и левый столбец могут иметь ленты одного цвета
• Доска может быть прямоугольной
• Все координаты будут неотрицательными ( >=0) (или строго положительными ( >=1), если вы выберете 1-индексацию)
• Проигнорируйте любые обмены, которые находятся вне доски
• Вы можете работать с буквами ( [a-zA-Z]), целыми числами ( [0-9]) или обоими
• Ленты на вашем выходе должны точно соответствовать лентам на входе ( a -> a)
• Вы можете предположить, что список свопов отсортирован любым способом, если вы хотите, чтобы он был последовательным (если вы делаете, пожалуйста, укажите, как он должен быть отсортирован)
• Вы можете принять координаты свопинга как 0 или 1-индексированные
• Лазейки по умолчанию запрещены

Больше примеров:

Input:
[b], [r], []
Output:
[b], [r]

Input:
[b], [r], [(0, 0)]
Output:
[r], [b]

Input:
[r, p, y], [r, y, p], [(0, 0), (1, 2), (2, 1), (3, 2)]
Output:
[r, p, y], [r, y, p]

Input:
[b, y, o, r],
[r, o, b, y],
[(0, 0), (2, 0), (3, 2)]
Output:
[b, y, y, r],
[b, o, r, o]

Последний пример относится к этому случаю (если это облегчает визуализацию):

Это код-гольф, поэтому выигрывает самый короткий ответ в байтах для каждого языка.

Python 3 , 74 байта

def g(a,b,l):
 for x,y in l:
  if x<len(a)and y<len(b):a[x],b[y]=b[y],a[x]

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

Требуется lотсортировать в лексикографическом порядке. aи bявляются списками символов, представляющих (левая лента, верхняя лента).

Возвращает путем изменения списка aи b.

Желе , 37 35 30 байт

ṙ"z0U1¦Zḟ€0ṙ"N}
<Ạ¥ÐfL€}⁹ṭṚç/Y

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

Диадическая программа, принимает 0-индексный список индексов подкачки в качестве левого аргумента (отсортированный в обратном лексикографическом порядке) и (левая лента, верхняя лента) в качестве правого аргумента. Возвращает (правая лента, нижняя лента).

Желе это молчаливый язык. Нет (почти) никакой переменной для работы, поэтому выполнение чего-либо требует более двух переменных одновременно - беспорядок.

Первая ссылка принимает в [l,t]качестве своего левого аргумента [x,y](0-индексирование) в качестве правого аргумента и возвращает [l,t]с помощью l[x]и r[y]обменивается.

¨R "z0U1|Zḟ € 0R" N}
Z "Zipwith rotate. Текущее значение:` [l ṙ x, t ṙ y] `
                   (поэтому l [x] и r [x] становятся l [0] и r [0] соответственно)
  z0 Zip, заполните 0. Элементы с соответствующими (новыми) индексами
                   в паре, с 0 в качестве наполнителя.
    U1¦ Обратная пара по индексу `1` (первый индекс).
       Zḟ € 0 Зипните снова и отфильтруйте `0`, эффективно отмените z0.
           N "N} Zip с вращением на отрицательную величину смещения, противоположную` ṙ "`.

Так что в основном « U1¦под ṙ"z0».

Вторая ссылка просто отфильтровывает индексы OoB ( <Ạ¥Ðf L€), добавляет второй аргумент ( ⁹ṭ), reverse ( Ṛ) и уменьшает ç(аналогично Haskell foldl)

Python 2 , 193 байта

def f(t,l,s):
 m=[[x,y]for y in[0]+l for x in[0]+t];L=len(t)+1
 for i in range(len(m)):
  if i%L:m[i]=[m[i-L][0],m[i-1][1]][::[1,-1][(i/L,i%L)in s]]
 s=sum(m,[]);print s[2-L*2::2],s[4*L-1::2*L]

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

Принимает 1-индексированные координаты обмена

APL (Dyalog Classic) , 31 30 байт

{⊃{⌽@(0 1,¨⍺)⊢⍵}/(⍵∩,⍳≢¨⍺),⊂⍺}

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

Левый аргумент представляет собой пару символьных векторов - левые ленты и верхние ленты. Правильный аргумент - это вектор координатных пар - мест обмена. Возвращает пару правых и нижних лент. (Обратите внимание, что в отличие от примеров я использую порядок слева-вверх и справа-вниз для лент, чтобы соответствовать порядку оси строк-столбцов в координатах.)

Свопы должны быть отсортированы так, чтобы своп в верхнем левом углу другого предшествовал после него. Если два свопа находятся в нижнем левом / верхнем правом углу друг от друга, их порядок не имеет значения.

РЕДАКТИРОВАТЬ: сохранить один байт ( ⌽), требуя обратный порядок перестановок на входе

Javascript, 87 76 62 байта

(c,r,s)=>{for([i,j]of s)if(r[i]&&c[j])[r[i],c[j]]=[c[j],r[i]]}

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

Тот же тривиальный алгоритм, что и в ответе на Python 3. Использует массивы в качестве координатных кортежей. Требует, чтобы цвета ленты были обозначены истинными значениями. Требует, чтобы координаты были частично упорядочены таким образом, чтобыx1,y1 предшествовали, x2,y2если либо, x1 < x2 && y1 = y2либо x1 = x2 && y1 < y2. Возвращает путем изменения входных массивов.

Рубин , 56 54 байта

->t,l,s{s.map{|i,j|a=t[j];t[j]&&=l[i]||a;a&&l[i]&&=a}}

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

Порт ответа пользователя Python 3 пользователя 202729 с некоторыми рубиновыми трюками

Координаты должны быть лексикографически отсортированы