Vous obtenez une liste non vide d'entiers positifs, par exemple

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

Vous devez classer ces nombres en fonction de leur valeur, mais comme d'habitude dans les classements, s'il y a égalité, tous les nombres liés obtiennent le même rang et un nombre approprié de rangs est ignoré. Le résultat attendu pour la liste ci-dessus serait donc

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

Par exemple, la valeur la plus élevée dans l'entrée était 9, donc cela devient un 1(premier rang). La troisième valeur la plus élevée est 6, donc les deux 6s deviennent 3, et le rang 4est entièrement ignoré.

Règles

Vous pouvez utiliser n'importe quel format de liste plat pratique et sans ambiguïté pour l'entrée et la sortie. Le premier / plus petit rang dans la sortie doit toujours être 1 .

Vous pouvez écrire un programme ou une fonction et utiliser l'une de nos méthodes standard de réception d'entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

Il s'agit de code-golf , donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Cas de test

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

Solution de contournement dans Excel pour les règles stupides concernant les entrées de souris sur l'échange de pile de golf de code: (WESRRMICGSE) 28 octets

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

Entrez la liste en tant que csv ( 10,23,34,2,) dans le compilateur après avoir entré la source. pas de guillemets, pas de crochets, virgule de fin.

WESRRMICGSE est exactement comme la programmation dans Excel, sauf que vous pouvez omettre le signe '=' initial pour enregistrer un octet. La différence de fonctionnalité vient du fait que WESRRMICGSE fera glisser la formule vers le bas pour copier le code automatiquement et fournir différentes sorties fournies avec une seule entrée entière. fourni une liste en entrée, cette liste va dans la colonne B (colonne d'entrée), et la formule est automatiquement décomposée pour correspondre au nombre d'entrées. (par exemple: l'entrée 34,21,45 «ferait glisser» la formule vers le bas de 2 cellules, pour un total de 3 cellules avec la formule).

Edit: je ne m'attendais pas à ce que cette réponse soit populaire. Hou la la!

MATL , 4 octets

&<sQ

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

Python 2, 41 octets

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

Pour chaque valeur, recherchez son index dans la liste triée par ordre décroissant. Pour que la plus grande valeur donne 1 au lieu de 0, nous utilisons un élément supplémentaire "infini" de la liste elle-même, car Python 2 traite les listes comme plus grandes que les nombres.

Une solution plus directe est de 42 octets et fonctionne également en Python 3.

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

Pour chaque élément, compte le nombre d'éléments plus petits, en ajoutant 1 pour passer à 1 indexé.

Gelée , 5 octets

ṢṚiЀ

Essayez-le en ligne!

Comment ça marche

ṢṚ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 octets

Utilise la fonction de classement standard avec la méthode des liens "min" sur le vecteur nié. catajouté pour le sortir vers STDOUT. Un enregistré grâce à @Guiseppe

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

Exemple

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

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

Développé indépendamment, mais je vois que c'est le même algorithme que la solution Python @ xnor , donc / hausser les épaules.

Prend les entrées sous forme d'arguments de ligne de commande individuels (c'est-à-dire une liste séparée par des espaces). La sortie (formatage par défaut) est une nouvelle ligne entre les éléments.

Pour chaque élément de la liste d'entrée, il s'agit de sortla liste d'entrée dans l' -dordre croissant, prend l' .indexOf()élément en cours et ajoute 1. Notez le tableau explicite cast@(...) afin de prendre en compte une entrée à un chiffre. Les nombres résultants sont laissés sur le pipeline et la sortie est implicite.

Sauvegardé 2 octets grâce à @Matt!

Exemple

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

Octave, 15 octets

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

Port de ma réponse MATL à Octave. Il fonctionne également dans Matlab R2016b.

Le code définit une fonction anonyme. Pour l'appeler, affectez-le à une variable. Essayez-le chez Ideone .

JavaScript (ES6), 38 36 octets

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

Edit: sauvé 2 octets grâce à @ETHproductions.

Gelée , 5 octets

<S‘ð€

TryItOnline!

Comment?

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

Trouver le premier index :kdans une [R,]liste triée inversée

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

Comptez les valeurs plus grandes et ajoutez-en une

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

JavaScript, 87 49 octets

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)

^{Merci Conor O'Brien et ETHproductions!}

Mathematica, 44 octets 42 octets 40 octets

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

est le caractère à usage privé de 3 octets U+F4A1( page de documentation de Wolfram )

Edit: Merci à JHM pour les économies d'octets.

Pyke, 6 octets

FQS_@h

Essayez-le ici!

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

J , 14 8 octets

1+1#.</~

Comment?

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

Solution précédente

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

Haskell, 28 octets

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

Juste quelques listes de compréhension.

Wonder , 28 octets

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

Usage:

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

Mappez sur le tableau d'entrée avec une fonction qui ajoute 1 au premier index de l'élément dans une version triée décroissante de l'entrée.

Dyalog APL , 7 octets

⊢⍳⍨⍒⊃¨⊂

⊢ arguments'

⍳⍨ indices dans

⍒ les indices qui trieraient l'argument en ordre décroissant

⊃¨ chacun choisi

⊂ l'argument entier

TryAPL en ligne!

Mathematica, 37 octets

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

Une fonction pure qui classera son entrée, selon les règles du problème. 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}*)

Méduse , 15 octets

p`&& ~i
  >/+`<

Essayez-le en ligne!

Explication

Il ne semble pas encore y avoir un bon moyen de trouver l'index d'une valeur dans une liste dans Jellyfish, donc cela utilise l'approche de compter le nombre de valeurs plus grandes que la valeur actuelle et d'incrémenter le résultat. Cela se fait en grande partie en construisant une fonction unaire qui calcule cette valeur pour un élément donné.

     `<

Cela crée une version filetée de l'opérateur de comparaison, donc si vous lui donnez un entier et une liste, il renverra une liste de résultats de comparaison entre cet entier et chaque élément de la liste.

     ~i
     `<

Cela recense l'argument de droite de la fonction précédente avec la liste d'entrée. Le résultat est donc une fonction unaire qui prend un entier et vous donne la liste des résultats de comparaison avec l'entrée du programme.

   & ~i
   /+`<

Ici, /+c'est la réduction par addition, ce qui signifie que c'est simplement une fonction "additionner cette liste". &compose ceci sur la fonction précédente, nous avons donc maintenant une fonction unaire qui compte combien de valeurs dans l'entrée sont plus grandes que cet entier.

  && ~i
  >/+`<

Nous composons également la fonction d'incrémentation sur ceci.

 `&& ~i
  >/+`<

Enfin, nous enfilons également cette fonction, afin qu'elle soit automatiquement appliquée à chaque entier d'une liste qui lui est passée. En raison de la disposition du code, iil se trouve que l'entrée est également utilisée pour cette fonction, de sorte que cela calcule la sortie souhaitée.

p`&& ~i
  >/+`<

Enfin, cela imprime le résultat.

brainfuck, 124 octets

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

Formaté:

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

Ceci est conçu pour les implémentations brainfuck 8 bits. L'entrée et la sortie se font via des valeurs d'octets .

Essayez-le en ligne.

Pour chaque élément, cela compte le nombre d'éléments supérieur à celui-ci, puis imprime le résultat plus un. Ceci est accompli en incrémentant tous les éléments jusqu'à ce que l'élément actuel soit égal à zéro, en mettant à jour le résultat chaque fois qu'un autre élément devient nul avant l'élément actuel.

La bande est divisée en nœuds à 4 cellules,

b c 0 0

où c est l'élément et best un indicateur de navigation qui est négatif pour l'élément actuel, sinon un.

Le résultat et une copie de l'élément courant sont conservés à gauche du tableau.

Java, 215 octets

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]+",");}}

Explication:

Très explicite.

Fondamentalement, pour chaque entier du tableau, il vérifie combien sont plus grands que lui, puis imprime le nouveau tableau avec les classements.

Je suis désolé, ce n'est pas très concis, mais c'est mon premier essai sur l'un d'entre eux et je n'ai pas vu d'entrée pour Java. Je suis sûr qu'il peut être joué plus bas.

Il peut être exécuté simplement en faisant référence à la méthode statique et en passant un tableau. Je ne pensais pas qu'il était nécessaire d'écrire la fonction principale, mais si c'est le cas, je le ferai à l'avenir.

PHP, 101 octets

Il doit y avoir un moyen plus court.

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 fonction prend l'entrée comme un tableau d'entiers, écrase la variable d'entrée avec les rangs sous forme de chaînes numériques.

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

Rubis, 45 40 octets

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

Clojure, 48 44 octets

Mise à jour: utilisation forau lieu demap

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

Filtre simplement chaque valeur plus petite que la valeur actuelle, compte la longueur de la liste et incrémente d'une unité.

Tcl , 54 octets

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

Essayez-le en ligne!

PHP, 84 octets

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

Utilisation: transmettez la fonction r à votre tableau d'entiers et elle renverra le tableau correspondant d'entiers classés.

Passer les tests ici.

Perl 5, 23 +2 (-ap)

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

Essayez-le en ligne

K (oK) , 11 octets

Solution:

1+(x@>x)?x:

Essayez-le en ligne!

Exemples:

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

Explication:

Position de recherche de la liste d'origine dans la liste triée, puis ajoutez-en une.

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