挑战

这个问题的任务是在第二次出现该整数的输入整数时拆分该整数的输入数组。

还不够清楚？这是一个帮助的例子

输入数组：

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

输出：

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

说明：

这是仅以粗体突出显示第二个元素的数组：

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

现在，我们将拆分数组块放在这些大胆的第二次出现周围：

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

并将这些拆分后的数组包装在数组中以获得最终

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

请注意，当相邻的第二个事件发生时，将有空数组。

规则

与往常一样，您必须编写一个完整程序或通过STDIN，ARGV或函数参数接受输入数组的函数。

输入值

输入包含任何方便的整数数组（或类似数组的格式）。

例如，以下任何一项都可以接受：

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

输出量

当输出到STDOUT时，您的阵列也可以以任何方便的（嵌套的）阵列格式进行打印，例如

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

（这通常是您语言中数组的本机字符串表示形式。）

另请注意，结尾的空数组应作为数组的一部分进行打印。

计分

这是代码高尔夫球，因此最短的代码以字节为单位！

杀伤人员地雷25

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⍳⍨¨在每个数组中，找到first的索引2。
  • (⍳⍴⍵)∊：对于的每个可能的索引⍵，请查看它是否包含在第二次出现的索引列表中。（这些开始每个组，第一个除外。）
  • 1,：1在前面添加一个，标记第一个组的开始。
• 1↓¨：从每个组中删除第一个元素。（这些是0每个值的相加和第二次出现。）

J，28 24个字符

特别感谢randomra。

(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中，您可以分别为每个输入定义函数的值，而无需为所有可能的输入指定值（它更像是类固醇的哈希表）。

所以我首先f将输入中存在的值初始化为0(f@#=0;#)&/@。

现在，SplitBy获取一个列表和一个函数，然后“将列表拆分为由连续元素组成的子列表，这些元素在f应用时会提供相同的值”（请注意，SplitBy它不会删除任何元素）。但是（未记录的）捕获是在每个元素上f调用两次的 -与它的前任及其后继相比。所以如果我们这样做

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

我们不只是获取每个数字一次，而是打印

 1
 2
 2
 3
 3
 4

这是6个，需要进行3个比较。

如果我们编写一个始终返回但将第二次出现与之前的元素进行比较时返回的函数，则可以在第二次出现之前拆分列表。那是对该元素的第三次检查（第一次检查两次，再加上第二次检查第一次）。因此，我们使用。令人高兴的是，这已经在第二次出现的第二次检查中再次返回，因此我可以返回FalseTrue++f[#]==3&FalseTrue连续的第二次出现，但仍然可以在它们之间进行分割。同样，第二次出现后也不会拆分，因为该函数已经返回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)]

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

这样就存储了每个元素出现的数量（从一个元素到它们各自的数量），这是一个有趣的技巧。

这可以使用%，给定函数f和参数的函数x返回一个新函数，f如果该函数不同于x，则该函数返回适用于其参数的函数，并且1 + f x。

例如，3 % const 0是一个函数，它为除3之外的每个参数返回0，对于该参数它返回 1。update： 融合foldl以获得更小的程序。

Ruby 66 演示

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

Ruby stabby lambda，它将数组作为参数并返回数组数组。

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

简单的解决方案。我遍历该列表，计算一个字符之前出现过多少次，并将自上次检查以来的部分追加到输出列表中。

Ruby，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个字节

Ruby，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]/'

除了通过stdin输入。它基本上只是用代替第二次出现"] ["。不适用于空字符串，[]会给出一个空字符串，我认为这是一个方便的空数组表示形式：)

APL，42个字符

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

例：

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

输出：

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

在这里测试。

如果我必须输出一个完全解释为APL中正确结构的字符串... 49个字符

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

爪哇，223

这仅在Oracle或OpenJDK JRE上有效，因为我在后置量词和长度检查的实现中使用了这个怪癖，从而实现了变长后置。

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

大部分工作都在正则表达式中完成，下面以原始格式显示：

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

在查看上面的正则表达式之前，让我们看一下等效的.NET正则表达式，它更简单，因为它直接支持可变长度的后向查找（.NET后向查找很可能是从右向左匹配模式完成的） ：

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

•  *\b(\d+)\b 和  *在末尾匹配数字和周围的空格（如果有）。边界检查是为了防止部分数字匹配，因为两侧的空格是可选的。它还捕获数字以检查它是否是数组中的第二个外观。

• (?<=(.*\b\1\b){2}) 检查是否可以找到上面捕获的数字的2个实例。 (?<!(.*\b\1\b){3})检查是否找不到3个捕获到的号码实例。结合这两个条件可以断言，到目前为止，只有两个实例。在那里进行了边界检查，以确保对整数进行了测试。

返回Java版本。为了实现变长后视，我们将

(?<=var-length-pattern)

至

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

^{我有点挥霍， .排除行分隔符，但是可以轻松修复它，并且我不想进一步使语法复杂化。}

前瞻的长度始终为0，由于实施了，长度检查通过 *量词。

的 ^是没有必要的，使其工作，但它的存在使失败的情况下，失败得更快。在Oracle / OpenJDK实现中进行回溯是通过退回模式的最小长度，然后进行匹配，然后通过增加长度直到达到匹配为止进行漂洗并重复，或者在最坏的情况下，达到模式的最大长度。用^，我确保前缀字符串仅匹配一次。

但是，后向内部的前向不受后向右边界的限制，因此它可以一直匹配到字符串的末尾。为了确定边界，我将字符串的其余部分捕获到了向前看的另一个捕获组中，并用它来限制可变长度模式的统治。

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

由于我的模式已经从开始.*，所以我不需要.*在前面添加其他模式。

Perl 108

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

实际上：

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

注意：前两行$Data::...仅用于更好地演示，而第三行@a=@b=@e=();则用于使工具在多行上工作。

R，76

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

示例的输出：五个元素的列表，包括三个空向量。（numeric(0)）。

$`0`
[1] 2 1

$`1`
numeric(0)

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

$`3`
numeric(0)

$`4`
[1] 0

$`5`
numeric(0)

顺便说一句：该代码生成一条警告消息，可以将其忽略。

AWK 29

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

输入和输出格式需要一些自由。输入“数组”是垂直的，每行一个数字。输出也是垂直的，每行一个，用破折号分隔数组。

输入：

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

输出：

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

腐霉病30 32

这是我第一次尝试Pyth。与我的Python解决方案中的解决方案相同。

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

您可以在线尝试：Pyth编译器/执行器

例如输入

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


}

Scala中，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字节

请注意，由于使用了foreach，因此使用Java 8，而JDK8之前的版本则要长几个字节。

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