Étant donné deux listes différentes d'entiers non négatifs, renvoyez la liste qui a le maximum le plus élevé (par exemple [4, 2], [3, 3, 1] -> [4, 2]).

S'ils ont tous les deux le même maximum, renvoyez la liste qui contient plus d'instances de ce maximum (par exemple [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]).

Si, après ces comparaisons, elles sont égales, faites la même comparaison mais avec leur prochain élément le plus élevé (par exemple [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1]).

Si, après toutes ces comparaisons, elles sont toujours considérées comme égales, affichez la liste la plus longue (par exemple [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0]).

Faites votre code aussi court que possible.

Cas de 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 octets

eo_S

Essayez-le en ligne

Explication

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

Python 2 , 44 octets

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

Essayez-le en ligne!

Gelée , 4 octets

NÞÞṪ

Essayez-le en ligne!

Comment ça fonctionne

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 octets

import Data.Lists
argmax$sortOn(0-)

L'entrée est considérée comme une liste à deux éléments, par exemple ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Trouvez l'élément dans la liste d'entrée qui est le maximum après le tri en annulant les valeurs (c'est-à-dire l'ordre décroissant).

Nettoyer , 42 octets

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

Essayez-le en ligne!

JavaScript (ES7), 52 octets

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

Cette méthode fonctionne sans trier les tableaux. Au lieu de cela, il calcule la somme de 10 000 élevée aux éléments de chaque tableau. La plus grande somme représente le tableau avec le score le plus élevé. (Cette solution suppose qu'aucun des tableaux ne contient plus de 10 000 éléments.)

Cas de 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]

Ruby , 33 octets

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

Essayez-le en ligne!

Python 2 , 79 octets

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

Essayez-le en ligne!

Rubis 149 octets

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

Essayez-le en ligne!

Husk , 3 octets

►Ö_

Essayez-le en ligne!

Cette soumission prend essentiellement une liste de listes à deux éléments en entrée et récupère le maximum ( ►), trié par ses valeurs triées dans l'ordre décroissant ( Ö_).

05AB1E , 5 octets

Σ{R}θ

Essayez-le en ligne!

JavaScript (ES6), 98 octets

(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

gtrie une copie de son paramètre dans l'ordre inverse (car sortmute le tableau), tout en heffectuant récursivement la comparaison élément par élément des tableaux.

Perl 6 , 17 octets

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

Testez-le ^{_{(Lambda Lambda Lambda)}}

• -* lambda qui nie numériquement l'entrée
• *.sort(-*) lambda qui utilise qui utilise les résultats de l'application pour comparer les éléments
• *.max(*.sort(-*)) lambda qui trouve le maximum de ces résultats et l'utilise pour déterminer quelle entrée renvoyer.

J, 20 octets

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

Non golfé:

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

Essentiellement, la réponse Pyth, traduite sans équivoque en J.

Essayez-le en ligne!