Kesinlikle pozitif tamsayıların bir listesi göz önüne alındığında, her bir farklı sayının içinden geçin ve tüm oluşumlarını yeni bir dizinin ardışık indeksleri (sıfır veya bir tabanlı) ile değiştirin.

Örnekler

[]→ []/[]

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

1 endeksli.

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Açıklama:

ave(x,x,FUN=seq)vektörü , gruplandırma tuşları olarak xdeğerleri kullanarak alt vektörlere böler x. Daha sonra seqher grup için fonksiyon çağrılır ve her sonuç orijinal grup konumuna geri ayarlanır.

Bir örnek görmek daha iyi:

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

Not :

seq(y)Bir dizi fonksiyonu döner 1:length(y)durumda ybulunmaktadır length(y) > 1, ancak döner bir sekans 1:y[1]ise ysadece bir eleman içerir.
Bu neyse ki bir sorun değil çünkü bu durumda R - çok fazla uyarı ile şikayet etmek - sadece tesadüfen istediğimiz şey olan ilk değeri seçiyor :)

Matl , 4 bayt

&=Rs

Bu çözüm 1 tabanlı

MATL Online'da deneyin !

açıklama

[1,2,3,2]Örnek olarak kullanır

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

Bu hata ayıklama ve düzeltmedeki tüm yardımları için H.PWiz, Adám ve dzaima'ya çok, çok teşekkürler.

+/¨⊢=,\

Çevrimiçi deneyin!

açıklama

10 bit baytlık olmayan versiyonun ilk önce anlatılması daha kolay olacak

{+/¨⍵=,\⍵}

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

Tacik sürüm üç şey yapar

• Birincisi, sağda olduğu gibi ⍵kullanılan örneği kaldırır, dolaylı olarak doğru argüman üzerinde çalışması gerektiğini anlayabilir.,\⍵,\
• İkincisi, doğru argüman anlamına ⍵=gelen ⍵with ile değiştiriyoruz.⊢
• Üçüncüsü, şimdi açık bir argümanımız olmadığı için (bu durumda, ⍵), parantez {}işlevleri bunları kullanmadıkça parantezleri kaldırabiliriz.

AWK , 14

• @NahuelFouilleul sayesinde 1 bayt kurtarıldı

{print++a[$1]}

Çevrimiçi deneyin!

Yukarıdakiler tek tabanlı bir indeksleme yapar. Sıfır tabanlı endekslemeyi tercih ederseniz, bu ekstra bir bayt olur:

{print a[$1]++}

Çevrimiçi deneyin!

J , 7 bayt

1#.]=]\

Çevrimiçi deneyin!

1 endeksli.

Açıklama:

]\ 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 bayt

Ngn sayesinde -1 bayt!

{+/'x=,\x}

Çevrimiçi deneyin!

Python 2,48 bayt

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

Çevrimiçi deneyin!

05AB1E , 4 bayt

ηε¤¢

Çevrimiçi deneyin! veya Test Paketi olarak

açıklama

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

C # (Visual C # Etkileşimli Derleyici) , 44 bayt

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

Çevrimiçi deneyin!

Python 2 , 47 43 bayt

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

Çevrimiçi deneyin!

Özyinelemeli 'tek tabanlı' bir çözüm.

Jöle , 4 bayt

ċṪ$Ƥ

Çevrimiçi deneyin!

Giriş listesinin her öneki için, kendi son elemanının oluşum sayısını sayar.

R , 41 bayt

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

Çevrimiçi deneyin!

İşin garibi, sıfır temelli bir endeks döndürmek R'de daha kısa.

Ruby, 35 bayt

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

Oldukça sıradan, maalesef - şu ana kadar karşılaşılan her giriş için toplamı depolayan bir karmaşa oluşturmak.

Maalesef yeterince kısa olmayan diğer bazı eğlenceli seçenekler:

->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 bayt

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

-19 bayt Giuseppe sayesinde, hangisini ve tablosunu kaldırarak ve uygulamada sadece küçük değişiklikler yaparak

orijinal

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

Giuseppe'nin bilgisiyle rekabet edemiyorum, bu yüzden başvurum ondan biraz daha uzun, ama temel bilgimi kullanarak bu çözümün zekice olduğunu hissettim.

r<-table(x) Gelecekte başvurmak için her sayının görünme sayısını ve r olarak sakladığını

names() tablodaki her benzersiz girişin değerlerini alır ve bu isimler üzerinde for döngüsüyle yineleriz.

Kalan kısım, hangi girişlerin yinelemelere eşit olduğunu kontrol eder ve bir dizi değer depolar (1'den yinelemenin giriş sayısına kadar)

Çevrimiçi deneyin!

Haskell , 44 bayt

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

Çevrimiçi deneyin!

açıklama

xBaşlangıçta ziyaret edilen öğelerin listesini tutmak için listeyi soldan sağa geçirir []:

Bir ysayının her karşılaşması için listedeki tüm eşit unsurlar x.

Perl 6 , 15 bayt

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

Çevrimiçi deneyin!

Bir temelli dizin için ++için öncesine gidebilirsiniz %.

Açıklama:

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

Haskell , 47 46 bayt

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

Çevrimiçi deneyin!

BMO'nun cevabından biraz daha uzun süren farklı bir yaklaşım . (Ve kibarca güzel sınavlarını ödünç alır.)

Buradaki fikir, giriş listesi üzerinde yineleme yapmak ve bir fonksiyonu güncelleyerek her bir elemanın kaç kez oluştuğunu takip etmektir g. Ungolfed:

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

İki ilginç golf fırsatı ortaya çıktı. Birincisi, ilk değeri için g, argümanını dikkate almayan ve döndüren sabit bir işlev 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

İkincisi, değişkenler üzerinde ifade eden xve eşit ve aksi takdirde sonuç yveren bir ifade:1xy0

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!

Hala daha kısa yollar olabilir. Bir fikri olan var mı?

Java (JDK) , 76 bayt

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

Çevrimiçi deneyin!

Kredi

• Kevin Cruijssen sayesinde -2 bayt

Ruby , 34 bayt

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

Çevrimiçi deneyin!

bash, 37 24 bayt

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

TIO

eğer geçerliyse, DigitalTrauma tarafından önerilen şekilde, bu varyasyon da vardır.

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

TIO

Perl 5, 11 bayt

$_=$h{$_}++

TIO

yorumu izleyen açıklamalar

• $_ Perl girişi sırasında döngüde mevcut satırı içeren özel değişken-p veya -nanahtarlar)
• $h{$_}++ haritayı otomatik olarak canlandırır %h anahtar $_ve artışlarla bir giriş oluşturur ve önce değer verir
• Özel değişken, -panahtar nedeniyle basılır , -lanahtar girişteki satır sonunu kaldırır ve satırın çıkışına son ekler

Pari / GP , 32 bayt

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

$k$cevabın içindeki-element, 'nin katsayısıdır $x^{a_k}$ polinomda terim $\sum_{i=1}^kx^{a_i}$.

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 33 bayt

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

$k$cevabın içindeki-element, 'nin katsayısıdır $x^{a_k}$ polinomda terim $\sum_{i=1}^kx^{a_i}$.

Çevrimiçi deneyin!

Ataşesi , 23 bayt

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

Çevrimiçi deneyin!

açıklama

{`~&>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 bayt

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

Çevrimiçi deneyin!

Sadece ASCII sayesinde -2 bayt

Bu çok basit hissettiriyor, ancak farklı bir yaklaşımla daha da kısalıyor gibi görünmüyorum.

K (ngn / k) , 18 bayt

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

Çevrimiçi deneyin!

ESKİ YAKLAŞIMI

K (ngn / k) , 27 23 22 bayt

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

Çevrimiçi deneyin!

bu güzel değil ... hızlı ve kirli bir çözüm, daha sonra daha iyi bir yaklaşım düşünme şansını yakaladığımda bunu iyileştireceğim

açıklama:

• =x(tuşlar x öğelerdir ve değerleri endeksleri olan bir dicti döndürür 3 1 4 5 9 2 6!(0 9;1 3;,2;4 8 10;5 11;,6;,7))
• i: için dict ata i
• #:'Her anahtar için değerleri sayın ( 3 1 4 5 9 2 6!2 2 1 3 2 1 1)
• !:'her değeri sırala ( 3 1 4 5 9 2 6!(0 1;0 1;,0;0 1 2;0 1;,0;,0))
• ,/.:değerleri çıkartın ve listeyi düzleştirin ( 0 1 0 1 0 0 1 2 0 1 0 0)
• x[,/.:i]: i'den dizinleri çıkar, düzleştir ve sağdaki listeden her bir değeri bu dizinlerde ata

can sıkıcı bir şekilde, liste güncellenir ancak atama tarafından boş bir değer döndürülür, bu yüzden noktalı virgülten ( ;x) sonra listeyi döndürmem gerekir

düzenleme: yabancı virgül kaldırıldı

edit2: gereksiz atama kaldırıldı

Retina 0.8.2 , 30 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. 1 endeksli. Açıklama: Düzenlemenin ilk kısmı, sırayla listedeki her bir tamsayı ile eşleşir. Lookbehind grubu, o satırdaki o tamsayı her biri ile o andaki tamsayıya eşzamanlı olarak eşleştirir. Tam sayı daha sonra eşleşme sayısı ile değiştirilir.

Toplu iş, 61 bayt

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

1 endeksli. Değişken ikame ayrıştırma işleminden önce gerçekleştiğinden, set/akomut mektubu clisteden tam sayı ile birleştirerek verilen değişken adını artırarak sona erer (sayısal değişkenler Toplu iş içinde varsayılan olarak sıfıra kadar). Sonuç daha sonra çıktı kolaylığı için başka bir tam sayıya kopyalanır (daha doğrusu bir bayt kazandırır).

Tcl , 48 bayt

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

Çevrimiçi deneyin!

Japt, 8 bayt

£¯YÄ è¶X

Burada dene

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