Виклик

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

Не досить зрозуміло? Ось приклад на допомогу

Вхідний масив:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

Вихід:

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

Пояснення:

Ось масив із лише другим елементом, виділеним жирним шрифтом:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5 ]

Тепер ми поміщаємо блоки масиву розщеплення навколо цих сміливих секундних подій:

[2 1] 1 [] 2 [3 2 2 4 5 6 7] 3 [] 7 [0] 5 []

і загортайте ці розбиті масиви в масив, щоб отримати остаточний

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

Зауважте, що при виникненні суміжних секундних подій з'являться порожні масиви.

Правила

Як завжди, ви повинні написати повну програму або функцію, що приймає вхідний масив через STDIN, ARGV або аргумент функції.

Вхідні дані

Вхід складається з будь-якого зручного масиву (або схожий на масив) цілих чисел.

Наприклад, будь-яке з наступного було б прийнятним:

2 1 1 1 4 5 6
[2 1 1 1 4 5 6]
[2, 1, 1, 1, 4, 5, 6]

Вихідні дані

При виведенні в STDOUT ваш масив також може бути надрукований у будь-якому зручному (вкладеному) форматі масиву, наприклад, одному з

[[2 1] [1 4 5 6]]
[[2, 1], [1, 4, 5, 6]]
{{2, 1}, {1, 4, 5, 6}}

(Зазвичай це рідне представлення рядків масивів у вашій мові.)

Також зауважте, що трейлінг порожніх масивів повинен бути надрукований як частина масиву.

Оцінка балів

Це код-гольф, тому найкоротший код у виграші байтів!

25 APL

1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←

Приклад:

]display 1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌→──────────────────────────────────────┐
│ ┌→──┐ ┌⊖┐ ┌→────────────┐ ┌⊖┐ ┌→┐ ┌⊖┐ │
│ │2 1│ │0│ │3 2 2 4 5 6 7│ │0│ │0│ │0│ │
│ └~──┘ └~┘ └~────────────┘ └~┘ └~┘ └~┘ │
└∊──────────────────────────────────────┘

Старий:

{1↓¨(1,(⍳⍴⍵)∊,{1↑1↓⍵}⌸⍵)⊂1,⍵}

Це хороше запитання для ключового оператора (⌸), який був представлений з Dyalog APL v14. Він бере ліву функцію аргументу ({1 ↑ 1 ↓ ⍵}) і надає її для кожного унікального аргументу, індекси у векторі для цього аргументу. Ось я беру другий індекс, потім я перевіряю, який з індексів присутній у цьому списку ((⍳⍴⍵) ∊) і використовую отриманий булів для розщеплення вихідного вектора.

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

http://tryapl.org

APL (Діалог 14) (31)

{1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵}

Це функція, яка бере масив і повертає вкладений масив.

Тест:

      +V← {1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵} 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌───┬┬─────────────┬┬─┬┐
│2 1││3 2 2 4 5 6 7││0││
└───┴┴─────────────┴┴─┴┘
      ⍝ this return value is a real nested array:
      ⎕←'Length: ',⍴V ⋄ (⍳⍴V){⎕←'Array #',⍺,': (', ⍵, ')'}¨V 
Length:  6
Array # 1 : ( 2 1 )
Array # 2 : ()
Array # 3 : ( 3 2 2 4 5 6 7 )
Array # 4 : ()
Array # 5 : ( 0 )
Array # 6 : ()

Пояснення:

• 0,⍵: Додайте 0передню частину ⍵, щоб полегшити обробку. (Це не враховується як подія.)
• (... )⊂: Розбийте масив відповідно до заданої біт-маски. Нова група починається з кожного 1в біт-масці.
  • +\∘.=⍨⍵: для кожного значення в (оригіналі) ⍵знайдіть усі події в ⍵. Потім складіть поточну суму для кожного значення, даючи квадратну матрицю, що показує для кожної позиції, ⍵скільки кожного значення вже відбулося.
  • ↓: Розбийте матрицю на її рядки, даючи для кожного значення масив, що показує кількість разів, коли він відбувся по кожній позиції.
  • 2⍳⍨¨: У кожному з цих масивів знайдіть індекс першого 2.
  • (⍳⍴⍵)∊: Для кожного можливого індексу перевірте ⍵, чи міститься він у списку індексів другої події. (Вони починаються з кожної групи, крім першої.)
  • 1,: Додайте 1фронт, позначаючи початок першої групи.
• 1↓¨: Видаліть перший елемент із кожної групи. (Це додані 0та другі випадки кожного значення.)

J, 28 24 char

Особлива подяка випадковим особам .

(1&,<;._1~1,2=+/@(={:)\)

Це працює так. Над усіма префіксами ( \) вхідного масиву ми дивимось, скільки ( +/@) елементів префікса дорівнюють останньому елементу ( ={:) цього префікса. Коли це число дорівнює 2, ми знаємо, що це другий випадок цього елемента в масиві, тому ми розділимо масив там, використовуючи <;._1.

   a=.2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
   (={:)\ a
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 1
   +/@(={:)\ a
1 1 2 2 1 3 4 1 1 1 1 2 2 1 2

Стара річ , з допомогою сортування фокусів: (1&,<;._1~1,1=i.~(]-{)/:@/:).

Математика, 58 51 49 байт

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&

Це неназвана функція, яка займає такий список

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&[{2,1,1,2,3,2,2,4,5,6,7,3,7,0,5}]

і повертає вкладений список типу

{{2, 1}, {}, {3, 2, 2, 4, 5, 6, 7}, {}, {0}, {}}

Як це працює

Для цього використовується якась незрозуміла магія SplitBy.

Я відслідковую виникнення кожного числа у функції f. У Mathematica ви можете визначити значення функції для кожного входу окремо, і вам не потрібно вказувати значення для всіх можливих входів (це більше схоже на хеш-таблицю на стероїдах).

Отже, я починаю з ініціалізації fдо 0 для значень, які присутні у вхідному значенні з (f@#=0;#)&/@.

Тепер SplitByбереться список та функція та "розбиває список на підсписи, що складаються із запусків послідовних елементів, які дають однакове значення при fзастосуванні" (зауважте, що SplitByне вилучає жодних елементів). Але (недокументований) улов є, що fназивається двічі на кожному елементі - при порівнянні його з попередником і його наступником. Тож якщо ми це зробимо

 SplitBy[{1,2,3,4},Print]

ми не просто отримуємо кожне число один раз, а замість цього друкуємо

 1
 2
 2
 3
 3
 4

що становить 6 викликів за 3 порівняння.

Ми можемо розділити список перед кожним другим виникненням, якщо запишемо функцію, яка завжди повертається, Falseале повертається, Trueколи друге явище порівнюється з елементом перед нею. Це третя перевірка цього елемента (дві перевірки на перше виникнення плюс перша перевірка на друге виникнення). Отже, ми використовуємо ++f[#]==3&. Приємно те, що це вже Falseзнову повертається під час другої перевірки другого явища, таким чином, що я можу повернутися Trueдля послідовних повторних подій, але все-таки розділитись між ними . Аналогічно, це не розділиться після повторних випадків, оскільки функція вже Falseзнову повертається під час другої перевірки.

Тепер питання хоче, щоб ми також видалили ці другі події, тому ми викидаємо перший елемент із кожного списку, з Rest/@. Але, звичайно, ми не хочемо видаляти найперший елемент із вхідних даних, тому ми фактично починаємо, додаючи елемент aдо початку списку {a}~Join~#. aє невизначеною змінною, яку Mathematica просто трактує як невідому, тому вона не вплине на будь-які інші значення f. Це також гарантує, що перший фактичний елемент на вході отримує дві перевірки, як і кожен інший елемент.

Пітон, 148 байт

def s(a):z=len(a);x=[-1]+sorted({[i for i in range(z)if a[i]==n][1]for n in a if a.count(n)>1})+[z];return[a[x[i]+1:x[i+1]]for i in range(len(x)-1)]

Досить жахливе рішення. Треба бути кращим способом ...

Подзвоніть з s([2, 1, 1, 1, 4, 5, 6]).

Безгольова версія

def split(array):
  indices = [-1]
  second_occurrences = set()

  for n in array:
      if array.count(n) > 1:
          occurrences = [i for i in range(len(array)) if array[i] == n]
          second_occurrences.add(occurrences[1])

  indices += sorted(second_occurrences)
  indices += [len(array)]

  return [array[indices[i]+1:indices[i+1]] for i in range(len(indices)-1)]

Хаскелл, 115 113 106 88

f?(x:s)|1<-f x=[]:x%f?s|a:b<-x%f?s=(x:a):b
f?x=[x]
(x%f)h=sum$f h:[1|x==h]
r s=(\_->0)?s

тут зберігається кількість кожного елемента, що з'явився на даний момент, як функція від елементів до їх відповідної кількості, що є цікавим трюком.

це працює , використовуючи %, функція , яка задана функцією F і аргумент xповертає нову функцію , яка повертає fзастосовані до нього в аргумент , якщо він відрізняється x, і в 1 + f xіншому випадку.

наприклад, 3 % const 0це функція, яка повертає 0 для кожного аргументу, крім 3, для якого він повертає 1. update: fused the, foldlщоб отримати набагато меншу програму.

Рубін 66 демо

f=->a{c=Hash.new 0
r=[[]]
a.map{|e|2==(c[e]+=1)?r<<[]:r[-1]<<e}
r}

Ruby stabby lambda, який приймає масив як параметр і повертає масив масивів.

Пітон: 100 байт

def g(l):
 i=j=0;o=[]
 for e in l:
  if l[:i].count(e)==1:o+=[l[j:i]];j=i+1
  i+=1
 return o+[l[j:]]

Безпосереднє рішення. Я повторюю список, підраховую, скільки разів персонаж з'являвся раніше, і додаю частину після останньої перевірки до списку вихідних даних.

Рубі, 66

f=->a{s=Hash.new 0
r=[[]]
a.map{|e|(s[e]+=1)==2?r<<[]:r[-1]<<e}
r}

Пояснення

• eявляє собою хеш підрахунків подій для кожного елемента, rце масив, в якому зберігається результат.
• Проведіть цикл через вхід, збільшуючи кількість подій для кожного елемента на 1.
  • Якщо кількість подій є 2, нам потрібно розділити. Додайте порожній Arrayрезультат.
  • В іншому випадку просто додайте елемент до останнього Arrayв результаті.

CJam, 25 24 байти

q~{_L+:L1$a/,3=S@?}%Sa/p

Бере вхід з типу STDIN

[ 2 1 2 1 0 2 2 1 1 3 4 3]

і результати, як

[[2 1] "" [0 2 2 1 1 3 4] ""]

Я в основному повторюю всі елементи масиву, по одному вводячи їх в інший масив. Потім я отримую підрахунок поточного елемента в іншому масиві. Якщо його 2, я запускаю інший масив з цього місця. Цей вид запуску випадкових масивів може бути досягнутий лише мовою на основі стека.

Розширення коду :

q~{_L+:L1$a/,3=S@?}%Sa/p
q~{               }%             "Evaluate the input array and map it on this block";
   _                             "Copy the current element in iteration";
    L+:L                         "Add the copy to an initially blank array L and update L";
        1$a/                     "Make another copy of the element and split L on it";
            ,3=                  "This checks if the splitted array is of length 3";
                                 "which indirectly means that L contains the element twice";
               S@?               "If the above is true, replace the element by space";
                    Sa/          "Split the final array on space. This final array contains";
                                 "second occurrence of every integer replaced by a space";
                       p         "Print the stringified version of the final nested array";

Спробуйте його онлайн тут

1 байт збережено від підказки Мартіна в чаті

Рубін, 64 байти

s=->a{x=[];b=[[]];a.map{|e|x<<e;x.count(e)==2?b<<[]:b[-1]<<e};b}

Перл 5: 36

Не впевнений, чи це прийнятно, оскільки фактичного розщеплення тут не відбувається.

#!perl -pa
$x{$_}++-1or$_=']['for@F;$_="[[@F]]"

Приклад:

$ perl spl.pl <<<"2 1 1 2 3 2 2 4 5 6 7 3 7 0 5"
[[2 1 ][ ][ 3 2 2 4 5 6 7 ][ ][ 0 ][]]

CJam, 28 байт

Lq~{1$1$a/,3=S2$?@++}/-2%S/`

Приймає вхід на зразок STDIN

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

і друкує висновок на зразок STDOUT

[[2 1] "" [3 2 2 4 5 6 7] "" [0] ""]

Зверніть увагу , що порожні рядки і порожні масиви одне і те ж в CJam і відображаються ""за замовчуванням (це є рідним поданням порожніх масивів).

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

Пояснення

В основному я копіюю кожен елемент у масиві, якщо це не є другим явищем, і в такому випадку я замінюю першу копію пробілом. З метою гольфу цей модифікований масив побудований у зворотному напрямку. Так [2 1 1 2 3 2 3]стає

[3 S 2 2 3 3 2 S 1 S 1 1 2 2]

Потім я вибираю кожен другий елемент з кінця, який є вихідним масивом, але з другими входженнями замінюється пробілами, тобто

[2 1 S S 3 2 S]

Нарешті, я просто розділив масив на пробіли. Ось розбивка коду:

L                            "Push empty array.";
 q~                          "Read STDIN an evaluate.";
   {                }/       "For each element of the input.";
    1$1$                     "Copy the array and the element.";
        a/                   "Split the array by that element.";
          ,3=                "Check that it's split into 3 parts.";
             S2$?            "If so, push a space, else, copy the current number.";
                 @++         "Pull up the array from the bottom and add both to the beginning.";
                      -2%    "Pick every second element from the end.";
                         S/  "Split on spaces.";
                           ` "Get the string representation.";

Інструменти Unix, 100 байт

grep -o '[-0-9]*'|awk '{print(++A[$0]-2)?$0:"] ["}'|paste -sd' '|sed -e '/]/s/.*/[\0]/' -e's//[\0]/'

Виключає вхід через stdin. В основному він просто замінює кожне друге виникнення "] [". Не працює з порожніми рядками, []дасть порожній рядок, що, на мою думку, є зручним поданням порожнього масиву :)

APL, 42 символи

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}

Приклад:

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}2 1 1 2 3 2 2 4 5 6 7 3 7 0 5

Вихід:

( 2 1  )(   )(  3 2 2 4 5 6 7  )(   )(  0  )(  )

Тестували тут.

Якщо я повинен вивести рядок, який трактується точно як правильна структура в APL ... 49 символів

{'1↓1(',',⍬)',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂',⍬)('}

Ява, 223

Це працює лише на Oracle або OpenJDK JRE, оскільки я використовую цю химерність у впровадженні кількісного показника та перевірки довжини в огляді, щоб реалізувати огляд змінної довжини.

class W{public static void main(String a[]){System.out.print("["+new java.util.Scanner(System.in).nextLine().replaceAll(" *\\b(\\d+)\\b(?=(.*))(?<=^(?=(.*\\b\\1\\b){2}\\2).*)(?<!^(?=(.*\\b\\1\\b){3}\\2).*) *","] [")+"]");}}

Більша частина роботи виконується в регулярному вираженні, який наведено нижче в сирому вигляді:

 *\b(\d+)\b(?=(.*))(?<=^(?=(.*\b\1\b){2}\2).*)(?<!^(?=(.*\b\1\b){3}\2).*) *

Перш ніж ми подивимось на регулярний вираз, розглянемо еквівалентний .NET-регулярний вираз, який є простішим, оскільки він безпосередньо підтримує огляд змінної довжини (огляд .NET, швидше за все, робиться в режимі відповідності справа-наліво) :

 *\b(\d+)\b(?<=(.*\b\1\b){2})(?<!(.*\b\1\b){3}) *

•  *\b(\d+)\bі  *в кінці відповідає номеру та навколишнім просторам (якщо такі є). Зв'язані чеки повинні запобігати збігу часткового числа, оскільки пробіли з обох сторін необов’язкові. Він також фіксує номер, щоб перевірити, чи є це другий вигляд у масиві.

• (?<=(.*\b\1\b){2})перевіряє, що можна знайти 2 екземпляри кількості захоплених вище. (?<!(.*\b\1\b){3})перевіряє, що не знайдено жодних 3 примірників захопленої кількості. Обидві умови комбінованого твердження стверджують, що до цих пір є лише 2 екземпляри числа. Зв'язані чеки є, щоб переконатися, що ціле число перевірено.

Повернутися до версії Java. Для реалізації погляд змінної довжини позаду ми перетворюємо

(?<=var-length-pattern)

до

(?<=^(?=.*var-length-pattern).*)

^{Я трохи махаю руками щодо того, що .виключає роздільники рядків, але це можна легко виправити, і я не хочу додатково ускладнювати синтаксис.}

Попереду завжди завдовжки 0, і перевірка довжини проходить завдяки реалізації * кількісного показника.

Це ^не обов'язково для того, щоб він працював, але саме для того, щоб випадна справа вийшла з ладу швидше. Огляд у впровадженні Oracle / OpenJDK виконується шляхом відхилення мінімальної довжини шаблону, потім узгодження, потім промивання та повторення, збільшуючи довжину, поки не буде знайдено відповідність, або в гіршому випадку, до максимальної довжини шаблону. . З ^, я переконуюсь, що рядок префікса відповідає лише один раз.

Однак погляд вперед всередині позаду не обмежений правою межею позаду, тому він може відповідати до кінця рядка. Для того, щоб стверджувати межу, я захоплюю решту рядка в іншу групу захоплення всередині погляду вперед і використовую її для обмеження панування шаблону змінної довжини.

(?=(.*))(?<=^(?=.*var-length-pattern\m).*)
   ^--^                              ^
   mth capturing group               m is the number of the capturing group marked

Оскільки мій шаблон вже починається .*, мені не потрібно додавати ще один .*спереду.

Perl 108

map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";push@a,[@b];s/.*/Data::Dumper->Dump(\@a)/e;

Дія:

perl -MData::Dumper -pe '
    $Data::Dumper::Terse = 1;
    $Data::Dumper::Indent = 0;
    @a=@b=@e=();
    map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";
    push@a,[@b];
    s/.*/Data::Dumper->Dump(\@a)/e;
' <<<$'2 1 1 2 3 2 2 4 5 6 7 3 7 0 5\n2 1 1 1 4 5 6\n'"$(
    sed 's/./& /g;w/dev/stderr' <<< ${RANDOM}${RANDOM}${RANDOM}$'\n'${RANDOM}${RANDOM})"
2 4 4 7 7 2 9 8 8 4 6 0 1 8 
1 0 3 9 3 7 9 
[2,1][][3,2,2,4,5,6,7][][0][]
[2,1][1,4,5,6]
[2,4][7][][9,8][4,6,0,1,8]
[1,0,3,9][7][]

Нота: Два перших рядки $Data::...є лише для кращого представлення, а третій рядок @a=@b=@e=();- для того, щоб інструмент працював над кількома лініями.

R, 76

y=scan();r=split(y,cumsum(ave(y,y,FUN=seq)==2));c(r[1],lapply(r[-1],"[",-1))

Результат для прикладу: Список з п'яти елементів, включаючи три порожні вектори. ( numeric(0)).

$`0`
[1] 2 1

$`1`
numeric(0)

$`2`
[1] 3 2 2 4 5 6 7

$`3`
numeric(0)

$`4`
[1] 0

$`5`
numeric(0)

До речі: код генерує попереджувальне повідомлення, яке можна ігнорувати.

awk 29

a[$1]++==1{print"-";next}1

Це вимагає трохи свободи за допомогою вхідних та вихідних форматів. Вхідний "масив" - вертикальний, по одному номеру на рядок. Вихід також вертикальний, по одному номеру на рядок, з тиреми, що розділяють масиви.

Вхід:

2
1
1
2
3
2
2
4
5
6
7
3
7
0
5

Вихід:

2
1
–
–
3
2
2
4
5
6
7
–
–
0
–

Піт 30 32

Це мій перший експеримент із Pyth. Це те саме рішення, що і в моєму рішенні Python.

VQIq/<QN@QN1~Y]:QZN=ZhN;+Y]>QZ

Ви можете спробувати в Інтернеті: Pyth Compiler / Executor

Напр. Вхід

[2,1,1,2,3,2,2,4,5,6,7,3,7,0,5]

буде надруковано

[[2, 1], [], [3, 2, 2, 4, 5, 6, 7], [], [0], []]

Пояснення:

                                 # Q = input(), Y = [], Z = 0
VQ                               # for loop: N iterates over the indices of Q
  I                              # if 
   q\<QN@QN1                     #    Q[N] appears exactly once in Q[:N]
            ~Y]:QZN              #         append the list [Q[Z:N]] to Y
                   =ZhN          #         and assign Z = N + 1
                       ;         # end if and for loop
                        +Y]>QZ   # print Y + [Q[Z:]]

Пітон 2, 84

l=[[]];p=[]
for x in input():p+=[x];b=p.count(x)==2;l+=[[]]*b;l[-1]+=[x][b:]
print l

Список l- це вихідний результат. Перебираємо елементи. Якщо поточний - це другий вигляд, ми починаємо новий порожній список; в іншому випадку ми додаємо його до останнього підпису. Список елементів, які ви бачили дотепер, зберігається в p. Як не дивно, реконструкція списку здається коротшою, ніж скорочення введення.

Чистий баш 111 94

81 тільки для розщеплення:

for i;do [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i;b[i]+=7;done;c+=("${d# }")
declare -p c

Другий рядок declare -p cпросто скидає змінну

Зразок:

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    declare -p c
}

Примітка: рядок local b c d iпотрібен лише для запуску функції кілька разів.

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
declare -a c='([0]="2 1" [1]="" [2]="3 2 2 4 5 6 7" [3]="" [4]="0" [5]="")'

splitIntFunc 2 1 1 1 4 5 6
declare -a c='([0]="2 1" [1]="1 4 5 6")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
1 6 5 3 2 2 4 3 9 4 2 9 7 7 4 
declare -a c='([0]="1 6 5 3 2" [1]="4" [2]="9" [3]="2" [4]="7" [5]="4")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 4 5 2 9 1 1 4 8 7 8 1 0 3 
declare -a c='([0]="2 4 5" [1]="9 1" [2]="" [3]="8 7" [4]="1 0 3")'

Для сексуальної презентації (+26)

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    printf -v l "(%s) " "${c[@]}"
    echo "<$l>"

Виведе щось на зразок:

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
<(2 1) () (3 2 2 4 5 6 7) () (0) () >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
4 3 8 1 4 5 7 9 2 7 8 4 0 
<(4 3 8 1) (5 7 9 2) () (4 0) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
3 1 3 0 2 5 3 6 6 9 2 5 5 
<(3 1) (0 2 5 3 6) (9) () (5) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 2 2 9 1 9 5 0 2 2 7 6 5 4 
<(2) (2 9 1) (5 0 2 2 7 6) (4) >


}

Скала, 122 111

Візьміть колекцію символів, надрукуйте у формі [21][][3224567][][0][], 122 111:

def s(a:Any*)=print((("[","")/:a){case((b,c),d)=>if(b.indexOf(d)==c.indexOf(d))(b+d,c)else(b+"][",c+d)}._1+"]")

... або візьміть колекцію символів і поверніть вкладені списки, 135 129:

def s(a:Char*)=(("",List(List[Any]()))/:a){case((b,c),d)=>b+d->(if(b.count(d==)==1)List()::c else(c.head:+d)::c.tail)}._2.reverse

Я впевнений, що я можу отримати певні заощадження, я не виглядав надто важко.

Python 220 байт

Нижче 220 байт, що не чудово порівняно з багатьма іншими, але працює досить швидко з більшими цілими числами!

xlist = list(input()); result = []; x = 0
for i in range(len(xlist)):
    if xlist[0:i+1].count(xlist[i]) == 2: result.append(xlist[x:i]);x = i+1
    elif i == len(xlist)-1: result.append(xlist[x:])
print(result)

Java: 563 байти

Зверніть увагу, що для цього використовується Java 8, попередній JDK8 був би на кілька байт довше за рахунок foreach.

import java.util.*;public class a{static String c(String[]b){List<String>d=new ArrayList<>(Arrays.asList(b));Set<String>e=new HashSet<>();Set<String>f=new HashSet<>();for(int i=0;i<Integer.MAX_VALUE;i++){String g;try{g=d.get(i);}catch(IndexOutOfBoundsException ex){break;}
if(e.contains(g)&&!f.contains(g)){d.remove(i);d.add(i,"]");d.add(i+1,"[");f.add(g);i++;}else{e.add(g);}}
d.add(0,"[[");d.add(d.size(),"]]");StringBuilder sb=new StringBuilder();d.forEach(sb::append);return sb.toString();}
public static void main(String[]args){System.out.println(c(args));}}