परिचय

मैंने पहले की चुनौती में चींटियों के क्रमपरिवर्तन के वर्ग को परिभाषित किया । एक अनुस्मारक के रूप में, 0 से r-1 तक की संख्याओं का एक क्रमपरिवर्तन p है, यदि प्रत्येक प्रविष्टि p [i] को छोड़कर, पहले कुछ है, तो कुछ पहले से प्रवेश p [ik] है जैसे कि p [i] == p [ ik] ± १ । एक मजेदार तथ्य के रूप में, मैंने यह भी कहा कि आर there 1 के लिए , लंबाई आर के बिल्कुल 2 ^{आर -1} चींटी क्रमपरिवर्तन हैं । इसका मतलब है कि लंबाई आर के बंटी क्रमपरिवर्तन और लंबाई -1 के बाइनरी वैक्टर के बीच एक-से-एक पत्राचार है। इस चुनौती में, आपका कार्य इस तरह के पत्राचार को लागू करना है।

काम

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो लंबाई 1 ≤ n , 99 के द्विआधारी वेक्टर में लेता है , और लंबाई n + 1 के एक चींटियों के क्रमपरिवर्तन को आउटपुट करता है । क्रमपरिवर्तन 0-आधारित 1-आधारित हो सकता है (लेकिन यह सुसंगत होना चाहिए), और इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं। इसके अलावा, विभिन्न आदानों को हमेशा अलग आउटपुट देना चाहिए; इसके अलावा, आप जो भी चींटियों की अनुमति चाहते हैं, उन्हें वापस करने के लिए स्वतंत्र हैं।

सबसे कम बाइट गिनती जीतती है।

उदाहरण

(0-आधारित) लंबाई के चींटियों के क्रमपरिवर्तन 4 हैं

और आपके कार्यक्रम को उनमें से प्रत्येक के लिए लंबाई 3 के आठ बिट वैक्टर में से एक को वापस करना चाहिए:

code-golf permutations

— Zgarb
स्रोत

क्या कार्यक्रम इसके बजाय प्रत्येक बाइनरी वेक्टर के पूर्णांक प्रतिनिधित्व को ले सकता है?

— mbomb007

1

@ mbomb007 नहीं, क्योंकि प्रमुख शून्य महत्वपूर्ण हैं। 0 1और 0 0 1अलग-अलग लंबाई के आउटपुट देना चाहिए।

— जर्गर्ब

3

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

ḟẋLṭ+
0;ç/

इसे ऑनलाइन आज़माएं! या लंबाई 4 के सभी क्रमपरिवर्तन उत्पन्न करें ।

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

0;ç/   Main link. Argument: B (bit array)

0;     Prepend a 0 to B.
  ç/   Reduce [0] + B by the helper link.


ḟẋLṭ+  Helper link. Left argument: A (array or 0). Right argument: b (bit)

 ẋ     Repeat A b times, yielding A or [].
ḟ      Filter false; remove the elements of A or [] from A.
  L    Get the length of the resulting array.
       This yield len(A) if b = 0 and 0 if b = 1.
    +  Add b to all elements of A.
   ṭ   Tack; append the result to the left to the result to the right.

— डेनिस
स्रोत

3

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

x=0,
for n in input():x=[t-n+1for t in x]+[n*len(x)]
print x

2 बाइट बंद करने के लिए @xnor को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

क्या आपको अल्पविराम की आवश्यकता है x=0,?

— 20

0,एक टपल है। अल्पविराम के बिना, एक्स पर मैपिंग विफल हो जाएगी।

— डेनिस

मुझे लगता है कि आप कर सकते हैं nकरने के लिए फ्लिप [n*len(x)]और नक्शा एक सूची COMP में बदल जाते हैं।

— xnor

@xnor वास्तव में। धन्यवाद!

— डेनिस

3

पायथन, 54 बाइट्स

lambda l:[i-i*x+sum(l[i:])for i,x in enumerate([1]+l)]

निम्नलिखित प्रक्रिया का उपयोग करता है:

सूची में 1 को प्रस्तुत करें।
प्रत्येक 0 प्रविष्टि के लिए, 0-अनुक्रमित सूची में इसकी स्थिति लिखें।
प्रत्येक प्रविष्टि के लिए, 1 की संख्या को उसके दाईं ओर लिखें, न कि खुद को गिनते हुए।
चरण 2 और 3 प्रविष्टि के परिणामों को जोड़ें।

उदाहरण के लिए, l=[1,0,1,0]देता हैf(l) == [2,1,3,0,4]

List with prepended 1         1 1 0 1 0

0-indexed position for 0's        2   4
Number of 1's to right        2 1 1 0 0
Sum of above two              2 1 3 0 4

एक 0 को प्रस्तुत करना भी एक ही परिणाम देगा। enumerateभद्दा है, अगर यह बेहतर रिकर्सिवली किया जा रहा देखेंगे।

— XNOR
स्रोत

चतुर तकनीक! यह आकर्षक है कि प्रत्येक भाषा में विभिन्न तकनीकें कैसे सर्वोत्तम हैं। मैंने इसे जेएस में पोर्ट करने की कोशिश की, लेकिन यह 57 sumऔर सिंटेक्स की कमी के कारण समाप्त हो गया ।

— 23

3

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

a=>[h=l=0,...a.map(c=>c?--l:++h)].map(e=>e-l)

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

a=>a.reduce((r,b)=>[...r.map(e=>b+e),r.length*!b],[0])

— नील
स्रोत

2

पर्ल, 33 बाइट्स

के लिए +1 शामिल है -p

वेक्टर को स्टैटिन पर रिक्त स्थान के बिना स्ट्रिंग के रूप में दें:

antsy.pl <<< 110

antsy.pl:

#!/usr/bin/perl -p
s%^|.%y/0//+($&?++$a:$b--).$"%eg

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

2

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

v=>[...v,l=0].map(x=>x?l++:h--,h=v.length).reverse()

इसका परीक्षण करें:

f=v=>[...v,l=0].map(x=>x?l++:h--,h=v.length).reverse()
g=v=>console.log(f((v.match(/[01]/g)||[]).map(x=>+x)))

<input oninput="g(this.value)" value="010">

स्निपेट का विस्तार करें

व्याख्या

यह इस तथ्य का लाभ उठाता है कि जब एक चींटियों के क्रमपरिवर्तन को उलट दिया जाता है, तो प्रत्येक वस्तु पिछली कम प्रविष्टियों की अधिकतम से 1 या अधिक होती है, या पिछले उच्च प्रविष्टियों के न्यूनतम से 1 कम होती है। किसी उच्च वस्तु को a 0और निम्न वस्तु के रूप में निरूपित करके 1, हम लंबाई n और 1 के लंबाई के बाइनरी वैक्टर के बीच एक सटीक एक-से-एक पत्राचार बना सकते हैं ।

सबसे अच्छा मैं डेनिस की तकनीक के साथ कर सकता हूँ 57 51 बाइट्स हैं:

v=>v.reduce((x,n)=>[...x.map(i=>i+n),!n*++j],[j=0])
v=>v.map(n=>x=[...x.map(i=>i+n),!n*++j],x=[j=0])&&x

xnor का समाधान 56 है (@Neil के लिए 1 बाइट की बदौलत):

l=>[1,...l].map((x,i)=>i*!x+eval(l.slice(i).join`+`||0))

— ETHproductions
स्रोत

i-i*xहो सकता है i*!x।

— नील

@ नील आह, धन्यवाद।

— ETHproductions

0

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

foldl(\r a->map(+0^a)r++[a*length r])[0]

डेनिस के पायथन सॉल्यूशन गोल्फ के साथ हास्केल में mapऔर शानदार ढंग से fold। यह मेरे सीधे एंट्री वाइज निर्माण को पोर्ट करने के मेरे प्रयासों से कम है :

f l=[i*0^x+sum(drop i l)|(i,x)<-zip[0..]$0:l]
f l=[a+c-b*c|(a,c,b)<-zip3(scanr(+)0l)[0..]$0:l]