Défi

Votre tâche pour cette question consiste à diviser un tableau d'entrée d'entiers à la deuxième occurrence de chaque entier de ce tableau.

Pas assez clair? Voici un exemple pour vous aider

Tableau d'entrée:

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

Production:

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

Explication:

Voici le tableau avec juste le deuxième élément mis en évidence en gras:

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

Maintenant, nous plaçons les blocs de tableau de fractionnement autour de ces secondes occurrences en gras:

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

et envelopper ces tableaux fractionnés dans un tableau pour obtenir la finale

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

Notez que lorsque des secondes occurrences adjacentes se produisent, il y aura des tableaux vides.

Règles

Comme d'habitude, vous devez écrire un programme complet ou une fonction prenant le tableau d'entrée via STDIN, ARGV ou un argument de fonction.

Contribution

L'entrée se compose de n'importe quel format de tableau (ou de type tableau) d'entiers.

Par exemple, l'un des éléments suivants serait acceptable:

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

Production

Lors de la sortie vers STDOUT, votre tableau peut également être imprimé dans n'importe quel format de tableau (imbriqué) pratique, par exemple l'un des

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

(Ce sera généralement la représentation sous forme de chaîne native des tableaux dans votre langue.)

Notez également que les tableaux vides de fin doivent être imprimés en tant que partie du tableau.

Notation

C'est le code-golf donc le code le plus court en octets gagne!

APL 25

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

Exemple:

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

Le vieux:

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

C'est une belle question pour l'opérateur clé (⌸) qui a été introduit avec Dyalog APL v14. Il prend la fonction d'argument de gauche ({1 ↑ 1 ↓ ⍵}) et lui donne pour chaque argument unique, les indices dans le vecteur de cet argument. Ici, je prends le deuxième indice, puis je vérifie lequel des indices est présent dans cette liste ((⍳⍴⍵) ∊) et utilise le booléen résultant pour diviser le vecteur d'origine.

Peut être essayé en ligne ici:

http://tryapl.org

APL (Dyalog 14) (31)

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

Il s'agit d'une fonction qui prend un tableau et renvoie un tableau imbriqué.

Tester:

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

Explication:

• 0,⍵: Ajoutez un 0à l'avant de ⍵, pour un traitement plus facile. (Cela ne compte pas comme une occurrence.)
• (... )⊂: divise le tableau en fonction du masque de bits donné. Un nouveau groupe commence à chacun 1dans le masque de bits.
  • +\∘.=⍨⍵: pour chaque valeur dans (l'original) ⍵, recherchez toutes les occurrences dans ⍵. Ensuite, faites une somme cumulée pour chaque valeur, donnant une matrice carrée montrant pour chaque position ⍵le nombre de chaque valeur qui s'est déjà produite.
  • ↓: Divise la matrice par ses lignes, donnant pour chaque valeur un tableau indiquant le nombre de fois où elle s'est produite pour chaque position.
  • 2⍳⍨¨: Dans chacun de ces tableaux, recherchez l'index du premier 2.
  • (⍳⍴⍵)∊: Pour chaque index possible dans ⍵, voir s'il est contenu dans la liste des index des secondes occurrences. (Ceux-ci commencent chaque groupe, sauf le premier.)
  • 1,: Ajoutez un 1à l'avant, marquant le début du premier groupe.
• 1↓¨: Supprimez le premier élément de chaque groupe. (Ce sont l'ajout 0et la deuxième occurrence de chaque valeur.)

J, 28 24 car

Un merci spécial à randomra .

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

Cela fonctionne comme ça. Sur tous les préfixes ( \) du tableau d'entrée, nous regardons combien d' +/@éléments ( ) du préfixe sont égaux au dernier élément ( ={:) de ce préfixe. Lorsque ce nombre est 2, nous savons que c'est la deuxième occurrence de cet élément dans le tableau, nous avons donc divisé le tableau à l'aide de <;._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

Old chose en utilisant des tours de tri: (1&,<;._1~1,1=i.~(]-{)/:@/:).

Mathematica, 58 51 49 octets

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

Ceci est une fonction sans nom qui prend une liste comme

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

et renvoie une liste imbriquée comme

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

Comment ça fonctionne

Cela utilise une magie assez obscure avec SplitBy.

Je garde une trace des occurrences de chaque nombre dans une fonction f. Dans Mathematica, vous pouvez définir la valeur d'une fonction pour chaque entrée séparément, et vous n'avez pas besoin de spécifier la valeur pour toutes les entrées possibles (c'est plus comme une table de hachage sur les stéroïdes).

Je commence donc par initialiser fà 0 pour les valeurs présentes dans l'entrée avec (f@#=0;#)&/@.

Prend maintenant SplitByune liste et une fonction et "divise la liste en sous-listes constituées d'exécutions d'éléments successifs qui donnent la même valeur lorsqu'elle fest appliquée" (notez que SplitBycela ne supprime aucun élément). Mais la capture (non documentée) est, qui fest appelée deux fois sur chaque élément - lors de la comparaison avec son prédécesseur et son successeur. Donc, si nous le faisons

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

nous n'obtenons pas seulement chaque numéro une fois, mais à la place, cela imprime

 1
 2
 2
 3
 3
 4

soit 6 appels pour 3 comparaisons.

Nous pouvons diviser la liste avant chaque seconde occurrence, si nous écrivons une fonction qui retourne toujours Falsemais revient Truequand une deuxième occurrence est comparée à l'élément précédent. Il s'agit du troisième contrôle sur cet élément (deux contrôles sur la première occurrence, plus le premier contrôle sur la deuxième occurrence). Par conséquent, nous utilisons ++f[#]==3&. La bonne chose est que cela revient déjà à Falsenouveau lors de la deuxième vérification de la deuxième occurrence, de sorte que je peux revenir Truepour des secondes occurrences consécutives, mais toujours réparties entre elles . De même, cela ne se divisera pas après les secondes occurrences, car la fonction revient déjà à Falsenouveau lors de la deuxième vérification.

Maintenant, la question veut que nous supprimions également ces secondes occurrences, donc nous supprimons le premier élément de chaque liste, avec Rest/@. Mais bien sûr, nous ne voulons pas supprimer le tout premier élément dans l'entrée, donc nous commençons en fait, en ajoutant un élément aau début de la liste avec {a}~Join~#. aest une variable non définie, que Mathematica considère comme une inconnue, de sorte qu'elle n'affectera aucune autre valeur de f. Cela garantit également que le premier élément réel dans l'entrée obtient ses deux contrôles comme tous les autres éléments.

Python, 148 octets

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

Solution assez horrible. Il doit y avoir un meilleur moyen ...

Appelez avec s([2, 1, 1, 1, 4, 5, 6]).

Version non golfée

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

cela stocke le montant que chaque élément est apparu en fonction des éléments à leur montant respectif, ce qui est une astuce intéressante.

cela fonctionne en utilisant %, une fonction qui a donné une fonction f et un argument xrenvoie une nouvelle fonction qui retourne fappliquée à son argument s'il est différent de x, et 1 + f xsinon.

par exemple, 3 % const 0est une fonction qui retourne 0 pour chaque argument sauf 3, pour laquelle elle retourne 1. update: a fusionné le foldlpour obtenir un programme beaucoup plus petit.

Démo Ruby 66

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

Ruby stabby lambda qui prend un tableau en paramètre et renvoie un tableau de tableaux.

Python: 100 octets

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

Solution simple. Je parcourt la liste, compte le nombre de fois qu'un personnage est apparu avant et ajoute la partie depuis la dernière vérification à la liste de sortie.

Rubis, 66

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

Explication

• eest un hachage d'occurrence compte pour chaque élément, rest un tableau dans lequel le résultat est stocké.
• En boucle à travers l'entrée, incrémentez le nombre d'occurrences pour chaque élément de 1.
  • Si le nombre d'occurrences est 2, nous devons nous séparer. Ajoutez un vide Arrayau résultat.
  • Sinon, ajoutez simplement l'élément au dernier Arrayrésultat.

CJam, 25 24 octets

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

Prend l'entrée de STDIN comme

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

et des sorties comme

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

Je suis essentiellement en train d'itérer sur tous les éléments du tableau, un par un en les plaçant dans un autre tableau. Ensuite, j'obtiens le nombre de l'élément actuel dans l'autre tableau. Si c'est 2, je démarre un autre tableau à partir de cet emplacement. Ce type de démarrage de tableau aléatoire ne peut être réalisé que dans un langage basé sur la pile.

Expansion du code :

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

Essayez-le en ligne ici

1 octet enregistré à partir du conseil de Martin sur le chat

Ruby, 64 octets

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

Perl 5: 36

Je ne sais pas si cela est acceptable car aucun fractionnement réel ne se produit ici.

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

Exemple:

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

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

Prend des entrées sur STDIN comme

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

et imprime la sortie sur STDOUT comme

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

Notez que les chaînes vides et les tableaux vides sont la même chose dans CJam et sont affichés comme ""par défaut ( c'est la représentation native des tableaux vides).

(J'ai commencé à y travailler un peu avant la publication du défi, car nous discutions de la difficulté du défi.)

Explication

Fondamentalement, je duplique chaque élément du tableau, sauf s'il s'agit de la deuxième occurrence, auquel cas je remplace la première copie par un espace. Pour des raisons de golf, ce tableau modifié est construit à l'envers. Devient [2 1 1 2 3 2 3]ainsi

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

Ensuite, je choisis chaque deuxième élément de la fin, qui est le tableau d'origine, mais avec les secondes occurrences remplacées par des espaces, c'est-à-dire

[2 1 S S 3 2 S]

Enfin, je divise simplement le tableau sur les espaces. Voici une ventilation du code:

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

Outils Unix, 100 octets

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

Exclut l'entrée via stdin. Il remplace simplement chaque seconde occurrence par "] [". Ne fonctionne pas avec des chaînes vides, []donnera une chaîne vide, qui je pense est une représentation pratique d'un tableau vide :)

APL, 42 caractères

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

Exemple:

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

Production:

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

Testé ici.

Si je dois produire une chaîne qui est interprétée exactement comme la bonne structure en APL ... 49 caractères

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

Java, 223

Cela ne fonctionne que sur Oracle ou OpenJDK JRE, car j'utilise cette bizarrerie dans leur implémentation du quantificateur et de la vérification de la longueur en regard pour implémenter le regard de longueur 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 plupart du travail est effectué dans l'expression régulière, qui est présentée ci-dessous sous forme brute:

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

Avant de regarder l'expression régulière ci-dessus, examinons l'expression régulière .NET équivalente, qui est plus simple, car elle prend directement en charge la recherche de longueur variable (la recherche de .NET est très probablement effectuée par le mode de correspondance de droite à gauche) :

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

•  *\b(\d+)\bet  *à la fin correspond à un nombre et aux espaces environnants (le cas échéant). Les vérifications liées visent à empêcher la correspondance d'un nombre partiel, car les espaces des deux côtés sont facultatifs. Il capture également le nombre pour vérifier s'il s'agit de la 2e apparition dans le tableau.

• (?<=(.*\b\1\b){2})vérifie que 2 instances du nombre capturé ci-dessus peuvent être trouvées. (?<!(.*\b\1\b){3})vérifie qu'aucune instance du nombre capturé ne peut être trouvée. Les deux conditions combinées affirment qu'il n'y a jusqu'à présent que 2 instances du nombre. Les vérifications liées sont là pour s'assurer que le nombre entier est testé.

Retour à la version Java. Pour implémenter un look de longueur variable derrière, nous transformons

(?<=var-length-pattern)

à

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

^{Je suis un peu en train de saluer le fait que . les séparateurs de lignes sont exclus, mais cela peut être corrigé facilement et je ne veux pas compliquer davantage la syntaxe.}

L’anticipation a toujours une longueur de 0 et le contrôle de longueur passe en raison de la mise en œuvre de * quantificateur.

Il ^n'est pas nécessaire de le faire fonctionner, mais il est là pour accélérer l'échec du cas défaillant. L'arrière-plan dans l'implémentation Oracle / OpenJDK se fait en reculant de la longueur minimale du modèle, puis en faisant correspondre, puis en rinçant et en répétant en incrémentant la longueur jusqu'à ce qu'une correspondance soit trouvée, ou dans le pire des cas, à la longueur maximale du modèle . Avec ^, je m'assure que la chaîne de préfixe ne correspond qu'une seule fois.

Cependant, l'anticipation à l'intérieur de l'observation n'est pas limitée par la limite droite de l'observation, de sorte qu'elle peut correspondre jusqu'à la fin de la chaîne. Afin d'affirmer la frontière, je capture le reste de la chaîne dans un autre groupe de capture à l'intérieur d'un regard en avant, et je l'utilise pour limiter le règne du modèle de longueur variable.

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

Puisque mon motif commence déjà .*, je n'ai pas besoin d'en ajouter un autre .*devant.

Perl 108

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

En action:

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: Les deux premières lignes ne $Data::...sont là que pour une présentation plus agréable et la troisième ligne @a=@b=@e=();est là pour faire fonctionner l'outil sur plusieurs lignes.

R, 76

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

Sortie pour l'exemple: Une liste de cinq éléments, dont trois vecteurs vides. ( 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)

Soit dit en passant: le code génère un message d'avertissement qui peut être ignoré.

awk 29

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

Cela prend un peu de liberté avec les formats d'entrée et de sortie. Le "tableau" d'entrée est vertical, un nombre par ligne. La sortie est également verticale, un nombre par ligne, avec des tirets séparant les tableaux.

Contribution:

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

Production:

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

Pyth 30 32

C'est ma première expérience avec Pyth. C'est la même solution que dans ma solution Python.

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

Vous pouvez l'essayer en ligne: Pyth Compiler / Executor

Par exemple, l'entrée

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

imprimera

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

Explication:

                                 # 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

La liste lest la sortie jusqu'à présent. Nous parcourons les éléments. Si l'actuelle est la deuxième apparition, nous commençons une nouvelle sous-liste vide; sinon, nous l'ajoutons à la dernière sous-liste. La liste des éléments vus jusqu'à présent est stockée dans p. Curieusement, la reconstruction de la liste semble plus courte que la découpe de l'entrée.

Pure bash 111 94

81 pour seulement le fractionnement:

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

La deuxième ligne declare -p cvient de vider la variable

Échantillon:

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 ligne local b c d i n'est requise que pour exécuter la fonction plusieurs fois.

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

Pour la présentation la plus 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>"

Rendra quelque chose comme:

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

Prendre la collection de caractères, imprimer sous forme 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 prenez une collection de caractères et retournez des listes imbriquées, 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

Je suis sûr qu'il y a des économies à réaliser, je n'ai pas trop cherché.

Python 220 octets

Ce qui suit est de 220 octets, ce qui n'est pas génial par rapport à la plupart des autres mais il fonctionne assez rapidement avec des entiers plus grands!

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 octets

notez que cela utilise Java 8, le pré-JDK8 serait plus long de quelques octets en raison de 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));}}