Câu hỏi này rất khó (và đặc biệt khó hơn số lớn nào lớn hơn? ), Dành cho những người thích những câu đố khó hơn.

Đầu vào

Các số nguyên a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 mỗi trong phạm vi từ 1 đến 10.

Đầu ra

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

^ là lũy thừa trong câu hỏi này.

Quy tắc

Đây là môn đánh gôn. Mã của bạn phải chấm dứt chính xác trong vòng 10 giây đối với mọi đầu vào hợp lệ trên TIO . Nếu ngôn ngữ của bạn không có trên TIO, mã sẽ kết thúc dưới 10 giây trên máy của bạn.

Bạn có thể xuất bất cứ thứ gì Truthy for True và bất cứ thứ gì Falsey cho false.

Các trường hợp thử nghiệm

Hãy nhớ lại rằng theo quy tắc của exponentiaon, 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

Các trường hợp thử nghiệm mới từ Kevin Cruijssen

[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

Ruby, 150 byte

Xem bản sửa đổi cho số byte trước đó.

->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 byte nhờ @ValueInk

+16 byte nhờ @RosLuP cho các lỗi.

Hãy thử trực tuyến .

So sánh các tháp sức mạnh cơ sở khác nhau (của 'chiều cao' năm)?

Mã bị đánh cắp:

-> 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
}

Mã lỗi:

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

Đây là tlogarit cơ sở , sẽ được sử dụng để giảm kích thước của các số chúng ta đang so sánh. Nó mặc định là cơ sở ckhi chỉ có một đối số được đưa ra.

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

Bản cập nhật này i = i ** jvì ikhông bao giờ được sử dụng riêng và ylà kết quả của việc đăng nhập b^c^d^e == g^h^i(^j)hai lần và chuyển mọi thứ sang một bên. Sau đó chúng ta để z = l[a, f] * b ** clàm cơ sở gnhật ký fcủa cơ sở nhật ký a ** b ** c.

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

1^b^c^d^e = 1không bao giờ lớn hơn f^g^h^i^j, và tương tự, a^b^c^d^eluôn luôn lớn hơn 1^g^h^i^j = 1nếu a != 1. Lưu ý rằng return ptrả về nil, đó là falsey, và return 1trả lại 1, đó là sự thật.

elsif b == 1
    return z > h

Nếu b == 1hoặc g == 1, thì điều này giảm so a ** b ** cvới f ** g ** h, được thực hiện với hai bản ghi cho cả hai bên.

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

Điều này so sánh a ** b ** cvới f ** g ** h ** ibằng cách sắp xếp lại nó log[log[b ** c * log[a, f], g], h]so với i. (Nhớ lại rằng i **= jvào đầu và z = log[b ** c * log[a, f], g].)

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

Điều này so sánh 4 quyền hạn cao nhất sau khi đăng nhập cả hai bên. Nếu chúng bằng nhau, nó so sánh cơ sở.

Python 2, 671 612 495 490 611 597 byte

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 byte nhờ @EmbodimentOfIgnorance
-117 byte nhờ @Neil
+ 121 byte cho khoảng năm bản sửa lỗi, tất cả được tìm thấy bởi @ngn

Lấy đầu vào là hai danh sách. LƯU Ý: Cũng hoạt động với danh sách lớn hơn hoặc những danh sách có độ dài không bằng nhau. EDIT: Không còn đúng nữa; nó vẫn hoạt động nếu P(a)và P(b)dẫn đến các bộ dữ liệu khác nhau, nhưng nếu chúng giống nhau thì mã cập nhật ở trên chỉ hoạt động với các danh sách có kích thước cố định là 5.

Hãy thử trực tuyến.

Giải trình:

Phiên bản đánh gôn của câu trả lời này trên math.stackexchange.com , vì vậy tất cả tín dụng đều thuộc về @ThomasAhle .

Để trích dẫn câu trả lời của anh ấy:

$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}}}}}}}$

Tôi sẽ quan tâm đến các đề xuất cho các loại ví dụ khác, đặc biệt là các số nguyên.

Dường như với tôi, đối với bài toán nằm trong P, chúng ta cần các phương thức phi số. Dường như không có khả năng nào cả, rằng một số trường hợp phân tích nhất định khó hơn P.

Ví dụ:

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)

Ví dụ truy cập:

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

Về các ví dụ phản biện, ông đề cập đến những điều sau đây trong phần bình luận:

$1<a<100$

Do đó, điều chính cần được chứng minh là một khi phần đầu của tháp vượt quá một điểm nhất định và phần còn lại của số mũ bị giới hạn (và nhiều số bằng nhau), chúng ta có thể chỉ cần nhìn vào giá trị khác nhau hàng đầu. Đó là một chút phản trực quan, nhưng có vẻ như rất có thể từ sự bất bình đẳng đơn giản mà bạn nhận được.

Vì kế hoạch A và B không liên quan trong thử thách này, vì chiều cao là 5 cho cả hai tháp năng lượng mà chúng tôi nhập vào, kế hoạch C là như vậy. Vì vậy, tôi đã thay đổi P(a)>P(b)đến P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)với chức năng đệ quy S(a,b). Nếu P(a)và P(b)kết quả trong cùng một bộ dữ liệu, P(S(a,b))>P(S(b,a))trước tiên , sẽ loại bỏ các giá trị theo dõi bằng nhau tại cùng các chỉ số, trước khi thực hiện P(A)>P(B)kiểm tra tương tự trên các danh sách ngắn hơn hiện tại này.

05AB1E , 96 104 byte

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›

Cổng câu trả lời Ruby của @SimplyBeautitableArt , vì vậy hãy đảm bảo nâng cấp anh ấy!

$\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

Nhập dưới dạng danh sách mười số nguyên : [a,b,c,d,e,f,g,h,i,j].

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Nếu bất cứ ai muốn thử và đánh gôn thêm, đây là chương trình trợ giúp tôi đã sử dụng để lấy các biến chính xác từ danh sách đầu vào.

C, 168 180 byte

Cổng C từ câu trả lời của Kevin Cruijssen.

#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);}

Dùng thử trực tuyến

APL (NARS), ký tự 118, byte 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}

Hàm trên gọi z, trong "az w" sẽ trả về 1 nếu số trong a lớn hơn số trong w, nếu không nó sẽ trả về 0.

Nếu tôi có

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

Nó sẽ là f (aa)> f (bb) với cả mảng aa và bb gồm 5 số dương khi và chỉ khi (nếu a> 1 của aa và bb) log (log (f (aa))))> log ( log (f (bb))) người ta phải sử dụng luật log ():

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

for build v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = Hàm {p (3 ↑ ⍵), / 3 ↓ ⍵} và do đó bài tập được tìm thấy khi v (aa)> v (bb).

Nhưng có một trường hợp v (aa) và v (bb) đều vô hạn (APL đã kết thúc không gian nổi) trong trường hợp đó tôi sẽ sử dụng hàm không bảo mật

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

rằng tôi không hoàn toàn hiểu nếu nó ổn và nó cũng không tính đến một tham số ... kiểm tra:

  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 byte

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]);}

Cổng câu trả lời Ruby của @SimplyBeautitableArt , vì vậy hãy đảm bảo nâng cấp anh ấy!
-14 byte nhờ @SimplyBeautitableArt .
+17 byte cho các sửa lỗi tương tự như câu trả lời của Ruby.

Hãy thử trực tuyến.

Giải trình:

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]);}