वास्तव में कौन सी बड़ी संख्या बड़ी है?

Question

यह सवाल मुश्किल है (और विशेष रूप से कठिन है कि कौन से बड़ी संख्या बड़ी है? ), उन लोगों के लिए जो अधिक चुनौतीपूर्ण पहेलियाँ पसंद करते हैं।

इनपुट

1 से 10 रेंज में इंटेगर ए 1, ए 2, ए 3, ए 4, ए 5, बी 1, बी 2, बी 3, बी 4, बी 5।

उत्पादन

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

^ इस सवाल में घातांक है।

नियम

यह कोड-गोल्फ है। TIO पर किसी भी मान्य इनपुट के लिए आपका कोड 10 सेकंड के भीतर सही ढंग से समाप्त होना चाहिए । यदि आपकी भाषा TIO पर नहीं है, तो कोड आपके मशीन पर 10 सेकंड के भीतर समाप्त हो जाना चाहिए।

आप कुछ भी ट्रू के लिए ट्रू और कुछ भी फालसे के लिए सच कर सकते हैं।

परीक्षण के मामलों

एक्सपोनेंटिया के नियमों को याद करें, 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

केविन क्रूज़सेन से नए परीक्षण के मामले

[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

Comments

मैं इसे VTC'ing कर रहा हूँ, भले ही यह एक डुबकी नहीं है; यह सिर्फ एक चुनौती के करीब है जिसे आपने 4 घंटे पहले पोस्ट किया था और अद्वितीय चुनौतियों पर विचार करने के प्रयास में कमी दिखाता है।

— मैजिक ऑक्टोपस Urn

मुझे ऐसा लगता है कि मेरी बात पर 9 लोग अपने मतों से सहमत थे; लेकिन, जैसा कि आप कहते हैं, यह आपकी पसंद है, भले ही इसमें 9 डाउनवोट हों। बस कुछ प्रकाश बहा रहा था कि नीचे की ओर क्यों हो सकता है।

— मैजिक ऑक्टोपस Urn

सिर्फ मेरे दो सेंट आदमी थे, ईमानदारी से; हमें यहां विस्तार से जाने की आवश्यकता नहीं है। अफसोस कि मैंने भी कुछ कहा; आखिरी बात जो मैं चाहता था वह एक तर्कपूर्ण प्रतिक्रिया थी। मैं सिर्फ यह बता रहा था कि मैंने -1 क्यों दिया।

— मैजिक ऑक्टोपस Urn

मैं इस पद को फिर से खोलने के लिए मतदान कर रहा हूं क्योंकि इसमें अलग-अलग कठिनाई पैरामीटर हैं और इसे हल करने के लिए आवश्यक दृष्टिकोण बहुत अलग है। मेटा पोस्ट ।

— user202729

सुझाए गए परीक्षण के मामले (पायथन, रूबी, जावा और 05AB1E उत्तरों के सामने आने वाले किनारे के मामलों के लिए)

— केविन क्रूज़सेन

Answer 1

रूबी, 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के लॉग बेस fके रूप में जाने देते हैं a ** 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 उच्चतम शक्तियों की तुलना करता है। यदि वे समान हैं, तो यह आधार की तुलना करता है।

Answer 2

पायथन 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 के निश्चित आकार के साथ सूचियों के साथ काम करता है।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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

मुझे अन्य प्रकार के काउंटर उदाहरणों के सुझावों में दिलचस्पी होगी, विशेष रूप से पूर्णांक वाले।

यह मुझे लगता है कि पी में होने वाली समस्या के लिए, हमें गैर-संख्यात्मक तरीकों की आवश्यकता है। यह बिल्कुल भी संभावना नहीं लगती है, कि कुछ विश्लेषणात्मक मामले पी की तुलना में कठिन हैं।

उदाहरण:

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$

इसलिए मुख्य बात यह है कि एक टावर का सिर एक निश्चित बिंदु से अधिक हो जाने के बाद, और शेष एक्सपोर्टर बंधे होते हैं (और समान रूप से कई), हम बस शीर्ष भिन्नता को देख सकते हैं। यह थोड़ा सा सहज है, लेकिन यह आपको मिलने वाली साधारण असमानताओं से बहुत कम लगता है।

चूँकि योजना 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)पुनरावर्ती क्रिया के साथ S(a,b)। यदि एक ही ट्यूपल में परिणाम P(a)और P(b)परिणाम होता है, तो P(S(a,b))>P(S(b,a))पहले ट्रेसिंग मानों को हटा देगा जो समान सूचकांकों के बराबर हैं, P(A)>P(B)इन छोटी सूचियों पर समान जांच करने से पहले ।

Comments

मैं अजगर में गोल्फ भी चूसता हूं, लेकिन यहां 612 बटर है

— इग्नोरेंस का अवतार

495 बाइट्स

— नील

के लिए विफल[10,10,10,10,10]>[9,10,10,10,10]

— अज्ञानता

आप केवल Rएक बार फ़ंक्शन का उपयोग करते हैं , इसलिए शायद आप इसे केवल इनलाइन कर सकते हैं?

— अज्ञानता

@EmbodimentofIgnorance Rलाइन 5 पर अभी भी एक उत्कृष्ट कॉल है ...

— नील

Answer 3

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 का रूबी जवाब है , इसलिए उसे उभारना सुनिश्चित करें!

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

अगर कोई इसे और आगे बढ़ाने की कोशिश करना चाहता है, तो यहां एक सहायक कार्यक्रम है जिसका मैंने इनपुट-सूची से सही चर प्राप्त करने के लिए उपयोग किया है।

Comments

बहुत प्रभावित यह 100 के तहत मिल गया है! और बाउंटी को जोड़ने के लिए बहुत-बहुत धन्यवाद।

— अनुष

@ आंसू मुझे वास्तव में लग रहा है 96 बहुत सुंदर है, गैर-गोल्फ भाषा पर विचार करते हुए रूबी को 151 मिला; पी और एनपीटी इनाम के बारे में। यह मुख्य रूप से @SimplyBeautifulArt के दृष्टिकोण के लिए है, लेकिन एक ही समय में चुनौती को कुछ ध्यान देने के लिए। इसका कारण यह बताया गया है क्योंकि आपने 3 शक्तियों के साथ अपने पहले के उत्तर के कुछ घंटे बाद इसे पोस्ट किया था। मैं व्यक्तिगत रूप से इस चुनौती को पसंद करता हूं, और यह पहली बार अपवोट और इसका जवाब देने वाला था, लेकिन मैं अभी भी थोड़े समय में पहली पोस्ट में चुनौती पोस्ट के तहत सच देख सकता हूं। उम्मीद है कि इनाम आपकी चुनौती को 0 या सकारात्मक बना देगा, हालांकि :)

— केविन क्रूज़सेन

मैं एक पाने का सपना 0! :)

— अनुष

[2,1,1,1,1,3,1,1,1,1] परिणाम 1 के बजाय परिणाम 0

— RosLuP

$log_1(x)$

Answer 4

सी, 168 180 बाइट्स

केविन क्रूज़सेन के जवाब से सी पोर्ट।

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

इसे ऑनलाइन आज़माएं

Comments

हम्मम

— ब्यूटीफुल आर्ट

3,1,10,10,10,2,1,10,10,10मेरे जावा उत्तर की तरह विफल भी हुआ करते थे। और यह वास्तव में @ SimplyBeautifulArt के रूबी जवाब का एक बंदरगाह है, क्योंकि वह एक है जो सब कुछ के साथ आया है और कीड़े को ठीक किया है ..

— केविन क्रूज़सेन

Answer 5

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

"Z w" में कॉल z से ऊपर का कार्य 1 वापस आएगा यदि a में संख्या w में संख्या से अधिक है, अन्यथा यह 0 पर वापस आ जाएगी।

अगर मेरे पास

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

यह f (आ)> f (बी बी) दोनों एए और बी बी दोनों के साथ ५ पॉजिटिव नंबरों का होगा यदि और केवल अगर (अगर ए और बी ए का १) लॉग (लॉग (एफ (ए)))> लॉग ( लॉग (f (bb))) एक को लॉग () कानूनों का उपयोग करना होगा:

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

निर्माण के लिए v (आ) = लॉग (लॉग (आ)) = वी (ए, बी, सी, डी, ई) = लॉग (लॉग (ए)) + लॉग (बी) (सी ^ (डी ^ ई)) = {p (3 ⍵ ⍵), / 3 ⍵ and} फ़ंक्शन और इसलिए व्यायाम तब पाया जाता है जब v (aa)> v (bb) होता है।

लेकिन एक ऐसा मामला है जहां v (आ) और 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

Comments

चुनौती विवरण में परीक्षणों में कुछ किनारे के मामलों की कमी है। क्या आप सत्यापित कर सकते हैं कि यह इन सभी परीक्षण मामलों के लिए भी काम कर रहा है ?

— केविन क्रूज़सेन

@KevinCruijssen यहां आपका परीक्षण, अगर ऊपर वाले को ठीक लगता है ...

— RosLuP

यदि सभी परीक्षण मामले सही हैं, तो मेरे से +1। अपने कोड के स्पष्टीकरण को देखते हुए आगे। :)

— केविन क्रूज़सेन

आपने कहा कि आपने प्रत्येक की गणना की है log(log()), लेकिन उस परीक्षण मामले के लिए, अंतर log(log(10^10^10^10^10))और log(log(9^10^10^10^10))सटीकता की बेतुकी मात्रा की आवश्यकता होगी। आपको 2e10सटीकता के आधार 10 अंकों के साथ एक अस्थायी बिंदु होना चाहिए । और यह इस तथ्य को नजरअंदाज कर रहा है कि दोनों पक्ष लगभग बड़े हैं 10^10^10, जो मुझे विश्वास करना मुश्किल है कि आप गणना करने में सक्षम थे।

— ब्यूटीफुल आर्ट

शायद यह विफल हो जाता है 9, 10, 10, 10, 10, 10, 9, 10, 10, 10, जिसे वापस लौटना चाहिए 1, लेकिन s(9,10,10,10,10) < s(10,9,10,10,10)।

— ब्यूटीफुल आर्ट

Answer 6

जावा 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 का रूबी जवाब है , इसलिए उसे उभारना सुनिश्चित करें!
-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]);}

Comments

यदि आप x==yइसके बजाय उपयोग करते हैं तो यह ठीक काम करने लगता है M.abs(x-y)<1e-9।

— ब्यूटी आर्ट

@SimplyBeautifulArt रुको, यह करता है? .. Wtf। जब मेरे पास मेरा अनगोल्ड संस्करण था, तो यह एक परीक्षण के मामले में काम नहीं करता था। स्ट्रिंग आउटपुट समान था, लेकिन आंतरिक रूप से यह कभी थोड़ा अलग था। Ungolfed संस्करण आपका ungolfed संस्करण था, इससे पहले कि मैं इसे आपके रूबी उत्तर में भी गोल्फ टर्नरी में बदलूं। बेवकूफ फ्लोटिंग पॉइंट प्रिसिजन .. इसे बदल देगा, क्योंकि यह वर्तमान दृष्टिकोण में परीक्षण मामलों के लिए वास्तव में काम करता है। धन्यवाद।

— केविन क्रूज़सेन

Lol, जब आप इस पर होते हैं तो आप मेरे अपडेट को देखना चाहते हैं: ^)

— ब्यूटीफुल आर्ट

tएक बाइट को बचाने के लिए हटाया जा सकता है yजैसे मैंने किया था। टीआईओ

— ब्यूटीफुल आर्ट

@SimplyBeautifulArt Nvm उसी बदलाव के साथ मेरे 05AB1E उत्तर को अपडेट करने के बारे में। बाइट-काउंट 96 तक रहेगा।

— केविन क्रूज़सेन