Ostatnio grałem w „ The Weaver ” i myślę, że stanowi to interesujące wyzwanie dla golfa kodowego .

Przesłanka:

Weaver to gra, w której dostajesz wiele wstążek pochodzących z 2 kierunków w odstępie 90 stopni, a Twoim celem jest zamiana ich na określonych skrzyżowaniach, aby osiągnąć pożądany wynik.

   W ten sposób: To jest zamiana: To nie jest:

Wejście:

3 tablice:

• Górne wstążki (od lewej do prawej)
• Lewe wstążki (od góry do dołu)
• Współrzędne skrzyżowań do zamiany

Wynik:

2 tablice:

• Dolne wstążki (od lewej do prawej)
• Prawa wstążka (od góry do dołu)

Przykłady:

Użyję powyższego obrazu jako pierwszego przykładu:

Wejście: [r, y, b], [r, y, b], [(0, 1), (2, 1), (2, 2)]

Co się dzieje:

   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

Gdzie •reprezentuje zamianę.

Wynik: [r, b, r], [y, y, b]

Wejście: [a, b, c], [d, e, f], [(0, 0), (2, 1)]

Co się dzieje:

   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

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

Wejście: [a, b], [a, b, c], [(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1)]

Co się dzieje:

   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

Wynik: [c, b], [b, a, a]

Uwagi:

• Przykłady pokazują podane współrzędne, tak (row, column)jakbyś mógł je przyjąć (column, row).
• Górny rząd i lewa kolumna mogą mieć wstążki tego samego koloru
• Tablica może być prostokątna
• Wszystkie współrzędne będą nieujemne ( >=0) (lub ściśle dodatnie ( >=1), jeśli wybierzesz indeksowanie 1)
• Zignoruj ​​wszelkie zamiany znajdujące się poza planszą
• Możesz wybrać pracę z literami ( [a-zA-Z]), liczbami całkowitymi ( [0-9]) lub obydwoma
• Taśmy wyjściowe muszą dokładnie pasować do wstążek na wejściu ( a -> a)
• Możesz założyć, że lista zamian jest posortowana w dowolny sposób, pod warunkiem, że jest spójna (jeśli tak, proszę określić, w jaki sposób powinna być posortowana)
• Możesz przyjąć współrzędne wymiany jako indeksowane 0 lub 1
• Domyślne luki są zabronione

Więcej przykładów:

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]

Ostatni przykład dotyczy tego przypadku (jeśli to ułatwia wizualizację):

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach dla każdego języka.

Python 3 , 74 bajty

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]

Wypróbuj online!

Wymaga lsortowania w porządku leksykograficznym. ai bsą to listy znaków reprezentujących (lewa wstążka, górna wstążka).

Zwraca, modyfikując listę ai b.

Galaretka , 37 35 30 bajtów

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

Wypróbuj online!

Program dynamiczny, weź 0-indeksującą listę indeksów wymiany jako lewy argument (posortowany w odwrotnej kolejności leksykograficznej) i (lewą wstążkę, górną wstążkę) jako prawy argument. Zwraca (prawa wstążka, dolna wstążka).

Galaretka to język milczący. Nie ma (prawie) żadnej zmiennej do pracy, więc robienie czegokolwiek wymaga więcej niż dwóch zmiennych naraz.

Pierwszy człon wykonuje [l,t]jako lewego argumentu [x,y](0 indeksowania) jako prawym argumencie, i powrót [l,t]do l[x]i r[y]wymieniane.

ṙ "z0U1¦Zḟ 0 €" N}
ṙ "Zipwith rotate. Aktualna wartość:` [l ṙ x, t ṙ y] `
                   (więc l [x] ir [x] staje się odpowiednio l [0] i r [0])
  z0 Zip, wypełnij 0. Elementy o odpowiednich (nowych) indeksach to
                   sparowane razem, z 0 jako wypełniaczem.
    U1¦ Odwróć parę przy indeksie „1” (pierwszy indeks).
       0 € Z powrotem Zip i odfiltruj „0”, skutecznie cofnij Z0.
           ṙ „N} Zipz obracaniem o wartość przesunięcia ujemnego, do tyłu od„ ṙ ”.

Więc w zasadzie „ U1¦pod ṙ"z0”.

Drugi link po prostu odfiltrowuje indeksy OoB ( <Ạ¥Ðf L€), dołącza drugi argument ( ⁹ṭ), reverse ( Ṛ) i redukuje ç(podobnie jak w przypadku Haskella foldl)

Python 2 , 193 bajtów

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]

Wypróbuj online!

Pobiera 1-indeksowane współrzędne wymiany

APL (Dyalog Classic) , 31 30 bajtów

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

Wypróbuj online!

Lewy argument to para wektorów znaków - lewe wstążki i górne wstążki. Właściwym argumentem jest wektor par współrzędnych - lokalizacji zamiany. Zwraca parę prawych wstążek i dolnych wstążek. (Zauważ, że inaczej niż w przykładach, używam kolejności lewy górny i prawy dolny dla wstążek, aby zachować spójność z kolejnością osi rzędów-kolumn we współrzędnych.)

Swapy musi być uporządkowane tak, że zamiana na lewym górnym rogu innego przychodzi zanim po niego. Jeśli dwie wymiany znajdują się w lewym dolnym rogu / prawym górnym rogu, ich kolejność nie ma znaczenia.

EDYCJA: zapisano jeden bajt ( ⌽), wymagając odwrotnej kolejności zamiany w danych wejściowych

JavaScript, 87 76 62 bajtów

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

Wypróbuj online!

Ten sam trywialny algorytm jak odpowiedź na Python 3. Używa tablic jako krotek współrzędnych. Wymaga, aby kolory wstążki były oznaczone prawdziwymi wartościami. Wymaga częściowego uporządkowania współrzędnych, aby pojawiło się x1,y1wcześniej, x2,y2jeśli któryś x1 < x2 && y1 = y2lub x1 = x2 && y1 < y2. Zwraca przez modyfikację tablic wejściowych.

Rubin , 56 54 bajtów

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

Wypróbuj online!

Port odpowiedzi Python 3 użytkownika202729 z kilkoma rubinowymi sztuczkami

Współrzędne muszą być posortowane leksykograficznie