Viết chương trình ngắn nhất có thể (độ dài tính bằng byte) thỏa mãn các yêu cầu sau:

• không có đầu vào
• đầu ra là thiết bị xuất chuẩn
• thực hiện cuối cùng chấm dứt
• tổng số byte đầu ra vượt quá số của Graham

Giả sử rằng các chương trình chạy cho đến khi chấm dứt "bình thường" trên máy tính lý tưởng ¹ có thể truy cập tài nguyên không giới hạn và các ngôn ngữ lập trình phổ biến được sửa đổi nếu cần (không thay đổi cú pháp) để cho phép điều này. Do những giả định này, chúng tôi có thể gọi đây là một loại Gedankenexperiment.

Để bắt đầu, đây là chương trình Ruby 73 byte tính toán f _{ω + 1} (99) trong hệ thống phân cấp đang phát triển nhanh :

f=proc{|k,n|k>0?n.times{n=f[k-1,n]}:n+=1;n};n=99;n.times{n=f[n,n]};puts n

¹ EDIT: Chính xác hơn, giả sử chúng ta đang sử dụng một hệ thống hiện có và chỉ sửa đổi nó để không có giới hạn trên về kích thước lưu trữ (nhưng nó luôn luôn hữu hạn). Thời gian thực hiện của các hướng dẫn không được phép sửa đổi, nhưng máy được coi là lý tưởng ở chỗ nó sẽ không có giới hạn trên trong vòng đời hoạt động của nó.

GolfScript ( 49 47 ký tự)

4.,{\):i\.0={.0+.({<}+??\((\+.@<i*\+}{(;}if.}do

Xem Trọn đời của một con sâu để biết nhiều lời giải thích. Nói tóm lại, đây in một lớn hơn số hơn e _{w ^w} (2).

Haskell, _{59 57 55} 63

(f%s)1=s;(f%s)n=f.(f%s)$n-1
main=print$((flip((%3)%(3^))3)%4)66

Làm thế nào nó hoạt động: %chỉ đơn giản là có một chức năng và tổng hợp n-1thời gian trên đầu trang s; tức là %3lấy một hàm fvà trả về một hàm nbằng với việc áp dụng nó fcho 3, số n-1lần liên tiếp. Nếu chúng ta lặp lại ứng dụng của hàm bậc cao hơn này, chúng ta sẽ có được một chuỗi các hàm tăng trưởng nhanh - bắt đầu bằng phép lũy thừa, đó chính xác là chuỗi các kích cỡ rừng mũi tên Knuth:
((%3)%(3^))1 n = (3^)n     = 3ⁿ = 3↑n
((%3)%(3^))2 n = ((3^)%3)n = (3↑)ⁿ⁻¹ $ 3 = 3↑↑n
((%3)%(3^))3 n = (((3^)%3)%3)n = (3↑↑)ⁿ⁻¹ $ 3  = 3↑↑↑n
v.v. ((%3)%(3^))n 3là 3 ↑ⁿ 3, đó là những gì xuất hiện trong tính toán cho số của Graham. Tất cả những gì còn lại phải làm là soạn thảo hàm(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))3hơn 64 lần, trên đầu 4 (số mũi tên mà phép tính bắt đầu bằng), để có được số lớn hơn số của Graham. Rõ ràng là logarit (chức năng cực kỳ chậm!) g₆₅Vẫn lớn hơn g₆₄=G, vì vậy nếu chúng ta in số đó thì chiều dài đầu ra vượt quá G.

⬛

Bình thường , 29 28 byte

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

Xác định lambda cho siêu hoạt động và gọi đệ quy nó. Giống như định nghĩa cho số của Graham, nhưng với các giá trị lớn hơn.

Điều này:

M?*GHgtGtgGtH^3hH

Xác định một lambda, gần bằng với con trăn

g = lambda G, H:
  g(G-1, g(G, H-1)-1) if G*H else 3^(H+1)

Điều này cho hàm siêu hoạt động, g (G, H) = 3 ^{G + 1} (H + 1).
Vì vậy, ví dụ, g (1,2) = 3 ↑ ² 3 = 7.625.597.484.987, mà bạn có thể kiểm tra ở đây .

V<x><y>bắt đầu một vòng lặp thực thi cơ thể y, xlần.
=gZTlà phần thân của vòng lặp ở đây, tương đương vớiZ=g(Z,10)

Mật mã:

M?*GHgtGtgGtH^3hH=Z3V64=gZ2)Z

Nên gọi đệ quy siêu phẫu thuật trên 64 lần, cho Số của Graham.

Tuy nhiên, trong câu trả lời của tôi, tôi đã thay thế các chữ số đơn bằng T, được khởi tạo thành 10 và tăng độ sâu đệ quy lên 99. Sử dụng Ký hiệu mảng Graham, Số của Graham là [3,3,4,64] và của tôi chương trình đầu ra lớn hơn [10,11,11,99]. Tôi cũng đã loại bỏ việc )đóng vòng lặp để lưu một byte, do đó, nó sẽ in từng giá trị liên tiếp trong 99 lần lặp.

Con trăn (111 + n), n = chiều dài (x)

Mặc dù chương trình này không ngắn như chương trình Ruby của người trả lời, dù sao tôi cũng sẽ đăng nó để loại trừ khả năng này.

Nó sử dụng hàm Ackermann và gọi hàm Ackermann với m và n là các giá trị từ một lệnh gọi khác đến hàm Ackermann và đệ quy 1000 lần.

Con số này có thể lớn hơn số của Graham, nhưng tôi không chắc lắm, vì không ai biết độ dài chính xác của nó. Nó có thể dễ dàng mở rộng, nếu nó không lớn hơn.

x=999
b='A('*x+'5,5'+')'*x
def A(m,n):n+1 if m==0 else A(m-1,A(m,n-1)if n>0 else 1)
exec('print A('%s,%s')'%(b,b))

Ruby, 54 52 50 byte

f=->b{a*=a;eval"f[b-1];"*b*a};eval"f[a];"*a=99;p a

Ruby, 85 81 76 71 68 64 63 59 57 byte

f=->a,b=-a{eval"a*=b<0?f[a,a]:b<1?a:f[a,b-1];"*a};p f[99]

Hệ thống phân cấp phát triển khá nhanh với f (a + 1)> f _{ω + 1} (a).

Ruby, 61 byte

f=->a,b=-a{a<0?9:b==0?a*a:f[f[a-1,b],b>0?b-1:f[a,b+1]]};f[99]

Về cơ bản là một chức năng Ackermann với một twist.

Ruby, 63 59 byte

n=99;(H=->a{b,*c=a;n.times{b ?H[[b-1]*n*b+c]:n+=n}})[n];p n

Một Ruby khác, 74 71 byte

def f(a,b=a)a<0?b:b<0?f(a-1):f(a-1,f(a,b-1))end;n=99;n.times{n=f n};p n

Về cơ bản Ackermann có chức năng 99 lần.

Con trăn: 85

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*99
exec'f('*64+'3'+',3)'*64

Mà có thể rút ngắn xuống còn 74 +length(X) :

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*int('9'*X)
f(3,3)

Trường hợp Xlà một số lớn thích hợp sao cho siêu tăng kết quả trên 3, 3lớn hơn số Grahams (nếu số này nhỏ hơn 99999999999thì một số byte được lưu).

Lưu ý: Tôi giả sử mã python được thực thi trên trình thông dịch tương tác do đó kết quả được in ra thiết bị xuất chuẩn, nếu không thì thêm 9byte vào mỗi giải pháp cho lệnh gọi print.

Javascript, 83 byte

Một giải pháp chức năng Ackermann.

(function a(m,n,x){return x?a(a(m,n,x-1),n,0):(m?a(m-1,n?a(m,n-1):1):n+1)})(9,9,99)

JavaScript, 68 byte, tuy nhiên không thể nén để sử dụng ES6

a=(x,y)=>y?x?a(a(x-1,y)*9,y-1):a(9,y-1):x;b=x=>x?a(9,b(x-1)):9;b(99)

a chức năng tương tự như ký hiệu mũi tên lên với cơ sở 9.

       /a(a(x-1,y)*9,y-1)  x>0, y>0
a(x,y)=|a(9,y-1)           x=0, y>0
       \x                  y=0

bhàm là: b (x) = b ^x (9).

b(99)là ~ f _{ω + 1} (99), so với số của Graham <f _{ω + 1} (64).