вход

Целые числа a1, a2, a3, b1, b2, b3, каждое в диапазоне от 1 до 20.

Выход

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

^ это возведение в степень в этом вопросе.

правила

Это код-гольф. Ваш код должен завершаться правильно в течение 10 секунд для любого допустимого ввода на стандартном настольном ПК.

Вы можете вывести что-нибудь Truthy для True и что-нибудь Falsey для False.

Вы можете принять любой порядок ввода, который вам нравится, если он указан в ответе и всегда одинаков.

Для этого вопроса ваш код всегда должен быть правильным. То есть он не должен выходить из строя из-за неточностей с плавающей запятой. Из-за ограниченного диапазона входных данных это не должно быть слишком трудным для достижения.

Контрольные примеры

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 байт

-2 байта благодаря Грими

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

Попробуйте онлайн!

Верьте или нет, это не esolang, даже если он состоит в основном из звездочек. При этом используется формула Арно , с log10 вместо ln.

R , 39 байт

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

Попробуйте онлайн!

Возвращает FALSE когда a > bи TRUE еслиb < a

05AB1E , 11 9 11 7 байт

.²Šm*`›

Порт @Arnauld 's JavaScript и @digEmAll 's R подходов (я видел их примерно в одно и то же время)
-2 байта благодаря @Emigna
+2 байта как исправлению ошибки после того, как ответы @Arnauld и @digEmAll содержали ошибка
-4 байта теперь, когда после комментариев @LuisMendo разрешен другой порядок ввода

Входные данные, как [a1,b1], [a3,b3], в [a2,b2]виде трех разделенных входов.

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

.²       # 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 байт

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

Попробуйте онлайн!

кредиты

• @ Örjan Johansen за обнаружение ошибки в моем решении.
• Экономия 10 байтов за счет повторного использования выгодных операндов @ tsh .

Wolfram Language (Mathematica) , 23 байта

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

Попробуйте онлайн!

J , ¹¹ 9 байт

>&(^.@^/)

Попробуйте онлайн!

Аргументы приведены в виде списков.

• > левый больше?
• &(...) но сначала преобразуйте каждый аргумент следующим образом:
• ^.@^/уменьшите это справа налево с показателем. Но поскольку обычное возведение в степень ограничит ошибку даже для расширенных чисел, мы берем журналы обеих сторон

Чисто , 44 байта

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

Попробуйте онлайн!

Использует адаптацию формулы Арно.

Python 3 , 68 байт

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

Попробуйте онлайн!

Порт @Arnualds отвечаю, но база для логов изменилась.

05AB1E , 13 байтов

Использует метод из ответа Арнаулда JS

2F.²IIm*ˆ}¯`›

Попробуйте онлайн!

Excel, 28 байт

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

В Excel реализация той же формулы уже используется.

JavaScript, 51 байт

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

Удивительно, но тестовые примеры не показывают ошибок с плавающей точкой. Я не знаю, будет ли это когда-либо в таком размере.

Это просто сравнивает логарифм чисел.

Равенство терпимости равно 1e-8.

bc -l, 47 байт

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

с входным чтением STDIN, по одному целому числу на строку.

bcдовольно быстро; он обрабатывает a = b = c = d = e = f = 1 000 000 за чуть более секунды на моем ноутбуке.

C ++ (gcc) , 86 байт

Спасибо @ ØrjanJohansen за указание на недостаток в этом и @Ourous за исправление.

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

Попробуйте онлайн!

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

Желе , 8 байт

l⁵×*/}>/

Попробуйте онлайн!

Основано на ответе Арно . Ожидается как вход[a1, b1] как левый аргумент и [[a2, b2], [a3, b3]]как правый аргумент.

Теперь изменилось, чтобы использовать log для базы 10, которая насколько правильно обрабатывает все возможные входы в указанном диапазоне. Спасибо Орджану Йохансену за то, что он нашел оригинальную проблему!

TI-BASIC, 27 31 байт

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

$6$Ans

Примеры:

{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

Объяснение:

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"

Примечание: TI-BASIC - это токенизированный язык. Количество символов не равно количеству байтов.

APL (NARS), символы 36, байты 72

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

Здесь ниже функция z в (abc) z (xyt) вернет 1, если a ^ (b ^ c)> x ^ (y ^ t), в противном случае вернет 0; тест

  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} - функция p (a, b, c) = log (log (a)) + c * log (b) ) = log (log (a ^ b ^ c)) и, если aa = a ^ (b ^ c) с a, b, c> 0 и a> 1 bb = x ^ (y ^ t) с x, y, t> 0 и x> 1, чем

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

Существует проблема с функцией p: когда a равно 1, log log 1 не существует, поэтому я решил представить это числом -1; когда a = 2, так что log log a - отрицательное число, но> -1.

PS. Видела функцию в ее большем наборе, в котором определяется

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

диапазон появления для a, b, c в 1..20 слишком мал ... Если посмотреть, когда он переполняется с помощью базы 10 журналов, диапазон для a, b, c может быть 1..10000000 или больше для 64-битного Тип поплавка.