Recientemente he estado jugando a través de ' The Weaver ' y creo que presenta un desafío interesante para el código golf .

Premisa:

The Weaver es un juego en el que se te dan varias cintas que vienen de 2 direcciones separadas 90 grados y tu objetivo es intercambiarlas en ciertas intersecciones para lograr el resultado deseado.

   Así: Esto es un intercambio: Esto no es:

Entrada:

3 matrices:

• Cintas superiores (de izquierda a derecha)
• Cintas izquierdas (de arriba a abajo)
• Las coordenadas de las intersecciones para intercambiar

Salida:

2 matrices:

• Cintas inferiores (de izquierda a derecha)
• Cintas derechas (de arriba a abajo)

Ejemplos:

Usaré la imagen de arriba como primer ejemplo:

Entrada: [r, y, b], [r, y, b], [(0, 1), (2, 1), (2, 2)]

Lo que pasa:

   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

Donde •representa un intercambio.

Salida: [r, b, r], [y, y, b]

Entrada: [a, b, c], [d, e, f], [(0, 0), (2, 1)]

Lo que pasa:

   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

Salida: [d, f, c], [a, e, b]

Entrada: [a, b], [a, b, c], [(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1)]

Lo que pasa:

   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

Salida: [c, b], [b, a, a]

Notas:

• Los ejemplos muestran coordenadas dadas como (row, column)si pudiera tomarlas como (column, row).
• La fila superior y la columna izquierda pueden tener cintas del mismo color.
• El tablero puede ser rectangular.
• Todas las coordenadas serán no negativas ( >=0) (o estrictamente positivas ( >=1) si elige 1 indexación)
• Ignorar cualquier intercambio que esté fuera del tablero
• Puede elegir trabajar con letras ( [a-zA-Z]), enteros ( [0-9]) o ambos
• Las cintas en su salida deben coincidir exactamente con las cintas en la entrada ( a -> a)
• Puede suponer que la lista de swaps está ordenada de la manera que desee, siempre que sea coherente (si lo hace, especifique cómo se debe ordenar)
• Puede tomar las coordenadas de intercambio como 0 o 1 indexado
• Las lagunas predeterminadas están prohibidas

Más ejemplos:

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]

El último ejemplo se relaciona con este caso (si eso facilita la visualización):

Este es el código de golf, por lo que gana la respuesta más corta en bytes para cada idioma.

Python 3 , 74 bytes

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]

Pruébalo en línea!

Requiere lser ordenado en orden lexicográfico. ay bson listas de caracteres que representan (cinta izquierda, cinta superior).

Devuelve modificando la lista ay b.

Gelatina , 37 35 30 bytes

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

Pruébalo en línea!

Programa dinámico, tome la lista de indexación 0 de los índices de intercambio como argumento izquierdo (ordenado en orden lexicográfico inverso) y (cinta izquierda, cinta superior) como argumento derecho. Devoluciones (cinta derecha, cinta inferior).

Jelly es un lenguaje tácito. No hay (casi) ninguna variable con la que trabajar, por lo que hacer cualquier cosa implica más de dos variables a la vez es un desastre.

El primer enlace toma [l,t]como argumento izquierdo, [x,y](indexación 0) como argumento derecho, y regresa [l,t]con l[x]yr[y] intercambiado.

ṙ "z0U1¦Zḟ € 0ṙ" N}
ṙ "Zipwith rotar. Valor actual:` [l ṙ x, t ṙ y] `
                   (entonces l [x] yr [x] se convierte en l [0] yr [0] respectivamente)
  z0 Zip, rellene con 0. Los elementos en los índices (nuevos) correspondientes son
                   emparejados juntos, con 0 como relleno.
    U1¦ Invierta el par en el índice `1` (primer índice).
       Zḟ € 0 Vuelva a comprimir y filtre los `0`s, deshaga efectivamente el z0.
           ṙ "N} Zipwith rotar por cantidad de desplazamiento negativo, reverso de` ṙ "`.

Así que básicamente " U1¦debajo ṙ"z0".

El segundo enlace simplemente filtra los índices OoB ( <Ạ¥Ðf L€), agrega el segundo argumento ( ⁹ṭ), reverse ( Ṛ) y reduce ç(similar al de Haskell foldl)

Python 2 , 193 bytes

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]

Pruébalo en línea!

Toma coordenadas de intercambio indexadas 1

APL (Dyalog Classic) , 31 30 bytes

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

Pruébalo en línea!

El argumento de la izquierda es un par de vectores de caracteres: cintas izquierdas y cintas superiores. El argumento correcto es un vector de pares de coordenadas: ubicaciones de intercambio. Devuelve un par de cintas derechas y cintas inferiores. (Tenga en cuenta que, a diferencia de los ejemplos, utilizo el orden arriba a la izquierda y abajo a la derecha para las cintas para que sea coherente con el orden del eje fila-col en las coordenadas).

Los intercambios deben ordenarse de modo que un intercambio en la esquina superior izquierda de otro ocurra antes y después ella. Si hay dos intercambios en la esquina inferior izquierda / superior derecha, su orden no importa.

EDITAR: guardado un byte ( ⌽) al requerir el orden inverso de los intercambios en la entrada

Javascript, 87 76 62 bytes

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

Pruébalo en línea!

El mismo algoritmo trivial que la respuesta de Python 3. Utiliza matrices como tuplas de coordenadas. Requiere que los colores de la cinta sean designados por valores verdaderos. Requiere que las coordenadas se ordenen parcialmente, de modo que x1,y1viene antes x2,y2si x1 < x2 && y1 = y2o x1 = x2 && y1 < y2. Devuelve modificando las matrices de entrada.

Ruby , 56 54 bytes

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

Pruébalo en línea!

Un puerto de la respuesta Python 3 de user202729 con algunos trucos de rubí

Las coordenadas deben ser ordenadas lexicográficamente