क्रमपरिवर्तन करें

17

आकार n का क्रमपरिवर्तन पहले n धनात्मक पूर्णांक का एक पुन: क्रमांकन है । (मतलब प्रत्येक पूर्णांक एक बार और ठीक एक बार दिखाई देता है)। क्रमपरिवर्तन को उन कार्यों की तरह माना जा सकता है जो आकार n की वस्तुओं की सूची के क्रम को बदलते हैं । उदाहरण के लिए

(4 1 2 3) ["a", "b", "c", "d"] = ["d", "a", "b", "c"]

इस प्रकार क्रमपरिवर्तन को कार्यों की तरह बनाया जा सकता है।

(4 1 2 3)(2 1 3 4) = (4 2 1 3)

यह बहुत सारे दिलचस्प गुणों को लाता है। आज हम संयुग्मता पर ध्यान केंद्रित कर रहे हैं । क्रमपरिवर्तन y और x (आकार n के दोनों ) संयुग्म हैं यदि यदि क्रमपरिवर्तन g और g -1 हैं (आकार n का भी ) तो

x = gyg-1

और gg -1 पहचान क्रमचय ( उचित क्रम में पहला n संख्या) के बराबर है ।

आपका कार्य मानक इनपुट विधियों के माध्यम से एक ही आकार के दो क्रमपरिवर्तन लेना है और यह तय करना है कि क्या वे संयुग्म हैं। आपको दो सुसंगत मूल्यों में से एक का उत्पादन करना चाहिए, एक यदि वे संयुग्म हैं और दूसरा यदि वे नहीं हैं।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

संयुग्म परमिट के बारे में बहुत सारी प्रमेय हैं जो आपके निपटान में हैं, इसलिए शुभकामनाएं और खुश गोल्फ।

आप एक ऑर्डर किए गए कंटेनर के मान के रूप में इनपुट ले सकते हैं (या तो 1-एन या 0-एन) ऊपर की तरह क्रमचय का प्रतिनिधित्व करते हैं, या एक फ़ंक्शन के रूप में जो एक ऑर्डर किए गए कंटेनर को लेता है और क्रमांकन करता है। यदि आप फ़ंक्शन लेना चुनते हैं तो आपको इसे पूर्वनिर्धारित नाम पर रखने के बजाय एक तर्क के रूप में लेना चाहिए।

परीक्षण के मामलों

(1) (1) -> True
(1 2) (2 1) -> False
(2 1) (2 1) -> True
(4 1 3 2) (4 2 1 3) -> True
(3 2 1 4) (4 3 2 1) -> False 
(2 1 3 4 5 7 6) (1 3 2 5 4 6 7) -> True
code-golf  decision-problem  combinatorics  permutations  abstract-algebra 
— पोस्ट रॉक गार्फ हंटर
स्रोत
क्या हम एक फ़ंक्शन के रूप में इनपुट ले सकते हैं? क्या हम आकार n में भी ले सकते हैं?
— xnor
@xnor दोनों काउंट पर ज़रूर। मुझे यकीन नहीं है कि पहले आपकी मदद कैसे करेगा।
— पोस्ट रॉक गार्फ हंटर
डिफ़ॉल्ट फ़ंक्शन इनपुट नियम फ़ंक्शन को पूर्वनिर्धारित मानने की अनुमति देते हैं, जो इसे तर्क के रूप में लिखने पर बाइट्स बचाता है, यदि यह अनुमति देता है।
— xnor
@xnor क्या हम इस नियम के बारे में बात कर रहे हैं ? यह ब्लैक बॉक्स फ़ंक्शंस के लिए है जो क्रमपरिवर्तन नहीं हैं। यह समझ में आता है क्योंकि यह सर्वसम्मति से डिज़ाइन किए गए हैं कि बिना फंक्शन पॉइंटर्स / ऑब्जेक्ट्स के भाषाओं को प्रतिस्पर्धा करने की अनुमति दी जाए, क्योंकि वे इसलिए कर सकते हैं क्योंकि क्रमपरिवर्तन का प्रतिनिधित्व अन्यथा किया जा सकता है।
— पोस्ट रॉक गार्फ हंटर
मैं था, मैंने उनके ब्लैक-बॉक्स होने के भेद के बारे में नहीं सोचा था। तो यहाँ, इनपुट एक फ़ंक्शन हो सकता है, लेकिन केवल एक स्पष्ट तर्क के रूप में?
— xnor

जवाबों:

6

पायथन 2 , 87 बाइट्स

f=lambda P,k:k<1or len({sum([x==eval('L['*k+'x'+']'*k)for x in L])for L in P})&f(P,k-1)

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

Pदोनों क्रमपरिवर्तन और kउनकी लंबाई की एक जोड़ी के रूप में इनपुट लेता है । 1संयुग्मों के लिए आउटपुट और 0नहीं।

यह परिणाम का उपयोग करता है:

दो क्रमपरिवर्तन x और y बिल्कुल संयुग्मित होते हैं यदि उनकी k -th शक्तियां x k और y k की संख्या 0 से n तक प्रत्येक k के लिए समान अंक हों ।

दो संयुग्म क्रमपरिवर्तन इस बात को संतुष्ट करते हैं क्योंकि उनकी k -th शक्तियां भी संयुग्मित होती हैं, और संयुग्मता निश्चित बिंदुओं की गिनती को बनाए रखती है।

यह कम स्पष्ट है कि किसी भी दो गैर-संयुग्मक क्रमांकन हमेशा भिन्न होते हैं। विशेष रूप से, संयुग्मता चक्र की लंबाई की क्रमबद्ध सूची द्वारा निर्धारित की जाती है, और इन्हें निश्चित बिंदुओं की गिनती से पुनर्प्राप्त किया जा सकता है। यह दिखाने का एक तरीका रैखिक बीजगणित के साथ है, हालांकि यह ओवरकिल हो सकता है।

चलो एक्स के लिए परिवर्तन मैट्रिक्स हो एक्स । फिर, के निश्चित बिंदुओं की संख्या एक्स कश्मीर है Tr (एक्स कश्मीर ) । ये निशान गुणन के साथ X k के eigenvalues ​​के पावर सम सममित बहुपद हैं । के लिए इन बहुआयामी पद कश्मीर से 0 करने के लिए n हमें इसी की वसूली जाने प्राथमिक सममित बहुआयामी पद इन eigenvalues की है, और इसलिए विशेषता बहुपद और इतने eigenvalues खुद को।

चूँकि ये प्रतिरूप x के चक्रों के अनुरूप एकता की जड़ें हैं , इनसे हम चक्र के आकार और उनके गुणन को ठीक कर सकते हैं। तो, हमारे "हस्ताक्षर" संयुग्मन तक के क्रमपरिवर्तन की पहचान करते हैं।

— XNOR
स्रोत
6

जे , 25 बाइट्स 23 बाइट्स 16 बाइट्स

मील ' टैसिट समाधान:

-:&([:/:~#&>)&C.

ओपी का स्पष्ट समाधान:

c=:4 :'-://:~"1#&>C.&>x;y'

यह जाँच करता है कि क्या पर्मुलेशन x और y में एक ही साइकल टाइप है, C.साइकल रिप्रेजेंटेशन के निर्माण के लिए बिल्ट-इन फंक्शन का उपयोग कर रहा है ।

   4 1 3 2   c   4 2 1 3
1
   3 2 1 4   c   4 3 2 1
0
   2 1 3 4 5 7 6   c   1 3 2 5 4 6 7
1
— मैथियास डोलिडॉन
स्रोत
1
PPCG और अच्छी पहली पोस्ट में आपका स्वागत है। मैंने -:&([:/:~#&>)&C.टैसी फॉर्म का उपयोग करके आपकी विधि को 16 बाइट्स तक छोटा कर दिया । इसे आज़माने के लिए एक TIO लिंक यहां दिया गया है।
— मील
धन्यवाद। :) मैं अभी भी काफी जे शुरुआती हूं, और हालांकि मैं आसानी से इसे स्पष्ट रूपों के साथ अच्छे उपयोग के लिए डाल रहा हूं, कुशल टैकिट रूपों की रचना करना अभी भी मेरे लिए बहुत अधिक विचार की आवश्यकता है। मैं तुम्हारा समाधान जोड़ दूँगा।
— मथियास डॉलीडन
पुनश्च: क्या हम फ़ंक्शन असाइनमेंट के वर्णों की गणना नहीं करते हैं? c=:
— मथियास डॉलीडन
1
@MathiasDolidon नहीं, डिफ़ॉल्ट सर्वसम्मति से, हम असाइनमेंट के लिए आवश्यक वर्णों की गणना नहीं करते हैं, क्योंकि फ़ंक्शन का उपयोग इस तरह किया जा सकता है (कोष्ठक के साथ, लेकिन हम उन्हें गिनते नहीं हैं)।
— को एर्गेल्फ़र से एरिक
1
ठीक ! मैंने इसे ध्यान में रखते हुए शीर्षक में स्पष्ट समाधान के लिए प्रतिवर्ती रूप से अद्यतन किया है।
— मैथियास डॉलीडन
4

MATL , 20 19 17 16 बाइट्स

xY@!"&G@)@b)X=va

इनपुट: दो कॉलम वैक्टर ( ;विभाजक के रूप में उपयोग )। आउटपुट: 1यदि संयुग्म, 0यदि नहीं।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

इस्तेमाल किए गए क्रमपरिवर्तन के बारे में कोई प्रमेय (सरासर अज्ञानता से बाहर); बस क्रूर बल और ये दो तथ्य:

  • दो क्रमपरिवर्तन के लिए पी और क्यू , रचना pq का उपयोग कर के बराबर है पी के तत्वों के सूचकांक को क्ष ।

  • स्थिति x = gyg −1 , xg = gy के बराबर है ।

टिप्पणी कोड:

x      % Implicitly input first permutation, x. Delete it. Gets copied into clipboard G
Y@     % Implicitly input second permutation, y. Push a matrix with all permutations
       % of its elements, each permutation on a different row. So each matrix row is
       % a permutation of [1 2 ...n], where n is the size of y
!      % Transpose. Now each permutation is a column
"      % For each column
  &G   %   Push x, then y
  @    %   Push current column. This is a candidate g permutation
  )    %   Reference indexing. This gives g composed with y
  @    %   Push current column again
  b    %   Bubble up. Moves x to the top of the stack
  )    %   Reference indexing. This gives x composed with g
  X=   %   Are they equal as vectors? Gives true or false
  v    %   Concatenate stack so far. The stack contains the latest true/false result
       %   and possibly the accumulated result from previous iterations
  a    %   Any: gives true if any element is true. This is the "accumulating" function
       % Implicit end. Implicit display
— लुइस मेंडो
स्रोत
2

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 44 बाइट्स

Equal@@(PermutationCycles[#,Sort[0#]&]&/@#)&

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

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 44 बाइट्स

x_±y_:=Or@@(#[[x]]==y[[#]]&/@Permutations@x)

CP-1252 एन्कोडिंग का उपयोग करना, जहां ±एक बाइट है।

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

— alephalpha
स्रोत
2

जेली , 11 बाइट्स

Œ!©Ụ€ịị"®⁸e

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

यह काम किस प्रकार करता है

Œ!©Ụ€ịị"®⁸e  Main link. Left argument: x. Right argument: y

Œ!©          Take all permutations g of x. Copy the result to the register.
   Ụ€        Grade up each; sort the indices of each permutation g by their
             corresponding values. For permutations of [1, ..., n], grading up
             essentially computes the inverse, g⁻¹.
     ị       Let each g⁻¹ index into y, computing g⁻¹y.
      ị"®    Let the results index into the corresponding g, computing g⁻¹yg.
         ⁸e  Test if x occurs in the result.
— डेनिस
स्रोत
जहां तक ​​मैं समझता हूं, यह वास्तव में है yजो प्रत्येक में अनुक्रमित करता है g⁻¹, न कि दूसरे तरीके से। , उदाहरण देखें (4 1 2 3)(2 1 3 4) = (4 2 1 3)। आपके दृष्टिकोण के साथ, इसके (1 4 2 3)बजाय परिणाम होगा , चूंकि दूसरी अनुक्रमणिका पहले में है। इसे ध्यान में रखते हुए, मेरे पास एक 12-बाइट समाधान है जो मैं अभी तक खराब नहीं करूंगा। :-)
— द एग्रीग्राफर से एरिक
@EriktheOutgolfer फिक्स्ड।
— डेनिस
@ डेनिस लेकिन मैं स्पष्टीकरण के आधार पर उस निष्कर्ष पर नहीं आया था, मैं ठीक उसी दृष्टिकोण पर पहुंच गया, सिवाय इसके कि मेरे पास कुछ ऐसा था Œ!©Ụ€⁹ịЀ®ị"⁸e(मूल रूप से सभी उल्टे तर्कों के साथ अनुक्रमण कर रहा था ), सिवाय मेरे छोटे संशोधनों के बाद। मुझे नहीं लगता कि g⁻¹ygऐसा ही है gyg⁻¹। इसके अलावा, मुझे लगता है कि आपका उत्तर उन संशोधनों से भी लाभान्वित हो सकता है, लेकिन, जैसा कि मैंने पहले कहा था, मैं अभी तक मज़ा को बर्बाद नहीं करना चाहता।
— 12
हां, बिलकुल ऐसा ही है। यदि x = g⁻¹yg, तब gxg⁻¹ = y, तो xऔर yसंयुग्मित हैं।
— डेनिस
हम्म, मुझे ऐसा लगता है कि मुझे अपना 12-बाइट समाधान तब प्रकट करना चाहिए:eŒ!ị"Ụị@¥€¥¥
— एरिक द आउटग्राफर
1

भूसी , 9 बाइट्स

¤¦ṠmöLU¡!

1संयुग्म के लिए और 0गैर संयुग्म के लिए रिटर्न । इसे ऑनलाइन आज़माएं!

व्याख्या

L = [1,2, .., n] के क्रमपरिवर्तन P की संयुग्मन कक्षा को बहु के द्वारा निर्धारित किया जाता है जिसमें P के तहत L में प्रत्येक संख्या की कम से कम अवधि होती है । जब P को सूची प्रारूप में लिया जाता है, तो मैं L को P से बदल सकता हूं और एक ही मल्टीसेट प्राप्त कर सकता हूं । कार्यक्रम प्रत्येक इनपुट के लिए संबंधित मल्टीसेट की गणना करता है और जांचता है कि क्या एक दूसरे का उप-मल्टीसेट है। चूंकि उनके पास समान तत्वों की संख्या है, यह एक ही मल्टीसेट होने के बराबर है।

¤¦ṠmöLU¡!  Implicit inputs: two lists of integers.
¤          Apply one function to both and combine with another function.
  ṠmöLU¡!  First function. Argument: a list P.
  Ṡm       Map this function over P:
       ¡!  iterate indexing into P,
      U    take longest prefix with unique elements,
    öL     take its length.
 ¦         Combining function: is the first list a subset of the other, counting multiplicities?
— Zgarb
स्रोत
1

पर्ल, 61 58 57 बाइट्स

के लिए शामिल +2हैap

STDIN पर 2 लाइनों के रूप में 0-आधारित क्रमपरिवर्तन दें

perl -ap '$_=[@1]~~[@1=map{-grep$_-$G[$i++%@G],@F=@G[@F]}@G=@F,0]'
3 0 2 1
3 1 0 2
^D

एल्गोरिथ्म xnor के समाधान में एक पर एक मामूली बदलाव है

कोड का यह पुराना संस्करण एक पर्ल बग को हिट करता है और मेरे नवीनतम पर्ल पर कई इनपुट के लिए कोर को डंप 5.26.1करता है, लेकिन यह एक पुराने पर्ल पर काम करता है 5.16.3।

@{$.}=map{-grep$_==$F[$i++%@F],@G=@F[@G]}@G=@F,0}{$_=@1~~@2

यह संभवतः मेरे पुराने perlgolf दुश्मन का एक और उदाहरण है, तथ्य यह है कि पर्ल अपने स्टैक को ठीक से रिफंड नहीं करता है।

— टन हास्पेल
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 66 64 बाइट्स

(a,b,g=a=>b+a.map(h=(e,i)=>e-i&&1+h(a[e],i)).sort())=>g(a)==g(b)

यदि मैंने अन्य उत्तरों को सही ढंग से पढ़ा है, तो समस्या सभी तत्वों की अवधियों को गिनने और जाँचने के बराबर है कि दोनों सूचियों में प्रत्येक अवधि की संख्या समान है। संपादित करें: अवधि से कम की गणना करके @Arnauld के लिए 1 बाइट का धन्यवाद सहेजा गया। सरणियों की तुलना करने के लिए जावास्क्रिप्ट के अजीब ज़बरदस्ती नियमों का दुरुपयोग करके @Arnauld के लिए एक और बाइट धन्यवाद दिया। एक और बाइट को करीने से बचाया जा सकता है लेकिन मुझे चिकन पसंद नहीं है जब तक कि यह चिकन टिक्का मसाला नहीं है।

— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.