Contribution

Entiers a1, a2, a3, b1, b2, b3 chacun compris entre 1 et 20.

Sortie

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

^ est l'exponentiation dans cette question.

Règles

C'est du code-golf. Votre code doit se terminer correctement dans les 10 secondes pour toute entrée valide sur un ordinateur de bureau standard.

Vous pouvez générer n'importe quoi Truthy for True et n'importe quoi Falsey for False.

Vous pouvez assumer n'importe quel ordre de saisie que vous aimez tant qu'il est spécifié dans la réponse et toujours le même.

Pour cette question, votre code doit toujours être correct. Autrement dit, il ne devrait pas échouer en raison d'inexactitudes en virgule flottante. En raison de la plage limitée de l'entrée, cela ne devrait pas être trop difficile à réaliser.

Cas de 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 octets

-2 octets grâce à Grimy

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

Essayez-le en ligne!

Croyez-le ou non, ce n'est pas un esolang, même s'il est composé principalement d'astérisques. Cela utilise la formule d'Arnauld , avec log10 au lieu de ln.

R , 39 octets

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

Essayez-le en ligne!

Retourne FALSE quand a > bet TRUE sib < a

05AB1E , 11 9 11 7 octets

.²Šm*`›

Port de @Arnauld 's JavaScript et @digEmAll de R approche (je les ai vus poste dans le même temps)
-2 octets grâce à @Emigna
+2 octets comme bug-fix après @Arnauld ' s et @digEmAll réponses de contenues une erreur de
-4 octets maintenant qu'un ordre d'entrée différent est autorisé après les commentaires de @LuisMendo

Entrée en [a1,b1], [a3,b3], [a2,b2]en tant que trois entrées séparées.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Crédits

• @ Ørjan Johansen pour avoir trouvé un bug dans ma solution.
• 10 octets enregistrés en réutilisant l' agencement d'opérandes avantageux de @ tsh .

Wolfram Language (Mathematica) , 23 octets

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

Essayez-le en ligne!

J , ¹¹ 9 octets

>&(^.@^/)

Essayez-le en ligne!

Arguments donnés sous forme de listes.

• > la gauche est-elle plus grosse?
• &(...) mais d'abord, transformez ainsi chaque argument:
• ^.@^/réduisez-la de droite à gauche avec exponention. Mais parce que l'exponentiation ordinaire limitera l'erreur même pour les nombres étendus, nous prenons les journaux des deux côtés

Nettoyer , 44 octets

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

Essayez-le en ligne!

Utilise une adaptation de la formule d'Arnauld.

Python 3 , 68 octets

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

Essayez-le en ligne!

Le port de @Arnualds répond, mais la base du journal a changé.

05AB1E , 13 octets

Utilise la méthode de la réponse JS d' Arnauld

2F.²IIm*ˆ}¯`›

Essayez-le en ligne!

Excel, 28 octets

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

Implémentation Excel de la même formule déjà utilisée.

JavaScript, 51 octets

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

Étonnamment, les cas de test ne montrent aucune erreur en virgule flottante. Je ne sais pas si c'est le cas à cette taille.

Cela compare simplement le logarithme des nombres.

La tolérance à l'égalité est égale à 1e-8.

bc -l, 47 octets

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

avec l'entrée lue STDIN, un entier par ligne.

bcest assez rapide; il gère a = b = c = d = e = f = 1 000 000 en un peu plus d'une seconde sur mon ordinateur portable.

C ++ (gcc) , 86 octets

Merci à @ ØrjanJohansen d'avoir signalé un défaut et à @Ourous d'avoir corrigé.

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

Essayez-le en ligne!

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

Gelée , 8 octets

l⁵×*/}>/

Essayez-le en ligne!

Basé sur la réponse JS d'Arnauld . Attend en entrée [a1, b1]comme argument de gauche et [[a2, b2], [a3, b3]]comme argument de droite.

Maintenant modifié pour utiliser le journal de la base 10 qui, dans la mesure du possible, gère correctement toutes les entrées possibles dans la plage spécifiée. Merci à Ørjan Johansen d'avoir trouvé le problème d'origine!

TI-BASIC, 27 31 octets

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

$6$Ans

Exemples:

{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

Explication:

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"

Remarque: TI-BASIC est un langage à jetons. Le nombre de caractères n'est pas égal au nombre d'octets.

APL (NARS), caractères 36, octets 72

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

Ci-dessous, la fonction z dans (abc) z (xyt) retournerait 1 si a ^ (b ^ c)> x ^ (y ^ t) sinon retournerait 0; tester

  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} est la fonction p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)) et si aa = a ^ (b ^ c) avec a, b, c> 0 et a> 1 bb = x ^ (y ^ t) avec x, y, t> 0 et x> 1 que

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

Il y a un problème avec la fonction p: quand a est 1, le journal de log 1 n'existe pas, je choisis donc de représenter cela avec le nombre -1; quand a = 2 donc log log a est un nombre négatif mais> -1.

PS. Vu la fonction dans son ensemble plus grand dans lequel est défini

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

apparaît la plage pour a, b, c dans 1..20 est trop peu ... Si on voit quand il déborde avec log base 10, la plage pour a, b, c pourrait être 1..10000000 ou plus grande pour un 64 bits type flotteur.