Diberikan dua yang berbeda daftar bilangan bulat non-negatif, kembali daftar yang memiliki maksimum tertinggi (misalnya [4, 2], [3, 3, 1] -> [4, 2]).

Jika keduanya memiliki maksimum yang sama, kembalikan daftar yang berisi lebih banyak instance dari maksimum ini (misalnya [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]).

Jika, setelah perbandingan ini, keduanya sama, lakukan perbandingan yang sama tetapi dengan item tertinggi berikutnya (mis [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1].).

Jika, setelah semua perbandingan ini, mereka masih dianggap sama, mengeluarkan daftar yang lebih panjang (misalnya [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0]).

Buat kode Anda sesingkat mungkin.

Uji Kasus

[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

Cobalah online

Penjelasan

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

Cobalah online!

Jelly , 4 byte

NÞÞṪ

Cobalah online!

Bagaimana itu bekerja

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

Input diambil sebagai daftar dua elemen, misalnya ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Temukan elemen dalam daftar input yang merupakan maksimum setelah penyortiran dengan meniadakan nilai-nilai (yaitu urutan menurun).

Bersih , 42 byte

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

Cobalah online!

JavaScript (ES7), 52 byte

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

Metode ini berfungsi tanpa menyortir array. Alih-alih, ia menghitung jumlah 10.000 yang dinaikkan ke setiap elemen array. Jumlah terbesar mewakili array dengan skor tertinggi. (Solusi ini mengasumsikan bahwa array tidak memiliki lebih dari 10.000 elemen.)

Uji kasus

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 byte

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

Cobalah online!

Python 2 , 79 byte

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

Cobalah online!

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

Cobalah online!

Sekam , 3 byte

►Ö_

Cobalah online!

Kiriman ini pada dasarnya mengambil daftar dua elemen dari daftar sebagai input dan mengambil maksimum ( ►), diurutkan berdasarkan nilainya diurutkan dalam urutan menurun ( Ö_).

05AB1E , 5 byte

Σ{R}θ

Cobalah 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

gmengurutkan salinan parameternya dalam urutan terbalik (karena sortbermutasi array), sementara hmelakukan perbandingan elemen array secara bertahap.

Perl 6 , 17 byte

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

Menguji ^{_{(Lambda Lambda Lambda)}}

• -* lambda yang secara numerik meniadakan input
• *.sort(-*) lambda yang menggunakan yang menggunakan hasil menerapkan itu untuk membandingkan elemen
• *.max(*.sort(-*)) lambda yang menemukan hasil maksimal, dan menggunakannya untuk menentukan input mana yang akan dikembalikan.

J, 20 byte

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

Tidak Disatukan:

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

Pada dasarnya jawaban Pyth, diterjemahkan tanpa henti ke dalam J.

Cobalah online!