Bạn được cung cấp một danh sách các số nguyên dương không trống, ví dụ:

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

Bạn nên xếp hạng các số này theo giá trị của chúng, nhưng như thường lệ trong bảng xếp hạng, nếu có một ràng buộc thì tất cả các số bị ràng buộc sẽ có cùng một thứ hạng và một số thứ hạng thích hợp sẽ bị bỏ qua. Do đó, đầu ra dự kiến ​​cho danh sách trên sẽ là

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

Ví dụ: giá trị cao nhất trong đầu vào là 9, vì vậy giá trị này trở thành 1(thứ hạng đầu tiên). Giá trị cao thứ ba là 6, vì vậy cả hai đều 6trở thành 3và thứ hạng 4bị bỏ qua hoàn toàn.

Quy tắc

Bạn có thể sử dụng bất kỳ định dạng danh sách phẳng, thuận tiện, rõ ràng cho đầu vào và đầu ra. Thứ hạng đầu tiên / nhỏ nhất trong đầu ra phải luôn là 1 .

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Các trường hợp thử nghiệm

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

Giải pháp thay thế trong Excel cho các quy tắc ngớ ngẩn liên quan đến đầu vào của chuột trên trao đổi ngăn xếp mã Golf: (WESRRMICGSE) 28 byte

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

Nhập danh sách dưới dạng csv ( 10,23,34,2,) vào trình biên dịch sau khi nhập nguồn. không dấu ngoặc kép, không dấu ngoặc, dấu phẩy.

WESRRMICGSE hoàn toàn giống như lập trình trong excel, ngoại trừ bạn có thể bỏ qua dấu '=' ban đầu để lưu một byte. Sự khác biệt về chức năng xuất phát từ việc WESRRMICGSE sẽ kéo công thức xuống để sao chép mã tự động và cung cấp các đầu ra khác nhau được cung cấp với một đầu vào số nguyên. được cung cấp một danh sách làm đầu vào, danh sách đó sẽ đi vào cột B (cột đầu vào) và công thức được tự động giảm xuống để phù hợp với số lượng đầu vào. (ví dụ: đầu vào 34,21,45, sẽ 'kéo' công thức xuống 2 ô, với tổng số 3 ô có công thức).

Chỉnh sửa: Tôi không bao giờ mong đợi câu trả lời này là phổ biến. Ồ

MATL , 4 byte

&<sQ

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

Python 2, 41 byte

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

Đối với mỗi giá trị, tìm chỉ mục của nó trong danh sách được sắp xếp theo thứ tự giảm dần. Để tạo giá trị lớn nhất cho 1 thay vì 0, chúng tôi sử dụng phần tử "vô cực" bổ sung của chính danh sách, vì Python 2 coi danh sách lớn hơn số.

Một giải pháp trực tiếp hơn là 42 byte và cũng hoạt động trong Python 3.

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

Đối với mỗi phần tử, hãy đếm số lượng phần tử nhỏ hơn, thêm 1 để chuyển sang 1 chỉ mục.

Thạch , 5 byte

ṢṚiЀ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Sử dụng hàm xếp hạng tiêu chuẩn với phương thức quan hệ "tối thiểu" trên vectơ phủ định. catđược thêm vào để xuất nó vào STDOUT. Đã lưu một lời cảm ơn đến @Guiseppe

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

Thí dụ

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

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

Được phát triển độc lập, nhưng tôi thấy rằng đây là thuật toán tương tự như giải pháp Python của @ xnor , vì vậy / nhún vai.

Đưa đầu vào dưới dạng đối số dòng lệnh riêng lẻ (nghĩa là danh sách được phân tách bằng dấu cách). Đầu ra (định dạng mặc định) là một dòng mới giữa các yếu tố.

Đối với mỗi phần tử trong danh sách đầu vào, nó sortlà danh sách đầu vào theo -dthứ tự tăng dần, lấy .indexOf()phần tử hiện tại và thêm vào 1. Lưu ý các mảng rõ ràng được đúc @(...)để tính toán cho một đầu vào một chữ số. Các số kết quả được để lại trên đường ống và đầu ra là ẩn.

Đã lưu 2 byte nhờ @Matt!

Thí dụ

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 byte

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

Cổng câu trả lời MATL của tôi cho Octave. Nó cũng hoạt động trong Matlab R2016b.

Mã xác định một chức năng ẩn danh. Để gọi nó, gán nó cho một biến. Hãy thử nó tại Ideone .

JavaScript (ES6), 38 36 byte

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

Chỉnh sửa: Đã lưu 2 byte nhờ @ETHproductions.

Thạch , 5 byte

<S‘ð€

Dùng thử trực tuyến!

Làm sao?

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

Tìm chỉ mục đầu tiên :ktrong [R,]danh sách được sắp xếp đảo ngược

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

Đếm các giá trị lớn hơn và thêm một giá trị

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

JavaScript, 87 49 byte

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)

^{Cảm ơn Conor O'Brien và ETHproductions!}

Mathicala, 44 byte 42 byte 40 byte

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

là ký tự sử dụng riêng 3 byte U+F4A1( trang tài liệu Wolfram )

Chỉnh sửa: Cảm ơn JHM vì đã tiết kiệm byte.

Pyke, 6 byte

FQS_@h

Hãy thử nó ở đây!

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

J , 14 8 byte

1+1#.</~

Làm sao?

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

Giải pháp trước

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

Haskell, 28 byte

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

Chỉ cần một số danh sách hiểu.

Kỳ quan , 28 byte

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

Sử dụng:

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

Ánh xạ qua mảng đầu vào với chức năng thêm 1 vào chỉ mục đầu tiên của mục trong phiên bản sắp xếp giảm dần của đầu vào.

APL Dyalog , 7 byte

⊢⍳⍨⍒⊃¨⊂

⊢ lập luận'

⍳⍨ chỉ số trong

⍒ các chỉ số sẽ sắp xếp đối số giảm dần

⊃¨ từng được chọn từ

⊂ toàn bộ lập luận

Dùng thử trực tuyến!

Toán học, 37 byte

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

Một hàm thuần túy sẽ xếp hạng đầu vào của nó, theo quy tắc của vấn đề. Vd

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

Sứa , 15 byte

p`&& ~i
  >/+`<

Hãy thử trực tuyến!

Giải trình

Dường như không có cách nào tốt để tìm chỉ số của một giá trị trong danh sách trong Jellyfish, vì vậy cách này sử dụng phương pháp đếm xem có bao nhiêu giá trị lớn hơn giá trị hiện tại và tăng kết quả. Điều này phần lớn được thực hiện bằng cách xây dựng một hàm unary tính toán giá trị này cho một phần tử nhất định.

     `<

Điều này tạo ra một phiên bản luồng của toán tử so sánh, vì vậy nếu bạn đưa ra số nguyên này và một danh sách, nó sẽ trả về một danh sách kết quả so sánh giữa số nguyên đó và từng phần tử trong danh sách.

     ~i
     `<

Điều này tạo ra đối số bên phải của hàm trước với danh sách đầu vào. Vì vậy, kết quả là một hàm unary lấy một số nguyên và cung cấp cho bạn danh sách kết quả so sánh với đầu vào của chương trình.

   & ~i
   /+`<

Ở đây, /+là giảm bằng cách thêm, có nghĩa là nó chỉ đơn giản là một hàm "tổng hợp danh sách này". &kết hợp điều này với hàm trước đó, vì vậy bây giờ chúng ta có một hàm unary đếm xem có bao nhiêu giá trị trong đầu vào lớn hơn số nguyên đó.

  && ~i
  >/+`<

Chúng tôi cũng soạn hàm tăng lên này.

 `&& ~i
  >/+`<

Cuối cùng, chúng tôi cũng xử lý chức năng này để nó tự động được áp dụng cho từng số nguyên của danh sách được truyền cho nó. Do cách bố trí mã, cũng iđược lấy làm đầu vào của hàm này, do đó, điều này sẽ tính toán đầu ra mong muốn.

p`&& ~i
  >/+`<

Cuối cùng, điều này in kết quả.

Brainfuck, 124 byte

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

Định dạng:

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

Điều này được thiết kế để thực hiện brainfuck 8 bit. Đầu vào và đầu ra thông qua các giá trị byte .

Hãy thử trực tuyến.

Đối với mỗi phần tử, phần tử này sẽ đếm số phần tử lớn hơn nó, sau đó in kết quả cộng với một phần tử. Điều này được thực hiện bằng cách tăng tất cả các phần tử cho đến khi phần tử hiện tại bằng 0, cập nhật kết quả bất cứ khi nào phần tử khác trở thành số 0 trước phần tử hiện tại.

Băng được chia thành các nút 4 ô,

b c 0 0

trong đó clà phần tử và blà cờ điều hướng là phần tử âm cho phần tử hiện tại, nếu không thì là phần tử.

Kết quả và một bản sao của phần tử hiện tại được giữ ở bên trái của mảng.

Java, 215 byte

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

Giải trình:

Rất tự giải thích.

Về cơ bản đối với mỗi số nguyên trong mảng, nó kiểm tra có bao nhiêu số lớn hơn nó, sau đó in mảng mới với bảng xếp hạng.

Tôi xin lỗi điều này không ngắn gọn lắm nhưng đây là lần thử đầu tiên của tôi tại một trong những điều này và tôi đã không thấy một mục nào cho java. Tôi chắc chắn rằng nó có thể được chơi golf nhiều hơn.

Nó có thể được chạy chỉ bằng cách tham chiếu đến phương thức tĩnh và truyền một mảng. Tôi đã không nghĩ rằng nó là cần thiết để viết chức năng chính nhưng nếu đó là tôi sẽ làm điều đó trong tương lai.

PHP, 101 byte

Phải có một số cách ngắn hơn.

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

Hàm lấy đầu vào là mảng số nguyên, ghi đè biến đầu vào với các cấp bậc dưới dạng chuỗi số.

Sử dụng: $a=[1,2,4,2,2,3];f($a);print_r($a);

Ruby, 45 40 byte

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

Clojure, 48 44 byte

Cập nhật: sử dụng forthay vìmap

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

Đơn giản chỉ cần lọc từng giá trị nhỏ hơn giá trị hiện tại, đếm độ dài của danh sách và tăng thêm một.

Tcl , 54 byte

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

Hãy thử trực tuyến!

PHP, 84 byte

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

Cách sử dụng: Truyền hàm r mảng số nguyên của bạn và nó sẽ trả về mảng tương ứng của các số nguyên được xếp hạng.

Vượt qua các bài kiểm tra ở đây.

Perl 5, 23 +2 (-ap)

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

Dùng thử trực tuyến

K (oK) , 11 byte

Dung dịch:

1+(x@>x)?x:

Hãy thử trực tuyến!

Ví dụ:

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

Giải trình:

Vị trí tra cứu của danh sách gốc trong danh sách được sắp xếp, sau đó thêm một.

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