อินพุต

จำนวน a1, a2, a3, b1, b2, b3 แต่ละค่าในช่วง 1 ถึง 20

เอาท์พุต

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

^ คือการยกกำลังในคำถามนี้

กฎระเบียบ

นี่คือรหัสกอล์ฟ รหัสของคุณจะต้องยุติอย่างถูกต้องภายใน 10 วินาทีสำหรับการป้อนข้อมูลที่ถูกต้องบนพีซีเดสก์ทอปมาตรฐาน

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

คุณสามารถสมมติว่าคำสั่งซื้อใด ๆ ที่คุณต้องการตราบเท่าที่มันระบุไว้ในคำตอบและเสมอเหมือนกัน

สำหรับคำถามนี้รหัสของคุณควรถูกต้องเสมอ นั่นคือมันไม่ควรล้มเหลวเพราะความไม่ถูกต้องของจุดลอย เนื่องจากช่วงอินพุตที่มีอยู่อย่าง จำกัด จึงไม่ควรยากเกินกว่าจะบรรลุผล

กรณีทดสอบ

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 ไบต์

-2 ไบต์ขอบคุณ Grimy

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

ลองออนไลน์!

เชื่อหรือไม่นี่ไม่ใช่ esolang แม้ว่ามันจะประกอบด้วยดอกจันเป็นส่วนใหญ่ สิ่งนี้ใช้สูตรของ Arnauldโดยใช้ log10 แทนที่จะเป็น ln

R , 39 ไบต์

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

ลองออนไลน์!

ส่งคืน FALSE เมื่อa > bและ TRUE ถ้าb < a

05AB1E , 11 9 11 7 ไบต์

.²Šm*`›

ท่าเรือ@Arnauldของ JavaScriptและ@digEmAll 's Rแนวทาง (ผมเห็นพวกเขาโพสต์ในเวลาเดียวกัน)
-2 ไบต์ขอบคุณที่@Emigna
2 ไบต์เป็นข้อผิดพลาดการแก้ไขหลังจาก@Arnauld 's และ@digEmAllตอบ' s ที่มีอยู่ ข้อผิดพลาด
-4 ไบต์ในขณะนี้ที่อนุญาตให้สั่งซื้อที่แตกต่างกันหลังจากความคิดเห็นของ@LuisMendo

การป้อนข้อมูลเป็น[a1,b1], [a3,b3], [a2,b2]สามแยกปัจจัยการผลิต

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

.²       # 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 ไบต์

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

ลองออนไลน์!

เครดิต

• @ Ørjan Johansenเพื่อค้นหาข้อบกพร่องในโซลูชันของฉัน
• บันทึก 10 ไบต์ด้วยการนำตัวดำเนินการที่เป็นประโยชน์ของ @ tshกลับมาใช้อีกครั้ง

ภาษา Wolfram (Mathematica)ขนาด 23 ไบต์

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

ลองออนไลน์!

J , ¹¹ 9 ไบต์

>&(^.@^/)

ลองออนไลน์!

อาร์กิวเมนต์ให้เป็นรายการ

• > ทางซ้ายใหญ่กว่าไหม
• &(...) แต่ก่อนอื่นจงเปลี่ยนข้อโต้แย้งแต่ละข้อดังนี้:
• ^.@^/ลดจากขวาไปซ้ายด้วย exponention แต่เนื่องจากการยกกำลังธรรมดาจะ จำกัด ข้อผิดพลาดแม้จะเป็นจำนวนที่เพิ่มขึ้นเราจึงนำบันทึกของทั้งสองฝั่ง

สะอาด , 44 ไบต์

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

ลองออนไลน์!

ใช้การปรับสูตรของ Arnauld

Python 3 , 68 ไบต์

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

ลองออนไลน์!

พอร์ตของ @Arnualds คำตอบ แต่ด้วยการเปลี่ยนแปลงฐานสำหรับบันทึก

05AB1E , 13 ไบต์

ใช้วิธีนี้จากคำตอบ JS ของ Arnauld

2F.²IIm*ˆ}¯`›

ลองออนไลน์!

Excel, 28 ไบต์

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

การใช้ Excel ของสูตรเดียวกันที่ใช้ไปแล้ว

จาวาสคริปต์, 51 ไบต์

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

น่าแปลกที่กรณีทดสอบไม่แสดงข้อผิดพลาดจุดลอยตัว ฉันไม่รู้ว่ามันจะมีขนาดเท่านี้หรือไม่

นี่เป็นการเปรียบเทียบลอการิทึมของตัวเลข

1e-8ความเท่าเทียมกันความอดทนจะมีค่าเท่ากับ

bc -l, 47 ไบต์

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

ด้วยอินพุตที่อ่านจากSTDINหนึ่งจำนวนเต็มต่อบรรทัด

bcค่อนข้างเร็ว มันจัดการ a = b = c = d = e = f = 1,000,000 ในไม่กี่วินาทีบนแล็ปท็อปของฉัน

C ++ (gcc) , 86 ไบต์

ขอบคุณ @ ØrjanJohansenที่ชี้ให้เห็นข้อบกพร่องในเรื่องนี้และ @Ourous สำหรับการแก้ไข

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

ลองออนไลน์!

รับอินพุตเป็นอาร์เรย์ 6 จำนวนเต็ม ส่งคืน 1 ถ้า$a^{b^c} > d^{e^f}$มิฉะนั้น 0

เยลลี่ขนาด 8 ไบต์

l⁵×*/}>/

ลองออนไลน์!

ขึ้นอยู่กับArnauld คำตอบของ คาดว่าเป็นอินพุต[a1, b1]เป็นอาร์กิวเมนต์ซ้ายและ[[a2, b2], [a3, b3]]อาร์กิวเมนต์ขวา

ตอนนี้เปลี่ยนเป็นใช้บันทึกเป็นฐาน 10 ซึ่งเท่าที่ถูกต้องจัดการอินพุตที่เป็นไปได้ทั้งหมดในช่วงที่ระบุ ขอบคุณØrjan Johansen สำหรับการค้นหาปัญหาดั้งเดิม!

TI-BASIC, 27 31 ไบต์

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

อินพุตคือรายการความยาว $6$ในAns.
ส่งออกจริงถ้าจำนวนใหญ่ครั้งแรกมากกว่าจำนวนใหญ่ที่สอง เอาต์พุตเป็นเท็จมิฉะนั้น

ตัวอย่าง:

{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

คำอธิบาย:

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"

หมายเหตุ: TI-BASIC เป็นภาษาโทเค็น จำนวนตัวอักษรไม่เท่ากับจำนวนไบต์

APL (NARS), ตัวอักษร 36, ไบต์ 72

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

ด้านล่างฟังก์ชัน z ใน (abc) z (xyt) จะส่งคืน 1 ถ้า a ^ (b ^ c)> x ^ (y ^ t) มิฉะนั้นจะส่งคืน 0 ทดสอบ

  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} คือฟังก์ชัน p (a, b, c) = log (log (a)) + c * log (b ) = log (log (a ^ b ^ c)) และถ้า aa = a ^ (b ^ c) ด้วย a, b, c> 0 และ a> 1 bb = x ^ (y ^ t) ด้วย x, y, t> 0 และ x> 1 กว่า

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

มีปัญหากับฟังก์ชัน p: เมื่อ a คือ 1, log log 1 ไม่มีอยู่ดังนั้นฉันเลือกที่จะแทนด้วย -1 เมื่อ a = 2 ดังนั้น log log a เป็นจำนวนลบ แต่> -1

PS เห็นฟังก์ชั่นในชุดที่ใหญ่กว่าซึ่งกำหนดไว้

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

ช่วงที่ปรากฏสำหรับ a, b, c ใน 1..20 มีน้อยเกินไป ... ถ้าใครเห็นเมื่อมันล้นด้วย log ฐาน 10 ช่วงสำหรับ a, b, c อาจเท่ากับ 1..10000000 หรือใหญ่กว่าสำหรับ 64 บิต ประเภทลอย