एक सूची के विभाजन

Question

इस सवाल का जवाब बहुत लंबा है

आपकी चुनौती सबसे छोटी संख्या में वर्णों में विभाजन कार्य लिखना है ।

इनपुट उदाहरण

['a', 'b', 'c']

आउटपुट उदाहरण

[(('a'),('b'),('c')),
 (('a', 'b'), ('c')),
 (('a', 'c'), ('b')),
 (('b', 'c'), ('a')),
 (('a', 'b', 'c'))]

इनपुट एक सूची / सरणी / सेट / स्ट्रिंग आदि हो सकता है जो आपके फ़ंक्शन को संसाधित करने के लिए सबसे आसान है

जब तक संरचना स्पष्ट नहीं हो जाती, तब तक आप अपने आप को सूट करने के लिए आउटपुट स्वरूप का चयन कर सकते हैं।

आपका कार्य इनपुट में कम से कम 6 वस्तुओं के लिए काम करना चाहिए

Comments

क्या खाली विभाजन भी आउटपुट का हिस्सा हो सकता है?

— फ़ूजक्कल

Answer 1

गोल्फस्क्रिप्ट (43 वर्ण)

{[[]]:E\{:v;{:^E+1/{^1$-\[~[v]+]+}/}%}/}:P;

या

{[[]]:E\{:v;{:^E+1/{^1$-\{[v]+}%+}/}%}/}:P;

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

Answer 2

GolfScript, 51 अक्षर

{[[]]\{[.;]`{1$[1$]+@@`1$`{[2$]-@@[+]+}++/}+%}/}:P;

स्क्रिप्ट एक वैरिएबल को परिभाषित करती है Pजो स्टैक के ऊपर से एक सरणी लेता है और सभी विभाजनों की सूची को पीछे धकेलता है, जैसे

[1 2] P            # => [[[1] [2]] [[1 2]]]
["a" "b" "c"] P    # => [[["a"] ["b"] ["c"]] [["b"] ["a" "c"]] [["a"] ["b" "c"]] [["a" "b"] ["c"]] [["a" "b" "c"]]]

यह बड़ी सूचियों पर भी काम करता है:

6, P ,p            # prints 203, i.e. Bell number B6
8, P ,p            # 4140

आप ऑनलाइन परीक्षण कर सकते हैं ।

Answer 3

जे, 51 अक्षर

([:<a:-.~])"1~.((>:@i.#:i.@!)#l)<@;/."1[l=:;:1!:1[1

कीबोर्ड से इनपुट लेता है, रिक्त स्थान द्वारा अलग किए गए आइटम:

   ([:<a:-.~])"1~.((>:@i.#:i.@!)#l)<@;/."1[l=:;:1!:1[1
a b c
+-----+------+------+------+-------+
|+---+|+--+-+|+--+-+|+-+--+|+-+-+-+|
||abc|||ab|c|||ac|b|||a|bc|||a|b|c||
|+---+|+--+-+|+--+-+|+-+--+|+-+-+-+|
+-----+------+------+------+-------+

Answer 4

हास्केल, 90 87 71 66

सहेजे गए 5 बाइट्स निम्मी के लिए धन्यवाद ।

x#[]=[[[x]]]
x#(y:s)=((x:y):s):map(y:)(x#s)
p=foldr((=<<).(#))[[]]

उदाहरण:

*Main> p "abc"
[["abc"],["bc","a"],["ac","b"],["c","ab"],["c","b","a"]]

Comments

कुछ बाइट्स को बचाने के लिए: के 2 लाइन में कोष्ठकों को पुनर्व्यवस्थित #: :map(y:)(x#s)और एक बिंदु नि: शुल्क संस्करण में लैम्ब्डा बारी: foldr((=<<).(#))[[]]।

— निमि

Answer 5

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

def P(L):
 if len(L)<2:yield[L];return
 for p in P(L[1:]):
	for n,s in enumerate(p):yield p[:n]+[[L[0]]+s]+p[n+1:]
	yield[[L[0]]]+p

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

इस एल्गोरिथ्म का उपयोग करता है ।