एक पर्म्यूटर का निर्माण

Question

इस चुनौती के लिए आप एक फ़ंक्शन बनाने जा रहे हैं (आपका फ़ंक्शन एक पूर्ण प्रोग्राम हो सकता है) जो किसी सूची को इनपुट के रूप में लेता है और उस सूची का क्रमचय लौटाता है। आपके फ़ंक्शन को निम्नलिखित आवश्यकताओं का पालन करना चाहिए।

• यह निर्धारक होना चाहिए।

• अपने फ़ंक्शन को स्वयं के साथ बार की चर संख्या में लिखना, इसके किसी भी क्रमपरिवर्तन के लिए एक सूची प्राप्त करने में सक्षम होना चाहिए।

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

आगे के नियम

• आप सूची में किसी भी प्रकार, (समय लग सकता है [Integer], [String], [[Integer]]यह के रूप में लंबे समय के रूप)

  • खाली नहीं हो सकता
  • कम से कम 16 संभावित मूल्यों के साथ अलग-अलग ऑब्जेक्ट हो सकते हैं। (आप हास्केल का उपयोग नहीं कर सकते हैं [()]और दावा करते हैं कि आपका कार्य है id)
  • डुप्लिकेट ऑब्जेक्ट्स हो सकते हैं (कोई सेट नहीं)

• आप एक कार्यक्रम या एक समारोह लिख सकते हैं, लेकिन मानक IO का पालन करना चाहिए।

Comments

लेकिन के S_nलिए केवल चक्रीय हैn<3

— लीक नन

@LeakyNun, यह एक एकल क्रमचय के लिए नहीं कह रहा है जो सममित समूह उत्पन्न करता है: यह एक next_permutationफ़ंक्शन के लिए पूछ रहा है ।

— पीटर टेलर

क्या यह केवल 0 और 1 की सूची की अनुमति देने के लिए पर्याप्त होगा?

— xnor

मुझे यकीन नहीं है कि मैं इस प्रतिबंध की बात समझ पा रहा हूं। यदि आप बूलियन्स की सूची की अनुमति देते हैं, तो किसी भी दो अलग-अलग वस्तुओं पर पुनरावृत्तियों की अनुमति नहीं देने का क्या मतलब है?

— डेनिस

@ डेनिस आप एक अच्छी बात करते हैं। मैं बूलियन्स की सूचियों को अस्वीकृत कर दूंगा। या प्रकार जिनके पास 16 से कम संभव मान हैं।

— तदर्थ गार्फ हंटर

Answer 1

CJam (11 बाइट्स)

{_e!_@a#(=}

एक डुप्लिकेट तत्व के साथ चार-तत्व सूची के लिए पूर्ण चक्र दिखा रहा ऑनलाइन डेमो ।

विच्छेदन

{      e# Define a block
  _e!  e#   Find all permutations of the input. Note that if there are duplicate
       e#   elements in the input then only distinct permutations are produced.
       e#   Note also that the permutations are always generated in lexicographic
       e#   order, so the order is independent of the input.
  _@a# e#   Find the index of the input in the list
  (=   e#   Decrement and get the corresponding element of the list
       e#   Incrementing would also have worked, but indexing by -1 feels less
       e#   wrong than indexing by the length, and makes this more portable to
       e#   GolfScript if it ever adds a "permutations" built-in
}

Answer 2

मैथमेटिका + कॉम्बिनेटरिका (बिल्ट-इन पैकेज) 34 बाइट्स

पैकेज को लोड करने के लिए 19 बाइट्स और फंक्शन के लिए 15 बाइट्स।

<<"Combinatorica`";NextPermutation

उपयोग:

%@{c, b, a}

अंतर्निर्मित 61 बाइट्स के बिना

Extract[s=Permutations[Sort@#],Mod[s~Position~#+1,Length@s]]&

कॉम्बिनेटरिका को पूरी तरह से गणितज्ञ में शामिल माना जाता है, लेकिन मुझे लगता है कि नेक्स्टपर्मुटेशन फ़ंक्शन को अनदेखा किया गया था।

Answer 3

पायथन 3 , 90 बाइट्स

from itertools import*
def f(l):p=[*permutations(sorted(l))];return p[-~p.index(l)%len(p)]

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

Answer 4

सी ++, 42 बाइट्स

#include <algorithm>
std::next_permutation

यह सटीक ऑपरेशन C ++ में निर्मित है।

Comments

स्पेस के बाद क्यों #include?

— यति जूल

Answer 5

जावास्क्रिप्ट (ईएस 6), 145 139 137 134 108 बाइट्स

@Neil के लिए धन्यवाद 25 बाइट्स की बचत!

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

a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,a.concat(a.splice(x+1).sort()))

कैसे?

यह लेक्सोग्राफ़िक क्रम में एक पीढ़ी है जो प्रत्येक पुनरावृत्ति पर 4 चरणों की प्रक्रिया करती है:

1. सबसे बड़ा सूचकांक X को ऐसे खोजें जैसे कि [X] <[X + 1]

   a.map((v, i) => v < a[i + 1] ? (t = v, x = i) : ...)

2. X से बड़ा सबसे बड़ा सूचकांक Y खोजें जैसे कि [Y]> [a]

   a.map((v, i) => v < a[i + 1] ? ... : y = i > x & v > t ? i : y)

3. एक [Y] के साथ [X] का मान स्वैप करें

   a[x] = a[y], a[y] = t

4. अनुक्रम को एक [X + 1] से ऊपर और अंतिम तत्व सहित, आरोही लेक्सिकोग्राफिक क्रम में क्रमबद्ध करें

   a.concat(a.splice(x + 1).sort())

उदाहरण:

डेमो

let f =

a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,a.concat(a.splice(x+1).sort()))

for(a = ["A", "B", "C", "D"], n = 0; n < 25; n++) {
  console.log(a.join(','));
  a = f(a);
}

Comments

क्या आप उलटने के बजाय हल नहीं कर सकते? इसके अलावा, मुझे लगता v<a[i+1]&&(t=v,x=i)है कि एक बाइट की बचत होती है, और आप spliceदो sliceएस के बजाय अधिक बचत करने में सक्षम हो सकते हैं ।

— नील

@ नील अच्छी पकड़!

— अरनुलद

मुझे लगता है कि मैं map112 बाइट्स के लिए दोनों एस को मर्ज करने में सक्षम था :a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,t=a.splice(++x).sort(),a.concat(t))

— नील

मुझे मानना ​​पड़ेगा कि मुझे नहीं लगता a.concat(a.splice(++x).sort())था कि मैं काम करने जा रहा था अन्यथा मैंने कोशिश की होती ...

— नील

@ नील धन्यवाद! अपडेट किया गया। (4 के साथ अधिक है क्योंकि हम वास्तव में जरूरत नहीं है बचाया बाइट टी करने के लिए concat () )।

— अरनुलद

Answer 6

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

Œ¿’œ?Ṣ

अवरोही क्रमिक क्रम में क्रमपरिवर्तन के माध्यम से चक्र।

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

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

Œ¿’œ?Ṣ  Main link. Argument: A (array)

Œ¿      Compute the permutation index n of A, i.e., the index of A in the
        lexicographically sorted list of permutations of A.
  ’     Decrement the index by 1, yielding n-1.
     Ṣ  Sort A.
   œ?   Getthe (n-1)-th permutation of sorted A.

Answer 7

सी, 161 बाइट्स

वास्तविक O (n) एल्गोरिथ्म।

#define S(x,y){t=x;x=y;y=t;}
P(a,n,i,j,t)int*a;{for(i=n;--i&&a[i-1]>a[i];);for(j=n;i&&a[--j]<=a[i-1];);if(i)S(a[i-1],a[j])for(j=0;j++<n-i>>1;)S(a[i+j-1],a[n-j])}

उदाहरण उपयोग:

int main(int argc, char** argv) {
    int i;
    int a[] = {1, 2, 3, 4};

    for (i = 0; i < 25; ++i) {
        printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
        P(a, 4);
    }

    return 0;
}

Answer 8

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

x=input()
try:exec'%s=max(k for k in range(%s,len(x))if x[%s-1]<x[k]);'*2%tuple('i1kjii');x[i-1],x[j]=x[j],x[i-1];x[i:]=x[:i-1:-1]
except:x.sort()
print x

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

Comments

मुझे लगता है कि यह एक फ़ंक्शन के रूप में छोटा है जो सूची को इन-प्लेस की अनुमति देता है।

— orlp

मैंने कोशिश की, लेकिन execमुझे एक समारोह में सभी प्रकार की त्रुटियां दीं

— डेनिस

Answer 9

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

ṢŒ!Q©i⁸‘ị®

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

सॉर्ट करें> सभी क्रमपरिवर्तन> इनपुट ढूंढें> 1> अनुक्रमणिका को "सभी क्रमपरिवर्तन" में जोड़ें

Comments

@PeterTaylor मैंने इसे ठीक कर दिया है।

— लीक नन

क्रमपरिवर्तन के लिए विशिष्ट भवन हैं (यानी आप बस कर सकते हैं Œ¿‘œ?Ṣ)। मुझे ऐसा महसूस नहीं हुआ कि मैं चोरी कर रहा हूं, ठीक है, उसी तरह।

— आउटगोल्फ जूल

@EriktheOutgolfer डुप्लिकेट वाले इनपुट के लिए यह थोड़ा गड़बड़ हो सकता है।

— लीक नन

हम्म ... मुझे ऐसा लगता है, मेरे पास एक ऐसा संस्करण था जो पहले के लिए काम करता था लेकिन आप चीज़ का उपयोग करते हैं Q। आप अभी भी गोल्फ कर सकते हैं ṢŒ!Qµi³‘ị।

— निकोलग्राफ जूल

Answer 10

05AB1E , 7 बाइट्स

œêD¹k>è

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

Answer 11

PHP , 117 बाइट्स

निम्न पत्रों की स्ट्रिंग सूची के रूप में इनपुट / आउटपुट लेता है

$a=str_split($s=$argn);rsort($a);if(join($a)!=$s)for($n=$s;($c=count_chars)(++$n)!=$c($s););else$n=strrev($s);echo$n;

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