Враховуючи не порожній список цілих чисел, виведіть усі можливі розділи списку, де кожен розділ є не порожнім підписом.

Отже для списку [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) кому ( ,), у кожному рядку ( %) (трактуючи цей рядок як окремий рядок, що стосується $'та "$ 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]

Спробуйте в Інтернеті!

-5 байт завдяки @JonathanAllan

Haskell , 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]]].

-6 байт завдяки xnor !

J , 42 байти

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

Генерує всі розділи підпису, створюючи ключі для списків розділів довжиною 1 та ітерацією до довжини вхідного списку. Кожен підпис підрозділу формується шляхом вибору з клавіш.

Наприклад, ось процес створення ключів для списку довжиною 4.

Спробуйте в Інтернеті!

J , 26 24 байти

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

Спробуйте в Інтернеті!

Брахілог , 2 байти

~c

Спробуйте в Інтернеті!

Подання функції, що виробляє вихід, виконуючи функцію генератора. (Посилання TIO містить додатковий код, щоб перетворити це на повну програму для тестування.)

Між іншим, хоча технічно не є вбудованим, це настільки часто використовується в Брахілозі, що: а) воно, ймовірно, заслуговує однобайтового подання; б) 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позиціями (тобто Xсама буде обертатися 0).
• ↓⍉: обертати матрицю і розділити її по лініях ( ⊤в результаті отримує матрицю з числами вздовж стовпців), даючи масив бітових векторів
• 1,¨: додайте 1 до кожного бітового вектора.
• ⊂∘⍵¨: для кожного бітового вектора розділіть ⍵на кожен 1.

Haskell , 45 байт

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

Спробуйте в Інтернеті!

Я знайшов це рішення ще раз, думаючи про підказку Haskell .

Пітон , 90 байт

перевершив овець (робив щось, що я думав, що спробував роботу: 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

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

Спробуйте в Інтернеті!

Haskell, 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): я повторюю двійкові числа в цьому діапазоні, беру групи нулів і одиниць і відображаю їх як підмножини початкового списку.
• Замість того, щоб сповзати з діапазоном, я роблю його подвійним і відкидаю дублікати в кінці. Тепер я також можу відкинути першу двійкову цифру і зробити функцію шматка коротшою.

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, але дуже повільне, непридатне для масиву arg з 9 елементів вже ...

  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

Якщо це занадто багато місця, скажіть це, і я видаляю приклади ...