Pertanyaan ini rumit (dan khususnya lebih sulit daripada Jumlah besar mana yang lebih besar? ), Bagi mereka yang suka teka-teki yang lebih menantang.

Memasukkan

Integer a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 masing-masing dalam kisaran 1 hingga 10.

Keluaran

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

^ adalah eksponensial dalam pertanyaan ini.

Aturan

Ini adalah kode-golf. Kode Anda harus berakhir dengan benar dalam waktu 10 detik untuk setiap input yang valid pada TIO . Jika bahasa Anda tidak pada TIO, kode harus selesai di bawah 10 detik pada mesin Anda.

Anda dapat menampilkan apa pun yang Sejati untuk Benar dan apa pun yang Falsey untuk Salah.

Uji kasus

Ingatlah bahwa dengan aturan eksponensial, a1 ^ (a2 ^ (a3 ^ (a4 ^ a5)))) == a1 ^ a2 ^ a3 ^ a4 ^ a5 ^ 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

Kasus uji baru dari 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

Lihat revisi untuk jumlah byte sebelumnya.

->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 terima kasih kepada @ValueInk

+16 byte berkat @RosLuP untuk bug.

Cobalah online .

Bandingkan menara kekuatan pangkalan yang berbeda (dengan 'tinggi' lima)?

Kode tidak dikunci:

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

Rincian kode:

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

Ini adalah basis tlogaritma, yang akan digunakan untuk mengurangi ukuran angka yang kita bandingkan. Ini default ke basis cketika hanya satu argumen yang diberikan.

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

Pembaruan ini i = i ** jkarena itidak pernah digunakan sendiri, dan ymerupakan hasil dari pencatatan b^c^d^e == g^h^i(^j)dua kali dan memindahkan semuanya ke satu sisi. Kami kemudian membiarkannya z = l[a, f] * b ** csebagai basis glog fdari basis log a ** b ** c.

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

1^b^c^d^e = 1tidak pernah lebih besar dari f^g^h^i^j, dan juga, a^b^c^d^eselalu lebih besar dari 1^g^h^i^j = 1jika a != 1. Perhatikan bahwa return ppengembalian nil, yang palsu, dan return 1kembali 1, yang benar.

elsif b == 1
    return z > h

Jika b == 1atau g == 1, maka ini untuk mengurangi membandingkan a ** b ** cuntuk f ** g ** h, yang dilakukan dengan dua log untuk kedua belah pihak.

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

Ini membandingkan a ** b ** cdengan f ** g ** h ** imenata ulang itu log[log[b ** c * log[a, f], g], h]dibandingkan dengan i. (Ingat itu i **= jdi awal dan z = log[b ** c * log[a, f], g].)

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

Ini membandingkan 4 kekuatan tertinggi setelah masuk kedua sisi dua kali. Jika mereka sama, itu membandingkan basis.

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 berkat @EmbodimentOfIgnorance
-117 byte berkat @ Neil
121 byte selama sekitar lima bug-perbaikan, semua ditemukan oleh @ngn

Mengambil input sebagai dua daftar. CATATAN: Juga berfungsi dengan daftar yang lebih besar atau panjang yang tidak sama. EDIT: Tidak lagi benar; masih berfungsi jika P(a)dan P(b)menghasilkan tupel yang berbeda, tetapi jika sama, kode yang diperbarui ini di atas hanya berfungsi dengan daftar dengan ukuran tetap 5 sekarang.

Cobalah online.

Penjelasan:

Versi Golf jawaban ini di math.stackexchange.com , jadi semua kredit diberikan ke @ThomasAhle .

Mengutip jawabannya:

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

Saya akan tertarik pada saran untuk jenis contoh counter lainnya, terutama yang integer.

Menurut saya, agar masalahnya ada di P, kita perlu metode non-numerik. Tampaknya tidak mungkin sama sekali, bahwa kasus analitis tertentu lebih sulit daripada P.

Contoh:

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)

Contoh balasan:

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

Mengenai contoh-contoh balasan, ia menyebutkan yang berikut di bagian komentar:

$1<a<100$

Oleh karena itu hal utama yang harus dibuktikan adalah bahwa sekali kepala menara melebihi titik tertentu, dan sisa eksponen terikat (dan sama-sama banyak), kita dapat dengan mudah melihat perbedaan nilai teratas. Ini agak kontra intuitif, tetapi tampaknya sangat mungkin dari ketidaksetaraan sederhana yang Anda dapatkan.

Karena rencana A dan B tidak relevan dalam tantangan ini, karena tingginya 5 untuk kedua menara listrik yang kami input, maka rencana C adalah. Jadi saya sudah berubah P(a)>P(b)untuk P(S(a,b))>P(S(b,a))if P(a)==P(b)else P(a)>P(b)dengan fungsi rekursif S(a,b). Jika P(a)dan P(b)menghasilkan tuple yang sama, yang P(S(a,b))>P(S(b,a))pertama akan menghapus nilai trailing yang sama pada indeks yang sama, sebelum melakukan P(A)>P(B)pengecekan yang sama pada daftar yang sekarang lebih pendek ini.

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›

Port of @SimplyBeautifulArt 's Ruby menjawab , jadi pastikan untuk membatalkannya!

$\log_1(x)$POSITIVE_INFINITY$x\gt1$NEGATIVE_INFINITY$x\lt1$ , tetapi menghasilkan 0.0untuk kedua kasus, bukan di 05AB1E (yaitu kasus uji [3,2,2,1,1,2,5,1,1,1]( POSITIVE_INFINITEkasus) dan [2,4,1,1,1,3,3,1,1,1]( NEGATIVE_INFINITYkasus).

Masukan sebagai daftar bilangan bulat sepuluh: [a,b,c,d,e,f,g,h,i,j].

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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)

Jika ada yang ingin mencoba dan golf lebih jauh, ini adalah program pembantu yang saya gunakan untuk mendapatkan variabel yang benar dari daftar input.

C, 168 180 byte

Port C dari jawaban 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);}

Cobalah online

APL (NARS), karakter 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}

Fungsi panggilan di atas z, dalam "az w" akan mengembalikan 1 jika nomor dalam a lebih besar dari angka di w, jika tidak maka akan mengembalikan 0.

Jika saya punya

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

Ini akan menjadi f (aa)> f (bb) dengan array aa dan bb dari 5 angka positif jika dan hanya jika (jika a> 1 dari aa dan bb) log (log (f (aa)))> log ( log (f (bb))) kita harus menggunakan hukum log ():

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

untuk build v (aa) = log (log (aa)) = v (a, b, c, d, e) = log (log (a)) + log (b) (c ^ (d ^ e)) = {p (3 ↑ ⍵), / 3 ↓ ⍵} berfungsi dan latihannya ditemukan ketika v (aa)> v (bb).

Tetapi ada kasus di mana v (aa) dan v (bb) keduanya tak terbatas (APL telah mengakhiri ruang apung) dalam hal itu saya akan menggunakan fungsi tidak aman

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

bahwa saya tidak sepenuhnya mengerti apakah itu baik-baik saja dan tidak menghitung parameter juga ... tes:

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

Port of @SimplyBeautifulArt 's Ruby menjawab , jadi pastikan untuk membatalkannya!
-14 byte berkat @SimplyBeautifulArt .
+17 byte untuk perbaikan bug yang sama dengan jawaban Ruby.

Cobalah online.

Penjelasan:

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