আপনারা কেউ কেউ বিগনাম বেকওফের সাথে পরিচিত হতে পারেন , যা বেশ আকর্ষণীয়ভাবে শেষ হয়েছিল। কিছু বাধা এবং তাত্ত্বিক পরিস্থিতিতে যেমন প্রোগ্রামটি চালাতে পারে এমন একটি কম্পিউটারের ফলাফল কে সবচেয়ে বেশি হবে এমন সি প্রোগ্রাম লেখার লক্ষ্যে লক্ষ্যটি কমবেশি সংক্ষিপ্ত করা যেতে পারে।

একই চেতনায় আমি সকল ভাষার জন্য একই ধরণের চ্যালেঞ্জ উন্মুক্ত করছি। শর্তগুলি হ'ল:

সর্বাধিক 512 বাইট ।
চূড়ান্ত ফলাফলটি অবশ্যই STDOUT এ মুদ্রিত করতে হবে। এটি আপনার স্কোর। যদি একাধিক পূর্ণসংখ্যা মুদ্রিত হয় তবে সেগুলি সংক্ষিপ্ত করে তোলা হবে।
আউটপুট অবশ্যই একটি পূর্ণসংখ্যা হতে হবে। (দ্রষ্টব্য: অনন্ত কোনও পূর্ণসংখ্যা নয় ))
কোনও 10-এর চেয়ে বড় বিল্ট-ইন ধ্রুবক নয়, তবে সংখ্যা / সংখ্যাগুলি ভাল (যেমন অ্যাভোগাড্রোর ধ্রুবক (একটি বিল্ট-ইন ধ্রুবক হিসাবে) অবৈধ, তবে 10000 নয়))
চালানোর জন্য পর্যাপ্ত সংস্থান সরবরাহ করার সময় প্রোগ্রামটি অবশ্যই শেষ করতে হবে।
মুদ্রিত আউটপুট হতে হবে নির্ণায়ক যখন যথেষ্ট সম্পদ চালানো যাবে প্রদান করা হয়েছে।
আপনার প্রোগ্রামটি চালানোর জন্য আপনাকে যথেষ্ট পরিমাণে পূর্ণসংখ্যা বা বড় চিহ্ন প্রদান করা হয়েছে। উদাহরণস্বরূপ, যদি আপনার প্রোগ্রামটি ^{১০,০০০,০০০ এর} চেয়ে কম সংখ্যকতে বেসিক অপারেশনগুলি প্রয়োগ করার প্রয়োজন হয় তবে আপনি ধরে নিতে পারেন যে এটি চালিত কম্পিউটারটি কমপক্ষে কমপক্ষে ^{10,000,000 ডলার} পর্যন্ত সংখ্যা পরিচালনা করতে পারে । (দ্রষ্টব্য: আপনার প্রোগ্রামটি এমন একটি কম্পিউটারেও চালানো যেতে পারে যা ১০,০০০,০০০ ^ডলার পর্যন্ত সংখ্যা পরিচালনা করে , সুতরাং কেবলমাত্র কম্পিউটারটি যে সর্বোচ্চ সংখ্যক সংখ্যক সংখ্যক হ্যান্ডেল করতে পারে তার উপর কল করা ^{নির্বিচার} ফলাফলের ফল দেয় না results)
আপনার প্রোগ্রামটির জন্য 5 সেকেন্ডের মধ্যে সম্পাদন শেষ করার জন্য আপনাকে যথেষ্ট পরিমাণে কম্পিউটিং শক্তি সরবরাহ করা হয়েছে। (সুতরাং আপনার প্রোগ্রামটি যদি আপনার কম্পিউটারে এক ঘন্টার জন্য চলমান থাকে এবং শীঘ্রই যে কোনও সময় শেষ হয় না তবে চিন্তা করবেন না))
কোনও বাহ্যিক সংস্থান নেই, সুতরাং যদি না এটি অন্তর্নির্মিত থাকে তবে সেই অ্যাকার্ম্যান ফাংশনটি আমদানি করার বিষয়ে চিন্তা করবেন না।

সমস্ত icalন্দ্রজালিক আইটেম অস্থায়ীভাবে উদার দেবতা থেকে ধার করা হচ্ছে।

অজানা সীমা সহ অত্যন্ত বড়

স্টিভেন এইচ , পাইথ f_{3 + B³F + ω²} (256²⁶ )

যেখানে B³F- এর মৌলিক অনুক্রমের সাথে চার্চ-ক্লিন অর্ডিনাল

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

লিডারবোর্ড:

কেবল সুন্দর শিল্প , রুবি f_{ψ ₀ (এক্স (Ω _{এম + এক্স (Ω _{এম + 1}^{Ω _{এম + 1}} )} )) + 29} (9^{9 ⁹} )
স্টিভেন এইচ , পাইথ চ_{ψ (Ω ^Ω ) + ω² + 183} (256^27! )
ফাঁস নুন , পাইথন 3 ফ_{ε ₀} (9^{9 ⁹} )
ফেজেফো , পাইথন 3 ফ_{ω ^{ω ⁶}} (এফ_{ω ^{ω ⁵}} (9e999))
স্টিভেন এইচ , পাইথন 3 ফ_{ω ^ω + ω²} (9^{9 ^{9 ⁹⁹}} )
কেবল সুন্দর শিল্প , রুবি f_{ω + 35} (9^{9 ⁹⁹} )
i .. , পাইথন 2 , f₃ (f₃ (141))

কিছু পক্ষের নোট:

আমরা যদি আপনার স্কোরটি যাচাই করতে না পারি তবে আমরা এটিকে লিডারবোর্ডে রাখতে পারি না। সুতরাং আপনি আপনার প্রোগ্রামটি কিছুটা ব্যাখ্যা করার আশা করতে পারেন।

তেমনি, যদি আপনি বুঝতে না পারেন যে আপনার সংখ্যাটি কত বড়, তবে আপনার প্রোগ্রামটি ব্যাখ্যা করুন এবং আমরা এটি কার্যকর করার চেষ্টা করব।

আপনি যদি কোনও লোডারের সংখ্যার প্রোগ্রাম ব্যবহার করেন তবে আমি আপনাকে "অজানা সীমা সহ চূড়ান্তভাবে বড়" নামক একটি পৃথক বিভাগে রাখব , যেহেতু দ্রুতগতির ক্রমবর্ধমান স্তরের ক্ষেত্রে লোডার সংখ্যার একটি তুচ্ছ ত্রিভুজ বাউন্ড নেই ' স্ট্যান্ডার্ড 'মৌলিক ক্রম।

সংখ্যাগুলি দ্রুত বর্ধমান শ্রেণিবিন্যাসের মাধ্যমে স্থান পাবে ।

যারা প্রায় ক্রমবর্ধমান সত্যিকারের সংখ্যায় দ্রুত বর্ধনশীল শ্রেণিবিন্যাসটি কীভাবে ব্যবহার করতে শিখতে চান তাদের জন্য আমি একটি ডিসকর্ড সার্ভার হোস্ট করছি just এখানে একটি আড্ডার ঘরও রয়েছে : সাধারণতা ।

অনুরূপ চ্যালেঞ্জ:

বৃহত্তম সংখ্যা মুদ্রণযোগ্য

TREE (3) এর চেয়ে বড় গল্ফ

সংক্ষিপ্ততম সমাপনী প্রোগ্রাম যার আউটপুট আকার গ্রাহামের সংখ্যার বেশি

যারা কিছু সাধারণ প্রোগ্রাম দেখতে চান যা ক্ষুদ্র মানের জন্য দ্রুত বর্ধমান শ্রেণিবিন্যাসকে আউটপুট দেয়, তারা এখানে:

রুবি: দ্রুত বর্ধমান শ্রেণিবিন্যাস

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

প্রভৃতি

থেকে যেতে f_xকরার f_(x+1), আমরা এক লুপ যোগ n.times{...}।

অন্যথায়, আমরা পূর্ববর্তী সমস্ত যেমনগুলির সাথে ডায়াগোনালাইজ করছি

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)

প্রভৃতি

math code-challenge busy-beaver

— কেবল সুন্দর শিল্প
সূত্র

সংখ্যাগুলি কি অন্তর্নির্মিত স্থির হিসাবে গণনা করা হয়?

— পাইরুলেজ

3

@ ক্লোসওয়েটারগুলি কীভাবে এটি খুব বিস্তৃত হতে পারে ... ঠিক আছে, ব্যবহারকারীকে অসীম বহু সংখ্যায় একটি নম্বর আউটপুট করতে বলা ব্যবহারকারীকে অসীম অনেকগুলি কাজ করতে বেছে নিতে অনুরোধ করার মতো নয়। এই প্রশ্নটি ন্যায়সঙ্গত হওয়ার জন্য ব্যবহারকারীকে একই জিনিসটি করতে বলুন। ইতিমধ্যে 4 টি কাছাকাছি ভোট খুব বিস্তৃত হিসাবে ...

— ব্যবহারকারী 202729

1

@ Οurous হ্যাঁ, আপনি এটি ধরে নিতে পারেন। তবে উপলব্ধি করুন যে যখন আপনার প্রোগ্রামটিকে দ্রুত গণনা সহ আরও সংস্থান দেওয়া হয়, তখন আউটপুটটি অবশ্যই নির্দ্বিধায় থাকতে হবে।

— কেবল সুন্দর আর্ট

1

আমি অন্য মন্তব্য বিভাগে বলেছি কেন আমি মনে করি সীমান্ত ব্রেইনফাক ব্যাসি বিভার ফাংশনটি তাত্পর্যপূর্ণ হবে তবে আমি আরও সাধারণভাবে এটি যুক্ত করতে চাই, আমি মনে করি না যে চার্চ-ক্লিন অর্ডিনাল কোনও কম্পিউটার প্রোগ্রামের জন্য উপযুক্ত স্তর হবে । একটি প্রোগ্রামের সাথে একটি কোড করতে পারে এমন একটি ফাংশনটি গণনাযোগ্য, এবং তাই কিছু পর্যাপ্ত শক্তিশালী পুনরাবৃত্ত শব্দ তত্ত্বের প্রবর্তনযোগ্য পুনরাবৃত্ত ফাংশনগুলির মধ্যে পড়ে। এই তত্ত্বটির একটি পুনরাবৃত্ত প্রমাণ তাত্ত্বিক অর্ডিনাল থাকবে এবং যুক্ত ফাংশনটি যুক্তিসঙ্গত মৌলিক অনুক্রমগুলি ধরে ধরে FGH এ নিয়মিতের নীচে থাকবে।

— ডিডলিট

1

অবশ্যই প্রকৃত ব্যস্ত বিভার ফাংশনটি প্রোগ্রামে কোড করা যাবে না (হাইপারকম্পিউশনাল ভাষাগুলি একপাশে), এবং সীমাবদ্ধ ব্যস্ত বিভার ফাংশনগুলি যা প্রয়োজনীয়ভাবে প্রোগ্রাম করা যেতে পারে তা অনেক ধীর গতিতে বাড়তে হবে।

— ডিডলিট

7

রুবি, ফ _{ψ ₀ (এক্স (Ω _{এম + এক্স (Ω _{এম + 1}^{Ω _{এম + 1}} )} )) + 29} (9 ^{9 ⁹} )

যেখানে এম হ'ল প্রথম মাহলো 'অর্ডিনাল', এক্স হ'ল চি ফাংশন (মাহলো ভেঙে ফাংশন), এবং ψ হ'ল অর্ডিনাল ভেঙে ফাংশন।

f=->a,n,b=a,q=n{c,d,e=a;!c ?[q]:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

এটি অনলাইন চেষ্টা করুন!

কোড ব্রেকডাউন:

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

ম্যাথ ব্রেকডাউন:

fহ্রাস aউপর ভিত্তি করে n,b,q।

মূল ধারণাটি হ'ল চূড়ান্তভাবে বাসা aবেঁধে রাখা এবং এটি হ্রাস না হওয়া পর্যন্ত বার বার এটি হ্রাস করা a=0। সরলতার জন্য, আসুন

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

আপাতত, শুধুমাত্র চিন্তা করা যাক n।

যে কোনও পূর্ণসংখ্যার জন্য k, আমরা পাই f[k,n]=k-1, তাই আমরা এটি দেখতে পারি

g[k,n]=n+k

আমরা তখন আছে, কোন d, f[[0,d],n]=n, তাই আমরা দেখতে পারেন

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

আমাদের তখন, সবার জন্য c,d,e, আছে f[[c,0,e],n]=f[[c,d,0],n]=c। উদাহরণ স্বরূপ,

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

আমাদের তখন রয়েছে, c,d,eএর আগের কোনও ক্ষেত্রে এটি পড়ে না f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]। এখান থেকেই এটি জটিল হতে শুরু করে। কয়েকটি উদাহরণ:

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

এটি সেখান থেকে দ্রুত mpালু। আগ্রহের কিছু বিষয়:

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

অবশেষে fফাংশনটির আরও তর্ক যুক্ত করার পাশাপাশি অ্যারের জন্য আরও কিছু ক্ষেত্রে আমাদের সর্বাধিক নামকরণকৃত কম্পিউটিংযোগ্য স্বরলিপিগুলি ছাড়িয়ে যাওয়ার অনুমতি দেয়। কিছু বিশেষত পরিচিত:

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function

— কেবল সুন্দর শিল্প
সূত্র

1

সাধারণ ব্যাখ্যা?

— ক্যালকুলেটরলাইন

এটি কি এখনও আপনার বৃহত্তম সংজ্ঞায়িত নম্বর? দেখা যাচ্ছে তাই!

— ThePlasmaRailgun

3

পাইথ, এফ _{ψ (Ω ^Ω ) + ω ² +183} (6 256 ^27! )

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

কোনও খালি খালি ইনপুট প্রয়োজন, তবে এর মান ব্যবহার করা হয় না।

ব্যাখ্যা ( নতুন এবং আসলে-যুক্তিসঙ্গতভাবে-স্কোরিং সংস্করণের জন্য):

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

এটির আকারটি গণনা করা আমার পক্ষে খুব কঠিন কারণ বেশিরভাগ দিন এটি দেরী হয়ে গেছে এবং আমি দ্রুত বর্ধমান শ্রেণিবিন্যাসের সাথে খুব বেশি পরিচিত নই বা আমি কীভাবে কতবার বেরিয়েছি তা বের করার চেষ্টাও করতে পারি না y()ভিজা কাপড় হইতে জল নিংড়াইবার যন্ত্র। আমি এখন অধ্যক্ষগুলি সম্পর্কে আরও জানার পরেও, আমার প্রোগ্রামে পুনরাবৃত্ত সংজ্ঞা দ্বারা প্রতিনিধিত্ব করা অর্ডিনালটির মান কীভাবে গণনা করতে হবে তা আমার এখনও ধারণা নেই। আমি ডিসকর্ড সার্ভারে যোগ দেব, তবে এটি একটি ছদ্মনামের অধীনে আমি বরং আমার আসল নামের সাথে যুক্ত হব না।

দুর্ভাগ্যক্রমে, যেহেতু আমি দ্রুত বর্ধমান শ্রেণিবিন্যাস সম্পর্কে তুলনামূলকভাবে খুব কম জানি, আমি ইতিমধ্যে রুবির উত্তরটি হারিয়ে ফেলতে পারি। এটা বলা আমার পক্ষে শক্ত। ~~আমি রুবীর উত্তরটি মারতে পারি, তবে আমি 100% নিশ্চিত নই।~~ ¯ \: _ (ツ): _ / ¯

— স্টিভেন এইচ।
সূত্র

যদি আমি সঠিকভাবে বুঝতে পারি তবে আপনার স্কোর সম্ভবত বলের পার্কের কোথাও 27^^^27^^27^^4বা f4(27^^27^^4)) ≈ f4(f3(f3(19)))।

— কেবল সুন্দর আর্ট

আমি একটি ছোট পরিবর্তন করেছি যা গতকাল সম্পর্কে আমার ভাবা উচিত ছিল, তবে কোনওভাবেই হয়নি - yকেবল অপারেশন করার y(Q-1)পরিবর্তে অপারেট করার জন্য পুনরাবৃত্তি করা Q। এটি কীভাবে স্কোরকে প্রভাবিত করে?

— স্টিভেন এইচ।

1

আমি পুরোপুরি নিশ্চিত নই যে কী চলছে। নেই y(Q) = L(y(Q-1)), কোনটাই?

— কেবল সুন্দর আর্ট

1

আমি মনে করি আমাদের আরও ভাগ্য ভালো হবে এটি একটি চ্যাটরুমে করার জন্য ।

— স্টিভেন এইচ।

@ সিম্প্লি বিউটিফুলআর্ট, এটি ধরণের ছোট হওয়ার কারণে এটির জন্য দ্রুত বর্ধমান শ্রেণিবিন্যাসের স্বরলিপি ব্যবহার না করা সম্ভবত সেরা।

— পাইরুলেজ

3

পাইথ, এফ _{3 + σ _-1 + ω ²} (256 ²⁶ )

যেখানে σ _মি [এন] হ'ল ব্যস্ত বিভার ফাংশন order অর্ডারের আদেশ দেওয়া mহয়েছে n: σ _এম [এন] = Σ _এম (এন)) আদেশটি -1বোঝাতে হ'ল যে এখানে ব্যস্ত বিভারকে সত্যিকারের টুরিং মেশিনে ডাকা হচ্ছে না, বরং Qউপাদানগুলির একটি সীমাবদ্ধ মোড়ানোর টেপ দিয়ে একটি সন্নিবেশ করা হয়েছে । এটি এই প্রোগ্রামগুলির জন্য থামার সমস্যাটি সমাধানযোগ্য হতে দেয়।

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

টিএল; ডিআর হ'ল এটি দৈর্ঘ্যের কিউ এর সমস্ত সম্ভাব্য ব্রেইনএফ ** কে প্রোগ্রাম তৈরি করে, এমন পরিবেশে চালায় যেখানে পূর্ণসংখ্যার সর্বাধিক মান Q এবং টেপের দৈর্ঘ্য Q হয় এবং এই ক্রিয়াকলাপ থেকে সমস্ত রাজ্যকে একসাথে সংকলিত করে 3+এফ ( _{^{2 এর}} স্কেলে _{উপরেরটি} পুনরাবৃত্তি করে Q তে সংযুক্ত করুন (এটিই ) ।

আমি আরও কিছু করতে চাইলে আমি এখনও কাজ করতে অর্ধশত অক্ষর রেখেছি, তবে এটি কোথায় রয়েছে তা আবিষ্কার না করা পর্যন্ত আমি এটিকে ঠিক যেমন রেখে দেব।

— স্টিভেন এইচ।
সূত্র

আমি লিডারবোর্ডে - এর আরও ভাল ব্যাখ্যা করেছি।

— কেবল সুন্দর আর্ট

4

এটি আমার কাছে বিশেষ ব্যস্ত বিভার ফাংশনটির মতো দেখে মনে হচ্ছে না যেন দ্রুত বর্ধমান হয়। 0 এবং Q এর মধ্যে Q এর পূর্ণসংখ্যার সীমা রয়েছে, প্রোগ্রামে কেবল (Q + 1) ^ Q সম্ভাব্য টেপ এবং Q সম্ভাব্য অবস্থান রয়েছে, সুতরাং সর্বাধিক Q * (Q + 1) ^ Q এর সম্ভাব্য রাষ্ট্রগুলি থাকতে পারে একটি চলমান প্রোগ্রাম। সুতরাং কোনও প্রোগ্রাম অবশ্যই Q * (Q + 1) ^ Q পদক্ষেপের মধ্যেই থামবে বা হবে না। সম্ভাব্য প্রোগ্রামগুলির সংখ্যাটি তাত্পর্যপূর্ণ উপরের সীমা দ্বারাও সীমাবদ্ধ। সুতরাং আমার কাছে দেখে মনে হচ্ছে যেন এই ব্যস্ত বিভার ফাংশনটির উপরের বাউন্ড যুক্ত হয়, এবং চূড়ান্ত ফাংশনটি $ f _ {\ ওমেগা ^ 2} of এর ক্রমে হবে $

— ডিডলিট

2

পাইথন, এফ ₃ (চ ₃ (141)), 512 বাইট

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

এটি সত্যই কোনও বৈধ উত্তর নয়, তবে আমি এটি যেভাবেই পোস্ট করতে চেয়েছিলাম। একটি দ্রুত পালটা:

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

যাইহোক, এই উত্তরটি প্রযুক্তিগতভাবে আইনী কিনা আমি জানি না, তবে এটি লিখতে মজা পেয়েছিল। আপনি কোডটিতে যে কোনও ত্রুটি আবিষ্কার করেন তা নির্দ্বিধায় محسوس করুন।

— আমি ..
সূত্র

আমি মনে করি এটি f_3 (9), এবং এটি অবশ্যই আইনী। for j in range(f(x)): for j in range(f(x)): x = f(x)যদিও বাসা বেঁধে আপনি আরও বেশি সংখ্যক সংখ্যা পাবেন । আমাদের সাথে কথা বলার জন্য আড্ডায় যোগ দিন !

— স্টিভেন এইচ।

কেন এটি একটি বৈধ উত্তর নয়?

— কেবল সুন্দর আর্ট

আমি বেশ করা হয়নি পেতে , প্রশ্ন তাই আমি ঠিক তৈরি আমি যা চিন্তা সঠিক ছিল।

— আমি ..

1

রুবি, সম্ভবত ~ f _{ω + 35} (9 ^{9 ⁹⁹} )

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

এটি অনলাইন চেষ্টা করুন!

আনুমানিক গণিত ব্যাখ্যা:

নীচে উপরের প্রোগ্রামটির প্রায় সমান, তবে সরলীকৃত যাতে এটি বুঝতে সহজ হয়।

G(0,k) = k আমাদের বেস ফাংশন।

মূল্যায়ন করার জন্য G(n,k), আমরা এটি গ্রহণ করি kএবং হিসাবে এটি লিখি G(n-1,1) + ... + G(n-2,1) + ... + G(0,1)।

তারপরে G(x,1)'গুলি'র সমস্ত পরিবর্তন করুন G(x,2)এবং 1সম্পূর্ণ ফলাফল থেকে বিয়োগ করুন ।

উপরের ফর্মটিতে আবার G(x,2)কোথায় লিখুন x<nএবং আবার বাকীটি শেষে রেখে দিন leave একই পদ্ধতি পুনরাবৃত্তি করুন, পরিবর্তন G(x,2)করার জন্য G(x,3), ইত্যাদি

ফলাফল পৌঁছে গেলে -1, বেসটি ফেরত দিন (এটি bহবে G(x,b))

উদাহরণ:

জি (1,1):

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

জি (1,2):

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

জি (1,3):

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

জি (2,5):

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

কিছু গণিত করছেন, আমি এটি পেলাম

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

এবং এর বাইরে এটি কিছুটা লোমশ হয়ে উঠেছে।

সাধারণভাবে, আমরা আছে

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.

— কেবল সুন্দর শিল্প
সূত্র

1

পাইথন 3, চ _{ω ^ω + ω * ω} (9 ^{9 ^{9 ⁹⁹}} )

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

আমি শীঘ্রই একটি ব্যাখ্যা পেতে হবে।

— স্টিভেন এইচ।
সূত্র

1

পাইথন 3 , ~ f _{ε ₀} (9 ^{9 ⁹} )

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

এটি অনলাইন চেষ্টা করুন!

— ফুটো নুন
সূত্র

এন = 9 ** 9e99 কিছুটা বড় হতে হবে

— 21

কার উত্তর?

— লিকি নুন

আমি বলতে চাইছি আপনি যদি এন = 9 ** 9e99 এর সাথে প্রথমটি প্রতিস্থাপন করেন তবে আউটপুটটি কিছুটা বড় হওয়া উচিত কারণ 9e99> 9 ** 9। অবশ্যই এটি আপনার উত্তর।

— fejfo

@fejfo আমার অর্থ এটি আমার র‌্যাঙ্কিংয়ে পরিবর্তন আনবে না।

— লিকি নুন

2

যে ব্যাপার?

— fejfo

1

পাইথন 3, 323 বাইট, জি ^9e9 (9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

পাইথন 3 সত্যই পুনরাবৃত্তিযোগ্য ভাষা, এর অর্থ এই যে কেবল একটি ফাংশন নিজে কল করতে পারে না, একটি ফাংশন অন্যান্য ফাংশনগুলিকে ইনপুট বা আউটপুট ফাংশন হিসাবে গ্রহণ করতে পারে। নিজেকে আরও উন্নত করতে ফাংশনগুলি ব্যবহার করা আমার প্রোগ্রামের উপর ভিত্তি করে।

f = ল্যাম্বদা এক্স, এ: [এ (এক্স), ই (এক্স) ((এক্স, এ)) [১]]

সংজ্ঞা

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

সংজ্ঞা ব্যাখ্যা

a(x)=9^x a বেস ফাংশন, আমি এই ফাংশনটি বেছে নিয়েছি কারণ x> 0 => এ (এক্স)> এক্স` যা নির্দিষ্ট পয়েন্টগুলি এড়িয়ে চলে।

b(x,f)=a(x), f^xবি হ'ল সাধারণ উন্নতিকরণ ফাংশন, এটি কোনও ফাংশনে লাগে এবং এর আরও ভাল সংস্করণ আউটপুট করে। খ এমনকি নিজের প্রয়োগ করা যেতে পারে:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

তবে পুরোপুরি bউন্নতি করার জন্য bআপনাকে খ এর আউটপুট নিতে হবে এবং এটি নতুন খ হিসাবে ব্যবহার করতে হবে, সি0 এটি করে:

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

আরও সাধারণ সি (এন) ফাংশনটি এন শেষ যুক্তিটি (0 থেকে শুরু করে) নেয় c(1)(…,f,a)=f(…,f,a)এবং তাই c(2)(…,f,a,b)=f(…,f,a,b)। *lএর অর্থ l একটি অ্যারে এবং l[~n]এন শেষ যুক্তিটি গ্রহণ করে

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld অন্যান্য সমস্ত ইনপুট ফাংশনগুলি (যার মধ্যে তালিকাটির কারণে কোনও পরিমাণ থাকতে পারে) আপগ্রেড করতে b এবং b আপগ্রেড করতে সি 0 ব্যবহার করে
d(x,b,c,d)>9^x,b^x,c^x,d^xএবংd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

আপনি যদি সি এর সাথে একত্রিত হন তবে ডি আরও ভাল হয়:
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

আপনি যত বেশি সি (এক্স) যুক্ত করবেন শেষ পর্যন্ত তত বেশি শক্তিশালী হয়। প্রথম সি 0 সর্বদা ডি থাকে: c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
তবে দ্বিতীয়টি পিছনে পুনরাবৃত্তি করা সংস্করণগুলি ছেড়ে দেয়:

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

যখন d^xপরিশেষে গণনা করা হয় c4একটি আরো অনেক কিছু iterated সংস্করণ নিতে হবে dপরবর্তী সময়। c4^xঅবশেষে গণনা করা হলে এর c3আরও পুনরাবৃত্ত সংস্করণ লাগবে c4,…
এটি পুনরাবৃত্তির একটি সত্যই শক্তিশালী সংস্করণ তৈরি করে কারণ d:

bব্যবহার উন্নত করেc0
c0ব্যবহার উন্নত করেb
নীড় ব্যবহার করে সমস্ত স্তর উন্নত করে b তাদের উন্নত করে উন্নতি করে, এর অর্থ এটি আরও পুনরাবৃত্তি করা হলে ডি আরও শক্তিশালী হয়।

গ এর এই দীর্ঘ শৃঙ্খলা তৈরি করা কি e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]করে।
এটি c0^xবাইপাস ব্যবহার করে যা c0কেবল দেয় d।
এর [1]অর্থ এটি শেষ পর্যন্ত এর দ্বিতীয় আউটপুট ফিরে আসবে d^…। সুতরাংb^… ।

এই সময়ে আমি ইনপুট বাড়ানো ব্যতীত এর আউটপুটকে উল্লেখযোগ্যভাবে বাড়ানোর জন্য ই (এক্স) এর সাথে করার কোনও কিছুই ভাবতে পারি না।

তাই f(x,a)=a(x),e(a(x))(x,a)[1](x)ব্যবহার b^…দ্বারা উত্পন্ন e(x)একটি উন্নততর বেস ফাংশন এবং যে ব্যবহারগুলি বেস ফাংশন কল করতে আউটপুট e(x)একটি বড় ইনপুট সঙ্গে।

g(x)=e(x)(x,f)[1](x,a)[1](x)e(x)বাসা থেকে একটি চূড়ান্ত ব্যবহার fকরে এবং একটি সত্যই শক্তিশালী ফাংশন উত্পাদন করে।

Fgh আনুমানিক

যে কোনও ধরণের fg এর সাথে এই সংখ্যাটি অনুমান করতে আমার সহায়তা প্রয়োজন হবে।

পুরানো সংস্করণ : f _{ω ^{ω ⁶}} (f _{ω ^{ω ⁵}} (9e999)), এটি অনলাইনে চেষ্টা করুন! ব্যাখ্যা সংশোধন ইতিহাস

— fejfo
সূত্র

আসলে, f_1(x) = x+xতবে দীর্ঘকালীন সময়ে, এটি খুব বেশি গুরুত্ব দেয় না।

— কেবল সুন্দর আর্ট

আপনি কি আপনার মৌলিক ক্রমগুলি আরও কিছুটা ব্যাখ্যা করতে পারেন?

— কেবল সুন্দর আর্ট

@ সিম্প্লি বিউটিফুলআর্ট ওও হ্যাঁ আমি এটিকে পরিবর্তন করার পরে আপডেট করতে ভুলে গেছি x*x।

— fejfo

@ সিম্প্লি বিউটিফুলআর্ট আমার উত্তরটি কোনও অর্ডিনাল ব্যবহার করে না সুতরাং অধ্যাদেশগুলি দিয়ে এটি ব্যাখ্যা করা আমার পক্ষে কঠিন। আমি সত্যিই যা করতে পারি তা হ'ল আমার ফাংশনগুলির সংজ্ঞা এবং এফএইচএইজে প্রভাবের একটি সংলগ্নতা। উদাহরণ:a2(f_n)~=f_{n+1}

— fejfo

1

রুবি, এফ _{ε ₀ 2} (5), 271 বাইট

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

এটি অনলাইন চেষ্টা করুন!

এটি এম (এন) মানচিত্রের বাইরে রয়েছে ।

ব্যাখ্যা:

m[0][f0][k] = f0[f0[...f0[k]...]]সঙ্গে kএর পুনরাবৃত্তিও f0।

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]সঙ্গে kএর পুনরাবৃত্তিও f0।

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]সঙ্গে kএর পুনরাবৃত্তিও f0।

সাধারণভাবে, m[n]লাগে n+2যুক্তি প্রথম আর্গুমেন্ট iterates, f0, kবার দ্বিতীয় যুক্তি সম্মুখের, এবং তারপর তৃতীয় যুক্তি সম্মুখের ফলে ফাংশন প্রযোজ্য (যদি থাকে তাহলে), তারপর চতুর্থ যুক্তি সম্মুখের ফলে ফাংশন প্রযোজ্য (যদি থাকে তাহলে), প্রভৃতি

উদাহরণ

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

সাধারণভাবে m[0][n↦n+1] = n↦2n,।

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

সাধারণভাবে m[0][m[0][n↦n+1]] = n↦n*2^n,।

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

সাধারণভাবে, m[1][m[0]][n↦n+1] = f_ωদ্রুত বর্ধমান শ্রেণিবিন্যাসে।

g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

এবং চূড়ান্ত আউটপুট হচ্ছে

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

— কেবল সুন্দর শিল্প
সূত্র

বিগনাম বেকওফ পুনরায় বুট করুন

অজানা সীমা সহ অত্যন্ত বড়

লিডারবোর্ড:

কিছু পক্ষের নোট:

রুবি: দ্রুত বর্ধমান শ্রেণিবিন্যাস

রুবি, ফ ψ 0 (এক্স (Ω এম + এক্স (Ω এম + 1 Ω এম + 1 ) )) + 29 (9 9 9 )

কোড ব্রেকডাউন:

ম্যাথ ব্রেকডাউন:

পাইথ, এফ ψ (Ω Ω ) + ω 2 +183 (6 256 27! )

পাইথ, এফ 3 + σ -1 + ω 2 (256 26 )

পাইথন, এফ 3 (চ 3 (141)), 512 বাইট

রুবি, সম্ভবত ~ f ω + 35 (9 9 99 )

আনুমানিক গণিত ব্যাখ্যা:

উদাহরণ:

জি (1,1):

জি (1,2):

জি (1,3):

জি (2,5):

পাইথন 3, চ ω ω + ω * ω (9 9 9 99 )

পাইথন 3 , ~ f ε 0 (9 9 9 )

পাইথন 3, 323 বাইট, জি 9e9 (9)

ব্যাখ্যা

সংজ্ঞা

সংজ্ঞা ব্যাখ্যা

Fgh আনুমানিক

রুবি, এফ ε 0 2 (5), 271 বাইট

ব্যাখ্যা:

উদাহরণ

রুবি, ফ _{ψ ₀ (এক্স (Ω _{এম + এক্স (Ω _{এম + 1}^{Ω _{এম + 1}} )} )) + 29} (9 ^{9 ⁹} )

পাইথ, এফ _{ψ (Ω ^Ω ) + ω ² +183} (6 256 ^27! )

পাইথ, এফ _{3 + σ _-1 + ω ²} (256 ²⁶ )

পাইথন, এফ ₃ (চ ₃ (141)), 512 বাইট

রুবি, সম্ভবত ~ f _{ω + 35} (9 ^{9 ⁹⁹} )

পাইথন 3, চ _{ω ^ω + ω * ω} (9 ^{9 ^{9 ⁹⁹}} )

পাইথন 3 , ~ f _{ε ₀} (9 ^{9 ⁹} )

পাইথন 3, 323 বাইট, জি ^9e9 (9)

রুবি, এফ _{ε ₀ 2} (5), 271 বাইট