11

पूर्णांकों की एक गैर-रिक्त सूची को देखते हुए, सूची का हर संभव विभाजन आउटपुट करता है जहां प्रत्येक विभाजन एक गैर-खाली सबलिस्ट है।

तो सूची के [1, 2, 3, 4]लिए परिणाम है:

[[1, 2, 3, 4]]
[[1, 2, 3], [4]]
[[1, 2], [3, 4]]
[[1, 2], [3], [4]]
[[1], [2, 3, 4]]
[[1], [2, 3], [4]]
[[1], [2], [3, 4]]
[[1], [2], [3], [4]]

आउटपुट में सूचियों का क्रम मायने नहीं रखता है, इसलिए [[1, 2, 3, 4]]पहले, अंतिम, या जहां भी हो सकता है। तत्वों का क्रम संरक्षित होना चाहिए।

यह कोड-गोल्फ है, इसलिए सबसे कम उत्तर जीतता है।

संबंधित: विभाजन एक सूची!

— mbomb007
स्रोत

2

क्या हम [...]आउटपुट फॉर्मेट में आसपास के को छोड़ सकते हैं ? (जब तक विभाजन स्पष्ट रूप से अलग हो जाते हैं, उदाहरण के लिए लाइनफीड्स।)

— मार्टिन एंडर

इनपुट और आउटपुट प्रारूप लचीले हैं, लेकिन वे समान होने चाहिए। इसलिए यदि इनपुट सूची में एक लाइन पर इसके तत्व हैं, तो आउटपुट सूची भी होनी चाहिए।

— mbomb007

मेरा यह मतलब नहीं था। बैश जवाब पर एक नजर। यह :सूची विभाजक के रूप में उपयोग करता है लेकिन आउटपुट में, विभाजन खुद को अतिरिक्त जोड़ी में नहीं लपेटता है [...]।

— मार्टिन एंडर

या, अलग तरीके से पूछा: चुनौती में आपके उदाहरण प्रारूप में, क्या मैं प्रत्येक पंक्ति से पहली [और आखिरी ड्रॉप कर सकता हूं ]?

— मार्टिन एंडर

1

टिप्स के रूप में एक ही सवाल

— xnor

2

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

ŒṖ

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

— डेनिस
स्रोत

13

रेटिना , 27 19 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

+1%`,
;$'¶$`];[
;
,

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

व्याख्या

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

इनपुट बेस केस के रूप में कार्य करता है: वह विभाजन जहां सभी तत्व अभी भी एक ही सूची में हैं।

+1%`,
;$'¶$`];[

अब हम बार-बार प्रत्येक लाइन पर +पहले ( 1) अल्पविराम ( ) से मेल खाते हैं ,, ( %) (उस लाइन को एक अलग स्ट्रिंग के रूप में मानते हैं, जो $'प्रतिस्थापन में `` $ 1 `के लिए प्रासंगिक है )।

उस अल्पविराम को प्रतिस्थापित किया जाता है:

;   A semicolon. This is just a stand-in for the comma, so we know we've already
    processed it and it won't be substituted again by the next iteration.
$'  Everything after the match. This completes the first (unchanged) version of
    the current line.
¶   A linefeed. Since the next iteration will scan for all lines again, this doubles
    the number of strings we're working with.
$`  Everything before the match. This completes the second (split) version of
    the current line.
];[ A semicolon around which we split the list.

याद रखें कि मैच के बाद और मैच के बाद सब कुछ वैसे भी स्ट्रिंग में रहता है, इसलिए पूर्ण परिणाम वास्तव में है $`;$'¶$`];[$'जो बताता है कि हम उस क्रम में प्रत्यय और उपसर्ग क्यों सम्मिलित करते हैं।

सभी अल्पविराम चले जाने के बाद यह लूप बंद हो जाता है।

;
,

अंत में, इनपुट प्रारूप से मेल खाने के लिए अर्धविराम को फिर से अल्पविराम से बदलें।

— मार्टिन एंडर
स्रोत

10

शुद्ध बैश, 28

eval echo [${1//:/{:,]:[\}}]

यहाँ, सूचियाँ औपनिवेशिक-पृथक हैं, और वर्ग कोष्ठक में समाहित हैं। प्रश्न में उदाहरण के लिए, इनपुट सूची होगी 1:2:3:4और आउटपुट है:

[1:2:3:4] [1:2:3]:[4] [1:2]:[3:4] [1:2]:[3]:[4] [1]:[2:3:4] [1]:[2:3]:[4] [1]:[2]:[3:4] [1]:[2]:[3]:[4]

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

${1//:/REPLACEMENT}में कोलन की जगह $1के साथ{:,]:[\}
यह जैसे ब्रेस विस्तार उत्पन्न करता है [1{:,]:[}2{:,]:[}3{:,]:[}4]
निष्कासन (और सावधानी से \बचना) का कारण होता है ब्रेस का विस्तार अंतिम होना और वांछित परिणाम देना।

यदि दिए गए [[ , , ...]]प्रारूप से मेल खाना आवश्यक है , तो हम इसके बजाय यह कर सकते हैं:

शुद्ध बैश, 47

eval printf '%s\\n' ${1//, /{\\,\\ ,]\\,\\ [\}}

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

— डिजिटल आघात
स्रोत

6

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

./

इनपुट के साथ [1, 2, 3, 4](उदाहरण के लिए)।

स्पष्टीकरण : ./विभाजन ऑपरेटर है। यह इनपुट सूची के सभी प्रभागों को उप-सूचियों में विघटित कर देता है। इनपुट को कार्यक्रम के लिए अंतर्निहित रूप से खिलाया गया है।

इसे ऑनलाइन टेस्ट करें!

— जिम
स्रोत

6

05AB1E , 5 बाइट्स

Œæʒ˜Q

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

Œæʒ˜Q  Main link. Argument l
Œ      Get all sublists of l
 æ     Powerset of those lists
  ʒ˜Q  Filter: Keep the lists that when flattened equal the input

— kalsowerus
स्रोत

1

वाह, यह बहुत साफ जवाब है!

— अदनान १

1

@ अदनान धन्यवाद, मैं भी इससे काफी खुश हूं। यद्यपि यह सब कुछ है लेकिन कुशल है :)

— कलसोवरस

अच्छा जवाब जब वहाँ एक अभी तक नहीं था, मेरे से +1! बस किसी और भविष्य में यहाँ आने के लिए इस छोड़ रहा है, लेकिन 05AB1E अब एक 2-बाइट सभी विभाजनों को पाने के लिए builtin: .œ: यह ऑनलाइन की कोशिश करो।

— केविन क्रूज़सेन

4

पायथन 3 , 82 72 66 बाइट्स

f=lambda l:[k+[l[i:]]for i in range(len(l))for k in f(l[:i])]or[l]

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

-5 बाइट्स @JonathanAllan को धन्यवाद

— OVS
स्रोत

ओह मेरी, मैं फिर से नहीं कर सकता v :( मैं वास्तव में इस तरह की कोशिश की और यह काम नहीं किया, मैं कहीं गलत हो गया होगा

— जोनाथन एलन

1

... किस मामले में 5 और बंद करें

— जोनाथन एलन

1

@JonathanAllan बहुत बहुत धन्यवाद! मैं पुन: उपयोग कर किसी अन्य बाइट बचा सकता है lअंत में

— OVS

यह समाधान यहां पहले से मौजूद है । मैंने प्रश्न पोस्ट करने के बाद TNB में @ Faersum को मैसेज किया, ताकि उसे इसे पोस्ट करने का मौका मिले।

— mbomb007

मेरा मतलब यह नहीं था कि आपको इसे पूर्ववत करना चाहिए, मेरा मतलब सिर्फ यह था कि आप उसे हरा दें। यह निश्चित रूप से आपकी पसंद है।

— mbomb007

4

हास्केल , 59 55 49 बाइट्स

p[x]=[[[x]]]
p(x:r)=do a:b<-p r;[(x:a):b,[x]:a:b]

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

पुनरावर्ती समाधान। उपयोग उदाहरण: p [1,2,3]रिटर्न [[[1,2,3]],[[1,2],[3]],[[1],[2,3]],[[1],[2],[3]]]।

X6 के लिए -6 बाइट्स धन्यवाद !

— Laikoni
स्रोत

1

आप दूसरी पंक्ति को नोटेशन से छोटी लिख सकते हैं: do a:b<-p r;[(x:a):b,[x]:a:b](यह सूचियों के क्रम को बदल देता है)।

— xnor

1

इसके अलावा, <*>वास्तव में आप क्या चाहते हैं [\(a:b)->(x:a):b,([x]:)]<*>p r, हालांकि यह इससे अधिक लंबा है doक्योंकि पहले लैंबडा को एक पैटर्न मैच की आवश्यकता है।

— xnor

3

जे , 42 बाइट्स

<@(</."1)~<:@#_&(][:;<@(,~"{~0 1+>./)"1)0:

लंबाई 1 के विभाजन उपखंड के लिए कुंजी बनाकर और इनपुट सूची की लंबाई के लिए सभी सबलिस्ट पार्टिशन उत्पन्न करता है। प्रत्येक विभाजन सबलिस्ट तब कुंजियों से चयन करके बनाया जाता है।

उदाहरण के लिए, यहां लंबाई 4 सूची के लिए कुंजी बनाने की प्रक्रिया है।

उदाहरण

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

— मील की दूरी पर
स्रोत

3

जे , 26 24 बाइट्स

<@(<;.1)~2#:@(+i.)@^<:@#

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

— मील की दूरी पर
स्रोत

2

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

~c

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

फंक्शन सबमिशन जो एक जनरेटर के रूप में अभिनय के माध्यम से आउटपुट पैदा करता है। (TIO लिंक में परीक्षण प्रयोजनों के लिए इसे एक पूर्ण कार्यक्रम में बनाने के लिए अतिरिक्त कोड है।)

संयोग से, हालांकि तकनीकी रूप से एक बिलिन नहीं है, यह आमतौर पर Brachylog में उपयोग किया जाता है कि a) यह संभवतः एक सिंगल-बाइट प्रतिनिधित्व के योग्य है, और b) cबिलिन अपने इनपुट के बारे में अभिकथन करने के लिए एक पैरामीटर ले सकता है (जबकि अधिकांश बिलिन, एक पैरामीटर कैसे उत्पादन का उत्पादन करने के बारे में बात करता है )।

व्याख्या

~c
~     Find a value with the following properties:
 c      concatenating its elements produces {the input}

2

एपीएल, 26 बाइट्स

{⊂∘⍵¨1,¨↓⍉(X⍴2)⊤⍳2*X←⍴1↓⍵}

परीक्षा:

      {⊂∘⍵¨1,¨↓⍉(X⍴2)⊤⍳2*X←⍴1↓⍵} 1 2 3 4
┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│┌─────┬─┐│┌───┬───┐│┌───┬─┬─┐│┌─┬─────┐│┌─┬───┬─┐│┌─┬─┬───┐│┌─┬─┬─┬─┐│┌───────┐│
││1 2 3│4│││1 2│3 4│││1 2│3│4│││1│2 3 4│││1│2 3│4│││1│2│3 4│││1│2│3│4│││1 2 3 4││
│└─────┴─┘│└───┴───┘│└───┴─┴─┘│└─┴─────┘│└─┴───┴─┘│└─┴─┴───┘│└─┴─┴─┴─┘│└───────┘│
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

स्पष्टीकरण:

X←⍴1↓⍵: इसकी पहली तत्व के साथ (इनपुट सूची) Xकी लंबाई है⍵
⍳2*X: संख्या [1..2 ^ X]
(X⍴2)⊤: बेस -2 उन संख्याओं का प्रतिनिधित्व, Xपदों के साथ (यानी Xखुद को चारों ओर लपेटेंगे 0)।
↓⍉: मैट्रिक्स को घुमाएं और लाइनों के साथ विभाजित करें (⊤ परिणामस्वरूप स्तंभों के साथ संख्याओं के साथ मैट्रिक्स देता है), बिटक्टरों की एक सरणी देता है
1,¨: प्रत्येक बिट वेक्टर के लिए एक 1 प्रस्तुत करना।
⊂∘⍵¨: प्रत्येक बिट वेक्टर के लिए, ⍵प्रत्येक 1 पर विभाजित करें ।

— मारीनस
स्रोत

2

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

foldr(\h t->map([h]:)t++[(h:y):z|y:z<-t])[[]]

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

हास्केल टिप के बारे में सोचने पर मुझे यह समाधान कुछ समय पहले मिला ।

— XNOR
स्रोत

1

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

ovs द्वारा outgolfed (मुझे लगता है कि मैं काम करने की कोशिश की थी कुछ बना: p)

def f(a):r=[[a]];i=len(a)-1;exec("for s in f(a[:i]):s+=[a[i:]];r+=[s]\ni-=1\n"*i);return r

एक पुनरावर्ती फ़ंक्शन जो पूंछ के साथ इनपुट के स्लाइस से विभाजन की सूची बनाता है जब स्लाइस की लंबाई 1 होती है।

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

execएक से अधिक 4 बाइट की बचत होती है whileएक से अधिक या 3 for(नीचे) पाश के बाद से यह केवल दो का मतलब \nखरोज के दो स्तर के बजाय रों, पूरे समारोह एक लाइन पर होना करने के लिए (जबकि टुकड़ा करने की क्रिया के क्रम आवश्यक नहीं है) की इजाजत दी।

def f(a):
 r=[[a]]
 for i in range(1,len(a)):
  for s in f(a[:i]):s+=[a[i:]];r+=[s]
 return r

— जोनाथन एलन
स्रोत

1

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

f=lambda x,n=1:x[n:]and[y+[x[n:]]for y in f(x[:n])]+f(x,n+1)or[[x]]

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

— डेनिस
स्रोत

1

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

x#[]=[[[x]]]
x#(a:b)=[(x:a):b,[x]:a:b]
foldr((=<<).(#))[[]]

— alephalpha
स्रोत

1

रूबी , 62 57 बाइट्स

->l{(0..2**l.size).map{|x|l.chunk{1&x/=2}.map &:last}|[]}

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

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

विभाजन की संख्या 2 ^ (n-1) है: मैं उस सीमा में द्विआधारी संख्याओं पर पुनरावृति करता हूं, शून्य और समूह के समूह लेता हूं और उन्हें प्रारंभिक सूची के सबसेट के रूप में मैप करता हूं।
रेंज के साथ फ़िडलिंग के बजाय, मैं इसे दोहरा बनाता हूं और अंत में डुप्लिकेट को त्याग देता हूं। अब मैं पहले बाइनरी अंक को भी छोड़ सकता हूं और चंक फंक्शन को छोटा कर सकता हूं।

— जीबी
स्रोत

0

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

([e,...a],b=[],c=[e],d=[...b,c])=>1/a[0]?[...f(a,b,[...c,a[0]]),...f(a,d,[a[0]])]:[d]

स्पष्टीकरण: bपिछले उपलेस्ट्स की सूची cहै, वर्तमान सबलिस्ट है, (जो सरणी के पहले तत्व के रूप में शुरू होता है, क्योंकि यह पहले सबलिस्ट में होना चाहिए) जबकि dसभी उप सूची की सूची है। बाकी सरणी तत्वों को फिर से संसाधित किया जाता है। प्रत्येक मामले में दो विकल्प होते हैं: या तो अगला तत्व वर्तमान सबलिस्ट में जोड़ा जाता है, या वर्तमान सबलिस्ट पूरा हो जाता है और अगला तत्व एक नया सबलिस्ट शुरू होता है। पुनरावर्ती परिणाम एक साथ समाप्‍त होते हैं। जब सरणी समाप्त हो जाती है, तो सभी उप सूचीकर्ताओं की सूची का परिणाम होता है।

— नील
स्रोत

0

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

{k←↑⍴⍵⋄x←11 1‼k k⋄y←⍵⋄∪{x[⍵;]⊂y}¨⍳↑⍴x}

यह Nars फ़ंक्शन 11 1 the kk का उपयोग करता है, लेकिन पहले से ही 9 तत्वों के arg सरणी के लिए बहुत धीमा, अनुपयोगी है ...

  P3←{k←↑⍴⍵⋄x←11 1‼k k⋄y←⍵⋄∪{x[⍵;]⊂y}¨⍳↑⍴x}

  ⍴∘P3¨{1..⍵}¨⍳8
1  2  4  8  16  32  64  128 
  P3 'abcd'
abcd    abc d    ab cd    a bcd    ab c d    a bc d    a b cd    a b c d

यह निम्न कार्य है जो बिल्ट इन का उपयोग नहीं करता है:

r←h w;k;i
   r←⊂,⊂w⋄k←↑⍴w⋄i←1⋄→B
A: r←r,(⊂⊂,i↑w),¨h i↓w⋄i+←1
B: →A×⍳i<k

  h 'abcd'
abcd    a bcd    a b cd    a b c d    a bc d    ab cd    ab c d    abc d
  ⍴∘h¨{1..⍵}¨⍳8
2  4  8  16  32  64  128

हम प्रत्येक परिणाम टाइप करते हैं:

  o h ,1
┌──────┐
│┌1───┐│
││┌1─┐││
│││ 1│││
││└~─┘2│
│└∊───┘3
└∊─────┘
  o h 1 2
┌2───────────────────┐
│┌1─────┐ ┌2────────┐│
││┌2───┐│ │┌1─┐ ┌1─┐││
│││ 1 2││ ││ 1│ │ 2│││
││└~───┘2 │└~─┘ └~─┘2│
│└∊─────┘ └∊────────┘3
└∊───────────────────┘

मुझे नहीं पता कि यह कैसे काम करता है, यह केवल हेयूरिस्टिक कोशिश है ...

संभव है कि मैं कुछ त्रुटि करूं; दोनों फ़ंक्शन सूची के विभाजन का निर्माण करते हैं जो भी इनपुट और न केवल 1 2 ... n।

— RosLuP
स्रोत

0

Axiom, 251 बाइट्स

C==>concat;A==>List Any;px(a:A):A==(k:=#a;r:=copy[a];k<=1=>r;i:=1;repeat(i>=k=>break;x:=a.(1..i);y:=a.((i+1)..k);z:=px(y);t:=[x,z.1];for j in 2..#z repeat(w:=(z.j)::A;m:=#w;v:=[x];for q in 1..m repeat v:=C(v,w.q);t:=C(t,[v]));r:=C(r,copy t);i:=i+1);r)

अगर किसी को कुछ बेहतर लगता है ... ungof और परीक्षण:

pp(a:List Any):List Any==
  k:=#a;r:=copy[a];k<=1=>r;i:=1
  repeat
    i>=k=>break
    x:=a.(1..i);y:=a.((i+1)..k);z:=pp(y);
    t:=[x,z.1]
    for j in 2..#z repeat
           w:=(z.j)::List Any
           m:=#w; v:=[x]
           for q in 1..m repeat 
                       v:=concat(v,w.q);
           t:=concat(t,[v])
    r:=concat(r,copy t);
    i:=i+1
  r

(7) -> px []
 (7)  [[]]
                                                           Type: List Any
(8) -> px [1]
 (8)  [[1]]
                                                           Type: List Any
(9) -> px [1,2]
 (9)  [[1,2],[[1],[2]]]
                                                           Type: List Any
(10) -> px [1,2,3]
 (10)  [[1,2,3],[[1],[2,3]],[[1],[2],[3]],[[1,2],[3]]]
                                                           Type: List Any
(11) -> px [1,2,3,4,5,6]
 (11)
[[1,2,3,4,5,6], [[1],[2,3,4,5,6]], [[1],[2],[3,4,5,6]],
 [[1],[2],[3],[4,5,6]], [[1],[2],[3],[4],[5,6]], [[1],[2],[3],[4],[5],[6]],
 [[1],[2],[3],[4,5],[6]], [[1],[2],[3,4],[5,6]], [[1],[2],[3,4],[5],[6]],
 [[1],[2],[3,4,5],[6]], [[1],[2,3],[4,5,6]], [[1],[2,3],[4],[5,6]],
 [[1],[2,3],[4],[5],[6]], [[1],[2,3],[4,5],[6]], [[1],[2,3,4],[5,6]],
 [[1],[2,3,4],[5],[6]], [[1],[2,3,4,5],[6]], [[1,2],[3,4,5,6]],
 [[1,2],[3],[4,5,6]], [[1,2],[3],[4],[5,6]], [[1,2],[3],[4],[5],[6]],
 [[1,2],[3],[4,5],[6]], [[1,2],[3,4],[5,6]], [[1,2],[3,4],[5],[6]],
 [[1,2],[3,4,5],[6]], [[1,2,3],[4,5,6]], [[1,2,3],[4],[5,6]],
 [[1,2,3],[4],[5],[6]], [[1,2,3],[4,5],[6]], [[1,2,3,4],[5,6]],
 [[1,2,3,4],[5],[6]], [[1,2,3,4,5],[6]]]
                                                           Type: List Any
(12) -> [[i,#px i] for i in [[],[1],[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5,6]] ]
 (12)
[[[],1],[[1],1],[[1,2],2],[[1,2,3],4],[[1,2,3,4],8],[[1,2,3,4,5,6],32]]
                                                      Type: List List Any
(13) -> [#px(i) for i in [[],[1],[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5,6]] ]
 (13)  [1,1,2,4,8,32]
                                            Type: List NonNegativeInteger

यदि यह बहुत अधिक स्थान है, तो मैं कहता हूं और मैं उदाहरणों को हटा देता हूं ...

— RosLuP
स्रोत

सभी सबलिस्ट विभाजन उत्पन्न करें

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

रेटिना , 27 19 बाइट्स

व्याख्या

शुद्ध बैश, 28

शुद्ध बैश, 47

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

05AB1E , 5 बाइट्स

पायथन 3 , 82 72 66 बाइट्स

हास्केल , 59 55 49 बाइट्स

जे , 42 बाइट्स

जे , 26 24 बाइट्स

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

व्याख्या

एपीएल, 26 बाइट्स

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

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

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

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

रूबी , 62 57 बाइट्स

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

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

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

Axiom, 251 बाइट्स