Đầu vào

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

Đầu ra

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

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

Quy tắc

Đây là mã golf. 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 máy tính để bàn tiêu chuẩn.

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

Bạn có thể giả sử bất kỳ thứ tự đầu vào nào bạn muốn miễn là nó được chỉ định trong câu trả lời và luôn giống nhau.

Đối với câu hỏi này, mã của bạn phải luôn luôn chính xác. Đó là nó không nên thất bại vì không chính xác điểm nổi. Do phạm vi đầu vào hạn chế, điều này không quá khó để đạt được.

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

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 byte

-2 byte nhờ Grimy

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

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

Dù bạn có tin hay không, đây không phải là một esolang, ngay cả khi nó bao gồm chủ yếu là các dấu hoa thị. Điều này sử dụng công thức của Arnauld , với log10 thay vì ln.

R , 39 byte

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

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

Trả về SAI khi a > bvà TRUE nếub < a

05AB1E , 11 9 11 7 byte

.²Šm*`›

Cảng @Arnauld 's JavaScript và @digEmAll R' s phương pháp tiếp cận (tôi thấy họ gửi trong khoảng thời gian tương tự)
-2 byte nhờ @Emigna
2 byte như lỗi-sửa chữa sau khi @Arnauld 's và @digEmAll câu trả lời' s chứa một lỗi
-4 byte bây giờ cho phép một thứ tự đầu vào khác sau khi nhận xét của @LuisMendo

Đầu vào như [a1,b1], [a3,b3], [a2,b2]như ba tách đầu vào.

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:

.²       # 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 byte

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

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

Tín dụng

• @ Rjan Johansen vì đã tìm thấy một lỗi trong giải pháp của tôi.
• Đã lưu 10 byte bằng cách sử dụng lại các toán hạng thuận lợi của @ tsh .

Ngôn ngữ Wolfram (Mathicala) , 23 byte

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

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

J , ¹¹ 9 byte

>&(^.@^/)

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

Các đối số được đưa ra như danh sách.

• > bên trái có lớn hơn không?
• &(...) nhưng trước tiên, hãy chuyển đổi từng đối số như vậy:
• ^.@^/giảm nó từ bên phải sang bên trái với số mũ. Nhưng vì lũy thừa thông thường sẽ hạn chế lỗi ngay cả đối với các số mở rộng, chúng tôi lấy nhật ký của cả hai bên

Sạch sẽ , 44 byte

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

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

Sử dụng một công thức thích ứng của Arnauld.

Python 3 , 68 byte

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

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

Cổng của @Arnualds trả lời, nhưng với cơ sở cho nhật ký đã thay đổi.

05AB1E , 13 byte

Sử dụng phương thức từ câu trả lời JS của Arnauld

2F.²IIm*ˆ}¯`›

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

Excel, 28 byte

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

Excel thực hiện cùng một công thức đã được sử dụng.

JavaScript, 51 byte

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

Đáng ngạc nhiên, các trường hợp thử nghiệm không hiển thị bất kỳ lỗi dấu phẩy động. Tôi không biết nếu nó bao giờ làm ở kích thước này.

Điều này chỉ so sánh logarit của các con số.

Dung sai bình đẳng bằng 1e-8.

bc -l, 47 byte

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

với đầu vào đọc từ STDIN, một số nguyên trên mỗi dòng.

bclà khá nhanh; nó xử lý a = b = c = d = e = f = 1.000.000 trong một giây trên máy tính xách tay của tôi.

C ++ (gcc) , 86 byte

Cảm ơn @ rjanJohansen đã chỉ ra một lỗ hổng trong việc này và @Ourous đã đưa ra cách khắc phục.

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

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

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

Thạch , 8 byte

l⁵×*/}>/

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

Dựa trên câu trả lời JS của Arnauld . Mong đợi như là đầu vào [a1, b1]như đối số trái và [[a2, b2], [a3, b3]]đối số phải.

Bây giờ đã thay đổi để sử dụng nhật ký cho cơ sở 10, theo như xử lý chính xác tất cả các đầu vào có thể có trong phạm vi được chỉ định. Cảm ơn Ørjan Johansen vì đã tìm ra vấn đề ban đầu!

TI-BASIC, 27 31 byte

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

$6$Ans

Ví dụ:

{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

Giải trình:

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"

Lưu ý: TI-BASIC là ngôn ngữ được mã hóa. Số lượng ký tự không bằng số byte.

APL (NARS), ký tự 36, byte 72

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

Ở đây bên dưới hàm z trong (abc) z (xyt) sẽ trả về 1 nếu a ^ (b ^ c)> x ^ (y ^ t) khác sẽ trả về 0; kiểm tra

  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} là hàm p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)) và nếu aa = a ^ (b ^ c) với a, b, c> 0 và a> 1 bb = x ^ (y ^ t) với x, y, t> 0 và x> 1 hơn

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

Có một vấn đề với hàm p: Khi a là 1, log log 1 không tồn tại nên tôi chọn thể hiện điều đó với số -1; khi a = 2 nên log log a là số âm nhưng> -1.

Tái bút Nhìn thấy hàm trong tập lớn hơn của nó được xác định

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

xuất hiện phạm vi cho a, b, c trong 1..20 là quá ít ... Nếu người ta thấy khi nó tràn vào cơ sở nhật ký 10, thì phạm vi cho a, b, c có thể là 1..10000000 hoặc lớn hơn cho 64 bit loại phao.