Welche wirklich große Zahl ist größer?

11

Diese Frage ist schwierig (und insbesondere schwieriger als Welche große Zahl ist größer? ) Für diejenigen, die anspruchsvollere Rätsel mögen.

Eingang

Ganzzahlen a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 jeweils im Bereich von 1 bis 10.

Ausgabe

True if a1^(a2^(a3^(a4^a5))) > b1^(b2^(b3^(b4^b5))) and False otherwise.

^ ist Potenzierung in dieser Frage.

Regeln

Das ist Code-Golf. Ihr Code muss innerhalb von 10 Sekunden für jede gültige Eingabe in TIO korrekt beendet werden . Wenn Ihre Sprache nicht auf TIO ist, sollte der Code auf Ihrem Computer weniger als 10 Sekunden dauern.

Sie können alles Truthy for True und alles Falsey for False ausgeben.

Testfälle

Denken Sie daran, dass nach den Exponentiaon-Regeln a1 ^ (a2 ^ (a3 ^ (a4 ^ a5)) == a1 ^ a2 ^ a3 ^ a4 ^ a5.

10^10^10^10^10 > 10^10^10^10^9
1^2^3^4^5 < 5^4^3^2^1
2^2^2^2^3 > 10^4^3^2^2
6^7^8^9^10 is not bigger than 6^7^8^9^10
10^6^4^2^2 < 10^6^2^4^2
2^2^2^2^10 > 2^2^2^10^2
10^9^8^7^6 < 6^7^8^9^10 
3^1^10^10^10 > 2^1^10^10^10 
9^10^10^10^10 < 10^9^10^10^10

Neue Testfälle von Kevin Cruijssen

[10,10,10,10,10, 10,10,10,10,9] #true
[2,2,2,2,3,      10,4,3,2,2]    #true
[2,2,2,2,10,     2,2,2,10,2]    #true
[10,10,10,10,10, 9,10,10,10,10] #true
[3,2,2,1,1,      2,5,1,1,1]     #true
[2,2,3,10,1,     2,7,3,9,1]     #true
[7,9,10,10,10,   6,9,10,10,10]  #true
[3,2,2,2,2,      2,2,2,2,2]     #true
[8,3,1,2,1,      2,2,3,1,1]     #true
[2,4,2,1,1,      3,3,2,1,1]     #true
[5,4,3,2,1,      1,2,3,4,5]     #true

[1,2,3,4,5,      5,4,3,2,1]     #false
[6,7,8,9,10,     6,7,8,9,10]    #false
[10,6,4,2,2,     10,6,2,4,2]    #false
[10,9,8,7,6,     6,7,8,9,10]    #false
[1,10,10,10,10,  1,10,10,10,9]  #false
[2,4,1,1,1,      2,2,2,1,1]     #false
[2,2,2,1,1,      2,4,1,1,1]     #false
[2,5,1,1,1,      3,2,2,1,1]     #false
[4,2,1,1,1,      2,4,1,1,1]     #false
[2,4,1,1,1,      4,2,1,1,1]     #false
[2,3,10,1,1,     8,3,9,1,1]     #false
[8,3,9,1,1,      2,3,10,1,1]    #false
[2,4,1,1,1,      3,3,1,1,1]     #false
[2,2,1,9,9,      2,2,1,10,10]   #false
[2,2,1,10,10,    2,2,1,9,9]     #false
[1,1,1,1,1,      1,2,1,1,1]     #false
Anush
quelle
5
Ich mache VTC, obwohl es kein Betrüger ist; Es ist einfach zu nah an einer Herausforderung, die Sie 4 Stunden zuvor gepostet haben, und es zeigt einen Mangel an Anstrengung, sich einzigartige Herausforderungen auszudenken.
Magic Octopus Urn
3
Ich habe das Gefühl, 9 Leute haben sich mit ihren Stimmen auf meinen Punkt geeinigt. Aber wie Sie sagen, haben Sie die Wahl, es zu behalten, obwohl es 9 Downvotes hat. Ich habe nur ein wenig Licht darauf geworfen, warum es Abstimmungen geben kann.
Magic Octopus Urn
3
War ehrlich gesagt nur mein Zwei-Cent-Mann; Wir müssen hier nicht ins Detail gehen. Bedauere, dass ich überhaupt etwas gesagt habe; Das Letzte, was ich wollte, war eine argumentative Antwort. Ich habe nur gesagt, warum ich -1 gegeben habe.
Magic Octopus Urn
7
Ich stimme dafür, diesen Beitrag erneut zu öffnen, da er unterschiedliche Schwierigkeitsparameter hat und der erforderliche Lösungsansatz sehr unterschiedlich ist. Meta-Post .
user202729
3
Vorgeschlagene Testfälle (für die Randfälle, auf die die Antworten von Python, Ruby, Java und 05AB1E stoßen)
Kevin Cruijssen

Antworten:

8

Ruby, 150 Bytes

Siehe Revisionen für frühere Byteanzahlen.

->a,b,c,d,e,f,g,h,i,j{l=->s,t=c{Math.log(s,t)};y,z=l[l[g,b]]-d**e+l[h]*i**=j,l[l[a,f]*b**c,g];a>1?f<2?1:b<2||g<2?z>h:c<2||d<2?l[z,h]>i:y==0?a>f:y<0:p}

-10 Bytes dank @ValueInk

+16 Bytes danke an @RosLuP für Fehler.

Probieren Sie es online aus .

Vergleichen Sie verschiedene Basiskräfte-Türme (von 'Höhe' fünf)?

Ungolfed Code:

-> a, b, c, d, e, f, g, h, i, j {
    l =-> s, t = c {Math.log(s, t)}
    i **= j
    y = l[l[g, b]] - d ** e + l[h] * i
    z = l[l[a, f] * b ** c, g]
    if a == 1
        return p
    elsif f == 1
        return 1
    elsif b == 1 || g == 1
        return z > h
    elsif d == 1 || c == 1
        return l[z, h] > i
    elsif y == 0
        return a > f
    else
        return y < 0
    end
}

Aufschlüsselung des Codes:

l =-> s, t = c {Math.log(s, t)}

Dies ist der tBasislogarithmus, mit dem die Größe der zu vergleichenden Zahlen verringert wird. Der Standardwert ist base, cwenn nur ein Argument angegeben wird.

i **= j
y = l[l[g, b]] - d ** e + l[h] * i
z = l[l[a, f] * b ** c, g]

Dieses Update wird i = i ** jseitdem inie alleine verwendet und yist das Ergebnis einer b^c^d^e == g^h^i(^j)zweimaligen Protokollierung und einer Verschiebung aller Elemente. Wir lassen dann z = l[a, f] * b ** cals Logbasis gdie Logbasis fvon a ** b ** c.

if a == 1
    return p
elsif f == 1
    return 1

1^b^c^d^e = 1ist niemals größer als f^g^h^i^jund ebenso a^b^c^d^eimmer größer als 1^g^h^i^j = 1wenn a != 1. Beachten Sie, dass return pRückkehr nil, was Falsey ist, und return 1Rückkehr 1, was wahr ist.

elsif b == 1
    return z > h

Wenn b == 1oder g == 1, dann reduziert sich dies auf den Vergleich a ** b ** cmit f ** g ** h, was mit zwei Protokollen auf beiden Seiten erfolgt.

elsif d == 1 || c == 1
    return l[z, h] > i

Dies ist vergleichbar a ** b ** cmit einer f ** g ** h ** iNeuanordnung im log[log[b ** c * log[a, f], g], h]Vergleich zu i. (Erinnern Sie sich daran i **= jam Anfang und z = log[b ** c * log[a, f], g].)

elsif y == 0
    return a > f
else
    return y < 0
end

Dies vergleicht die 4 höchsten Potenzen nach zweimaliger Protokollierung beider Seiten. Wenn sie gleich sind, wird die Basis verglichen.

Einfach schöne Kunst
quelle
5

Python 2, 671 612 495 490 611 597 Bytes

lambda a,b:P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)
def S(a,b):
  if a and a[-1]==b[-1]:
    a.pop()
    b.pop()
    return S(a,b)
from math import*
L=log
E=exp
N=lambda m,n,x:N(m,n+1,L(x))if x>=1else N(m,n-1,E(x))if x<0else(m+n,x)
A=lambda a,n,x:(0,1)if a==1else(1,R(x,n)*L(a))if a<1else N(2,*C(L(L(a)),x,n-1))if n else(1,x*L(a))
def C(c,x,n):
 if c*n==0:return(0if c else n,x+c)
 z=R(x,n-1)
 if z<=L(abs(c)):return(0,E(z)+c)
 return N(1,*C(L(1-E(L(-c)-z)if c<0else 1+E(L(c)-z)),x,n-1))
def R(x,n):
 try:exec'x=E(x)'*n
 except:x=float('inf')
 return x
P=lambda b:b and N(0,*A(b[0],*P(b[1:])))or(0,1)

-59 Bytes dank @EmbodimentOfIgnorance
-117 Bytes dank @Neil
+121 Bytes für ungefähr fünf Fehlerkorrekturen, die alle von @ngn gefunden wurden

Nimmt die Eingaben als zwei Listen. HINWEIS: Funktioniert auch mit größeren Listen oder Listen mit ungleicher Länge. EDIT: Nicht mehr wahr; Es funktioniert immer noch, wenn P(a)und P(b)führt zu unterschiedlichen Tupeln, aber wenn sie gleich sind, funktioniert dieser aktualisierte Code oben nur mit Listen mit einer festen Größe von 5.

Probieren Sie es online aus.

Erläuterung:

Golfversion dieser Antwort auf math.stackexchange.com , daher geht der gesamte Kredit an @ThomasAhle .

Um seine Antwort zu zitieren:

Die Idee ist, Leistungstürme als einzelne Gleitkommazahl mit Potenzierungen darzustellen : . Dieses Format normalisiert und ermöglicht einen einfachen Vergleich zwischen Zahlen.n(xn):=expn(x)x[0,1)

Was bleibt, ist eine Möglichkeit, für jedes reale, positive zu berechnen . Mein Python-Code unten ist ein Versuch, dies zu tun, während er so numerisch stabil wie möglich ist, z. B. mithilfe des Protokollsummen-Tricks. Mein Code wird zeitlich proportional zur Höhe des Turms (Anzahl der Aufrufe) und dem iterierten Protokoll seines Werts (Anzahl der rekursiven Aufrufe) ausgeführt.a(xn)aapow

Ich konnte nicht zwei Türme mit Werten finden, die nahe genug sind, um zu verhindern, dass meine Methode fehlschlägt. Zumindest für ganzzahlige Exponenten. Mit gebrochenen Exponenten ist es möglich, sehr Türme zu erstellen, die für meine Darstellung zu nahe sind. ZB22220<2222(1/2)2222

Ich würde mich für Vorschläge zu anderen Arten von Gegenbeispielen interessieren, insbesondere zu ganzzahligen.

Es scheint mir, dass wir nicht numerische Methoden benötigen, damit das Problem in P liegt. Es scheint überhaupt nicht unwahrscheinlich, dass bestimmte analytische Fälle schwieriger sind als P.

Beispiele:

powtow([2,2,2,2,2,2,2,2,2,2,2,2,2,2,4,2,2,2]) = (0.1184590219613409, 18)
powtow([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]) = (0.10111176550354063, 18)

powtow([2,2,5,2,7,4,9,3,7,6,9,9,9,9,3,2]) = (0.10111176550354042, 17)
powtow([3,3,6,3,9,4,2,3,2,2,2,2,2,3,3,3]) = (0.19648862015624008, 17)

Gegenbeispiele:

powtow([2,2,2,2,2,2,2]) = (0.8639310719129168, 6)
powtow([3,2,2,2,2,2,2]) = (0.8639310719129168, 6)

In Bezug auf die Gegenbeispiele erwähnt er im Kommentarbereich Folgendes:

Ich glaube, wenn wir die Exponenten so (oder vielleicht eine viel größere Obergrenze) binden, können wir meine Methode zum Vergleichen der Höhe 3 oder 4 des Turmkopfes verwenden. Es sollte stark genug sein, um uns zu sagen, ob sie gleich oder größer sind. Plan B sieht vor, den höchsten Turm zu wählen. Plan C ist interessant: An diesem Punkt sind die Werte des restlichen Turms nur dann von Bedeutung, wenn die Köpfe gleich sind, sodass wir parallel die Türme hinuntergehen und anhalten können, sobald wir einen unterschiedlichen Wert sehen.1<a<100

Daher muss vor allem bewiesen werden, dass wir, sobald der Kopf eines Turms einen bestimmten Punkt überschreitet und der Rest der Exponenten begrenzt (und ebenso zahlreich) ist, einfach den obersten unterschiedlichen Wert betrachten können. Es ist ein bisschen kontraintuitiv, aber es scheint sehr wahrscheinlich aufgrund der einfachen Ungleichungen, die Sie bekommen.

Da Plan A und B für diese Herausforderung irrelevant sind, ist Plan C, da die Höhe für beide von uns eingegebenen Krafttürme 5 beträgt. Also habe ich geändert , P(a)>P(b)um P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)mit der rekursiven Funktion S(a,b). Wenn P(a)und P(b)zu demselben Tupel führen, P(S(a,b))>P(S(b,a))werden zuerst nachfolgende Werte entfernt, die bei denselben Indizes gleich sind, bevor P(A)>P(B)diese jetzt kürzeren Listen auf dieselbe Weise überprüft werden.

Kevin Cruijssen
quelle
1
Ich lutsche
Verkörperung der Ignoranz
1
495 Bytes
Neil
2
Schlägt für[10,10,10,10,10]>[9,10,10,10,10]
Verkörperung der Unwissenheit
1
Sie verwenden die Funktion nur Reinmal, also können Sie sie vielleicht einfach inline setzen?
Verkörperung der Unwissenheit
1
@EmbodimentofIgnorance Es gibt noch einen ausstehenden Anruf Rauf Linie 5 ...
Neil
4

05AB1E , 96 104 Bytes

3èI4èmU8.$`m©I7èI2è.n*I6èI1è.nI2è.n+Vнi0ë5èi1ë2ô1èßi¦2£`mIнI5è.n*I6è.nDI7èDi\1›·<žm*ë.n}®›ëXYQiнI5è›ëXY›

Port of @SimplyBeautifulArts Ruby-Antwort , also stellen Sie sicher, dass Sie ihn positiv bewerten!

log1(x)POSITIVE_INFINITYx>1NEGATIVE_INFINITYx<10.0[3,2,2,1,1,2,5,1,1,1]POSITIVE_INFINITE[2,4,1,1,1,3,3,1,1,1]NEGATIVE_INFINITY

Eingabe als Liste von zehn ganzen Zahlen : [a,b,c,d,e,f,g,h,i,j].

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

3èI4èm         # Calculate d**e
      U        # And pop and store it in variable `X`
8.$`m          # Calculate i**j
     ©         # Store it in variable `®` (without popping)
I7èI2è.n       # Calculate c_log(h)
 *             # Multiply it with i**j that was still on the stack: i**j * c_log(h)
I6èI1è.nI2è.n  # Calculate c_log(b_log(g))
 +             # And sum them together: i**j * c_log(h) + c_log(b_log(g))
  V            # Pop and store the result in variable `Y`

нi             # If `a` is 1:
 0             #  Push 0 (falsey)
ë5èi           # Else-if `f` is 1:
 1             #  Push 1 (truthy)
ë2ô1èßi        # Else-if the lowest value of [c,d] is 1:
 ¦2£`m         #  Calculate b**c
 IнI5è.n       #  Calculate f_log(a)
  *            #  Multiply them together: b**c * f_log(a)
   I6è.n       #  Calculate g_log(^): g_log(b**c * f_log(a))
 D             #  Duplicate it
  I7è          #  Push h
     Di        #  Duplicate it as well, and if h is exactly 1:
       \       #   Discard the duplicated h
       1      #   Check if the calculated g_log(b**c * f_log(a)) is larger than 1
               #   (which results in 0 for falsey and 1 for truthy)
         ·<    #   Double it, and decrease it by 1 (it becomes -1 for falsey; 1 for truthy)
           žm* #   Multiply that by 9876543210 (to mimic POSITIVE/NEGATIVE INFINITY)
      ë        #  Else:
       .n      #   Calculate h_log(g_log(b**c * f_log(a))) instead
      }        #  After the if-else:
       ®›      #  Check whether the top of the stack is larger than variable `®`
ëXYQi          # Else-if variables `X` and `Y` are equal:
     нI5è›     #  Check whether `a` is larger than `f`
ë              # Else:
 XY           #  Check whether `X` is larger than `Y`
               # (after which the top of the stack is output implicitly as result)

Wenn jemand versuchen möchte, es weiter zu spielen, ist hier ein Hilfsprogramm, mit dem ich die richtigen Variablen aus der Eingabeliste abgerufen habe.

Kevin Cruijssen
quelle
1
Sehr beeindruckt ist dies unter 100! Und vielen Dank, dass Sie das Kopfgeld hinzugefügt haben.
Anush
2
@ Anush Ich habe tatsächlich das Gefühl, dass 96 ziemlich lang ist, wenn man bedenkt, dass Ruby 151 nicht Golf spielt .; P Und np über das Kopfgeld. Es ist hauptsächlich für den Ansatz von @SimplyBeautifulArt gedacht , aber gleichzeitig, um der Herausforderung etwas Aufmerksamkeit zu schenken. Der Grund, warum es abgelehnt wurde, ist, dass Sie es einige Stunden nach Ihrer früheren Antwort mit 3 Kräften veröffentlicht haben. Ich persönlich mag diese Herausforderung und war die erste, die sie positiv bewertet und beantwortet hat, aber ich kann die Wahrheit immer noch im allerersten Kommentar unter dem Herausforderungsbeitrag zur gleichen Zeit sehen. Hoffentlich macht das Kopfgeld Ihre Herausforderung 0 oder positiv :)
Kevin Cruijssen
Ich träume von einer 0! :)
Anush
1
[2,1,1,1,1,3,1,1,1,1] Ergebnis 1 muss stattdessen 0 ergeben
RosLuP
1
log1(x)
3

C 168 180 Bytes

C Port von Kevin Cruijssens Antwort.

#define l(a,b)log(a)/log(b)
z(a,b,c,d,e,f,g,h,i,j){float t=pow(i,j),y=l(l(g,b),c)-pow(d,e)+l(h,c)*t,z=l(l(a,f)*pow(b,c),g);return~-a&&f<2|(b<2|g<2?z>h:c<2|d<2?l(z,h)>t:y?y<0:a>f);}

Probieren Sie es online aus

Johan du Toit
quelle
1
Hmmm ... ein Hafen eines Hafens * thonks *
Simply Beautiful Art
Schlägt3,1,10,10,10,2,1,10,10,10 wie meine Java-Antwort auch. Und es ist tatsächlich eine Portierung von @ SimplyBeautifulArts Ruby-Antwort, da er derjenige ist, der sich alles
ausgedacht
2

APL (NARS), Zeichen 118, Bytes 236

{p←{(a b c d)←⍵⋄a=1:¯1⋄b=1:⍟⍟a⋄(⍟⍟a)+(c*d)×⍟b}⋄(=/(a b)←{p 1↓⍵}¨⍺⍵)∧k←(∞ ∞)≡(m n)←{p(3↑⍵),*/3↓⍵}¨⍺⍵:(↑⍺)>↑⍵⋄k:a>b⋄m>n}

Die Funktion über dem Aufruf von z in "az w" würde 1 zurückgeben, wenn die Zahl in a größer als die Zahl in w ist, andernfalls würde sie 0 zurückgeben.

Wenn ich habe

f(a,b,c,d,e)=a^b^c^d^e

Es ist f (aa)> f (bb) mit einem aa- und einem bb-Array von 5 positiven Zahlen, wenn und nur wenn (wenn a> 1 von aa und bb) log (log (f (aa)))> log ( log (f (bb))) muss man die log () Gesetze anwenden:

log(A*B)=log(A)+log(B)
log(A^B)=B*log(A)

für Build v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} Funktion und so wird die Übung gefunden, wenn v (aa)> v (bb).

Aber es gibt einen Fall, in dem v (aa) und v (bb) beide unendlich sind (APL hat den Float-Raum beendet). In diesem Fall würde ich die unsichere Funktion verwenden

s(a,b,c,d,e)=log(log(b))+log(c)*(d^e)={p 1↓⍵}

dass ich nicht ganz verstehe, ob es in Ordnung ist und es auch keinen Parameter berücksichtigt ... test:

  z←{p←{(a b c d)←⍵⋄a=1:¯1⋄b=1:⍟⍟a⋄(⍟⍟a)+(c*d)×⍟b}⋄(=/(a b)←{p 1↓⍵}¨⍺⍵)∧k←(∞ ∞)≡(m n)←{p(3↑⍵),*/3↓⍵}¨⍺⍵:(↑⍺)>↑⍵⋄k:a>b⋄m>n}
  10 10 10 10 10 z 10 10 10 10 9
1
  1 2 3 4 5 z 5 4 3 2 1
0
  2 2 2 2 3 z 10 4 3 2 2
1
  10 6 4 2 2 z 10 6 2 4 2
0
  2 2 2 2 10 z 2 2 2 10 2
1
  10 9 8 7 6 z 6 7 8 9 10
0
  10 10 10 10 10 z 10 10 10 10 9
1      
  2 2 2 2 3   z    10 4 3 2 2
1
  2 2 2 2 10   z   2 2 2 10 2
1
  10 10 10 10 10 z 9 10 10 10 10
1
  3 2 2 1 1   z    2 5 1 1 1
1
  2 2 3 10 1  z    2 7 3 9 1
1
  7 9 10 10 10 z   6 9 10 10 10
1
  3 2 2 2 2    z   2 2 2 2 2
1
  3 10 10 10 10 z  2 10 10 10 10
1
  8 3 1 2 1    z   2 2 3 1 1
1
  2 4 2 1 1    z   3 3 2 1 1
1
  5 4 3 2 1    z   1 2 3 4 5
1
  1 2 3 4 5    z   5 4 3 2 1
0
  6 7 8 9 10    z  6 7 8 9 10
0
  10 6 4 2 2 z     10 6 2 4 2
0
  10 9 8 7 6  z   6 7 8 9 10
0
  1 10 10 10 10 z 1 10 10 10 9
0
  2 4 1 1 1 z     2 2 2 1 1
0
  2 2 2 1 1    z  2 4 1 1 1
0
  2 5 1 1 1   z   3 2 2 1 1
0
  4 2 1 1 1   z   2 4 1 1 1
0
  2 4 1 1 1   z   4 2 1 1 1
0
  2 3 10 1 1  z   8 3 9 1 1
0
  8 3 9 1 1   z   2 3 10 1 1
0
  2 4 1 1 1   z   3 3 1 1 1
0
  2 2 1 9 9   z   2 2 1 10 10
0
  2 2 1 10 10 z   2 2 1 9 9
0
  1 1 1 1 1   z   1 2 1 1 1
0
  1 1 1 1 2   z   1 1 1 1 1
0
  1 1 1 1 1   z   1 1 1 1 1
0
  9 10 10 10 10 z  10 9 10 10 10
1
  9 10 10 10 10 z  10 10 10 10 10
0
  10 10 10 10 10 z  10 10 10 10 10
0
  11 10 10 10 10 z  10 10 10 10 10
1
RosLuP
quelle
Den Tests in der Herausforderungsbeschreibung fehlen einige Randfälle. Können Sie überprüfen, ob es auch für alle diese Testfälle funktioniert ?
Kevin Cruijssen
1
@ KevinCruijssen Hier Ihr Test, wenn Sie den oben genannten ausschließen, scheint in
Ordnung zu sein
1
Wenn alle Testfälle korrekt sind, dann +1 von mir. Ich freue mich auf eine Erklärung Ihres Codes. :)
Kevin Cruijssen
1
Sie sagten, Sie hätten jede berechnet, indem Sie genommen haben log(log()), aber für diesen Testfall würde der Unterschied zwischen log(log(10^10^10^10^10))und log(log(9^10^10^10^10))eine absurde Menge an Genauigkeit erfordern, um ihn zu erfassen. Sie benötigen einen Gleitkommawert mit 2e10einer Genauigkeit von etwa 10 Stellen. Und dies ignoriert die Tatsache, dass beide Seiten ungefähr so ​​groß sind wie 10^10^10, was ich kaum glauben kann, dass Sie in der Lage waren zu berechnen.
Einfach schöne Kunst
1
Vielleicht scheitert es 9, 10, 10, 10, 10, 10, 9, 10, 10, 10, was zurückgeben sollte 1, aber s(9,10,10,10,10) < s(10,9,10,10,10).
Einfach schöne Kunst
1

Java 8, 299 288 286 252 210 208 224 Bytes

Math M;(a,b,c,d,e,f,g,h,i,j)->{double t=M.pow(i,j),y=l(l(g,b),c)-M.pow(d,e)+l(h,c)*t,z=l(l(a,f)*M.pow(b,c),g);return a>1&&f<2|(b<2|g<2?z>h:c<2|d<2?l(z,h)>t:y==0?a>f:y<0);}double l(double...A){return M.log(A[0])/M.log(A[1]);}

Port of @SimplyBeautifulArts Ruby-Antwort , also stellen Sie sicher, dass Sie ihn positiv bewerten!
-14 Bytes dank @SimplyBeautifulArt .
+17 Bytes für die gleichen Fehlerbehebungen wie die Ruby-Antwort.

Probieren Sie es online aus.

Erläuterung:

Math M;                      // Math M=null on class-level to save bytes

(a,b,c,d,e,f,g,h,i,j)->{     // Method with ten integer parameters and boolean return-type
  double t=M.pow(i,j),       //  Temp `t` = `i` to the power `j`
    y=l(l(g,b),c)            //  Temp `y` = `c`_log(`b`_log(`g`))
      -M.pow(d,e)            //  - `d` to the power `e`
      +l(h,c)*t,             //  + `c`_log(`h`) * `t`
    z=l(l(a,f)*M.pow(b,c),g);//  Temp `z` = `g`_log(`f`_log(`a`) * `b` to the power `c`)
  return a>1&&               //  If `a` is 1:
                             //   Return false
   f<2|(                     //  Else-if `f` is 1:
                             //   Return true
    b<2|g<2?                 //  Else-if either `b` or `g` is 1:
     z>h                     //   Return whether `z` is larger than `h`
    :c<2|d<2?                //  Else-if either `c` or `d` is 1:
     l(z,h)>t                //    Return whether `h`_log(`z`) is larger than `t`
    :y==0?                   //   Else-if `y` is 0:
      a>f                    //    Return whether `a` is larger than `f`
    :                        //   Else:
     y<0);}                  //    Return whether `y` is negative

// Separated method to calculate `B`_log(`A`) for inputs `A,B`
double l(double...A){return M.log(A[0])/M.log(A[1]);}
Kevin Cruijssen
quelle
Es scheint gut zu funktionieren, wenn Sie x==yanstelle von verwenden M.abs(x-y)<1e-9.
Einfach schöne Kunst
@SimplyBeautifulArt Warten Sie, es tut? .. Wtf. Als ich meine ungolfed Version hatte, funktionierte es nicht für einen Testfall. Die String-Ausgabe war die gleiche, aber intern unterschied sie sich geringfügig. Die ungolfed Version war Ihre ungolfed Version, bevor ich sie in die golfed ternary Version geändert habe, die Sie auch in Ihrer Ruby-Antwort haben. Dumme Gleitkommapräzision. Wird es ändern, da es in der Tat für die Testfälle im aktuellen Ansatz funktioniert. Vielen Dank.
Kevin Cruijssen
Lol, wenn du schon dabei bist, solltest du dir vielleicht meine Updates ansehen: ^)
Simply Beautiful Art
1
tEs kann entfernt werden, um ein Byte zu speichern, indem es ywie ich eingefügt wird. TIO
Simply Beautiful Art
1
@SimplyBeautifulArt Nvm über die Aktualisierung meiner 05AB1E-Antwort mit der gleichen Änderung. Die Byteanzahl würde 96 bleiben.
Kevin Cruijssen