チャレンジ

この質問のタスクは、整数の入力配列を、その配列内のすべての整数の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] []]

説明：

これは、2番目の要素だけが太字で強調表示されている配列です。

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

次に、これらの太字の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] []]

隣接する2番目のオカレンスが発生すると、空の配列が存在することに注意してください。

ルール

いつものように、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↓⍵}）を受け取り、一意の引数ごとに、その引数のベクトル内のインデックスを与えます。ここでは、2番目のインデックスを取得し、このリストにインデックスが存在するかどうかを確認し（（⍳⍴⍵）∊）、結果のブール値を使用して元のベクトルを分割します。

ここでオンラインで試すことができます：

http://tryapl.org

APL（ダイアログ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の前にa を追加して、⍵処理を容易にします。（オカレンスとしてカウントされません。）
• (... )⊂：指定されたビットマスクに従って配列を分割します。新しいグループは1、ビットマスク内のそれぞれから始まります。
  • +\∘.=⍨⍵：（元の）の各値について⍵、のすべての出現を検索し⍵ます。次に、各値の累積合計を作成し、⍵各値の数がすでに発生している各位置を示す正方行列を与えます。
  • ↓：行ごとにマトリックスを分割し、各値ごとに、各位置で発生した回数を示す配列を指定します。
  • 2⍳⍨¨：これらの各配列で、最初ののインデックスを見つけます2。
  • (⍳⍴⍵)∊：への可能性のある各インデックス⍵について、それが2番目のオカレンスのインデックスのリストに含まれているかどうかを確認します。（これらは、最初のグループを除く各グループを開始します。）
  • 1,：を1先頭に追加し、最初のグループの開始をマークします。
• 1↓¨：各グループから最初の要素を削除します。（これらは、追加された0、および各値の2番目の出現です。）

J、28 24文字

randomraに感謝します。

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

それはこのように動作します。\入力配列のすべてのプレフィックス（）について、+/@プレフィックスの最後の要素（={:）と等しいプレフィックスの要素数（）を調べます。この数が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しません削除任意の要素）。しかし、（文書化されていない）キャッチは、各要素で2回f呼び出されます-先行および後続と比較する場合。もしそうなら

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

各番号を一度だけ取得するのではなく、代わりに次のように出力します

 1
 2
 2
 3
 3
 4

これは3回の比較に対して6回の呼び出しです。

常に戻るが、2番目の出現がその前の要素と比較されたときに戻る関数を記述する場合、2番目の出現の前にリストを分割できます。これは、その要素の3回目のチェックです（最初の発生時に2回のチェックに加え、2回目の発生時に1回目のチェック）。したがって、使用します。良いことは、2回目のオカレンスの2回目のチェックでこれが既に戻っていることです。連続した2回目のオカレンスに戻ることができますが、それらの間で分割されます。同様に、関数は2回目のチェックですでに戻っているため、2回目の出現後にこれは分割されません。FalseTrue++f[#]==3&FalseTrueFalse

さて、質問ではこれらの2番目のオカレンスも削除する必要があるため、各リストから最初の要素を削除しRest/@ます。ただし、もちろん、入力の最初の要素を削除したくないので、実際にaは、リストの先頭にを使用して要素を追加することから始め{a}~Join~#ます。aは未定義の変数であり、Mathematicaは単に未知のものとして扱うため、の他の値には影響しませんf。これにより、入力の最初の実際の要素が、他のすべての要素と同様に2つのチェックを取得することも保証されます。

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 01を返す3を除くすべての引数に対して0を返す関数です 。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:]]

簡単なソリューション。リストを反復処理し、以前に文字が出現した回数をカウントし、最後のチェック以降の部分を出力リストに追加します。

ルビー、66

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

説明

• e各要素の発生回数のハッシュrであり、結果が格納される配列です。
• 入力をループし、各要素のオカレンスカウントを1ずつ増やします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] ""]

基本的に、配列のすべての要素を1つずつ別の配列に入れて繰り返します。次に、他の配列の現在の要素のカウントを取得します。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";

こちらからオンラインでお試しください

チャットに関するMartinのヒントから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番目に出現しない限り、配列の各要素を複製します。その場合、最初のコピーをスペースに置き換えます。ゴルフの理由から、この変更されたアレイは逆に構築されます。そう[2 1 1 2 3 2 3]なる

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

次に、元の配列である最後から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を介した入力を除きます。基本的には、1回おきにを置き換えるだけ"] ["です。空の文字列で[]は機能せず、空の文字列を提供しますが、これは空の配列の便利な表現だと思います:)

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=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂',⍬)('}

Java、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そして *終わりに番号と周囲のスペース（もしあれば）に一致します。両側のスペースはオプションであるため、バインドされたチェックは部分的な番号の一致を防ぐためのものです。また、配列内の2番目の外観であるかどうかを確認する番号をキャプチャします。

• (?<=(.*\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][]

注：最初の2行$Data::...は見やすくするためだけにあり、3行目@a=@b=@e=();はツールを複数の行で動作させるためにあります。

R、76

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

例の出力：3つの空のベクトルを含む5つの要素のリスト。（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

これには、入力形式と出力形式に多少の自由度があります。入力の「配列」は垂直で、1行に1つの数字があります。出力も垂直で、行ごとに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 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これまでのリストは出力です。要素を繰り返し処理します。現在のものが2番目の外観である場合、新しい空のサブリストを開始します。それ以外の場合は、最新のサブリストに追加します。これまでに見た要素のリストはに保存され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変数をダンプするだけの2行目

サンプル：

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バイト

これはJava 8を使用していることに注意してください。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));}}