Đưa ra hai danh sách các số nguyên không âm khác nhau , trả về danh sách có mức tối đa cao nhất (ví dụ [4, 2], [3, 3, 1] -> [4, 2]).

Nếu cả hai đều có cùng mức tối đa, hãy trả về danh sách chứa nhiều phiên bản của mức tối đa này (ví dụ [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]).

Nếu, sau những so sánh này, chúng bằng nhau, thực hiện so sánh tương tự nhưng với mục cao nhất tiếp theo của chúng (ví dụ [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1]).

Nếu, sau tất cả những so sánh này, chúng vẫn được coi là bằng nhau, đưa ra danh sách dài hơn (ví dụ [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0]).

Làm cho mã của bạn càng ngắn càng tốt.

Các trường hợp thử nghiệm

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

Bình thường, 4 byte

eo_S

Dùng thử trực tuyến

Giải trình

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

Hãy thử trực tuyến!

Thạch , 4 byte

NÞÞṪ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đầu vào được lấy dưới dạng danh sách hai thành phần, vd ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Tìm phần tử trong danh sách đầu vào là mức tối đa sau khi sắp xếp bằng cách phủ định các giá trị (tức là thứ tự giảm dần).

Sạch , 42 byte

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

Hãy thử trực tuyến!

JavaScript (ES7), 52 byte

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

Phương pháp này hoạt động mà không sắp xếp các mảng. Thay vào đó, nó tính toán tổng số 10.000 được nâng lên cho các phần tử của mỗi mảng. Tổng lớn nhất đại diện cho mảng có số điểm cao nhất. (Giải pháp này giả định rằng không mảng nào có hơn 10.000 phần tử.)

Các trường hợp thử nghiệm

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

Hãy thử trực tuyến!

Python 2 , 79 byte

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

Hãy thử trực tuyến!

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}

Hãy thử trực tuyến!

Husk , 3 byte

►Ö_

Hãy thử trực tuyến!

Trình này về cơ bản lấy danh sách hai yếu tố của danh sách làm đầu vào và truy xuất mức tối đa ( ►), được sắp xếp theo giá trị của chúng được sắp xếp theo thứ tự giảm dần ( Ö_).

05AB1E , 5 byte

Σ{R}θ

Hãy thử trực tuyến!

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

gsắp xếp một bản sao của tham số của nó theo thứ tự ngược lại (vì làm thay sortđổi mảng), trong khi hthực hiện đệ quy so sánh các phần tử của các mảng.

Perl 6 , 17 byte

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

Kiểm tra nó ^{_{(Lambda Lambda Lambda)}}

• -* lambda mà phủ nhận số lượng đầu vào
• *.sort(-*) lambda sử dụng kết quả của việc áp dụng đó để so sánh các yếu tố
• *.max(*.sort(-*)) lambda tìm thấy tối đa các kết quả đó và sử dụng kết quả đó để xác định đầu vào nào sẽ trả về.

J, 20 byte

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

Ung dung:

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

Về cơ bản là câu trả lời của Pyth, đã dịch một cách không trung thực sang J.

Hãy thử trực tuyến!