Desafio

A tarefa desta pergunta é dividir uma matriz de entrada de números inteiros na segunda ocorrência de cada número inteiro nessa matriz.

Não está claro o suficiente? Aqui está um exemplo para ajudar

Matriz de entrada:

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

Resultado:

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

Explicação:

Aqui está a matriz com apenas o segundo elemento destacado em negrito:

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

Agora, colocamos os blocos de matriz divididos em torno dessas ocorrências em segundos em negrito:

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

e agrupe essas matrizes divididas em uma matriz para obter a final

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

Observe que quando ocorrem segundas ocorrências adjacentes, haverá matrizes vazias.

Regras

Como de costume, você deve escrever um programa completo ou uma função utilizando a matriz de entrada via STDIN, ARGV ou argumento de função.

Entrada

A entrada consiste em qualquer formato de matriz conveniente (ou semelhante a matriz) de números inteiros.

Por exemplo, qualquer um dos seguintes itens seria aceitável:

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

Resultado

Ao enviar para STDOUT, sua matriz também pode ser impressa em qualquer formato conveniente (aninhado) de matriz, por exemplo, um dos

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

(Geralmente, essa é a representação de string nativa de matrizes no seu idioma.)

Observe também que as matrizes vazias à direita devem ser impressas como parte da matriz.

Pontuação

Este é o código-golfe, pelo que o código mais curto em bytes ganha!

APL 25

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

Exemplo:

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

Antigo:

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

Essa é uma boa pergunta para o operador principal (⌸) que foi introduzido com o Dyalog APL v14. Ele pega a função de argumento esquerdo ({1 ↑ 1 ↓ ⍵}) e fornece para cada argumento único, os índices do vetor para esse argumento. Aqui estou pegando o segundo índice, depois verifico qual dos índices está presente nesta lista ((⍳⍴⍵) ∊) e uso o booleano resultante para dividir o vetor original.

Pode ser experimentado online aqui:

http://tryapl.org

APL (Diálogo 14) (31)

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

Esta é uma função que pega uma matriz e retorna uma matriz aninhada.

Teste:

      +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 : ()

Explicação:

• 0,⍵: Adicione 0a à frente ⍵para facilitar o processamento. (Não conta como uma ocorrência.)
• (... )⊂: Divide a matriz de acordo com a máscara de bits fornecida. Um novo grupo começa em cada um 1na máscara de bits.
  • +\∘.=⍨⍵: para cada valor em (o original) ⍵, encontre todas as ocorrências em ⍵. Em seguida, faça uma soma contínua para cada valor, fornecendo uma matriz quadrada para cada posição em ⍵quantos de cada valor já ocorreu.
  • ↓: Divida a matriz por suas linhas, fornecendo para cada valor uma matriz que mostre a quantidade de vezes que ocorreu em cada posição.
  • 2⍳⍨¨: Em cada uma dessas matrizes, encontre o índice da primeira 2.
  • (⍳⍴⍵)∊: Para cada índice possível ⍵, veja se está contido na lista de índices de segundas ocorrências. (Eles iniciam cada grupo, exceto o primeiro.)
  • 1,: Adicione um 1à frente, marcando o início do primeiro grupo.
• 1↓¨: Remova o primeiro elemento de cada grupo. (Estes são os adicionados 0e a segunda ocorrência de cada valor.)

J, 28 24 caracteres

Agradecimentos especiais a randomra .

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

Funciona assim. Sobre todos os prefixos ( \) da matriz de entrada, examinamos quantos ( +/@) elementos do prefixo são iguais ao último elemento ( ={:) desse prefixo. Quando esse número é 2, sabemos que esta é a segunda ocorrência desse item na matriz, portanto, dividimos a matriz lá usando <;._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

Coisa velha usando truques de classificação: (1&,<;._1~1,1=i.~(]-{)/:@/:).

Mathematica, 58 51 49 bytes

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

Esta é uma função sem nome que leva uma lista como

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

e retorna uma lista aninhada como

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

Como funciona

Isso usa alguma magia bastante obscura SplitBy.

Estou acompanhando as ocorrências de cada número em uma função f. No Mathematica, você pode definir o valor de uma função para cada entrada separadamente e não precisa especificar o valor para todas as entradas possíveis (é mais como uma tabela de hash para esteróides).

Então, iniciando fcom 0 para valores que estão presentes na entrada com (f@#=0;#)&/@.

Agora SplitBypega uma lista e uma função e "divide a lista em sublistas, consistindo em execuções de elementos sucessivos que dão o mesmo valor quando fé aplicado" (observe que SplitBynão remove nenhum elemento). Mas o problema (não documentado) é, que fé chamado duas vezes em cada elemento - quando comparado ao seu antecessor e seu sucessor. Então, se fizermos

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

não apenas obtemos cada número uma vez, mas isso imprime

 1
 2
 2
 3
 3
 4

que é 6 solicita 3 comparações.

Podemos dividir a lista antes de cada segunda ocorrência, se escrevermos uma função que sempre retorna, Falsemas retorna Truequando uma segunda ocorrência é comparada ao elemento anterior. Essa é a terceira verificação desse elemento (duas verificações na primeira ocorrência, mais a primeira verificação na segunda ocorrência). Por isso, usamos ++f[#]==3&. O bom é que isso já retorna Falsenovamente na segunda verificação da segunda ocorrência, para que eu possa retornar Truepor segundas ocorrências consecutivas, mas ainda assim dividir entre elas . Da mesma forma, isso não será dividido após a segunda ocorrência, porque a função já retorna Falsenovamente na segunda verificação.

Agora, a pergunta quer que também removamos essas segundas ocorrências; portanto, eliminamos o primeiro elemento de cada lista com Rest/@. Mas é claro que não queremos remover o primeiro elemento da entrada; portanto, começamos adicionando um elemento aao início da lista com {a}~Join~#. aé uma variável indefinida, que o Mathematica trata apenas como desconhecida, portanto não afetará nenhum outro valor de f. Isso também garante que o primeiro elemento real na entrada obtenha suas duas verificações como todos os outros elementos.

Python, 148 bytes

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

Solução bastante horrenda. Tem que haver uma maneira melhor ...

Ligue com s([2, 1, 1, 1, 4, 5, 6]).

Versão ungolfed

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

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

isso armazena a quantidade que cada elemento apareceu até agora em função dos elementos para a respectiva quantidade, o que é um truque interessante.

isso funciona usando %, uma função que recebe uma função f e um argumento xretorna uma nova função que retorna faplicada ao seu argumento se for diferente de x, e 1 + f xcaso contrário.

por exemplo, 3 % const 0é uma função que retorna 0 para cada argumento, exceto 3, para o qual retorna 1. update: fused the foldlpara obter um programa muito menor.

Demonstração do Ruby 66

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

Ruby stabby lambda que usa uma matriz como parâmetro e retorna uma matriz de matrizes.

Python: 100 bytes

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

Solução simples. Eu percorro a lista, conto quantas vezes um personagem apareceu antes e anexo a parte desde a última verificação à lista de saída.

Ruby, 66

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

Explicação

• eé um hash de contagens de ocorrências para cada elemento, ré uma matriz na qual o resultado é armazenado.
• Faça um loop na entrada, aumente a contagem de ocorrências para cada elemento em 1.
  • Se a contagem de ocorrências for 2, precisamos dividir. Adicione um vazio Arrayao resultado.
  • Caso contrário, basta adicionar o elemento ao último Arrayresultado.

CJam, 25 24 bytes

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

Recebe entrada do STDIN como

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

e saídas como

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

Basicamente, eu estou iterando sobre todos os elementos da matriz, um por um, colocando-os em outra matriz. Então eu recebo a contagem do elemento atual na outra matriz. Se for 2, inicio outra matriz a partir desse local. Esse tipo de arranjo aleatório de matriz só pode ser alcançado em uma linguagem baseada em pilha.

Expansão do código :

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

Experimente online aqui

1 byte salvo da dica de Martin no chat

Ruby, 64 bytes

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

Perl 5: 36

Não tenho certeza se isso é aceitável, pois nenhuma divisão real acontece aqui.

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

Exemplo:

$ 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 bytes

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

Recebe entrada em STDIN como

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

e imprime a saída em STDOUT como

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

Observe que cadeias vazias e matrizes vazias são a mesma coisa no CJam e são exibidas como ""padrão (esta é a representação nativa de matrizes vazias).

(Comecei a trabalhar nisso um pouco antes do lançamento do desafio, porque estávamos discutindo o quão difícil o desafio seria.)

Explicação

Basicamente, estou duplicando cada elemento da matriz, a menos que seja a segunda ocorrência; nesse caso, substituo a primeira cópia por um espaço. Por razões de golfe, essa matriz modificada é construída ao contrário. Então [2 1 1 2 3 2 3]se torna

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

Então eu escolho cada segundo elemento do final, que é a matriz original, mas com as segundas ocorrências substituídas por espaços, ou seja,

[2 1 S S 3 2 S]

Finalmente, eu simplesmente divido a matriz em espaços. Aqui está um detalhamento do código:

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

Ferramentas Unix, 100 bytes

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

Aceita a entrada via stdin. Basicamente, apenas substitui cada segunda ocorrência por "] [". Não funciona com cadeias vazias, []dará uma cadeia vazia, o que eu acho que é uma representação conveniente de uma matriz vazia :)

APL, 42 caracteres

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

Exemplo:

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

Resultado:

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

Testado aqui.

Se eu precisar gerar uma string que seja interpretada exatamente como a estrutura correta no APL ... 49 caracteres

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

Java, 223

Isso funciona apenas no Oracle ou no OpenJDK JRE, uma vez que utilizo essa peculiaridade na implementação de quantificação e verificação de comprimento no look-behind para implementar o look-behind de comprimento variável.

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).*) *","] [")+"]");}}

A maior parte do trabalho é feita na regex, que é mostrada abaixo na forma bruta:

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

Antes de examinarmos o regex acima, vejamos o regex .NET equivalente, que é mais simples, pois suporta diretamente look-behind de comprimento variável (o look-behind do .NET é provavelmente feito pelo modo de correspondência da direita para a esquerda) :

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

•  *\b(\d+)\be  *no final corresponde a um número e os espaços ao redor (se houver). As verificações vinculadas são para impedir que o número parcial seja correspondido, pois os espaços dos dois lados são opcionais. Ele também captura o número para verificar se é a segunda aparição na matriz.

• (?<=(.*\b\1\b){2})verifica se duas instâncias do número capturado acima podem ser encontradas. (?<!(.*\b\1\b){3})verifica se não há 3 instâncias do número capturado. As duas condições combinadas afirmam que existem apenas 2 instâncias do número até o momento. As verificações vinculadas existem para garantir que o número inteiro seja testado.

Voltar para a versão Java. Para implementar um olhar de comprimento variável, transformamos

(?<=var-length-pattern)

para

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

^{Estou acenando um pouco a respeito do fato de .excluir separadores de linha, mas ele pode ser corrigido facilmente e não quero complicar ainda mais a sintaxe.}

O look-ahead tem sempre 0 comprimento e a verificação do comprimento passa devido à implementação de * quantificador.

o ^ é necessário fazê-lo funcionar, mas existe para fazer com que o caso com falha falhe mais rapidamente. O look-behind na implementação do Oracle / OpenJDK é feito recuando o comprimento mínimo do padrão, depois corresponde, enxágue e repita incrementando o comprimento até que uma correspondência seja encontrada, ou, na pior das hipóteses, com o comprimento máximo do padrão. . Com ^, garanto que a sequência de prefixos seja correspondida apenas uma vez.

No entanto, o olhar para frente dentro do olhar para trás não é limitado pelo limite direito do olhar para trás, para que possa corresponder todo o caminho até o final da cadeia. Para afirmar o limite, capturo o restante da string em outro grupo de captura dentro de um olhar à frente e o uso para limitar o reino do padrão de comprimento variável.

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

Como meu padrão já começa .*, não preciso adicionar outro .*na frente.

Perl 108

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

Em ação:

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

Nota: As duas primeiras linhas $Data::...existem apenas para uma melhor apresentação e a terceira linha @a=@b=@e=();existe para tornar a ferramenta funcionando em várias linhas.

R, 76

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

Saída para o exemplo: Uma lista de cinco elementos, incluindo três vetores vazios. (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)

A propósito: O código gera uma mensagem de aviso que pode ser ignorada.

awk 29

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

Isso requer um pouco de liberdade com os formatos de entrada e saída. A entrada "array" é vertical, um número por linha. A saída também é vertical, um número por linha, com traços separando matrizes.

Entrada:

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

Resultado:

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

Pitão 30 32

Esta é minha primeira vez experimentando Pyth. É a mesma solução que na minha solução Python.

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

Você pode experimentá-lo online: Pyth Compiler / Executor

Por exemplo, a entrada

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

irá imprimir

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

Explicação:

                                 # 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

A lista lé a saída até agora. Nós iteramos sobre os elementos. Se a atual for a segunda aparição, iniciaremos uma nova sublist vazia; caso contrário, adicionamos à sublist mais recente. A lista de elementos vistos até agora é armazenada p. Estranhamente, reconstruir a lista parece mais curto do que cortar a entrada.

Pure bash 111 94

81 apenas para divisão:

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

A segunda linha declare -p c apenas despeja a variável

Amostra:

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
}

Nota: a linha local b c d ié necessária apenas para executar a função várias vezes.

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")'

Para uma apresentação mais sexy (+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>"

Renderizará algo como:

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) >


}

Scala, 122 111

Pegue a coleção de caracteres, imprima em forma de [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+"]")

... ou faça uma coleção de caracteres e retorne listas aninhadas, 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

Tenho certeza de que há algumas economias que pude obter, não pareci muito.

Python 220 bytes

O abaixo é de 220 bytes, o que não é ótimo comparado a muitos outros, mas roda rápido o suficiente com números inteiros maiores!

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 bytes

note que isso usa Java 8, o pré-JDK8 demoraria alguns bytes a mais devido ao 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));}}