Đưa ra một danh sách các số nguyên không trống, xuất ra mọi phân vùng có thể có của danh sách trong đó mỗi phân vùng là một danh sách con không trống.

Vì vậy, cho danh sách [1, 2, 3, 4]kết quả là:

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

Thứ tự của các danh sách trong đầu ra không quan trọng, vì vậy [[1, 2, 3, 4]]có thể là đầu tiên, cuối cùng hoặc bất cứ nơi nào. Thứ tự của các yếu tố phải được bảo tồn.

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất sẽ thắng.

Liên quan: Phân vùng một danh sách!

Thạch , 2 byte

ŒṖ

Hãy thử trực tuyến!

Võng mạc , 27 19 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Hãy thử trực tuyến!

Giải trình

Tất nhiên điều này sẽ tính toán tất cả các phân vùng bằng cách xử lý chuỗi. Ý tưởng cơ bản là chúng ta có thể tạo tất cả các phân vùng bằng cách quyết định cho từng ,cá nhân cho dù chúng ta có muốn chia danh sách ở đó hay không. Loại công cụ này có thể được thực hiện trong Retina bằng cách khớp từng ,lượt và sử dụng thay thế cho cả hai đầu ra có thể.

Đầu vào đóng vai trò là trường hợp cơ sở: phân vùng nơi tất cả các thành phần vẫn nằm trong một danh sách.

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

Bây giờ chúng tôi lặp lại ( +) khớp với 1dấu phẩy ( ) dấu phẩy ( ,) đầu tiên , trên mỗi dòng ( %) (coi dòng đó là một chuỗi riêng biệt, có liên quan đến $'và `` $ 1 `thay thế).

Dấu phẩy được thay thế bằng:

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

Hãy nhớ rằng mọi thứ ở phía trước của trận đấu và sau trận đấu vẫn nằm trong chuỗi, vì vậy kết quả đầy đủ thực sự $`;$'¶$`];[$'giải thích tại sao chúng ta chèn hậu tố và tiền tố theo thứ tự đó.

Vòng lặp này dừng lại khi tất cả dấu phẩy đã biến mất.

;
,

Cuối cùng, thay thế dấu chấm phẩy bằng dấu phẩy một lần nữa để phù hợp với định dạng đầu vào.

Bash thuần khiết, 28

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

Ở đây, các danh sách được phân tách bằng dấu hai chấm và được chứa trong dấu ngoặc vuông. Ví dụ trong câu hỏi, danh sách đầu vào sẽ là 1:2:3:4và đầu ra là:

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

Hãy thử trực tuyến .

• ${1//:/REPLACEMENT}thay thế dấu hai chấm $1bằng{:,]:[\}
• Điều này tạo ra một mở rộng cú đúp như [1{:,]:[}2{:,]:[}3{:,]:[}4]
• Các eval (và \thoát cẩn thận ) làm cho việc mở rộng niềng răng xảy ra lần cuối và cho kết quả mong muốn.

Nếu cần phải khớp chính xác với [[ , , ...]]định dạng đã cho , thì chúng ta có thể thực hiện việc này thay thế:

Bash thuần khiết, 47

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

Hãy thử trực tuyến .

Bình thường , 2 byte

./

Với đầu vào [1, 2, 3, 4](ví dụ).

Giải thích : ./là toán tử phân vùng. Nó trả về tất cả các bộ phận của danh sách đầu vào thành các danh sách phụ rời rạc. Đầu vào được ngầm đưa vào chương trình.

Kiểm tra nó trực tuyến!

05AB1E , 5 byte

Œæʒ˜Q

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

-5 byte nhờ @Jonathan ALLan

Haskell , 59 55 49 byte

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

Hãy thử trực tuyến!

Giải pháp đệ quy. Ví dụ sử dụng: p [1,2,3]trả về [[[1,2,3]],[[1,2],[3]],[[1],[2,3]],[[1],[2],[3]]].

-6 byte nhờ xnor !

J , 42 byte

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

Tạo tất cả các partlist của danh sách con bằng cách tạo các khóa cho danh sách phụ phân vùng có độ dài 1 và lặp theo chiều dài của danh sách đầu vào. Mỗi danh sách con phân vùng sau đó được hình thành bằng cách chọn từ các phím.

Ví dụ, đây là quá trình tạo các khóa cho danh sách dài 4.

Hãy thử trực tuyến!

J , 26 24 byte

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

Hãy thử trực tuyến!

Brachylog , 2 byte

~c

Hãy thử trực tuyến!

Chức năng đệ trình tạo ra đầu ra thông qua hoạt động như một máy phát. (Liên kết TIO chứa mã bổ sung để biến điều này thành một chương trình đầy đủ, cho mục đích thử nghiệm.)

Ngẫu nhiên, mặc dù về mặt kỹ thuật không phải là một nội trang, nhưng điều này thường được sử dụng trong Brachylog đến mức a) nó có thể xứng đáng là một đại diện một byte và b) cnội dung có thể lấy tham số để đưa ra các xác nhận về đầu vào của nó (trong khi với hầu hết các nội dung, một tham số nói về cách sản xuất đầu ra ).

Giải trình

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

APL, 26 byte

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

Kiểm tra:

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

Giải trình:

• X←⍴1↓⍵: Xlà độ dài của ⍵(danh sách đầu vào) với phần tử đầu tiên được loại bỏ
• ⍳2*X: các số [1..2 ^ X]
• (X⍴2)⊤: biểu diễn cơ sở-2 của các số đó, với Xcác vị trí (tức là Xchính nó sẽ bao quanh 0).
• ↓⍉: xoay ma trận và phân chia nó dọc theo các dòng ( ⊤kết quả là một ma trận với các số dọc theo các cột), tạo ra một mảng các vectơ bit
• 1,¨: trả trước 1 cho mỗi vectơ bit.
• ⊂∘⍵¨: cho mỗi vectơ bit, chia ⍵ở mỗi 1.

Haskell , 45 byte

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

Hãy thử trực tuyến!

Tôi đã tìm thấy giải pháp này một thời gian trước khi nghĩ về một mẹo Haskell .

Python , 90 byte

vượt trội hơn so với lò nướng (làm một cái gì đó tôi nghĩ rằng tôi đã thử làm việc: 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

Hàm đệ quy xây dựng danh sách các phân vùng từ các lát của đầu vào với đuôi đạt được khi các lát có độ dài 1.

Hãy thử trực tuyến!

Việc execlưu 4 byte trên một whilehoặc 3 trên một forvòng lặp (bên dưới) vì nó chỉ có nghĩa là hai \ns chứ không phải hai mức thụt, cho phép toàn bộ hàm nằm trên một dòng (trong khi thứ tự cắt không quan trọng).

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 byte

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

Hãy thử trực tuyến!

Haskell, 59 byte

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

Ruby , 62 57 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

• Số lượng phân vùng là 2 ^ (n-1): Tôi lặp trên các số nhị phân trong phạm vi đó, lấy các nhóm số không và số 0 và ánh xạ chúng dưới dạng tập hợp con của danh sách ban đầu.
• Thay vì loay hoay với phạm vi, tôi làm cho nó tăng gấp đôi và loại bỏ các bản sao ở cuối. Bây giờ tôi cũng có thể loại bỏ chữ số nhị phân đầu tiên và làm cho hàm chunk ngắn hơn.

JavaScript (ES6), 87 byte

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

Giải thích: blà danh sách các danh sách con trước đó, clà danh sách con hiện tại, (bắt đầu là phần tử đầu tiên của mảng, vì nó phải nằm trong danh sách phụ đầu tiên) trong khi đó dlà danh sách của tất cả các danh sách phụ. Phần còn lại của các phần tử mảng sau đó được xử lý đệ quy. Trong mỗi trường hợp, có hai tùy chọn: hoặc phần tử tiếp theo được thêm vào danh sách con hiện tại hoặc danh sách con hiện tại được hoàn thành và phần tử tiếp theo bắt đầu một danh sách con mới. Các kết quả đệ quy sau đó được nối với nhau. Khi mảng hết, danh sách danh sách của tất cả các danh sách con là kết quả.

APL (NARS) 38 char, 76 byte

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

cái này sử dụng hàm Nars 11 1‼ kk nhưng rất chậm, không sử dụng được cho mảng arg gồm 9 phần tử đã ...

  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

Dưới đây là chức năng không sử dụng tích hợp:

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 

chúng tôi sẽ loại từng kết quả:

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

Tôi không biết nó hoạt động như thế nào, chỉ là thử heuristic ...

Có thể tôi mắc một số lỗi; cả hai hàm đều xây dựng các phân vùng của danh sách bất kỳ đầu vào nào và không chỉ 1 2 ... n.

Tiên đề, 251 byte

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)

Nếu ai đó tìm thấy một cái gì đó tốt hơn ... vô ích và kiểm tra:

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

Nếu đây là quá nhiều không gian nói điều đó và tôi loại bỏ các ví dụ ...