คำถามนี้มีเล่ห์เหลี่ยม (และโดยเฉพาะอย่างยิ่งยากกว่าเลขใหญ่ใดที่ใหญ่กว่า ) สำหรับผู้ที่ชอบปริศนาที่ท้าทายมากขึ้น

อินพุต

จำนวน 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 วินาทีในเครื่องของคุณ

คุณสามารถเอาท์พุทอะไรจริงสำหรับ True และอะไรเท็จสำหรับเท็จ

กรณีทดสอบ

จำได้ว่าตามกฎของ 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

กรณีทดสอบใหม่จาก 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

ทับทิม 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ของฐานเข้าสู่ระบบของfa ** 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

รับอินพุตเป็นสองรายการ หมายเหตุ: ยังทำงานกับรายการที่มีขนาดใหญ่ขึ้นหรือรายการที่มีความยาวไม่เท่ากัน แก้ไข: ไม่เป็นความจริงอีกต่อไป; มันยังคงใช้งานได้หากP(a)และP(b)ส่งผลให้สิ่งอันดับแตกต่างกัน แต่หากเป็นรหัสเดียวกันนี้ที่อัปเดตข้างต้นจะใช้ได้กับรายการที่มีขนาดคงที่เท่ากับ 5 เท่านั้น

ลองออนไลน์

คำอธิบาย:

รุ่นของ golfed คำตอบเกี่ยวกับเรื่องนี้ 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 เราจำเป็นต้องมีวิธีการที่ไม่ใช่ตัวเลข ไม่น่าเป็นไปได้เลยที่กรณีวิเคราะห์บางเรื่องยากกว่า 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$

ดังนั้นสิ่งสำคัญที่ต้องพิสูจน์คือเมื่อหัวของหอคอยสูงกว่าจุดหนึ่งและส่วนที่เหลือของ exponents ถูก จำกัด ขอบเขต (และเท่ากันมากมาย) เราสามารถดูค่าที่ต่างกันสูงสุด มันค่อนข้างเคาน์เตอร์หยั่งรู้ แต่ดูเหมือนว่าเป็นไปได้มากจากความไม่เท่าเทียมที่คุณได้รับ

เนื่องจากแผน 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) recursive S(a,b)หากP(a)และP(b)ส่งผลให้ tuple เดียวกันค่า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›

พอร์ตของ@SimplyBeautifulArtคำตอบของ Rubyดังนั้นอย่าลืมโหวตเขา!

$\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 จากคำตอบของ 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);}

ลองออนไลน์

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}

ฟังก์ชั่นด้านบน call 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 (f (aa)))> 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↓⍵}

ที่ฉันไม่เข้าใจถ้ามันโอเคและไม่นับพารามิเตอร์ด้วย ... ทดสอบ:

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

พอร์ตของ@SimplyBeautifulArtคำตอบของ Rubyดังนั้นอย่าลืมโหวตเขา!
-14 ไบต์ขอบคุณที่@SimplyBeautifulArt
+17 ไบต์สำหรับการแก้ไขข้อบกพร่องเช่นเดียวกับคำตอบทับทิม

ลองออนไลน์

คำอธิบาย:

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