Sie erhalten eine nicht leere Liste mit positiven ganzen Zahlen, z

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

Sie sollten diese Zahlen nach ihrem Wert ordnen, aber wie in Ranglisten üblich, erhalten bei einem Gleichstand alle verbundenen Zahlen den gleichen Rang, und eine entsprechende Anzahl von Rängen wird übersprungen. Die erwartete Ausgabe für die obige Liste wäre daher

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

Beispielsweise war der höchste Wert in der Eingabe 9 , so dass dies ein 1(erster Rang) wird. Der dritthöchste Wert ist 6, so dass beide 6s worden 3, und der Rang 4ist komplett übersprungen.

Regeln

Sie können jedes bequeme, eindeutige, flache Listenformat für die Eingabe und Ausgabe verwenden. Der erste / kleinste Rang in der Ausgabe sollte immer 1 sein .

Du darfst schreiben a Programm oder eine Funktion unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede verwenden Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

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

Problemumgehung in Excel für dumme Regeln in Bezug auf Mauseingaben bei Code Golf Stack Exchange: (WESRRMICGSE) 28 Byte

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

Geben Sie die Liste als csv ( 10,23,34,2,) in den Compiler ein, nachdem Sie die Quelle eingegeben haben . Keine Anführungszeichen, keine eckigen Klammern, nachgestelltes Komma.

WESRRMICGSE entspricht genau der Programmierung in Excel, mit der Ausnahme, dass Sie das anfängliche Zeichen '=' weglassen können, um ein Byte zu speichern. Der Unterschied in der Funktionalität ergibt sich aus der Tatsache, dass WESRRMICGSE entweder die Formel nach unten zieht, um den Code automatisch zu kopieren und verschiedene Ausgaben mit einer einzelnen Ganzzahleingabe bereitzustellen. Wenn eine Liste als Eingabe bereitgestellt wird, wird diese Liste in die B-Spalte (Eingabespalte) verschoben, und die Formel wird automatisch abgesetzt, um der Anzahl der Eingaben zu entsprechen. (zB: die Eingabe 34,21,45 würde die Formel um 2 Zellen nach unten ziehen, für insgesamt 3 Zellen mit der Formel).

Edit: Ich hätte nie gedacht, dass diese Antwort populär wird. Wow!

MATL , 4 Bytes

&<sQ

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

&<   % 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)

Suchen Sie für jeden Wert den Index in der Liste, sortiert nach absteigender Reihenfolge. Damit der größte Wert 1 anstelle von 0 ergibt, verwenden wir ein zusätzliches "unendlich" -Element in der Liste selbst, da Python 2 Listen als größer als Zahlen behandelt.

Eine direktere Lösung ist 42 Bytes und funktioniert auch in Python 3.

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

Zählt für jedes Element die Anzahl der kleineren Elemente und addiert 1 zu 1-indiziert.

Gelee , 5 Bytes

ṢṚiЀ

Probieren Sie es online!

Wie es funktioniert

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

Verwendet die Standardrangfunktion mit der "min" -Bindungsmethode über dem negierten Vektor. cathinzugefügt, um es an STDOUT auszugeben. Danke an @Guiseppe

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

Beispiel

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

Unabhängig entwickelt, aber ich sehe, dass dies der gleiche Algorithmus wie bei @ xnor's ist Python-Lösung , also / achselzucken.

Nimmt Eingaben als einzelne Befehlszeilenargumente an (dh als durch Leerzeichen getrennte Liste). Ausgabe (Standardformatierung) ist eine neue Zeile zwischen Elementen.

Für jedes Element in der Eingabeliste ist es sortdie Eingabeliste in -dabsteigender Reihenfolge, nimmt .indexOf()das aktuelle Element und fügt hinzu1 . Beachten Sie die explizite Array-Umwandlung @(...), um eine einstellige Eingabe zu berücksichtigen. Die resultierenden Zahlen verbleiben in der Pipeline und die Ausgabe ist implizit.

2 Bytes gespart dank @Matt!

Beispiel

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

Oktave, 15 Bytes

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

Port meiner MATL-Antwort auf Octave. Es funktioniert auch in Matlab R2016b.

Der Code definiert eine anonyme Funktion. Um es aufzurufen, weisen Sie es einer Variablen zu. Probieren Sie es bei Ideone .

JavaScript (ES6), 38 36 Bytes

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

Bearbeiten: 2 Bytes dank @ETHproductions gespeichert.

Gelee , 5 Bytes

<S‘ð€

TryItOnline!

Wie?

<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

Suchen Sie den ersten Index :kin einer umgekehrt [R,]sortierten Liste

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

Zählen Sie die größeren Werte und addieren Sie einen

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

^{Vielen Dank an Conor O'Brien und ETHproductions!}

Mathematica, 44 Bytes 42 Bytes 40 Bytes

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

ist das 3-Byte-Zeichen für den privaten Gebrauch U+F4A1( Wolfram-Dokumentseite )

Edit: Danke an JHM für die Byteeinsparung.

Pyke, 6 Bytes

FQS_@h

Probieren Sie es hier aus!

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

Wie?

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

Vorherige Lösung

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

Haskell, 28 Bytes

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

Nur ein paar Listenverständnisse.

Wunder , 28 Bytes

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

Verwendung:

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

Ordnen Sie das Eingabearray mit einer Funktion zu, die dem ersten Index des Elements in einer absteigend sortierten Version der Eingabe eine 1 hinzufügt.

Dyalog APL , 7 Bytes

⊢⍳⍨⍒⊃¨⊂

⊢ Argumente'

⍳⍨ Indizes in

⍒ die Indizes, die das Argument absteigend sortieren würden

⊃¨ jeder wählte aus

⊂ das gesamte Argument

TryAPL online!

Mathematica, 37 Bytes

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

Eine reine Funktion, die ihre Eingabe nach den Regeln des Problems einstuft. 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}*)

Qualle , 15 Bytes

p`&& ~i
  >/+`<

Probieren Sie es online!

Erläuterung

Es scheint noch keine gute Möglichkeit zu geben, den Index eines Werts in einer Liste in Jellyfish zu finden. Daher wird der Ansatz verwendet, um zu zählen, wie viele Werte größer als der aktuelle Wert sind, und das Ergebnis zu erhöhen. Dies geschieht hauptsächlich durch die Konstruktion einer unären Funktion, die diesen Wert für ein bestimmtes Element berechnet.

     `<

Dadurch wird eine Thread-Version des Vergleichsoperators erstellt. Wenn Sie diesem also eine Ganzzahl und eine Liste zuweisen, wird eine Liste der Vergleichsergebnisse zwischen dieser Ganzzahl und jedem Element in der Liste zurückgegeben.

     ~i
     `<

Dies entspricht dem rechten Argument der vorherigen Funktion mit der Eingabeliste. Das Ergebnis ist also eine unäre Funktion, die eine ganze Zahl annimmt und Ihnen die Liste der Vergleichsergebnisse mit der Eingabe des Programms liefert.

   & ~i
   /+`<

Hier /+ist die Reduktion durch Addition, was bedeutet, dass es sich einfach um eine Funktion handelt, die diese Liste summiert. &setzt dies auf die vorherige Funktion auf, sodass wir jetzt eine unäre Funktion haben, die zählt, wie viele Werte in der Eingabe größer als diese ganze Zahl sind.

  && ~i
  >/+`<

Darauf setzen wir auch die Inkrementfunktion.

 `&& ~i
  >/+`<

Schließlich führen wir diese Funktion auch als Thread durch, sodass sie automatisch auf jede Ganzzahl einer an sie übergebenen Liste angewendet wird. Aufgrund des Layouts des Codes wird idies zufällig auch als Eingabe für diese Funktion verwendet, sodass die gewünschte Ausgabe berechnet wird.

p`&& ~i
  >/+`<

Abschließend wird das Ergebnis gedruckt.

Brainfuck, 124 Bytes

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

Formatiert:

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

Dies ist für 8-Bit-Brainfuck-Implementierungen vorgesehen. Ein- und Ausgabe erfolgen über Bytewerte .

Probieren Sie es online aus.

Für jedes Element zählt dies die Anzahl der Elemente, die größer sind, und gibt dann das Ergebnis plus eins aus. Dies wird erreicht, indem alle Elemente inkrementiert werden, bis das aktuelle Element gleich Null ist, und das Ergebnis aktualisiert wird, wenn ein anderes Element vor dem aktuellen Element zu Null wird.

Das Band ist in 4-Zellen-Knoten unterteilt.

b c 0 0

Dabei cist das Element und bein Navigationsflag, das für das aktuelle Element negativ ist, andernfalls eins.

Das Ergebnis und eine Kopie des aktuellen Elements werden links vom Array gespeichert.

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

Erläuterung:

Sehr selbsterklärend.

Grundsätzlich wird für jede Ganzzahl im Array überprüft, wie viele größer sind, und anschließend das neue Array mit den Rangfolgen gedruckt.

Es tut mir leid, dass dies nicht sehr präzise ist, aber es ist mein erster Versuch, und ich habe keinen Eintrag für Java gesehen. Ich bin mir sicher, dass man mehr Golf spielen kann.

Es kann nur ausgeführt werden, indem auf die statische Methode verwiesen und ein Array übergeben wird. Ich dachte nicht, dass es notwendig wäre, die Hauptfunktion zu schreiben, aber wenn ja, werde ich das in Zukunft tun.

PHP, 101 Bytes

Es muss einen kürzeren Weg geben.

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

Die Funktion verwendet die Eingabe als Ganzzahl-Array und überschreibt die Eingabevariable mit den Rängen als numerische Zeichenfolgen.

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

Ruby, 45 bis 40 Bytes

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

Clojure, 48 44 Bytes

Update: mit foranstelle vonmap

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

Filtert einfach jeden Wert, der kleiner als der aktuelle ist, zählt die Länge der Liste und erhöht sich um eins.

Tcl , 54 Bytes

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

Probieren Sie es online!

PHP, 84 Bytes

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

Verwendung: Übergeben Sie die Funktion für Ihr Array von Ganzzahlen und es wird das entsprechende Array von geordneten Ganzzahlen zurückgegeben.

Tests hier bestehen.

Perl 5, 23 + 2 (-ap)

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

Probieren Sie es online aus

K (oK) , 11 Bytes

Lösung:

1+(x@>x)?x:

Probieren Sie es online!

Beispiele:

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

Erläuterung:

Suchen Sie die Position der ursprünglichen Liste in der sortierten Liste und fügen Sie eine hinzu.

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