Eingang

Ganzzahlen a1, a2, a3, b1, b2, b3 jeweils im Bereich von 1 bis 20.

Ausgabe

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

^ ist Potenzierung in dieser Frage.

Regeln

Das ist Code-Golf. Ihr Code muss innerhalb von 10 Sekunden korrekt terminiert sein, damit eine gültige Eingabe auf einem Standard-Desktop-PC möglich ist.

Sie können Truthy für True und Falsey für False ausgeben.

Sie können eine beliebige Eingabereihenfolge annehmen, solange sie in der Antwort angegeben ist und immer dieselbe.

Für diese Frage sollte Ihr Code immer korrekt sein. Das heißt, es sollte nicht an Gleitkommaungenauigkeiten scheitern. Aufgrund des begrenzten Eingangsbereichs sollte dies nicht zu schwer zu erreichen sein.

Testfälle

3^(4^5) > 5^(4^3)
1^(2^3) < 3^(2^1)
3^(6^5) < 5^(20^3)
20^(20^20) > 20^(20^19)
20^(20^20) == 20^(20^20)
2^2^20 > 2^20^2
2^3^12 == 8^3^11
1^20^20 == 1^1^1
1^1^1 == 1^20^20

Perl 6 , 31 29 Bytes

-2 Bytes dank Grimy

*.log10* * ***>*.log10* * ***

Probieren Sie es online!

Ob Sie es glauben oder nicht, dies ist kein Esolang, auch wenn er hauptsächlich aus Sternchen besteht. Dies verwendet die Arnauld-Formel mit log10 anstelle von ln.

R , 39 Bytes

function(x,y,z)rank(log2(x)*(y^z))[1]<2

Probieren Sie es online!

Liefert FALSE when a > bund TRUE ifb < a

05AB1E , 11 9 11 7 Bytes

.²Šm*`›

Port of @Arnauld 's JavaScript und @digEmAll ' s R nähert sich (ich sah sie die gleiche Zeit schreiben um)
-2 Bytes dank @Emigna
+2 Bytes als Bug-Fix nach @Arnauld 's und @digEmAll ' s Antworten enthalten ein Fehler
-4 Bytes jetzt, da nach @LuisMendos Kommentaren eine andere Eingabereihenfolge zulässig ist

Input wie [a1,b1], [a3,b3], [a2,b2]als drei getrennte Eingänge.

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

Erläuterung:

.²       # Take the logarithm with base 2 of the implicit [a1,b1]-input
  Š      # Triple-swap a,b,c to c,a,b with the implicit inputs
         #  The stack order is now: [log2(a1),log2(b1)], [a2,b2], [a3,b3]
   m     # Take the power, resulting in [a2**a3,b2**b3]
    *    # Multiply it with the log2-list, resulting in [log2(a1)*a2**a3,log2(b1)*b2**b3]
     `   # Push both values separated to the stack
      ›  # And check if log2(a1)*a2**a3 is larger than log2(b1)*b2**b3
         # (after which the result is output implicitly)

Java (JDK) , 56 Byte

(a,b,c,d,e,f)->a>Math.pow(d,Math.pow(e,f)/Math.pow(b,c))

Probieren Sie es online!

Credits

• @ Ørjan Johansen für das Finden eines Fehlers in meiner Lösung.
• Durch Wiederverwendung der vorteilhaften Operandenverwaltung von @ tsh wurden 10 Byte eingespart .

Wolfram Language (Mathematica) , 23 Byte

#2^#3Log@#>#5^#6Log@#4&

Probieren Sie es online!

J , ¹¹ 9 Bytes

>&(^.@^/)

Probieren Sie es online!

Argumente als Listen angegeben.

• > Ist der linke größer?
• &(...) Aber zuerst transformiere jedes Argument so:
• ^.@^/reduzieren Sie es von rechts nach links mit Exponential. Da die gewöhnliche Potenzierung den Fehler auch bei erweiterten Zahlen einschränkt, nehmen wir die Protokolle beider Seiten

Sauber , 44 Bytes

import StdEnv
$a b c d e f=b^c/e^f>ln d/ln a

Probieren Sie es online!

Verwendet eine Anpassung der Arnauldschen Formel.

Python 3 , 68 Bytes

lambda a,b,c,d,e,f:log(a,2)*(b**c)>log(d,2)*(e**f)
from math import*

Probieren Sie es online!

Port von @Arnualds antwortet, aber die Basis für das Protokoll wurde geändert.

05AB1E , 13 Bytes

Verwendet die Methode aus Arnauld's JS-Antwort

2F.²IIm*ˆ}¯`›

Probieren Sie es online!

Excel, 28 Bytes

=B1^C1*LOG(A1)>E1^F1*LOG(D1)

Excel-Implementierung der gleichen Formel bereits verwendet.

JavaScript, 51 Bytes

f=(a,b,c,h,i,j)=>(l=Math.log)(a)*b**c-l(h)*i**j>1e-8

Überraschenderweise zeigen die Testfälle keinen Gleitkommafehler. Ich weiß nicht, ob es jemals bei dieser Größe funktioniert.

Dies vergleicht nur den Logarithmus der Zahlen.

Gleichheitstoleranz ist gleich 1e-8.

bc -l, 47 Bytes

l(read())*read()^read()>l(read())*read()^read()

Wenn die Eingabe von gelesen wird STDIN, eine Ganzzahl pro Zeile.

bcist ziemlich schnell; Auf meinem Laptop funktioniert a = b = c = d = e = f = 1,000,000 in etwas mehr als einer Sekunde.

C ++ (gcc) , 86 Bytes

Vielen Dank an @ ØrjanJohansen für den Hinweis auf einen Fehler und an @Ourous für die Behebung.

#import<cmath>
int a(int i[]){return pow(i[1],i[2])/pow(i[4],i[5])>log(i[3])/log(*i);}

Probieren Sie es online!

$a^{b^c} > d^{e^f}$

Gelee , 8 Bytes

l⁵×*/}>/

Probieren Sie es online!

Basierend auf Arnauld's JS Antwort . Erwartet als Eingabe [a1, b1]als linkes Argument und [[a2, b2], [a3, b3]]als rechtes Argument.

Jetzt wurde geändert, dass log auf die Basis 10 angewendet wird, die alle möglichen Eingaben im angegebenen Bereich soweit korrekt verarbeitet. Vielen Dank an Ørjan Johansen, der das ursprüngliche Problem gefunden hat!

TI-BASIC, 27 31 Bytes

ln(Ans(1))Ans(2)^Ans(3)>Ans(5)^Ans(6)(ln(Ans(4

$6$Ans

Beispiele:

{3,4,5,5,4,3
   {3 4 5 5 4 3}
prgmCDGF16
               1
{20,20,20,20,20,19       ;these two lines go off-screen
{20 20 20 20 20 19}
prgmCDGF16
               1
{3,6,5,5,20,3
  {3 6 5 5 20 3}
prgmCDGF16
               0

Erläuterung:

ln(Ans(1))Ans(2)^Ans(3)>Ans(5)^Ans(6)(ln(Ans(4   ;full program
                                                 ;elements of input denoted as:
                                                 ; {#1 #2 #3 #4 #5 #6}

ln(Ans(1))Ans(2)^Ans(3)                          ;calculate ln(#1)*(#2^#3)
                        Ans(5)^Ans(6)(ln(Ans(4   ;calculate (#5^#6)*ln(#4)
                       >                         ;is the first result greater than the
                                                 ; second result?
                                                 ; leave answer in "Ans"
                                                 ;implicit print of "Ans"

Hinweis: TI-BASIC ist eine Token-Sprache. Die Anzahl der Zeichen entspricht nicht der Anzahl der Bytes.

APL (NARS), Zeichen 36, Bytes 72

{>/{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b}¨⍺⍵}

Hier unten würde die Funktion z in (abc) z (xyt) 1 zurückgeben, wenn a ^ (b ^ c)> x ^ (y ^ t) else 0 zurückgeben würde; Prüfung

  z←{>/{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b}¨⍺⍵}
  3 4 5 z 5 4 3
1
  1 2 3 z 3 2 1
0
  3 6 5 z 5 20 3
0
  20 20 20 z 20 20 19
1
  20 20 20 z 20 20 20
0
  2 2 20 z 2 20 2
1
  2 3 12 z 8 3 11
0
  1 20 20 z 1 1 1
0
  1 1 1 z 1 20 20
0
  1 4 5 z 2 1 1
0

{(abc) ← ⍵⋄a = 1: ¯1⋄ (⍟⍟a) + c × ⍟b} ist die Funktion p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)) und wenn aa = a ^ (b ^ c) mit a, b, c> 0 und a> 1 bb = x ^ (y ^ t) mit x, y, t> 0 und x> 1 als

aa>bb <=> log(log(a^b^c))>log(log(x^y^t))  <=>  p(a,b,c)>p(x,y,t)

Es gibt ein Problem mit der Funktion p: Wenn a 1 ist, existiert das Protokoll log 1 nicht, so dass ich es mit der Zahl -1 darstelle; Wenn a = 2, ist log log a eine negative Zahl, aber> -1.

PS. Gesehen die Funktion in seiner größeren Menge, in der definiert ist

p(a,b,c)=log(log(a))+c*log(b)

Der Bereich für a, b, c in 1..20 ist zu gering ... Wenn man sieht, wenn es mit der Log-Basis 10 überläuft, könnte der Bereich für a, b, c für 64-Bit 1..10000000 oder größer sein Schwimmertyp.