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

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.

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$$(x\mid n) := exp^n(x)$$x\in[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^{(x\mid n)}$$a$apow

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. ZB$2^{2^{2^{2^0}}}<2^{2^{2^{2^{(1/2)^{2^{2^{2^2}}}}}}}$

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.

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!

$\log_1(x)$POSITIVE_INFINITY$x\gt1$NEGATIVE_INFINITY$x\lt1$0.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.

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

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

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