งานของคุณคือการสร้างฟังก์ชั่นที่เติบโตช้าที่สุดที่คุณสามารถทำได้ไม่เกิน 100 ไบต์

โปรแกรมของคุณจะรับข้อมูลเป็นจำนวนเต็มไม่ใช่ค่าลบและส่งออกจำนวนเต็มแบบไม่ลบ เรียกโปรแกรมของคุณ P

จะต้องเป็นไปตามเกณฑ์ทั้งสองนี้:

• ซอร์สโค้ดของมันต้องน้อยกว่าหรือเท่ากับ 100 ไบต์
• ทุกภาคมีความ N เช่นว่าสำหรับทุก n> = N, P (n)> เคในคำอื่น ๆLim _{(n-> ∞)} P (n) = ∞ (นี่คือความหมายสำหรับการเป็น "การเติบโต")

"คะแนน" ของคุณคืออัตราการเติบโตของฟังก์ชันพื้นฐานของโปรแกรมของคุณ

โดยเฉพาะอย่างยิ่งโปรแกรม P เติบโตช้ากว่า Q หากมี N เช่นนั้นสำหรับ n> = N, P (n) <= Q (n) และมีอย่างน้อยหนึ่ง n> = N เช่นนั้น P (n ) <Q (n) หากโปรแกรมใดไม่ดีไปกว่าโปรแกรมอื่น ๆ (โดยพื้นฐานแล้วโปรแกรมใดช้ากว่านี้จะขึ้นอยู่กับค่าของ Lim _{(n-> ∞)} P (n) -Q (n))

ฟังก์ชั่นการเจริญเติบโตช้าที่สุดถูกกำหนดให้เป็นฟังก์ชั่นที่เติบโตช้ากว่าฟังก์ชั่นอื่น ๆ ตามคำนิยามในย่อหน้าก่อนหน้า

นี่คืออัตราการเติบโตกอล์ฟดังนั้นโปรแกรมที่เติบโตช้าที่สุดชนะ!

หมายเหตุ:

• เพื่อช่วยให้คะแนนลองใส่ฟังก์ชันที่โปรแกรมของคุณคำนวณในคำตอบ
• นอกจากนี้ยังใส่อินพุทและเอาท์พุททางทฤษฎีบางอย่างเพื่อช่วยให้ผู้คนเข้าใจว่าคุณไปได้ช้าแค่ไหน

Haskell, 98 ไบต์, คะแนน = f _{ε 0} ⁻¹ ( n )

_#[]=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

มันทำงานอย่างไร

นี้คำนวณค่าผกผันของฟังก์ชั่นที่กำลังเติบโตอย่างรวดเร็วมากที่เกี่ยวข้องกับเกมหนอน Beklemishev ของ อัตราการเจริญเติบโตของมันก็เปรียบได้กับฉ_{ε 0}ที่ฉ_αเป็นลำดับชั้นที่เติบโตอย่างรวดเร็วและε ₀เป็นครั้งแรกจำนวน epsilon

สำหรับการเปรียบเทียบกับคำตอบอื่น ๆ โปรดทราบว่า

• การยกกำลังเปรียบได้กับf ₂ ;
• การยกกำลังแบบซ้ำ ( tetrationหรือ↑↑ ) เทียบได้กับf ₃ ;
• arrows ⋯↑↑พร้อมลูกศรmเทียบได้กับf _{m + 1} ;
• ฟังก์ชั่น Ackermannก็เปรียบได้กับฉ_ω ;
• การวนซ้ำของฟังก์ชัน Ackermann (การสร้างเช่นหมายเลขของ Graham ) ยังคงถูกครอบงำโดยf _{ω + 1} ;
• และε ₀เป็นข้อ จำกัด ของอาคารทั้งหมดω ^{ω ω ⋰} ω

Brachylogขนาด 100 ไบต์

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

ลองออนไลน์!

นี่คงไม่มีที่ไหนใกล้ความช้าของคำตอบแฟนซีอื่น ๆ แต่ฉันไม่อยากจะเชื่อเลยว่าไม่มีใครได้ลองวิธีการที่เรียบง่ายและสวยงามนี้

เพียงแค่เราคำนวณความยาวของหมายเลขอินพุตจากนั้นความยาวของผลลัพธ์นี้แล้วความยาวของผลลัพธ์อื่น ๆ ... ทั้งหมด 100 ครั้ง

สิ่งนี้จะเติบโตเร็วพอ ๆ กับบันทึก (บันทึก (บันทึก ... บันทึก (x) โดยมีบันทึก 100 รายการ -10)

หากคุณป้อนหมายเลขของคุณเป็นสตริงสิ่งนี้จะทำงานอย่างรวดเร็วมากสำหรับอินพุตที่คุณสามารถลองได้ แต่อย่าคาดหวังว่าจะเห็นผลลัพธ์ที่สูงกว่า 1: D

JavaScript (ES6), ฟังก์ชัน Ackermann Ackermann *, 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เป็นฟังก์ชั่น Ackermann ฟังก์ชั่นaที่ควรจะเป็นฟังก์ชันผกผัน Ackermann ถ้าผมดำเนินการอย่างถูกต้อง, วิกิพีเดียบอกว่ามันจะไม่ตี5จนเท่ากับm 2^2^2^2^16ฉันStackOverflowไป1000ไหนมาไหน

การใช้งาน:

console.log(a(1000))

คำอธิบาย:

ฟังก์ชั่น Ackermann

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

ฟังก์ชัน Ackermann แบบผกผัน

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

Pure Evil: Eval

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 * a 10 ^{10 10 10 10 10 8.57}ซึ่งประกอบด้วยอะไร แต่โทรมากขึ้นฟังก์ชั่นแลมบ์ดาแต่ละที่จะสร้างสตริงของที่คล้ายกันยาวบนและบนจนในที่สุดyกลายเป็น 0 อย่างเห็นได้ชัด สิ่งนี้มีความซับซ้อนเช่นเดียวกับวิธี Eschew ด้านล่าง แต่แทนที่จะอาศัยตรรกะของการควบคุมแบบ if and and or หรือเพียงแค่การรวมสายใหญ่ ๆ เข้าด้วยกัน (และผลสุทธิก็ยิ่งเพิ่มขึ้น ... อาจเป็นไปได้?)

yค่าที่ใหญ่ที่สุดที่ฉันสามารถจัดหาและคำนวณได้โดยไม่ต้องใช้ Python ในการโยนข้อผิดพลาดคือ 2 ซึ่งเพียงพอแล้วที่จะลดอินพุตของ max-float ให้กลับมาเป็น 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 Sequence? คำตอบสำหรับคนจำนวนมากเป็นแรงบันดาลใจให้กับโซลูชันนี้

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 ส่งผลให้การดำเนินงานจำนวนมากที่จำนวนจุดลอยตัวสูญเสียบิตที่สำคัญทั้งหมด )

การกำหนดค่าการเรียกแลมบ์ดาเดิมให้มีค่าการเรียกซ้ำเป็น 0 และ 2 ...

>>>1.7976931348623157e+308
1.0000000071

หากเปรียบเทียบที่จะทำเพื่อ "ชดเชยจาก 0" แทน "ชดเชยจาก 1" ผลตอบแทนที่ฟังก์ชั่นนี้ซึ่งแน่นอนมีขนาดเล็กกว่า7.1e-96.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ความลึกเดิม (หรือความลึกใกล้กับขนาด googolplex: 10 ^{10 94} )
• 9**9**9e9เพิ่มจำนวนไบต์ทีละ 5 และเพิ่มความลึกของการเรียกซ้ำโดย ... จำนวนบ้า ลึก recursion คือตอนนี้ 10 ^{10 10 9.93}สำหรับการอ้างอิงเป็นกูกอลเพลกซ์คือ 10 ^{10 10} 2
• การประกาศแลมบ์ดาทำให้การเรียกซ้ำเพิ่มขึ้นโดยขั้นตอนพิเศษ: m(m(...))เป็นa(a(a(...)))ต้นทุน 7 ไบต์

ใหม่มูลค่าส่งออก (ที่ความลึก 9 ซ้ำ):

>>>1.7976931348623157e+308
6.77538853089e-05

การเรียกซ้ำลึกลงไปถึงจุดที่ผลลัพธ์นี้ไม่มีความหมายอย่างแท้จริงยกเว้นเมื่อเปรียบเทียบกับผลลัพธ์ก่อนหน้าโดยใช้ค่าอินพุตเดียวกัน:

• ต้นฉบับเรียกว่าlog25 ครั้ง
• การปรับปรุงครั้งแรกเรียกว่า 81 ครั้ง
  • จริงโปรแกรมจะเรียกมันว่า 1e99 ²หรือประมาณ 10 ^{10 2.3}ครั้ง
• รุ่นนี้เรียกมันว่า 729 ครั้ง
  • จริงโปรแกรมจะเรียกมันว่า (9 ^{9 99} ) ³หรือน้อยกว่า 10 ^{10 95}ครั้ง)

การลงทะเบียนเรียน Lambda คะแนน: ???

ฉันได้ยินคุณชอบ lambdas ดังนั้น ...

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 ชั้น (แทนที่จะเป็นgoogolเต็มรูปแบบของพวกเขา):

>>>1.7976931348623157e+308
0.00196323936205

ฉันคิดว่าวิธีนี้มีความซับซ้อนคล้ายกับลำดับ Ackerman เพียงเล็กน้อยแทนที่จะใหญ่

ขอบคุณ ETHproductions สำหรับการประหยัดแบบ 3 ไบต์ในช่องว่างที่ฉันไม่ทราบว่าสามารถลบออกได้

คำตอบเก่า:

การตัดจำนวนเต็มของบันทึกฟังก์ชั่น (i + 1) ทำซ้ำ20 25 ครั้ง (Python) โดยใช้ lambda'd lambdas

คำตอบของ 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()))))))

ใช้ 99 100 ตัวอักษร

นี้ผลิตซ้ำของ20 25 กว่าเดิม 12. นอกจากมันจะช่วยประหยัด 2 ตัวอักษรโดยใช้int()แทนfloor()ซึ่งได้รับอนุญาตเพื่อเพิ่มx()สแต็ค หากช่องว่างหลังจากแลมบ์ดาสามารถลบออกได้ (ฉันไม่สามารถตรวจสอบได้ในขณะนี้) y()สามารถเพิ่มช่องว่างที่ 5 ได้ ! ที่เป็นไปได้

หากมีวิธีการข้ามfrom mathการนำเข้าโดยใช้ชื่อที่ผ่านการรับรอง (เช่น. x=lambda i: math.log(i+1))) นั่นจะช่วยประหยัดอักขระได้มากขึ้นและอนุญาตให้ใช้สแต็กอื่นx()แต่ฉันไม่รู้ว่า Python สนับสนุนสิ่งเหล่านี้หรือไม่ (ฉันสงสัยว่าไม่ได้) ทำ!

นี่เป็นกลอุบายแบบเดียวกับที่ใช้ในการโพสต์บล็อกของ XCKD เป็นจำนวนมากอย่างไรก็ตามค่าใช้จ่ายในการประกาศ lambdas จะแยกออกจากสแต็กที่สาม:

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 lambdas ที่เกินความสูงของสแต็กที่คำนวณเป็น 2 lambdas (การลด lambda ใด ๆ ไปยังสองการโทรจะทำให้ความสูงของสแต็คลดลงเหลือ 18 ซึ่งต่ำกว่ารุ่น 2 แลมบ์ดา

Haskell , 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เป็นรุ่นลูกนอกคอกของ Knuth's notation ที่เติบโตเร็วขึ้นเล็กน้อย (เล็กน้อยเป็นการพูดน้อย แต่ตัวเลขที่เรากำลังติดต่ออยู่นั้นมีขนาดใหญ่มาก เรากำหนดกรณีฐานของf 0 a bที่จะเป็นa^bหรือเพื่ออำนาจของa bจากนั้นเราจะกำหนดกรณีทั่วไปที่จะ(f$c-1)นำไปใช้กับกรณีของb+2 aหากเรากำหนดสัญกรณ์ Knuth uparrow อย่างเช่น construct เราจะใช้มันกับ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 9f 9 9 9 9↑↑↑↑↑↑↑↑↑99↑↑↑↑↑↑↑↑↑99↑↑↑↑↑↑↑↑↑↑9 (สิบลูกศร) ตอนนี้เป็นจำนวนมากอย่างไม่น่าเชื่อไกลไปใหญ่ที่จะเก็บไว้ในคอมพิวเตอร์เครื่องใดก็ได้ที่มีอยู่ (ในรูปแบบเลขฐานสอง) จากนั้นเราก็นำสิ่งนั้นมาวางไว้ในฐานะที่เป็นข้อโต้แย้งแรกของเราfนั่นหมายความว่าคุณค่าของเรานั้นใหญ่กว่า9↑↑↑↑↑↑...↑↑↑↑↑↑9ด้วยf 9 9 9

แต่ละอันlength.showมีค่าประมาณเท่ากับการบันทึกฐาน 10 ของจำนวนเต็ม ซึ่งหมายความว่าตัวเลขส่วนใหญ่จะคืนค่า 1 เมื่อfใช้กับพวกเขา จำนวนที่น้อยที่สุดที่จะคืนสิ่งอื่นที่ไม่ใช่ 1 คือ10↑↑(f(f 9 9 9)9 9)ซึ่งคืนค่า 2 ให้คิดดูสักครู่ จำนวนที่น้อยที่สุดที่เรากำหนดไว้ก่อนหน้านี้คือจำนวนที่น้อยที่สุดที่ส่งกลับ 2 คือ 10 ให้แก่กำลังของตัวเองหลาย ๆ ครั้ง 10↑(f(f 9 9 9)9 9)นั่นคือ 1 ตามด้วยศูนย์

สำหรับกรณีทั่วไปของnการป้อนข้อมูลที่เล็กที่สุด outputting n (10↑(n-1))↑↑(f(f 9 9 9)9 9)ใดก็ตามจะต้องเป็น

โปรดทราบว่าโปรแกรมนี้ต้องใช้เวลาและหน่วยความจำจำนวนมากสำหรับแม้แต่ n น้อย (มากกว่าในเอกภพหลายเท่า) หากคุณต้องการทดสอบสิ่งนี้ฉันขอแนะนำให้แทนที่f(f 9 9 9)9 9ด้วยจำนวนที่น้อยกว่าลอง 1 หรือ 2 ถ้าคุณต้องการ เคยได้รับผลลัพธ์ใด ๆ นอกเหนือจาก 1

APL, Apply log(n + 1), e^9^9...^9times โดยที่ความยาวของ chain เป็นe^9^9...^9ความยาวของ chain ลบ 1 ครั้งและอื่น ๆ

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

MATL , 42 ไบต์

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

ลองออนไลน์!

โปรแกรมนี้ใช้ซีรีส์ฮาร์มอนิกโดยใช้ค่าคงที่ออยเลอร์ - มาเชอร์โรนี่ ขณะที่ฉันอ่านเอกสาร @LuisMendo เกี่ยวกับภาษา MATL ของเขา (ด้วยตัวพิมพ์ใหญ่ดังนั้นมันจึงสำคัญ) ฉันสังเกตเห็นค่าคงที่นี้ การแสดงออกของฟังก์ชั่นการเจริญเติบโตช้ามีดังนี้:

โดยที่ εk ~ 1 / 2k

ฉันทดสอบซ้ำมากถึง 10,000 ครั้ง (ใน 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 + γ + εkเป็นสีน้ำเงินเสมอ

มีการสร้างโปรแกรมสำหรับ (ln k ) + 1

Matlab, 47 18 14 ไบต์

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

ที่น่าสนใจที่จะทราบว่าเวลาที่ผ่านไปสำหรับ n = 100 คือ 0.208693s บนแล็ปท็อปของฉัน แต่เพียง 0.121945 วินาทีด้วยd=rand(1,n);A=d*0;และแม้แต่น้อย 0.112147 ด้วยA=zeros(1,n)กับ ถ้าเลขศูนย์เสียพื้นที่จะช่วยประหยัดความเร็ว! แต่ฉันแยกจากหัวข้อ (อาจช้ามาก)

แก้ไข: ขอบคุณ Stewie ที่ช่วยลดการแสดงออก Matlab นี้เพียง:

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

Python 3 , 100 ไบต์

พื้นของบันทึกการทำงาน (i + 1) ซ้ำแล้วซ้ำอีก 9999999999999999999999999999999999999 ครั้ง

หนึ่งสามารถใช้เลขชี้กำลังเพื่อทำให้จำนวนดังกล่าวมากขึ้น ...

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

ลองออนไลน์!

พื้นของบันทึกการทำงาน (i + 1) ซ้ำ 14 ครั้ง (Python)

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 ^ n ^ n ^ n -> ~ n (ประมาณ n)

ทับทิม 100 ไบต์คะแนน^-1 = f _{โอห์ม^{โอห์ม + 1}} (n ² )

โดยทั่วไปยืมมาจากจำนวนที่ใหญ่ที่สุดที่พิมพ์ได้นี่คือโปรแกรมของฉัน:

->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 _{ωω ^{+ 1}} (n ² ) ในลำดับชั้นที่เพิ่มขึ้นอย่างรวดเร็ว ค่าแรก ๆ คือ

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

และจากนั้นมันจะยังคงส่งออก2เป็นเวลานานมาก แม้แต่เบอร์ของเกรแฮมอยู่x[G] = 2ที่ไหนG

Mathematica, 99 ไบต์

(สมมติว่า±ใช้เวลา 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±yAckermann(y, x)ในการประเมิน

ผลลัพธ์ของฟังก์ชันคือจำนวนครั้งที่f(#)=#±#±#±#±#±#±#±#ต้องใช้กับ 1 ก่อนที่ค่าจะไปถึงค่าของพารามิเตอร์ ในฐานะที่เป็นf(#)=#±#±#±#±#±#±#±#(นั่นคือf(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) เติบโตเร็วมากฟังก์ชั่นเติบโตช้ามาก

Clojure, 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

ฉันสมมติว่าชุดที่ดัดแปลงนี้ยังคงมีความแตกต่าง แต่ตอนนี้รู้วิธีการพิสูจน์แล้ว

ซีรีส์ที่สามต้องใช้จำนวนคำของ googolplex ก่อนที่เทอมบางส่วนจะเกิน 10

Javascript (ES6), 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)

คำอธิบาย :

Id อ้างถึง x => 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)จะประมาณเท่ากับ

ฟังก์ชัน Ackermann แบบผกผัน 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)เราทำสิ่งนี้อีกหนึ่งระดับเพื่อให้ได้ทางออกสุดท้าย