Вызов

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

Недостаточно ясно? Вот пример, чтобы помочь

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

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

(Обычно это будет собственное строковое представление массивов на вашем языке.)

Также обратите внимание, что конечные пустые массивы должны быть напечатаны как часть массива.

счет

Это код-гольф, поэтому выиграй самый короткий код в байтах!

APL 25

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 (Dyalog 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 символа

Отдельное спасибо рандоме .

(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.~(]-{)/:@/:).

Mathematica, 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 вы можете определить значение функции для каждого входа отдельно, и вам не нужно указывать значение для всех возможных входов (это больше похоже на хеш-таблицу на стероидах).

Поэтому я начинаю с инициализации f0 для значений, которые присутствуют во входных данных с помощью (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. Это также гарантирует, что первый фактический элемент на входе получает две проверки, как и любой другой элемент.

Python, 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: объединяет, foldlчтобы получить гораздо меньшую программу.

Ruby 66 demo

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}

Perl 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]/'

Исключает ввод через стандартный ввод. Это в основном просто заменяет каждое второе вхождение "] [". Не работает с пустыми строками, []выдаст пустую строку, что я считаю удобным представлением пустого массива :)

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
–

Pyth 30 32

Я впервые экспериментирую с Пифом. Это то же решение, что и в моем решении 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:]]

Python 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, pre-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));}}