Ayrık döngü biçiminde iki permütasyon göz önüne alındığında , ürün / bileşimini ayrık döngü biçiminde çıktılar.

Kompozisyonu bulmak için, ayrık döngüleri iki satırlı gösterimdeki permütasyonlara dönüştürün. Bir döngünün ayrık bölümündeki her sayı, aynı bölümden sonraki sayı ile eşlenir. Etrafı sarar. Yani 1 -> 5, 5 -> 1, 2 -> 4, 4 -> 2. Bir sayı bulunamazsa, 3 -> 3kendisine eşlenir. İlk ayrık döngü de yazılabilir (1 5)(2 4)(3). Bu eşlemeler iki satıra dönüştürülür, örneğin ( P ve Q sırasının tersine çevrildiğine dikkat edin):

[Perm] iki permütasyon ürünü, ikinci (en soldaki) permütasyon kolonlarını yeniden düzenleyerek elde edilir, böylece ilk sırası, ilk (en sağdaki) permütasyonun ikinci satırı ile aynı olur. Ürün daha sonra değiştirilmiş ikinci permütasyonun ikinci satırı üzerine birinci permütasyonun ilk satırı olarak yazılabilir.

Wikipedia makalesi

Kurallar:

• Girdi, liste listesi veya benzer bir biçim olarak verilecektir
• Sen olabilir değil gibi bir şey almak (1 5)(2 4)olarak [5, 4, 3, 2, 1]çift hatlı şeklinde zaten (değere eşleme endeksi)
• Tüm sayılar olsun diye, her grupta meydana zorunda (1 5)·(1 2)sonuçlanan (2 5 1).
• Çıktınız girdiniz olarak kullanılabilmelidir.
• Boş bir döngü ile girişi desteklemenize gerek yoktur (1 5)·(). Bunun yerine bu şekilde (1 5)·(1)veya eşdeğeri bir şey verilir .
• Döngüler sarıldığından, sonuç doğru olduğu sürece sipariş önemli değildir.
• Sıfır veya bir ile başlayabilirsiniz. Önemli değil, çünkü sonuçlar aynı.
• Sayılar daha büyük olabilir 9 .
• Çıktıya aynı sayıyı bir defadan fazla dahil edemezsiniz. Yani[[1],[1]] izin verilmiyor.
• Bu işlemin değişmeli olmadığını unutmayın ! Q'yu P'nin önüne koydum, çünkü Wikipedia bunu yaptı. Herhangi bir siparişi seçebilirsiniz, ancak hangisi farklıysa belirtin.
• En kısa kod kazanır
• Yerleşiklere izin verilir, ancak bir tane kullanırsanız, kullanmadan da bir çözüm gösterin.

Örnekler:

Eşdeğer çıktı olasılıklarının tümü gösterilmemiştir

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 bayt

C.@C.@,

Çevrimiçi deneyin!

Mathematica, 15 bayt

##⊙Cycles@{}&

Evet Virginia, bir yerleşik var .... Mathematica zaten ayrık döngü gösterimde olan bir permütasyon veri türünü destekler: bu saf fonksiyon formdaki herhangi bir sayıda argümanı girdi olarak alır Cycles[{{1, 5}, {2, 4}}]ve ürün permütasyonunu tekrar Cycles[]formda çıkarır . OP olarak tersi sıralama kuralını kullanır, örneğin,

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

döner Cycles[{{1, 4, 3, 5}}]. ⊙Yukarıda kullanılan sembol gerçekten Mathematica'da işe 3 bayt, özel kullanım Unicode sembolü U + F3DE olmalıdır. Mathematica'nın bu işlem için adlandırılmış bir yerleşimi olduğunu unutmayın PermutationProduct, ancak bu üç bayt daha uzun.

Haskell , 157 bayt

DÜZENLE:

• -9 bayt: Bu gerçekten daha fazla golf olabilir. Etrafta gereksiz parantez kaldırıldı p++q. İle değiştirilen bağımsız değişken sırası g. Got kurtulmak dbaşlatarak iterateile p xbundan sonra, takeWhileartık birlikte bağladılar fst+ span. Yapılmış iterateinfix.

Geç kaldığımda bunu yapmak ... muhtemelen biraz daha golf oynayabilir.

Daha basitti ve izin verildiği görülüyordu, bu nedenle çıktı tek elemanlı döngüler içeriyor.

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

Çevrimiçi deneyin!

Nasıl çalışır:

• #ana işlevdir. q#piki sayı listesi alır ve benzer bir liste döndürür. Testlerin P'den önce Q olduğu görülüyor, bu yüzden aynı sırayı kullandım.
• f ppermütasyon dönüştüren pbir fonksiyona ayrık döngüsü biçiminden, daha sonra f qve f pher zamanki gibi bir bileşim operatörü ile oluşturulabilir. .
  • Liste kavrayışı , halefini carayarak ave bularak döngüler boyunca yinelenir . Anlama hiçbir şey bulamazsa a, sadece iade edilir.
  • zip(0:c)(c++c)öğelerinin çiftlerinin cve haleflerinin bir listesidir . Soru " 0bir tanede başlamamıza" izin verdiğinden , sahte bir değer olarak kullanabiliriz ; zipilk argümana tailikincisinde kullanmaktan daha ucuz .
• g l pbir leleman listesi ve bir permütasyon fonksiyonu alır ve elemanlara pdokunan döngü listesini döndürür.
  • İşte listenin cilk elemanını içeren döngü x, diğer elemanları tekrardan bulunana kadar cyinelenerek bulunur. Kalan döngüleri bulmak için tekrarlanırken, öğesinin tüm öğeleri önce bir liste kavrama ile kaldırılır.p xxc

Python, 220 bayt

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 bayt

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

Çevrimiçi deneyin! veya Tüm test senaryolarını kontrol edin!

Girdi : qve pbu sırayla, her biri bir tuples kümesidir STDIN.
Çıktı : Q·PBir dizi tuples olarak ürün permütasyonu STDERR.

açıklama

İşlev g, hangi sayının ipermütasyondaki sayıyla eşleştiğini bulur p(aka gters permütasyonudur 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

İşlev hbir sayı alır ve Q·Pbu sayıyı içeren döngüyü döndürür . Döndürülen döngü, en küçük eleman 0 dizininde olacak şekilde biçimlendirilmiş bir demet olacaktır.

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

hTüm sayılara uygulayarak tüm döngüleri elde edebiliriz Q·P. Sonuçta yinelenen döngüleri önlemek için, tüm döngüleri bir sete koyarız. Bu, döndürülen benzer döngülerin haynı gruba (0 dizinindeki en küçük öğe olacak şekilde) biçimlendirileceğinden çalışır .
Yalnızca, içinde görünen sayıları dikkate almamız gerekir Pveya Qdiğer tüm sayılar kendileriyle eşleşeceğinden.

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