Superpermutations

26

परिचय

आप नए तकनीकी स्टार्टअप Dejavu से कुछ गुप्त योजनाओं को चुराने वाले अपराधी हैं। आप पिछली दीवार के ऊपर से छलनी करते हैं, लेकिन एक ऐसा दरवाजा खोजें, जिसे खोलने के लिए पिन की आवश्यकता हो। आप लॉक के मेक को पहचानते हैं और जानते हैं कि यह 0 से 4 तक के सभी नंबरों का उपयोग करके 5 अंकों का पिन लेता है। प्रत्येक अंक में प्रवेश करने के बाद, लॉक दर्ज किए गए अंतिम 5 अंकों की जांच करता है और कोड सही होने पर खुलता है। आपको इस लॉक को प्राप्त करना होगा, और तेजी से।

संक्षेप में सुपरपरमुटेशन

एक क्रमचय एक निश्चित समूह के अंकों का सभी संभव संयोजन है। उदाहरण के लिए, अंक 0, 1, 2 के सभी क्रमांकन हैं:

012, 021, 102, 120, 201 और 210।

यदि हम इन सभी क्रमपरिवर्तन को एक साथ जोड़ते हैं, तो हमें एक अतिपरिवर्तन प्राप्त होता है:

012021102120201210

इस अतिपरिवर्तन में 0, 1, 2 के सभी क्रमपरिवर्तन शामिल हैं, लेकिन इससे एक को कम करना संभव है। मैं यहाँ थोड़ा परेशान करने जा रहा हूँ, लेकिन इन अंकों में सबसे छोटा है:

012010210

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

कार्य

आपका कार्य सुपरपरमुटेशन उदाहरण की तुलना में थोड़ा कठिन है, जैसा कि ऊपर दिखाया गया है, क्योंकि आपके पास चिंता करने के लिए दो और अंक हैं। - यदि आपने सुपरपरमुटेशन के बारे में नहीं पढ़ा है, या ऊपर दिया गया मेरा उदाहरण थोड़ा अस्पष्ट था, तो मैं आपको इस विषय पर पैट्रिक ऑनर का यह शानदार लेख पढ़ने का सुझाव देता हूं (यह चुनौती उनके लेख से काफी प्रेरित थी, इसलिए उनके लिए यश:) https://www.quantamagazine.org/unscrambling-the-hidden-secrets-of-superpermutations-20190116/ । आपका लक्ष्य संभवतया सबसे छोटा कार्यक्रम लिखना है जो अंकों के 0 से 4 तक का सुपरपरमुटेशन उत्पन्न करता है।

स्कोरिंग

आपका प्रोग्राम किसी भी प्रकार का कोई इनपुट नहीं लेता है, और 0 से 4 तक अंकों का एक सुपरपरमुटेशन उत्पन्न करता है। इसके परिणामस्वरूप सुपरपरमुटेशन को आपकी पसंद की भाषा द्वारा प्रदान की गई सीमा तक उपयोगकर्ता के लिए प्रदर्शित कंसोल या विज़ुअली में प्रिंट किया जाना चाहिए। इसके लिए सबसे छोटा क्रमपरिवर्तन संभव नहीं है, बस इसे एक मान्य सुपरपरमुटेशन होना चाहिए। इस वजह से, लक्ष्य सबसे छोटा सुपरपरमुटेशन के साथ सबसे छोटा प्रोग्राम लिखना है, इसलिए आपको अपने स्कोर की गणना करनी चाहिए:

फ़ाइल का आकार (बाइट्स) * उत्पन्न सुपरपरमुटेशन लंबाई (अंक)

उदाहरण के लिए, यदि मेरे पास 40 बाइट का कार्यक्रम था, और मेरा सुपरपरमुटेशन 153 अंक लंबा है, तो मेरा स्कोर होगा:

40 * 153 = 6120

हमेशा की तरह, इस स्कोर को कम से कम प्राप्त करने का लक्ष्य है।

खाका

यहां बताया गया है कि आपको अपना उत्तर कैसे देना चाहिए:

भाषा | स्कोर

काम के माहौल में कोड के लिए लिंक (यदि संभव हो तो)

code snippet

कोड स्पष्टीकरण, आदि।

Finalities

यह इस साइट पर मेरे पहले सवालों में से एक है। तो कृपया मुझे बताएं कि क्या मुझे कुछ याद आ रहा है या मेरी चुनौती का एक खंड स्पष्ट नहीं है। धन्यवाद, और मज़ा गोल्फ है!

code-challenge  sequence  permutations 
— इसहाक सी
स्रोत
क्या हम सबसे कम स्कोर का अंदाजा लगाने के लिए सबसे छोटे सुपरपरमुटेशन की लंबाई जान सकते हैं?
— घातक
1
@Fatalize 153 सबसे छोटा है
— TFeld
1
@Fatalize देखें A180632 ।
— अरनौल
1
पहली नज़र में, ऐसा लगता है कि यह सिर्फ एक डी ब्रूजन अनुक्रम के लिए पूछता है; हालाँकि, स्कोरिंग मानदंड इस चुनौती को दिलचस्प बनाता है। बहुत बढ़िया!
— आउटगॉल्फ
3
@EriktheOutgolfer यह सिर्फ एक स्कोरिंग अंतर नहीं है: एक सुपरपरमुटेशन में कुछ लंबाई के सभी क्रमपरिवर्तन शामिल होते हैं, जबकि एक डी ब्रूजन अनुक्रम में कुछ लंबाई के सभी तार शामिल होते हैं।
— एंडर्स कासोर्ग

जवाबों:

6

05AB1E , स्कोर = 1673 (7 बाइट्स · 239)

žBœ∊{3ý

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

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

žB          push 1024
  œ         permutations: ["1024", "1042", …, "4201"]
   ∊        vertically mirror: ["1024", "1042", …, "4201", "4201", …, "1042", "1024"]
    {       sort: ["0124", "0124", "0142", "0142", …, "4210", "4210"]
     3      push 3
      ý     join: "01243012430142301423…3421034210"

पायथ , स्कोर = 1944 (9 बाइट · 216)

s+R+4d.p4

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

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

 +R   .p4   append to each permutation d of [0, 1, 2, 3]:
   +4d        [4] + d
s           concatenate
— एंडर्स कसीर्ग
स्रोत
1
vy3yJएक बाइट बचाता है
— Emigna
1
Pyth कोड में, m+d-> +Rएक बाइट बचाता है।
— isaacg
8
क्या इसे दो अलग-अलग उत्तरों के रूप में पोस्ट करना बेहतर नहीं होगा, क्योंकि दृष्टिकोण और प्रोग्रामिंग भाषा दोनों अलग-अलग हैं?
— केविन क्रूज़सेन
@KevinCruijssen मेह, वे दोनों शेष तत्वों के साथ 4 तत्वों के क्रमपरिवर्तन में शामिल होने के विषय पर भिन्नताएं हैं; मेरे 05AB1E उत्तर में वास्तव में मेरे पाइथ उत्तर के रूप में लगभग उतना ही है जितना कि यह स्वयं के विभिन्न संस्करणों के साथ है। इसलिए मैं केवल दो भाषाओं के लिए नहीं चाहता था, केवल भाषाओं को बदलने के लिए।
— एंडर्स कासोर्ग
3

ब्रेकीलॉग , स्कोर = 2907 (19 बाइट्स × 153)

4⟦pᶠP∧~l.g;Pz{sᵈ}ᵐ∧

कुछ भी देखने के लिए बहुत धीमा है, लेकिन यदि आप अपने 4द्वारा बदलते हैं तो आप 2इसका परीक्षण कर सकते हैं: इसे ऑनलाइन आज़माएं!

यह इस तरह के रूप में सबसे छोटा अध: पतन पाता है:

4⟦                   The range [0,1,2,3,4]
  pᶠP                P is the list of all permutations of this range
     ∧
      ~l.            Try increasing lengths for the output
         g;Pz        Zip the output with P
             {sᵈ}ᵐ   For each permutation, it must be a substring of the output
                  ∧
— Fatalize
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 26975 (325 * 83 बाइट्स)

इस स्कोरिंग प्रणाली के साथ, कम से कम गैर-esolangs में 'हार्डकोड द इष्टतमतम सुपरमुटेशन' और 'सिर्फ एक शॉर्ट-बिल्ट-इन सभी पर्मुनेशंस का उपयोग करने के लिए' के बीच बहुत कम जगह है।

यहाँ वैसे भी एक प्रयास है।

f=(a=[0,1,2,3,4],p=r='')=>a.map((v,i)=>f(a.filter(_=>i--),p+v))|~r.search(p)?r:r+=p

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

यह 325 बाइट्स की एक स्ट्रिंग उत्पन्न करता है:

012340124301324013420142301432021340214302314023410241302431031240314203214032410341203421
041230413204213042310431204321102341024310324103421042310432201342014320314203412041320431
210342104330124301423021430241304123042131024310423201432041321044012340132402134023140312
4032141023410324201342031421034301243021431024320143210
— Arnauld
स्रोत
आपके पास एक वैध बिंदु है, मैं कहूंगा कि मैं स्कोरिंग प्रणाली के बारे में थोड़ा चिंतित था। भविष्य में, मैं और अधिक विचारशील बनने की कोशिश करूँगा और कई तरह के तरीकों से स्कोर कर सकूँगा। : डी
— इसहाक सी
यदि आप 23 बाइट्स 26975/153-153>23
— बायलरप्लेट
@ सेंचुरी हमें एक स्ट्रिंग के लिए 5 बाइट्स बॉयलरप्लेट की आवश्यकता है, या एक बिगआईंट के लिए 4 ।
— अरनुलद
@ सेंचुरी हम स्ट्रिंग को थोड़ा संकुचित कर सकते हैं: इसे ऑनलाइन आज़माएं! (या कम है अगर आप डिफ़ॉल्ट nप्रत्यय की गणना नहीं करते हैं जो console.logआउटपुट करता है)
— नील 20
2

05AB1E , स्कोर: 5355 2160 (216 * 10 बाइट्स )

3ÝœJε4yJ}J

का बंदरगाह @AndersKaseorg का तीखा जवाब , इसलिए उसे उभारना सुनिश्चित करें!

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

स्पष्टीकरण:

3Ý           # Push a list in the range [0,3]: [0,1,2,3]
  œ          # Get all possible permutations of this list
   J         # Join each inner list together to a single string
    ε        # Map each string `y` to:
             #  (Push string `y` implicitly)
     4       #  Push 4
      y      #  Push string `y` again
       J     #  Join all three together
        }J   # After the map: Join all strings together to a single string
             # (and output it implicitly as result)
— केविन क्रूज़सेन
स्रोत
2

ऑक्टेव , 27 x 442 = 11934

'01234'(perms(1:5)'(4:445))

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

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

ऑक्टेव , 97 x 153 = 14841

a=sym(9);while i<120
i=0;a+=1;q='01234';for t=q(perms(1:5))'
i+=any(regexp(char(a),t'));end
end
a

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

कुछ चीजों के लिए प्रवेश अद्यतन

  • a++ प्रतीकात्मक संख्याओं के लिए लागू नहीं किया गया है।
  • contains()ऑक्टेव में लागू नहीं है। के साथ बदला गया any(regexp())।
  • ऑनलाइन लिंक में, मैंने मैन्युअल रूप aसे 153-लंबाई वाले सुपरपरमुटेशन के बहुत करीब प्रवेश किया । यह समाधान को सत्यापित करने की अनुमति देता है।
— Sanchises
स्रोत
2

सीजाम (6 * 240 = 1440)

5e!72>

ऑनलाइन डेमो , सत्यापन (उस सूचकांक को आउटपुट करता है, जिसमें से प्रत्येक क्रमपरिवर्तन होता है0..4 पाया जा सकता है; इसे आउटपुट को समतल करने की आवश्यकता है क्योंकि मूल कार्यक्रम स्टडआउट के लिए उपयुक्त आउटपुट देता है लेकिन यह स्टैक पर जो जगह है वह सीधे उपयोग करने योग्य नहीं है)।

Sanchises से चोरी किया गया दृष्टिकोण , हालांकि CJam का क्रमपरिवर्तन क्रम अलग है, एक अलग विकल्प प्रदान करता है।

सीजाम (22 * 207 = 4554)

0a4{)W@+W+1$)ew\a*W-}/

ऑनलाइन डेमो , सत्यापन ।

विच्छेदन

यह एक सरल पुनरावर्ती निर्माण का उपयोग करता है।

0a       e# Start with a superpermutation of one element, [0]
4{       e# for x = 0 to 3:
  )      e#   increment it: n = x+1
  W@+W+  e#   wrap the smaller superpermutation in [-1 ... -1]
  1$)ew  e#   split into chunks of length n+1
  \a*    e#   insert an n between each chunk
  W-     e#   remove the -1s from the ends
}/
— पीटर टेलर
स्रोत
1

चारकोल , 29 बाइट्स, आउटपुट लंबाई 153, स्कोर 4437

”)⊞⧴�r3⁼Ｈ⁴↓¦σ✳ＬïpＷＳ [Ｔ↑ZωÞ”‖Ｏ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: @TFeld की तरह, मैं सिर्फ एक सुपरपरमुटेशन का आधा प्रिंट करता हूं और इसे दर्पण करता हूं। मैंने निम्नलिखित कोड का उपयोग करके सुपरपरमुटेशन की गणना की:

Push(u, w);
for (u) {
    Assign(Plus(Plus(i, Length(i)), i), h);
    Assign(Ternary(i, Join(Split(w, i), h), h), w);
    Assign(Incremented(Length(i)), z);
    if (Less(z, 5)) for (z) Push(u, Slice(h, k, Plus(k, z));
}
Print(w);

यह चारकोल में एक 45-बाइट कार्यक्रम के लिए अनुवाद करता है इसलिए 6885 स्कोर किया होगा।

— नील
स्रोत
0

पर्ल 6 , 7191 (153 * 47 बाइट्स)

say first *.comb(permutations(5).all.join),0..*

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

पहला नंबर ढूँढता है जिसमें अंक 0 से 4 के सभी क्रमपरिवर्तन होते हैं। इसे निष्पादित करने में लंबा समय लगेगा , लेकिन आप इसे पहले दो क्रमपरिवर्तन 0और परीक्षण कर सकते हैं0,1

— मजाक कर रहा है
स्रोत
0

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 153 * 95 बाइट्स, 14535

Nest[Flatten[Join[#,{Max@#+1},#]&/@Partition[#,Max@#+1,1]]//.{b__,a__,a__,c__}:>{b,a,c}&,{0},4]

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

— J42161217
स्रोत
— एएससीआईआई-केवल
— एएससीआईआई-केवल
— एएससीआईआई-केवल
अच्छा! मैं सिर्फ 153-समाधान पोस्ट करना चाहता था। यदि आप चाहें तो एक नया उत्तर पोस्ट कर सकते हैं
— J42161217
ओह, यह भी ... स्पष्टीकरण pls: पी
— ASCII- केवल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.