Ti viene dato un elenco non vuoto di numeri interi positivi, ad es

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

Dovresti classificare questi numeri in base al loro valore, ma come al solito nelle classifiche, se c'è un pareggio, tutti i numeri in parità ottengono lo stesso valore e viene saltato un numero appropriato di gradi. L'output previsto per l'elenco sopra sarebbe quindi

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

Ad esempio, il valore più alto nell'input era 9, quindi questo diventa un 1(primo rango). Il terzo valore più alto è 6, quindi entrambi 6diventano 3, e il grado 4viene saltato del tutto.

Regole

È possibile utilizzare qualsiasi formato elenco semplice, chiaro e non ambiguo per input e output. Il primo / più piccolo rango nell'output dovrebbe essere sempre 1 .

È possibile scrivere un programma o una funzione e utilizzare uno qualsiasi dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

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

Soluzione alternativa in Excel per le regole stupide relative agli input del mouse sullo scambio di stack di code di codice: (WESRRMICGSE) 28 byte

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

Inserisci l'elenco come csv ( 10,23,34,2,) nel compilatore dopo aver inserito la fonte. senza virgolette, senza parentesi, virgola finale.

WESRRMICGSE è esattamente come la programmazione in Excel, tranne che è possibile omettere il segno '=' iniziale per salvare un byte. La differenza di funzionalità deriva dal fatto che WESRRMICGSE trascinerà la formula verso il basso per copiare automaticamente il codice e fornire output diversi forniti con un singolo input intero. fornito un elenco come input, tale elenco viene inserito nella colonna B (colonna di input) e la formula viene ridotta automaticamente per corrispondere al numero di input. (es: l'ingresso 34,21,45, "trascinerebbe" la formula verso il basso di 2 celle, per un totale di 3 celle con la formula).

Modifica: non mi sarei mai aspettato che questa risposta fosse popolare. Wow!

MATL , 4 byte

&<sQ

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

Per ogni valore, trova il suo indice nell'elenco ordinato in ordine decrescente. Per fare in modo che il valore più grande dia 1 invece di 0, usiamo un ulteriore elemento "infinito" dell'elenco stesso, poiché Python 2 considera gli elenchi più grandi dei numeri.

Una soluzione più diretta è di 42 byte e funziona anche in Python 3.

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

Per ogni elemento, conta il numero di elementi più piccoli, aggiungendo 1 per passare a 1 indicizzato.

Gelatina , 5 byte

ṢṚiЀ

Provalo online!

Come funziona

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

Utilizza la funzione di classificazione standard con il metodo dei legami "min" sul vettore negato. cataggiunto per inviarlo a STDOUT. Ne ho salvato uno grazie a @Guiseppe

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

Esempio

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

Sviluppato in modo indipendente, ma vedo che questo è lo stesso algoritmo della soluzione Python di @ xnor , quindi / scrollata di spalle.

Accetta input come singoli argomenti della riga di comando (ovvero un elenco separato da spazi). L'output (formattazione predefinita) è una nuova riga tra gli elementi.

Per ogni elemento nell'elenco di input, è sortl'elenco di input in -dordine crescente, prende l' .indexOf()elemento corrente e aggiunge 1. Nota il cast di array esplicito @(...)per tenere conto di un input a una cifra. I numeri risultanti vengono lasciati sulla pipeline e l'output è implicito.

Salvato 2 byte grazie a @Matt!

Esempio

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

Ottava, 15 byte

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

Porta della mia risposta MATL a Octave. Funziona anche in Matlab R2016b.

Il codice definisce una funzione anonima. Per chiamarlo, assegnarlo a una variabile. Provalo su Ideone .

JavaScript (ES6), 38 36 byte

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

Modifica: salvato 2 byte grazie a @ETHproductions.

Gelatina , 5 byte

<S‘ð€

TryItOnline!

Come?

<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

Trova il primo indice :kin un [R,]elenco ordinato invertito

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

Contare i valori più grandi e aggiungerne uno

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

^{Grazie Conor O'Brien e ETHproductions!}

Mathematica, 44 byte 42 byte 40 byte

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

è il carattere di uso privato a 3 byte U+F4A1( pagina dei documenti di Wolfram )

Modifica: grazie a JHM per il risparmio di byte.

Pyke, 6 byte

FQS_@h

Provalo qui!

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

Come?

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

Soluzione precedente

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

Haskell, 28 byte

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

Solo alcune comprensioni dell'elenco.

Meraviglia , 28 byte

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

Uso:

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

Mappa su array di input con una funzione che aggiunge 1 al primo indice dell'elemento in una versione in ordine decrescente dell'input.

Dyalog APL , 7 byte

⊢⍳⍨⍒⊃¨⊂

⊢ argomenti'

⍳⍨ indici in

⍒ gli indici che ordinerebbero l'argomento discendente

⊃¨ ognuno scelto da

⊂ l'intero argomento

ProvaAPL online!

Mathematica, 37 byte

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

Una funzione pura che classificherà il suo input, secondo le regole del problema. 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}*)

Meduse , 15 byte

p`&& ~i
  >/+`<

Provalo online!

Spiegazione

Non sembra esserci un buon modo per trovare l'indice di un valore in un elenco in Jellyfish, quindi questo utilizza l'approccio del conteggio di quanti valori sono più grandi di quello attuale e incrementando il risultato. Ciò viene in gran parte realizzato costruendo una funzione unaria che calcola questo valore per un dato elemento.

     `<

Ciò crea una versione thread dell'operatore di confronto, quindi se si assegna a questo un numero intero e un elenco, verrà restituito un elenco di risultati del confronto tra tale numero intero e ciascun elemento nell'elenco.

     ~i
     `<

Ciò elimina l'argomento di destra della funzione precedente con l'elenco di input. Quindi il risultato è una funzione unaria che accetta un numero intero e ti dà la lista dei risultati del confronto con l'input del programma.

   & ~i
   /+`<

Qui, /+c'è la riduzione per addizione, il che significa che è semplicemente una funzione "somma questa lista". &compone questo nella funzione precedente, quindi ora abbiamo una funzione unaria che conta quanti valori nell'input sono più grandi di quel numero intero.

  && ~i
  >/+`<

Componiamo anche la funzione di incremento su questo.

 `&& ~i
  >/+`<

Infine, eseguiamo anche il thread di questa funzione, in modo che venga automaticamente applicata a ciascun numero intero di un elenco passato ad esso. A causa del layout del codice, isembra essere preso anche come input di questa funzione, in modo che questo calcoli l'output desiderato.

p`&& ~i
  >/+`<

Alla fine, questo stampa il risultato.

Brainfuck, 124 byte

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

formattato:

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

Questo è progettato per implementazioni brainfuck a 8 bit. Ingresso e uscita sono tramite valori byte .

Provalo online.

Per ogni elemento, questo conta il numero di elementi maggiore di esso, quindi stampa il risultato più uno. Ciò si ottiene incrementando tutti gli elementi fino a quando l'elemento corrente è uguale a zero, aggiornando il risultato ogni volta che un altro elemento diventa zero prima dell'elemento corrente.

Il nastro è suddiviso in nodi a 4 celle,

b c 0 0

dove cè l'elemento ed bè un flag di navigazione che è negativo per l'elemento corrente, altrimenti uno.

Il risultato e una copia dell'elemento corrente vengono mantenuti a sinistra dell'array.

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

Spiegazione:

Molto esplicativo.

Fondamentalmente per ogni numero intero nell'array controlla quanti sono più grandi di esso, quindi stampa il nuovo array con le classifiche.

Mi dispiace che non sia molto conciso, ma è il mio primo tentativo in uno di questi e non ho visto una voce per Java. Sono sicuro che si può giocare di più.

Può essere eseguito semplicemente facendo riferimento al metodo statico e passando un array. Non pensavo fosse necessario scrivere la funzione principale, ma se lo è lo farò in futuro.

PHP, 101 byte

Deve esserci un modo più breve.

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 funzione accetta l'input come array di numeri interi, sovrascrive la variabile di input con i ranghi come stringhe numeriche.

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

Rubino, 45 40 byte

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

Clojure, 48 44 byte

Aggiornamento: usando forinvece dimap

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

Filtra semplicemente ogni valore più piccolo di quello corrente, conta la lunghezza della lista e incrementa di uno.

Tcl , 54 byte

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

Provalo online!

PHP, 84 byte

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

Utilizzo: passa la funzione al tuo array di numeri interi e restituirà l'array corrispondente di numeri interi classificati.

Passando i test qui.

Perl 5, 23 +2 (-ap)

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

Provalo online

K (oK) , 11 byte

Soluzione:

1+(x@>x)?x:

Provalo online!

Esempi:

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

Spiegazione:

Cerca la posizione dell'elenco originale nell'elenco ordinato, quindi aggiungine uno.

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