चक्रीय संकेतन में सममित समूह Sn के "सम" को क्रमपरिवर्तित करें

Question

काम

परिभाषाएं

अंक {1,2,3,4,5} और उनके सभी क्रमपरिवर्तन पर विचार करें। हम एक साधारण चाल द्वारा इन 5 बिंदुओं के संभावित क्रमों की कुल संख्या पा सकते हैं: इन बिंदुओं के साथ 5 स्लॉट्स को भरना, पहले स्लॉट में 5 संभावित नंबर होंगे, दूसरा 4 (जैसा कि पहले स्लॉट को भरने के लिए उपयोग किया गया है) तीसरा 3 और इसी तरह। इस प्रकार क्रमपरिवर्तन की कुल संख्या 5 * 4 * 3 * 2 * 1 है; यह 5 होगा! क्रमपरिवर्तन या 120 क्रमपरिवर्तन। हम इसे सममित समूह S5 के रूप में सोच सकते हैं, और फिर सममित समूह Sn में n! or (n*n-1*n-2...*1)क्रमपरिवर्तन होगा ।

एक "सम" क्रमपरिवर्तन वह होता है जहाँ सम चक्र की सम संख्या होती है। यह समझना आसान है, जब चक्रीय अंकन में लिखा जाता है, उदाहरण के लिए (1 2 3)(4 5)परमिट 1->2->3->1और 4->5->4एक 3 लंबाई चक्र (1 2 3)और एक 2 लंबाई चक्र है (4 5)। जब किसी क्रमांकन को विषम के रूप में वर्गीकृत किया जाता है या यहां तक ​​कि हम विषम लंबाई के चक्रों को अनदेखा कर देते हैं और कहते हैं कि यह क्रमांकन [ (1 2 3)(4 5)] विषम है क्योंकि इसमें विषम संख्या {1} सम लंबाई चक्र है। यहां तक ​​कि उदाहरण:

1. (1)(2 3)(4 5)= दो 2 लंबाई चक्र | EVEN |
2. (1 2 3 4 5)= कोई लंबाई चक्र भी नहीं | EVEN | * ध्यान दें कि यदि कोई भी लंबाई चक्र मौजूद नहीं है, तो क्रमपरिवर्तन भी है।

अजीब उदाहरण:

1. (1 2)(3 4 5)= एक 2 लंबाई चक्र | ODD |
2. (1)(2 3 4 5)= एक 4 लंबाई चक्र | ODD |

जैसा कि किसी भी सममित समूह में क्रमपरिवर्तन का आधा हिस्सा है, यहां तक ​​कि हम समूह को प्रत्यावर्ती समूह N भी कह सकते हैं, इसलिए S5 = 120 A5 = 60 क्रमपरिवर्तन।

अंकन

क्रमचय, इसके लिए, कम से कम, चक्रीय अंकन में लिखा जाना चाहिए, जहां प्रत्येक चक्र अलग-अलग कोष्ठक में है और प्रत्येक चक्र आरोही क्रम में जाता है। उदाहरण के लिए (1 2 3 4 5)नहीं (3 4 5 1 2)। और एकल संख्या वाले चक्रों के लिए, जैसे: (1)(2 3 4)(5)एकल / निश्चित बिंदुओं को अर्थ से बाहर रखा जा सकता है (1)(2 3 4)(5) = (2 3 4)। लेकिन पहचान {वह बिंदु जहां सभी बिंदु तय किए जाते हैं (1)(2)(3)(4)(5)} को ()केवल इसे दर्शाने के लिए लिखा जाना चाहिए ।

चुनौती

मैं आपको कम से कम कोड में, किसी भी सकारात्मक पूर्णांक को इनपुट {1,2,3,4 ...} के रूप में लेना चाहूंगा और वैकल्पिक समूह के सभी क्रमपरिवर्तन को प्रदर्शित करूंगा जहां n इनपुट / सभी सम है एसएन के क्रमपरिवर्तन। उदाहरण के लिए:

Input = 3
()
(1 2 3)
(1 3 2)

तथा

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

और उदाहरण के रूप में मैं एक लंबाई के सभी चक्रों को समाप्त करने के लिए चाहूंगा, और पहचान के लिए: कुछ भी नहीं के आउटपुट , (){न केवल कोष्ठक बल्कि जो भी आप अलग-अलग क्रमपरिवर्तन दिखाने के लिए उपयोग कर रहे हैं} या idस्वीकार्य हैं।

अतिरिक्त कारोबार

आपके द्वारा यहां और अधिक जानकारी प्राप्त की जा सकती है:

• https://en.wikipedia.org/wiki/Permutation
• https://en.wikipedia.org/wiki/Alternating_group

सौभाग्य

और जैसा कि यह कोडगॉल्फ है जो भी सबसे कम बाइट्स जीत में अल्टरनेटिंग ग्रुप एन के क्रमपरिवर्तन को प्रिंट कर सकता है।

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! आम तौर पर, हम आउटपुट को लचीला बनाने की अनुमति देते हैं, ताकि जिन भाषाओं को सही प्रारूप में आउटपुट करने में समस्या हो, उनका अनुचित नुकसान न हो। क्या इसके [[1, 2], [3, 4]]बजाय उदाहरण के लिए आउटपुट की अनुमति है (1 2)(3 4)?

— अदनान

@ अदनान हां, मुझे स्पष्ट करना चाहिए। जब तक अलग-अलग चक्रों को अलग-अलग दिखाया जाता है, तब तक कोई समस्या नहीं होनी चाहिए कि आपने इसका प्रतिनिधित्व कैसे किया है।

— हैरी

"एक" यहां तक ​​कि "क्रमपरिवर्तन वह है जहां सम क्रमांक की संख्या भी है।" यह चक्रीय परिभाषा की तरह दिखता है। शायद पहले चक्र संकेतन का परिचय दें और फिर उस वाक्य को "... सम-लंबाई चक्रों की संख्या" को फिर से लिखें?

— मार्टिन एंडर

इसके अलावा, मैं चक्र (2 3 1 4)को आरोही क्रम में कैसे डालूं? क्या आपका मतलब है कि हमें सबसे छोटा तत्व सामने रखना चाहिए?

— मार्टिन एंडर

@MartinEnder हाँ सबसे छोटे तत्व को पहले जाना चाहिए जब तक कि यह ऑर्डर के साथ गड़बड़ नहीं करता है, इसलिए जैसा (2 3 1 4)कि इसके सबसे छोटे तत्व के साथ 2->3->1->4->2लिखा जा सकता है(1 4 2 3)

— हैरी

Answer 1

पायथ, 26 बाइट्स

t#Mf%+QlT2mcdf<>dTS<dTd.pS

          m            .pSQ   Map over permutations d of [1, …, Q]:
             f        d         Find all indices T in [1, …, Q] such that
               >dT                the last Q-T elements of d
              <   S<dT            is less than the sorted first T elements of d
           cd                   Chop d at those indices
   f                          Filter on results T such that
      Q                         the input number Q
     + lT                       plus the length of T
    %    2                      modulo 2
                                is truthy (1)
t#M                           In each result, remove 0- and 1-cycles.

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

यह समाधान एक-पंक्ति संकेतन में क्रमपरिवर्तन और चक्र संकेतन में क्रमपरिवर्तन के बीच एक स्वच्छ जीवनी पर आधारित है। बेशक, वहाँ स्पष्ट पूर्वाग्रह है जहां दो सूचनाएं समान क्रमांकन का प्रतिनिधित्व करती हैं:

[8, 4, 6, 3, 10, 1, 5, 9, 2, 7] = (1 8 9 2 4 3 6) (5 10 7)

लेकिन यह बहुत अधिक कोड ले जाएगा। इसके बजाय, बस एक पंक्ति के नोटेशन को उन सभी नंबरों से पहले टुकड़ों में काटें जो उनके सभी पूर्ववर्तियों से छोटे हैं, इन टुकड़ों को कॉल करें, और उनमें से एक नया क्रमांकन बनाएं।

[6, ४, ६, ३, १०, १, ५, ९, २, ↦] 4 (() (४ ६) (३ १०) (१ ५ ९ २ 6)

इस आक्षेप को उलटने के लिए, हम किसी भी क्रमचय को चक्र रूप में ले सकते हैं, प्रत्येक चक्र को घुमा सकते हैं, इसलिए इसकी सबसे छोटी संख्या सबसे पहले है, चक्रों को क्रमबद्ध करें ताकि उनकी छोटी संख्या घटते क्रम में दिखाई दे और सभी कोष्ठकों को मिटा दें।

Comments

ओपी को एक-चक्र के बिना पहचान की अनुमति की आवश्यकता होती है। मुझे लगता है कि अगर यह मामला नहीं होता तो बेहतर होता।

— मील

हैरी को मेरा जेली उत्तर ठीक लग रहा था, जो 1-चक्र के लिए भी प्रिंट करता है id। शायद वह झंकार कर सकता था?

— लिन

जिस तरह से यह कहा गया है, मैं भी इतना निश्चित नहीं हूं, और मैंने यह नहीं देखा कि आपके (लिन के) समाधान ने भी ऐसा ही किया।

— मील

मेरी समझ यह थी कि आप खाली स्ट्रिंग का उपयोग करते हुए पहचान की अनुमति का प्रतिनिधित्व नहीं कर सकते थे, इसलिए मैंने सभी 1-साइकिल (यह भी आसानी से 6 बाइट्स की बचत) रखने के लिए मेरे उत्तर में संशोधन किया।

— नील

मैंने अपने प्रश्न को और अधिक स्पष्ट करने के लिए संपादित किया है, मैं चाहूंगा कि "एक चक्र" समाप्त हो जाए जैसा आपने अपने उत्तर के दूसरे भाग में किया है। वैसे किया भी है।

— हैरी

Answer 2

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

GroupElements@*AlternatingGroup

दो कार्यों की संरचना। {Cycles[{}], Cycles[{{a, b}}], Cycles[{{c, d}, {e, f}}], ...}प्रतिनिधित्व के रूप में आउटपुट (), (a b), (c d)(e f), ...।

Answer 3

जे , 53 बाइट्स

[:(<@((>:@|.~]i.<./)&.>@#~1<#@>)@C.@#~1=C.!.2)!A.&i.]

प्रत्येक क्रमपरिवर्तन में चक्रों को बॉक्सिंग सरणियों के रूप में दर्शाया जाता है, क्योंकि J शून्य-पैड रैग्ड सरणियों का प्रतिनिधित्व करेगा।

यदि 41 बाइट्स का उपयोग करके आउटपुट को आराम दिया जाता है

[:((1+]|.~]i.<./)&.>@C.@#~1=C.!.2)!A.&i.]

जहां प्रत्येक क्रमचय में एक-चक्र और शून्य-चक्र हो सकते हैं।

प्रयोग

   f =: [:(<@((>:@|.~]i.<./)&.>@#~1<#@>)@C.@#~1=C.!.2)!A.&i.]
   f 3
┌┬───────┬───────┐
││┌─────┐│┌─────┐│
│││1 2 3│││1 3 2││
││└─────┘│└─────┘│
└┴───────┴───────┘
   f 4
┌┬───────┬───────┬─────────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┬─────────┐
││┌─────┐│┌─────┐│┌───┬───┐│┌─────┐│┌─────┐│┌─────┐│┌─────┐│┌───┬───┐│┌─────┐│┌─────┐│┌───┬───┐│
│││2 3 4│││2 4 3│││1 2│3 4│││1 2 3│││1 2 4│││1 3 2│││1 3 4│││1 3│2 4│││1 4 2│││1 4 3│││2 3│1 4││
││└─────┘│└─────┘│└───┴───┘│└─────┘│└─────┘│└─────┘│└─────┘│└───┴───┘│└─────┘│└─────┘│└───┴───┘│
└┴───────┴───────┴─────────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┴─────────┘

वैकल्पिक लागू करने के लिए,

   f =: [:((1+]|.~]i.<./)&.>@C.@#~1=C.!.2)!A.&i.]
   f 3
┌─────┬─┬─┐
│1    │2│3│
├─────┼─┼─┤
│1 2 3│ │ │
├─────┼─┼─┤
│1 3 2│ │ │
└─────┴─┴─┘

Comments

यह वास्तव में सुंदर है ... अच्छी तरह से किया।

— हैरी

Answer 4

जेली , 34 28 बाइट्स

L€’SḂ
ṙLR$Ṃµ€Ṣ
Œ!ŒṖ€;/Ç€ÑÐḟQ

इसे यहाँ आज़माएँ ।

व्याख्या

जेली कार्यक्रम में प्रत्येक पंक्ति एक फ़ंक्शन को परिभाषित करती है; नीचे एक " main" है।

• पहली पंक्ति एक फ़ंक्शन को परिभाषित करती है जो परीक्षण करती है कि क्या एक चक्र उत्पाद विषम है।

  L€      Length of each
    ’     Add 1 to each length 
     S    Take the sum
      Ḃ   Modulo 2
  

• दूसरी पंक्ति [1…n]एक चक्र उत्पाद में क्रमबद्धता के विभाजन को सामान्य करती है:

       µ€    For each list X in the partition:
  ṙLR$          Rotate X by each element in [1…length(X)].
      Ṃ         Get the lexicographically smallest element.
                Thus, find the rotation so that the smallest element is in front.
         Ṣ   Sort the cycles in the partition.
  

  यह जैसे (4 3)(2 5 1)में बदल जाएगा (1 2 5)(3 4)।

यहाँ मुख्य कार्यक्रम है। यह nकमांड लाइन से एक तर्क लेता है , और:

Œ!              Compute all permutations of [1…n].
  ŒṖ€           Compute all partitions of each permutation.
     ;/         Put them in one big list.
       ǀ       Normalize each of them into a cycle product.
         ÑÐḟ    Reject elements satisfying the top function,
                i.e. keep only even cycle products.
            Q   Remove duplicates.

Comments

मैंने इसे इनपुट के रूप में 5 के साथ चलाने की कोशिश की, और इसका कोई आउटपुट नहीं मिला। क्या यह स्क्रिप्ट सिर्फ समूह A3 और A4 के लिए है या क्या यह संभावित रूप से कोई समूह दे सकता है? मैंने पहले कभी भी जेली को नहीं देखा था इसलिए कोई भी स्पष्टीकरण सहायक होगा।

— हैरी

नहीं, मैंने अब तक केवल 3 और 4 ही चालान में डाले हैं, अब तक आप जीत रहे हैं, लेकिन मैं वास्तव में और अधिक सीखना चाहता हूं।

— हैरी

जेली वास्तव में एक अंतर्निहित विभाजन है, जिसके बारे में मैं भूल गया था! शुक्र है, एक दोस्त ने मुझे याद दिलाया। तो अब यह अधिक कुशल है (n = 5, yay!) को संभालता है और छोटा होता है।

— लिन

ओपी ने प्रश्न को स्पष्ट करने के लिए संपादित किया है कि 1-चक्र को समाप्त किया जाना चाहिए।

— एंडर्स कासोर्ग

Answer 5

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 220 218 212 211 बाइट्स

f=(a,p)=>a[2]?[for(i of a)for(j of f(a.filter(m=>m!=i),p,p^=1))[i,...j]]:[[a[p],a[p^1]]]

अफसोस की बात है कि केवल 88 बाइट्स ही वैकल्पिक समूह को उत्पन्न करने की अनुमति के रूप में प्रस्तुत करते हैं a, इसलिए आउटपुट को वांछित प्रारूप में बदलने के लिए मुझे एक अतिरिक्त 132 130 124 123 बाइट्स की लागत आती है:

n=>f([...Array(n).keys()],0).map(a=>a.map((e,i)=>{if(e>i){for(s+='('+-~i;e>i;[a[e],e]=[,a[e]])s+=','+-~e;s+=')'}},s='')&&s)

मैं अपने ES6 संस्करण को 222 216 215 बाइट्स तक नीचे ट्रिम करने में कामयाब रहा :

n=>(g=(a,p,t=[])=>a[2]?a.map(e=>g(a.filter(m=>m!=e),p,[...t,e],p^=1)):[...t,a[p],a[p^1]].map((e,i,a)=>{if(e>i){for(s+='('+-~i;e>i;[a[e],e]=[,a[e]])s+=','+-~e;s+=')'}},s='')&&r.push(s))([...Array(n).keys(r=[])],0)&&r

Comments

मुझे कोई आपत्ति नहीं है जब तक कि प्रारूप सही चक्रीय संकेतन में नहीं है: प्रत्येक क्रमपरिवर्तन और उसके चक्र अलग-अलग दिखाए जाते हैं (जैसे [१ २ ३] [४ ५] और << १२३> <४५ >> दोनों स्वीकार्य होंगे ) और एक लंबाई के चक्र बढ़े हुए हैं। शायद यह आपके जवाब को छोटा कर सकता है

— हैरी

@ हेरी मैं कभी नहीं दिखाऊंगा (1,2,3)(4,5)- यह एक अजीब क्रमचय है! वर्तमान में मैं दिखाऊंगा (1,2,3)(4)(5)- न केवल लंबाई के चक्रों को हटाने से मुझे 6 बाइट्स की लागत मिलती है, फिर मैं पहचान चक्र के लिए एक खाली परिणाम के साथ समाप्त होता हूं जो मुझे ठीक करने के लिए एक और 4 बाइट्स खर्च होंगे।

— नील

अगर आपका मतलब है कि पहचान के लिए कुछ भी नहीं छपा है तो मैं उसे स्वीकार कर लूंगा जैसा कि मैंने कहा as for the identity outputs of nothing ... are accepatble। और यह भी दिखाया जाएगा कि यदि आप अपना "कच्चा डेटा" आउटपुट करते हैं, तो क्या यह फॉर्म (1,2,3) (4) (5) या कुछ और के रूप में आता है?

— हैरी

@ हेरी अब पहचान के लिए एक रिक्त प्रविष्टि सहित लंबाई एक के चक्रों को छोड़कर, और अभी भी एक बाइट को बचाने के लिए प्रबंधन!

— नील

@ हैरी रॉ डेटा [1, 2, 0, 3, 4]उस विशेष उदाहरण के लिए होगा, इसलिए कहीं भी आप क्या चाहते हैं।

— नील

Answer 6

जीएपी , 32 बाइट्स

आधे में गिनती काटने के लिए @ChristianSievers का धन्यवाद।

f:=n->List(AlternatingGroup(n));

प्रॉम्प्ट पर उपयोग:

gap> f(4);
[ (), (1,3,2), (1,2,3), (1,4,3), (2,4,3), (1,3)(2,4), (1,2,4), (1,4)(2,3), (2,3,4), (1,3,4), (1,2)(3,4), (1,4,2) ]

Comments

बहुत अच्छा स्वरूपण, मुझे लगता है कि इस समस्या का जवाब देने के लिए जीएपी एक बहुत अच्छा विकल्प था।

— हैरी

आपका उत्तर यह नहीं दिखाता है कि एक क्रमचय कहां समाप्त होता है और अगला शुरू होता है। मान लें कि फ़ंक्शन को साइड इफेक्ट के रूप में मान प्रिंट करने की आवश्यकता नहीं है, लेकिन इंटरप्रेटर द्वारा मुद्रित की जाने वाली सूची के रूप में मूल्यों को वापस कर सकता है, मैं करूँगाf:=n->List(AlternatingGroup(n));

— क्रिश्चियन सेवर्स