Công việc của bạn là tạo ra hàm phát triển chậm nhất mà bạn có thể có không quá 100 byte.

Chương trình của bạn sẽ lấy đầu vào là một số nguyên không âm và xuất ra một số nguyên không âm. Hãy gọi chương trình của bạn P.

Nó phải đáp ứng hai tiêu chí sau:

• Mã nguồn của nó phải nhỏ hơn hoặc bằng 100 byte.
• Với mỗi K, có một N, sao cho với mọi n> = N, P (n)> K. Nói cách khác, lim _{(n-> ∞)} P (n) = . (Đây là ý nghĩa của việc nó đang "phát triển".)

"Điểm số" của bạn là tốc độ tăng trưởng của chức năng cơ bản của chương trình.

Cụ thể hơn, chương trình P phát triển chậm hơn Q nếu có N sao cho tất cả n> = N, P (n) <= Q (n) và có ít nhất một n> = N sao cho P (n ) <Q (n). Nếu không chương trình nào tốt hơn chương trình kia, chúng sẽ bị ràng buộc. (Về cơ bản, chương trình nào chậm hơn dựa trên giá trị của lim _(n->) P (n) -Q (n).)

Hàm tăng trưởng chậm nhất được định nghĩa là hàm tăng chậm hơn bất kỳ hàm nào khác, theo định nghĩa trong đoạn trước.

Đây là tốc độ tăng trưởng-golf , vì vậy chương trình tăng trưởng chậm nhất sẽ thắng!

Ghi chú:

• Để hỗ trợ cho việc ghi điểm, hãy thử đặt chức năng mà chương trình của bạn tính toán trong câu trả lời.
• Cũng đặt một số đầu vào (lý thuyết) và đầu ra, để giúp cung cấp cho mọi người ý tưởng về việc bạn có thể đi chậm như thế nào.

Haskell, 98 byte, score = f _{ε 0} ^-1 ( 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

Làm thế nào nó hoạt động

Điều này tính toán nghịch đảo của một chức năng phát triển rất nhanh liên quan đến trò chơi con sâu của Beklemishev . Tốc độ tăng trưởng của nó tương đương với f _{ε 0} , trong đó f _α là hệ thống phân cấp tăng trưởng nhanh và ε ₀ là số epsilon đầu tiên .

Để so sánh với các câu trả lời khác, lưu ý rằng

• lũy thừa có thể so sánh với f ₂ ;
• lũy thừa lặp ( tetration hoặc ↑↑ ) tương đương với f ₃ ;
• ↑↑ ⋯ với m mũi tên có thể so sánh với f _{m + 1} ;
• Hàm Ackermann có thể so sánh với f _ω ;
• lặp đi lặp lại của hàm Ackermann (các cấu trúc như số của Graham ) vẫn bị chi phối bởi f _{ω + 1} ;
• và ε ₀ là giới hạn của tất cả các tháp ^{ω ω ⋰ ω} .

Brachylog , 100 byte

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Hãy thử trực tuyến!

Đây có lẽ là nơi gần với sự chậm chạp của một số câu trả lời lạ mắt khác, nhưng tôi không thể tin rằng không ai đã thử cách tiếp cận đơn giản và đẹp đẽ này.

Đơn giản, chúng tôi tính độ dài của số đầu vào, sau đó là độ dài của kết quả này, sau đó là độ dài của kết quả khác này ... tổng cộng 100 lần.

Điều này phát triển nhanh như log (log (log ... log (x), với 100 log-10 cơ sở.

Nếu bạn nhập số của mình dưới dạng chuỗi , chuỗi này sẽ chạy cực nhanh trên bất kỳ đầu vào nào bạn có thể thử, nhưng đừng hy vọng sẽ thấy kết quả cao hơn 1: D

JavaScript (ES6), Hàm Ackermann nghịch đảo *, 97 byte

* nếu tôi làm đúng

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}

Chức năng Alà chức năng Ackermann . Chức năng ađược cho là chức năng Inverse Ackermann . Nếu tôi thực hiện nó một cách chính xác, Wikipedia nói rằng nó sẽ không đạt được 5cho đến khi mbằng 2^2^2^2^16. Tôi nhận được một StackOverflowxung quanh 1000.

Sử dụng:

console.log(a(1000))

Giải thích:

Chức năng 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))

Hàm Ackermann nghịch đảo

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

Ác ma thuần khiết: 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

Câu lệnh bên trong eval tạo ra một chuỗi có độ dài 7 * 10 ^{10 10 10 10 10 8.57} , bao gồm không có gì ngoài nhiều lệnh gọi đến hàm lambda, mỗi chuỗi sẽ tạo ra một chuỗi có độ dài tương tự , bật và tắt cho đến khi cuối cùng ytrở thành 0. Rõ ràng điều này có độ phức tạp tương tự như phương pháp Eschew bên dưới, nhưng thay vì dựa vào logic điều khiển if và và, nó chỉ đập các chuỗi khổng lồ lại với nhau (và kết quả thực là có nhiều ngăn xếp hơn ... có lẽ?).

yGiá trị lớn nhất tôi có thể cung cấp và tính toán mà không cần Python ném lỗi là 2, điều này đã đủ để giảm đầu vào của max-float khi trả về 1.

Một chuỗi có độ dài 7.625.597.484.987 là quá lớn : OverflowError: cannot fit 'long' into an index-sized integer.

Toi nên dừng lại.

Eschew Math.log: Đi đến gốc ( 10- ) (của vấn đề), Điểm: chức năng không thể phân biệt hiệu quả với y = 1.

Nhập thư viện toán học là hạn chế số byte. Hãy loại bỏ điều đó và thay thế log(x)hàm bằng một cái gì đó tương đương: x**.1và có giá xấp xỉ cùng một số ký tự, nhưng không yêu cầu nhập. Cả hai hàm đều có đầu ra tuyến tính liên quan đến đầu vào, nhưng x ^0,1 thậm chí còn phát triển chậm hơn . Tuy nhiên, chúng tôi không quan tâm nhiều, chúng tôi chỉ quan tâm rằng nó có cùng một kiểu tăng trưởng cơ sở đối với số lượng lớn trong khi tiêu thụ một số lượng ký tự tương đương (ví dụ: x**.9có cùng số lượng ký tự, nhưng tăng nhanh hơn, do đó là một số giá trị sẽ thể hiện sự tăng trưởng chính xác như nhau).

Bây giờ, phải làm gì với 16 ký tự. Làm thế nào về việc ... mở rộng chức năng lambda của chúng ta để có các thuộc tính Chuỗi Ackermann? Câu trả lời này cho số lượng lớn lấy cảm hứng từ giải pháp này.

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

Các z**zphần ở đây ngăn cản tôi chạy chức năng này với bất cứ nơi nào gần tới đầu vào sane cho yvà z, các giá trị lớn nhất mà tôi sử dụng có thể là 9 và 3 mà tôi lấy lại giá trị là 1.0, ngay cả đối với phao Python hỗ trợ lớn nhất (lưu ý: trong khi 1.0 là số lớn hơn 6,77538853089e-05, các mức đệ quy tăng di chuyển đầu ra của hàm này gần hơn 1, trong khi vẫn lớn hơn 1, trong khi hàm trước đó di chuyển các giá trị gần hơn 0 trong khi vẫn lớn hơn 0, do đó vừa phải đệ quy trên hàm này dẫn đến nhiều hoạt động đến mức số dấu phẩy động mất tất cả các bit đáng kể).

Định cấu hình lại cuộc gọi lambda ban đầu để có các giá trị đệ quy là 0 và 2 ...

>>>1.7976931348623157e+308
1.0000000071

Nếu so sánh được thực hiện để "bù từ 0" thay vì "bù từ 1" thì hàm này trả về 7.1e-9, chắc chắn là nhỏ hơn 6.7e-05.

Đệ quy cơ sở của chương trình thực tế (giá trị z) là 10 ^{10 10 10 1,97} cấp độ sâu, ngay khi y cạn kiệt, nó được đặt lại với 10 ^{10 10 10 10 1.97} (đó là lý do tại sao giá trị ban đầu là 9 là đủ), vì vậy tôi không Thậm chí còn biết cách tính toán chính xác tổng số lần thu hồi xảy ra: Tôi đã đạt đến cuối kiến ​​thức toán học của mình. Tương tự như vậy, tôi không biết nếu di chuyển một trong các **nsố mũ từ đầu vào ban đầu sang thứ cấp z**zsẽ cải thiện số lần thu hồi hay không (ngược lại).

Cho phép đi chậm hơn với đệ quy thậm chí nhiều hơn

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 - tiết kiệm hơn 2 byte int(n)
• import math, math.tiết kiệm hơn 1 bytefrom math import*
• a(...) tiết kiệm tổng cộng 8 byte m(m,...)
• (y>0)*x tiết kiệm một byte trêny>0and x
• 9**9**99tăng byte count bởi 4 và tăng độ sâu đệ quy bằng xấp xỉ 2.8 * 10^xnơi xlà chiều sâu cũ (hoặc độ sâu gần một GOOGOLPLEX trong kích thước: 10 ^{10 94} ).
• 9**9**9e9tăng số byte lên 5 và tăng độ sâu đệ quy bằng ... một lượng điên. Độ sâu đệ quy hiện là 10 ^{10 10 9,93} , để tham khảo, một googolplex là 10 ^{10 10 2} .
• khai lambda tăng đệ quy bằng cách thêm một bước: m(m(...))để a(a(a(...)))chi phí 7 byte

Giá trị đầu ra mới (ở độ sâu đệ quy 9):

>>>1.7976931348623157e+308
6.77538853089e-05

Độ sâu đệ quy đã bùng nổ đến điểm mà tại đó kết quả này là theo nghĩa đen vô nghĩa trừ khi so sánh với các kết quả trước đó bằng cách sử dụng các giá trị đầu vào tương tự:

• Bản gốc được gọi log25 lần
• Sự cải tiến đầu tiên gọi nó là 81 lần
  • Các thực tế chương trình sẽ gọi nó là 1e99 ² tương đương khoảng 10 ^{10 2.3} lần
• Phiên bản này gọi nó là 729 lần
  • Các thực tế chương trình sẽ gọi nó là (9 ^{9 99} ) ³ hoặc hơi ít hơn 10 ^{10 95} lần).

Lambda Khởi động, điểm số: ???

Tôi nghe nói bạn thích lambdas, vì vậy ...

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

Tôi thậm chí không thể chạy cái này, tôi xếp chồng lên nhau thậm chí chỉ với 99 lớp đệ quy.

Phương thức cũ (bên dưới) trả về (bỏ qua chuyển đổi thành số nguyên):

>>>1.7976931348623157e+308
0.0909072713593

Phương thức mới trả về, chỉ sử dụng 9 lớp xâm nhập (chứ không phải toàn bộ googol của chúng):

>>>1.7976931348623157e+308
0.00196323936205

Tôi nghĩ rằng điều này hoạt động có độ phức tạp tương tự như chuỗi Ackerman, chỉ nhỏ thay vì lớn.

Ngoài ra, nhờ vào ETHproductions để tiết kiệm 3 byte trong không gian mà tôi không nhận ra có thể bị xóa.

Câu trả lời cũ:

Việc cắt số nguyên của nhật ký hàm (i + 1) được lặp lại 20 25 lần (Python) bằng lambda'd lambdas.

Câu trả lời của PyRulez có thể được nén bằng cách giới thiệu lambda thứ hai và xếp chồng nó:

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 ký tự được sử dụng.

Điều này tạo ra số lần lặp là 20 25, so với bản gốc 12. Ngoài ra, nó lưu 2 ký tự bằng cách sử dụng int()thay vì floor()cho phép một x()ngăn xếp bổ sung . Nếu khoảng trắng sau lambda có thể được loại bỏ (tôi không thể kiểm tra tại thời điểm này) thì y()có thể thêm lần thứ 5 . Khả thi!

Nếu có một cách để bỏ qua việc from mathnhập bằng cách sử dụng một tên đủ điều kiện (ví dụ x=lambda i: math.log(i+1)):), điều đó sẽ lưu nhiều ký tự hơn và cho phép một ngăn xếp khác x()nhưng tôi không biết liệu Python có hỗ trợ những thứ đó không (tôi nghi ngờ là không). Làm xong!

Đây thực chất là một mẹo tương tự được sử dụng trong bài đăng trên blog của XCKD với số lượng lớn , tuy nhiên, chi phí khai báo lambdas ngăn chặn ngăn xếp thứ ba:

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

Đây là lần đệ quy nhỏ nhất có thể với 3 lambdas vượt quá chiều cao ngăn xếp được tính toán của 2 lambdas (giảm bất kỳ lambda nào xuống hai cuộc gọi giảm chiều cao ngăn xếp xuống còn 18, thấp hơn so với phiên bản 2-lambda), nhưng không may cần 110 ký tự.

Haskell , 100 byte

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

Hãy thử trực tuyến!

Giải pháp này không có nghịch đảo của một hàm tăng trưởng nhanh, thay vào đó, nó có một hàm phát triển khá chậm, trong trường hợp này length.show, và áp dụng nó rất nhiều lần.

Đầu tiên chúng ta định nghĩa một hàm f. flà một phiên bản khốn của ký hiệu uparrow của Knuth phát triển nhanh hơn một chút (hơi là một chút thiếu, nhưng con số chúng ta đang giải quyết rất lớn đến mức trong sơ đồ lớn của mọi thứ ...). Chúng tôi xác định trường hợp cơ bản f 0 a blà a^bhoặc asức mạnh của b. Sau đó, chúng tôi xác định trường hợp chung sẽ được (f$c-1)áp dụng cho các b+2trường hợp a. Nếu chúng ta định nghĩa một ký hiệu nâng cao Knuth như xây dựng, chúng ta sẽ áp dụng nó cho các btrường hợp a, nhưng b+2thực sự là golfer và có lợi thế là phát triển nhanh hơn.

Sau đó chúng ta xác định toán tử #. a#bđược định nghĩa để length.showáp dụng cho b athời gian. Mỗi ứng dụng length.showgần bằng với log ₁₀ , đây không phải là một chức năng phát triển rất nhanh.

Sau đó, chúng ta đi về việc xác định hàm của chúng ta glấy và số nguyên và áp dụng length.showcho số nguyên một loạt các lần. Để được cụ thể, nó áp dụng length.showcho đầu vào f(f 9 9 9)9 9. Trước khi chúng ta đi vào làm thế nào lớn này là cho phép nhìn vào f 9 9 9. f 9 9 9là lớn hơn 9↑↑↑↑↑↑↑↑↑9 (chín mũi tên), bằng lãi khổng lồ. Tôi tin rằng nó ở đâu đó giữa 9↑↑↑↑↑↑↑↑↑9(chín mũi tên) và 9↑↑↑↑↑↑↑↑↑↑9(mười mũi tên). Bây giờ đây là một số lượng lớn không thể tưởng tượng, từ xa đến lớn sẽ được lưu trữ trên bất kỳ máy tính nào đang tồn tại (theo ký hiệu nhị phân). Sau đó, chúng tôi lấy điều đó và coi đó là đối số đầu tiên của chúng tôi fcó nghĩa là giá trị của chúng tôi lớn hơn so 9↑↑↑↑↑↑...↑↑↑↑↑↑9vớif 9 9 9mũi tên ở giữa. Tôi sẽ không mô tả con số này bởi vì nó quá lớn Tôi không nghĩ rằng tôi sẽ có thể làm điều đó công lý.

Mỗi giá trị length.showxấp xỉ bằng với cơ sở nhật ký 10 của số nguyên. Điều này có nghĩa là hầu hết các số sẽ trả về 1 khi fđược áp dụng cho chúng. Số nhỏ nhất để trả về một cái gì đó không phải là 1 10↑↑(f(f 9 9 9)9 9), trả về 2. Hãy suy nghĩ về điều đó một lát. Lớn đến mức đáng kinh ngạc như con số mà chúng ta đã xác định trước đó là, số nhỏ nhất trả về 2 là 10 với sức mạnh của chính nó nhiều lần. Đó là 1 10↑(f(f 9 9 9)9 9)số không.

Đối với trường hợp chung của nđầu vào nhỏ nhất xuất ra bất kỳ n đã cho phải (10↑(n-1))↑↑(f(f 9 9 9)9 9).

Lưu ý rằng chương trình này đòi hỏi lượng thời gian và bộ nhớ lớn cho cả n nhỏ (nhiều hơn so với trong vũ trụ nhiều lần), nếu bạn muốn kiểm tra điều này, tôi khuyên bạn nên thay thế f(f 9 9 9)9 9bằng một số nhỏ hơn nhiều, hãy thử 1 hoặc 2 nếu bạn muốn bao giờ nhận được bất kỳ đầu ra nào ngoài 1.

APL, Áp dụng log(n + 1), e^9^9...^9thời gian, trong đó độ dài của chuỗi có e^9^9...^9độ dài của chuỗi trừ đi 1 lần, v.v.

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

MATL , 42 byte

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

Hãy thử trực tuyến!

Chương trình này dựa trên loạt điều hòa với việc sử dụng hằng số Euler ăn Mascheroni. Khi tôi đang đọc tài liệu @LuisMendo về ngôn ngữ MATL của anh ấy (với chữ in hoa, vì vậy nó có vẻ quan trọng) tôi nhận thấy hằng số này. Biểu thức chức năng tăng trưởng chậm như sau:

trong đó kk ~ 1 / 2k

Tôi đã thử nghiệm tới 10000 lần lặp (trong Matlab, vì nó quá lớn so với TIO) và nó đạt điểm dưới 10, vì vậy nó rất chậm.

Giải thích:

 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

Bằng chứng thực nghiệm: (ln k ) + 1 màu đỏ luôn ở trên ln k + γ + εk màu xanh lam.

Chương trình cho (ln k ) + 1 đã được thực hiện trong

Matlab, 47 18 14 byte

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

Thật thú vị khi lưu ý rằng thời gian trôi qua cho n = 100 là 0,208693 trên máy tính xách tay của tôi, nhưng chỉ có 0,121945 với d=rand(1,n);A=d*0;và thậm chí ít hơn, 0,12547 với A=zeros(1,n). Nếu số không là một sự lãng phí không gian, nó sẽ tiết kiệm tốc độ! Nhưng tôi đang chuyển hướng từ chủ đề (có lẽ rất chậm).

Chỉnh sửa: cảm ơn Stewie vì đã giúp giảm biểu thức Matlab này, chỉ đơn giản là:

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

Python 3 , 100 byte

Tầng của nhật ký chức năng (i + 1) lặp lại 9999999999999999999999999999999999999 lần.

Người ta có thể sử dụng số mũ để làm cho số trên thậm chí còn lớn hơn ...

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

Hãy thử trực tuyến!

Tầng của nhật ký hàm (i + 1) lặp lại 14 lần (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())))))))))))))))

Tôi không hy vọng điều này sẽ làm rất tốt, nhưng tôi nghĩ rằng đó là một khởi đầu tốt.

Ví dụ:

• e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n -> ~ n (khoảng n)

Ruby, 100 byte, điểm số ^-1 = f _{w ^{w + 1}} (n ² )

Về cơ bản mượn từ Số lớn nhất có thể in của tôi, đây là chương trình của tôi:

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

Dùng thử trực tuyến

Về cơ bản tính toán nghịch đảo của f _{ω ^{+ 1}} (n ² ) trong hệ thống phân cấp phát triển nhanh. Một vài giá trị đầu tiên là

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

Và sau đó nó tiếp tục đầu ra 2trong một thời gian rất dài. Thậm chí x[G] = 2, Gsố của Graham ở đâu.

Toán học, 99 byte

(giả sử ± mất 1 byte)

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 lệnh đầu tiên xác định x±yđể đánh giá Ackermann(y, x).

Kết quả của hàm là số lần f(#)=#±#±#±#±#±#±#±#cần được áp dụng cho 1 trước khi giá trị nhận được giá trị của tham số. Vì f(#)=#±#±#±#±#±#±#±#(nghĩa là f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) phát triển rất nhanh, chức năng phát triển rất chậm.

Clojure, 91 byte

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

Loại tính toán sum 1/(n * log(n) * log(log(n)) * ...), mà tôi tìm thấy từ đây . Nhưng hàm đã kết thúc dài 101 byte nên tôi phải bỏ số lần lặp rõ ràng, và thay vào đó lặp đi lặp lại miễn là số đó lớn hơn một. Ví dụ đầu ra cho đầu vào của 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

Tôi giả sử loạt sửa đổi này vẫn phân kỳ nhưng bây giờ biết làm thế nào để chứng minh nó.

Sê-ri thứ ba thực sự yêu cầu số lượng thuật ngữ googolplex trước khi các điều khoản một phần vượt quá 10.

Javascript (ES6), 94 byte

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

Giải thích :

Idđề cập đến x => xsau đây.

Trước tiên hãy xem:

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

p(Math.log)xấp xỉ bằng log*(x).

p(p(Math.log))xấp xỉ bằng log**(x)(số lần bạn có thể mất log*cho đến khi giá trị tối đa là 1).

p(p(p(Math.log)))xấp xỉ bằng log***(x).

Hàm Ackermann nghịch đảo alpha(x)xấp xỉ bằng số lần tối thiểu bạn cần soạn pcho đến khi giá trị nhiều nhất là 1.

Nếu chúng ta sử dụng:

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

sau đó chúng ta có thể viết alpha = p(Id)(Math.log).

Điều đó khá nhàm chán, tuy nhiên, vì vậy hãy tăng số lượng cấp độ:

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

Điều này giống như cách chúng tôi xây dựng alpha(x), ngoại trừ thay vì làm log**...**(x), bây giờ chúng tôi làm alpha**...**(x).

Tại sao dừng lại ở đây mặc dù?

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

Nếu chức năng trước là f(x)~alpha**...**(x), cái này là bây giờ ~ f**...**(x). Chúng tôi làm thêm một cấp độ này để có được giải pháp cuối cùng.