เมื่อได้รับการเปลี่ยนรูปแบบสองรูปแบบในรูปของวงรอบที่ไม่ปะติดปะต่อ

ในการค้นหาองค์ประกอบให้แปลงวงรอบที่แยกกันเป็นพีชคณิตในรูปแบบสองบรรทัด แต่ละหมายเลขในส่วนที่ไม่เป็นสมาชิกร่วมของรอบจะถูกแมปกับหมายเลขที่ตามมาในส่วนเดียวกัน มันล้อมรอบ ดังนั้น1 -> 5, 5 -> 1, ,2 -> 4 4 -> 2หากไม่พบตัวเลข3 -> 3มันจะถูกแม็พกับตัวเอง (1 5)(2 4)(3)วงจรเคล็ดแรกอาจจะมีการเขียน การแมปเหล่านี้จะถูกแปลงเป็นสองบรรทัดเช่นนั้น (โปรดทราบว่าลำดับของPและQจะถูกย้อนกลับ):

[T] ผลคูณของการเปลี่ยนสองอันได้มาจากการจัดเรียงคอลัมน์ของการเปลี่ยนแปลงลำดับที่สอง (ซ้ายสุด) เพื่อให้แถวแรกของแถวนั้นเหมือนกันกับแถวที่สองของการเปลี่ยนรูปแรก (ขวาสุด) ผลิตภัณฑ์สามารถเขียนเป็นแถวแรกของการเปลี่ยนรูปแรกเหนือแถวที่สองของการเปลี่ยนแปลงที่สองที่ถูกดัดแปลง

บทความ Wikipedia

กฎ:

• อินพุตจะได้รับเป็นรายการของรายการหรือรูปแบบที่คล้ายกัน
• คุณอาจจะไม่ได้ใช้สิ่งที่ต้องการ(1 5)(2 4)เป็น[5, 4, 3, 2, 1]อยู่แล้วในรูปแบบสองบรรทัด (ดัชนีการทำแผนที่เพื่อค่า)
• ไม่ใช่ว่าทุกตัวเลขจะต้องเกิดขึ้นในแต่ละกลุ่มดังนั้นคุณอาจมี(1 5)·(1 2)ผลลัพธ์(2 5 1)ได้
• เอาต์พุตของคุณควรสามารถใช้เป็นอินพุตของคุณได้
• (1 5)·()คุณไม่จำเป็นต้องป้อนข้อมูลสนับสนุนที่มีวงจรที่ว่างเปล่า ที่จะได้รับเป็นแทน(1 5)·(1)หรือสิ่งที่เทียบเท่า
• เนื่องจากรอบตัดคำสั่งนั้นไม่สำคัญตราบใดที่ผลลัพธ์ถูกต้อง
• คุณสามารถเริ่มต้นที่ศูนย์หรือหนึ่ง มันไม่สำคัญเพราะผลลัพธ์เหมือนกัน
• 9ตัวเลขจะมีขนาดใหญ่กว่า
• คุณไม่สามารถใส่หมายเลขเดียวกันมากกว่าหนึ่งครั้งในผลลัพธ์ ดังนั้นจึง[[1],[1]]ไม่ได้รับอนุญาต
• โปรดทราบว่าการดำเนินการนี้ไม่ได้สลับกัน ! ฉันใส่ Q ก่อน P เพราะนั่นคือสิ่งที่ Wikipedia ทำ คุณสามารถเลือกคำสั่งซื้อใด ๆ แต่ระบุว่ามันแตกต่างกัน
• รหัสที่สั้นที่สุดชนะ
• อนุญาตให้ใช้บิวด์อิน แต่ถ้าคุณใช้ให้แสดงโซลูชันโดยไม่ใช้ด้วย

ตัวอย่าง:

ไม่ใช่ความเป็นไปได้ที่เทียบเท่าที่จะแสดงทั้งหมด

Input
Output

[[1, 5], [2, 4]], [[1, 2, 4, 3]]
[[1, 4, 3, 5]] (or [[4, 3, 5, 1]] or ...)

[[1, 5]], [[1, 2]]
[[2, 5, 1]]

[[10, 2, 3]], [[2]]
[[3, 10, 2]]

[[1]], [[3]]
[[]] (or [[1]] or something equivalent)

[[10,2,3,15],[1,7],[5,6],[14,4,13,11,12]], [[5,6,7,9,14],[2,8,3,10],[1,11]]
[[12, 14, 6, 1], [8, 15, 10, 3, 2], [13, 11, 7, 9, 4]]

(arguments in reverse order from above gives a different answer)
[[5,6,7,9,14],[2,8,3,10],[1,11]], [[10,2,3,15],[1,7],[5,6],[14,4,13,11,12]]
[[9, 14, 4, 13, 1], [10, 8, 3, 15, 2], [7, 11, 12, 5]]

J , 7 ไบต์

C.@C.@,

ลองออนไลน์!

Mathematica ขนาด 15 ไบต์

##⊙Cycles@{}&

ใช่เวอร์จิเนียมี builtin .... Mathematica รองรับชนิดข้อมูลการเปลี่ยนแปลงอยู่แล้วในเครื่องหมายวงรอบ disjoint: ฟังก์ชั่นบริสุทธิ์นี้ใช้เป็นข้อโต้แย้งจำนวนใด ๆ ในรูปแบบCycles[{{1, 5}, {2, 4}}]และเอาท์พุทการเปลี่ยนแปลงผลิตภัณฑ์อีกครั้งในCycles[]รูปแบบ มันใช้รูปแบบการสั่งซื้อตรงกันข้ามเป็น OP ดังนั้นตัวอย่างเช่น

##⊙Cycles@{}&[Cycles[{{1, 2, 4, 3}}], Cycles[{{1, 5}, {2, 4}}]]

Cycles[{{1, 4, 3, 5}}]ผลตอบแทน ⊙สัญลักษณ์ผมใช้ข้างต้นจริงๆควรจะเป็น 3 ไบต์ส่วนตัวใช้ Unicode สัญลักษณ์ U + F3DE การทำงานใน Mathematica โปรดทราบว่า Mathematica มีชื่อ builtin สำหรับการดำเนินการนี้PermutationProductแต่มีความยาวสามไบต์

Haskell , 157 148 bytes

แก้ไข:

• -9 ไบท์: นั่นอาจจะเป็นกอล์ฟมากกว่า p++qซ้ำซ้อนที่ถูกลบวงเล็บรอบ gเพื่อโต้แย้งสลับของ ได้กำจัดdโดยเริ่มต้นiterateด้วยp xหลังจากที่takeWhileผูกไม่มีอีกต่อไปกับ+fst spanทำiterateมัด

การทำเช่นนี้ในขณะที่ฉันสาย ... อาจจะเล่นกอล์ฟเพิ่มอีก

มันง่ายกว่าและดูเหมือนว่าจะได้รับอนุญาตดังนั้นเอาต์พุตจึงรวมวงจรองค์ประกอบเดี่ยว

q#p=g(p++q>>=id)$f q.f p
f p a=last$a:[y|c<-p,(x,y)<-zip(0:c)(c++c),x==a]
g(x:l)p|c<-x:fst(span(/=x)$p`iterate`p x)=c:g[x|x<-l,x`notElem`c]p
g[]p=[]

ลองออนไลน์!

มันทำงานอย่างไร:

• #เป็นหน้าที่หลัก q#pรับรายการหมายเลขสองรายการและส่งคืนรายการที่คล้ายกัน การทดสอบดูเหมือนจะมีคิวก่อนพีดังนั้นฉันจึงใช้คำสั่งเดียวกัน
• f pแปลงการเปลี่ยนลําดับpจากรูปแบบวงจรการเคลื่อนไปยังฟังก์ชันหลังจากที่f qและสามารถประกอบกับผู้ประกอบการองค์ประกอบปกติ f p.
  • ความเข้าใจในรายการจะวนซ้ำตามวัฏจักรcค้นหาaและค้นหาผู้สืบทอด หากความเข้าใจไม่พบสิ่งใดสิ่งนั้นaจะถูกส่งคืน
  • zip(0:c)(c++c)เป็นรายการองค์ประกอบคู่cและตัวต่อของพวกเขา เนื่องจากคำถามทำให้เรา "เริ่มต้นที่หนึ่ง" เราสามารถใช้0เป็นค่าตัวอย่าง; มันถูกกว่าที่จะเสริมว่าการzipโต้เถียงครั้งแรกนั้นเป็นการใช้tailครั้งที่สอง
• g l pใช้รายการlองค์ประกอบและฟังก์ชันการเรียงสับเปลี่ยนpและส่งกลับรายการรอบที่สัมผัสกับองค์ประกอบ
  • นี่cคือวงจรที่มีองค์ประกอบแรกxของรายการองค์ประกอบอื่น ๆ ของcจะถูกพบโดยวนซ้ำจากp xจนกว่าxจะพบอีกครั้ง เมื่อเรียกซ้ำเพื่อค้นหารอบที่เหลือองค์ประกอบทั้งหมดของcจะถูกลบออกเป็นครั้งแรกด้วยความเข้าใจในรายการ

Python ขนาด 220 ไบต์

a,b=eval(input())
p,o=a+b,[]
for i in range(1,1+max(map(max,p))):
 if not any(i in t for t in o):
  u,m=(i,),i
  while 1:
   for t in p[::-1]:
    if m in t:m=t[(t.index(m)+1)%len(t)]
   if m==i:o+=[u];break
   u+=(m,)
o

Python 3.8 , 187 ไบต์

q,p=eval(input())
g=lambda p,i:[*(c[c.index(i)-1]for c in p if i in c),i][0]
h=lambda*c:(x:=g(p,g(q,c[0])))in c and(*c[(m:=c.index(min(c))):],*c[:m])or h(x,*c)
exit({*map(h,sum(p|q,()))})

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด!

การป้อนข้อมูล : qและpอยู่ในลำดับที่แต่ละคือชุดของ tuples STDINจาก
เอาท์พุท : ผลิตภัณฑ์ที่เปลี่ยนแปลงQ·Pเป็นชุดของ tuples STDERRเพื่อ

คำอธิบาย

ฟังก์ชั่นgค้นหาว่าหมายเลขใดที่แม็พกับหมายเลขiในการเรียงสับเปลี่ยนp(aka gคือการเรียงสับเปลี่ยนของp)

g=lambda p,i:        
[                   # creates a list
  *(                # containing the following
    c[c.index(i)-1] #   the number before i in cycle c
    for c in p      #   for all cycles in permutation
    if i in c       #   if i is in that cycle
  )                 #
  ,i                # adds i to the end of that list
                    #   (in case i is not in any cycle)
][0]                # returns the first element of the list

ฟังก์ชั่นhใช้เวลาเป็นตัวเลขและส่งกลับรอบในQ·Pที่มีหมายเลขนั้น วัฏจักรที่ส่งคืนจะเป็น tuple ซึ่งจัดรูปแบบในลักษณะที่องค์ประกอบที่เล็กที่สุดอยู่ที่ดัชนี 0

h=lambda*c:                   # input: an incomplete cycle c, as a list
(x:=g(p,g(q,c[0])))           # finds the number x before the first number in c
in c                          # if x is also in c (aka the cycle is complete)
and                           # then returns the following:
(                             #   c as a tuple with min element at index 0
  *c[(m:=c.index(min(c))):],  #   (c, from the min element to the end)
  *c[:m]                      #   (c, from start to the min element)
)
or                            # else (cycle is incomplete) returns the following
h(x,*c)                       #   recursive result when after prepending x to c

โดยการประยุกต์ใช้ให้เป็นตัวเลขทั้งหมดที่เราจะได้รับทั้งหมดในรอบh Q·Pเพื่อป้องกันวงจรซ้ำในผลลัพธ์ของเราเราเพียงใส่วัฏจักรทั้งหมดในชุด การทำงานนี้เนื่องจากวงจรที่คล้ายกันที่ส่งคืนโดยhจะถูกจัดรูปแบบเป็น tuple เดียวกัน (โดยมีองค์ประกอบที่เล็กที่สุดที่ดัชนี 0)
เราเพียงแค่ต้องพิจารณาตัวเลขที่ปรากฏในPหรือQเนื่องจากตัวเลขอื่น ๆ จะจับคู่กับตัวเอง

exit(              # returns through STDERR
  {                # create a set from the followings
    *map(h,        #   map function h to
      sum(p|q,())  #   all numbers in P or Q
    )
  }
)