Dada uma lista de pontuações (números inteiros não negativos) pré-classificadas do maior para o menor:

[ 10, 10, 6,  6,  4,  0]

Atribua a cada pontuação uma classificação inteira, começando com 1 e crescente, para que pontuações iguais tenham a mesma classificação (ou seja, estão empatadas):

[ 1, 1, 3, 3, 5, 6 ]

No caso de empates, as fileiras são "puladas", por exemplo, uma vez que a primeira e a segunda maiores pontuações (10 e 10) estão empatadas, ambas têm classificação 1 e a classificação 2 é "pulada", de modo que a terceira maior pontuação ( 6) tem classificação 3.

Envie uma lista de classificações não decrescentes correspondentes às pontuações de entrada.

Exemplos

In:  10 10  6  6  4  0
Out:  1  1  3  3  5  6

In:  10  9  8
Out:  1  2  3

In:   0  0  0
Out:  1  1  1

In:  16 15 15 12 11 11 10  9  9  9  8  2  2  2  0
Out:  1  2  2  4  5  5  7  8  8  8 11 12 12 12 15

Entrada

Suponha que todas as pontuações estejam entre 0 e 1.000, inclusive, e a entrada não terá mais que 500 pontuações. A entrada pode estar em qualquer formato que seja conveniente para o seu idioma de escolha (incluindo, sem limitação, STDIN, argumentos para uma função, uma matriz já armazenada em uma variável etc.).

Resultado

Retorno ou armazenar em uma variável da lista resultante ordenada de fileiras, ou escrever para STDOUT de forma legível (por exemplo 1 2 3, [1,2,3], 1\n2\n3\ne { 1, 2, 3 }são todos muito bem, 123não é, por falta de um delimitador). As pontuações de entrada podem ser armazenadas / impressas junto com suas classificações de saída correspondentes, mas isso não é necessário.

Restrições

Você pode usar qualquer biblioteca padrão oferecida por seu idioma. Aplicam-se brechas padrão.

Condições vencedoras

Isso é código-golfe , então o menor programa (em bytes) vence. Em caso de empate, a resposta com mais votos vence.

Notas

Isso se baseia em uma pergunta do Ruby no SO que gerou algumas respostas interessantes, incluindo uma muito curta. Convido você a apresentar suas próprias soluções antes de procurar lá.

J ( 7 6)

EDIT: Ah, espera! Não precisa ser uma função!

>:i.~y

Graças a Deus por i.~...

>:@:i.~

Ou como uma função nomeada (3 caracteres a mais, mas não funcionalmente diferente):

f=:>:@:i.~

Execute testes:

   f=:>:@:i.~
   f 10 10  6  6  4  0
1 1 3 3 5 6
   f 10  9  8
1 2 3
   f 0  0  0
1 1 1
   f 16 15 15 12 11 11 10  9  9  9  8  2  2  2  0
1 2 2 4 5 5 7 8 8 8 11 12 12 12 15

T-SQL (40)

SELECT RANK()OVER(ORDER BY B DESC)
FROM @

Suponha que @é uma tabela que contém as pontuações como linhas.

Pitão , 6

m'XYdY

A lista é armazenada em Y para começar. É funcionalmente o mesmo que a solução ruby ​​de 22 caracteres: mapeie sobre d em Y para o índice de d em Y mais 1 e depois imprima.

Exemplo:

$ echo "=Y[16 15 15 12 11 11 10 9 9 9 8 2 2 2 0)m'XYdY" | python3 pyth.py

[1, 2, 2, 4, 5, 5, 7, 8, 8, 8, 11, 12, 12, 12, 15]

Python (33 caracteres)

lambda x:[1+x.index(i)for i in x]

Funcionalmente igual à minha resposta em J.

APL, 2 bytes

⍳⍨

In ⎕IO←1. O iota diádico pesquisa seu argumento correto no argumento esquerdo. O operador ⍨copia o argumento da direita para o argumento da esquerda se o operando for usado monadicamente. Portanto, a solução simplesmente pesquisa a posição de cada um dos elementos do vetor dados em si.

Amostras:

    ⍳⍨10 10 6  6  4  0
1 1 3 3 5 6
    ⍳⍨0  0  0 
1 1 1 
    ⍳⍨16 15 15 12 11 11 10  9  9  9  8  2  2  2  0
1 2 2 4 5 5 7 8 8 8 11 12 12 12 15

STATA (16)

egen b=rank(c),f

O resultado está em b.

Assume que c é uma variável no conjunto de dados que contém a entrada.

Haskell (31)

f x=succ.(`elemIndexJust`x)<$>x -- Requires the Safe module

Uso:

f [10,10,6,6,4,0] --evaluates to [1,1,3,3,5,6]

Para estabelecer uma linha de base:

Rubi (38)

Assumindo que aé uma matriz:

r,i=1,0;a.map{|x|i+=1;x==a[i-2]?r:r=i}

(Isso é baseado na resposta da falsetru no thread SO original e não é o meu trabalho original. Eu sei que há uma solução Ruby com 22 caracteres, mas eu gostaria de ver alguém aparecer com uma mais curta que a do Ruby.)

JavaScript (E6) 41

Uma função com um argumento de matriz, retornando uma matriz

F=s=>s.map((n,i)=>p-n?(p=n,r=i+1):r,p=-1)

Teste no console do Firefox

F([10,10,6,6,4,0])

Saída: [1, 1, 3, 3, 5, 6]

F([16, 15, 15, 12, 11, 11, 10, 9, 9, 9, 8, 2, 2, 2, 0])

Saída: [1, 2, 2, 4, 5, 5, 7, 8, 8, 8, 11, 12, 12, 12, 15]

R, 15

com entrada armazenada como vetor x,

rank(-x,T,"mi")

Powershell (70)

$n=1;$c=0;$l=$a[0];$a|%{if($l-eq$_){$n}else{$n=$c+1;$n}$l=$a[$c];$c++}

São apenas 51 caracteres se você escolher as atribuições de variáveis ​​no início, o que me faz sentir um pouco menos inadequada.

Supõe que $ a seja atribuído e classificado conforme especificado pelo problema. $ n rastreia a classificação, $ c é apenas um contador que funciona com $ l, o último elemento verificado na matriz.

Se há algo que eu possa fazer para melhorar isso, eu adoraria saber.

Java (57)

Usando as mesmas 'regras' que o Allbeert :

Constante ié definida como int[]matriz e contém a entrada, zcontém o tamanho da entrada. Outros, l, c, xe n, são definidos como int.

O trecho de código que resta à esquerda é:

l=0;c=1;for(x=0;x<z;x++){n=i[x];i[x]=n==l?c:(c=x+1);l=n;}

O resultado está na matriz de entrada.

Ruby, 22

Eu não olhei para o tópico SO, mas imagino que é isso que eles criaram.

a.map{|i|a.index(i)+1}

Edit: Sim, é. Duvido que seja possível ficar menor no Ruby, a menos que você assuma que o está definindo como um método Array, você pode fazê-lo em 18 caracteres com

map{|i|index(i)+1)

Mas é claro que o programa completo em torno desse trecho parece

class Array
  def ranks
    map{|i|index(i)+1)
  end
end

p [1, 2, 2, 4, 5, 5, 7, 8, 8, 8, 11, 12, 12, 12, 15].ranks

> <> (47)

Não particularmente otimizado, apenas testando a água com meu primeiro golfe.

r:1:nr2&>ao$:@=?vr~&:|   
&1+&l3)?^;      >r:nr

Supõe que a entrada seja preenchida previamente na pilha, de modo que o primeiro elemento da entrada seja o primeiro a ser retirado.

Teste:

fish.py ranks.fish -v 1 2 3 4 5 6 7 8 9 9 10 10

saídas

1
1
3
3
5
6
7
8
9
10
11
12

Clojure, 35

Com alguma interoperabilidade Java misturada:

(fn[l](map #(+ 1(.indexOf l %)) l))

Sessão REPL:

golf> ((fn[l](map #(+ 1(.indexOf l %)) l)) [10 10  6  6  4  0])
(1 1 3 3 5 6)
golf> ((fn[l](map #(+ 1(.indexOf l %)) l)) [16 15 15 12 11 11 10  9  9  9  8  2  2  2  0])
(1 2 2 4 5 5 7 8 8 8 11 12 12 12 15)

C - 62

Como um trecho de código, já que não havia requisito para função ou programa completo.

Assume a, n, j, e ksão já definido como int*, int, int, e int, respectivamente, em que aé uma matriz contendo a entrada, e ncontém o comprimento da entrada.

Isso falha na entrada de comprimento 0, caso em que são necessários mais 3 caracteres.

printf("1");for(k=j=1;++j<=n;)printf(" %d",*a-*(a+++1)?k=j:k);