100 बाइट्स में आप सबसे धीमी गति से बढ़ते हुए फंक्शन बना सकते हैं

Question

आपका काम 100 से अधिक बाइट्स में आपके द्वारा किए जा रहे सबसे धीमे विकास कार्य को बनाना है।

आपका प्रोग्राम इनपुट के रूप में एक nonnegative पूर्णांक लेगा, और एक nonnegative पूर्णांक आउटपुट करेगा। चलो अपने कार्यक्रम को पी।

यह इन दो मानदंडों को पूरा करना चाहिए:

• इसका स्रोत कोड 100 बाइट्स से कम या बराबर होना चाहिए।
• प्रत्येक K के लिए, एक N है, जैसे कि हर n> = N, P (n)> K के लिए। दूसरे शब्दों में, lim _{(n-> ∞)} P (n) = ∞ । (यह "बढ़ने" के लिए इसका अर्थ है।)

आपका "स्कोर" आपके प्रोग्राम के अंतर्निहित फ़ंक्शन की वृद्धि दर है।

अधिक विशेष रूप से, प्रोग्राम P, Q की तुलना में धीमा होता है यदि कोई N ऐसा है जो सभी n> = N, P (n) <= Q (n) के लिए है, और कम से कम एक n> = N है जैसे कि P (n) ) <क्यू (एन)। यदि न तो कार्यक्रम दूसरे से बेहतर है, तो वे बंधे हुए हैं। (अनिवार्य रूप से, कौन सा कार्यक्रम धीमा है _(n-> P ₎ P (n) -Q (n)) के मान पर आधारित है ।

पिछले पैराग्राफ में परिभाषा के अनुसार, सबसे धीमी गति से बढ़ने वाले फ़ंक्शन को किसी अन्य फ़ंक्शन की तुलना में धीमी गति से बढ़ने वाले के रूप में परिभाषित किया गया है।

यह विकास दर-गोल्फ है , इसलिए सबसे धीमी गति से बढ़ते कार्यक्रम जीतता है!

टिप्पणियाँ:

• स्कोरिंग में सहायता करने के लिए, उत्तर में अपने कार्यक्रम की गणना किस कार्य को करने की कोशिश करें।
• कुछ (सैद्धांतिक) इनपुट और आउटपुट भी डालें, जिससे लोगों को यह पता लगाने में मदद मिल सके कि आप कितने धीमे चल सकते हैं।

Comments

सम्बंधित।

— मार्टिन एंडर

एक प्रभावी रणनीति एक तेजी से बढ़ते कार्य को लिखना है और इसका उलटा लेना है, अर्थात इसका सबसे छोटा इनपुट ढूंढें जो कम से कम आवश्यक मूल्य पैदा करता है। शायद यह एक डुबकी है?

— xnor

"अधिक विशेष रूप से" पैराग्राफ का एक तिहाई गायब था क्योंकि मार्कडाउन को लगता है <कि एक पत्र के बाद एक HTML टैग की शुरुआत है। कृपया पोस्ट करने से पहले अपने प्रश्नों का पूर्वावलोकन करें: P

— ETHproductions

हम किन बड़े कार्डिनल स्वयंसिद्धों को मान सकते हैं?

— पीटर टेलर

क्या हमारे जवाब देने के लिए समय मशीन है?

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

Answer 1

हास्केल, 98 बाइट्स, स्कोर = च _{ε 0} ^-1 ( एन )

_#[]=0
k#(0:a)=k#a
k#(a:b)=1+(k#(([1..k]>>fst(span(>=a)b)++[a-1])++b))
f n=[k|k<-[0..],k#[k]>n]!!0

यह काम किस प्रकार करता है

यह बेक्लेमिशेव के कृमि खेल से संबंधित एक बहुत तेजी से बढ़ते कार्य के व्युत्क्रम की गणना करता है । इसकी विकास दर के बराबर है च _{ε 0} , जहां च _α है तेजी से बढ़ते पदानुक्रम और ε ₀ पहला है एप्सिलॉन संख्या ।

अन्य उत्तरों के साथ तुलना के लिए, ध्यान दें

• प्रतिपादक एफ _{2 के} लिए तुलनीय है ;
• iterated घातांक ( टेट्रेशन या iation ) f ₃ से तुलनीय है ;
• M तीर के साथ to ↑↑ m f _{m + 1 के} बराबर है ;
• एकरमैन समारोह के बराबर है च _ω ;
• एकरमन फ़ंक्शन (बार ग्राहम की संख्या जैसे निर्माण ) के दोहराया पुनरावृत्तियों पर अभी भी f ; _{+ 1 का} प्रभुत्व है ;
• और ε ₀ सभी टावरों ω की सीमा है ^{ω ω ⋰ ω} ।

Comments

मुझे यहां का वर्णन बेहतर लगा।

— 21

आप गूगोलॉजी विकी के तेजी से बढ़ते पदानुक्रम से परिचय के लिंक में डाल सकते हैं

— मिल्कीवेय

Answer 2

ब्रेकीलॉग , 100 बाइट्स

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

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

यह शायद कुछ अन्य फैंसी उत्तरों की सुस्ती के पास कहीं नहीं है, लेकिन मुझे विश्वास नहीं हो रहा था कि किसी ने भी इस सरल और सुंदर दृष्टिकोण की कोशिश नहीं की थी।

बस, हम इनपुट संख्या की लंबाई की गणना करते हैं, फिर इस परिणाम की लंबाई, फिर इस अन्य परिणाम की लंबाई ... कुल 100 गुना।

यह लॉग के रूप में तेजी से बढ़ता है (लॉग (लॉग ... लॉग ... x), 100 बेस -10 लॉग के साथ।

यदि आप एक स्ट्रिंग के रूप में अपना नंबर इनपुट करते हैं , तो यह आपके द्वारा किए गए किसी भी इनपुट पर बहुत तेज़ी से चलेगा, लेकिन 1: D से उच्चतर परिणाम देखने की अपेक्षा न करें

Comments

+1 केवल शुद्ध पागलपन के लिए: ओ मज़ा तथ्य: जेली में भी काम करता है अगर आप इसे सभी कैप बनाते हैं। : पी

— हाइपरनेत्रिनो

2 को आउटपुट देने वाली पहली संख्या 10 2 99 है।

— गेहूं जादूगर

Answer 3

जावास्क्रिप्ट (ईएस 6), उलटा एकरमैन फंक्शन *, 97 बाइट्स

* अगर मैंने इसे सही किया

A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1
a=(m,n=m,i=1)=>{while(A(i,m/n|0)<=Math.log2(n))i++;return i-1}

समारोह Aहै एकरमैन समारोह । फ़ंक्शन aको उलटा एकरमन फ़ंक्शन माना जाता है । अगर मैंने इसे सही तरीके से लागू किया, तो विकिपीडिया कहता है कि यह 5तब तक हिट नहीं होगा जब तक mबराबरी नहीं होगी 2^2^2^2^16। मैं StackOverflowचारों ओर हो गया 1000।

उपयोग:

console.log(a(1000))

स्पष्टीकरण:

एकरमन फंक्शन

A=(m,n)=>                           Function A with parameters m and n
         m?                   :n+1  If m == 0, return n + 1; else,
           A(m-1,n?        :1)       If n == 0, return A(m-1,1); else,
                   A(m,n-1)          return A(m-1,A(m,n-1))

एकरमन फंक्शन को उलटा करें

a=(m,n=m,i=1)=>{                                                Function a with parameter m, with n preinitialized to m and i preinitialized to 1
                while(A(i,m/n|0)<=Math.log2(n))                 While the result of A(i, floor(m/n)) is less than log₂ n,
                                               i++;             Increment i
                                                   return i-1}  Return i-1

Comments

हालांकि ढेर अतिप्रवाह अच्छा नहीं है?

— NoOneIsHere

आपका कथन कि यह 5 नहीं होगा जब तक m = 2 ^ ^ 7 गलत नहीं होगा। यह 5 तक हिट नहीं होगा जब तक m = 2 ^^ 7-3, लेकिन 2 ^^ 7-1 पर, यह 5 है । मुझे पता है कि -2 ^ ^ 7 की तुलना में -3 बहुत छोटा है, लेकिन 5A5 = 2 ^ ^ 7-3 <2 ^^ 7। (^ ^

— tetration का

Answer 4

शुद्ध ईविल: एवल

a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1

Eval के अंदर का स्टेटमेंट 7 * 10 ^{10 10 10 10 10 8.57} लंबाई का एक स्ट्रिंग बनाता है जिसमें लैंबडा फ़ंक्शन के अलावा और कुछ भी नहीं होता है, जिनमें से प्रत्येक समान लंबाई की एक स्ट्रिंग का निर्माण करेगा , जब तक कि अंत में y0. नहीं हो जाता। यह नीचे Eschew विधि के रूप में एक ही जटिलता है, लेकिन अगर-और-नियंत्रण तर्क पर भरोसा करने के बजाय, यह सिर्फ एक साथ विशाल तार को मिटाता है (और शुद्ध परिणाम अधिक ढेर हो रहा है ... शायद?)।

yपायथन को बिना किसी त्रुटि के फेंकने के लिए मैं सबसे बड़ी कीमत की आपूर्ति कर सकता हूं और गणना कर सकता हूं 2 जो पहले से ही 1 में लौटने में अधिकतम-फ्लोट के इनपुट को कम करने के लिए पर्याप्त है।

लंबाई की एक स्ट्रिंग 7,625,597,484,987 बहुत बड़ी है OverflowError: cannot fit 'long' into an index-sized integer:।

मुझे रुकना चाहिए।

Eschew Math.log: (10 वीं-) रूट (समस्या की) पर जा रहे हैं, स्कोर: y = 1 से प्रभावी रूप से अप्रभेद्य है।

गणित पुस्तकालय को आयात करना बाइट गिनती को प्रतिबंधित कर रहा है। आओ हम इसके साथ काम करते हैं और log(x)फ़ंक्शन को कुछ हद तक समान रूप से बदलते हैं : x**.1और जिसकी लागत लगभग समान वर्ण होती है, लेकिन आयात की आवश्यकता नहीं होती है। दोनों कार्यों में इनपुट के संबंध में एक सुस्पष्ट आउटपुट है, लेकिन x ^0.1 धीरे-धीरे बढ़ता है । हालाँकि, हम पूरी तरह से परवाह नहीं करते हैं, हम केवल इस बात की परवाह करते हैं कि इसमें एक ही आधार ग्रोथ पैटर्न है जिसमें बड़ी संख्या में वर्णों की तुलना होती है (उदाहरण के लिए) वर्णों x**.9की समान संख्या है, लेकिन अधिक तेज़ी से बढ़ता है, इसलिए वहाँ है। कुछ मूल्य है जो सटीक समान वृद्धि का प्रदर्शन करेंगे)।

अब, 16 पात्रों के साथ क्या करना है। कैसे के बारे में ... Ackermann अनुक्रम गुण है करने के लिए हमारे भेड़ के बच्चे समारोह का विस्तार? बड़ी संख्या के लिए इस जवाब ने इस समाधान को प्रेरित किया।

a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1

z**zभाग यहाँ मुझे कहीं भी साथ इस समारोह चल रहा से रोकता है पास के लिए समझदार आदानों की yऔर z, सबसे बड़ा मान मैं उपयोग 9 और कर रहे हैं कर सकते हैं 3 जिसके लिए मैं 1.0 का मूल्य वापस पाने के, यहां तक कि सबसे बड़ी नाव अजगर का समर्थन करता है टिप्पणी के लिए (: जबकि 1.0 संख्यात्मक रूप से 6.77538853089e-05 से अधिक है, बढ़ी हुई पुनरावृत्ति का स्तर इस फ़ंक्शन के आउटपुट को 1 के करीब ले जाता है, जबकि 1 से अधिक शेष रहता है, जबकि पिछला फ़ंक्शन 0 से अधिक शेष रहते हुए मानों को स्थानांतरित कर देता है, इस प्रकार इस फ़ंक्शन पर भी मध्यम पुनरावृत्ति होती है। इतने सारे परिचालनों में परिणाम कि फ्लोटिंग पॉइंट संख्या सभी महत्वपूर्ण बिट्स खो देती है )।

0 और 2 के पुनरावर्तन मान रखने के लिए मूल लैंबडा कॉल को पुनः कॉन्फ़िगर करना ...

>>>1.7976931348623157e+308
1.0000000071

यदि "फ़ंक्शन 1 से ऑफसेट" के बजाय "ऑफसेट से 0" की तुलना की जाती है 7.1e-9, तो यह फ़ंक्शन लौटता है , जो निश्चित रूप से इससे छोटा है 6.7e-05।

वास्तविक कार्यक्रम का आधार पुनरावर्तन (z मान) 10 ^{10 10 10 1.97} स्तर गहरा है, जैसे ही y स्वयं समाप्त हो जाता है, यह 10 ^{10 10 10 10 1.97 के} साथ रीसेट हो जाता है (यही कारण है कि 9 का प्रारंभिक मूल्य पर्याप्त है), इसलिए मैं डॉन यह भी पता नहीं है कि कैसे सही ढंग से होने वाली कुल संख्याओं की गणना करें: मैं अपने गणितीय ज्ञान के अंत में पहुंच गया हूं। इसी तरह मुझे नहीं पता **nकि प्रारंभिक इनपुट से माध्यमिक में एक्सपोनेंटिअशन में से एक को स्थानांतरित करने z**zसे रिकर्स की संख्या में सुधार होगा या नहीं (डिट्टो रिवर्स)।

और भी अधिक पुनरावृत्ति के साथ धीमी गति से चलते हैं

import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1

• n//1 - 2 बाइट्स बचाता है int(n)
• import math, math.1 बाइट ओवर बचाता हैfrom math import*
• a(...) कुल 8 बाइट बचाता है m(m,...)
• (y>0)*x एक बाइट की बचत होती है अधिकy>0and x
• 9**9**99बढ़ जाती है लगभग द्वारा 4 और बढ़ जाती है प्रत्यावर्तन गहराई से गिनती बाइट 2.8 * 10^xजहां xवर्ष गहराई (: 10 या गहराई आकार में एक googolplex होने जा रही है ^{10 94} )।
• 9**9**9e95 से बाइट की संख्या बढ़ाता है और एक गहरी राशि ... द्वारा पुनरावृत्ति की गहराई बढ़ाता है। संदर्भ की पुनरावृत्ति की गहराई अब 10 ^{10 10 9.93 है} , संदर्भ के लिए, एक गूगोलोप्लेक्स 10 ^{10 10 2 है} ।
• लैम्ब्डा घोषणा एक अतिरिक्त कदम से पुनरावृत्ति बढ़ाती है: 7 बाइट्स खर्च m(m(...))करने के लिएa(a(a(...)))

नया आउटपुट मान (9 पुनरावर्ती गहराई पर):

>>>1.7976931348623157e+308
6.77538853089e-05

पुनरावृत्ति की गहराई उस बिंदु तक फैल गई है जिस पर यह परिणाम शाब्दिक रूप से एक ही इनपुट मानों का उपयोग करने की तुलना में निरर्थक है:

• मूल log25 बार कहा जाता है
• पहला सुधार इसे 81 बार कहता है
  • वास्तविक कार्यक्रम यह 1e99 कहेंगे ² या 10 के बारे में ^{10 2.3} गुना
• यह संस्करण इसे 729 बार कहता है
  • वास्तविक कार्यक्रम यह (9 कहेंगे ^{9 99} ) ³ या थोड़ा कम से कम 10 ^{10 95} बार)।

लम्बे इंसेप्शन, स्कोर: ???

मैंने तुम्हें लंबोदर की तरह सुना, इसलिए ...

from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))

मैं इसे भी नहीं चला सकता, मैं केवल 99 पुनरावृत्ति की परतों के साथ अतिप्रवाह को ढेर करता हूं ।

पुरानी विधि (नीचे) रिटर्न (रूपांतरण को पूर्णांक में लंघन):

>>>1.7976931348623157e+308
0.0909072713593

नई विधि वापस आती है, केवल 9 परतों का उपयोग करते हुए (उनके बजाय पूर्ण गोगोल की)

>>>1.7976931348623157e+308
0.00196323936205

मुझे लगता है कि यह एकरमैन सीक्वेंस की तरह ही जटिल है, बड़े के बजाय केवल छोटा है।

इसके अलावा उन स्थानों में 3-बाइट बचत के लिए ETHproductions के लिए धन्यवाद, जिन्हें मैंने महसूस नहीं किया था हटाया जा सकता है।

पुराना उत्तर:

फ़ंक्शन लॉग का पूर्णांक ट्रंकेशन (i + 1) लैम्ब्डा लैंबडास का उपयोग करके 20 25 बार (पायथन) को पुनरावृत्त करता है।

PyRulez का उत्तर एक दूसरे मेमने को पेश करके और उसे ढेर करके संकुचित किया जा सकता है:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))

९९ १०० पात्रों का उपयोग किया।

यह मूल 25 से अधिक 20 25 की एक पुनरावृत्ति पैदा करता है । इसके अतिरिक्त यह एक अतिरिक्त स्टैक के लिए अनुमति के int()बजाय 2 वर्णों को बचाता है । यदि लैम्ब्डा के बाद रिक्त स्थान हटाया जा सकता है (मैं इस समय जांच नहीं कर सकता ) तो एक 5 वें जोड़ा जा सकता है। मुमकिन!floor()x()y()

यदि from mathपूरी तरह से योग्य नाम (जैसे। x=lambda i: math.log(i+1))) का उपयोग करके आयात को छोड़ने का कोई तरीका है, तो यह और भी अधिक वर्णों को बचाएगा और एक और स्टैक के लिए अनुमति देगा, x()लेकिन मुझे नहीं पता कि पायथन ऐसी चीजों का समर्थन करता है (मुझे संदेह नहीं है)। किया हुआ!

यह मूल रूप से बड़ी संख्या में XCKD के ब्लॉग पोस्ट में उपयोग की जाने वाली एक ही चाल है , हालांकि लैम्ब्डा घोषित करने में ओवरहेड एक तीसरी स्टैक को रोकता है:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))

यह 3 लैम्ब्डा के साथ सबसे छोटी पुनरावृत्ति संभव है जो 2 लैम्ब्डा की गणना की गई स्टैक ऊंचाई से अधिक है (किसी भी लैम्ब्डा को दो कॉल तक कम करने से स्टैक की ऊंचाई 2-लैम्ब्डा संस्करण के नीचे 18 तक हो जाती है), लेकिन दुर्भाग्य से 110 वर्णों की आवश्यकता होती है।

Comments

FYI करें, मैं शीर्ष कार्यक्रम में 103 बाइट्स गिनता हूं

— ETHproductions

@ETHproductions ओह ओह। मैंने शायद intरूपांतरण के बिना एक गिनती की और सोचा कि मेरे पास कुछ पुर्जें हैं।

— ड्रेको

मुझे लगता है कि आप अंतरिक्ष के बाद importऔर अंतरिक्ष को हटा सकते हैं y<0। मैं बहुत ज्यादा अजगर नहीं जानता, हालांकि मैं निश्चित नहीं हूं

— ETHproductions

इसके अलावा, शायद y<0and x or m(m,m(m,log(x+1),y-1),y-1)एक और बाइट को बचाने के लिए (मान लिया गया xहै 0जब कभी नहीं y<0)

— ETHproductions

ठीक है ... (बड़े मूल्यों के लिए ) log(x)की किसी भी सकारात्मक शक्ति की तुलना में अधिक धीरे-धीरे बढ़ता है , और यह L'Hopital के नियम का उपयोग करके दिखाना मुश्किल नहीं है। मुझे पूरा यकीन है कि आपका वर्तमान संस्करण समय की एक पूरी गुच्छा करता है। लेकिन वे शक्तियां सिर्फ गुणा करती हैं, इसलिए यह प्रभावी है , जो एक (बहुत छोटी) सकारात्मक शक्ति है । इसका मतलब है कि यह वास्तव में लॉग फ़ंक्शन के एक एकल पुनरावृत्ति की तुलना में तेजी से बढ़ता है (हालांकि, दी गई, आपको ध्यान देने से पहले बहुत बड़े मूल्यों पर गौर करना होगा ... लेकिन इसका मतलब है कि हम "अनंत तक जा रहे हैं" )। xx(...(((x**.1)**.1)**.1)** ...)x**(.1** (whole bunch))xx

— मैथमैनंदन

Answer 5

हास्केल , 100 बाइट्स

f 0 a b=a^b
f c a b=foldr(f$c-1)a$[0..b]>>[a]
i=length.show
0#x=i x
y#x=i$(y-1)#x
g=(f(f 9 9 9)9 9#)

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

यह समाधान इस मामले में, बल्कि धीरे-धीरे बढ़ने वाले फ़ंक्शन के बजाय जल्दी से बढ़ने वाले फ़ंक्शन का उलटा नहीं लेता है length.show, और इसे कई बार लागू करता है।

पहले हम एक फंक्शन को परिभाषित करते हैं f। fनुथ के अपोजिट नोटेशन का एक हरामी संस्करण है जो थोड़ा तेज बढ़ता है (थोड़ा बहुत समझ में आता है, लेकिन हम जो संख्या में काम कर रहे हैं वह इतनी बड़ी है कि चीजों की भव्य योजना में ...)। हम f 0 a bहोने a^bया aहोने की शक्ति के आधार मामले को परिभाषित करते हैं b। हम तब के मामले में (f$c-1)लागू होने वाले सामान्य मामले को परिभाषित करते b+2हैं a। यदि हम निर्माण की तरह एक नथ अपस्ट्रो नोटेशन को परिभाषित कर रहे थे, तो हम इसे bउदाहरण के लिए लागू करेंगे a, लेकिन b+2वास्तव में गोल्फर है और तेजी से बढ़ने का फायदा है।

हम तब ऑपरेटर को परिभाषित करते हैं #। समय-समय पर लागू a#bहोने के लिए परिभाषित length.showकिया गया b aहै। हर एप्लिकेशन ₁₀length.show लॉग करने के लिए लगभग एक समान है , जो बहुत तेज़ी से बढ़ने वाला फ़ंक्शन नहीं है।

हम तब अपने फ़ंक्शन को परिभाषित करने के बारे में जाते हैं जो पूर्णांक को बार के एक गुच्छा में gलागू और पूर्णांक length.showबनाता है। विशिष्ट होने के length.showलिए यह इनपुट पर लागू होता है f(f 9 9 9)9 9। इससे पहले कि हम यह देखते हैं कि यह कितना बड़ा है f 9 9 9। f 9 9 9है की तुलना में अधिक 9↑↑↑↑↑↑↑↑↑9 (नौ तीर), एक बड़े पैमाने पर अंतर से। मेरा मानना ​​है कि यह 9↑↑↑↑↑↑↑↑↑9(नौ तीर) और 9↑↑↑↑↑↑↑↑↑↑9(दस तीर) के बीच कहीं है । अब यह एक अकल्पनीय बड़ी संख्या है, अस्तित्व में किसी भी कंप्यूटर पर संग्रहीत होने के लिए बड़ी से बड़ी (बाइनरी नोटेशन में)। फिर हम उस लेने के लिए और डाल कि हमारे के पहले तर्क के रूप में fइसका मतलब है कि हमारे मूल्य से भी बड़ा है 9↑↑↑↑↑↑...↑↑↑↑↑↑9साथf 9 9 9बीच में तीर। मैं इस संख्या का वर्णन नहीं कर रहा हूं क्योंकि यह इतना बड़ा है कि मुझे नहीं लगता कि मैं इसे न्याय कर पाऊंगा।

प्रत्येक length.showपूर्णांक के लॉग बेस 10 लेने के बराबर है। इसका मतलब यह है कि ज्यादातर नंबर 1 fलागू होंगे जब उनके लिए आवेदन किया जाएगा। 1 के अलावा किसी चीज़ को वापस करने के लिए सबसे छोटी संख्या है 10↑↑(f(f 9 9 9)9 9), जो वापस आती है। चलो एक पल के लिए उस बारे में सोचते हैं। जितनी बड़ी संख्या में उस संख्या को हमने पहले परिभाषित किया है, वह सबसे छोटी संख्या है जो 2 लौटती है वह 10 बार अपनी शक्ति से कई गुना अधिक है। थॉट्स 1 के बाद 10↑(f(f 9 9 9)9 9)शून्य।

nछोटे इनपुट इनपुट के सामान्य मामले के लिए किसी भी n को होना चाहिए (10↑(n-1))↑↑(f(f 9 9 9)9 9)।

ध्यान दें कि इस कार्यक्रम के लिए बड़े पैमाने पर समय और मेमोरी की आवश्यकता होती है यहां तक ​​कि छोटे n (ब्रह्मांड में कई बार अधिक होने पर भी), यदि आप यह परीक्षण करना चाहते हैं तो मैं सुझाव देता हूं कि आप f(f 9 9 9)9 9बहुत छोटी संख्या के साथ प्रतिस्थापित करें, यदि आप चाहते हैं तो 1 या 2 का प्रयास करें। 1 के अलावा कभी भी कोई आउटपुट नहीं मिलता है।

Comments

मेह, मुझे नहीं लगता कि किसी को भी इस बात की परवाह है कि इस तरह के सवालों को चलाने के लिए कार्यक्रम में कितनी देर लगती है या कितनी स्मृति की आवश्यकता होती है।

— बस सुंदर कला

Answer 6

एपीएल, लागू करें log(n + 1), e^9^9...^9समय, जहां श्रृंखला e^9^9...^9की लंबाई श्रृंखला की लंबाई 1 बार है, और इसी तरह।

⌊((⍟1+⊢)⍣((*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣⊢)))))))))))))))))))))9))⊢

Comments

क्या कोई तरीका है जिससे मैं इसे चला सकूं?

— ड्रेको १।

@ Draco18s को लगभग-अनंत मेमोरी के साथ एक क्वांटम कंप्यूटर मिलता है, एक सभ्य एपीएल वितरण स्थापित करें, और जब आप इसके लिए इंतजार कर रहे समय बिताते हैं तो यह एक बुढ़ापे को रोकने वाले सीरम को बनाने के लिए है, क्योंकि आपको कुछ शताब्दियों के लिए तंग बैठना होगा।

— उरेल

Haha। ठीक है फिर। : p

— Draco18s

क्या आप सुनिश्चित हैं कि यह अनंत तक पहुंचता है?

— प्यरुलेज़

@PyRulez यह अन्य समाधानों की तरह ही है, केवल लॉग पर बहुत अधिक पुनरावृत्तियों के साथ। लेकिन अधिक पुनरावृत्ति अभी भी एक ही समापन है - जो कि बहुत अधिक के रूप में अच्छी तरह से परिभाषित करके परिभाषित किया गया है। मुझे इस e^n^n...^nभाग के बारे में निश्चित नहीं था इसलिए मैंने इसे निरंतर में बदल दिया, लेकिन यह सच हो सकता है

— उरेल

Answer 7

MATL , 42 बाइट्स

iXI:`2*.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx

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

यह कार्यक्रम यूलर-मैसचोनी स्थिरांक के उपयोग के साथ हार्मोनिक श्रृंखला पर आधारित है। जैसा कि मैं उनकी MATL भाषा पर @LuisMendo के दस्तावेज़ पढ़ रहा था (बड़े अक्षरों के साथ, इसलिए यह महत्वपूर्ण लगता है) मैंने इस स्थिरांक पर ध्यान दिया। धीमी वृद्धि फलन अभिव्यक्ति निम्नानुसार है:

जहां εk ~ 1 / 2k

मैंने 10000 पुनरावृत्तियों (Matlab में, चूंकि यह TIO के लिए बहुत बड़ा है) का परीक्षण किया और यह 10 से नीचे स्कोर करता है, इसलिए यह बहुत धीमा है।

स्पष्टीकरण:

 iXI      % ask user input (number of iterations)

:`2*.]    % do...while loop, multiply by 2

X{        % convert numeric array into cell array

o         % convert to double precision array 

XH1H/     % copy to clipboard H and divide by 1: now we have an array of 1/2k

16L       % Euler–Mascheroni constant 

+         % addition (element-wise, singleton expansion)

XKxI:`    % save, clear the stack, do...while loop again

  Yl      % logarithm 

  .]      % break, ends the loop

K+XK      % paste from clipboard K, sum all

Xd        % trim: keep the diagonal of the matrix 

Xz        % remove all zeros

XG        % plot (yes it plots on-line too!)

x         % clear the stack
          % (implicit) display

अनुभवजन्य प्रमाण: (ln k ) + 1 लाल रंग में हमेशा ln k + ε + ink से ऊपर नीले रंग में।

(Ln k ) + 1 के लिए कार्यक्रम बनाया गया था

मतलाब, 47 18 14 बाइट्स

n=input('')
A=(1:n)
for k=1:n
A(k)=log(k)+1
end

यह ध्यान रखना दिलचस्प है कि मेरे लैपटॉप पर n = 100 के लिए बीता हुआ समय 0.208693 है, लेकिन केवल 0.121945s d=rand(1,n);A=d*0;और उससे भी कम, 0.112147 के साथ A=zeros(1,n)। यदि शून्य अंतरिक्ष की बर्बादी है, तो यह गति को बचाता है! लेकिन मैं विषय से विचलित हो रहा हूं (शायद बहुत धीरे से)।

संपादित करें: बस इस Matlab अभिव्यक्ति को कम करने में मदद करने के लिए Stewie को धन्यवाद , बस:

 @(n)log(1:n)+1

Comments

+1 न केवल एक तेज़ फ़ंक्शन का व्युत्क्रम है

— PyRulez

आपके दिलचस्प नोट के बारे में एक दिलचस्प एसओ-पोस्ट । :)

— स्टिव ग्रिफिन

वैसे, नीचे में स्क्रिप्ट को गोल्फ करना (जब से आपने बाइट काउंट को शामिल किया है): अंतिम MATLAB स्क्रिप्ट बस है: n=input('');A=log(1:n)+1या एक अनाम अनाम फ़ंक्शन (14 बाइट्स) के रूप में @(n)log(1:n)+1:। मैं MATLAB के बारे में निश्चित नहीं हूं, लेकिन A=log(1:input(''))+1ऑक्टेव में काम करता हूं ...

— स्टिव ग्रिफ़िन

धन्यवाद @Stewie n=input('');A=log(1:n)+1काम करता है, @(n)log(1:n)+1मत करो (वास्तव में मतलाब में संभाल के साथ एक वैध कार्य, लेकिन इनपुट नहीं पूछा गया है), A=log(1:input(''))+1काम करता है और छोटा किया जा सकता हैlog(1:input(''))+1

— J Doe

क्या मैं गुमनाम समारोह के साथ का मतलब था यह । कमांड लाइन के बजाय फ़ंक्शन तर्कों (मेटा-पोस्ट) के रूप में इनपुट की आवश्यकता के द्वारा बाइट्स (कम से कम इस साइट पर) को बचाने का यह "सामान्य" तरीका है । इसके अलावा, f=किए जाने के लिए है, क्योंकि यह सिर्फ होना भी संभव है की जरूरत नहीं है: @(n)log(1:n)+1के बाद ans(10)पहली बार 10 नंबर प्राप्त करने।

— स्टू ग्रिफिन

Answer 8

पायथन 3 , 100 बाइट्स

फ़ंक्शन लॉग (i + 1) का फर्श 99999999999999999999999999999999999 बार पुन: प्रसारित किया गया।

उपरोक्त संख्या को और अधिक बड़ा बनाने के लिए एक्सपोर्टर का उपयोग कर सकते हैं ...

from math import *
s=input()
exec("s=log(s+1);"*99999999999999999999999999999999999)
print(floor(s))

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

Comments

क्या समाधान के लिए वास्तव में काम करना है? यह एक OverflowError फेंकता है।

— ETHproductions

@ETHproductions इस तरह की समस्याओं में, यह आमतौर पर स्वीकार किया जाता है कि समाधानों को केवल अनंत स्मृति और सीपीयू के साथ मशीन पर सैद्धांतिक रूप से व्यवहार्य होने की आवश्यकता है। यदि आप यह कोशिश करना चाहते हैं, तो 99999 ... 999 को

— घटाकर

तो उपयोग क्यों नहीं 9**9**9**...**9**9e9?

— कैलक्यूलेटरफ्लीन

Answer 9

फ़ंक्शन लॉग का फर्श (i + 1) 14 बार (पायथन) से पुनरावृत्त हुआ

import math
x=lambda i: math.log(i+1)
print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input())))))))))))))))

मैं यह बहुत अच्छा करने की उम्मीद नहीं करता, लेकिन मैंने इसकी अच्छी शुरुआत की।

उदाहरण:

• e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n -> ~ n (लगभग n)

Comments

यदि आप intइसके बजाय का उपयोग करते हैं floor, तो आप दूसरे में फिट हो सकते हैंx(

— बीटा डेके

@BetaDecay ठीक है मैंने इसे अपडेट किया है।

— PyRulez

क्या अभिव्यक्ति नहीं होनी चाहिए e^e^e^e...^n? इसके अलावा, क्यों एक जगह के बाद है :?

— कैलक्यूलेटरफ्लीन

@CalculatorFeline क्योंकि यह कोड गोल्फ नहीं है, यह सिर्फ 100 बाइट्स के तहत होना चाहिए।

— साइओस

इसलिए? एक बाइट को बचाने के बारे में इतना बुरा क्या है ताकि आप एक और x()कॉल जोड़ सकें ?

— कैलकुलेटरफनलीन

Answer 10

रूबी, 100 बाइट्स, स्कोर ^-1 = एफ _{ω ^{1 + 1}} (एन ² )

मूल रूप से मेरे सबसे बड़े नंबर प्रिंट करने योग्य से उधार लिया गया है , यहाँ मेरा कार्यक्रम है:

->k{n=0;n+=1 until(H=->z,a=[0]*z{b,*c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]*z+c]:z};z};H[n*n]>k);n}

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

मूल रूप से तेजी से बढ़ते पदानुक्रम में f _comp n ^{_{+ 1}} (n ² ) के व्युत्क्रम की गणना की जाती है। पहले कुछ मान हैं

x[0] = 1
x[1] = 1
x[2] = 1
x[3] = 1
x[4] = 2

और फिर यह 2बहुत लंबे समय तक जारी रहता है । यहां तक ​​कि x[G] = 2, Gग्राहम का नंबर कहां है।

Comments

लेकिन g (f <sub> about9001CK </ sub> 3) के बारे में क्या है जहां F FHH है?

— 1975 में user75200

@ user75200 fgh को असंबद्ध अध्यादेशों के लिए अच्छी तरह से परिभाषित नहीं किया गया है।

— बस सुंदर कला

FGH है uncomputable ऑर्डिनल्स के लिए अच्छी तरह से परिभाषित, जैसा कि वे मौलिक दृश्यों की है। यह सिर्फ अविश्वसनीय है।

— user75200

@ user75200 नहीं। मौलिक अनुक्रम बहुत मनमानी हैं। मैं ω9001CK निर्धारित कर सकते हैं [x] = एक्स लंबाई ω9001CK, जिनमें से एक मौलिक अनुक्रम के लिए है के लिए परिमित x गणना कर सका है, लेकिन बहुत संभावना नहीं है कि तुम क्या चाहते थे। "अच्छी तरह से परिभाषित," से मेरा मतलब था कि सभी के लिए सहमत होने वाले असंबद्ध अध्यादेशों के लिए एक मानक मौलिक अनुक्रम नहीं है।

— ब्यूटी आर्ट

हालांकि यह सच है कि मौलिक अनुक्रम अद्वितीय नहीं हैं, एक गणनीय क्रम के लिए एक मौलिक अनुक्रम लंबाई sequ का होना चाहिए।

— एंडर्स कासोर्ग

Answer 11

गणितज्ञ, 99 बाइट्स

(मान लिया assum 1 बाइट लेता है)

0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)&

पहले 3 कमांड x±yमूल्यांकन करने के लिए परिभाषित करते हैं Ackermann(y, x)।

फ़ंक्शन का परिणाम f(#)=#±#±#±#±#±#±#±#पैरामीटर के मान को प्राप्त करने से पहले 1 पर लागू करने की आवश्यकता की संख्या है । जैसे f(#)=#±#±#±#±#±#±#±#(वह है f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) बहुत तेजी से बढ़ता है, फ़ंक्शन बहुत धीमी गति से बढ़ता है।

Answer 12

क्लोजर, 91 बाइट्स

(defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur(* r v)(Math/log v))))))))

तरह की गणना sum 1/(n * log(n) * log(log(n)) * ...), जो मुझे यहाँ से मिली । लेकिन फ़ंक्शन 101 बाइट्स तक समाप्त हो गया, इसलिए मुझे पुनरावृत्तियों की स्पष्ट संख्या को छोड़ना पड़ा, और जब तक कि संख्या एक से अधिक न हो, तब तक पुनरावृति करें। उदाहरण इनपुट के लिए आउटपुट 10^i:

0 1
1 3.3851305685279143
2 3.9960532565317575
3 4.232195089969394
4 4.370995106860574
5 4.466762285601703
6 4.53872567524327
7 4.595525574477128
8 4.640390570825608

मुझे लगता है कि यह संशोधित श्रृंखला अभी भी विचलन कर रही है, लेकिन अब इसे कैसे साबित करना है, यह जानते हैं।

तीसरी श्रृंखला को आंशिक रूप से 10 से अधिक शब्दों से पहले एक गोगोलिप्लेक्स संख्या की आवश्यकता होती है।

Answer 13

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

(p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log)

स्पष्टीकरण :

Idx => xनिम्नलिखित में संदर्भित करता है ।

आइए पहले नज़र डालते हैं:

p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))

p(Math.log)के बराबर है log*(x)।

p(p(Math.log))के बराबर है log**(x)( log*जब तक कि मूल्य 1 पर हो, तब तक आप कितनी बार ले सकते हैं )।

p(p(p(Math.log)))के बराबर है log***(x)।

प्रतिलोम एकरमन फ़ंक्शन alpha(x)लगभग उस समय की न्यूनतम संख्या के बराबर होता है जिसे आपको pतब तक रचना करने की आवश्यकता होती है जब तक कि मान 1 पर न हो।

अगर हम उपयोग करते हैं:

p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x))

तो हम लिख सकते हैं alpha = p(Id)(Math.log)।

हालांकि, यह बहुत उबाऊ है, तो चलो स्तरों की संख्या में वृद्धि करें:

p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x))

यह ऐसा है कि हमने कैसे निर्माण किया alpha(x), करने के बजाय log**...**(x), अब हम करते हैं alpha**...**(x)।

हालांकि यहाँ क्यों रुकना है?

p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x))

यदि पिछला कार्य है f(x)~alpha**...**(x), तो यह अब है ~ f**...**(x)। हम इसका एक और स्तर अपने अंतिम समाधान को प्राप्त करने के लिए करते हैं।

Comments

" p(p(x => x - 2)) लगभग बराबर है log**(x)(जितनी बार आप ले सकते हैं, log*जब तक कि मान 1 से अधिक न हो)"। मैं इस कथन को नहीं समझता। यह मेरे लिए लगता है कि p(x => x - 2)" 2जब तक कि मूल्य अधिकतम 1 पर हो, तब तक आप कितनी बार घटा सकते हैं "। यही है, पी (x => x - 2) `को" 2 से विभाजित करें "फ़ंक्शन होना चाहिए। इसलिए p(p(x => x - 2))"जितनी बार आप 2 को विभाजित कर सकते हैं, जब तक कि मान 1 से अधिक न हो" होना चाहिए ... यानी यह logफ़ंक्शन होना चाहिए , log*या नहीं log**। शायद यह स्पष्ट किया जा सकता है?

— गणितमण्डल

@mathmandan लगता है जैसे मैं उस लाइन पर लिखने में कोई त्रुटि है, यह होना चाहिए p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x)), जहां pपारित हो जाता है p(f)अन्य लाइनों में की तरह, नहीं f।

— es1024