Cho hai hoán vị ở dạng chu kỳ rời rạc, xuất sản phẩm / thành phần của chúng ở dạng chu kỳ rời rạc.

Để tìm thành phần, chuyển đổi các chu kỳ rời rạc thành hoán vị trong ký hiệu hai dòng. Mỗi số trong một phần tách rời của một chu kỳ được ánh xạ tới số theo sau nó trong cùng một phần. Nó quấn quanh. Vì vậy 1 -> 5, 5 -> 1, 2 -> 4, 4 -> 2. Nếu một số không được tìm thấy 3 -> 3, nó được ánh xạ tới chính nó. Chu kỳ rời rạc đầu tiên cũng có thể được viết (1 5)(2 4)(3). Các ánh xạ này được chuyển đổi thành hai dòng, như vậy (lưu ý rằng thứ tự của P và Q được đảo ngược):

[T] ông sản phẩm của hai hoán vị thu được bằng cách sắp xếp lại các cột của hoán vị thứ hai (ngoài cùng bên trái) sao cho hàng đầu tiên của nó trùng với hàng thứ hai của hoán vị thứ nhất (ngoài cùng bên phải). Sản phẩm sau đó có thể được viết dưới dạng hàng đầu tiên của hoán vị đầu tiên trên hàng thứ hai của hoán vị thứ hai được sửa đổi.

Bài viết trên Wikipedia

Quy tắc:

• Đầu vào sẽ được đưa ra dưới dạng danh sách các danh sách hoặc định dạng tương tự
• Bạn có thể không lấy một cái gì đó như (1 5)(2 4)là[5, 4, 3, 2, 1] , đã có trong hình thức hai dòng (chỉ số ánh xạ tới giá trị)
• Không phải tất cả các số phải xảy ra trong mỗi nhóm, do đó bạn có thể có (1 5)·(1 2), dẫn đến(2 5 1) .
• Đầu ra của bạn sẽ có thể được sử dụng làm đầu vào của bạn.
• Bạn không cần phải hỗ trợ đầu vào với một chu kỳ trống (1 5)·(). Điều đó thay vào đó sẽ được đưa ra như(1 5)·(1) hoặc một cái gì đó tương đương.
• Vì các chu kỳ bao quanh, thứ tự không quan trọng miễn là kết quả là chính xác.
• Bạn có thể bắt đầu từ 0 hoặc 1. Không thành vấn đề, vì kết quả là như nhau.
• Các con số có thể lớn hơn 9.
• Bạn có thể không bao gồm cùng một số nhiều hơn một lần trong đầu ra. Vì vậy, [[1],[1]]không được phép.
• Lưu ý rằng hoạt động này không giao hoán ! Tôi đặt Q trước P, vì đó là những gì Wikipedia đã làm. Bạn có thể chọn bất kỳ thứ tự nào, nhưng chỉ định nếu nó khác.
• Mã ngắn nhất sẽ thắng
• Tích hợp được cho phép, nhưng nếu bạn sử dụng một, hãy hiển thị một giải pháp mà không sử dụng nó.

Ví dụ:

Không phải tất cả các khả năng đầu ra tương đương được hiển thị

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 byte

C.@C.@,

Hãy thử trực tuyến!

Toán học, 15 byte

##⊙Cycles@{}&

Có Virginia, có một nội dung .... Mathicala hỗ trợ kiểu dữ liệu hoán vị đã có trong ký hiệu chu kỳ rời rạc: hàm thuần túy này lấy đầu vào bất kỳ số lượng đối số nào trong biểu mẫu Cycles[{{1, 5}, {2, 4}}]và xuất lại hoán vị sản phẩm, Cycles[]dưới dạng. Nó sử dụng quy ước đặt hàng ngược lại như OP, ví dụ,

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

trả lại Cycles[{{1, 4, 3, 5}}]. Các ⊙biểu tượng tôi đã sử dụng trên thực sự nên là 3-byte tư nhân sử dụng Unicode biểu tượng U + F3DE để làm việc trong Mathematica. Lưu ý rằng Mathicala có một nội dung được đặt tên cho hoạt động này PermutationProduct, nhưng dài hơn ba byte.

Haskell , 157 148 byte

BIÊN TẬP:

• -9 byte: Điều đó thực sự có thể được đánh gôn nhiều hơn. Loại bỏ dấu ngoặc thừa xung quanh p++q. Hoán đổi thứ tự đối số của g. Loại bỏ dbằng cách bắt đầu iteratebằng p x, sau đó takeWhilekhông còn được gắn với fst+ span. Thực hiện iterate.

Làm điều này trong khi tôi đến muộn ... có thể chơi gôn nhiều hơn.

Nó đơn giản hơn và dường như được cho phép, vì vậy đầu ra bao gồm các chu kỳ phần tử đơn.

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=[]

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

• #là chức năng chính. q#plấy hai danh sách các danh sách các số và trả về một danh sách tương tự. Các xét nghiệm dường như có Q trước P nên tôi đã sử dụng cùng một thứ tự.
• f pchuyển đổi hoán vị ptừ dạng chu trình rời rạc thành hàm, sau đó f qvà f pcó thể được tạo với toán tử thành phần thông thường. .
  • Việc hiểu danh sách lặp đi lặp lại qua các chu kỳ c, tìm kiếm avà tìm kiếm sự kế thừa của nó. Nếu sự hiểu biết không tìm thấy gì, achỉ cần trả lại.
  • zip(0:c)(c++c)là một danh sách các cặp yếu tố cvà người kế vị của chúng. Vì câu hỏi cho phép chúng tôi "bắt đầu tại một", chúng tôi có thể sử dụng 0làm giá trị giả; rẻ hơn để trả trước cho zipđối số thứ nhất so với sử dụng tailđối số thứ hai.
• g l pcó một danh sách lcác phần tử và hàm hoán vịp và trả về danh sách các chu trình chạm vào các phần tử.
  • Đây clà chu trình chứa phần tử đầu tiên xcủa danh sách, các phần tử khác cđược tìm thấy bằng cách lặp lại p xcho đến khi xđược tìm thấy lại. Khi đệ quy để tìm các chu kỳ còn lại, tất cả các yếu tố cđầu tiên được loại bỏ với sự hiểu biết danh sách.

Python, 220 byte

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 byte

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,()))})

Hãy thử trực tuyến! hoặc Kiểm tra tất cả các trường hợp thử nghiệm!

Đầu vào : qvà ptheo thứ tự đó, mỗi bộ là một bộ dữ liệu, từ STDIN.
Đầu ra : Hoán vị sản phẩm Q·Plà một bộ tuples, to STDERR.

Giải trình

Hàm gtìm số ánh xạ tới số itrong hoán vị p(hay còn gọi glà hoán vị nghịch đảo của 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àm hlấy một số và trả về chu trình Q·Pchứa số đó. Chu trình được trả về sẽ là một tuple, được định dạng theo cách sao cho phần tử nhỏ nhất nằm ở chỉ số 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

Bằng cách áp dụng hcho tất cả các số, chúng tôi có thể nhận được tất cả các chu kỳ Q·P. Để ngăn chặn các chu kỳ trùng lặp trong kết quả của chúng tôi, chúng tôi chỉ cần đặt tất cả các chu kỳ trong một bộ. Điều này hoạt động vì các chu kỳ tương tự được trả về hsẽ được định dạng cho cùng một bộ (với phần tử nhỏ nhất ở chỉ số 0).
Chúng ta chỉ cần xem xét các số xuất hiện trong Phoặc Q, vì tất cả các số khác sẽ ánh xạ tới chính chúng.

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
    )
  }
)