Це питання є складним (і особливо складніше, ніж Яка велика кількість більша? ) Для тих, хто любить більш складні головоломки.

Вхідні дані

Цілі числа a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 кожен в інтервалі від 1 до 10.

Вихідні дані

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

^ - це експоненція в цьому питанні.

Правила

Це код-гольф. Ваш код повинен правильно скасуватись протягом 10 секунд для будь-якого дійсного вводу в TIO . Якщо ваша мова відсутня в TIO, код повинен закінчитися за 10 секунд на вашій машині.

Ви можете вивести що завгодно Truthy для True та False for False.

Тестові справи

Нагадаємо, що за правилами експоненціаона a1 ^ (a2 ^ (a3 ^ (a4 ^ a5))) == a1 ^ a2 ^ a3 ^ a4 ^ a5.

10^10^10^10^10 > 10^10^10^10^9
1^2^3^4^5 < 5^4^3^2^1
2^2^2^2^3 > 10^4^3^2^2
6^7^8^9^10 is not bigger than 6^7^8^9^10
10^6^4^2^2 < 10^6^2^4^2
2^2^2^2^10 > 2^2^2^10^2
10^9^8^7^6 < 6^7^8^9^10 
3^1^10^10^10 > 2^1^10^10^10 
9^10^10^10^10 < 10^9^10^10^10

Нові тестові справи від Кевіна Круїссена

[10,10,10,10,10, 10,10,10,10,9] #true
[2,2,2,2,3,      10,4,3,2,2]    #true
[2,2,2,2,10,     2,2,2,10,2]    #true
[10,10,10,10,10, 9,10,10,10,10] #true
[3,2,2,1,1,      2,5,1,1,1]     #true
[2,2,3,10,1,     2,7,3,9,1]     #true
[7,9,10,10,10,   6,9,10,10,10]  #true
[3,2,2,2,2,      2,2,2,2,2]     #true
[8,3,1,2,1,      2,2,3,1,1]     #true
[2,4,2,1,1,      3,3,2,1,1]     #true
[5,4,3,2,1,      1,2,3,4,5]     #true

[1,2,3,4,5,      5,4,3,2,1]     #false
[6,7,8,9,10,     6,7,8,9,10]    #false
[10,6,4,2,2,     10,6,2,4,2]    #false
[10,9,8,7,6,     6,7,8,9,10]    #false
[1,10,10,10,10,  1,10,10,10,9]  #false
[2,4,1,1,1,      2,2,2,1,1]     #false
[2,2,2,1,1,      2,4,1,1,1]     #false
[2,5,1,1,1,      3,2,2,1,1]     #false
[4,2,1,1,1,      2,4,1,1,1]     #false
[2,4,1,1,1,      4,2,1,1,1]     #false
[2,3,10,1,1,     8,3,9,1,1]     #false
[8,3,9,1,1,      2,3,10,1,1]    #false
[2,4,1,1,1,      3,3,1,1,1]     #false
[2,2,1,9,9,      2,2,1,10,10]   #false
[2,2,1,10,10,    2,2,1,9,9]     #false
[1,1,1,1,1,      1,2,1,1,1]     #false

Рубін, 150 байт

Дивіться версії попередніх підрахунків байтів.

->a,b,c,d,e,f,g,h,i,j{l=->s,t=c{Math.log(s,t)};y,z=l[l[g,b]]-d**e+l[h]*i**=j,l[l[a,f]*b**c,g];a>1?f<2?1:b<2||g<2?z>h:c<2||d<2?l[z,h]>i:y==0?a>f:y<0:p}

-10 байт завдяки @ValueInk

+16 байт завдяки @RosLuP для помилок.

Спробуйте в Інтернеті .

Порівняйте різні базові потужності-вежі («висоти» п'ять)?

Невикористаний код:

-> a, b, c, d, e, f, g, h, i, j {
    l =-> s, t = c {Math.log(s, t)}
    i **= j
    y = l[l[g, b]] - d ** e + l[h] * i
    z = l[l[a, f] * b ** c, g]
    if a == 1
        return p
    elsif f == 1
        return 1
    elsif b == 1 || g == 1
        return z > h
    elsif d == 1 || c == 1
        return l[z, h] > i
    elsif y == 0
        return a > f
    else
        return y < 0
    end
}

Розбивка коду:

l =-> s, t = c {Math.log(s, t)}

Це базовий tлогарифм, який буде використовуватися для зменшення розміру чисел, які ми порівнюємо. За замовчуванням базується cлише один аргумент.

i **= j
y = l[l[g, b]] - d ** e + l[h] * i
z = l[l[a, f] * b ** c, g]

Це оновлення, i = i ** jоскільки iніколи не використовується самостійно, і yє результатом реєстрації b^c^d^e == g^h^i(^j)двічі та переміщення всього в одну сторону. Тоді ми дамо z = l[a, f] * b ** cв якості основи gжурналу базу fжурналу a ** b ** c.

if a == 1
    return p
elsif f == 1
    return 1

1^b^c^d^e = 1ніколи не перевищує f^g^h^i^j, і так само, a^b^c^d^eзавжди більше, ніж 1^g^h^i^j = 1якби a != 1. Зауважте, що return pповернення nil, яке є фальси, і return 1повернення 1, що є правдою.

elsif b == 1
    return z > h

Якщо b == 1або g == 1, то це зводиться до порівняння a ** b ** cз f ** g ** h, що робиться з двома колодами для обох сторін.

elsif d == 1 || c == 1
    return l[z, h] > i

Це порівнюється a ** b ** cз f ** g ** h ** iперестановкою в log[log[b ** c * log[a, f], g], h]порівнянні з i. (Нагадаємо, що i **= jна початку і z = log[b ** c * log[a, f], g].)

elsif y == 0
    return a > f
else
    return y < 0
end

Це порівнює 4 найвищі потужності після входу обох сторін двічі. Якщо вони рівні, він порівнює основу.

Python 2, 671 612 495 490 611 597 байт

lambda a,b:P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)
def S(a,b):
  if a and a[-1]==b[-1]:
    a.pop()
    b.pop()
    return S(a,b)
from math import*
L=log
E=exp
N=lambda m,n,x:N(m,n+1,L(x))if x>=1else N(m,n-1,E(x))if x<0else(m+n,x)
A=lambda a,n,x:(0,1)if a==1else(1,R(x,n)*L(a))if a<1else N(2,*C(L(L(a)),x,n-1))if n else(1,x*L(a))
def C(c,x,n):
 if c*n==0:return(0if c else n,x+c)
 z=R(x,n-1)
 if z<=L(abs(c)):return(0,E(z)+c)
 return N(1,*C(L(1-E(L(-c)-z)if c<0else 1+E(L(c)-z)),x,n-1))
def R(x,n):
 try:exec'x=E(x)'*n
 except:x=float('inf')
 return x
P=lambda b:b and N(0,*A(b[0],*P(b[1:])))or(0,1)

-59 байт завдяки @EmbodimentOfIgnorance
-117 байт завдяки @Neil
+121 байт приблизно за п’ять виправлень помилок, усі знайдені @ngn

Вважає входи як два списки. ПРИМІТКА. Також працює з більшими списками або списками неоднакової довжини. EDIT: Більше не відповідає дійсності; він все ще працює, якщо P(a)і P(b)призводить до різних кортежів, але якщо вони однакові, цей оновлений код вище працює лише зі списками з фіксованим розміром 5.

Спробуйте в Інтернеті.

Пояснення:

Версія цієї відповіді на golfh на сайті math.stackexchange.com , тому весь кредит припадає на @ThomasAhle .

Щоб процитувати його відповідь:

$n$$(x\mid n) := exp^n(x)$$x\in[0,1)$

$a^{(x\mid n)}$$a$apow

$2^{2^{2^{2^0}}}<2^{2^{2^{2^{(1/2)^{2^{2^{2^2}}}}}}}$

Мені будуть цікаві пропозиції щодо інших типів лічильників, особливо цілих.

Мені здається, що для того, щоб проблема була в Р, нам потрібні нечислові методи. Це зовсім не здається, що певні аналітичні випадки важче, ніж P.

Приклади:

powtow([2,2,2,2,2,2,2,2,2,2,2,2,2,2,4,2,2,2]) = (0.1184590219613409, 18)
powtow([9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]) = (0.10111176550354063, 18)

powtow([2,2,5,2,7,4,9,3,7,6,9,9,9,9,3,2]) = (0.10111176550354042, 17)
powtow([3,3,6,3,9,4,2,3,2,2,2,2,2,3,3,3]) = (0.19648862015624008, 17)

Приклади лічильника:

powtow([2,2,2,2,2,2,2]) = (0.8639310719129168, 6)
powtow([3,2,2,2,2,2,2]) = (0.8639310719129168, 6)

Щодо зустрічних прикладів, він в розділі коментарів згадує таке:

$1<a<100$

Отже, головне, що потрібно довести, це те, що коли голова вежі перевищує певну точку, а решта експонентів обмежені (і однаково численні), ми можемо просто подивитися на верхню різну цінність. Це трохи протилежне інтуїтивному, але це здається дуже ймовірним із простих нерівностей, які ви отримуєте.

Оскільки план A і B не мають значення в цьому виклику, оскільки висота становить 5 для обох веж, які ми вводимо, план C це є. Тому я змінився P(a)>P(b)на P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)рекурсивну функцію S(a,b). Якщо P(a)і в P(b)результаті виходить один і той же кортеж, P(S(a,b))>P(S(b,a))спочатку буде видалено проміжні значення, рівні за одними і тими ж показниками, перед тим, як P(A)>P(B)перевірити ці коротші списки.

05AB1E , 96 104 байт

3èI4èmU8.$`m©I7èI2è.n*I6èI1è.nI2è.n+Vнi0ë5èi1ë2ô1èßi¦2£`mIнI5è.n*I6è.nDI7èDi\1›·<žm*ë.n}®›ëXYQiнI5è›ëXY›

Порт відповіді Ruby @SimplyBeautifulArt , тому обов'язково підтримайте його!

$\log_1(x)$POSITIVE_INFINITY$x\gt1$NEGATIVE_INFINITY$x\lt1$0.0[3,2,2,1,1,2,5,1,1,1]POSITIVE_INFINITE[2,4,1,1,1,3,3,1,1,1]NEGATIVE_INFINITY

Введення в вигляді списку з десяти цілих чисел: [a,b,c,d,e,f,g,h,i,j].

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

3èI4èm         # Calculate d**e
      U        # And pop and store it in variable `X`
8.$`m          # Calculate i**j
     ©         # Store it in variable `®` (without popping)
I7èI2è.n       # Calculate c_log(h)
 *             # Multiply it with i**j that was still on the stack: i**j * c_log(h)
I6èI1è.nI2è.n  # Calculate c_log(b_log(g))
 +             # And sum them together: i**j * c_log(h) + c_log(b_log(g))
  V            # Pop and store the result in variable `Y`

нi             # If `a` is 1:
 0             #  Push 0 (falsey)
ë5èi           # Else-if `f` is 1:
 1             #  Push 1 (truthy)
ë2ô1èßi        # Else-if the lowest value of [c,d] is 1:
 ¦2£`m         #  Calculate b**c
 IнI5è.n       #  Calculate f_log(a)
  *            #  Multiply them together: b**c * f_log(a)
   I6è.n       #  Calculate g_log(^): g_log(b**c * f_log(a))
 D             #  Duplicate it
  I7è          #  Push h
     Di        #  Duplicate it as well, and if h is exactly 1:
       \       #   Discard the duplicated h
       1›      #   Check if the calculated g_log(b**c * f_log(a)) is larger than 1
               #   (which results in 0 for falsey and 1 for truthy)
         ·<    #   Double it, and decrease it by 1 (it becomes -1 for falsey; 1 for truthy)
           žm* #   Multiply that by 9876543210 (to mimic POSITIVE/NEGATIVE INFINITY)
      ë        #  Else:
       .n      #   Calculate h_log(g_log(b**c * f_log(a))) instead
      }        #  After the if-else:
       ®›      #  Check whether the top of the stack is larger than variable `®`
ëXYQi          # Else-if variables `X` and `Y` are equal:
     нI5è›     #  Check whether `a` is larger than `f`
ë              # Else:
 XY›           #  Check whether `X` is larger than `Y`
               # (after which the top of the stack is output implicitly as result)

Якщо хтось хоче спробувати пограти далі, ось програма помічників, яку я використовував, щоб отримати правильні змінні зі списку вхідних даних.

C, 168 180 байт

C порт з відповіді Кевіна Круїссена.

#define l(a,b)log(a)/log(b)
z(a,b,c,d,e,f,g,h,i,j){float t=pow(i,j),y=l(l(g,b),c)-pow(d,e)+l(h,c)*t,z=l(l(a,f)*pow(b,c),g);return~-a&&f<2|(b<2|g<2?z>h:c<2|d<2?l(z,h)>t:y?y<0:a>f);}

Спробуйте в Інтернеті

APL (NARS), символи 118, байти 236

{p←{(a b c d)←⍵⋄a=1:¯1⋄b=1:⍟⍟a⋄(⍟⍟a)+(c*d)×⍟b}⋄(=/(a b)←{p 1↓⍵}¨⍺⍵)∧k←(∞ ∞)≡(m n)←{p(3↑⍵),*/3↓⍵}¨⍺⍵:(↑⍺)>↑⍵⋄k:a>b⋄m>n}

Функція над викликом z, в "az w" повертає 1, якщо число в a більше, ніж число в w, інакше воно поверне 0.

Якщо я маю

f(a,b,c,d,e)=a^b^c^d^e

Це буде f (aa)> f (bb) з масивом aa і bb з 5 позитивних чисел, якщо і тільки якщо (якщо a> 1 aa і bb) log (log (f (aa))))> log ( log (f (bb))) треба використовувати закони log ():

log(A*B)=log(A)+log(B)
log(A^B)=B*log(A)

для build v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} функція, і тому вправа знаходить, коли v (aa)> v (bb).

Але є випадок, коли v (aa) і v (bb) є нескінченними (APL закінчує поплавковий простір), у такому випадку я використовував би незахищену функцію

s(a,b,c,d,e)=log(log(b))+log(c)*(d^e)={p 1↓⍵}

що я не повністю розумію, якщо це нормально, і він не враховує параметр теж ... test:

  z←{p←{(a b c d)←⍵⋄a=1:¯1⋄b=1:⍟⍟a⋄(⍟⍟a)+(c*d)×⍟b}⋄(=/(a b)←{p 1↓⍵}¨⍺⍵)∧k←(∞ ∞)≡(m n)←{p(3↑⍵),*/3↓⍵}¨⍺⍵:(↑⍺)>↑⍵⋄k:a>b⋄m>n}
  10 10 10 10 10 z 10 10 10 10 9
1
  1 2 3 4 5 z 5 4 3 2 1
0
  2 2 2 2 3 z 10 4 3 2 2
1
  10 6 4 2 2 z 10 6 2 4 2
0
  2 2 2 2 10 z 2 2 2 10 2
1
  10 9 8 7 6 z 6 7 8 9 10
0
  10 10 10 10 10 z 10 10 10 10 9
1      
  2 2 2 2 3   z    10 4 3 2 2
1
  2 2 2 2 10   z   2 2 2 10 2
1
  10 10 10 10 10 z 9 10 10 10 10
1
  3 2 2 1 1   z    2 5 1 1 1
1
  2 2 3 10 1  z    2 7 3 9 1
1
  7 9 10 10 10 z   6 9 10 10 10
1
  3 2 2 2 2    z   2 2 2 2 2
1
  3 10 10 10 10 z  2 10 10 10 10
1
  8 3 1 2 1    z   2 2 3 1 1
1
  2 4 2 1 1    z   3 3 2 1 1
1
  5 4 3 2 1    z   1 2 3 4 5
1
  1 2 3 4 5    z   5 4 3 2 1
0
  6 7 8 9 10    z  6 7 8 9 10
0
  10 6 4 2 2 z     10 6 2 4 2
0
  10 9 8 7 6  z   6 7 8 9 10
0
  1 10 10 10 10 z 1 10 10 10 9
0
  2 4 1 1 1 z     2 2 2 1 1
0
  2 2 2 1 1    z  2 4 1 1 1
0
  2 5 1 1 1   z   3 2 2 1 1
0
  4 2 1 1 1   z   2 4 1 1 1
0
  2 4 1 1 1   z   4 2 1 1 1
0
  2 3 10 1 1  z   8 3 9 1 1
0
  8 3 9 1 1   z   2 3 10 1 1
0
  2 4 1 1 1   z   3 3 1 1 1
0
  2 2 1 9 9   z   2 2 1 10 10
0
  2 2 1 10 10 z   2 2 1 9 9
0
  1 1 1 1 1   z   1 2 1 1 1
0
  1 1 1 1 2   z   1 1 1 1 1
0
  1 1 1 1 1   z   1 1 1 1 1
0
  9 10 10 10 10 z  10 9 10 10 10
1
  9 10 10 10 10 z  10 10 10 10 10
0
  10 10 10 10 10 z  10 10 10 10 10
0
  11 10 10 10 10 z  10 10 10 10 10
1

Java 8, 299 288 286 252 210 208 224 байт

Math M;(a,b,c,d,e,f,g,h,i,j)->{double t=M.pow(i,j),y=l(l(g,b),c)-M.pow(d,e)+l(h,c)*t,z=l(l(a,f)*M.pow(b,c),g);return a>1&&f<2|(b<2|g<2?z>h:c<2|d<2?l(z,h)>t:y==0?a>f:y<0);}double l(double...A){return M.log(A[0])/M.log(A[1]);}

Порт відповіді Ruby @SimplyBeautifulArt , тому обов'язково підтримайте його!
-14 байт завдяки @SimplyBeautifulArt .
+17 байт для тих же виправлень помилок, що і відповідь Ruby.

Спробуйте в Інтернеті.

Пояснення:

Math M;                      // Math M=null on class-level to save bytes

(a,b,c,d,e,f,g,h,i,j)->{     // Method with ten integer parameters and boolean return-type
  double t=M.pow(i,j),       //  Temp `t` = `i` to the power `j`
    y=l(l(g,b),c)            //  Temp `y` = `c`_log(`b`_log(`g`))
      -M.pow(d,e)            //  - `d` to the power `e`
      +l(h,c)*t,             //  + `c`_log(`h`) * `t`
    z=l(l(a,f)*M.pow(b,c),g);//  Temp `z` = `g`_log(`f`_log(`a`) * `b` to the power `c`)
  return a>1&&               //  If `a` is 1:
                             //   Return false
   f<2|(                     //  Else-if `f` is 1:
                             //   Return true
    b<2|g<2?                 //  Else-if either `b` or `g` is 1:
     z>h                     //   Return whether `z` is larger than `h`
    :c<2|d<2?                //  Else-if either `c` or `d` is 1:
     l(z,h)>t                //    Return whether `h`_log(`z`) is larger than `t`
    :y==0?                   //   Else-if `y` is 0:
      a>f                    //    Return whether `a` is larger than `f`
    :                        //   Else:
     y<0);}                  //    Return whether `y` is negative

// Separated method to calculate `B`_log(`A`) for inputs `A,B`
double l(double...A){return M.log(A[0])/M.log(A[1]);}