Вам надається не порожній список натуральних чисел, наприклад

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

Введіть список як csv ( 10,23,34,2,) у компілятор після введення джерела. жодних лапок, без дужок, кома.

WESRRMICGSE так само, як програмування в excel, за винятком того, що ви можете опустити початковий знак '=', щоб зберегти байт. Різниця у функціональності пов'язана з тим, що WESRRMICGSE або перетягне формулу вниз, щоб автоматично скопіювати код і забезпечити різні виходи, забезпечені одним цілим числом. Якщо список є вхідним, цей список переходить до стовпця B (колонка введення), а формула автоматично знижується відповідно до кількості вхідних даних. (наприклад: вхід 34,21,45, "перетягне" формулу вниз на дві комірки, в цілому 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, ми використовуємо додатковий "нескінченний" елемент самого списку, оскільки 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 байт

Використовує стандартну функцію ранжування методом "min" зв'язків над запереченим вектором. 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}

Розроблено самостійно, але я бачу, що це той самий алгоритм, що і рішення Python @ xnor , так що / знизуйте плечима.

Вводить введення як окремі аргументи командного рядка (тобто список, розділений пробілом). Вихід (форматування за замовчуванням) - це новий рядок між елементами.

Для кожного елемента вхідного списку він sortвводить список в -dпорядку зростання, приймає .indexOf()поточний елемент і додає 1. Зверніть увагу на явний склад масиву @(...)для обліку одноцифрового введення. Отримані цифри залишаються на конвеєрі, а висновок неявний.

Збережено 2 байти завдяки @Matt!

Приклад

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)

Редагувати: збережено 2 байти завдяки @ETHproductions.

Желе , 5 байт

<S‘ð€

СпробуйтеItOnline!

Як?

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

Математика, 44 байти 42 байти 40 байт

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

є 3-байтним символом приватного використання U+F4A1( сторінка документів Wolfram )

Редагувати: Дякую JHM за економію байтів.

Пайк, 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 до першого індексу елемента у впорядкованій версії введення за спаданням.

Діалог APL , 7 байт

⊢⍳⍨⍒⊃¨⊂

⊢ аргументи '

⍳⍨ індекси в

⍒ індекси, які б сортували аргумент за убуванням

⊃¨ кожен з яких вибраний

⊂ весь аргумент

СпробуйтеAPAP онлайн!

Математика, 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
  >/+`<

Нарешті, це друкує результат.

мозковий ебать, 124 байти

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

Відформатовано:

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

Це розроблено для 8-бітних реалізацій brainfuck. Вхід і вихід здійснюється через значення байтів .

Спробуйте в Інтернеті.

Для кожного елемента при цьому підраховується кількість елементів, що перевищує його, потім виводиться результат плюс один. Це досягається збільшенням усіх елементів до тих пір, поки поточний елемент не дорівнює нулю, оновлення результату кожного разу, коли інший елемент стане нульовим перед поточним елементом.

Стрічка розбита на 4-елементні вузли,

b c 0 0

де cелемент іb навігаційний прапор, який є негативним для поточного елемента, інакше -.

Результат і копія поточного елемента зберігаються зліва від масиву.

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. Я впевнений, що можна побільшити більше.

Його можна запустити просто шляхом посилання на статичний метод і передача масиву. Я не вважав, що потрібно писати головну функцію, але якщо це так, я буду робити це в майбутньому.

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

Рубін, 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