도전 설명

항목의 목록 / 배열이 주어지면 모든 연속 반복 항목 그룹을 표시합니다.

입출력 설명

입력은 항목의 목록 / 배열입니다 (모든 항목이 동일한 유형이라고 가정 할 수 있음). 언어가 가진 모든 유형을 지원할 필요는 없지만 적어도 하나를 지원해야합니다 (바람직 int하지만 boolean, 흥미롭지는 않지만 같은 유형 도 좋습니다). 샘플 출력 :

[4, 4, 2, 2, 9, 9] -> [[4, 4], [2, 2], [9, 9]]
[1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4] -> [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
[1, 1, 1, 3, 3, 1, 1, 2, 2, 2, 1, 1, 3] -> [[1, 1, 1], [3, 3], [1, 1], [2, 2, 2], [1, 1], [3]]
[9, 7, 8, 6, 5] -> [[9], [7], [8], [6], [5]]
[5, 5, 5] -> [[5, 5, 5]]
['A', 'B', 'B', 'B', 'C', 'D', 'X', 'Y', 'Y', 'Z'] -> [['A'], ['B', 'B', 'B'], ['C'], ['D'], ['X'], ['Y', 'Y'], ['Z']]
[True, True, True, False, False, True, False, False, True, True, True] -> [[True, True, True], [False, False], [True], [False, False], [True, True, True]]
[0] -> [[0]]

빈 목록의 경우 출력이 정의되지 않습니다. 골프 목적에 가장 적합한 것은 아무것도 아니거나, 빈 목록 또는 예외 일 수 있습니다. 별도의 목록 목록도 만들 필요가 없으므로 완벽하게 유효한 결과입니다.

[1, 1, 1, 2, 2, 3, 3, 3, 4, 9] ->

1 1 1
2 2
3 3 3
4
9

중요한 것은 그룹을 어떤 식 으로든 분리하는 것입니다.

Mathematica, 5 바이트

Split

... 내장되어 있습니다.

젤리 , 5 바이트

I0;œṗ

모든 숫자 유형에 적용됩니다. 온라인으로 사용해보십시오! 또는 모든 숫자 테스트 사례를 확인하십시오 .

작동 원리

I0;œṗ  Main link. Argument: A (array)

I      Increments; compute the differences of consecutive elements.
 0;    Prepend a zero.
   œṗ  Partition; split A at truthy values in the result to the left.

망막 , 15 8 바이트

더 간단한 I / O 형식을 제안 해 준 Lynn에게 감사합니다.

!`(.)\1*

입력을 문자 목록으로 취급하고 줄 바꿈을 사용하여 그룹을 구분합니다.

온라인으로 사용해보십시오!

이것은 그룹을 일치시키고 그룹을 모두 인쇄하여 (줄 바꿈 구분을 자동으로 사용) 간단히 작동합니다.

자바 스크립트 (ES6), 39 37 바이트

f=
s=>s.replace(/(\w+) (?!\1\b)/g,`$1
`)
;

<input oninput=o.textContent=f(this.value);><pre id=o>

공백으로 구분 된 단어와 같은 토큰에서 작동합니다. @ MartinEnder ♦ 덕분에 2 바이트가 절약되었습니다. 배열 입력과 반환에 대해 할 수있는 최선은 68입니다.

a=>a.reduce((l,r)=>(l==r?c.push(r):b.push(c=[r]),r),b=[c=[a[0]]])&&b

MATL , 9 바이트

Y'v"@Z}Y"

Y'     % Take input. Run-length encoding. Gives two row arrays: values and run lengths
v      % Concatenate vertically   
"      % For each column
  @Z}  %   Push column and split into its two elements
  Y"   %   Run-length decoding
       % End for. Implicitly display

입력은 공백 또는 쉼표를 구분 기호로 사용하여 숫자 의 행 배열입니다 .

온라인으로 사용해보십시오! 정수 가 아닌 숫자로 테스트하십시오 .

MATL, 11 바이트

lidgvYsG7XQ

입력은 구분자로 사용하여 숫자 또는 문자 로 구성된 열 배열입니다 ;.

온라인으로 사용해보십시오! 임의의 숫자로 테스트하십시오 . 문자로 테스트하십시오 .

l     % Push 1
i     % Take input, say [4;4;2;2;9;9]
d     % Consecutive differences of input: [0;-2;0;7;0]
g     % Convert to logical: gives 1 if consecutive entries were different: [0;1;0;1;0]
v     % Concatenate vertically with the initial 1: [1;0;1;0;1;0]
Ys    % Cumulative sum. Each value is a group label: [1;1;2;2;3;3]
G     % Push input again
7XQ   % Split into horizontal arrays as indicated by group labels: {[4 4];[2 2];[9 9]}
      % Implicitly display

gs2, 2 바이트

c-

온라인으로 사용해보십시오!

c는 정확히 이것을 수행하는 그룹화 된 내장 기능이므로 STDIN (문자열, 즉 문자 목록)에서 호출하고 문자열 목록을 얻습니다. 안타깝게도 결과와 입력을 구분할 수 없으므로 구분 기호를 추가해야합니다! -(공백으로 결합) 트릭을 수행합니다.

대안적인 대답은 cα(2 바이트의 CP437)인데, 이것은 단순히 c익명 함수로 래핑 됩니다.

Brachylog , 13 바이트

:{s.dl1}fs.c?

경고 : 이것은 매우 비효율적이며 설명에서 이유를 이해할 것입니다.

이것은 [1:1:2:2:2]입력으로 목록 (예 :)을 기대합니다 . 목록 안의 요소는 거의 모든 것이 될 수 있습니다.

설명

:{     }f       Find all ordered subsets of the Input with a unique element in them
  s.                Output is a subset of the input
    dl1             Output minus all duplicates has a length of 1 (i.e. one unique value)
         s.     Output is an ordered subset of those subsets
           c?   The concatenation of those subsets is the Input

이것은 s - Subset통일 된 방식으로 만 작동합니다 : 가장 작은 세트가 끝났습니다. 따라서 Input에 연결되는 첫 번째 것은 예를 들어가 [[1:1]:[2:2:2]]아닌 가장 긴 실행 [[1:1]:[2:2]:[2]]입니다.

J , 13 바이트

<;.1~1,2~:/\]

J는 비정형 배열을 지원하지 않기 때문에 동일한 요소가 실행될 때마다 상자가 표시됩니다. 입력은 값의 배열이고 출력은 박스형 배열의 배열입니다.

용법

   f =: <;.1~1,2~:/\]
   f 4 4 2 2 9 9
┌───┬───┬───┐
│4 4│2 2│9 9│
└───┴───┴───┘
   f 1 1 1 3 3 1 1 2 2 2 1 1 3
┌─────┬───┬───┬─────┬───┬─┐
│1 1 1│3 3│1 1│2 2 2│1 1│3│
└─────┴───┴───┴─────┴───┴─┘
   f 'ABBBCDXYYZ'
┌─┬───┬─┬─┬─┬──┬─┐
│A│BBB│C│D│X│YY│Z│
└─┴───┴─┴─┴─┴──┴─┘
   f 0
┌─┐
│0│
└─┘

설명

<;.1~1,2~:/\]  Input: s
            ]  Identify function to get s
       2       The constant 2
           \   Operate on each overlapping sublist of size 2
        ~:/      Are the two values unequal, 1 if true else 0
     1,        Prepend a 1 to it
<;.1~          Using the list just made, chop s at each index equal to 1 and box it
               Return this as the result

Dyalog APL , 9 바이트

⊢⊂⍨1,2≠/⊢

⊢인수
⊂⍨에 분배
1첫 번째 요소로
,다음과
2≠/후속 쌍은 다르며
⊢인수에

파이썬 2, 43 바이트

p=-1
for x in input():print"|"[:x^p],x,;p=x

부울 목록에서 작동합니다. 예:

>> [True,True,False,False,False,True,False,True,False]
 True  True | False  False  False | True | False | True | False

입력 목록을 반복하여 마지막으로 본 요소를 저장합니다. 구분 기호 막대는 이전 요소와 다른 각 요소 앞에 인쇄되며 비트 xor ^가 0 인 것으로 확인 됩니다. 초기화 p=-1하면 첫 번째 요소 앞에 구분 기호가 표시되지 않습니다.

CJam, 9 바이트

두 가지 솔루션 :

{e`:a:e~}
{e`{(*}%}

여기에서 테스트하십시오.

설명

e`   e# Run-length encode (gives a list of pairs [run-length value]).
:a   e# Wrap each pair in a singleton list.
:e~  e# Run-length decode each list.

또는

e`   e# Run-length encode.
{    e# Map this block over each pair...
  (  e#   Pull out the run length.
  *  e#   Repeat the list containing only the value that many times.
}%

하스켈, 22 바이트

import Data.List
group

내장되어 있습니다. 평등을 지원하는 모든 유형에서 작동합니다.

MATL, 8 7 바이트

@Suever 덕분에 1 바이트가 제거되었습니다.

ly&Y'Y{

정수 / 부동 / 문자 / 부울 / 유니콘 포인트 / 기타 가상 입력과 함께 작동합니다.
부울의 경우 입력은 T/F, 출력은 1/0입니다.

온라인으로 사용해보십시오!

그룹화 및 반복

ly&Y'Y{
l          % push 1 onto the stack
 y         % duplicate the input
  &Y'      % run-length encoding (secondary output only)
     Y{    % break up array into cell array of subarrays

C #, 117 바이트

void f(List<String>m){Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));}

ungolfed (실제로는 아님)

    public static void f(List<String>m)
    {
        Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));
    }

Pyth, 9 7 바이트

mr9]dr8

2 바이트에 @LeakyNun에 대한 크레딧!

설명:

             input
     r8      run-length decode
m            for each...
   ]d        ...treat each run as standalone encoded form...
 r9          ...decode 
             print

이전 답변, 12 바이트

hf.Am!t{dT./

런 길이 내장을 잊어 버렸지 만 이것이 괜찮은 접근법이라고 생각합니다.

설명:

                input
          ./    all possible partitions
 f       T      filter by...
  .A            ...whether all groups of integers...
    m!t{d       ...have length one after deduplication
h               get the first element (first one has no adjacent [1,1] and [1])
                print

Pyth , 36 35 바이트

VQIqNk=hZ).?=+Y]*]kZ=Z1=kN;t+Y]*]kZ

테스트 링크

편집 : 설명 :

                                      standard variables: Y=[], Z=0, k='', Q=input
VQ                                    iterate over input
  IqNk                                if the current entity is equal to k:
      =hZ)                            increase Z.
          .?                          else:
               ]*]kZ                  list of length Z filled with k
            =+Y                       add it to Y
                    =Z1               set Z to 1
                       =kN            set k to the current entity
                          ;           end loop
                              ]*]kZ   list of length Z filled with k
                            +Y        add it to Y
                           t          implicitly print the tail of Y (removing the first element)

망막 , 24 22 바이트

Martin Ender 덕분에 2 바이트.

15 바이트의 대답 이 더 바이트 비용 또 다른 접근 방법이다, 그래서 이미 존재한다.

S-`(?<=(\d+)) (?!\1\b)

온라인으로 사용해보십시오!

선행 번호와 진행 번호가 다른 공간으로 분할됩니다.

이것은 둘러보기의 데모입니다.

05AB1E, 13 바이트

¬svyÊi¶}yðJ?y

설명

¬s             # push first element of list to stack and swap with input
  v            # for each X in input
   yÊi¶}       # if X is different from last iteration, push a newline
        yðJ?   # push X followed by a space to stack and join stack to string
            y  # push X to stack for next iterations comparison

모든 목록에서 작동합니다.
int와 char에서 테스트되었습니다.

온라인으로 사용해보십시오

스위프트, 43 바이트

var p=0;i.map{print($0==p ?"":",",$0);p=$0}

i를 동일시 가능한 객체의 배열이라고 가정합니다. int에서 문자열, 사용자 정의 객체에 이르기까지 모든 작업에 적합합니다. 출력에 많은 줄 바꿈이 포함되어 있다는 점에서 건방진이지만 더 예쁘게하면 바이트가 필요합니다.

더 예쁘고 골치 아픈 버전 :

var prev = Int.max // unlikely to be the first element, but not the end of the world if it happens to be.
i.map { n in
    print(n == prev ? " " : "\n•", n, terminator: "")
    prev = n
}

이 버전은 더 많은 코드를 희생하여 모든 그룹을 새 줄에 인쇄합니다.

개선을위한 아이디어

i.reduce(0){print($0==$1 ?"":"•",$1);return $1}

이 버전에는 47 바이트가 있지만 다른 접근 방식이므로 최적화해야 할 것이 있습니까? 가장 큰 문제는 return statement입니다.

C, 88 77 바이트

11 바이트 절약 strmcmp 내부 로 이동printf

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}

용법:

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}
main(c,v)char**v;{f(v);}

샘플 입력 :

(명령 행 매개 변수)

1 1 1 1 2 2 2 2 3 3 3 3 4 5 6 7777

샘플 출력 :

1 1 1 1
2 2 2 2
3 3 3 3
4
5
6
7777

에 테스트 :

gcc 4.4.7 (Red Hat 4.4.7-16)  - OK
gcc 5.3.0 (Cygwin)            - Segmetation Fault
gcc 4.8.1 (Windows)           - OK

5.3.0 Segmetation Fault를 수정하려고합니다.

88 버전

f(char**a){*a++;char*x;for(;*a;x=*a++)strcmp(*a,x)?printf("\n%s ",*a):printf("%s ",*a);}

자바 134 바이트

void a(String[]a){int i=0,l=a.length;for(;i<l-1;i++)System.out.print(a[i]+((a[i].equals(a[i+1]))?" ":"\n"));System.out.print(a[l-1]);}

반복하여 줄 바꾸기 또는 공백으로 구분할지 여부를 결정합니다.

ListSharp , 134 바이트

STRG l = READ[<here>+"\\l.txt"]
[FOREACH NUMB IN 1 TO l LENGTH-1 AS i]
{
[IF l[i] ISNOT l[i-1]]
STRG o=o+"\n"
STRG o=o+l[i]
}
SHOW = o

ListSharp는 함수를 지원하지 않으므로 배열이 로컬 파일에 저장됩니다. l.txt

루비 , 24 바이트

루비 Array인스턴스에는 내장 메소드가 있습니다.group_by

해결책은 다음과 같습니다.

a.group_by{|x| x}.values

TSQL, 132 바이트

이것은 다른 답변과 약간 다릅니다 .sql에는 배열이 없으며 sql에 대한 명백한 입력은 테이블입니다.

골프 :

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT REPLICATE(v+' ',COUNT(*))FROM(SELECT i,i-row_number()over(partition
by v order by i)x,v FROM @)z GROUP BY x,v ORDER BY max(i)

언 골프 드 :

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT
  REPLICATE(v+' ',COUNT(*))
FROM 
  (
     SELECT
       i,
       i-row_number()over(partition by v order by i)x,
       v
     FROM @
  )z
GROUP BY
  x,v
ORDER BY
  max(i)

깡깡이

펄 5-39 바이트

print$_.($/)[$_ eq@a[++$-]]for@a=sort@a

파이크, 2 바이트 (비경쟁)

정수만 지원

$f

여기 사용해보십시오!

split_at(input, delta(input))

split_at 노드 추가, 2 차 인수가 진실 일 때 입력을 분할

sed, 33 23 + 1 = 24 바이트

s/([^ ]+)( \1)* */&\n/g

-r옵션 이 필요합니다 .

사용 예 :

$ echo '1 1 1 2 2 3 3 3 4 9 9' | sed -r 's/([^ ]+)( \1)* */&\n/g'
1 1 1 
2 2 
3 3 3 
4 
9 9

자바 스크립트 (ES6), 56

입력 : 숫자 또는 문자열 배열

출력 : 배열의 배열

골프 코드에서 정확한 비교를 사용한 최초의 사례

a=>a.map(x=>x!==p?o.push(g=[p=x]):g.push(x),p=o=g=[])&&o

클로저, 19 바이트

#(partition-by + %)

내장되어 있지만 매핑 기능이 필요합니다. 이 경우 +아이덴티티 기능을합니다.

자바 스크립트 (외부 라이브러리 사용) (178 바이트)

(s)=>_.From(s).Aggregate((t,e)=>{if(0===t.Items.length)return t.Items.push([e]),t;var s=t.Items[t.Items.length-1];return s[0]===e?(s.push(e),t):(t.Items.push([e]),t)},{Items:[]})

면책 조항 : C #에서 LINQ를 JS로 구현하기 위해 작성한 라이브러리를 사용하고 있습니다. 이기는 데 도움이되지는 않았지만