Desafío

Su tarea para esta pregunta es dividir una matriz de entrada de enteros en la segunda aparición de cada entero en esa matriz.

¿No está lo suficientemente claro? Aquí hay un ejemplo para ayudar

Matriz de entrada:

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

Salida:

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

Explicación:

Aquí está la matriz con solo el segundo elemento resaltado en negrita:

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

Ahora colocamos los bloques de la matriz de división alrededor de estas segundas ocurrencias en negrita:

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

y envolver estas matrices divididas en una matriz para obtener el resultado final

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

Tenga en cuenta que cuando ocurran segundas ocurrencias adyacentes, habrá matrices vacías.

Reglas

Como de costumbre, debe escribir un programa completo o una función que tome la matriz de entrada a través de STDIN, ARGV o argumento de función.

Entrada

La entrada consiste en cualquier formato de matriz conveniente (o tipo matriz) de enteros.

Por ejemplo, cualquiera de los siguientes sería aceptable:

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

Salida

Al salir a STDOUT, su matriz también se puede imprimir en cualquier formato conveniente (anidado) de matriz, por ejemplo, uno de

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

(Esta suele ser la representación de cadenas nativas de matrices en su idioma).

También tenga en cuenta que las matrices vacías finales deben imprimirse como parte de la matriz.

Puntuación

Este es el código de golf, ¡el código más corto en bytes gana!

APL 25

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

Ejemplo:

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

El viejo:

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

Esta es una buena pregunta para el operador clave (⌸) que se introdujo con Dyalog APL v14. Toma la función de argumento izquierdo ({1 ↑ 1 ↓ ⍵}) y le da para cada argumento único, los índices en el vector para ese argumento. Aquí estoy tomando el segundo índice, luego verifico cuál de los índices está presente en esta lista ((⍳⍴⍵) ∊) y uso el booleano resultante para dividir el vector original.

Se puede probar en línea aquí:

http://tryapl.org

APL (Dyalog 14) (31)

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

Esta es una función que toma una matriz y devuelve una matriz anidada.

Prueba:

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

Explicación:

• 0,⍵: Agregue una 0al frente de ⍵, para un procesamiento más fácil. (No cuenta como una ocurrencia).
• (... )⊂: divide la matriz de acuerdo con la máscara de bits dada. Un nuevo grupo comienza en cada uno 1en la máscara de bits.
  • +\∘.=⍨⍵: para cada valor en (el original) ⍵, encuentre todas las ocurrencias en ⍵. Luego haga una suma continua para cada valor, dando una matriz cuadrada que muestre para cada posición ⍵cuántos de cada valor ya han ocurrido.
  • ↓: Divida la matriz por sus filas, dando para cada valor una matriz que muestra la cantidad de veces que ha ocurrido en cada posición.
  • 2⍳⍨¨: En cada una de estas matrices, encuentre el índice de la primera 2.
  • (⍳⍴⍵)∊: Para cada posible índice en ⍵, vea si está contenido en la lista de índices de segundas ocurrencias. (Estos comienzan cada grupo, excepto el primero).
  • 1,: Agregue un 1al frente, marcando el inicio del primer grupo.
• 1↓¨: Elimine el primer elemento de cada grupo. (Estos son los agregados 0y la segunda aparición de cada valor).

J, 28 24 char

Un agradecimiento especial a randomra .

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

Funciona así. Sobre todos los prefijos ( \) de la matriz de entrada, observamos cuántos ( +/@) elementos del prefijo son iguales al último elemento ( ={:) de ese prefijo. Cuando este número es 2, sabemos que esta es la segunda aparición de ese elemento en la matriz, por lo que dividimos la matriz allí 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

Cosa vieja usando trucos ordenar: (1&,<;._1~1,1=i.~(]-{)/:@/:).

Mathematica, 58 51 49 bytes

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

Esta es una función sin nombre que toma una 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}]

y devuelve una lista anidada como

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

Cómo funciona

Esto usa algo de magia bastante oscura con SplitBy.

Estoy realizando un seguimiento de las ocurrencias de cada número en una función f. En Mathematica, puede definir el valor de una función para cada entrada por separado, y no necesita especificar el valor para todas las entradas posibles (es más como una tabla hash con esteroides).

Así que empiezo inicializando fa 0 para los valores que están presentes en la entrada con (f@#=0;#)&/@.

Ahora SplitBytoma una lista y una función y "divide la lista en sublistas que consisten en ejecuciones de elementos sucesivos que dan el mismo valor cuando fse aplica" (tenga en cuenta que SplitByno elimina ningún elemento). Pero la captura (no documentada) es, que fse llama dos veces en cada elemento, cuando se compara con su predecesor y su sucesor. Entonces si lo hacemos

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

no solo obtenemos cada número una vez, sino que esto imprime

 1
 2
 2
 3
 3
 4

que son 6 llamadas para 3 comparaciones.

Podemos dividir la lista antes de cada segundo evento, si escribimos una función que siempre regresa Falsepero regresa Truecuando se compara un segundo evento con el elemento anterior. Esa es la tercera verificación en ese elemento (dos verificaciones en la primera aparición, más la primera verificación en la segunda aparición). Por lo tanto, usamos ++f[#]==3&. Lo bueno es que esto ya regresa Falsenuevamente en la segunda verificación de la segunda ocurrencia, de modo que puedo regresar Truepor segundas ocurrencias consecutivas, pero aún dividido entre ellas . Del mismo modo, esto no se dividirá después de las segundas ocurrencias, porque la función ya regresa Falsenuevamente en la segunda verificación.

Ahora, la pregunta quiere que también eliminemos esas segundas ocurrencias, por lo que eliminamos el primer elemento de cada lista, con Rest/@. Pero, por supuesto, no queremos eliminar el primer elemento de la entrada, por lo que en realidad comenzamos agregando un elemento aal comienzo de la lista con {a}~Join~#. aes una variable indefinida, que Mathematica solo trata como un desconocido, por lo que no afectará a ningún otro valor de f. Esto también asegura que el primer elemento real en la entrada obtenga sus dos verificaciones como cualquier otro elemento.

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

Una solución bastante horrenda. Tiene que haber una mejor manera ...

Llamada con s([2, 1, 1, 1, 4, 5, 6]).

Versión sin golf

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

Esto almacena la cantidad que cada elemento apareció hasta ahora como una función desde los elementos hasta su cantidad respectiva, lo cual es un truco interesante.

esto funciona usando %una función que da una función f y un argumento xdevuelve una nueva función que devuelve faplicada a su argumento si es diferente de x, y de lo 1 + f xcontrario.

por ejemplo, 3 % const 0es una función que devuelve 0 para cada argumento, excepto 3, para el que devuelve 1. actualización: fusionó el foldlpara obtener un programa mucho más pequeño.

Demo de 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 toma una matriz como parámetro y devuelve una matriz de matrices.

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

Solución directa. Repito la lista, cuento cuántas veces apareció un personaje antes y agrego la parte desde la última comprobación a la lista de salida.

Rubí, 66

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

Explicación

• e es un Hash de recuentos de ocurrencia para cada elemento, r es una matriz en la que se almacena el resultado.
• Pase por la entrada, incremente el recuento de ocurrencias para cada elemento en 1 .
  • Si el recuento de ocurrencias es 2, necesitamos dividirnos. Agregar un vacíoArray al resultado.
  • De lo contrario, simplemente agregue el elemento al último Arrayresultado.

CJam, 25 24 bytes

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

Toma información de STDIN como

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

y salidas como

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

Básicamente, estoy iterando sobre todos los elementos de la matriz, uno por uno, colocándolos en otra matriz. Luego obtengo el recuento del elemento actual en la otra matriz. Si es 2, comienzo otra matriz desde esa ubicación. Este tipo de inicio de matriz aleatoria solo se puede lograr en un lenguaje basado en pila.

Expansión de 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";

Pruébalo en línea aquí

1 byte guardado de la sugerencia de Martin en el 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

No estoy seguro de si esto es aceptable ya que aquí no ocurre una división real.

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

Ejemplo:

$ 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/`

Toma entrada en STDIN como

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

e imprime la salida a STDOUT como

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

Tenga en cuenta que las cadenas vacías y las matrices vacías son lo mismo en CJam, y se muestran ""de forma predeterminada (esto es la representación nativa de las matrices vacías).

(Comencé a trabajar en esto un poco antes de que se publicara el desafío, porque estábamos discutiendo lo difícil que sería el desafío).

Explicación

Básicamente, estoy duplicando cada elemento en la matriz, a menos que sea la segunda aparición, en cuyo caso reemplazo la primera copia con un espacio. Por razones de golf, esta matriz modificada se construye a la inversa. Entonces se [2 1 1 2 3 2 3]convierte

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

Luego selecciono cada segundo elemento desde el final, que es la matriz original, pero con las segundas ocurrencias reemplazadas por espacios, es decir

[2 1 S S 3 2 S]

Finalmente, simplemente dividí la matriz en espacios. Aquí hay un desglose del 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.";

Herramientas Unix, 100 bytes.

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

Excepto la entrada a través de stdin. Básicamente, simplemente reemplaza cada segundo caso con "] [". No funciona con cadenas vacías, []dará una cadena vacía, que creo que es una representación conveniente de una matriz vacía :)

APL, 42 caracteres

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

Ejemplo:

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

Salida:

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

Probado aquí.

Si debo generar una cadena que se interpreta exactamente como la estructura correcta en APL ... 49 caracteres

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

Java, 223

Esto solo funciona en Oracle o OpenJDK JRE, ya que uso esta peculiaridad en su implementación del cuantificador y la verificación de longitud en el retrospectivo para implementar el retrospectivo de longitud variable.

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

La mayor parte del trabajo se realiza en la expresión regular, que se muestra a continuación en forma cruda:

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

Antes de ver la expresión regular anterior, echemos una mirada a la expresión regular equivalente de .NET, que es más simple, ya que admite directamente la mirada retrospectiva de longitud variable (la mirada retrospectiva de .NET probablemente se realiza mediante el modo de coincidencia de derecha a izquierda) :

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

•  *\b(\d+)\b y  * al final coincide con un número y los espacios circundantes (si los hay). Los controles encuadernados son para evitar que un número parcial coincida, ya que los espacios en ambos lados son opcionales. También captura el número para verificar si es la segunda aparición en la matriz.

• (?<=(.*\b\1\b){2}) comprueba que se puedan encontrar 2 instancias del número capturado anteriormente. (?<!(.*\b\1\b){3})comprueba que no se puedan encontrar 3 instancias del número capturado. Ambas condiciones combinadas afirman que solo hay 2 instancias del número hasta ahora. Los cheques encuadernados están ahí para asegurarse de que se pruebe el número entero.

Volver a la versión de Java. Para implementar una mirada de longitud variable detrás, transformamos

(?<=var-length-pattern)

a

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

^{Estoy un poco indeciso con respecto al hecho de que .excluye los separadores de línea, pero se puede arreglar fácilmente y no quiero complicar aún más la sintaxis.}

La anticipación siempre tiene una longitud de 0, y la verificación de longitud pasa debido a la implementación de * cuantificador.

los ^ es necesario para que funcione, pero está ahí para hacer que el caso fallido falle más rápido. La implementación de Oracle / OpenJDK se realiza retrocediendo la longitud mínima del patrón, luego coincide, luego enjuaga y repite incrementando la longitud hasta encontrar una coincidencia, o en el peor de los casos, hasta la longitud máxima del patrón . Con^ , me aseguro de que la cadena de prefijo solo coincida una vez.

Sin embargo, la vista hacia el interior dentro de la vista posterior no está limitada por el límite derecho de la vista posterior, por lo que puede coincidir hasta el final de la cadena. Para afirmar el límite, capturo el resto de la cadena en otro grupo de captura dentro de una mirada hacia adelante, y lo uso para limitar el reinado del patrón de longitud variable.

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

Como mi patrón ya comienza .*, no necesito agregar otro .*al frente.

Perl 108

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

En acción:

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: Las dos primeras líneas $Data::...están ahí solo para una mejor presentación y la tercera línea @a=@b=@e=();está ahí para hacer que la herramienta funcione en varias líneas.

R, 76

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

Salida para el ejemplo: una lista de cinco elementos, incluidos tres vectores vacíos. ( 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)

Por cierto: el código genera un mensaje de advertencia que puede ignorarse.

awk 29

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

Esto toma un poco de libertad con los formatos de entrada y salida. La entrada "matriz" es vertical, un número por línea. La salida también es vertical, un número por línea, con guiones que separan las matrices.

Entrada:

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

Salida:

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

Pyth 30 32

Esta es la primera vez que experimento con Pyth. Es la misma solución que en mi solución Python.

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

Puedes probarlo en línea: Pyth Compiler / Executor

Por ejemplo, la entrada

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

imprimirá

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

Explicación:

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

Pitón 2, 84

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

La lista les el resultado hasta ahora. Repetimos los elementos. Si la actual es la segunda aparición, comenzamos una nueva sublista vacía; de lo contrario, lo agregamos a la última sublista. La lista de elementos vistos hasta ahora se almacena en p. Curiosamente, reconstruir la lista parece más corto que cortar la entrada.

Puro bash 111 94

81 por solo dividir:

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

La segunda linea declare -p c simplemente descarga la variable

Muestra:

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: la línea local b c d isolo es necesaria para ejecutar la función varias veces.

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 la presentación más 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

Tome carácter colección, imprimir en 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+"]")

... o toma una colección de personajes y devuelve listas anidadas, 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

Estoy seguro de que podría obtener algunos ahorros, no he buscado demasiado.

Python 220 bytes

¡El siguiente es de 220 bytes, que no es excelente en comparación con muchos de los otros, pero funciona lo suficientemente rápido con enteros más grandes!

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

tenga en cuenta que esto usa Java 8, pre-JDK8 sería unos pocos bytes más debido al 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));}}