Tôi có một danh sách các chữ số thập phân:

4, 4, 4, 7, 7, 9, 9, 9, 9, 2, 2, 2, 4, 4

Danh sách các chữ số thập phân được gọi là các mục. Chúng ta có thể tạo thành "khối" từ các mục này bằng cách nhóm các số giống nhau và liền kề nhau. Tôi muốn gán cho mỗi khối một số duy nhất, bắt đầu từ 1 và tăng 1 theo thứ tự các khối xuất hiện trong danh sách ban đầu. Vì vậy, đầu ra cho ví dụ đã cho sẽ như thế này:

1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5

định dạng đầu vào

Một danh sách các chữ số. (0-9) Bạn có thể sử dụng ngôn ngữ tích hợp để đọc danh sách này theo cách bạn muốn. Mã hóa: ASCII

Định dạng đầu ra

Một dãy số thập phân, được phân tách bằng dấu phân cách. Chương trình của bạn phải luôn luôn sử dụng cùng một dấu phân cách. Dấu phân cách phải dài hơn 0 bit. Mã hóa: ASCII

Tiêu chuẩn áp dụng.

Python 3,8 (tiền phát hành) , 41 byte

lambda l,n=0:[n:=n+(l!=(l:=x))for x in l]

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

Ca ngợi những con hải mã ma thuật :=của các biểu thức chuyển nhượng.

Python 2 , 42 byte

n=0
for x in input():n+=x!=id;id=x;print n

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

Python 2 , 44 byte

l=input()
n=0
for i in l:n+=i!=l;l=i;print n

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

APL (dzaima / APL) , 7 byte ^SBCS

Chức năng tiền tố ẩn danh. In ngăn cách không gian.

+\1,2≠/

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

2≠/ bất bình đẳng cặp

1, trả trước 1

+\ Tổng tích lũy

Thạch , 6 5 byte

ŒɠµJx

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

Đã lưu một byte nhờ UnrelatedString !

Đầu vào và đầu ra dưới dạng mảng (với dấu ngoặc mở / đóng)

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

ŒɠµJx - Main link, takes one argument:                       [7, 7, 5, 5, 5, 1]
Œɠ    - Get the lengths of consecutive elements:             [2, 3, 1]
  µ   - Call these lengths A
   J  - range(length(A))                                     [1, 2, 3]
    x - Repeat each element by the corresponding value in A: [1, 1, 2, 2, 2, 3]

Ngôn ngữ Wolfram (Mathicala) , 29 byte

Join@@(i=1;0#+i++&/@Split@#)&

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

05AB1E , 5 byte

¥Ā.¥>

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

Haskell , 40 byte

f(a:t)=1:map(+sum[1|a/=t!!0])(f t)
f e=e

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

Perl 6 , 21 byte

{+<<[\+] $,|$_ Zne$_}

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

Khối mã ẩn danh nhận danh sách và trả về danh sách. Điều này hoạt động bằng cách so sánh xem mỗi cặp phần tử liền kề không bằng nhau, hơn là lấy tổng tích lũy của danh sách.

05AB1E , 4 byte

γdƶ˜

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

γ       # group adjacent equal digits together
 d      # replace all digits with 1
  ƶ     # multiply each group by its 1-based index
   ˜    # flatten

R , 33 byte

function(x)cumsum(c(1,!!diff(x)))

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

Sử dụng phương pháp tổng tích lũy tương tự như Luis Mendo và các phương pháp khác.

MATL , 8 byte

Y'wn:wY"

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

Giải trình:

    Y'      % run-length encoding
    w       % swap elements in stack
    n       % number of elements in array / size along each dimension
    :       % range; vector of equally spaced values
    w       % swap elements in stack
    Y"      % replicate elements of array
            % (implicit) convert to string and display

Thạch , 4 byte

ŒgƤẈ

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

Làm sao?

ŒgƤẈ - Link: list of integers  e.g. [7,7,2,7,7]
  Ƥ  - for prefixes:     [7]   [7,7]   [7,7,2]      [7,7,2,7]        [7,7,2,7,7]
Œg   -   group runs      [[7]] [[7,7]] [[7,7],[2]]  [[7,7],[2],[7]]  [[7,7],[2],[7,7]]
   Ẉ - length of each    [1,   1,      2,           3,               3]

Octave / MATLAB, 25 byte

@(x)cumsum([1 ~~diff(x)])

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

Haskell , 46 43 byte

scanl(+)1.map fromEnum.(zipWith(/=)=<<tail)

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

Hàm ẩn danh ẩn danh có danh sách và trả về danh sách

J , 12 byte

1+/\@,2~:/\]

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

Tương tự như câu trả lời APL của Adám

      2~:/\]  - pair-wise inequality
1    ,        - prepend 1
    @         - and   
+/\           - find the cumulative sum

Perl 5 , 27 byte

s/\d/$i+=$&!=$p;$p=$&;$i/ge

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

Tùy chọn dòng lệnh -plàm cho perl đọc dòng đầu vào từ STDIN vào "biến mặc định" $_. Sau đó, nó tìm kiếm - thay thế tất cả các chữ số trong $_bộ đếm $i. Và $iđược tăng cho mỗi chữ số khác với chữ số trước đó, nó cũng ở chữ số đầu tiên để bộ đếm bắt đầu 1. Các chữ số trước được lưu trữ trong $p.

Bình thường , 13 11 byte

s.e*]hkhbr8

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

         r8  # Run-length encode (implicit argument is the input) (-> [[frequency, char], ...]
 .e          # Enumerated map (current element is b, index is k) over rQ8
   *]hk      # [ k+1 ] *
       hb    #           b[0]
s            # Reduce list on + ([a]+[b] = [a,b])

-2 byte nhờ ông Xcoder

Scala , 75 byte

s=>s.scanLeft(("",0))((x,y)=>(y,x._2+(if(x._1!=y)1 else 0))).tail.map(_._2)

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

Nếu đầu vào và đầu ra phải được phân tách bằng dấu phẩy Chuỗi (và không phải Danh sách) thì 102 byte.

s=>s.split(", ").scanLeft(("",0))((x,y)=>(y,x._2+(if(x._1!=y)1 else 0))).tail.map(_._2).mkString(", ")

Thạch , 5 byte

nƝÄŻ‘

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

Ban đầu, tôi nhắm đến 4 -terter (cùng một chương trình nhưng không có Ż) nhưng sau đó nhanh chóng nhận ra rằng 1 phải được chuẩn bị trước mỗi lần do bị giám sát ... Mặc dù có một 5 -terter khác trong Jelly, tôi sẽ thực sự giữ điều này bởi vì nó sử dụng một phương pháp khác

Đối với mỗi cặp mục lân cận của danh sách đầu vào $L$, kiểm tra nếu $L_i\ne L_{i+1}, \forall 1\le i<|L|$và lưu các kết quả này trong một danh sách. Sau đó lấy tổng số tích lũy của danh sách này và tăng chúng lên 1 để phù hợp với hệ thống lập chỉ mục khối. TL; DR. Bất cứ khi nào chúng tôi gặp các mục lân cận khác nhau, chúng tôi sẽ tăng chỉ số chunk lên 1 .

JavaScript (ES6), 30 byte

Đưa đầu vào như một mảng các số nguyên.

a=>a.map(p=n=>i+=p!=(p=n),i=0)

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

Đã bình luận

a =>                // a[] = input array
  a.map(p =         // initialize p to a non-numeric value
  n =>              // for each value n in a[]:
    i +=            //   increment i if:
      p != (p = n), //     p is not equal to n; and update p to n
    i = 0           //   start with i = 0 (chunk counter)
  )                 // end of map()

PHP , 52 byte

while(''<$d=$argv[++$x])echo$i+=$argv[$x-1]!=$d,' ';

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

Nhập qua dòng lệnh, đầu ra STDOUT.

Thx đến @ Night2 cho '0' == 0lỗi so sánh pesky !

Julia 1.0 , 56 byte

l->foldl(l,init=(0,0))do(p,i),c
println(i+=p!=c)
c,i
end

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

Japt v2.0a0, 9 byte

£T±A¦(A=X

Thử nó

Thêm ++ , 23 byte

D,f,@*,BGd€bL$bLRz€¦XBF

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

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

D,f,@*,     - Define a function, f, that takes one argument:  [7 7 5 5 5 1]
       BG   - Group neighbouring elements together:           [[[7 7] [5 5 5] [1]]]          
       d    - Duplicate:                                      [[[7 7] [5 5 5] [1]] [[7 7] [5 5 5] [1]]]
       €bL  - Get the length of each:                         [[[7 7] [5 5 5] [1]] [2 3 1]]
       $bLR - Length, then range of length:                   [[2 3 1] [1 2 3]]
       z    - Zip together:                                   [[2 1] [3 2] [1 3]]
       €¦X  - Reduce each by repetition:                      [[1 1] [2 2 2] [3]]
       BF   - Flatten:                                        [1 1 2 2 2 3]
            - Due to the * in the function definition,
                 return the whole stack:                      [1 1 2 2 2 3]

Japt , 8 7 byte

ä¦Ug)åÄ

Thử nó

Võng mạc 0.8.2 , 34 byte

\b\d+\b(?<=(\b(\3|(\d+))\D*)*)
$#3

Hãy thử trực tuyến! Giải trình:

\b\d+\b

Ghép từng số lần lượt.

(?<=(...)*)

Bắt đầu nhìn về phía sau để có càng nhiều trận đấu càng tốt. (Các mục tiếp theo sẽ theo thứ tự từ phải sang trái vì đó là cách hoạt động của lookbehind.)

\D*

Bỏ qua các dải phân cách.

(\3|(\d+))

Cố gắng khớp số tương tự như lần trước, nhưng không thành công, chỉ khớp bất kỳ số nào, nhưng hãy nhớ rằng chúng ta phải khớp với một số mới.

\b

Đảm bảo toàn bộ số được khớp.

$#3

Đếm số lượng số mới.

Stax , 10 byte

▓ª2ªmD?Ä╧╖

Chạy và gỡ lỗi nó

Đầu ra sử dụng không gian như một dấu phân cách. Đầu vào tuân theo các thông số kỹ thuật chính xác bằng cách sử dụng dấu phẩy làm dấu phân cách và hiện bao quanh dấu ngoặc.

C (gcc) , 62 61 byte

Đây là một trong số ít mục tôi đã thực hiện khi một chương trình hoàn chỉnh ngắn hơn chức năng gửi!

Ở lượt đi đầu tiên, tôi không quan tâm đến giá trị trước đó, vì vậy tôi dựa vào thực tế đó argvlà một con trỏ đến một nơi nào đó và cực kỳ khó có thể nằm trong khoảng [0..9]!

s;main(i,j){for(;~scanf("%d,",&i);j=i)printf("%d ",s+=j!=i);}

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

Scala , 114 byte

s.split(", ").zipWithIndex.scan(s.head,0){(a,b)=>if(a._1==b._1)a else b._1->(a._2+1)}.tail.unzip._2.mkString(", ")

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

C (gcc) , 62 byte

f(_,l)int*_;{printf("%d ",l=--l?f(_,l)+(_[l]!=_[l-1]):1);_=l;}

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

Một hàm lấy danh sách và độ dài của nó làm đối số.

f(_,l)int*_;{_=printf("%*d",--l?f(_,l)+(_[l]!=_[l-1]):2,0);}

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

Đầu ra trong unary, giới hạn bởi 0s