Saya baru-baru ini bermain melalui ' The Weaver ' dan saya pikir ini menyajikan tantangan yang menarik untuk golf kode .

Tempat:

Weaver adalah gim di mana Anda diberikan sejumlah pita yang datang dari jarak 2 arah 90 derajat dan tujuan Anda adalah menukarnya di persimpangan tertentu untuk mencapai hasil yang diinginkan.

   Seperti ini: Ini swap: Ini bukan:

Memasukkan:

3 array:

• Pita atas (kiri ke kanan)
• Pita kiri (atas ke bawah)
• Koordinat persimpangan untuk bertukar

Keluaran:

2 array:

• Pita bawah (kiri ke kanan)
• Pita kanan (atas ke bawah)

Contoh:

Saya akan menggunakan gambar di atas sebagai contoh pertama:

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

Apa yang terjadi:

   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

Dimana •merupakan swap.

Keluaran: [r, b, r], [y, y, b]

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

Apa yang terjadi:

   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

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

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

Apa yang terjadi:

   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

Keluaran: [c, b], [b, a, a]

Catatan:

• Contoh menunjukkan koordinat yang diberikan seolah- (row, column)olah Anda dapat mengambilnya sebagai (column, row).
• Baris atas dan kolom kiri mungkin memiliki pita dengan warna yang sama
• Papan bisa berbentuk persegi panjang
• Semua koordinat akan menjadi non-negatif ( >=0) (atau sangat positif ( >=1) jika Anda memilih 1-pengindeksan)
• Abaikan swap yang ada di luar papan
• Anda dapat memilih untuk bekerja dengan huruf ( [a-zA-Z]), bilangan bulat ( [0-9]) atau keduanya
• Pita dalam output Anda harus cocok dengan pita di input persis ( a -> a)
• Anda dapat mengasumsikan daftar swap disortir dengan cara apa pun yang Anda inginkan, asalkan konsisten (jika ya, sebutkan bagaimana itu harus diurutkan)
• Anda dapat mengambil koordinat swap sebagai 0 atau 1-diindeks
• Celah default dilarang

Lebih banyak contoh:

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]

Contoh terakhir terkait dengan kasus ini (jika itu membuatnya lebih mudah untuk divisualisasikan):

Ini adalah kode-golf sehingga jawaban terpendek dalam byte untuk setiap bahasa menang.

Python 3 , 74 byte

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]

Cobalah online!

Harus ldisortir dalam urutan leksikografis. adan bmerupakan daftar karakter yang mewakili (pita kiri, pita atas).

Kembali dengan mengubah daftar adan b.

Jelly , 37 35 30 byte

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

Cobalah online!

Program Dyadic, ambil daftar indeks indeks swap 0 sebagai indeks kiri (diurutkan dalam urutan leksikografis terbalik) dan (pita kiri, pita atas) sebagai argumen kanan. Pengembalian (pita kanan, pita bawah).

Jelly adalah bahasa diam-diam. Ada (hampir) tidak ada variabel untuk dikerjakan, jadi melakukan sesuatu melibatkan lebih dari dua variabel sekaligus yang berantakan.

Tautan pertama menggunakan [l,t]argumen kiri, [x,y](pengindeksan 0) sebagai argumen kanan, dan kembali [l,t]dengan l[x]dan r[y]dipertukarkan.

ṙ "z0U1¦Zḟ € 0ṙ" N}
ṙ "Zipwith rotate. Nilai saat ini:` [l ṙ x, t ṙ y] `
                   (jadi l [x] dan r [x] masing-masing menjadi l [0] dan r [0])
  z0 Zip, isi dengan 0. Elemen pada indeks (baru) yang sesuai adalah
                   dipasangkan bersama, dengan 0 sebagai pengisi.
    U1¦ Membalik pasangan pada indeks `1` (indeks pertama).
       Zḟ € 0 Zip lagi dan filter `0`s, secara efektif membatalkan z0.
           ṙ "N} Zipdengan memutar dengan jumlah shift negatif, kebalikan dari` ṙ "`.

Jadi pada dasarnya "di U1¦bawah ṙ"z0".

Tautan kedua cukup memfilter indeks OoB ( <Ạ¥Ðf L€), menambahkan argumen kedua ( ⁹ṭ), membalikkan ( Ṛ), dan mengurangi lebih ç(mirip dengan Haskell foldl)

Python 2 , 193 byte

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]

Cobalah online!

Membawa koordinat swap 1-diindeks

APL (Dyalog Classic) , 31 30 byte

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

Cobalah online!

Argumen kiri adalah sepasang vektor karakter - pita kiri dan pita atas. Argumen yang tepat adalah vektor pasangan koordinat - lokasi swap. Mengembalikan sepasang pita kanan dan bawah. (Perhatikan bahwa tidak seperti pada contoh, saya menggunakan urutan kiri-atas dan kanan-bawah untuk pita agar konsisten dengan urutan sumbu baris-col dalam koordinat.)

Swap harus disortir sehingga swap ke kiri atas yang lain datang sebelum setelah itu. Jika dua swap ke kiri bawah / kanan atas satu sama lain, urutannya tidak masalah.

EDIT: disimpan satu byte ( ⌽) dengan meminta urutan swap terbalik pada input

Javascript, 87 76 62 byte

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

Cobalah online!

Algoritma trivial yang sama dengan jawaban Python 3. Menggunakan array sebagai koordinat tupel. Membutuhkan warna pita ditetapkan oleh nilai-nilai kebenaran. Memerlukan koordinat untuk dipesan sebagian sehingga x1,y1datang sebelum x2,y2jika salah satu x1 < x2 && y1 = y2atau x1 = x2 && y1 < y2. Kembali dengan memodifikasi array input.

Ruby , 56 54 byte

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

Cobalah online!

Port Python 3 dari user202729 menjawab dengan beberapa trik ruby

Koordinat harus diurutkan secara leksikografis