Đưa ra một danh sách các số nguyên dương, đi qua từng số riêng biệt và thay thế tất cả các lần xuất hiện của nó bằng các chỉ số liên tiếp (không hoặc một dựa trên) của một chuỗi mới.

Ví dụ

[]→ []/[]

[42]→ [0]/[1]

[7,7,7]→ [0,1,2]/[1,2,3]

[10,20,30]→ [0,0,0]/[1,1,1]

[5,12,10,12,12,10]→ [0,0,0,1,2,1]/[1,1,1,2,3,2]

[2,7,1,8,2,8,1,8,2,8]→ [0,0,0,0,1,1,1,2,2,3]/[1,1,1,1,2,2,2,3,3,4]

[3,1,4,1,5,9,2,6,5,3,5,9]→ [0,0,0,1,0,0,0,0,1,1,2,1]/[1,1,1,2,1,1,1,1,2,2,3,2]

JavaScript (ES6), 26 byte

1 chỉ mục.

a=>a.map(o=x=>o[x]=-~o[x])

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

Đã bình luận

a =>                // a[] = input array
  a.map(o =         // assign the callback function of map() to the variable o, so that
                    // we have an object that can be used to store the counters
    x =>            // for each value x in a[]:
      o[x] = -~o[x] //   increment o[x] and yield the result
                    //   the '-~' syntax allows to go from undefined to 1
  )                 // end of map()

R , 27 byte

function(x)ave(x,x,FUN=seq)

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

Giải trình :

ave(x,x,FUN=seq)chia vectơ xthành các vectơ phụ bằng cách sử dụng các giá trị xnhư các khóa nhóm. Sau đó, seqhàm được gọi cho mỗi nhóm và mỗi kết quả được sắp xếp lại ở vị trí nhóm ban đầu.

Xem tốt hơn một ví dụ:

x <- c(5,7,5,5,7,6)
ave(x, x, FUN=seq) # returns 1,1,2,3,2


 ┌───┬───┬───┬───┬───┐
 │ 5 │ 7 │ 5 │ 5 │ 7 │
 └───┴───┴───┴───┴───┘            
   |   |   |    |  |     
   ▼   |   ▼    ▼  |
 GROUP A : seq(c(5,5,5)) = c(1,2,3)
   |   |   |    |  |     
   ▼   |   ▼    ▼  |
 ┌───┐ | ┌───┬───┐ |
 │ 1 │ | │ 2 │ 3 │ |
 └───┘ | └───┴───┘ |
       ▼           ▼
 GROUP B : seq(c(7,7)) = c(1,2)
       |           |
       ▼           ▼
     ┌───┐       ┌───┐
     │ 1 │       │ 2 │
     └───┘       └───┘ 

   |   |   |   |   |
   ▼   ▼   ▼   ▼   ▼ 
 ┌───┬───┬───┬───┬───┐
 │ 1 │ 1 │ 2 │ 3 │ 2 │
 └───┴───┴───┴───┴───┘  

Chú thích :

seq(y)Hàm trả về một chuỗi 1:length(y)trong trường hợp ycó length(y) > 1, nhưng trả về một chuỗi từ 1:y[1]nếu ychỉ chứa một phần tử.
Điều này may mắn không phải là một vấn đề bởi vì trong trường hợp đó R - phàn nàn với rất nhiều cảnh báo - chỉ chọn giá trị đầu tiên là ngẫu nhiên những gì chúng ta muốn :)

MATL , 4 byte

&=Rs

Giải pháp này dựa trên 1

Dùng thử tại MATL Online !

Giải trình

Sử dụng [1,2,3,2]làm ví dụ

    # Implicitly grab the input array of length N
    #
    #   [1,2,3,2]
    #
&=  # Create an N x N boolean matrix by performing an element-wise comparison
    # between the original array and its transpose:
    #
    #     1 2 3 2
    #     -------
    # 1 | 1 0 0 0
    # 2 | 0 1 0 1
    # 3 | 0 0 1 0
    # 2 | 0 1 0 1
    #
R   # Take the upper-triangular portion of this matrix (sets below-diagonal to 0)
    #
    #   [1 0 0 0
    #    0 1 0 1
    #    0 0 1 0
    #    0 0 0 1]
    #
s   # Compute the sum down the columns
    #
    #   [1,1,1,2]
    #
    # Implicitly display the result

APL (Dyalog Unicode) , 7 byte

Rất, rất cám ơn H.PWiz, Adám và dzaima vì tất cả sự giúp đỡ của họ trong việc gỡ lỗi và sửa lỗi này.

+/¨⊢=,\

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

Giải trình

Phiên bản không ngầm 10 byte sẽ dễ giải thích trước

{+/¨⍵=,\⍵}

{         } A user-defined function, a dfn
      ,\⍵  The list of prefixes of our input list ⍵
           (⍵ more generally means the right argument of a dfn)
           \ is 'scan' which both gives us our prefixes 
           and applies ,/ over each prefix, which keeps each prefix as-is
    ⍵=     Checks each element of ⍵ against its corresponding prefix
           This checks each prefix for occurrences of the last element of that prefix
           This gives us several lists of 0s and 1s
 +/¨       This sums over each list of 0s and 1s to give us the enumeration we are looking for

Phiên bản ngầm làm ba điều

• Đầu tiên, nó loại bỏ thể hiện ⍵được sử dụng ,\⍵như ,\bên phải, có thể ngầm hiểu rằng nó phải hoạt động theo đúng đối số.
• Thứ hai, vì ⍵=, chúng tôi thay thế ⍵bằng ⊢, viết tắt của đối số đúng
• Thứ ba, bây giờ chúng tôi không có đối số rõ ràng (trong trường hợp này, ⍵ ), chúng ta có thể loại bỏ dấu ngoặc nhọn {}vì các hàm ngầm không sử dụng chúng

AWK , 14

• Lưu 1 byte nhờ @NahuelFouilleul

{print++a[$1]}

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

Ở trên không lập chỉ mục một dựa trên. Nếu bạn thích lập chỉ mục dựa trên zero, thì đó là một byte bổ sung:

{print a[$1]++}

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

J , 7 byte

1#.]=]\

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

1 chỉ mục.

Giải trình:

]\ all the prefixes (filled with zeros, but there won't be any 0s in the input):
   ]\ 5 12 10 12 12 10
5  0  0  0  0  0
5 12  0  0  0  0
5 12 10  0  0  0
5 12 10 12  0  0
5 12 10 12 12  0
5 12 10 12 12 10

]= is each number from the input equal to the prefix:
   (]=]\) 5 12 10 12 12 10
1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 1 0 1 0 0
0 1 0 1 1 0
0 0 1 0 0 1

1#. sum each row:
   (1#.]=]\) 5 12 10 12 12 10
1 1 1 2 3 2

K (oK) , 11 10 byte

-1 byte nhờ ngn!

{+/'x=,\x}

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

Python 2 , 48 byte

lambda a:[a[:i].count(v)for i,v in enumerate(a)]

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

05AB1E , 4 byte

ηε¤¢

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

ηε     # apply to each prefix of the input list
  ¤¢   # count occurrences of the last element

C # (Trình biên dịch tương tác Visual C #) , 44 byte

x=>x.Select((y,i)=>x.Take(i).Count(z=>z==y))

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

Python 2 , 47 43 byte

f=lambda a:a and f(a[:-1])+[a.count(a[-1])]

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

Một giải pháp "một dựa trên đệ quy".

Thạch , 4 byte

ċṪ$Ƥ

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

Đối với mỗi tiền tố của danh sách đầu vào, nó sẽ đếm số lần xuất hiện của phần tử cuối cùng của chính nó.

R , 41 byte

function(x)diag(diffinv(outer(x,x,"==")))

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

Điều kỳ lạ là, việc trả về một chỉ số dựa trên zero sẽ ngắn hơn trong R.

Ruby, 35 byte

->a{f=Hash.new 0;a.map{|v|f[v]+=1}}

Thật không may, thật đáng tiếc - xây dựng một hàm băm lưu trữ tổng số cho mỗi mục nhập gặp phải cho đến nay.

Một số tùy chọn thú vị khác không may là khá ngắn:

->a{a.dup.map{a.count a.pop}.reverse}   # 37
->a{i=-1;a.map{|v|a[0..i+=1].count v}}  # 38

R , 62 43 byte

x=z=scan();for(i in x)z[y]=1:sum(y<-x==i);z

-19 byte nhờ Giuseppe, bằng cách loại bỏ cái nào và bảng và chỉ thay đổi một chút để thực hiện

Nguyên

x=z=scan();for(i in names(r<-table(x)))z[which(x==i)]=1:r[i];z

Tôi không thể cạnh tranh với kiến ​​thức của Giuseppe, vì vậy bài dự thi của tôi có phần dài hơn kiến ​​thức của anh ấy, nhưng sử dụng kiến ​​thức cơ bản của tôi, tôi cảm thấy rằng giải pháp này khá tài tình.

r<-table(x) đếm số lần mỗi số xuất hiện và lưu trữ trong r, để tham khảo trong tương lai

names() nhận các giá trị của từng mục duy nhất trong bảng và chúng tôi lặp lại các tên này bằng một vòng lặp for.

Phần còn lại kiểm tra mục nào bằng với số lần lặp và lưu một chuỗi các giá trị (từ 1 đến số lượng mục của lần lặp)

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

Haskell , 44 byte

([]#)
x#(y:z)=sum[1|a<-x,a==y]:(y:x)#z
_#e=e

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

Giải trình

Di chuyển danh sách từ trái sang phải giữ danh sách x các thành phần được truy cập, ban đầu []:

Đối với mỗi cuộc gặp gỡ của một ysố lượng tất cả các yếu tố bằng nhau trong danh sách x.

Perl 6 , 15 byte

*>>.&{%.{$_}++}

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

Bạn có thể di chuyển ++đến trước %một chỉ số dựa trên một.

Giải trình:

*>>.&{        }  # Map the input to
      %          # An anonymous hash
       .{$_}     # The current element indexed
            ++   # Incremented

Haskell , 47 46 byte

(#(*0))
(x:r)#g=g x:r# \y->0^(y-x)^2+g y
e#g=e

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

Một cách tiếp cận khác với câu trả lời của BMO mà lâu hơn một chút. (Và vui lòng mượn bộ đồ thử nghiệm đẹp của họ.)

Ý tưởng là lặp lại danh sách đầu vào và theo dõi số lần mỗi phần tử đã xảy ra bằng cách cập nhật một hàm g. Ung dung:

f (const 0)
f g (x:r) = g x : f (\ y -> if x==y then 1 + g y else g y) r
f g []    = []

Hai cơ hội chơi golf thú vị nảy sinh. Đầu tiên cho giá trị ban đầu của g, một hàm hằng mà bỏ qua đối số của nó và trả về 0:

const 0  -- the idiomatic way
(\_->0)  -- can be shorter if parenthesis are not needed
min 0    -- only works as inputs are guaranteed to be non-negative
(0*)     -- obvious in hindsight but took me a while to think of

Và thứ hai là một biểu thức trên các biến xvà ysẽ sinh ra 1nếu xbằng yvà 0khác:

if x==y then 1else 0  -- yes you don't need a space after the 1
fromEnum$x==y         -- works because Bool is an instance of Enum
sum[1|x==y]           -- uses that the sum of an empty list is zero
0^abs(x-y)            -- uses that 0^0=1 and 0^x=0 for any positive x
0^(x-y)^2             -- Thanks to  Christian Sievers!

Vẫn có thể có những cách ngắn hơn. Bất cứ ai cũng có một ý tưởng?

Java (JDK) , 76 byte

a->{for(int l=a.length,i,c;l-->0;a[l]=c)for(c=i=0;i<l;)c+=a[l]==a[i++]?1:0;}

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

Tín dụng

• -2 byte nhờ Kevin Cruijssen

Ruby , 34 byte

->a{r=[];a.map{|x|(r<<x).count x}}

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

bash, 37 24 byte

f()(for x;{ r+=$[a[x]++]\ ;};echo $r)

TIO

nếu hợp lệ, cũng có biến thể này, như được đề xuất bởi DigitalTrauma

for x;{ echo $[a[x]++];}

TIO

Perl 5, 11 byte

$_=$h{$_}++

TIO

giải thích sau bình luận

• $_ Biến đặc biệt của perl chứa dòng hiện tại khi lặp qua đầu vào (-p hoặc-n chuyển mạch)
• $h{$_}++ tự động hóa bản đồ %h và tạo một mục với khóa$_ và gia số và đưa ra giá trị trước khi tăng
• biến đặc biệt được in vì -pchuyển đổi, -lcông tắc loại bỏ đầu cuối của dòng trên đầu vào và thêm đầu cuối của dòng trên đầu ra

Pari / GP , 32 byte

a->p=0;[polcoeff(p+=x^t,t)|t<-a]

Các $k$phần tử thứ trong câu trả lời là hệ số của $x^{a_k}$ thuật ngữ trong đa thức $\sum_{i=1}^kx^{a_i}$.

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

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

Accumulate@#~Coefficient~#&[x^#]&

Các $k$phần tử thứ trong câu trả lời là hệ số của $x^{a_k}$ thuật ngữ trong đa thức $\sum_{i=1}^kx^{a_i}$.

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

Tùy viên , 23 byte

{`~&>Zip[_,_[0:#_::0]]}

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

Giải trình

{`~&>Zip[_,_[0:#_::0]]}
{                     }    _: input (e.g., [5, 12, 10, 12, 12, 10])
             0:#_          range from 0 to length of input (inclusive)
                           e.g., [0, 1, 2, 3, 4, 5, 6]
                 ::0       descending range down to 0 for each element
                           e.g., [[0], [1, 0], [2, 1, 0], [3, 2, 1, 0], [4, 3, 2, 1, 0], [5, 4, 3, 2, 1, 0], [6, 5, 4, 3, 2, 1, 0]]
           _[       ]      get input elements at those indices
                           e.g., [[5], [12, 5], [10, 12, 5], [12, 10, 12, 5], [12, 12, 10, 12, 5], [10, 12, 12, 10, 12, 5], [nil, 10, 12, 12, 10, 12, 5]]
     Zip[_,          ]     concatenate each value with this array
                           e.g., [[5, [5]], [12, [12, 5]], [10, [10, 12, 5]], [12, [12, 10, 12, 5]], [12, [12, 12, 10, 12, 5]], [10, [10, 12, 12, 10, 12, 5]]]
   &>                      using each sub-array spread as arguments...
 `~                            count frequency
                               e.g. [12, [12, 10, 12, 5]] = 12 ~ [12, 10, 12, 5] = 2

C (gcc) , 65 62 byte

c,d;f(a,b)int*a;{for(;c=d=b--;a[b]=d)for(;c--;d-=a[c]!=a[b]);}

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

-2 byte chỉ nhờ ASCII

Điều này cảm thấy quá đơn giản, nhưng tôi dường như không thể rút ngắn hơn bằng một cách tiếp cận khác.

K (ngn / k) , 18 byte

(,/.!'#'=x)@<,/.=x

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

TIẾP CẬN

K (ngn / k) , 27 23 22 byte

{x[,/.=x]:,/.!'#'=x;x}

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

Đây không phải là ... giải pháp nhanh và bẩn, tôi sẽ tinh chỉnh nó sau này khi tôi có cơ hội nghĩ ra một cách tiếp cận tốt hơn

giải trình:

• =xtrả về một dict trong đó các khóa là các mục của x và các giá trị là các chỉ số của chúng ( 3 1 4 5 9 2 6!(0 9;1 3;,2;4 8 10;5 11;,6;,7))
• i: gán dict cho i
• #:'đếm giá trị cho mỗi khóa ( 3 1 4 5 9 2 6!2 2 1 3 2 1 1)
• !:'liệt kê từng giá trị ( 3 1 4 5 9 2 6!(0 1;0 1;,0;0 1 2;0 1;,0;,0))
• ,/.:trích xuất các giá trị và danh sách làm phẳng ( 0 1 0 1 0 0 1 2 0 1 0 0)
• x[,/.:i]: trích xuất các chỉ mục từ i, làm phẳng và gán từng giá trị từ danh sách bên phải tại các chỉ mục này

thật khó chịu, danh sách được cập nhật nhưng giá trị null được trả về bởi phép gán, vì vậy tôi cần trả về danh sách sau dấu chấm phẩy ( ;x)

chỉnh sửa: loại bỏ dấu hai chấm

chỉnh sửa2: loại bỏ nhiệm vụ không cần thiết

Võng mạc 0.8.2 , 30 byte

\b(\d+)\b(?<=(\b\1\b.*?)+)
$#2

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. 1 chỉ mục. Giải thích: Phần đầu tiên của regex khớp với từng số nguyên trong danh sách. Nhóm của lookbehind khớp với từng lần xuất hiện của số nguyên đó trên dòng đó lên đến và bao gồm cả số nguyên hiện tại. Số nguyên sau đó được thay thế bằng số lượng khớp.

Mẻ, 61 byte

@setlocal
@for %%n in (%*)do @set/ac=c%%n+=1&call echo %%c%%

1 chỉ mục. Bởi vì thay thế biến xảy ra trước khi phân tích cú pháp, set/alệnh kết thúc tăng tên biến được đưa ra bằng cách ghép chữ cái cvới số nguyên từ danh sách (biến số mặc định thành 0 trong Batch). Kết quả sau đó được sao chép sang một số nguyên khác để dễ dàng xuất ra (chính xác hơn, nó tiết kiệm một byte).

Tcl , 48 byte

proc C L {lmap n $L {dict g [dict inc D $n] $n}}

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

Japt, 8 byte

£¯YÄ è¶X

Hãy thử nó ở đây

£¯YÄ è¶X
             :Implicit input of array U
£            :Map each X at 0-based index Y
 ¯           :  Slice U to index
  YÄ         :    Y+1
     è       :  Count the elements
      ¶X     :    Equal to X