Se le da una lista no vacía de enteros positivos, por ejemplo

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

Debe clasificar estos números por su valor, pero como es habitual en las tablas de clasificación, si hay un empate, todos los números empatados obtienen el mismo rango, y se omite un número apropiado de rangos. Por lo tanto, el resultado esperado para la lista anterior sería

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

Por ejemplo, el valor más alto en la entrada fue 9, por lo que se convierte en un 1(primer rango). El tercer valor más alto es 6, por lo que ambos se 6convierten 3, y el rango 4se omite por completo.

Reglas

Puede usar cualquier formato de lista plana conveniente, inequívoco para entrada y salida. El primer / menor rango en la salida siempre debe ser 1 .

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

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

Solución alternativa en Excel para reglas tontas con respecto a las entradas del mouse en Code Golf Stack Exchange: (WESRRMICGSE) 28 bytes

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

Ingrese la lista como csv ( 10,23,34,2,) en el compilador después de ingresar la fuente. sin comillas, sin corchetes, coma final.

WESRRMICGSE es exactamente como programar en Excel, excepto que puede omitir el signo inicial '=' para guardar un byte. La diferencia en la funcionalidad proviene del hecho de que WESRRMICGSE arrastrará la fórmula hacia abajo para copiar el código automáticamente y proporcionará diferentes salidas provistas con una sola entrada entera. proporcionó una lista como entrada, esa lista va a la columna B (columna de entrada), y la fórmula se desactiva automáticamente para que coincida con el número de entradas. (por ejemplo: la entrada 34, 21, 45 'arrastraría' la fórmula hacia abajo 2 celdas, para un total de 3 celdas con la fórmula).

Editar: nunca esperé que esta respuesta fuera popular. ¡Guauu!

MATL , 4 bytes

&<sQ

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

&<   % 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, encuentre su índice en la lista ordenada por orden decreciente. Para hacer que el valor más grande dé 1 en lugar de 0, utilizamos un elemento "infinito" adicional de la lista en sí, ya que Python 2 trata las listas como más grandes que los números.

Una solución más directa es de 42 bytes y también funciona en Python 3.

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

Para cada elemento, cuenta el número de elementos más pequeños, agregando 1 para cambiar a 1 indexado.

Jalea , 5 bytes

ṢṚiЀ

Pruébalo en línea!

Cómo 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

Utiliza la función de rango estándar con el método de vínculos "min" sobre el vector negado. catagregado a la salida a STDOUT. Salvé uno gracias a @Guiseppe

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

Ejemplo

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

Desarrollado de forma independiente, pero veo que este es el mismo algoritmo que la solución Python de @ xnor , así que / encogimiento de hombros.

Toma datos como argumentos de línea de comandos individuales (es decir, una lista separada por espacios). La salida (formato predeterminado) es una nueva línea entre elementos.

Para cada elemento en la lista de entrada, sortes la lista de entrada en -dorden ascendente, toma el .indexOf()elemento actual y agrega 1. Tenga en cuenta el reparto explícito de la matriz @(...)para tener en cuenta una entrada de un solo dígito. Los números resultantes se dejan en la tubería y la salida es implícita.

¡Ahorró 2 bytes gracias a @Matt!

Ejemplo

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

Octava, 15 bytes

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

Puerto de mi respuesta MATL a Octave. También funciona en Matlab R2016b.

El código define una función anónima. Para llamarlo, asígnelo a una variable. Pruébalo en Ideone .

JavaScript (ES6), 38 36 bytes

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

Editar: Guardado 2 bytes gracias a @ETHproductions.

Jalea , 5 bytes

<S‘ð€

TryItOnline!

¿Cómo?

<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

Encuentra el primer índice :ken una [R,]lista ordenada inversa

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

Cuente los valores que son más grandes y agregue uno

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

^{¡Gracias Conor O'Brien y ETHproductions!}

Mathematica, 44 bytes 42 bytes 40 bytes

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

es el carácter de uso privado de 3 bytes U+F4A1( página de documentos de Wolfram )

Editar: Gracias a JHM por el ahorro de bytes.

Pyke, 6 bytes

FQS_@h

Pruébalo aquí!

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#.</~

¿Cómo?

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

Solución previa

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

Haskell, 28 bytes

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

Solo algunas comprensiones de listas.

Maravilla , 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]

Asigne una matriz de entrada con una función que agrega 1 al primer índice del elemento en una versión ordenada descendente de la entrada.

Dyalog APL , 7 bytes

⊢⍳⍨⍒⊃¨⊂

⊢ argumentos

⍳⍨ índices en

⍒ los índices que ordenarían el argumento descendente

⊃¨ cada uno escogido de

⊂ todo el argumento

TryAPL en línea!

Mathematica, 37 bytes

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

Una función pura que clasificará su entrada, según las reglas del 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}*)

Medusa , 15 bytes

p`&& ~i
  >/+`<

Pruébalo en línea!

Explicación

Todavía no parece haber una buena manera de encontrar el índice de un valor en una lista en Jellyfish, por lo que utiliza el enfoque de contar cuántos valores son mayores que el actual e incrementar el resultado. Esto se realiza principalmente mediante la construcción de una función unaria que calcula este valor para un elemento dado.

     `<

Esto crea una versión enhebrada del operador de comparación, por lo que si le da a este un número entero y una lista, devolverá una lista de resultados de comparación entre ese número entero y cada elemento de la lista.

     ~i
     `<

Esto cursa el argumento de la mano derecha de la función anterior con la lista de entrada. Por lo tanto, el resultado es una función unaria que toma un número entero y le brinda la lista de resultados de comparación con la entrada del programa.

   & ~i
   /+`<

Aquí, la /+reducción por adición, lo que significa que es simplemente una función de "suma esta lista". &compone esto en la función anterior, por lo que ahora tenemos una función unaria que cuenta cuántos valores en la entrada son más grandes que ese entero.

  && ~i
  >/+`<

También componemos la función de incremento sobre esto.

 `&& ~i
  >/+`<

Finalmente, también enhebramos esta función, para que se aplique automáticamente a cada entero de una lista que se le pase. Debido a la disposición del código, también ise toma como entrada de esta función, de modo que calcula la salida deseada.

p`&& ~i
  >/+`<

Finalmente, esto imprime el resultado.

brainfuck, 124 bytes

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

Formateado:

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

Esto está diseñado para implementaciones de brainfuck de 8 bits. La entrada y la salida son a través de valores de bytes .

Pruébalo en línea.

Para cada elemento, esto cuenta el número de elementos mayor que él, luego imprime el resultado más uno. Esto se logra incrementando todos los elementos hasta que el elemento actual sea igual a cero, actualizando el resultado cada vez que otro elemento se convierta en cero antes del elemento actual.

La cinta se divide en nodos de 4 celdas,

b c 0 0

donde cestá el elemento y bes un indicador de navegación que es negativo para el elemento actual, de lo contrario, uno.

El resultado y una copia del elemento actual se mantienen a la izquierda de la 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]+",");}}

Explicación:

Muy autoexplicativo.

Básicamente, para cada número entero en la matriz, comprueba cuántos son más grandes que él, luego imprime la nueva matriz con las clasificaciones.

Lo siento, esto no es muy conciso, pero es mi primer intento en uno de estos y no vi una entrada para Java. Estoy seguro de que se puede jugar más golf.

Se puede ejecutar simplemente haciendo referencia al método estático y pasando una matriz. No pensé que fuera necesario escribir la función principal, pero si es así, lo haré en el futuro.

PHP, 101 bytes

Debe haber algún camino más corto.

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

La función toma la entrada como una matriz de enteros, sobrescribe la variable de entrada con rangos como cadenas 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

Actualización: usando for lugar demap

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

Simplemente filtra cada valor más pequeño que el actual, cuenta la longitud de la lista e incrementa en uno.

Tcl , 54 bytes

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

Pruébalo en línea!

PHP, 84 bytes

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

Uso: Pase la función r su matriz de enteros y devolverá la matriz correspondiente de enteros clasificados.

Pasando las pruebas aquí.

Perl 5, 23 +2 (-ap)

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

Pruébalo en línea

K (oK) , 11 bytes

Solución:

1+(x@>x)?x:

Pruébalo en línea!

Ejemplos:

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

Explicación:

Busque la posición de la lista original en la lista ordenada, luego agregue una.

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