Estive recentemente jogando ' The Weaver ' e acho que isso representa um desafio interessante para o código-golfe .

Premissa:

O Weaver é um jogo no qual você recebe um número de fitas vindas de 2 direções a 90 graus de distância e seu objetivo é trocá-las em determinadas interseções para obter a saída desejada.

   Assim: Isso é uma troca: Isso não é:

Entrada:

3 matrizes:

• Fitas superiores (da esquerda para a direita)
• Fitas esquerdas (de cima para baixo)
• As coordenadas das interseções para trocar

Resultado:

2 matrizes:

• Fitas inferiores (da esquerda para a direita)
• Fitas direitas (de cima para baixo)

Exemplos:

Vou usar a imagem acima como o primeiro exemplo:

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

O que acontece:

   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

Onde •representa uma troca.

Resultado: [r, b, r], [y, y, b]

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

O que acontece:

   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

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

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

O que acontece:

   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

Resultado: [c, b], [b, a, a]

Notas:

• Os exemplos mostram as coordenadas fornecidas como (row, column)se você pudesse tomá-las como (column, row).
• A linha superior e a coluna esquerda podem ter fitas da mesma cor
• A placa pode ser retangular
• Todas as coordenadas serão não-negativas ( >=0) (ou estritamente positivas ( >=1) se você escolher a indexação 1)
• Ignore todos os swaps que estão fora do quadro
• Você pode optar por trabalhar com letras ( [a-zA-Z]), números inteiros ( [0-9]) ou ambos
• As fitas na sua saída devem corresponder exatamente às fitas na entrada ( a -> a)
• Você pode presumir que a lista de trocas é classificada da maneira que desejar, desde que seja consistente (se o fizer, especifique como deve ser classificada)
• Você pode assumir as coordenadas de troca como 0 ou 1 indexado
• As brechas padrão são proibidas

Mais exemplos:

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]

O último exemplo refere-se a este caso (se isso facilita a visualização):

Isso é código-golfe, e a resposta mais curta em bytes para cada idioma vence.

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]

Experimente online!

Requer la classificação em ordem lexicográfica. ae bsão listas de caracteres que representam (faixa esquerda, faixa superior).

Retorna modificando a lista ae b.

Geléia , 37 35 30 bytes

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

Experimente online!

Programa diádico, use a lista de indexação 0 de índices de troca como argumento esquerdo (classificado em ordem lexicográfica reversa) e (faixa esquerda, faixa superior) como argumento direito. Retorna (fita direita, fita inferior).

A geléia é uma linguagem tácita. Não há (quase) nenhuma variável com a qual trabalhar; portanto, fazer qualquer coisa envolve mais de duas variáveis ​​ao mesmo tempo, é uma bagunça.

O primeiro link toma [l,t]como argumento à esquerda, [x,y](indexação 0) como argumento à direita, e retorna [l,t]com l[x]e r[y]trocado.

z "z0U1¦Zḟ 0 €" N}
Zip "Zip com rotação. Valor atual:` [l x, t y] `
                   (então l [x] er [x] se torna l [0] e r [0] respectivamente)
  z0 Zip, preencha com 0. Os elementos nos índices (novos) correspondentes são
                   emparelhados juntos, com 0 como preenchimento.
    U1 ... Inverta o par no índice `1` (primeiro índice).
       Zḟ 0 Zip novamente e filtre os `0`s, desfaz efetivamente o z0.
           N "N} Zip com rotação pelo valor do turno negativo, reverso de` ṙ "`.

Então basicamente " U1¦abaixo ṙ"z0".

O segundo link simplesmente filtra os índices OoB ( <Ạ¥Ðf L€), acrescenta o segundo argumento ( ⁹ṭ), reverse ( Ṛ) e reduz o excesso ç(semelhante ao 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]

Experimente online!

Leva coordenadas de troca indexadas 1

APL (Dyalog Classic) , 31 30 bytes

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

Experimente online!

O argumento da esquerda é um par de vetores de caracteres - fitas esquerdas e fitas superiores. O argumento certo é um vetor de pares de coordenadas - localizações de swap. Retorna um par de fitas direitas e inferiores. (Observe que, diferentemente dos exemplos, eu uso a ordem superior esquerda e inferior direita das fitas para ser consistente com a ordem do eixo linha-col nas coordenadas.)

Swaps deve ser resolvido para que uma troca para o canto superior esquerdo da outra vem antes após ele. Se dois swaps estiverem no canto inferior esquerdo / superior direito um do outro, a ordem deles não importará.

EDIT: salva um byte ( ⌽) exigindo ordem inversa de swaps na 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]]}

Experimente online!

O mesmo algoritmo trivial que a resposta do Python 3. Usa matrizes como tuplas de coordenadas. Requer que as cores da fita sejam designadas por valores reais. Requer que as coordenadas sejam parcialmente ordenadas, de modo que x1,y1seja anterior a x2,y2se x1 < x2 && y1 = y2ou x1 = x2 && y1 < y2. Retorna modificando matrizes 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}}

Experimente online!

Uma porta da resposta Python 3 do user202729 com alguns truques de rubi

As coordenadas devem ser classificadas lexicograficamente