Dengan diberikan daftar bilangan bulat yang benar-benar positif, telusuri setiap angka berbeda dan gantilah semua kemunculannya dengan indeks berurutan (nol atau satu berdasarkan) dari seri baru.

Contohnya

[]→ []/[]

[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-diindeks.

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

Cobalah online!

Berkomentar

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)

Cobalah online!

Penjelasan:

ave(x,x,FUN=seq)membagi vektor xmenjadi sub-vektor menggunakan nilai-nilai xsebagai kunci pengelompokan. Kemudian seqfungsi dipanggil untuk masing-masing kelompok dan setiap hasil diatur kembali ke posisi kelompok semula.

Lebih baik lihat contoh:

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

Catatan :

seq(y)fungsi mengembalikan urutan 1:length(y)jika ymemiliki length(y) > 1, tetapi mengembalikan urutan dari 1:y[1]jika yhanya mengandung satu elemen.
Untungnya ini bukan masalah karena dalam kasus itu R - mengeluh dengan banyak peringatan - hanya memilih nilai pertama yang kebetulan yang kita inginkan :)

MATL , 4 byte

&=Rs

Solusi ini berbasis 1

Cobalah di MATL Online !

Penjelasan

Gunakan [1,2,3,2]sebagai contoh

    # 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

Banyak, banyak terima kasih kepada H.PWiz, Adám dan dzaima atas semua bantuan mereka dalam debugging dan memperbaiki ini.

+/¨⊢=,\

Cobalah online!

Penjelasan

Versi 10-byte non-diam-diam akan lebih mudah dijelaskan terlebih dahulu

{+/¨⍵=,\⍵}

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

Versi diam-diam melakukan tiga hal

• Pertama, ia menghapus instance dari ⍵digunakan dalam ,\⍵sebagai ,\di sebelah kanan dengan sendirinya dapat secara implisit mengetahui bahwa itu seharusnya beroperasi pada argumen yang benar.
• Kedua, untuk ⍵=, kita ganti ⍵dengan ⊢, yang merupakan argumen yang benar
• Ketiga, sekarang kami tidak memiliki argumen eksplisit (dalam hal ini, ⍵), kami dapat menghapus kurung kurawal {}karena fungsi tacit tidak menggunakannya

AWK , 14

• 1 byte disimpan berkat @NahuelFouilleul

{print++a[$1]}

Cobalah online!

Di atas melakukan pengindeksan satu berbasis. Jika Anda lebih suka pengindeksan berbasis nol, ini merupakan byte tambahan:

{print a[$1]++}

Cobalah online!

J , 7 byte

1#.]=]\

Cobalah online!

1-diindeks.

Penjelasan:

]\ 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 terima kasih kepada ngn!

{+/'x=,\x}

Cobalah online!

Python 2 , 48 byte

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

Cobalah online!

05AB1E , 4 byte

ηε¤¢

Cobalah online! atau sebagai Test Suite

Penjelasan

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

C # (Visual C # Interactive Compiler) , 44 byte

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

Cobalah online!

Python 2 , 47 43 byte

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

Cobalah online!

Solusi 'berbasis satu' rekursif.

Jelly , 4 byte

ċṪ$Ƥ

Cobalah online!

Untuk setiap awalan daftar input, ia menghitung jumlah kemunculan elemen terakhir itu sendiri.

R , 41 byte

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

Cobalah online!

Anehnya, mengembalikan indeks berbasis nol lebih pendek di R.

Ruby, 35 byte

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

Sayangnya ini cukup biasa - membangun hash yang menyimpan total untuk setiap entri yang ditemukan sejauh ini.

Beberapa opsi lain yang menyenangkan yang sayangnya tidak cukup pendek:

->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 terima kasih kepada Giuseppe, dengan menghapus yang mana, dan tabel, dan hanya sedikit perubahan pada implementasi

Asli

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

Saya tidak bisa bersaing dengan pengetahuan Giuseppe, jadi pengajuan saya agak lebih lama dari pengetahuannya, tetapi menggunakan pengetahuan dasar saya, saya merasa bahwa solusi ini agak cerdik.

r<-table(x) menghitung berapa kali setiap angka muncul dan menyimpannya dalam r, untuk referensi di masa mendatang

names() mendapatkan nilai dari setiap entri unik dalam tabel, dan kami mengulangi nama-nama ini dengan for for.

Bagian yang tersisa memeriksa entri mana yang sama dengan iterasi dan menyimpan urutan nilai (dari 1 hingga jumlah entri iterasi)

Cobalah online!

Haskell , 44 byte

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

Cobalah online!

Penjelasan

Melintasi daftar dari kiri ke kanan dengan menjaga daftar xelemen yang dikunjungi, awalnya []:

Untuk setiap pertemuan yhitungan semua elemen sama dalam daftar x.

Perl 6 , 15 byte

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

Cobalah online!

Anda dapat memindahkan ++ke sebelum %untuk indeks berbasis satu.

Penjelasan:

*>>.&{        }  # 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

Cobalah online!

Pendekatan yang berbeda dari jawaban BMO yang ternyata sedikit lebih lama. (Dan silakan meminjam baju tes bagus mereka.)

Idenya adalah untuk beralih pada daftar input dan melacak berapa kali setiap elemen terjadi dengan memperbarui fungsi g. Tidak Disatukan:

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

Dua peluang golf yang menarik muncul. Pertama untuk nilai awal g, fungsi konstan yang mengabaikan argumennya dan mengembalikan 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

Dan yang kedua ekspresi atas variabel xdan yyang menghasilkan 1jika xsama ydan 0sebaliknya:

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!

Mungkin masih ada cara yang lebih pendek. Adakah yang punya ide?

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

Cobalah online!

Kredit

• -2 byte terima kasih kepada Kevin Cruijssen

Ruby , 34 byte

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

Cobalah online!

bash, 37 24 byte

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

TIO

jika valid, ada juga variasi ini, seperti yang disarankan oleh DigitalTrauma

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

TIO

Perl 5, 11 byte

$_=$h{$_}++

TIO

penjelasan komentar berikut

• $_variabel khusus perl yang berisi garis saat ini saat perulangan input ( -patau -nswitch)
• $h{$_}++Autovivifies peta %hdan membuat entri dengan kunci $_dan kenaikan dan memberikan nilai sebelum kenaikan
• variabel khusus dicetak karena -psakelar, -lsakelar menghilangkan ujung saluran pada input dan menambahkan ujung saluran pada keluaran

Pari / GP , 32 byte

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

$k$$x^{a_k}$$\sum_{i=1}^kx^{a_i}$

Cobalah online!

Bahasa Wolfram (Mathematica) , 33 byte

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

$k$$x^{a_k}$$\sum_{i=1}^kx^{a_i}$

Cobalah online!

Attache , 23 byte

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

Cobalah online!

Penjelasan

{`~&>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]);}

Cobalah online!

-2 byte berkat ASCII saja

Ini terasa terlalu mudah, tetapi sepertinya saya tidak bisa lebih pendek dengan pendekatan yang berbeda.

K (ngn / k) , 18 byte

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

Cobalah online!

PENDEKATAN TUA

K (ngn / k) , 27 23 22 byte

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

Cobalah online!

ini tidak cukup ... solusi cepat dan kotor, saya akan memperbaiki ini nanti ketika saya mendapat kesempatan untuk memikirkan pendekatan yang lebih baik

penjelasan:

• =xmengembalikan dict di mana kunci adalah item x dan nilainya adalah indeks mereka ( 3 1 4 5 9 2 6!(0 9;1 3;,2;4 8 10;5 11;,6;,7))
• i: tetapkan dict ke i
• #:'menghitung nilai untuk setiap tombol ( 3 1 4 5 9 2 6!2 2 1 3 2 1 1)
• !:'sebutkan setiap nilai ( 3 1 4 5 9 2 6!(0 1;0 1;,0;0 1 2;0 1;,0;,0))
• ,/.:ekstrak nilai dan ratakan daftar ( 0 1 0 1 0 0 1 2 0 1 0 0)
• x[,/.:i]: ekstrak indeks dari i, ratakan, dan tetapkan setiap nilai dari daftar sisi kanan pada indeks ini

mengganggu, daftar diperbarui tetapi nilai nol dikembalikan oleh tugas, jadi saya harus mengembalikan daftar setelah tanda titik koma ( ;x)

sunting: menghapus titik dua yang tidak berhubungan

edit2: menghapus tugas yang tidak perlu

Retina 0.8.2 , 30 byte

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

Cobalah online! Tautan termasuk kasus uji. 1-diindeks. Penjelasan: Bagian pertama dari regex cocok dengan masing-masing bilangan bulat dalam daftar pada gilirannya. Grup lookbehind mencocokkan setiap kemunculan integer pada baris tersebut hingga dan termasuk integer saat ini. Bilangan bulat kemudian diganti dengan jumlah kecocokan.

Batch, 61 byte

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

1-diindeks. Karena substitusi variabel terjadi sebelum parsing, set/aperintah akhirnya menambah nama variabel yang diberikan dengan menggabungkan huruf cdengan integer dari daftar (variabel numerik default ke nol dalam Batch). Hasilnya kemudian disalin ke integer lain untuk kemudahan output (lebih tepatnya, menghemat satu byte).

Tcl , 48 byte

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

Cobalah online!

Japt, 8 byte

£¯YÄ è¶X

Coba di sini

£¯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