ฉันได้รับเมื่อเร็ว ๆ นี้การเล่นผ่าน ' ทอ ' และฉันคิดว่ามันเป็นของขวัญที่เป็นความท้าทายที่น่าสนใจสำหรับรหัสกอล์ฟ

สถานที่ตั้ง:

The Weaver เป็นเกมที่คุณจะได้รับริบบิ้นจำนวนมากจาก 2 ทิศทาง 90 องศาและเป้าหมายของคุณคือการสลับมันที่ทางแยกบางแห่งเพื่อให้ได้ผลลัพธ์ที่ต้องการ

   เช่นนี้: นี่คือการแลกเปลี่ยน: นี่ไม่ใช่:

การป้อนข้อมูล:

3 อาร์เรย์:

• ริบบิ้นด้านบน (จากซ้ายไปขวา)
• ริบบิ้นด้านซ้าย (บนลงล่าง)
• พิกัดของจุดแยกที่ต้องการสลับ

เอาท์พุท:

2 อาร์เรย์:

• ริบบิ้นด้านล่าง (จากซ้ายไปขวา)
• ริบบิ้นด้านขวา (บนลงล่าง)

ตัวอย่าง:

ฉันจะใช้ภาพด้านบนเป็นตัวอย่างแรก:

การป้อนข้อมูล: [r, y, b], [r, y, b], [(0, 1), (2, 1), (2, 2)]

เกิดอะไรขึ้น:

   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

ในกรณีที่•แสดงให้เห็นถึงการแลกเปลี่ยน

เอาท์พุท: [r, b, r], [y, y, b]

การป้อนข้อมูล: [a, b, c], [d, e, f], [(0, 0), (2, 1)]

เกิดอะไรขึ้น:

   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

เอาท์พุท: [d, f, c], [a, e, b]

การป้อนข้อมูล: [a, b], [a, b, c], [(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1)]

เกิดอะไรขึ้น:

   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

เอาท์พุท: [c, b], [b, a, a]

หมายเหตุ:

• ตัวอย่างที่แสดงพิกัดให้เป็นแม้ว่าคุณอาจจะใช้พวกเขาเป็น(row, column)(column, row)
• แถวบนและคอลัมน์ซ้ายอาจมีริบบิ้นที่มีสีเดียวกัน
• คณะกรรมการสามารถเป็นรูปสี่เหลี่ยมผืนผ้า
• พิกัดทั้งหมดจะไม่เป็นลบ ( >=0) (หรือบวกอย่างยิ่ง ( >=1) หากคุณเลือก 1 การจัดทำดัชนี)
• ละเว้นการแลกเปลี่ยนใด ๆ ที่อยู่นอกบอร์ด
• คุณสามารถเลือกทำงานกับตัวอักษร ( [a-zA-Z]), จำนวนเต็ม ( [0-9]) หรือทั้งสองอย่าง
• ริบบิ้นในผลลัพธ์ของคุณจะต้องตรงกับริบบิ้นในอินพุตอย่างแน่นอน ( a -> a)
• คุณอาจถือว่ารายการ swaps ถูกเรียงลำดับในแบบที่คุณต้องการตราบใดที่มันสอดคล้องกัน (ถ้าคุณทำโปรดระบุว่าควรจะเรียงลำดับอย่างไร)
• คุณอาจใช้ค่า swap เป็น 0 หรือ 1-indexed
• ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม

ตัวอย่างเพิ่มเติม:

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]

ตัวอย่างสุดท้ายเกี่ยวข้องกับกรณีนี้ (หากทำให้เห็นภาพได้ง่ายขึ้น):

นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดเป็นไบต์สำหรับแต่ละภาษาที่ชนะ

Python 3 , 74 ไบต์

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]

ลองออนไลน์!

ต้องlมีการเรียงลำดับตามคำย่อของคำศัพท์ aและbเป็นรายการของตัวละครที่เป็นตัวแทน (ริบบิ้นซ้าย, ริบบิ้นด้านบน)

ผลตอบแทนโดยการปรับเปลี่ยนรายการและab

เยลลี่ , 37 35 30 ไบต์

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

ลองออนไลน์!

โปรแกรม Dyadic รับรายการดัชนีดัชนีการแลกเปลี่ยนเป็นอาร์กิวเมนต์ซ้าย 0 (เรียงตามลำดับพจนานุกรมย้อนกลับ) และ (ริบบิ้นซ้ายริบบิ้นด้านบน) เป็นอาร์กิวเมนต์ที่ถูกต้อง ผลตอบแทน (ริบบิ้นขวาริบบิ้นด้านล่าง)

เยลลี่เป็นภาษาโดยปริยาย มี (เกือบ) ไม่มีตัวแปรที่จะทำงานด้วยดังนั้นการทำสิ่งใดก็ตามที่เกี่ยวข้องกับตัวแปรมากกว่าสองตัวพร้อมกันนั้นเป็นสิ่งที่ไม่เป็นระเบียบ

ลิงก์แรกจะใช้เวลา[l,t]เป็นอาร์กิวเมนต์ซ้าย[x,y](0 ดัชนี) เป็นอาร์กิวเมนต์สิทธิของตนและผลตอบแทน[l,t]ที่มีl[x]และr[y]การแลกเปลี่ยน

R "z0U1|Zḟ€ 0R" N}
ṙ "Zipwith หมุนค่าปัจจุบัน:` [l ṙ x, t ṙ y] `
                   (ดังนั้น l [x] และ r [x] กลายเป็น l [0] และ r [0] ตามลำดับ)
  z0 Zip เติมด้วย 0 องค์ประกอบที่สอดคล้องกัน (ใหม่) ดัชนีคือ
                   จับคู่กันพร้อมกับ 0 เป็นฟิลเลอร์
    U1¦ กลับคู่ที่ดัชนี '1' (ดัชนีแรก)
       Zḟ€ 0 ซิปอีกครั้งและกรอง `0`s เลิกทำการ z0 ได้อย่างมีประสิทธิภาพ
           ṙ "N} Zipwith หมุนด้วยจำนวนกะลบ, ย้อนกลับของ` ṙ "'

โดยพื้นฐานแล้ว " U1¦ใต้ṙ"z0"

ลิงค์ที่สองเพียงกรองดัชนี OoB ( <Ạ¥Ðf L€) ต่อท้ายอาร์กิวเมนต์ที่สอง ( ⁹ṭ) ย้อนกลับ ( Ṛ) และลดส่วนเกินç(คล้ายกับของ Haskell foldl)

Python 2 , 193 ไบต์

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]

ลองออนไลน์!

รับค่า swap 1 ดัชนี

APL (Dyalog Classic) , 31 30 ไบต์

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

ลองออนไลน์!

อาร์กิวเมนต์ซ้ายเป็นเวกเตอร์อักขระหนึ่งตัว - ริบบอนด้านซ้ายและริบบอนด้านบน อาร์กิวเมนต์ที่ถูกต้องคือเวกเตอร์ของคู่พิกัด - ตำแหน่งสลับ ส่งคืนริบบ้อนขวาและริบบอนด้านล่าง (โปรดทราบว่าไม่เหมือนในตัวอย่างฉันใช้ลำดับซ้ายบนและล่างขวาสำหรับริบบิ้นเพื่อให้สอดคล้องกับลำดับแกนแถวคอลัมน์ในพิกัด)

Swaps ต้องเรียงลำดับเพื่อให้การสลับไปทางซ้ายบนของรายการอื่นมาก่อน หลังจากนั้น หากมีการสลับสองครั้งไปทางซ้ายล่าง / ขวาบนของกันและกันลำดับของพวกเขาก็ไม่สำคัญ

แก้ไข: บันทึกหนึ่งไบต์ ( ⌽) โดยต้องการลำดับการสลับย้อนกลับในอินพุต

Javascript, 87 76 62 ไบต์

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

ลองออนไลน์!

อัลกอริธึมเล็กน้อยเช่นเดียวกับคำตอบของ Python 3 ใช้อาร์เรย์เป็นสิ่งอันดับพิกัด ต้องใช้สีริบบิ้นเพื่อกำหนดโดยค่าความจริง ต้องใช้พิกัดที่จะสั่งซื้อบางส่วนเพื่อให้x1,y1มาก่อนx2,y2ถ้าอย่างใดอย่างหนึ่งหรือx1 < x2 && y1 = y2 x1 = x2 && y1 < y2ส่งคืนโดยการแก้ไขอาร์เรย์อินพุต

Ruby , 56 54 ไบต์

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

ลองออนไลน์!

พอร์ตของPython 3ของuser202729 ตอบด้วยเทคนิค ruby

พิกัดต้องถูกจัดเรียงตามพจนานุกรม