비어 있지 않은 정수 목록이 제공되면 각 파티션이 비어 있지 않은 하위 목록 인 목록의 가능한 모든 파티션을 출력하십시오.

따라서 목록 [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]]처음, 마지막 또는 어디에서나 될 수 있습니다. 요소의 순서는 유지되어야합니다.

이것은 코드 골프이므로 최단 답변이 이깁니다.

관련 : 목록을 파티션!

젤리 , 2 바이트

ŒṖ

온라인으로 사용해보십시오!

망막 , 27 19 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

온라인으로 사용해보십시오!

설명

물론 이것은 문자열 처리를 사용하여 모든 파티션을 계산합니다. 기본 아이디어는 ,목록을 분할할지 여부를 개별적 으로 결정하여 모든 파티션을 생성 할 수 있다는 것입니다. 이런 종류의 것들은 Retina에서 각각 일치시켜 수행 할 수 있습니다, 에서 을 차례로 시키고 가능한 모든 출력을 제공하는 대체품을 사용하여 .

입력은 기본 사례로 작동합니다. 모든 요소가 여전히 단일 목록에있는 파티션입니다.

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

경기 전과 경기 후의 모든 것이 어쨌든 문자열에 남아 있으므로 전체 결과는 실제로 $`;$'¶$`];[$' 접미사와 접두사를 순서대로 삽입하는 이유를 설명합니다.

모든 쉼표가 사라지면이 루프가 중지됩니다.

;
,

마지막으로 입력 형식과 일치하도록 세미콜론을 쉼표로 다시 바꿉니다.

퓨어 배쉬, 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//, /{\\,\\ ,]\\,\\ [\}}

온라인으로 사용해보십시오 .

Pyth , 2 바이트

./

입력 포함 [1, 2, 3, 4](예 :).

설명 : ./파티션 연산자입니다. 입력 목록의 모든 부분을 분리 된 하위 목록으로 반환합니다. 입력은 프로그램에 내재적으로 공급됩니다.

온라인으로 테스트하십시오!

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

파이썬 3 , 82 72 66 바이트

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

온라인으로 사용해보십시오!

@JonathanAllan 덕분에 -5 바이트

하스켈 , 59 55 49 바이트

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

온라인으로 사용해보십시오!

재귀 솔루션. 사용 예 : p [1,2,3]returns [[[1,2,3]],[[1,2],[3]],[[1],[2,3]],[[1],[2],[3]]].

xnor 덕분에 -6 바이트 !

J , 42 바이트

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

길이 1의 파티션 하위 목록에 대한 키를 작성하고 입력 목록의 길이까지 반복하여 모든 하위 목록 참여자를 생성합니다. 그런 다음 각 파티션 하위 목록은 키에서 선택하여 구성됩니다.

예를 들어, 길이 4 목록의 키를 작성하는 프로세스는 다음과 같습니다.

온라인으로 사용해보십시오!

J , 26 24 바이트

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

온라인으로 사용해보십시오!

Brachylog , 2 바이트

~c

온라인으로 사용해보십시오!

생성기 역할을 통해 출력을 생성하는 함수 제출. TIO 링크에는 테스트 목적으로이를 전체 프로그램으로 만들기위한 추가 코드가 포함되어 있습니다.

덧붙여 말하면, 이것은 기술적으로 내장되어 있지는 않지만 Brachylog에서 매우 일반적으로 사용되므로 a) 아마도 1 바이트 표현이 필요하고 b) c내장은 입력 에 대한 어설 션을 만들기 위해 매개 변수를 취할 수 있습니다 (대부분의 내장 기능은 매개 변수 출력 을 생성하는 방법에 대해 이야기 ).

설명

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

APL, 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)⊤: X위치 가있는 숫자의 밑이 2로 표시 X됩니다 (예 : 자체가로 줄 바꿈 됨 0).
• ↓⍉: 행렬을 회전시키고 선을 따라 분할 ( ⊤결과적으로 열을 따라 숫자가있는 행렬 제공) 비트 벡터 배열
• 1,¨: 각 비트 벡터에 1을 추가합니다.
• ⊂∘⍵¨: 각 비트 벡터 ⍵에 대해 각각 1로 분할 됩니다.

하스켈 , 45 바이트

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

온라인으로 사용해보십시오!

Haskell 팁에 ​​대해 생각하면서이 솔루션을 발견했습니다 .

파이썬 , 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(슬라이스의 순서는 중요하지 않지만) 전체 기능이 하나의 행에 있도록 S보다는 압입 두 가지 수준.

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

파이썬 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]]

온라인으로 사용해보십시오!

하스켈, 59 바이트

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

루비 , 62 57 바이트

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

온라인으로 사용해보십시오!

작동 방식 :

• 파티션 수는 2 ^ (n-1)입니다. 해당 범위의 이진수를 반복하고 0과 1의 그룹을 취하여 초기 목록의 하위 집합으로 매핑합니다.
• 범위를 조정하는 대신 두 배로 만들고 끝에 중복을 버립니다. 이제 첫 번째 이진수를 버리고 청크 기능을 더 짧게 만들 수도 있습니다.

JavaScript (ES6), 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목록이며 , 첫 번째 하위 목록에 있어야하므로 배열의 첫 번째 요소로 시작합니다. 반면 모든 하위 목록의 목록입니다. 그런 다음 나머지 배열 요소는 재귀 적으로 처리됩니다. 각각의 경우 다음 두 가지 옵션이 있습니다. 다음 요소가 현재 하위 목록에 추가되거나 현재 하위 목록이 완료되고 다음 요소가 새 하위 목록을 시작합니다. 그러면 재귀 결과가 함께 연결됩니다. 배열이 소진되면 모든 하위 목록의 목록이 결과입니다.

APL (NARS) 38 자, 76 바이트

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

이것은 Nars 함수 11 1‼ 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뿐만 아니라 입력에 관계없이 목록의 파티션을 만듭니다.

공리, 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)

누군가 더 나은 것을 발견하면 ... 무언가와 테스트 :

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

이것이 너무 많은 공간이라면 말하고 예제를 제거하십시오 ...