J'ai récemment joué à travers " The Weaver " et je pense que cela présente un défi intéressant pour le code-golf .

Prémisse:

The Weaver est un jeu dans lequel on vous donne un certain nombre de rubans provenant de 2 directions à 90 degrés et votre objectif est de les échanger à certaines intersections pour obtenir une sortie souhaitée.

   Comme ceci: Ceci est un échange: Ce n'est pas:

Contribution:

3 tableaux:

• Rubans supérieurs (de gauche à droite)
• Rubans gauches (de haut en bas)
• Les coordonnées des intersections à échanger

Production:

2 tableaux:

• Rubans inférieurs (de gauche à droite)
• Rubans droits (de haut en bas)

Exemples:

Je vais utiliser l'image ci-dessus comme premier exemple:

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

Ce qui se produit:

   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

Où •représente un échange.

Production: [r, b, r], [y, y, b]

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

Ce qui se produit:

   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

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

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

Ce qui se produit:

   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

Production: [c, b], [b, a, a]

Remarques:

• Les exemples montrent les coordonnées données comme (row, column)si vous pouviez les prendre comme (column, row).
• La rangée du haut et la colonne de gauche peuvent avoir des rubans de la même couleur
• La planche peut être rectangulaire
• Toutes les coordonnées seront non négatives ( >=0) (ou strictement positives ( >=1) si vous choisissez 1-indexation)
• Ignorez les swaps qui sont en dehors du forum
• Vous pouvez choisir de travailler avec des lettres ( [a-zA-Z]), des entiers ( [0-9]) ou les deux
• Les rubans de votre sortie doivent correspondre exactement aux rubans de l'entrée ( a -> a)
• Vous pouvez supposer que la liste des swaps est triée comme vous le souhaitez, tant qu'elle est cohérente (si vous le faites, veuillez spécifier comment elle doit être triée)
• Vous pouvez prendre les coordonnées d'échange comme 0 ou 1 indexées
• Les failles par défaut sont interdites

Plus d'exemples:

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]

Le dernier exemple concerne ce cas (si cela facilite la visualisation):

Il s'agit de code-golf, donc la réponse la plus courte en octets pour chaque langue l'emporte.

Python 3 , 74 octets

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]

Essayez-le en ligne!

Nécessite ld'être trié par ordre lexicographique. aet bsont des listes de caractères représentant (ruban gauche, ruban supérieur).

Renvoie en modifiant la liste aet b.

Gelée , 37 35 30 octets

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

Essayez-le en ligne!

Programme dyadique, prenez la liste d'indexation 0 d'index de swap comme argument de gauche (trié dans l'ordre lexicographique inverse) et (ruban de gauche, ruban du haut) comme argument de droite. Renvoie (ruban droit, ruban inférieur).

La gelée est une langue tacite. Il n'y a (presque) aucune variable avec laquelle travailler, donc tout ce qui implique plus de deux variables à la fois est un gâchis.

Le premier lien prend [l,t]comme argument de gauche, [x,y](indexation 0) comme argument de droite, et revient [l,t]avec l[x]et r[y]échangé.

ṙ "z0U1¦Zḟ 0 €" N}
ṙ "Zip avec rotation. Valeur actuelle:` [l ṙ x, t ṙ y] `
                   (donc l [x] et r [x] deviennent respectivement l [0] et r [0])
  z0 Zip, remplir avec 0. Les éléments aux (nouveaux) indices correspondants sont
                   appariés ensemble, avec 0 comme remplissage.
    U1¦ Inverse la paire à l'indice «1» (premier indice).
       Zḟ € 0 Zip à nouveau et filtrez les "0", annulez efficacement le z0.
           ṙ "N} Zip avec rotation par montant de décalage négatif, inverse de` ṙ "`.

Donc, fondamentalement " U1¦sous ṙ"z0".

Le deuxième lien filtre simplement les indices OoB ( <Ạ¥Ðf L€), ajoute le deuxième argument ( ⁹ṭ), inverse ( Ṛ) et réduit ç(similaire à celui de Haskell foldl)

Python 2 , 193 octets

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]

Essayez-le en ligne!

Prend des coordonnées de swap indexées à 1

APL (Dyalog Classic) , 31 30 octets

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

Essayez-le en ligne!

L'argument gauche est une paire de vecteurs de caractères - rubans gauches et rubans supérieurs. L'argument de droite est un vecteur de paires de coordonnées - emplacements de permutation. Renvoie une paire de rubans droits et des rubans inférieurs. (Notez que contrairement aux exemples, j'utilise l'ordre en haut à gauche et en bas à droite pour les rubans afin d'être cohérent avec l'ordre de l'axe ligne-col dans les coordonnées.)

Les swaps doivent être triés de manière à ce qu'un swap en haut à gauche d'un autre vienne avant après . Si deux swaps se trouvent en bas à gauche / en haut à droite l'un de l'autre, leur ordre n'a pas d'importance.

EDIT: enregistré un octet ( ⌽) en exigeant l'ordre inverse des swaps dans l'entrée

Javascript, 87 76 62 octets

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

Essayez-le en ligne!

Même algorithme trivial que la réponse Python 3. Utilise les tableaux comme tuples de coordonnées. Nécessite que les couleurs du ruban soient désignées par des valeurs véridiques. Nécessite que les coordonnées soient partiellement ordonnées afin que cela x1,y1précède x2,y2si l'un x1 < x2 && y1 = y2ou l' autre x1 = x2 && y1 < y2. Renvoie en modifiant les tableaux d'entrée.

Rubis , 56 54 octets

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

Essayez-le en ligne!

Un port de la réponse Python 3 de user202729 avec quelques astuces rubis

Les coordonnées doivent être triées lexicographiquement