İki farklı negatif olmayan tamsayı listesi verildiğinde, en yüksek maksimum değere sahip listeyi döndürün (ör. [4, 2], [3, 3, 1] -> [4, 2]).

Her ikisi de aynı maksimum değere sahipse, bu maksimum değerin daha fazla örneğini içeren listeyi döndürün (örneğin [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]).

Bu karşılaştırmalardan sonra eşitse, aynı karşılaştırmayı ancak bir sonraki en yüksek kalemleriyle (örn. [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1]) Yapın .

Tüm bu karşılaştırmalardan sonra, yine de eşit kabul edilirlerse, daha uzun listeyi (ör [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0].

Kodunuzu mümkün olduğunca kısa yapın.

Test Durumları

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

eo_S

Çevrimiçi deneyin

açıklama

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

Python 2 , 44 bayt

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

Çevrimiçi deneyin!

Jöle , 4 bayt

NÞÞṪ

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

import Data.Lists
argmax$sortOn(0-)

Giriş iki elemanlı bir liste olarak alınır, örn ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Değerleri (örn. Azalan sıralama) reddederek sıralamadan sonra maksimum olan giriş listesinde öğeyi bulun.

Temiz , 42 bayt

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

Çevrimiçi deneyin!

JavaScript (ES7), 52 bayt

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

Bu yöntem çalışır olmadan dizileri sıralama. Bunun yerine, her bir dizinin öğelerine eklenen 10.000 toplamı hesaplar. En büyük toplam, en yüksek puana sahip diziyi temsil eder. (Bu çözüm, hiçbir dizinin 10.000'den fazla öğeye sahip olmadığını varsayar.)

Test senaryoları

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 bayt

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

Çevrimiçi deneyin!

Python 2 , 79 bayt

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

Çevrimiçi deneyin!

Yakut 149 bayt

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

Çevrimiçi deneyin!

Kabuk , 3 bayt

►Ö_

Çevrimiçi deneyin!

Bu gönderim temel olarak iki elemanlı liste listesini girdi olarak alır ve ►değerlerine (azalan düzende ( Ö_) ) göre sıralanmış maksimum ( ) değerini getirir .

05AB1E , 5 bayt

Σ{R}θ

Çevrimiçi deneyin!

JavaScript (ES6), 98 bayt

(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

gdizilerinin mutasyonlu olarak karşılaştırmasını sortyaparken , parametresinin bir kopyasını ters sırada sıralar ( diziyi değiştirir) h.

Perl 6 , 17 bayt

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

Test edin ^{_{(Lambda Lambda Lambda)}}

• -* girişi sayısal olarak reddeden lambda
• *.sort(-*) Bunu karşılaştırmak için kullanılan sonuçları kullanan lambda
• *.max(*.sort(-*)) bu sonuçların maksimumunu bulan lambda ve bunu hangi girdinin döndürüleceğini belirlemek için kullanır.

J, 20 bayt

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

Ungolfed:

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

Esasen Pyth cevabı, isteksizce J'ye çevrildi.

Çevrimiçi deneyin!