Dadas dos listas diferentes de enteros no negativos, devuelve la lista que tiene el máximo más alto (p [4, 2], [3, 3, 1] -> [4, 2]. Ej .).

Si ambos tienen el mismo máximo, devuelva la lista que contiene más instancias de este máximo (por ejemplo [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]).

Si, después de estas comparaciones, son iguales, haga la misma comparación pero con su siguiente elemento más alto (p [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1]. Ej .).

Si, después de todas estas comparaciones, todavía se consideran iguales, envíe la lista más larga (por ejemplo [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0]).

Haz tu código lo más corto posible.

Casos de prueba

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

eo_S

Pruébalo en línea

Explicación

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

Python 2 , 44 bytes

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

Pruébalo en línea!

Jalea , 4 bytes

NÞÞṪ

Pruébalo en línea!

Cómo funciona

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 bytes

import Data.Lists
argmax$sortOn(0-)

La entrada se toma como una lista de dos elementos, por ejemplo ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Encuentre el elemento en la lista de entrada que es el máximo después de ordenar negando los valores (es decir, orden descendente).

Limpio , 42 bytes

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

Pruébalo en línea!

JavaScript (ES7), 52 bytes

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

Este metodo funciona sin ordenar las matrices. En cambio, calcula la suma de 10,000 generada para los elementos de cada matriz. La suma más grande representa la matriz con la puntuación más alta. (Esta solución supone que ninguna matriz tiene más de 10,000 elementos).

Casos de prueba

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 bytes

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

Pruébalo en línea!

Python 2 , 79 bytes

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

Pruébalo en línea!

Ruby 149 bytes

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

Pruébalo en línea!

Casco , 3 bytes

►Ö_

Pruébalo en línea!

Este envío básicamente toma una lista de dos elementos de listas como entrada y recupera el máximo ( ►), ordenado por sus valores ordenados en orden descendente ( Ö_).

05AB1E , 5 bytes

Σ{R}θ

Pruébalo en línea!

JavaScript (ES6), 98 bytes

(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

gordena una copia de su parámetro en orden inverso (ya que sortmuta la matriz), mientras hrealiza recursivamente la comparación por elementos de las matrices.

Perl 6 , 17 bytes

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

Pruébalo ^{_{(Lambda Lambda Lambda)}}

• -* lambda que niega numéricamente la entrada
• *.sort(-*) lambda que usa que usa los resultados de aplicar eso para comparar elementos
• *.max(*.sort(-*)) lambda que encuentra el máximo de esos resultados y lo usa para determinar qué entrada devolver.

J, 20 bytes

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

Sin golf:

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

Esencialmente, la respuesta de Pyth, traducida de manera imprecisa en J.

Pruébalo en línea!