Geben Sie bei zwei verschiedenen Listen nicht negativer Ganzzahlen die Liste mit dem höchsten Maximum zurück (z [4, 2], [3, 3, 1] -> [4, 2]. B. ).

Wenn beide dasselbe Maximum haben, geben Sie die Liste zurück, die mehr Instanzen dieses Maximums enthält (z [4, 2, 4], [4, 3, 3, 3, 1, 3] -> [4, 2, 4]. B. ).

Wenn sie nach diesen Vergleichen gleich sind, führen Sie den gleichen Vergleich durch, jedoch mit dem nächsthöheren Element (z [2, 3, 4, 4], [4, 4, 3, 3, 1] -> [4, 4, 3, 3, 1]. B. ).

Wenn nach all diesen Vergleichen immer noch angenommen wird, dass sie gleich sind, geben Sie die längere Liste aus (z [4, 3, 2, 1, 0], [1, 2, 3, 4] -> [4, 3, 2, 1, 0]. B. ).

Machen Sie Ihren Code so kurz wie möglich.

Testfälle

[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

Probieren Sie es online aus

Erläuterung

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

Probieren Sie es online!

Gelee , 4 Bytes

NÞÞṪ

Probieren Sie es online!

Wie es funktioniert

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

Die Eingabe wird als Liste mit zwei Elementen verwendet, z ( argmax$sortOn(0-) ) [[4,4,4,4,2,4], [4,4,4,4,3,2]].

Suchen Sie das Element in der Eingabeliste, das nach dem Sortieren maximal ist, indem Sie die Werte negieren (dh absteigende Reihenfolge).

Sauber , 42 Bytes

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

Probieren Sie es online!

JavaScript (ES7), 52 Byte

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

Diese Methode funktioniert ohne Sortieren der Arrays. Stattdessen wird die Summe von 10.000 berechnet, die auf die Elemente jedes Arrays angewendet werden. Die größte Summe repräsentiert das Array mit der höchsten Punktzahl. (Bei dieser Lösung wird davon ausgegangen, dass keines der Arrays mehr als 10.000 Elemente enthält.)

Testfälle

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

Probieren Sie es online!

Python 2 , 79 Bytes

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

Probieren Sie es online!

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}

Probieren Sie es online!

Schale , 3 Bytes

►Ö_

Probieren Sie es online!

Diese Übermittlung verwendet im Grunde genommen eine Liste mit zwei Elementen als Eingabe und ruft das Maximum ( ►) ab, sortiert nach ihren Werten, sortiert in absteigender Reihenfolge ( Ö_).

05AB1E , 5 Bytes

Σ{R}θ

Probieren Sie es 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

gsortiert eine Kopie seines Parameters in umgekehrter Reihenfolge (da sortdas Array mutiert), während hrekursiv der elementweise Vergleich der Arrays durchgeführt wird.

Perl 6 , 17 Bytes

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

Testen Sie es ^{_{(Lambda Lambda Lambda)}}

• -* Lambda, das die Eingabe numerisch negiert
• *.sort(-*) Lambda, das verwendet, verwendet die Ergebnisse der Anwendung, um Elemente zu vergleichen
• *.max(*.sort(-*)) Lambda, das das Maximum dieser Ergebnisse ermittelt und anhand dessen bestimmt, welche Eingabe zurückgegeben werden soll.

J, 20 Bytes

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

Ungolfed:

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

Im Wesentlichen die Pyth-Antwort, unausgesprochen übersetzt in J.

Probieren Sie es online!