您会得到一个非空的正整数列表，例如

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

您应该按其值对这些数字进行排名，但是在排行榜中通常如此，如果存在平局，则所有并列的数字都将获得相同的排名，而跳过适当的排名数。因此，以上列表的预期输出为

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

例如，输入中的最高值为9，因此这成为了1（第一等级）。第三高的值为6，因此都6变为3，并且排名4完全跳过。

规则

您可以使用任何方便，明确，平坦的列表格式进行输入和输出。输出中的第一/最小等级应始终为1。

您可以编写程序或函数，并使用我们的任何标准方法来接收输入和提供输出。

您可以使用任何编程语言，但是请注意，默认情况下，这些漏洞是禁止的。

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

测试用例

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

Excel中有关代码高尔夫堆栈交换上的鼠标输入的愚蠢规则的变通办法：（WESRRMICGSE） 28字节

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

输入10,23,34,2,源后，将列表作为csv（）输入到编译器中。没有引号，没有方括号，结尾逗号。

WESRRMICGSE与excel中的编程完全一样，不同之处在于您可以省略初始的'='符号以保存字节。功能上的差异来自于这样一个事实，即WESRRMICGSE要么将公式向下拖动以自动复制代码，然后为单个整数输入提供不同的输出。提供一个列表作为输入，该列表将进入B列（输入列），并且公式会自动降低药物含量以匹配输入数量。（例如：输入34、21、45将“拖动”公式到2个单元格中，总共3个单元格带有该公式）。

编辑：我没想到这个答案会很受欢迎。哇！

MATL，4个字节

&<sQ

在线尝试！或验证所有测试用例。

说明

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

Python 2，41个字节

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

对于每个值，请在列表中找到按降序排序的索引。为了使最大值给出1而不是0，我们使用列表本身的一个额外的“ infinity”元素，因为Python 2将列表视为大于数字。

更直接的解决方案是42个字节，并且也可以在Python 3中使用。

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

对于每个元素，计算较小元素的数量，加1即可转换为1索引。

果冻，5个字节

ṢṚiЀ

在线尝试！

怎么运行的

ṢṚ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字节

对负向量使用标准等级函数和“最小”联系方法。 cat添加以将其输出到STDOUT。感谢@Guiseppe保存了一个

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

例

> 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字节

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

是独立开发的，但我看到这与@xnor的Python解决方案（/ shrug）相同。

将输入作为单独的命令行参数（即，用空格分隔的列表）。输出（默认格式）是元素之间的换行符。

对于输入列表中的每个元素，它sort以-d升序排列为输入列表，获取.indexOf()当前元素，然后添加1。请注意显式数组强制转换@(...)，以说明一位数字输入。结果数字保留在管道上，并且输出是隐式的。

感谢@Matt，节省了2个字节！

例

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

八度，15字节

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

我的MATL答复端口至Octave。它也可以在Matlab R2016b中使用。

该代码定义了一个匿名函数。要调用它，请将其分配给变量。在Ideone尝试一下。

JavaScript（ES6），38 36字节

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

编辑：由于@ETHproductions，节省了2个字节。

果冻，5 个字节

<S‘ð€

TryItOnline！

怎么样？

<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个字节

:k在反向[R,]排序的列表中找到第一个索引

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

计算较大的值，然后加一个

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

JavaScript，87 49字节

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)

^{感谢Conor O'Brien和ETHproductions！}

Mathematica，44字节 42字节 40字节

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

是3个字节的私人使用字符U+F4A1（Wolfram docs页面）

编辑：感谢JHM节省了字节。

Pyke，6个字节

FQS_@h

在这里尝试！

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

J，14 8字节

1+1#.</~

怎么样？

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

先前的解决方案

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

Haskell，28个字节

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

只是一些列表理解。

不可思议，28个字节

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

用法：

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

在输入数组上映射，该函数将输入的降序版本中的第一个索引加1。

Dyalog APL，7 个字节

⊢⍳⍨⍒⊃¨⊂

⊢ 论点

⍳⍨ 索引

⍒ 将对参数降序排序的索引

⊃¨ 每个从

⊂ 整个论点

在线尝试APL！

Mathematica，37个字节

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

根据问题的规则，将对输入进行排序的纯函数。例如：

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

水母，15字节

p`&& ~i
  >/+`<

在线尝试！

说明

在水母中，似乎还没有找到在列表中找到值的索引的好方法，因此，该方法采用了计算比当前值大多少个值并递增结果的方法。这主要是通过构造一个为给定元素计算该值的一元函数来完成的。

     `<

这将创建比较运算符的线程版本，因此，如果给它一个整数和一个列表，它将返回该整数与列表中每个元素之间的比较结果的列表。

     ~i
     `<

这将使用输入列表来处理前一个函数的右手参数。因此，结果是一元函数，该函数采用整数，并通过程序输入为您提供比较结果列表。

   & ~i
   /+`<

在这里，/+是通过加法来减少的，这意味着它只是一个“将此列表求和”功能。&将其组合到上一个函数中，因此我们现在有了一个一元函数，该函数可以计算输入中有多少个值大于该整数。

  && ~i
  >/+`<

我们还可以在其上组成增量函数。

 `&& ~i
  >/+`<

最后，我们也对该函数进行线程化，以便将其自动应用于传递给它的列表的每个整数。由于代码的布局，i恰好也被当作该函数的输入，因此可以计算出所需的输出。

p`&& ~i
  >/+`<

最后，这将打印结果。

Brainfuck，124个字节

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

格式：

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

这是为8位Brainfuck实现而设计的。输入和输出通过字节值进行。

在线尝试。

对于每个元素，此操作都会计算大于该元素的元素数量，然后输出结果加一。这是通过递增所有元素直到当前元素等于零来实现的，只要在当前元素之前另一个元素变为零，就更新结果。

磁带分为4个单元，

b c 0 0

其中c是元素，b是一个导航标志，对于当前元素为负，否则为1。

结果和当前元素的副本保留在数组的左侧。

Java，215个字节

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

说明：

很自我解释。

基本上，对于数组中的每个整数，它都会检查比其大多少个整数，然后打印具有排名的新数组。

抱歉，这不是很简洁，但这是我第一次尝试其中的一种，但是我没有看到java的条目。我相信它可以打得更多。

只需引用静态方法并传递一个数组即可运行它。我认为没有必要编写main函数，但是如果是的话，我将来会这样做。

PHP，101字节

必须有一些更短的方法。

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=[1,2,4,2,2,3];f($a);print_r($a);

Ruby，45个 40字节

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

Clojure，48个 44字节

更新：使用for代替map

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

只需过滤每个小于当前值的值，对列表的长度进行计数并加一。

Tcl，54个字节

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

在线尝试！

PHP，84字节

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

用法：向您的整数数组传递函数r，它将返回相应的已排序整数数组。

在这里通过测试。

Perl 5、23 +2（-ap）

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

在线尝试

K（oK），11个字节

解：

1+(x@>x)?x:

在线尝试！

例子：

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

说明：

在排序列表中查找原始列表的位置，然后添加一个。

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