Mô tả thử thách

Đưa ra một danh sách / mảng các mục, hiển thị tất cả các nhóm các mục lặp lại liên tiếp.

Mô tả đầu vào / đầu ra

Đầu vào của bạn là một danh sách / mảng các mặt hàng (bạn có thể giả sử tất cả chúng đều cùng loại). Bạn không cần phải hỗ trợ mọi loại ngôn ngữ của bạn, nhưng phải hỗ trợ ít nhất một loại (tốt nhất là int, nhưng các loại như boolean, mặc dù không thú vị lắm, cũng tốt). Đầu ra mẫu:

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

Đối với danh sách trống, đầu ra không được xác định - nó có thể không là gì, danh sách trống hoặc ngoại lệ - bất cứ điều gì phù hợp với mục đích chơi golf của bạn là tốt nhất. Bạn cũng không phải tạo một danh sách danh sách riêng biệt, vì vậy đây cũng là một đầu ra hoàn toàn hợp lệ:

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

1 1 1
2 2
3 3 3
4
9

Điều quan trọng là giữ cho các nhóm tách biệt theo một cách nào đó.

Toán học, 5 byte

Split

... có tích hợp sẵn cho việc đó.

Thạch , 5 byte

I0;œṗ

Hoạt động cho tất cả các loại số. Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp kiểm tra số .

Làm thế nào nó hoạt động

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.

Võng mạc , 15 8 byte

Cảm ơn Lynn đã gợi ý một định dạng I / O đơn giản hơn.

!`(.)\1*

Xử lý đầu vào dưới dạng danh sách các ký tự (và sử dụng nguồn cấp dữ liệu để phân tách các nhóm).

Hãy thử trực tuyến!

Điều này chỉ đơn giản hoạt động bằng cách khớp các nhóm và in tất cả chúng (sử dụng tự động tách dòng).

JavaScript (ES6), 39 37 byte

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

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

Hoạt động trên mọi mã thông báo giống như từ được phân tách bằng dấu cách. Đã lưu 2 byte nhờ @ MartinEnder ♦. Tốt nhất tôi có thể làm cho đầu vào mảng và trả về là 68:

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

MATL , 9 byte

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

Đầu vào là một dãy số , với dấu cách hoặc dấu phẩy là dấu phân cách.

Hãy thử trực tuyến! Kiểm tra với các số không nguyên .

MATL, 11 byte

lidgvYsG7XQ

Đầu vào là một mảng cột gồm số hoặc ký tự , sử dụng ;làm dấu phân cách.

Hãy thử trực tuyến! Kiểm tra với số lượng tùy ý . Thử nghiệm với các nhân vật .

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 byte

c-

Hãy thử trực tuyến!

clà một nhóm được tích hợp sẵn thực hiện chính xác điều này, vì vậy chúng tôi gọi nó trên STDIN (là một chuỗi, tức là một danh sách các ký tự) và nhận danh sách các chuỗi. Đáng buồn thay, kết quả không thể phân biệt với đầu vào, vì vậy chúng ta cần thêm dấu phân cách! -(tham gia bởi không gian) thực hiện các mẹo.

Một câu trả lời khác là cα(2 byte CP437), chỉ đơn giản là bao bọc cthành một hàm ẩn danh.

Brachylog , 13 byte

:{s.dl1}fs.c?

Cảnh báo: điều này cực kỳ không hiệu quả, và bạn sẽ hiểu tại sao trong phần giải thích.

Điều này mong đợi một danh sách (ví dụ [1:1:2:2:2]) là đầu vào. Các yếu tố trong danh sách có thể là khá nhiều bất cứ điều gì.

Giải trình

:{     }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

Điều này chỉ hoạt động vì cách s - Subsetthống nhất: các bộ nhỏ nhất ở cuối. Do đó, điều đầu tiên mà nó thấy rằng nối với Đầu vào là các lần chạy dài nhất, ví dụ [[1:1]:[2:2:2]]và không phải là ví dụ [[1:1]:[2:2]:[2]].

J , 13 byte

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

Vì J không hỗ trợ các mảng bị rách, nên mỗi lần chạy các phần tử bằng nhau được đóng hộp. Đầu vào là một mảng các giá trị và đầu ra là mảng các mảng được đóng hộp.

Sử dụng

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

Giải trình

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

APL Dyalog , 9 byte

⊢⊂⍨1,2≠/⊢

⊢đối số được
⊂⍨phân vùng tại
1phần tử đầu tiên
,và sau đó
2≠/các cặp tiếp theo khác nhau
⊢trong đối số

Python 2, 43 byte

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

Hoạt động trên danh sách booleans. Thí dụ:

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

Lặp lại thông qua danh sách đầu vào, lưu trữ phần tử nhìn thấy lần cuối. Một thanh phân cách được in trước mỗi phần tử khác với phần tử trước, được kiểm tra là có xor bit bit ^bằng 0. Khởi tạo p=-1để tránh một dấu tách trước phần tử đầu tiên.

CJam, 9 byte

Hai giải pháp:

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

Kiểm tra nó ở đây.

Giải trình

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.

Hoặc là

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.
}%

Haskell, 22 byte

import Data.List
group

Có tích hợp sẵn. Hoạt động trên bất kỳ loại hỗ trợ bình đẳng.

MATL, 8 7 byte

Đã xóa 1 byte nhờ @Suever

ly&Y'Y{

Hoạt động với số nguyên / float / chars / booleans / unicorn points / các đầu vào tưởng tượng khác.
Đối với booleans, đầu vào là T/F, đầu ra là 1/0.

Hãy thử trực tuyến!

Được nhóm lại và lặp đi lặp lại

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 byte

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

vô dụng (không thực sự)

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

Bình thường, 9 7 byte

mr9]dr8

Tín dụng cho @LeakyNun cho 2 byte!

Giải trình:

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

Câu trả lời cũ, 12 byte

hf.Am!t{dT./

Quên về chiều dài chạy tích hợp, nhưng tôi nghĩ rằng đây là một cách tiếp cận ổn, vì vậy tôi đã giữ nó.

Giải trình:

                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

Bình thường , 36 35 byte

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

Liên kết kiểm tra

Chỉnh sửa: giải thích:

                                      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)

Võng mạc , 24 22 byte

2 byte nhờ Martin Ender.

Một câu trả lời 15 byte đã tồn tại, vì vậy đây chỉ là một cách tiếp cận khác có chi phí nhiều byte hơn.

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

Hãy thử trực tuyến!

Nó phân tách trên các không gian có số trước khác với tiến trình.

Đây là một minh chứng của cái nhìn.

05AB1E, 13 byte

¬svyÊi¶}yðJ?y

Giải thích

¬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

Nên làm việc cho bất kỳ danh sách.
Đã thử nghiệm trên int và char.

Dùng thử trực tuyến

Swift, 43 byte

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

Giả sử i là một mảng các đối tượng tương đương; hoạt động cho mọi thứ từ ints đến chuỗi đến các đối tượng tùy chỉnh. Kiểu táo tợn ở chỗ đầu ra chứa nhiều dòng mới, nhưng làm cho đẹp hơn sẽ tốn byte.

Phiên bản đẹp hơn, chưa được chỉnh sửa:

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
}

Phiên bản này in mỗi nhóm trên một dòng mới với chi phí nhiều mã hơn.

Ý tưởng để cải thiện

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

Phiên bản này có 47 byte, nhưng đó là một cách tiếp cận khác, vì vậy có lẽ có gì để tối ưu hóa ở đó không? Vấn đề lớn nhất là tuyên bố trở lại.

C, 88 77 byte

Di chuyển strmcmp bên trong printf tiết kiệm 11 byte

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

Sử dụng:

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

Đầu vào mẫu:

(tham số dòng lệnh)

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

Đầu ra mẫu:

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

Đã thử nghiệm trên:

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

Tôi đang cố gắng khắc phục lỗi Segmetation 5.3.0.

Phiên bản 88

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

Java 134 byte

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

lặp đi lặp lại và quyết định phân tách bằng một dòng mới hoặc khoảng trắng.

ListSharp , 134 byte

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 không hỗ trợ các chức năng để mảng được lưu trong tệp cục bộ có tên l.txt

Ruby , 24 byte

Trong Arraytrường hợp ruby có phương thức tích hợp sẵngroup_by

Vì vậy, giải pháp sẽ là:

a.group_by{|x| x}.values

TSQL, 132 byte

Điều này hơi khác so với các câu trả lời khác - sql không có mảng, đầu vào rõ ràng cho sql là một bảng.

Chơi gôn

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)

Ung dung:

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)

Vĩ cầm

Perl 5 - 39 byte

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

Pyke, 2 byte (không cạnh tranh)

Chỉ hỗ trợ số nguyên

$f

Hãy thử nó ở đây!

split_at(input, delta(input))

Đã thêm nút split_at, chia nhỏ đầu vào khi đối số thứ 2 là đúng

sed, 33 23 + 1 = 24 byte

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

Nó cần -rtùy chọn.

Ví dụ sử dụng:

$ 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

JavaScript (ES6), 56

Đầu vào: mảng số hoặc chuỗi

Đầu ra: mảng của mảng

Lần đầu tiên sử dụng so sánh chính xác trong mã golf

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

Clojure, 19 byte

#(partition-by + %)

Nó được tích hợp sẵn, nhưng nó có chức năng ánh xạ. Trong trường hợp này, +phục vụ như là một chức năng nhận dạng.

Javascript (sử dụng thư viện bên ngoài) (178 byte)

(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:[]})

Tuyên bố miễn trừ trách nhiệm: Tôi đang sử dụng một thư viện mà tôi đã viết để triển khai LINQ từ C # vào JS. Nó không chính xác giúp tôi giành chiến thắng nhưng oh tốt