도전

이 질문에 대한 당신의 임무는 해당 배열에서 모든 정수의 두 번째 발생에 정수의 입력 배열을 분할하는 것입니다.

충분히 명확하지 않습니까? 다음은 도움이되는 예입니다.

입력 배열 :

[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 2 2 3 4 5 6 7 3 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}}

(일반적으로 사용자 언어로 배열의 기본 문자열 표현이됩니다.)

또한 마지막 빈 배열은 배열의 일부로 인쇄해야합니다.

채점

이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 승리합니다!

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 ↓ ⍵})를 사용하여 각 고유 인수에 대해 해당 인수에 대한 벡터의 색인을 제공합니다. 여기에 두 번째 색인을 취한 다음이 목록 ((⍳⍴⍵) ∊)에 어떤 색인이 있는지 확인하고 결과 부울을 사용하여 원래 벡터를 분할합니다.

여기에서 온라인으로 시도 할 수 있습니다 :

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⍳⍨¨:이 각 배열에서 첫 번째 인덱스를 찾으십시오 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.~(]-{)/:@/:).

매스 매 티카, 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 하지 않음 ). 그러나 (문서화되지 않은) catch는 이전 요소와 후속 요소와 비교할 때 각 요소에서 두 번 호출 됩니다 . 우리가 할 경우f

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

우리는 각 숫자를 한 번만 얻는 것이 아니라 대신 인쇄합니다.

 1
 2
 2
 3
 3
 4

이것은 3 번의 비교를위한 6 번의 호출입니다.

우리는 항상 두 번째 항목을 이전 요소와 비교할 때 반환 하지만 반환 하는 함수를 작성하면 두 번째 항목 보다 먼저 목록을 분할 할 수 있습니다 . 이는 해당 요소 의 세 번째 검사입니다 (첫 번째 발생에 대한 두 가지 검사와 두 번째 발생에 대한 첫 번째 검사). 따라서 우리는를 사용 합니다. 좋은 점은 이것이 두 번째 발생의 두 번째 검사에서 이미 다시 반환 되어 연속적인 두 번째 발생을 반환 할 수는 있지만 여전히 분할 된다는 것 입니다. 마찬가지로, 두 번째 검사에서 함수가 이미 다시 반환되므로 두 번째 발생 후에도 분할 되지 않습니다 .FalseTrue++f[#]==3&FalseTrueFalse

이제 질문은 두 번째 항목도 제거하기를 원하므로 각 목록에서 첫 번째 요소를로 삭제하십시오 Rest/@. 그러나 물론 우리는 입력에서 첫 번째 요소를 제거하고 싶지 않기 때문에 실제로 a목록의 시작 부분에 요소 를 추가 하여 시작합니다 {a}~Join~#. a는 정의되지 않은 변수이며 Mathematica는 알 수없는 것으로 취급하므로의 다른 값에는 영향을 미치지 않습니다 f. 또한 입력 의 첫 번째 실제 요소는 다른 모든 요소와 마찬가지로 두 가지 검사를받습니다.

파이썬, 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 03을 제외한 모든 인수에 대해 0을 반환하고 1을 반환하는 함수입니다. update : fused the foldl가 더 작은 프로그램을 얻습니다.

루비 66 데모

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

배열을 매개 변수로 사용하고 배열 배열을 반환하는 Ruby stabby lambda

파이썬 : 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.
  • 발생 횟수가 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";

여기에서 온라인으로 사용해보십시오

채팅시 Martin의 팁에서 1 바이트 저장

루비, 64 바이트

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

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

유닉스 도구, 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

가변 길이 look-behind를 구현하기 위해 look-behind에서 수량화 및 길이 검사를 구현할 때이 쿼크 를 사용하기 때문에 이것은 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).*) *

위의 정규 표현식을 살펴보기 전에 가변 길이 look-behind를 직접 지원하기 때문에 더 간단한 동등한 .NET 정규식을 살펴 보겠습니다 (.NET look-behind는 오른쪽에서 왼쪽으로 일치하는 모드로 수행 될 가능성이 높습니다) :

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

•  *\b(\d+)\b및  *끝에 번호와 주위 공간 (있는 경우)과 일치. 바운드 검사는 양쪽의 공백이 선택 사항이므로 부분 번호가 일치하지 않도록합니다. 또한 배열에서 두 번째 모양인지 확인하기 위해 숫자를 캡처합니다.

• (?<=(.*\b\1\b){2})위에서 캡처 한 숫자의 2 개의 인스턴스를 찾을 수 있는지 확인합니다. (?<!(.*\b\1\b){3})캡처 된 숫자의 3 개의 인스턴스를 찾을 수 없는지 확인합니다. 두 조건을 결합하면 지금까지 2 개의 인스턴스가 있다고 주장합니다. 바운드 검사는 정수가 테스트되도록하기위한 것입니다.

Java 버전으로 돌아갑니다. 가변 길이 룩을 구현하기 위해

(?<=var-length-pattern)

에

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

^{.줄 구분 기호 를 제외 한다는 사실에 대해서는 약간 손을 ing 수 있지만 쉽게 고칠 수 있으며 구문을 더 복잡하게 만들고 싶지 않습니다.}

미리보기의 길이는 항상 0이며, *수량 화기 의 구현으로 인해 길이 검사가 통과 됩니다.

이 기능을 ^작동시킬 필요는 없지만 실패한 사례를 더 빨리 실패하게합니다. Oracle / OpenJDK 구현의 Look-Behind는 패턴의 최소 길이를 뒤로 물러서 일치시킨 다음 일치하는 것을 찾을 때까지 또는 최악의 경우 패턴의 최대 길이까지 길이를 늘려서 헹구고 반복합니다. . 로 ^접두사 문자열이 한 번만 일치하는지 확인합니다.

그러나 look-behind 내부의 look-ahead는 look-behind의 오른쪽 경계에 의해 제한되지 않으므로 문자열의 끝까지 일치 할 수 있습니다. 경계를 설정하기 위해 나머지 문자열을 다른 캡쳐 그룹으로 캡처하여 변수 길이 패턴의 통치를 제한합니다.

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

내 패턴은 이미로 시작하므로 앞에 .*다른 것을 추가 할 필요가 없습니다 .*.

펄 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=();은 도구를 여러 줄에서 사용할 수 있도록하기위한 것입니다.

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

그건 그렇고 : 코드는 무시할 수있는 경고 메시지를 생성합니다.

2 월 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를 실험 한 것은 이번이 처음입니다. 내 파이썬 솔루션과 동일한 솔루션입니다.

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

파이썬 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) >


}

스칼라 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

나는 내가 얻을 수있는 약간의 저축이 있다고 확신한다. 나는 너무 열심히 보지 않았다.

파이썬 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)

자바 : 563 바이트

이것은 Java 8을 사용하므로 pre-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));}}