कोड-गोल्फ: क्रमपरिवर्तन

Question

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

पायथन (95 वर्ण) :

p=lambda s:s and sum(map(lambda e:map(lambda p:[e]+p,p(filter(lambda x:x!=e,s))),s),[]) or [[]]

एक ही भाषा में पिटाई करना अच्छा होगा, लेकिन अन्य भाषाओं में कार्यान्वयन स्वागत से अधिक है!

Answer 1

पायथन - 76 वर्ण

Gnibbler की तुलना में लंबा है, लेकिन खरोंच से चीजों को लागू करता है।

p=lambda x:x and[[a]+b for a in x for b in p([c for c in x if c!=a])]or[[]]

Comments

मुझे यहाँ समझ का उपयोग पसंद है। यह वास्तव में मैं एक बहुत पोस्ट कोड सरल करता है!

— zxul767

Answer 2

पायथन, 52

इनपुट एक सेट है। आउटपुट सूचियों की एक सूची है।

f=lambda a:[p+[x]for x in a for p in f(a-{x})]or[[]]

यह उस उत्तर की तुलना में कम है जो एक बिल्डिन के साथ सभी काम करता है ।

Answer 3

जे, 11 वर्ण

(i.@!@#A.[)

उपयोग:

   (i.@!@#A.[) 1 3 5
1 3 5
1 5 3
3 1 5
3 5 1
5 1 3
5 3 1

स्पष्टीकरण:

i.@!@# किसी सूची को 0 से (n) -1 में लौटाने के लिए तीन क्रियाओं का उपयोग करता है -1 जहाँ n दी गई सूची में वस्तुओं की संख्या है।

[सूची को ही लौटाता है। दिखाया गया है कि उदाहरण में 0 1 2 3 4 5 A. 1 3 5।

A.पहली सूची में प्रत्येक आइटम के लिए दूसरी सूची का एक संभावित क्रमांकन लौटाता है (इस तरह का - उचित विवरण यहां दिया गया है )।

Comments

J के बारे में जानकारी के लिए एक लिंक प्रदान करें?

— स्पेर

@SRr J वेबसाइट में सी प्रोग्रामर्स के लिए लर्निंग जे और जे के कुछ अच्छे गाइड हैं - और शब्दावली को कवर करने वाला पेज ।

— गैरेथ

Answer 4

पायथन - 55 वर्ण

from itertools import*
p=lambda x:list(permutations(x))

Comments

बिल्कुल नहीं मैं उम्मीद कर रहा था कि लोग लिखेंगे ... लेकिन यह जानना उपयोगी है कि मानक पुस्तकालय में पायथन की ऐसी उपयोगिताएँ हैं।

— zxul767

@ zxul767: पहिया को क्यों मजबूत करें? मानक पुस्तकालय का उपयोग अविश्वसनीय रूप से कुशल साबित होगा ... (और इस मामले में जब गोल्फ के लिए संक्षिप्त कोड के लिए बनाता है ;-)

— ChristopheD

Answer 5

हास्केल, _^४४ ४३

p[]=[[]]
p l=[e:r|e<-l,r<-p$filter(/=e)l]

अनिवार्य रूप से बदसूरत समाधान के समान है, लेकिन सूची की समझ में हास्केल बेहतर है!

---

बेशक, यह भी कर सकता है

30

import Data.List
p=permutations

---

अधिक कुशल दृष्टिकोण, जिसकी समानता की आवश्यकता नहीं है:

92

import Data.List
p[]=[[]]
p l=(\(l,(e:r))->map(e:)$p(l++r))=<<(init$zip(inits l)(tails l))

एक भीड़ के रूप में, यह भी काम करता है जब सूची में डुप्लिकेट तत्व होते हैं।

Comments

इसका सबसे अच्छा हिस्सा यह है कि सूची समझ के साथ 44 लाइन हैस्केल समाधान पायथन समाधान से कम है जो मानक पुस्तकालय का उपयोग करता है।

— मोनिडिक

p=Data.List.permutations। हालांकि यह धोखा लगता है। इसके अलावा, Data.List.permutationslexicographic क्रम में क्रमपरिवर्तन का उत्पादन नहीं करता है।

— जॉन ड्वोरक

आप p[]=[[]]दो बाइट को सहेजने के बजाय एक आधार मामले के रूप में लिख सकते हैं ।

— लिन

@ मोरिस: सही है! मैंने किसी तरह यह मान लिया कि रिक्त सूची में परिभाषा के अनुसार शून्य क्रमपरिवर्तन होगा, लेकिन 0 से! = 1 कि स्पष्ट रूप से कोई मतलब नहीं है। एक खाली आधार मामला होने से बहुत अच्छा है।

— चालू करना बंद कर दिया

Answer 6

क्यू में (48)

g:{$[x=1;y;raze .z.s[x-1;y]{x,/:y except x}\:y]}

नमूना उपयोग:

q)g[3;1 2 3]
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

Answer 7

रूबी - 23 वर्ण

f=->x{p *x.permutation}

उदाहरण के लिए f[[1,2,3]] यह आउटपुट ।

लेकिन उपयोग करना [].permutationधोखा देने जैसा लगता है, इसलिए:

रूबी - 59 वर्ण

f=->a{a.size<2?[a]:a.flat_map{|x|f[(a-x=[x])].map{|y|x+y}}}

के साथ परीक्षण किया गया

100.times.all?{arr=(1..99).to_a.sample(rand(5)); arr.permutation.to_a==f[arr]}
=> true

Comments

यदि आप चाहें, तो आप अपने कोड को IdeOne: ideone.com/crvtD

— Mr. Llama

अंतर्निहित भाषा सुविधाओं का उपयोग धोखा क्यों होगा?

— मार्क थॉमस

@ मर्क शायद धोखा नहीं दे रहा है, लेकिन बहुत मज़ेदार भी नहीं है, एक फ़ंक्शन लिखने के लिए जो सिर्फ एक अंतर्निहित फ़ंक्शन को कॉल करता है। उदाहरण के लिए: " f(array) { return array.sort(); }

— अरेंज

Answer 8

पायथन - 58 वर्ण

इनपुट के रूप में एक सेट लेने से, बदसूरत से थोड़ा कम:

p=lambda x:x and[[y]+l for y in x for l in p(x-{y})]or[[]]

Answer 9

सी, 270 243 239 वर्ण

#define S t=*a;*a=a[i];a[i]=t;
#define R o=p(n,r-1,a+1,o,r-2,0)
int*p(n,r,a,o,i,t)int*a,*o;{if(!r)for(;n;--n)*o++=*--a;else{R;for(;i;--i){S R;S}}return o;}
P(n,a)int*a;{int N=1,i=n;for(;i;N*=i--);return p(n,n,a,malloc(N*n*8),n-1,0)-N*n;}

फ़ंक्शन P (n, a) n को पॉइंटर लौटाता है! एक, एक विशाल सरणी में एक के बाद एक पैक किया गया।

Comments

कुछ सुझाव: <malloc.h> isn't needed (ignore the warnings). sizeof n` 4 है (पोर्टेबिलिटी अच्छी है, लेकिन कम अच्छा है)। चर (जैसे p(n,a,N,i)) के रूप में अतिरिक्त मापदंडों का उपयोग करें । int*p(..)int*a,o;। मापदंडों और वापसी मूल्यों के बजाय वैश्विक चर का उपयोग करना अक्सर मदद करता है।

— 21

@ यूगोरेन, सुझावों के लिए धन्यवाद। अब तक, मैंने यह नहीं देखा कि ग्लोबल्स का उपयोग करके किसी भी अन्य पात्रों को कैसे दाढ़ी जाए। (और हे, फ़ंक्शन थ्रेड-सेफ है जैसा कि यह है!)

— माइकल रेडफोर्ड

Answer 10

के, 30 बाइट्स

{x@v@&((#x;1)~^=:)'v:!(#x)##x}

कोई निर्मित नहीं!

Answer 11

जेएस - 154 146 चरस

function f(x){var a=[],m;(m=x.length)>1?f(x.slice(1)).map(function(y){for(l=m;l--;a.push(y.slice(0,l).concat(x[0],y.slice(l))));}):a=[x];return a}

टेस्ट: यहf([1,2,3,4,5]).map(function(a){return a.join('')}).join('\n') लौटाता है ।

Answer 12

आर

चूंकि हम क्रमपरिवर्तन के बारे में बात कर रहे हैं, मुझे आर में कम से कम एक समाधान दिखाने दें:

library(gtools);v=c(3,4,5);permutations(length(v),length(v),v)

Answer 13

पर्ल 188

कोई लाइब्रेरी रूटीन नहीं, कोई रिकर्सन नहीं

sub p{$l=(@_=sort split'',shift)-1;while(print@_){$k=$j=$l;--$k while($_[$k-1]cmp$_[$k])>=0;$k||last;--$j while($_[$k-1]cmp$_[$j])>=0;@_[$j,$k-1]=@_[$k-1,$j];@_[$k..$l]=reverse@_[$k..$l]}}

Answer 14

स्केल 30:

def p(s:Seq[_])=s.permutations 

स्काला 195, quick'n'dirty, बिना क्रमपरिवर्तन पुस्तकालय से:

def c(x:Int,t:List[_]):List[_]={val l=t.size
val o=x%l
if(l>1){val r=c(x/l,t.tail)
r.take(o):::(t.head::r.drop(o))}else
t}
def p(y:List[_])=(0 to(1 to y.size).product).foreach(z=>println(c(z,y)))

val y=List(0,1,2,3)
p(y)

स्केल 293, पूर्ण विकसित, टाइप इट्रेटर:

class P[A](val l:Seq[A])extends Iterator[Seq[A]]{
var c=0
val s=(1 to l.size).product
def g(c:Int,t:List[A]):List[A]={
val n=t.size
val o=c%n
if(n>1){val r=g(c/n,t.tail)
r.take(o):::(t.head::r.drop(o))
}else
t}
def hasNext=c!=s
def next={c+=1
g(c-1,l.toList)}
}
for(e<-new P("golf"))println(e)

Answer 15

पायथन - 50 वर्ण

import itertools
list(itertools.permutations("123"))

Comments

इसे 5 साल बाद क्यों घटाया जाएगा?

— जेरेड बुरो

Answer 16

अजगर, 4 बाइट्स

L.pb

हाँ, इस चुनौती को पोस्ट करने और सभी के बाद Pyth बनाया गया था। यह अभी भी वास्तव में अच्छा है। : डी

लाइव डेमो।

स्टड से पढ़ना एक बाइट कम है:

.pQ

Answer 17

जावास्क्रिप्ट 143 136 134 123

function p(s,a="",c="",i,z=[]){a+=c,i=s.length
!i?z.push(a):0
for(;i--;s.splice(i,0,c))p(s,a,c=s.splice(i,1),0,z);return z}

var perms = p([1,2,3]);

document.getElementById('output').innerHTML = perms.join("\n");

<pre id="output"></pre>

Comments

मुझे लगता है कि आप 8 बाइट्स हासिल कर सकते हैं: js function p(s,a="",c="",i,z=[]){ इसके बजाय js function p(s,a,c,i,z){if(!z)a=c="",z=[]

— शीतके

धन्यवाद कोल्डके। यह काम किया और अब 8 बाइट्स छोटा है।

— वोल्फहैमर

Answer 18

ब्रेकीलॉग , 2 बाइट्स

pᵘ

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

 ᵘ    Find every unique
p     permutation of the input.

Answer 19

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

from itertools import*;lambda x:list(permutations(x))

Comments

यह मूल रूप से एक अन्य प्रस्तुत जवाब का एक डुप्लिकेट है । मुझे लगता है कि आप इसके साथ स्वतंत्र रूप से आए (और आपने इसे बेहतर ढंग से गोल्फ किया), लेकिन मुझे लगा कि यह डुप्लिकेट को इंगित करने के लायक है।

Answer 20

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

Œ!

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

बिल्डरों के लिए याय!

Answer 21

के (ओके) , 3 बाइट्स

समाधान

prm

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

स्पष्टीकरण:

यह एक 3 बाइट अंतर्निहित 47 बाइट फ़ंक्शन में निर्मित शॉर्टकट है :

{[x]{[x]$[x;,/x ,''o'x ^/:x;,x]}@$[-8>@x;!x;x]}

... जिसे 23 बाइट्स तक छोटा किया जा सकता है अगर हम जानते हैं कि हमें इनपुट के रूप में चींटियों की एक सूची मिल रही है:

{$[x;,/x,''o'x^/:x;,x]} / golfed built in
{                     } / lambda function with implicit input x
 $[ ;             ;  ]  / if[condition;true;false]
   x                    / if x is not null...
             x^/:x      / x except (^) each-right (/:) x; create length-x combinations
           o'           / call self (o) with each of these
       x,''             / x concatenated with each-each of these results (this is kinda magic to me)
     ,/                 / flatten list
                    ,x  / otherwise enlist x (enlisted empty list)

Answer 22

Axiom, 160 बाइट्स

p(a)==(#a=0=>[[]];r:=[[a.1]];r:=delete(r,1);n:=#a;m:=factorial n;m>1.E7=>r;b:=permutations n;for j in 1..m repeat(x:=b.j;r:=concat([a.(x.i)for i in 1..n],r));r)

ungolfed

--Permutation of a
pmt(a)==
     #a=0=>[[]]
     r:=[[a.1]]; r:=delete(r,1) -- r has the type List List typeof(a)
     n:=#a
     m:=factorial n
     m>1.E7=>r
     b:=permutations(n)         --one built in for permutation indices 
     for j in 1..m repeat
        x:=b.j
        r:=concat([a.(x.i) for i in 1..n],r)
     r

यह सब एक लाइब्रेरी फ़ंक्शन को कहते हैं जो इंडेक्स पर क्रमोन्नति (केवल पूर्णांकों के रूप में [1] पर क्रमपरिवर्तन के रूप में पूर्णांक, [1,2] पर क्रमोन्नति, [1,2,3] आदि पर क्रमपरिवर्तन) प्रदान करता है। तो क्या यह इन सेट के लिए पर्याप्त है। सूचियों का निर्माण और सूचियों का निर्माण; किसी को यह ध्यान रखना होगा कि यह हर प्रकार की X सूची के लिए अच्छा लगता है

(4) -> p([1,2,3])
   Compiling function p with type List PositiveInteger -> List List
      PositiveInteger
   (4)  [[1,2,3],[1,3,2],[3,1,2],[2,1,3],[2,3,1],[3,2,1]]
                                          Type: List List PositiveInteger
(5) -> p([x^2,y*x,y^2])
   Compiling function p with type List Polynomial Integer -> List List
      Polynomial Integer
   (5)
      2      2    2  2        2  2            2  2        2  2    2      2
   [[x ,x y,y ],[x ,y ,x y],[y ,x ,x y],[x y,x ,y ],[x y,y ,x ],[y ,x y,x ]]
                                       Type: List List Polynomial Integer
(6) -> p([sin(x),log(y)])
   Compiling function p with type List Expression Integer -> List List
      Expression Integer
   (6)  [[sin(x),log(y)],[log(y),sin(x)]]
                                       Type: List List Expression Integer
(7) -> m:=p("abc")::List List Character
   Compiling function p with type String -> Any
   (7)  [[a,b,c],[a,c,b],[c,a,b],[b,a,c],[b,c,a],[c,b,a]]
                                                Type: List List Character
(8) -> [concat(map(x+->x::String, m.j))  for j in 1..#m]
   (8)  ["abc","acb","cab","bac","bca","cba"]
                                                        Type: List String

Comments

क्या आपके पास Axiom दुभाषिया का लिंक है? मैं इसे ऑनलाइन आज़माना चाहता हूँ ! , यह एक दिलचस्प भाषा की तरह दिखता है।

— caird coinheringaahing

Answer 23

Japt , 1 बाइट

á

जाप दुभाषिया

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

Answer 24

एपीएल (एनएआरएस), 39 चार्ट, 78 बाइट्स

{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨q w[a∼⍵]}¨a←⍳k}

परीक्षा:

  q←{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨q w[a∼⍵]}¨a←⍳k}
  q 1 2 3
1 2 3  1 3 2  2 1 3  2 3 1  3 1 2  3 2 1 
  q 'abcd'
abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba dabc dacb dbac dbca dcab dcba 

Answer 25

05AB1E - 2 1 बाइट एस

œ

इनपुट एक सरणी / सूची होनी चाहिए।

स्पष्टीकरण:

œ //Takes all the permutations of the elements in the top of the stack (the input is a list, so it would work)

एग्री द आउटकॉलफर को एक बाइट धन्यवाद दिया

Comments

आप एक ही सूची के रूप में इनपुट ले सकते हैं, इसे न्यूलाइन से अलग करने की आवश्यकता नहीं है।

— आउटगोल्फ़र

धन्यवाद! मैं अब इसे एक बाइट को छोटा कर सकता हूं!

— MilkyWay90