JavaScript (ES6), 26 bytes

1-indexed.

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

Try it online!

Commented

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()

MATL, 4 bytes

&=Rs

This solution is 1-based

Try it out at MATL Online!

Explanation

Uses [1,2,3,2] as an example

    # 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 bytes

Many, many thanks to H.PWiz, Adám and dzaima for all their help in debugging and correcting this.

+/¨⊢=,

Try it online!

Explanation

The 10-byte non-tacit version will be easier to explain first

{+/¨⍵=,⍵}



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

The tacit version does three things

• First, it removes the instance of ⍵ used in ,⍵ as , on the right by itself can implicitly figure out that it's supposed to operate on the right argument.


• Second, for ⍵=, we replace the ⍵ with ⊢, which stands for right argument


• Third, now that we have no explicit arguments (in this case, ⍵), we can remove the braces {} as tacit functions do not use them

J, 7 bytes

1#.]=]

Try it online!

1-indexed.

Explanation:

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

{+/'x=',x}

Try it online!

Python 2, 48 bytes

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

Try it online!

05AB1E, 4 bytes

ηε¤¢

Try it online!
or as a Test Suite

Explanation

ηε     # apply to each prefix of the input list

  ¤¢   # count occurrences of the last element

AWK, 15

{print a[$1]++}

Try it online!

The above does zero-based indexing. If you prefer one-based indexing, its a simple change:

{print ++a[$1]}

Try it online!

Python 2, 47 43 bytes

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

Try it online!

A recursive 'one-based' solution.

Jelly, 4 bytes

ċṪ$Ƥ

Try it online!

For each prefix of the input list, it counts the number of occurrences of its last element in itself.

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

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

Try it online!

Ruby, 35 bytes

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

It's pretty mundane, unfortunately - build a hash that stores the total for each entry encountered so far.

Some other, fun options that unfortunately weren't quite short enough:

->a{a.dup.map{a.count a.pop}.reverse}   # 37

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

Perl 6, 15 bytes

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

Try it online!

You can move the ++ to before the % for a one based index.

Explanation:

*>>.&{        }  # Map the input to

      %          # An anonymous hash

       .{$_}     # The current element indexed

            ++   # Incremented

R, 41 bytes

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

Try it online!

Oddly, returning a zero-based index is shorter in R.

Java (JDK), 76 bytes

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

Try it online!

Credits

• -2 bytes thanks to Kevin Cruijssen
  

R, 62 43 bytes

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

-19 bytes thanks to Giuseppe, by removing which, and table, and only slight changes to the implementation

Original

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

I can't compete with Giuseppe's knowledge, so my submission is somewhat longer than his, but using my basic knowledge, I felt that this solution was rather ingenious.

r<-table(x) counts the number of times each number appears and stores it in r, for future reference

names() gets the values of each unique entry in the table, and we iterate over these names with a for loop.

The remaining portion checks which entries are equal to the iterations and stores a sequence of values (from 1 to the number of entries of the iteration)

Try it online!

Ruby, 34 bytes

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

Try it online!

bash, 37 bytes or 24 bytes

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

TIO

if valid, there is also this variation, as suggested by DigitalTrauma

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

TIO

Retina 0.8.2, 30 bytes

b(d+)b(?<=(b1b.*?)+)

$#2

Try it online! Link includes test cases. 1-indexed. Explanation: The first part of the regex matches each integer in the list in turn. The lookbehind's group matches each occurrence of that integer on that line up to and including the current integer. The integer is then substituted with the number of matches.

Batch, 61 bytes

@setlocal

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

1-indexed. Because variable substitution happens before parsing, the set/a command ends up incrementing the variable name given by concatenating the letter c with the integer from the list (numeric variables default to zero in Batch). The result is then copied to another integer for ease of output (more precisely, it saves a byte).

awk (46 bytes)

{delete(a);for(i=1;i<=NF;i++)$i=a[$i]++;print}

TIO

Tcl, 48 bytes

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

Try it online!

Japt, 8 bytes

£¯YÄ è¶X

Try it here

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

Haskell, 44 bytes

(#)

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

_#e=e

Try it online!

Explanation

Traverses the list from left to right keeping the list x of visited elements, initially :

For every encounter of a y count all equal elements in the list x.

Haxe, 58 bytes

l->{var x=[0=>0];l.map(e->++x[(x[e]==null?x[e]=0:0)+e]);};

(Requires arrow functions, so 4.0+)

var x=[0=>0] declares a new IntMap, with 0 as its only key (since the question say inputs are strictly positive). Unfortunately most targets throw when adding null to a number, hence the explicit check to make sure each key is in the map before incrementing.

Also a cheeky rip off based on the JS answer:

Haxe (JS target), 41 bytes

l->{var x=[0=>0];l.map(e->x[e]=-~x[e]);};

Try both online

GO 121 Bytes (Not included new lines and tabs)

func cg(a int) int{

    var m = make(map[int]int)

    var r = make(int, len(a))

    for i,v := range a{

        r[i] = m[v]

        m[v]++

    }

    return r

}

Accepts integer array and returns integer array.

C++,137 bytes
//v is input , ov is output ; //example to populate v: vector v{7,8,7};

vector<int> v,ov(v.size());map<int,int>m;transform(begin(v),end(v),begin(ov),[&m](int i){!m.count(i)?m[i]=0:m[i]+=1;return m[i];});

Python 2, 44 bytes

a=

for x in input():print a.count(x);a+=x,

Try it online!

The first thing I wrote tied Chas Brown's 43, so here's a different solution that's one byte longer.