एक क्रमचय की समता

Question

पृष्ठभूमि

क्रमपरिवर्तन की समता , के रूप में विकिपीडिया द्वारा परिभाषित किया गया , इस प्रकार है:

क्रमपरिवर्तन के संकेत या हस्ताक्षर को sgn (and) दर्शाया जाता है और +1 के रूप में परिभाषित किया जाता है यदि − सम है और even1 यदि odd विषम है।

क्रमपरिवर्तन का संकेत स्पष्ट रूप से व्यक्त किया जा सकता है

sgn (N) = (−1) ^ N (σ)

जहाँ N (in) (में व्युत्क्रमों की संख्या है।

वैकल्पिक रूप से, क्रमपरिवर्तन के उत्पाद में एक विघटन, के संकेत को इसके अपघटन से परिभाषित किया जा सकता है

sgn (m) = (−1) ^ m

जहां मी अपघटन में प्रत्यारोपण की संख्या है।

आप में से जो अपने गणित में ग्रीक वर्णमाला के सूप के शौकीन नहीं हैं, मैं कोशिश करूँगा और परिभाषा को एक उदाहरण (विकिपीडिया से चुराया गया) के साथ थोड़ा सरल करूँगा।

उदाहरण

इनपुट ऐरे पर विचार करें {1, 2, 3, 4, 5}, और इसे क्रमबद्ध करने दें, आइए बताते हैं {3, 4, 5, 2, 1}। मूल क्रम से इसकी क्रमपरिवर्तन तक प्राप्त करने के लिए, आपको सूचकांकों को स्वैप करना चाहिए 0और 2, 1और 3फिर, 2और 4। हालांकि यह एक अनूठा समाधान नहीं है, समता अच्छी तरह से परिभाषित है, इसलिए यह सभी मामलों के लिए काम करता है।

चूंकि इसमें 3 स्वैप की आवश्यकता होती है, इसलिए हम इस क्रमचय को oddसमता के साथ लेबल करते हैं । जैसा कि आप उम्मीद कर सकते हैं, एक क्रमपरिवर्तन के लिए एक समान राशि की आवश्यकता होती है जिसे evenसमता कहा जाता है ।

चुनौती

आपकी चुनौती क्रमबद्धता की समता निर्धारित करने के लिए यथासंभव कम बाइट्स में एक कार्यक्रम लिखना है। आपका कार्यक्रम या समारोह होना चाहिए:

• तर्क के रूप में स्वीकार करें, दो इनपुट सरणियों (या तार) एक क्रमपरिवर्तन से पहले और बाद में एक सेट का प्रतिनिधित्व करते हैं।
• क्रमपरिवर्तन को देखते हुए eया oविषम के लिए चरित्र को वापस या प्रिंट करें ।
• मान लेना चाहिए कि सरणियों या तारों के सभी सूचकांकों में अद्वितीय मूल्य हैं।

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

मान लिया गया कि आपने एक समारोह घोषित किया है f:

f([10], [10]) == "e"
f([10, 30, 20], [30, 20, 10]) == "e"
f([10, 30, 20, 40], [30, 20, 40, 10]) == "o"

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कार्यक्रम!

Comments

लोग सख्त आउटपुट प्रारूप को पसंद नहीं करेंगे। कैसे के लिए भी सत्य और विषम के लिए मिथ्या? (या आसपास का दूसरा रास्ता)

— कैलकुलेटर

मैं वास्तव में अपने द्वारा निर्दिष्ट आउटपुट प्रारूप को बनाए रखने की उम्मीद कर रहा था जब तक कि कोई और वास्तव में इससे परेशान न हो। संपादित करें , मैं समझौता करूंगा।

— पैट्रिक रॉबर्ट्स

@CatsAreFluffy क्या यह बेहतर है?

— पैट्रिक रॉबर्ट्स 2

खैर, मुझे लगता है कि हम देखेंगे!

— कैलक्यूलेटरफैनलाइन

शुभ रात्रि! जब आप इस पर वापस आते हैं (लेकिन कृपया अपनी जांच करें): [10], [10] -> e(शून्य ट्रांस्पोज़िशन) : के लिए कुछ सुझाव यहां दिए गए हैं । [10 30 20], [30 20 10] -> e(दो प्रत्यारोपण)। [10 30 20 40], [30 20 40 10] -> o(तीन बदलाव)

— लुइस मेंडू

Answer 1

जेली, 13 12 बाइट्स

żṗ2</€⁺Sị“oe

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

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

żṗ2</€⁺Sị“oe  Main link. Arguments: A, B (lists)

ż             Zip A with B. Yields an array of pairs [x, σ(x)].
 ṗ2           Generate all pairs [[x, σ(x)], [y, σ(y)]].
   </€        Reduce each pair by </€.
              This maps [[x, σ(x)], [y, σ(y)]] to [x < y, σ(x) < σ(y)].
      ⁺       Repeat the previous link, i.e., execute </€ once more.
              This maps [x < y, σ(x) < σ(y)] to ((x < y) < (σ(x) < σ(y))), which is
              true if and only if x > y and σ(x) < σ(y).
       S      Sum. This counts the number of inversions.
        ị“oe  Retrieve the letter at the corresponding index.
              Indexing is 1-based and modular, so an odd sum retrieves the first
              letter, an even sum the second.

Comments

वह प्रभावशाली रूप से छोटा है। कुडोस!

— पैट्रिक रॉबर्ट्स

Answer 2

MATL , 17 16 बाइट्स

1 बाइट डेनिस के एक सुझाव के लिए धन्यवाद हटा दिया

2$St!<Rz2\'oe'w)

यह भाषा के वर्तमान संस्करण (15.0.0) में काम करता है ।

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

व्याख्या

यह व्युत्क्रमों के संदर्भ में समता की परिभाषा का उपयोग करता है। एक उलटा दूसरे सरणी में तत्वों की एक जोड़ी है जो पहले सरणी के साथ तुलना में "गलत" क्रम में हैं। चूँकि पहले सरणी को क्रमबद्ध करने की आवश्यकता नहीं है, हम पहले इसे क्रमबद्ध करते हैं और उस क्रमबद्धता के लिए आवश्यक उसी पुनर्व्यवस्था को दूसरे सरणी पर लागू किया जाता है। फिर एक व्युत्क्रम एक जोड़ी तत्वों से मेल खाता है जो दूसरे सरणी में नहीं बढ़ रहा है।

ध्यान दें कि दो इनपुट सरणियों को स्वैप किया जा सकता है और परिणाम समान है। इसलिए यह महत्वपूर्ण नहीं है कि कौन सा सरणी "मूल" माना जाता है और कौन सा "अनुमति"।

2$S     % implicitly take two row vectors. Sort second and apply the indices
        % of that sorting to the first
t!      % duplicate. Transpose into column vector
<       % true for elements of the column vector that exceed those of the 
        % row vector. Gives a 2D array with all pairs of comparisons
R       % keep only upper triangular part of that array
z       % number of nonzero elements. This is the number of inversions
2\      % parity of that number: gives 0 or 1
'oe'w   % push string 'eo' below the top of the stack
)       % apply index to produce 'e' or 'o'. An index 1 refers to the first
        % element, whereas 0 refers to the last. Implicitly display 

Comments

यह वास्तव में चतुर समाधान है!

— एलेक्स ए।

@AlexA। धन्यवाद! मैंने यह स्पष्ट करने के लिए उत्तर को संपादित किया है कि पूर्व-क्रम वाला भाग क्या करता है: हम एक सरणी को क्रमबद्ध करते हैं और फिर उस छँटाई के लिए आवश्यक उसी पुनर्व्यवस्था को दूसरे सरणी पर लागू किया जाता है।

— लुइस मेन्डो

आपको MATL में मॉड्यूलर इंडेक्सिंग को जोड़ना चाहिए। यह यहाँ 3 बाइट्स बचाएगा।

— डेनिस

@ डेनिस हां, मैंने अक्सर इसके बारे में सोचा है ... लेकिन वर्तमान में यह एक प्रारूप का उपयोग करता है जहां नकारात्मक मूल्यों का एक अलग अर्थ है। मैंने x(1:end-2)स्पष्ट रूप से संकेत के बिना फॉर्म आदि के सूचकांकों को चुना है x। यकीन नहीं होता कि यह एक अच्छा विकल्प था, लेकिन मुझे लगता है कि अब इसे बदलने में बहुत देर हो चुकी है :-) शायद मुझे मॉड्यूलर अनुक्रमण जोड़ने का एक सुसंगत तरीका मिल जाएगा

— लुइस मेंडू

... और वर्तमान लंबाई से अधिक सूचकांकों का उपयोग नए मूल्यों को निर्दिष्ट करने के लिए किया जाता है। लेकिन इंडेक्स 0का अर्थ "अंतिम प्रविष्टि" है, इसलिए मैं एक बाइट (वेतन वृद्धि) को बचा सकता हूं। विचार के लिए धन्यवाद!

— लुइस मेन्डो

Answer 3

ऑक्टेव, 56 52 बाइट्स

ऐसा लगता है कि कोई भी अब तक इस दृष्टिकोण का उपयोग नहीं कर रहा है: मूल रूप से मैं बस इसी क्रमबद्धता मैट्रिसेस के निर्धारकों का उपयोग कर रहा हूं। अभिव्यक्ति det(eye(nnz(a))(a,:))वेक्टर द्वारा परिभाषित क्रमचय मैट्रिक्स के निर्धारक को लौटाती है a। फिर परिणाम के आधार पर, स्ट्रिंग से सही चरित्र को निकालने की बात है।

p=@(v)eye(nnz(v))(v,:);@(a,b)'ole'(det(p(a)*p(b))+2)

Comments

निर्धारकों का उपयोग करने के लिए अच्छा विचार है। ओले!

— लुइस मेन्डो

Answer 4

हास्केल, 58 बाइट्स

k%l|m<-zip k l=cycle"eo"!!sum[1|(a,b)<-m,(c,d)<-m,a<c,b>d]

उपयोग:

*Main> [8,3,5]%[5,3,8]
'o'

मेरे पायथन जवाब के रूप में एक ही विधि । गर्वित हेकलर ने एक बाइट को बचाया cycle।

Comments

आप एक बाइट को बचाने के cycle"eo"!!...बजाय लिख सकते हैं "eo"!!mod(...)2।

— गर्वित हैकेलर

Answer 5

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

lambda*M:"eo"[sum(a<b<M>A>B for a,A in zip(*M)for b,B in zip(*M))%2]

उपयोग:

>>> f=lambda*M:"eo"[sum(a<b<M>A>B for a,A in zip(*M)for b,B in zip(*M))%2]
>>> f([8,3,5],[5,3,8])
'o'

दो ज़िपित सूचियों के व्युत्क्रम युग्मों की संख्या की गणना करता है, i, e। मूल्यों (a,A)और (b,B)प्रत्येक सूची से a<bऔर साथ एक ही सूचकांक में A>B। इन तुलनाओं को a<b<M>A>Bउस संपत्ति के रूप में संयोजित किया जाता है जिसका उपयोग Mकिसी भी संख्या से अधिक होता है। योग तो सापेक्ष 2 ले लिया और में बदल गया है eया o।

Answer 6

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

(a,b)=>"eo"[r=0,g=a=>a.map((e,i)=>a.slice(i).map(d=>r^=d<e)),g(a),g(b),r]

चूंकि हम केवल समता में रुचि रखते हैं, इसलिए कोई भी डुप्लिकेट ट्रांस्फ़ॉर्म बस रद्द कर देता है। आसानी से जावास्क्रिप्ट की सरणी सदस्यताएँ बहुआयामी नहीं हैं।

Comments

एक अल्पविराम के लिए दिलचस्प जगह .. पता नहीं था कि आप ऐसा कर सकते हैं। -1 बाइट के लिए करीने की भूल न करें

— पैट्रिक रॉबर्ट्स

Answer 7

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

If[Mod[Plus@@Length/@(Join[{0},#]&)/@PermutationCycles[#][[1]],2]==0,"e","o"]&

मैं सहमत हूँ!

Comments

आसान काम, दुर्भाग्य से लंबे नाम!

— पैट्रिक रॉबर्ट्स

कष्टप्रद, है ना? मुझे नफरत है Cycles। यह PermutationCyclesनाम के आकार से टकराता है , और यहां तक PermutationCyclesकि बेवकूफ होता है, जो किसी Cyclesवस्तु को लौटाता है ! `

— कैलक्यूलेटरफलाइन

Answer 8

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

If[Tr[Signature/@{##}]==0,o,e]&

हस्ताक्षर [सूची] सूची के तत्वों को विहित क्रम में रखने के लिए आवश्यक अनुमति के हस्ताक्षर देता है

हम एक सूची को दूसरी सूची में फिर से व्यवस्थित कर सकते हैं, पहली सूची को किसी भी क्रम में पुन: व्यवस्थित करके (इस मामले में विहित आदेश) और इस सूची को अंतिम सूची में फिर से व्यवस्थित करें। समग्र क्रमपरिवर्तन का संकेत सम है, यदि दो उप-क्रमपरिवर्तन के चिह्न बराबर हैं।