ইনপুট হিসাবে পূর্ণসংখ্যার একটি সেট (একটি তালিকা, অ্যারে বা স্বতন্ত্র সংখ্যাগুলির সাথে অন্য কোনও ধারক হতে পারে) লিখুন এবং এর সমস্ত আদেশের তালিকা আউটপুট করে।
পাইথন (95 টি চর) :
p=lambda s:s and sum(map(lambda e:map(lambda p:[e]+p,p(filter(lambda x:x!=e,s))),s),[]) or [[]]একই ভাষায় মারধর করা ভাল লাগবে, তবে অন্যান্য ভাষায় বাস্তবায়ন স্বাগত অপেক্ষা বেশি!
উত্তর:
ইনপুট একটি সেট। আউটপুট হল তালিকার একটি তালিকা।
f=lambda a:[p+[x]for x in a for p in f(a-{x})]or[[]]
এটি উত্তরটির চেয়ে কম যা একটি বিল্টিন দিয়ে সমস্ত কাজ করে ।
(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 থেকে একটি তালিকা ফিরে আসতে তিনটি ক্রিয়া ব্যবহার করে যেখানে n প্রদত্ত তালিকার আইটেমের সংখ্যা।
[তালিকাটি নিজেই ফেরত দেয়। উদাহরণস্বরূপ যে দেয় 0 1 2 3 4 5 A. 1 3 5।
A.প্রথম তালিকার প্রতিটি আইটেমের জন্য দ্বিতীয় তালিকার একটি সম্ভাব্য সারমিটেশন প্রদান করে (ধরণের - যথাযথ ব্যাখ্যা এখানে দেওয়া আছে )।
from itertools import*
p=lambda x:list(permutations(x))
p[]=[[]]
p l=[e:r|e<-l,r<-p$filter(/=e)l]
মূলত উগোরেনের সমাধান হিসাবে একই, তবে হাস্কেল তালিকা বোঝার ক্ষেত্রে আরও ভাল!
import Data.List
p=permutations
import Data.List
p[]=[[]]
p l=(\(l,(e:r))->map(e:)$p(l++r))=<<(init$zip(inits l)(tails l))
ফলস্বরূপ, তালিকায় সদৃশ উপাদান উপস্থিত থাকলে এটিও কাজ করে।
p=Data.List.permutations। যদিও তা প্রতারণার মতো অনুভূত হয়। এছাড়াও, Data.List.permutationsলিক্সোগ্রাফিক ক্রমে ক্রমানুসারে আউটপুট দেয় না।
p[]=[[]]পরিবর্তে একটি বেস কেস হিসাবে লিখতে পারেন , দুটি বাইট সংরক্ষণ করুন।
f=->x{p *x.permutation}উদাহরণস্বরূপ এটি f[[1,2,3]] আউটপুট ।
তবে ব্যবহার করে [].permutationপ্রতারণার মতো বোধ হয়, তাই:
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]}
=> truef(array) { return array.sort(); }
পাইথন - 58 টি অক্ষর
ইনপুট হিসাবে একটি সেট নিয়ে ugoren এর চেয়ে সামান্য খাটো:
p=lambda x:x and[[y]+l for y in x for l in p(x-{y})]or[[]]
#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;}
পি (এন, এ) ফাংশনটি এনকে একটি পয়েন্টার দেয়! এর একের ক্রমবিন্যাস, একের পর এক বিশাল আকারের অ্যারে প্যাক করা।
<malloc.h> isn't needed (ignore the warnings). মাপের এনওটি 4 ( ভেরিয়েবল হিসাবে অতিরিক্ত পরামিতি ব্যবহার করুন (যেমন p(n,a,N,i))। int*p(..)int*a,o;। প্যারামিটারগুলির পরিবর্তে গ্লোবাল ভেরিয়েবলগুলি ব্যবহার এবং রিটার্ন মানগুলি প্রায়শই সহায়তা করে।
{x@v@&((#x;1)~^=:)'v:!(#x)##x}
বিল্টিন নেই!
def p(s:Seq[_])=s.permutations
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)
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)
import itertools
list(itertools.permutations("123"))
L.pb
হ্যাঁ, এই চ্যালেঞ্জটি পোস্ট করার পরে পাইথ তৈরি হয়েছিল এবং সমস্ত কিছু। এটি এখনও সত্যিই দুর্দান্ত। : ডি
স্টিডিনের কাছ থেকে পড়া একটি বাইট সংক্ষিপ্ত:
.pQ
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>js function p(s,a="",c="",i,z=[]){ পরিবর্তে js function p(s,a,c,i,z){if(!z)a=c="",z=[]
from itertools import*;lambda x:list(permutations(x))
সমাধান
prm
ব্যাখ্যা:
এটি নিম্নলিখিত অন্তর্নির্মিত 47 বাইট ফাংশনের একটি 3 বাইট অন্তর্নির্মিত শর্টকাট :
{[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)
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
á
এটি ধাক্কা খেয়েছে এবং জ্যাপের কোনও উত্তর নেই, সুতরাং আমি বুঝতে পেরেছিলাম যে আমি এগিয়ে গিয়ে একটি যুক্ত করব। áযখন অ্যারেতে প্রয়োগ করা হয় এবং কোনও যুক্তি ছাড়াই "সমস্ত অনুমতি পান" এর জন্য অন্তর্নির্মিত। -Rপতাকা অনুবাদক লিঙ্কটি কেবলমাত্র মডিফাই কিভাবে ফলাফলের ছাপা হয় ব্যবহার করা হয়।
{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
œ
ইনপুট অবশ্যই একটি অ্যারে / তালিকা হতে হবে।
ব্যাখ্যা:
œ //Takes all the permutations of the elements in the top of the stack (the input is a list, so it would work)
আউটগলফার এরিকের কাছে একটি বাইট ধন্যবাদ সংরক্ষণ করা