З огляду на два різні списки невід’ємних цілих чисел, поверніть список, який має найбільший максимум (наприклад [4, 2], [3, 3, 1] -> [4, 2]).

Якщо вони мають однаковий максимум, поверніть список, який містить більше примірників цього максимуму (наприклад [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]).

Якщо після цих порівнянь вони рівні, зробіть те саме порівняння, але зі своїм наступним найвищим пунктом (наприклад [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1]).

Якщо після цих порівнянь вони все-таки вважаються рівними, виведіть довший список (наприклад [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0]).

Зробіть свій код якомога коротшим.

Випробування

[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 байти

eo_S

Спробуйте в Інтернеті

Пояснення

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

Python 2 , 44 байти

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

Спробуйте в Інтернеті!

Желе , 4 байти

NÞÞṪ

Спробуйте в Інтернеті!

Як це працює

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 байт

import Data.Lists
argmax$sortOn(0-)

Вхід приймається як список двох елементів, наприклад ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Знайдіть елемент у списку входів, який є максимальним після сортування, відкинувши значення (тобто порядок зменшення).

Чисто , 42 байти

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

Спробуйте в Інтернеті!

JavaScript (ES7), 52 байти

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

Цей метод працює без сортування масивів. Натомість він обчислює суму 10 000, підняту для елементів кожного масиву. Найбільша сума являє собою масив з найвищим балом. (Це рішення передбачає, що жоден масив не містить більше 10000 елементів.)

Тестові справи

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]

Рубін , 33 байти

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

Спробуйте в Інтернеті!

Python 2 , 79 байт

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

Спробуйте в Інтернеті!

Ruby 149 байт

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

Спробуйте в Інтернеті!

Лушпиння , 3 байти

►Ö_

Спробуйте в Інтернеті!

Це подання в основному приймає двоелементний список списків як вхідний і отримує максимум ( ►), відсортований за їх значеннями, відсортованим у порядку зменшення ( Ö_).

05AB1E , 5 байт

Σ{R}θ

Спробуйте в Інтернеті!

JavaScript (ES6), 98 байт

(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

gсортує копію свого параметра у зворотному порядку (оскільки sortмутує масив), при цьому hрекурсивно виконує елементне порівняння масивів.

Perl 6 , 17 байт

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

Перевірте його ^{_{(Lambda Lambda Lambda)}}

• -* лямбда, яка чисельно заперечує вхід
• *.sort(-*) лямбда, яка використовує, що використовує результати застосування, щоб порівняти елементи
• *.max(*.sort(-*)) лямбда, яка знаходить максимум цих результатів, і використовує це, щоб визначити, який вхід повернути.

J, 20 байт

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

Безголівки:

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

По суті, відповідь Піта, переказана недоброзичливо на Дж.

Спробуйте в Інтернеті!