क्रमपरिवर्तन की संरचना - समूह उत्पाद

Question

असमान चक्र रूप में दो क्रमपरिवर्तन को देखते हुए , अपने उत्पाद / संरचना को असमान चक्र रूप में आउटपुट करते हैं।

रचना को खोजने के लिए, दो-पंक्ति संकेतन में डिसऑर्डर चक्रों को क्रमपरिवर्तन में परिवर्तित करें। एक चक्र के एक अव्यवस्थित हिस्से में प्रत्येक संख्या को उसी भाग में निम्नलिखित संख्या में मैप किया जाता है। यह चारों ओर लपेटता है। तो 1 -> 5, 5 -> 1, 2 -> 4, 4 -> 2। यदि कोई संख्या नहीं मिली है, 3 -> 3तो उसे स्वयं मैप किया जाता है। पहला असहमति चक्र भी लिखा जा सकता है (1 5)(2 4)(3)। ये मैपिंग दो लाइनों में बदल जाती हैं, जैसे (ध्यान दें कि P और Q का क्रम उल्टा है)

[T] वह दो क्रमपरिवर्तन का उत्पाद दूसरी (सबसे बाईं) क्रमपरिवर्तन के स्तंभों को पुनर्व्यवस्थित करके प्राप्त करता है ताकि इसकी पहली पंक्ति पहली (दाईं ओर) क्रमपरिवर्तन की दूसरी पंक्ति के समान हो। उत्पाद को फिर संशोधित दूसरी क्रमपरिवर्तन की दूसरी पंक्ति के पहले क्रमपरिवर्तन की पहली पंक्ति के रूप में लिखा जा सकता है।

विकिपीडिया लेख

---

नियम:

• इनपुट सूची या समान प्रारूप की सूची के रूप में दिया जाएगा
• आप कर सकते हैं नहीं की तरह कुछ ले (1 5)(2 4)के रूप में [5, 4, 3, 2, 1](मानचित्रण मूल्य के इंडेक्स) दो लाइन के रूप में पहले से ही,
• सभी संख्याएँ प्रत्येक समूह में नहीं होती हैं, इसलिए आप कर सकते हैं (1 5)·(1 2), जिसके परिणामस्वरूप (2 5 1)।
• आपका आउटपुट आपके इनपुट के रूप में उपयोग करने में सक्षम होना चाहिए।
• आपको खाली चक्र के साथ इनपुट का समर्थन करने की आवश्यकता नहीं है (1 5)·()। इसके बजाय इसके (1 5)·(1)बराबर या कुछ दिया जाएगा ।
• चूंकि चक्र चारों ओर से लपेटते हैं, इसलिए जब तक परिणाम सही नहीं होता तब तक क्रम मायने नहीं रखता।
• आप शून्य या एक पर शुरू कर सकते हैं। इससे कोई फर्क नहीं पड़ता, क्योंकि परिणाम समान हैं।
• संख्या से बड़ा हो सकता है 9।
• आप आउटपुट में एक से अधिक बार एक ही नंबर शामिल नहीं कर सकते हैं। इसलिए [[1],[1]]अनुमति नहीं है।
• ध्यान दें कि यह ऑपरेशन सराहनीय नहीं है ! मैंने P से पहले Q लगाया, क्योंकि यही विकिपीडिया ने किया था। आप कोई भी आदेश चुन सकते हैं, लेकिन यदि यह अलग है तो निर्दिष्ट करें।
• सबसे छोटा कोड जीतता है
• बिल्ट-इन की अनुमति है, लेकिन यदि आप एक का उपयोग करते हैं, तो इसका उपयोग किए बिना एक समाधान दिखाएं।

उदाहरण:

सभी समान आउटपुट संभावनाओं को नहीं दिखाया गया है

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

Comments

मेरे लिए, ये क्रमपरिवर्तन हैं , क्रमपरिवर्तन समूह नहीं । एक क्रमपरिवर्तन समूह एक संग्रह है, जो इस संरचना ऑपरेशन के तहत बंद है, व्यक्तिगत क्रमपरिवर्तन का एक समूह है।

— ग्रेग मार्टिन

@GregMartin फिक्स्ड शब्दावली

— mbomb007 19

Answer 1

जे , 7 बाइट्स

C.@C.@,

इसे ऑनलाइन आज़माएं!

Comments

आपका आउटपुट आपके इनपुट के रूप में उपयोग करने में सक्षम होना चाहिए।

— mbomb007

@ mbomb007 आउटपुट इनपुट के रूप में प्रयोग करने योग्य है। साइकिल की प्रत्येक सूची में बॉक्सेड सरणियों का 0-अनुक्रमित सरणी होना चाहिए।

— मील

या यह J का डिफ़ॉल्ट प्रिंट व्यवहार है? मैं सिर्फ यह सुनिश्चित करना चाहता हूं कि फ़ंक्शन को जंजीर बनाया जा सके।

— mbomb007

@ mbomb007 हां यह केवल इसका दृश्य प्रतिनिधित्व है। इसे 0-अनुक्रमित किया जाना है, लेकिन मेरे पास इसे 1-अनुक्रमित के रूप में सूचीबद्ध किया गया है और फ़ंक्शन में पारित होने के लिए चर में संग्रहीत करने से पहले उन्हें 0-सूचकांक में परिवर्तित कर दिया है। फिर बाद में, मैं इसे आउटपुट करने से पहले 0-अनुक्रमित से 1-अनुक्रमित में वापस परिवर्तित करता हूं।

— मील

Answer 2

गणितज्ञ, 15 बाइट्स

##⊙Cycles@{}&

हाँ वर्जीनिया, एक बिलिन है .... गणितज्ञ साइकल नोटेशन में पहले से ही एक क्रमचय डेटा प्रकार का समर्थन करता है: यह शुद्ध कार्य इनपुट के रूप में किसी भी संख्या में तर्कों को लेता है Cycles[{{1, 5}, {2, 4}}]और उत्पाद के क्रमांकन को फिर से Cycles[]फॉर्म में आउटपुट करता है । यह ओपी के रूप में विपरीत ऑर्डरिंग कन्वेंशन का उपयोग करता है, इसलिए उदाहरण के लिए,

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

लौटता है Cycles[{{1, 4, 3, 5}}]। ⊙मैंने जो प्रतीक ऊपर इस्तेमाल किया है, वह वास्तव में 3-बाइट वाला निजी-उपयोग वाला यूनिकोड प्रतीक U + F3DE होना चाहिए जो गणितज्ञ के काम में आता है। ध्यान दें कि इस ऑपरेशन के लिए मैथेमेटिका का एक नाम बिलिन है PermutationProduct, लेकिन यह तीन बाइट्स लंबा है।

Answer 3

हास्केल , 157 148 बाइट्स

संपादित करें:

• -9 बाइट्स: कि वास्तव में अधिक गोल्फ हो सकता है। चारों ओर निरर्थक कोष्ठक हटा दिए गए p++q। का स्वैग तर्क आदेश g। के साथ dशुरू करने से छुटकारा मिल गया , जिसके बाद अब + के साथ बंधे नहीं । काफिर बना दिया ।iteratep xtakeWhilefstspaniterate

ऐसा करते हुए मुझे देर हो रही है ... शायद कुछ और गोल्फ कर सकते हैं।

यह सरल था, और इसकी अनुमति दी गई थी, इसलिए आउटपुट में एकल-तत्व चक्र शामिल हैं।

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 ppविच्छेदन चक्र रूप से क्रमचय को एक फ़ंक्शन में परिवर्तित करता है, जिसके बाद f qऔर f pसामान्य रचना ऑपरेटर के साथ रचना की जा सकती है .।
  • सूची चक्रों के माध्यम से पुनरावृत्ति करती है c, aइसके उत्तराधिकारी की खोज और खोज करती है। यदि समझ कुछ नहीं पाती है, aतो बस वापस आ जाती है।
  • zip(0:c)(c++c)cऔर उनके उत्तराधिकारियों के तत्वों की जोड़ी की एक सूची है । चूँकि प्रश्न हमें "एक पर शुरू" करने देता है इसलिए हम 0डमी मूल्य के रूप में उपयोग कर सकते हैं ; यह दूसरे पक्ष पर zipप्रयोग करने की तुलना में पहले तर्क के लिए सस्ता है tail।
• g l plतत्वों की एक सूची और एक क्रमपरिवर्तन फ़ंक्शन लेता है , और pतत्वों को छूने वाले चक्रों की सूची लौटाता है।
  • यहां सूची का cपहला तत्व युक्त चक्र है x, अन्य तत्वों cको p xतब तक पुनरावृत्त करके पाया जाता हैx है। जब शेष चक्रों को खोजने के लिए पुनरावृत्ति होती है, तो सभी तत्वों cको पहले सूची समझ के साथ हटा दिया जाता है।

Comments

परिणाम की गणना करते समय उस आदेश को नोट करने के लिए धन्यवाद। मैं एक उदाहरण जोड़ना या इसके बारे में टिप्पणी करना भूल गया। वह ठीक हो गया है।

— mbomb007 18

Answer 4

पायथन, 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

Comments

साइट पर आपका स्वागत है। मैं काफी कुछ ऐसे तरीके देखता हूं जिनसे आप इसे छोटा कर सकते हैं। अजगर के लिए सुझाव पृष्ठ की जाँच करने पर विचार करें ।

— तदर्थ गार्फ हंटर

Answer 5

पायथन 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के एक सेट के रूप में उत्पाद क्रमपरिवर्तनSTDERR ।

व्याख्या

फ़ंक्शन gपाता iहै कि क्रमांकन में नंबर के लिए कौन से नक्शे हैं p(उर्फ 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उस संख्या में वापस करता है । लौटा चक्र एक ट्यूपल होगा, जिसे इस तरह से स्वरूपित किया जाएगा कि सबसे छोटा तत्व इंडेक्स 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समान ट्यूपल (इंडेक्स 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
    )
  }
)