Aşağıdaki gereksinimleri karşılayarak mümkün olan en kısa programı (bayt cinsinden ölçülen uzunluk) yazın:

• giriş yok
• çıktı stdout
• yürütme sonunda sona erer
• toplam çıktı baytı sayısı Graham sayısını aşıyor

Programların sınırsız kaynaklara erişebilen ideal bir bilgisayarda ¹ "normal" sonlandırmaya kadar çalıştığını ve gerektiğinde (programlama sözdizimini değiştirmeden) ortak programlama dillerinin değiştirildiğini varsayalım . Bu varsayımlar nedeniyle, buna bir tür Gedanken deneyi diyebiliriz.

İşleri başlatmak için, hızlı büyüyen hiyerarşideki f _{ω + 1} (99) _değerini hesaplayan 73 baytlık bir Ruby programı :

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: Daha doğrusu, var olan bir sistemi kullandığımızı ve sadece depolama boyutunda üst sınır olmayacak şekilde değiştirdiğimizi varsayalım (ancak her zaman sonludur). Talimatların infaz süreleri vardır değil değiştirilmesi gerekiyordu, ama makine kendi işletim ömrü üzerinde hiçbir üst sınırı olacağı ideal olduğu varsayılır.

GolfScript ( 49 47 karakter)

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

Çok fazla açıklama için bkz . Solucan ömrü . Kısacası, bu f _{ω ^ω} (2) 'den daha büyük bir sayı basar .

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

Nasıl çalışır: %basitçe bir işlev alır ve n-1üstündeki zamanları oluşturur s; yani %3bir işlevi alır fve üst üste 3 kere nuygulayarak ona eşit olan bir işlevi döndürür . Bu üst düzey fonksiyonun uygulanmasını yinelersek, hızlı büyüyen bir fonksiyonlar dizisi elde ederiz - üstelleşmeyle başlayarak, tam olarak Knuth-ok-orman büyüklükleri dizisi: vb. olan Graham'ın numarasına hesaplanmasında görünen olan. Tek yapılması gereken işlevi oluşturmakfn-1
((%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
((%3)%(3^))n 33 ↑ⁿ 3(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))3Graham sayısından daha büyük bir sayı elde etmek için 4'ün üstünde (hesaplamanın başladığı ok sayısı) 64 defadan fazla. Logaritmanın (ne kadar yavaş yavaş bir fonksiyon!) g₆₅Hala daha büyük olduğu açıktır g₆₄=G, bu nedenle eğer bu sayıyı basarsak, çıkış uzunluğu aşılır G.

⬛

Pyth , 29 28 bayt

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

Hiper-işlem için bir lambda tanımlar ve tekrarlı olarak çağırır. Graham'ın sayısının tanımı gibi, ancak daha büyük değerleri olan.

Bu:

M?*GHgtGtgGtH^3hH

Python'a kabaca eşit bir lambda tanımlar.

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

Bu, hiper işlem işlevini verir, g (G, H) = 3 ↑ ^{G + 1} (H + 1).
Yani, örneğin, g (1,2) = 3 3 ² 3 = 7,625,597,484,987, burada test edebilirsiniz .

V<x><y>, gövde yürüten bir döngü başlar y, xkat.
=gZTBurada döngünün gövdesi, eşdeğer olanZ=g(Z,10)

Kod:

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

Tekrar tekrar, Graham'ın Numarasını vererek 64 defadan fazla olan hiperoperasyonu çağırmalıyız.

Ancak cevabımda, T10'a ilklendirilen tek haneleri değiştirdim ve özyineleme derinliğini 99'a yükselttim. Graham Array Notation kullanarak , Graham Numarası: program daha büyük çıktılar [10,11,11,99]. Ayrıca )bir bayttan tasarruf etmek için döngüyü kapayanı kaldırdım , böylece 99 yinelemedeki art arda her değeri yazdırır.

Python (111 + n), n = uzunluk (x)

Bu, cevap verenin Ruby programı kadar kısa olmasa da, bu olasılığı elemek için yine de göndereceğim.

Ackermann işlevini kullanır ve Ackermann işlevini çağırır ve m ve n, başka bir çağrıdan Ackermann işlevine bir değer oluşturur ve 1000 kez tekrarlar.

Bu muhtemelen Graham'ın sayısından daha büyük, ama emin değilim, çünkü hiç kimse bunun tam olarak uzunluğunu bilmiyor. Daha büyük değilse kolayca genişletilebilir.

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 bayt

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 bayt

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

F (a + 1)> f _{ω + 1} (a) ile hemen hemen hızlı büyüyen hiyerarşi .

Ruby, 61 bayt

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]

Temelde bir bükülme ile Ackermann işlevi.

Ruby, 63 59 bayt

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

Başka bir Yakut, 74 71 bayt

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

Temelde Ackermann 99 defa kendi kendine çalışır.

Python: 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

Belki 74 + 'yalength(X) kısaltılabilir :

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

Nerede Xuygun bir büyük sayı bu tür üzerinde çıkan hiperişlem yani 3, 3Graham'lar sayısından daha büyük olan (bu sayı daha az ise 99999999999o zaman bazı bayt kaydedilir).

Not: Python kodunun etkileşimli tercüman üzerinde yürütüldüğünü ve dolayısıyla sonuç stdout'a yazdırıldığını, aksi takdirde 9çağrı için her bir çözüme bayt eklediğini farz ediyorum print.

Javascript, 83 bayt

Başka bir Ackermann fonksiyon çözümü.

(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 bayt, ancak ES6 kullanmak için uncompeting

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 işlev, taban 9 ile yukarı ok gösterme işlevine benzer.

       /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

bfonksiyon şudur: b (x) = b ^x (9).

b(99)~ f _{ω + 1} (99), Graham sayısının <f _{ω + 1} (64) ile karşılaştırılmasıdır.