Entrada

Inteiros a1, a2, a3, b1, b2, b3, cada um no intervalo de 1 a 20.

Saída

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

^ é exponenciação nesta questão.

Regras

Isso é código-golfe. Seu código deve terminar corretamente em 10 segundos para qualquer entrada válida em um PC de mesa padrão.

Você pode produzir qualquer coisa Truthy for True e qualquer coisa Falsey for False.

Você pode assumir qualquer ordem de entrada que desejar, desde que especificada na resposta e sempre a mesma.

Para esta pergunta, seu código deve estar sempre correto. Ou seja, não deve falhar devido a imprecisões de ponto flutuante. Devido ao alcance limitado da entrada, isso não deve ser muito difícil de alcançar.

Casos de teste

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 graças ao Grimy

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

Experimente online!

Acredite ou não, isso é não um esolang, mesmo que seja composto principalmente de asteriscos. Isso usa a fórmula de Arnauld , com log10 em vez de ln.

R , 39 bytes

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

Experimente online!

Retorna FALSE quando a > be VERDADEIRO seb < a

05AB1E , 11 9 11 7 bytes

.²Šm*`›

Porto de @Arnauld 's JavaScript e @Arnauld R do @digEmAll (eu os vi postando na mesma época)
-2 bytes graças a @Emigna
+2 bytes como correção de bugs após as respostas de @Arnauld e @digEmAll contidas um erro
-4 bytes agora que uma ordem de entrada diferente é permitida apósos comentários de @LuisMendo

De entrada como [a1,b1], [a3,b3], [a2,b2]como três entradas separadas.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

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

Experimente online!

Créditos

• @ Ørjan Johansen por encontrar um bug na minha solução.
• Economizou 10 bytes reutilizando a vantagem da operação dos operandos do @ tsh .

Wolfram Language (Mathematica) , 23 bytes

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

Experimente online!

J , ¹¹ 9 bytes

>&(^.@^/)

Experimente online!

Argumentos dados como listas.

• > a esquerda é maior?
• &(...) mas primeiro, transforme cada argumento assim:
• ^.@^/reduza-o da direita para a esquerda com exponência. Mas como a exponenciação comum limitará o erro, mesmo para números estendidos, pegamos os logs de ambos os lados

Limpo , 44 bytes

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

Experimente online!

Usa uma adaptação da fórmula de Arnauld.

Python 3 , 68 bytes

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

Experimente online!

Resposta da porta do @Arnualds, mas com a base do log alterada.

05AB1E , 13 bytes

Usa o método da resposta JS de Arnauld

2F.²IIm*ˆ}¯`›

Experimente online!

Excel, 28 bytes

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

Implementação em Excel da mesma fórmula já usada.

JavaScript, 51 bytes

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

Surpreendentemente, os casos de teste não mostram nenhum erro de ponto flutuante. Não sei se é desse tamanho.

Isso apenas compara o logaritmo dos números.

A tolerância à igualdade é igual a 1e-8.

bc -l, 47 bytes

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

com a entrada lida STDIN, um número inteiro por linha.

bcé bem rápido; ele lida com a = b = c = d = e = f = 1.000.000 em pouco mais de um segundo no meu laptop.

C++ (gcc), 86 bytes

Thanks to @ØrjanJohansen for pointing out a flaw in this and @Ourous for giving a fix.

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

Try it online!

Takes input as a 6-integer array. Returns 1 if $a^{b^c} > d^{e^f}$, 0 otherwise.

Jelly, 8 bytes

l⁵×*/}>/

Try it online!

Based on Arnauld’s JS answer. Expects as input [a1, b1] as left argument and [[a2, b2], [a3, b3]] as right argument.

Now changed to use log to the base 10 which as far as correctly handles all the possible inputs in the range specified. Thanks to Ørjan Johansen for finding the original problem!

TI-BASIC, 27 31 bytes

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

Entrada é uma lista de comprimento $6$no Ans.
Saída true se o primeiro número grande for maior que o segundo número grande. Caso contrário, gera false.

Exemplos:

{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

Explicação:

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 é um idioma tokenizado. Contagem de caracteres não é igual à contagem de bytes.

APL (NARS), caracteres 36, bytes 72

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

Aqui abaixo da função z em (abc) z (xyt) retornaria 1 se a ^ (b ^ c)> x ^ (y ^ t) retornasse 0; teste

  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} é a função p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)) e se aa = a ^ (b ^ c) com a, b, c> 0 e a> 1 bb = x ^ (y ^ t) com x, y, t> 0 ex> 1 que

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

Há um problema com a função p: Quando a é 1, o log de log 1 não existe, então eu escolhi representá-lo com o número -1; quando a = 2, então log log a é um número negativo, mas> -1.

PS. Visto a função em seu conjunto maior, no qual é definido

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

o intervalo de exibição para a, b, c em 1..20 é muito pequeno ... Se alguém observar quando ele ultrapassa a base de log 10, o intervalo para a, b, c pode ser de 1..10000000 ou maior para 64 bits tipo de flutuador.