Você recebe uma lista não vazia de números inteiros positivos, por exemplo

[6 2 9 7 2 6 5 3 3 4]

Você deve classificar esses números pelo seu valor, mas, como é habitual nas tabelas de classificação, se houver um empate, todos os números empatados obterão a mesma classificação e um número apropriado de classificações será ignorado. O resultado esperado para a lista acima seria, portanto,

[3 9 1 2 9 3 5 7 7 6]

Por exemplo, o valor mais alto na entrada foi 9, então isso se torna um 1(primeiro rank). O terceiro valor mais alto é 6, então ambos 6se tornam 3e a classificação 4é ignorada completamente.

Regras

Você pode usar qualquer formato de lista simples, conveniente e inequívoco para entrada e saída. A primeira / menor classificação na saída deve sempre ser 1 .

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

[8] -> [1]
[1 15] -> [2 1]
[18 14 11] -> [1 2 3]
[11 16 14 8] -> [3 1 2 4]
[15 15 15 15 15] -> [1 1 1 1 1]
[10 2 5 4 15 5] -> [2 6 3 5 1 3]
[5 5 10 10 5 11 18] -> [5 5 3 3 5 2 1]
[2 4 9 4 17 9 17 16] -> [8 6 4 6 1 4 1 3]
[11 17 19 17 10 10 15 3 18] -> [6 3 1 3 7 7 5 9 2]
[2 11 4 8 3 3 12 20 4 18] -> [10 4 6 5 8 8 3 1 6 2]
[12 6 10 2 19 19 6 19 8 6 18] -> [5 8 6 11 1 1 8 1 7 8 4]
[5 6 14 19 13 5 19 9 19 9 9 19] -> [11 10 5 1 6 11 1 7 1 7 7 1]
[9 2 12 3 7 11 15 11 6 8 11 17 11] -> [8 13 3 12 10 4 2 4 11 9 4 1 4]
[3 5 15 7 18 5 3 9 11 2 18 1 10 19] -> [11 9 4 8 2 9 11 7 5 13 2 14 6 1]
[6 11 4 19 14 7 13 16 10 12 7 9 7 10 10] -> [14 6 15 1 3 11 4 2 7 5 11 10 11 7 7]
[11 20 11 1 20 16 11 11 4 8 9 7 11 14 10 14] -> [6 1 6 16 1 3 6 6 15 13 12 14 6 4 11 4]
[4 7 15 2 3 2 3 1 14 2 10 4 7 6 11 2 18] -> [9 6 2 13 11 13 11 17 3 13 5 9 6 8 4 13 1]
[5 1 17 7 1 9 3 6 9 7 6 3 2 18 14 4 18 16] -> [12 17 3 8 17 6 14 10 6 8 10 14 16 1 5 13 1 4]
[5 6 8 10 18 13 20 10 7 1 8 19 20 10 10 18 7 2 1] -> [16 15 11 7 4 6 1 7 13 18 11 3 1 7 7 4 13 17 18]
[12 17 8 2 9 7 15 6 19 5 13 16 14 20 10 11 18 4 3 1] -> [9 4 13 19 12 14 6 15 2 16 8 5 7 1 11 10 3 17 18 20]

Solução alternativa no Excel para regras tolas em relação às entradas do mouse no Exchange Code Stack Exchange: (WESRRMICGSE) 28 bytes

rank(RC[1],r1c1:r1024:c1024)

Lista de entrada como csv ( 10,23,34,2,) no compilador depois de inserir a fonte. sem aspas, sem colchetes, vírgula à direita.

O WESRRMICGSE é exatamente como a programação no Excel, exceto que você pode omitir o sinal inicial '=' para salvar um byte. A diferença na funcionalidade vem do fato de o WESRRMICGSE arrastar a fórmula para baixo para copiar o código automaticamente e fornecer diferentes saídas fornecidas com uma única entrada inteira. fornecida uma lista como entrada, essa lista entra na coluna B (coluna de entrada) e a fórmula é desativada automaticamente para corresponder ao número de entradas. (por exemplo: a entrada 34,21,45, 'arrastaria' a fórmula para baixo em 2 células, para um total de 3 células com a fórmula).

Edit: Eu nunca esperei que esta resposta fosse popular. Uau!

MATL , 4 bytes

&<sQ

Experimente online! Ou verifique todos os casos de teste .

Explicação

&<   % Input array implicitly. Matrix of all pairwise "less than" comparisons
s    % Sum of each column
Q    % Add 1. Display implicitly

Python 2, 41 bytes

lambda l:map(sorted(l+[l])[::-1].index,l)

Para cada valor, encontre seu índice na lista classificada por ordem decrescente. Para fazer com que o maior valor dê 1 em vez de 0, usamos um elemento "infinito" extra da própria lista, pois o Python 2 trata as listas como maiores que os números.

Uma solução mais direta é de 42 bytes e também funciona no Python 3.

lambda l:[1+sum(y<x for x in l)for y in l]

Para cada elemento, conta o número de elementos menores, adicionando 1 para mudar para 1-indexado.

Geléia , 5 bytes

ṢṚiЀ

Experimente online!

Como funciona

ṢṚiЀ  Main link. Argument: A (array)

ṢṚ     Sort and reverse A.
  iЀ  Find the index of each n in A in the previous result.

R, 24 25 20 bytes

Usa a função de classificação padrão com o método de empates "min" sobre o vetor negado. catadicionado para enviá-lo para STDOUT. Guardado 1 graças a @Guiseppe

cat(rank(-scan(),,"mi"))

Exemplo

> cat(rank(-scan(),,"mi"))
1: 9 2 12 3 7 11 15 11 6 8 11 17 11
14: 
Read 13 items
8 13 3 12 10 4 2 4 11 9 4 1 4
> 

PowerShell v2 +, 43 41 bytes

($a=$args)|%{@($a|sort -d).indexof($_)+1}

Desenvolvido de forma independente, mas vejo que esse é o mesmo algoritmo da solução Python do @ xnor , então / shrug.

Recebe entrada como argumentos individuais da linha de comando (ou seja, uma lista separada por espaços). Saída (formatação padrão) é uma nova linha entre elementos.

Para cada elemento na lista de entrada, sorté a lista de entrada em -dordem de tendência, pega o .indexOf()elemento atual e adiciona 1. Observe a matriz explícita convertida @(...)para contabilizar uma entrada de um dígito. Os números resultantes são deixados no pipeline e a saída está implícita.

Economizou 2 bytes graças a @Matt!

Exemplo

PS C:\Tools\Scripts\golfing> .\rank-the-integers.ps1 6 2 9 7 2 6 5 3 3 4
3
9
1
2
9
3
5
7
7
6

Oitava, 15 bytes

@(x)sum(x<x')+1

Porta da minha resposta MATL para Octave. Também funciona no Matlab R2016b.

O código define uma função anônima. Para chamá-lo, atribua-o a uma variável. Experimente em Ideone .

JavaScript (ES6), 38 36 bytes

a=>a.map(e=>a.map(d=>r+=e<d,r=1)&&r)

Editar: salvou 2 bytes graças a @ETHproductions.

Geléia , 5 bytes

<S‘ð€

TryItOnline!

Quão?

<S‘ð€ - Main link: listOfValues
   ð  - dyadic chain separation
    € - for each
<     - less than (vectorises) - yields a list of 1s and 0s
 S    - sum - yields number of values the current value is less than (those that beat it)
  ‘   - increment - the place of a value is the number that beat it plus 1.

Perl 6 ,  42  26 bytes

Encontre o primeiro índice :kem uma [R,]lista classificada invertida

{map {[R,](.sort).first(*==$^a,:k)+1},@$_}

Conte os valores maiores e adicione um

{map {1+.grep(*>$^a)},@$_}

JavaScript, 87 49 bytes

f=a=>a.slice().map(function(v){return a.sort(function(a,b){return b-a}).indexOf(v)+1 })

a=>[...a].map(v=>a.sort((a,b)=>b-a).indexOf(v)+1)

^{Obrigado Conor O'Brien e ETHproductions!}

Mathematica, 44 bytes 42 bytes 40 bytes

xPosition[SortBy[x,-#&],#][[1,1]]&/@x

é o caractere de uso privado de 3 bytes U+F4A1( página de documentos da Wolfram )

Edit: Obrigado ao JHM pela economia de bytes.

Pyke, 6 bytes

FQS_@h

Experimente aqui!

F      - for i in input():
 QS    -     sorted(input())
   _   -    reversed(^)
    @  -   i.find(^)
     h -  ^+1 (not required if allowed to start from 0)

J , 14 8 bytes

1+1#.</~

Quão?

1+1#.</~ - Consumes and returns a list of integers
       ~ - Use the same list for both inputs
     </  - Create a table of less-than comparisons
  1#.    - Treat each row like digits of a base-one number, returning a list of integers
1+       - Increment the results

Solução anterior

1+(+/@:<)"0 1~

Haskell, 28 bytes

f l=[1+sum[1|y<-l,y>x]|x<-l]

Apenas algumas compreensões de lista.

Maravilha , 28 bytes

@(->@+1:0iO#0rev sort#I#1)#0

Uso:

(@(->@+1:0iO#0rev sort#I#1)#0)[6 2 9 7 2 6 5 3 3 4]

Mapeie sobre a matriz de entrada com uma função que adiciona 1 ao primeiro índice do item em uma versão ordenada descendente da entrada.

Dyalog APL , 7 bytes

⊢⍳⍨⍒⊃¨⊂

⊢ argumentos

⍳⍨ índices em

⍒ os índices que classificariam o argumento descendente

⊃¨ cada um escolhido

⊂ todo o argumento

TryAPL online!

Mathematica, 37 bytes

Min@Position[-Sort@-#,i]~Table~{i,#}&

Uma função pura que classificará sua entrada, conforme as regras do problema. Ex:

Min@Position[-Sort@-#, i]~Table~{i, #} &[{6, 2, 9, 7, 2, 6, 5, 3, 3, 4}]
(*{3, 9, 1, 2, 9, 3, 5, 7, 7, 6}*)

Água-viva , 15 bytes

p`&& ~i
  >/+`<

Experimente online!

Explicação

Ainda não parece ser uma boa maneira de encontrar o índice de um valor em uma lista no Jellyfish, então isso usa a abordagem de contar quantos valores são maiores que o atual e incrementar o resultado. Isso é amplamente feito através da construção de uma função unária que calcula esse valor para um determinado elemento.

     `<

Isso cria uma versão encadeada do operador de comparação; portanto, se você fornecer um número inteiro e uma lista, ele retornará uma lista de resultados de comparação entre esse número inteiro e cada elemento da lista.

     ~i
     `<

Isso atualiza o argumento do lado direito da função anterior com a lista de entradas. Portanto, o resultado é uma função unária que pega um número inteiro e fornece a lista de resultados de comparação com a entrada do programa.

   & ~i
   /+`<

Aqui /+está a redução por adição, o que significa que é simplesmente uma função "somar esta lista". &compõe isso na função anterior, então agora temos uma função unária que conta quantos valores na entrada são maiores que esse número inteiro.

  && ~i
  >/+`<

Também compomos a função de incremento para isso.

 `&& ~i
  >/+`<

Finalmente, também encadeamos essa função, para que ela seja aplicada automaticamente a cada número inteiro de uma lista passada para ela. Devido ao layout do código, também ié considerado a entrada dessa função, para que isso calcule a saída desejada.

p`&& ~i
  >/+`<

Finalmente, isso imprime o resultado.

brainfuck, 124 bytes

->,[>>>+>,]<[-<+]+[-->[<[<<<<]>>>+>[>[>>]<[[<<+<<]>+>[->>>>]]<+>>>]+[-<<+]->]<[<
<<<]>+.,>>[>[>->+>>]<<[-<<<<]>-]+[->+]+>>>>]

Formatado:

->
,[>>>+>,]
<[-<+]
+
[
  -->
  [
    <[<<<<]
    >>>+>
    [
      >[>>]
      <
      [
        [<<+<<]
        >+>[->>>>]
      ]
      <+> >>
    ]
    +[-<<+]
    ->
  ]
  <[<<<<]
  >+.,>>
  [
    >[>->+>>]
    <<[-<<<<]
    >-
  ]
  +[->+]
  +>>>>
]

Isso foi projetado para implementações de 8-brainfuck. Entrada e saída são via valores de bytes .

Experimente online.

Para cada elemento, isso conta o número de elementos maior que ele e imprime o resultado mais um. Isso é feito incrementando todos os elementos até que o elemento atual seja igual a zero, atualizando o resultado sempre que outro elemento se torna zero antes do elemento atual.

A fita é dividida em nós de 4 células,

b c 0 0

onde cestá o elemento eb é um sinalizador de navegação negativo para o elemento atual, caso contrário, um.

O resultado e uma cópia do elemento atual são mantidos à esquerda da matriz.

Java, 215 bytes

public class G{public static void L(int[]A){int[]r=new int[A.length];for(int i=0;i<A.length;i++){int c=1;for(int j=0;j<A.length;j++){if(A[j]>A[i])c++;}r[i]=c;}for(int i=0;i<r.length;i++)System.out.print(r[i]+",");}}

Explicação:

Muito auto-explicativo.

Basicamente, para cada número inteiro na matriz, ele verifica quantos são maiores que ele e depois imprime a nova matriz com as classificações.

Sinto muito, isso não é muito conciso, mas é a minha primeira tentativa em um desses e não vi uma entrada para java. Tenho certeza de que pode ser jogado mais.

Ele pode ser executado apenas fazendo referência ao método estático e passando uma matriz. Não achei que fosse necessário escrever a função principal, mas se for, farei isso no futuro.

PHP, 101 bytes

Deve haver uma maneira mais curta.

function f(&$a){for($r=1;$v++<max($a);$r+=$n,$n=0)foreach($a as$k=>$w)if($w===$v){$a[$k]="$r";$n++;}}

A função recebe a entrada como matriz de números inteiros, substitui a variável de entrada com as classificações como seqüências numéricas.

Uso: $a=[1,2,4,2,2,3];f($a);print_r($a);

Ruby, 45 40 bytes

->a{a.map{|x|a.sort.reverse.index(x)+1}}

Clojure, 48 44 bytes

Atualização: usando em forvez demap

#(for[i %](+(count(filter(partial < i)%))1))

Simplesmente filtra cada valor menor que o atual, conta o comprimento da lista e aumenta em um.

Tcl , 54 bytes

proc R L {lmap x $L {lsearch .\ [lsort -r -de $L] $x}}

Experimente online!

PHP, 84 bytes

function r($l){$s=$l;rsort($s);foreach($l as$n)$r[]=array_search($n,$s)+1;return$r;}

Uso: Passe a função r sua matriz de números inteiros e ela retornará a matriz correspondente de números inteiros classificados.

Passando nos testes aqui.

Perl 5, 23 +2 (-ap)

s/\d+/1+grep$&<$_,@F/ge

Experimente online

K (oK) , 11 bytes

Solução:

1+(x@>x)?x:

Experimente online!

Exemplos:

1+(x@>x)?x:6 2 9 7 2 6 5 3 3 4
3 9 1 2 9 3 5 7 7 6
1+(x@>x)?x:5 6 14 19 13 5 19 9 19 9 9 19
11 10 5 1 6 11 1 7 1 7 7 1

Explicação:

Procure a posição da lista original na lista classificada e adicione uma.

1+(x@>x)?x: / the solution
         x: / save input as x
  (  >x)    / return indices of x sorted in descending order
   x@       / apply these indices to x (thus sort x)
        ?   / lookup right in left
1+          / add one