Ingresso

Numeri interi a1, a2, a3, b1, b2, b3 ciascuno nell'intervallo da 1 a 20.

Produzione

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

^ è esponenziazione in questa domanda.

Regole

Questo è code-golf. Il codice deve terminare correttamente entro 10 secondi per qualsiasi input valido su un PC desktop standard.

Puoi produrre qualsiasi cosa Verità per vero e qualsiasi cosa Falsey per falso.

Puoi assumere qualsiasi ordine di input che desideri purché sia ​​specificato nella risposta e sempre lo stesso.

Per questa domanda il tuo codice dovrebbe essere sempre corretto. Cioè non dovrebbe fallire a causa di imprecisioni in virgola mobile. A causa della gamma limitata dell'input, questo non dovrebbe essere troppo difficile da ottenere.

Casi test

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 byte

-2 byte grazie a Grimy

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

Provalo online!

Che ci crediate o no, questo non è un esolang, anche se è composto principalmente da asterischi. Questo utilizza la formula di Arnauld , con log10 anziché ln.

R , 39 byte

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

Provalo online!

Restituisce FALSO quando a > be VERO seb < a

05AB1E , 11 9 11 7 byte

.²Šm*`›

Porto di @Arnauld 's JavaScript e @digEmAll ' s R si avvicina (li ho visti postare intorno allo stesso tempo)
-2 byte grazie alla @Emigna
+2 byte come bug-fix dopo @Arnauld 's e @digEmAll risposte' s contenevano un errore di
-4 byte ora che è consentito un diverso ordine di input dopo i commenti di @LuisMendo

Input come [a1,b1], [a3,b3], [a2,b2]come tre ingressi separati.

Provalo online o verifica tutti i casi di test .

Spiegazione:

.²       # 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))

Provalo online!

Crediti

• @ Ørjan Johansen per aver trovato un bug nella mia soluzione.
• Salvato 10 byte riutilizzando l' agenzia di operandi vantaggiosi di @ tsh .

Wolfram Language (Mathematica) , 23 byte

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

Provalo online!

J , ¹¹ 9 byte

>&(^.@^/)

Provalo online!

Argomenti forniti come elenchi.

• > quello di sinistra è più grande?
• &(...) ma prima, trasforma ogni argomento in questo modo:
• ^.@^/ridurlo da destra a sinistra con esponenzione. Ma poiché l'espiazione ordinaria limiterà l'errore anche per i numeri estesi, prendiamo i registri di entrambe le parti

Pulito , 44 byte

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

Provalo online!

Utilizza un adattamento della formula di Arnauld.

Python 3 , 68 byte

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

Provalo online!

La porta di @Arnualds risponde, ma con la base per il registro modificata.

05AB1E , 13 byte

Utilizza il metodo dalla risposta JS di Arnauld

2F.²IIm*ˆ}¯`›

Provalo online!

Excel, 28 byte

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

Implementazione Excel della stessa formula già utilizzata.

JavaScript, 51 byte

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

Sorprendentemente, i casi di test non mostrano alcun errore in virgola mobile. Non so se lo farà mai a queste dimensioni.

Questo confronta solo il logaritmo dei numeri.

La tolleranza dell'uguaglianza è uguale a 1e-8.

bc -l, 47 byte

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

con l'input letto da STDIN, un numero intero per riga.

bcè abbastanza veloce; gestisce a = b = c = d = e = f = 1.000.000 in poco più di un secondo sul mio laptop.

C ++ (gcc) , 86 byte

Grazie a @ ØrjanJohansen per aver segnalato un difetto in questo e @Ourous per averci dato una soluzione.

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

Provalo online!

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

Gelatina , 8 byte

l⁵×*/}>/

Provalo online!

Basato sulla risposta JS di Arnauld . Si aspetta come input [a1, b1]come argomento di sinistra e [[a2, b2], [a3, b3]]come argomento di destra.

Ora modificato per utilizzare il registro sulla base 10 che, per quanto possibile, gestisce correttamente tutti gli input possibili nell'intervallo specificato. Grazie a Ørjan Johansen per aver trovato il problema originale!

TI-BASIC, 27 31 byte

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

$6$Ans

Esempi:

{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

Spiegazione:

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"

Nota: TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.

APL (NARS), caratteri 36, byte 72

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

Di seguito la funzione z in (abc) z (xyt) restituisce 1 se a ^ (b ^ c)> x ^ (y ^ t) altrimenti restituisce 0; test

  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} è la funzione p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)) e se aa = a ^ (b ^ c) con a, b, c> 0 e a> 1 bb = x ^ (y ^ t) con x, y, t> 0 e x> 1 di

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

C'è un problema con la funzione p: quando a è 1, il registro 1 non esiste, quindi scelgo di rappresentarlo con il numero -1; quando a = 2, il registro log a è un numero negativo ma> -1.

PS. Ho visto la funzione nel suo set più grande in cui è definita

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

appare l'intervallo per a, b, c in 1..20 è troppo pochi ... Se si vede quando trabocca con la base di registro 10, l'intervallo per a, b, c potrebbe essere 1..10000000 o maggiore per un 64 bit tipo di galleggiante.