Dati due diversi elenchi di numeri interi non negativi, restituisce l'elenco che ha il massimo più alto (ad es [4, 2], [3, 3, 1] -> [4, 2].).

Se entrambi hanno lo stesso massimo, restituisce l'elenco che contiene più istanze di questo massimo (ad es [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4].).

Se, dopo questi confronti, sono uguali, fai lo stesso confronto ma con l'elemento successivo più alto (ad es [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1].).

Se, dopo tutti questi confronti, sono ancora considerati uguali, visualizza l'elenco più lungo (ad es [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0].).

Rendi il tuo codice il più breve possibile.

Casi test

[4, 4, 4, 4, 2, 4], [4, 4, 4, 4, 3, 2] -> [4, 4, 4, 4, 2, 4]
[0], [] -> [0]
[0, 0], [0] -> [0, 0]
[1], [0, 0] -> [1]
[4, 4, 4, 4, 4, 2], [4, 4, 4, 4, 4] -> [4, 4, 4, 4, 4, 2]
[1, 0], [0, 0, 0] -> [1, 0]

Pyth, 4 byte

eo_S

Provalo online

Spiegazione

eo_S
 o  NQ    Order the inputs...
  _S      ... by their reversed sorted values...
e         ... and take the last.

Python 2 , 44 byte

lambda*x:max(x,key=lambda y:sorted(y)[::-1])

Provalo online!

Gelatina , 4 byte

NÞÞṪ

Provalo online!

Come funziona

NÞÞṪ  Main link. Argument: [u, v] (pair of vectors)

  Þ   Sort [u, v], using the link to the left as key.
NÞ      Sort u (or v) by the negatives of its values.
        This sorts the vector in descending order.
   Ṫ  Tail; select the last, lexicographically larger vector.

Haskell, 37 35 byte

import Data.Lists
argmax$sortOn(0-)

L'input viene preso come un elenco di due elementi, ad es ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Trova l'elemento nella lista di input che è il massimo dopo l'ordinamento negando i valori (cioè l'ordine decrescente).

Pulito , 42 byte

import StdEnv
s=sortBy(>)
?a b|s a>s b=a=b

Provalo online!

JavaScript (ES7), 52 byte

(a,b,m=d=>d.map(n=>N+=1e4**n,N=0)&&N)=>m(a)>m(b)?a:b

Questo metodo funziona senza ordinare le matrici. Invece, calcola la somma di 10.000 raccolti per gli elementi di ciascun array. La somma più grande rappresenta l'array con il punteggio più alto. (Questa soluzione presuppone che nessuno dei due array abbia più di 10.000 elementi.)

Casi test

let f=

(a,b,m=d=>d.map(n=>N+=1e4**n,N=0)&&N)=>m(a)>m(b)?a:b


console.log(JSON.stringify(f([4, 4, 4, 4, 2, 4], [4, 4, 4, 4, 3, 2]))); // [4, 4, 4, 4, 2, 4]
console.log(JSON.stringify(f([0], []))); // [0]
console.log(JSON.stringify(f([0, 0], [0]))); // [0, 0]
console.log(JSON.stringify(f([1], [0, 0]))); // [1]
console.log(JSON.stringify(f([4, 4, 4, 4, 4, 2], [4, 4, 4, 4, 4]))); // [4, 4, 4, 4, 4, 2]
console.log(JSON.stringify(f([1, 0], [0, 0, 0]))); // [1, 0]
console.log(JSON.stringify(f([3], [11]))); // [11]
console.log(JSON.stringify(f([4, 3, 3, 3, 1, 3], [4, 2, 4]))); // [4, 2, 4]
console.log(JSON.stringify(f([3,3],[3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]))); //[3, 3]

Rubino , 33 byte

->*a{a.max_by{|x|x.sort.reverse}}

Provalo online!

Python 2 , 79 byte

lambda*a:max(a,key=lambda l:sum(zip(map(l.count,s(l)),s(l)),())[::-1])
s=sorted

Provalo online!

Rubino 149 byte

->n,m{(n+m).sort.reverse.map{|i|r=((a=n.index(i))&&m.index(i)?(b=n.count(i))==(c=m.count(i))?nil:b>c ?n:m:a ?n:m);return r if r};n.size>m.size ? n:m}

Provalo online!

Buccia , 3 byte

►Ö_

Provalo online!

Questa presentazione prende sostanzialmente un elenco di liste di due elementi come input e recupera il massimo ( ►), ordinato in base ai loro valori ordinati in ordine decrescente ( Ö_).

05AB1E , 5 byte

Σ{R}θ

Provalo online!

JavaScript (ES6), 98 byte

(a,b,g=a=>[...a].sort((a,b)=>b-a),h=([a,...b],[c,...d])=>a==c?h(b,d):a<c|!(1/a))=>h(g(a),g(b))?b:a

gordina una copia del suo parametro in ordine inverso (poiché sortmuta l'array), mentre hricorsivamente esegue il confronto elementwise degli array.

Perl 6 , 17 byte

*.max(*.sort(-*))

Provalo ^{_{(Lambda Lambda Lambda)}}

• -* lambda che nega numericamente l'input
• *.sort(-*) lambda che utilizza che utilizza i risultati dell'applicazione per confrontare gli elementi
• *.max(*.sort(-*)) lambda che trova il massimo di tali risultati e lo utilizza per determinare quale input restituire.

J, 20 byte

[:{.]\:[:#.[:>\:~&.>

Ungolfed:

[: {. ] \: [: #. [: > \:~&.>

Essenzialmente la risposta di Pyth, tradotta senza motivo in J.

Provalo online!