Boş olmayan bir tamsayı listesi verildiğinde, her bölümün boş olmayan bir alt liste olduğu listenin olası tüm bölümlemelerini çıktılar.

Yani liste [1, 2, 3, 4]için sonuç:

[[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]]

Çıktıdaki listelerin sırası önemli değildir, bu nedenle [[1, 2, 3, 4]]ilk, son veya her yerde olabilir. Elemanların sırası korunmalıdır.

Bu kod golf, bu yüzden en kısa cevap kazanır.

İlgili: Bir liste bölümleme!

Jöle , 2 bayt

ŒṖ

Çevrimiçi deneyin!

Retina , 27 19 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

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

Çevrimiçi deneyin!

açıklama

Tabii ki bu, dize işleme kullanarak tüm bölümleri hesaplar. Temel fikir, ,listeyi oraya bölmek isteyip istemediğimize her biri için ayrı ayrı karar vererek tüm bölümleri oluşturabilmemizdir . Bu tür şeyler Retina'da her birini ,sırayla eşleştirerek ve her iki olası çıktıyı veren bir yedek kullanarak yapılabilir.

Girdi temel durum olarak işlev görür: tüm öğelerin hala tek bir listede olduğu bölüm.

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

Şimdi her satırda ( ) +ilk ( 1) virgülünü ( ,) tekrar tekrar ( ) eşleştiriyoruz %(bu satırı $'ikame ile alakalı ve `` $ 1 '' ile alakalı ayrı bir dize olarak ele alıyoruz ).

Bu virgül ile değiştirilir:

;   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.

Maçın önündeki ve maçtan sonraki her şeyin dizede kaldığını unutmayın, bu yüzden tam sonuç aslında $`;$'¶$`];[$'bu eki ve öneki neden bu sırayla eklediğimizi açıklar.

Bu döngü, tüm virgüller gittikten sonra durur.

;
,

Son olarak, giriş biçimiyle eşleşmek için noktalı virgülleri virgülle tekrar değiştirin.

Saf Bash, 28

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

Burada listeler iki nokta üstüste ayrılır ve köşeli parantez içinde bulunur. Örneğin soruda, giriş listesi olacaktır 1:2:3:4ve çıktı:

[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]

Çevrimiçi deneyin .

• ${1//:/REPLACEMENT}içinde iki nokta üst üste değiştirir $1ile{:,]:[\}
• Bu gibi bir küme ayracı genişlemesi oluşturur [1{:,]:[}2{:,]:[}3{:,]:[}4]
• Eval (ve dikkatli \kaçar) küme ayracı genişlemesinin en son gerçekleşmesine neden olur ve istenen sonucu verir.

Verilen [[ , , ...]]formatla tam olarak eşleşmek gerekiyorsa , bunun yerine bunu yapabiliriz:

Saf Bash, 47

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

Çevrimiçi deneyin .

Pyth , 2 bayt

./

Girdi ile [1, 2, 3, 4](örneğin).

Açıklama : ./bölümleme operatörüdür. Giriş listesinin tüm bölümlerini ayrık alt listelere döndürür. Giriş dolaylı olarak programa beslenir.

Çevrimiçi test edin!

05AB1E , 5 bayt

Œæʒ˜Q

Çevrimiçi deneyin!

Œæʒ˜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

Python 3 , 82 72 66 bayt

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

Çevrimiçi deneyin!

@JonathanAllan sayesinde -5 bayt

Haskell , 59 55 49 bayt

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

Çevrimiçi deneyin!

Özyinelemeli çözüm. Kullanım örneği: p [1,2,3]döner [[[1,2,3]],[[1,2],[3]],[[1],[2,3]],[[1],[2],[3]]].

Xnor sayesinde -6 bayt !

J , 42 bayt

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

1 uzunluğundaki bölüm alt listeleri için anahtarlar oluşturarak ve giriş listesinin uzunluğuna yineleyerek tüm alt liste parçalarını oluşturur. Her bölüm alt listesi daha sonra anahtarlardan seçilerek oluşturulur.

Örneğin, bir uzunluk 4 listesi için anahtarlar oluşturma işlemi.

Çevrimiçi deneyin!

J , 26 24 bayt

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

Çevrimiçi deneyin!

Brachylog , 2 bayt

~c

Çevrimiçi deneyin!

Jeneratör gibi davranarak çıktı üreten fonksiyon sunumu. (TIO bağlantısı, test amacıyla bunu tam bir program haline getirmek için ekstra kod içerir.)

Bu arada, teknik olarak bir yerleşik olmasa da, bu Brachylog'da o kadar yaygın olarak kullanılır ki, a) muhtemelen tek baytlık bir temsili hak eder ve b) cyerleşik, girdisi hakkında iddialarda bulunmak için bir parametre alabilir (oysa çoğu yerleşik, bir parametre üretmek için nasıl bahsediyor çıkışı ).

açıklama

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

APL, 26 bayt

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

Ölçek:

      {⊂∘⍵¨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││
│└─────┴─┘│└───┴───┘│└───┴─┴─┘│└─┴─────┘│└─┴───┴─┘│└─┴─┴───┘│└─┴─┴─┴─┘│└───────┘│
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

Açıklama:

• X←⍴1↓⍵: ilk öğesi düştüğünde (giriş listesinin) Xuzunluğu⍵
• ⍳2*X: sayılar [1..2 ^ X]
• (X⍴2)⊤: bu sayıların Xkonumlarla taban-2 gösterimi (ör.X kendisi etrafına sarılacaktır 0).
• ↓⍉: matrisi döndürün ve çizgiler boyunca bölün (⊤ sonuç olarak sütunlar boyunca sayılar içeren bir matris verir), bir dizi bit vektörü verir
• 1,¨: her bit vektörüne 1 ekler.
• ⊂∘⍵¨: her bit vektörü ⍵için her 1'e bölün .

Haskell , 45 bayt

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

Çevrimiçi deneyin!

Bu çözümü bir süre önce bir Haskell ipucu hakkında düşünürken buldum .

Python , 90 bayt

OV'lardan daha fazla moda (çalışmayı denediğimi düşündüğüm bir şey yapmak: 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

Dilimler 1 uzunluğunda olduğunda kuyruğa ulaşılan giriş dilimlerinden bölümler listesini oluşturan özyinelemeli bir işlev.

Çevrimiçi deneyin!

execBir fazla 4 bayt kaydeder whilebir ya da 3 for, sadece iki anlamına gelir çünkü (aşağıda) döngü \n(dilimleme sırası önemli değil ise) bütün fonksiyonu bir satırda olmasını sağlayan, s yerine girinti iki seviyede.

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

Python 3 , 67 bayt

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

Çevrimiçi deneyin!

Haskell, 59 bayt

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

Yakut , 62 57 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır:

• Bölüm sayısı 2 ^ (n-1): Bu aralıktaki ikili sayıları yineliyorum, sıfır ve grup gruplarını alıp ilk listenin alt kümeleri olarak eşleştiriyorum.
• Menzil ile uğraşmak yerine, iki katına çıkarıyorum ve sonunda kopyaları atıyorum. Şimdi ilk ikili rakamı da atabilir ve yığın işlevini kısaltabilirim.

JavaScript (ES6), 87 bayt

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

Açıklama: bönceki alt listelerin listesidir c, geçerli alt listedir (bu, ilk dalt listede olması gerektiği için dizinin ilk öğesi olarak başlar) ve tüm alt listelerin listesidir. Dizi öğelerinin geri kalanı özyinelemeli olarak işlenir. Her durumda iki seçenek vardır: geçerli alt listeye bir sonraki öğe eklenir veya geçerli alt liste tamamlanır ve sonraki öğe yeni bir alt liste başlatır. Daha sonra özyinelemeli sonuçlar birleştirilir. Dizi bittiğinde, tüm alt listelerin listesi sonuçtur.

APL (NARS) 38 karakter, 76 bayt

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

Bu Nars işlevini kullanın 11 1‼ kk ama çok yavaş, zaten 9 öğenin arg dizisi için kullanılamaz ...

  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

bu, yerleşik kullanmayan işlevdir:

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 

Her sonucun türünü görüyoruz:

  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
└∊───────────────────┘

Nasıl çalıştığını bilmiyorum, sadece sezgisel bir deneme ...

Bazı hatalar yapabilirim; her iki fonksiyon da sadece 1 2 ... n değil, girdi ne olursa olsun listenin bölümlerini oluşturur.

Aksiyom, 251 bayt

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)

Birisi daha iyi bir şey bulursa ... ungof ve test:

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

Bu çok fazla alan varsa bunu söyleyin ve örnekleri kaldırırım ...