엄격하게 양의 정수 목록이 제공되면 각각의 고유 한 숫자를 살펴보고 모든 발생을 새로운 계열의 연속 인덱스 (0 또는 1 기준)로 바꿉니다.

예

[]→ []/[]

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

자바 스크립트 (ES6), 26 바이트

1- 색인.

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

온라인으로 사용해보십시오!

댓글

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 바이트

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

온라인으로 사용해보십시오!

설명 :

ave(x,x,FUN=seq)그룹화 키 x값을 사용하여 벡터 를 하위 벡터 로 분할 x합니다. 그런 다음 seq각 그룹에 대해 함수가 호출되고 각 결과는 원래 그룹 위치로 다시 정렬됩니다.

예를 더 잘보십시오.

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

노트 :

seq(y)연속 함수가 리턴 1:length(y)경우는 y가지고 length(y) > 1있지만, 복귀에서 서열 1:y[1]경우 y단지 하나의 요소를 포함한다.
이 경우 R- 많은 경고로 불평- 우연히 우리가 원하는 것의 첫 번째 값 만 선택 하기 때문에 이것은 문제가되지 않습니다. :)

MATL , 4 바이트

&=Rs

이 솔루션은 1 기반입니다

MATL Online 에서 사용해보십시오 !

설명

용도 [1,2,3,2]예를 들어

    # 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 유니 코드) , 7 바이트

디버깅 및 수정에 도움을 주신 H.PWiz, Adám 및 dzaima에게 감사드립니다.

+/¨⊢=,\

온라인으로 사용해보십시오!

설명

10 바이트의 무소음 버전이 먼저 설명하기 쉬울 것입니다

{+/¨⍵=,\⍵}

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

암묵적인 버전은 세 가지 일을한다

• 첫째, 그것은 인스턴스 제거 ⍵에 사용 ,\⍵으로 ,\암시 적으로 적절한 인수에서 작동하도록 해야하는 것을 알아낼 수 자체 오른쪽에 있습니다.
• 대한 둘째, ⍵=우리는 교체 ⍵로 ⊢오른쪽 인자를 의미하는,
• 셋째, 이제 명시 적 인수 (이 경우 ⍵) {}가 없으므로 암묵적 함수가이를 사용하지 않으므로 중괄호 를 제거 할 수 있습니다.

AWK , 14

• @NahuelFouilleul 덕분에 1 바이트 절약

{print++a[$1]}

온라인으로 사용해보십시오!

위의 1 기반 색인 생성을 수행합니다. 0부터 시작하는 색인 ​​작성을 선호하는 경우 추가 바이트 :

{print a[$1]++}

온라인으로 사용해보십시오!

J , 7 바이트

1#.]=]\

온라인으로 사용해보십시오!

1- 색인.

설명:

]\ 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 바이트

ngn 덕분에 -1 바이트!

{+/'x=,\x}

온라인으로 사용해보십시오!

파이썬 2 , 48 바이트

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

온라인으로 사용해보십시오!

05AB1E , 4 바이트

ηε¤¢

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

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

C # (Visual C # 대화식 컴파일러) , 44 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 47 43 바이트

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

온라인으로 사용해보십시오!

재귀적인 '1 기반'솔루션.

젤리 , 4 바이트

ċṪ$Ƥ

온라인으로 사용해보십시오!

입력 목록의 각 접두사마다 마지막 요소 자체의 발생 횟수를 계산합니다.

R , 41 바이트

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

온라인으로 사용해보십시오!

이상하게도, 0부터 시작하는 인덱스 반환은 R에서 더 짧습니다.

루비, 35 바이트

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

불행히도 그것은 평범한 일입니다. 지금까지 발생한 각 항목의 총계를 저장하는 해시를 작성하십시오.

불행히도 다른 재미있는 옵션은 충분히 짧지 않았습니다.

->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 바이트

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

Giuseppe 덕분에 -19 바이트, which 및 table을 제거하고 구현에 약간의 변경 사항 만 있음

기발한

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

주세페의 지식과 경쟁 할 수 없어서 제출 한 것이 그의 것보다 다소 길지만 기본 지식을 사용하면이 솔루션이 독창적이라고 느꼈습니다.

r<-table(x) 나중에 참조 할 수 있도록 각 숫자가 나타나는 횟수를 세고 r에 저장합니다.

names() 테이블에서 각 고유 항목의 값을 가져오고 for 루프를 사용하여 이러한 이름을 반복합니다.

나머지 부분은 반복과 동일한 항목을 확인하고 값 시퀀스 (1에서 반복의 항목 수까지)를 저장합니다.

온라인으로 사용해보십시오!

하스켈 , 44 바이트

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

온라인으로 사용해보십시오!

설명

x처음에 방문한 요소 의 목록 을 유지하면서 목록을 왼쪽에서 오른쪽으로 순회합니다 [].

y카운트 가 발생할 때마다 목록의 모든 동일한 요소 가 계산됩니다 x.

펄 6 , 15 바이트

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

온라인으로 사용해보십시오!

하나의 기반 인덱스에 대해 ++를 이전으로 이동할 수 있습니다 %.

설명:

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

하스켈 , 47 46 바이트

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

온라인으로 사용해보십시오!

조금 더 길어진 BMO의 대답 과 다른 접근법 . (그리고 좋은 시험 복을 친절하게 빌려줍니다.)

아이디어는 입력 목록을 반복하고 함수를 업데이트하여 각 요소가 발생한 횟수를 추적하는 것 g입니다. 언 골프 드 :

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

두 가지 흥미로운 골프 기회가 생겼습니다. 먼저의 초기 값에 대해서는 g인수를 무시하고 다음을 반환하는 상수 함수입니다 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

그리고 둘째로 변수에 대한 표현식 x이며 같 거나 그렇지 않으면 y산출 1합니다 .xy0

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!

여전히 더 짧은 방법이있을 수 있습니다. 누구나 아이디어가 있습니까?

자바 (JDK) , 76 바이트

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

온라인으로 사용해보십시오!

크레딧

• Kevin Cruijssen 덕분에 -2 바이트

루비 , 34 바이트

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

온라인으로 사용해보십시오!

bash, 37 24 바이트

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

TIO

유효한 경우 DigitalTrauma에서 제안한대로이 변형도 있습니다.

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

TIO

펄 5, 11 바이트

$_=$h{$_}++

TIO

주석 다음 설명

• $_입력 ( -p또는 -n스위치)을 반복 할 때 전류 라인을 포함하는 Perl의 특수 변수
• $h{$_}++지도를 자동으로 활성화하고 %h키 $_와 증분으로 항목을 작성 하고 증분 전에 값을 제공합니다.
• -p스위치로 인해 특수 변수가 인쇄되고 , -l스위치는 입력에서 라인 끝을 제거하고 출력에서 ​​라인 끝을 추가합니다

Pari / GP , 32 바이트

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

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 33 바이트

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

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

온라인으로 사용해보십시오!

첨부 , 23 바이트

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

온라인으로 사용해보십시오!

설명

{`~&>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 바이트

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

온라인으로 사용해보십시오!

ASCII 전용으로 -2 바이트

이것은 너무 솔직하게 느껴졌지만 다른 접근법으로는 더 짧아 질 수 없었습니다.

K (ngn / k) , 18 바이트

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

온라인으로 사용해보십시오!

오래된 접근법

K (ngn / k) , 27 23 22 바이트

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

온라인으로 사용해보십시오!

이것은 예쁘지 않습니다 ... 빠르고 더러운 해결책입니다. 나중에 더 나은 접근 방식을 생각할 때 이것을 정제 할 것입니다.

설명:

• =x키가 x의 항목이고 값이 색인 ( 3 1 4 5 9 2 6!(0 9;1 3;,2;4 8 10;5 11;,6;,7)) 인 dict를 반환합니다.
• i: 받아쓰기 i
• #:'각 키의 개수 값 ( 3 1 4 5 9 2 6!2 2 1 3 2 1 1)
• !:'각 값을 열거 ( 3 1 4 5 9 2 6!(0 1;0 1;,0;0 1 2;0 1;,0;,0))
• ,/.:값 추출 및 평평한 목록 ( 0 1 0 1 0 0 1 2 0 1 0 0)
• x[,/.:i]: i에서 인덱스를 추출하고 평평하게 만들고이 인덱스의 오른쪽 목록에서 각 값을 할당합니다

짜증나게, 목록은 업데이트되지만 할당에 의해 null 값이 반환되므로 세미콜론 ( ;x) 뒤에 목록을 반환해야합니다.

편집 : 외부 콜론 제거

edit2 : 불필요한 할당 제거

레티 나 0.8.2 , 30 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 1- 색인. 설명 : 정규식의 첫 번째 부분은 목록의 각 정수와 차례로 일치합니다. lookbehind의 그룹은 현재 정수를 포함하여 해당 행에서 해당 정수의 각 발생을 일치시킵니다. 그런 다음 정수는 일치 횟수로 대체됩니다.

배치, 61 바이트

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

1- 색인. 변수 대체는 구문 분석 전에 발생하므로, set/a명령은 문자 c를 목록의 정수 로 연결하여 주어진 변수 이름을 증가시킵니다 (숫자 변수는 기본적으로 배치에서 0으로 설정 됨). 결과는 출력을 쉽게하기 위해 다른 정수로 복사됩니다 (보다 정확하게는 바이트를 절약합니다).

Tcl , 48 바이트

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

온라인으로 사용해보십시오!

apt, 8 바이트

£¯YÄ è¶X

여기 사용해보십시오

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