Напишіть найкоротшу можливу програму (довжина вимірюється в байтах), що відповідає таким вимогам:

• немає вводу
• вихід - до stdout
• виконання з часом припиняється
• загальна кількість вихідних байтів перевищує число Грема

Припустимо, що програми працюють до "нормального" завершення на ідеальному комп'ютері ^{1, який} має доступ до необмежених ресурсів, і що загальні мови програмування змінюються при необхідності (без зміни синтаксису), щоб це допустити. Через ці припущення ми можемо назвати це своєрідним експериментом Геданке.

Щоб почати все, ось 73-байтна програма Ruby, яка обчислює f _{ω + 1} (99) у швидко зростаючій ієрархії :

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: Точніше, припустимо, ми приймаємо існуючу систему та модифікуємо її лише для того, щоб не було верхньої межі розміру пам’яті (але вона завжди обмежена). Час виконання інструкцій не повинен змінюватися, але припускається, що машина є ідеальною, оскільки у неї не буде верхньої межі терміну експлуатації.

GolfScript ( 49 47 символів)

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

Докладніше про життя черв'яка див . Коротше кажучи, це друкує число, що перевищує f _{ω ^ω} (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

Як це працює: %просто приймає функцію і складає її n-1на вершині s; тобто %3приймає функцію fі повертає функцію, nщо дорівнює її застосуванню fдо 3, n-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 3це те 3 ↑ⁿ 3, що відображається в обчисленні до числа Грема. Залишилося лише скласти функцію(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))3більше 64 разів, зверху 4 (кількість стрілок, з якої починається обчислення), щоб отримати число, що перевищує число Грема. Очевидно, що логарифм (що таке кульгаво повільна функція!) Все- g₆₅таки більший g₆₄=G, тому якщо ми друкуємо це число, довжина виходу перевищує G.

⬛

Pyth , 29 28 байт

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

Визначає лямбда для гіпер-операції і рекурсивно називає її. Як і визначення числа Грема, але з більшими значеннями.

Це:

M?*GHgtGtgGtH^3hH

Визначає лямбда, приблизно рівну пітону

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

Це дає функцію гіпер-операції, g (G, H) = 3 ↑ ^{G + 1} (H + 1).
Так, наприклад, g (1,2) = 3 ↑ ² 3 = 7,625,597,484,987, які ви можете перевірити тут .

V<x><y>починає цикл , який виконує тіло, y, xраз.
=gZT- це тіло петлі, яке рівносильноZ=g(Z,10)

Кодекс:

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

Якщо рекурсивно слід зателефонувати на гіперпроцедур вище 64 разів, вказавши номер Грема.

У своїй відповіді, однак, я замінив однозначні цифри на T, які ініціалізуються на 10, і збільшив глибину рекурсії до 99. Використовуючи позначення масиву Грема, число Грем є [3,3,4,64], і мій програма виводить більші [10,11,11,99]. Я також видалив те, )що закриває цикл, щоб зберегти один байт, тому він друкує кожне наступне значення в 99 ітераціях.

Python (111 + n), n = довжина (x)

Хоча ця програма не така коротка, як програма Ruby відповіді, я все одно опублікую її, щоб виключити цю можливість.

Він використовує функцію Ackermann і викликає функцію Ackermann, при цьому m і n є значеннями з іншого виклику до функції Ackermann, і повторюється 1000 разів.

Це, мабуть, більше, ніж число Грема, але я не впевнений, тому що ніхто не знає точної довжини. Його можна легко розширити, якщо він не більший.

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

Рубі, 54 52 50 байт

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

Рубі, 85 81 76 71 68 64 63 59 57 байт

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

Рубін, 61 байт

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]

В основному функція Ackermann з поворотом.

Рубі, 63 59 байт

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

Ще один Рубін, 74 71 байт

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

В основному, Акерманн функціонує на собі 99 разів.

Пітон: 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

Що, можливо, можна скоротити до 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)

Де X є відповідне велике число, таке, що результуюча гіперпереробка на 3, 3це більше, ніж число Гремса (якщо це число менше, ніж 99999999999деякий байт зберігається).

Примітка. Я припускаю, що код python виконується на інтерактивному інтерпретаторі, тому результат друкується до stdout, інакше додайте 9байти до кожного рішення для виклику print.

Javascript, 83 байти

Ще одне рішення функції 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 байт, однак не конкурентоспроможний для використання 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 функція схожа на позначення стрілки вгору з базою 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

bфункція: b (x) = b ^x (9).

b(99)є ~ f _{ω + 1} (99), порівняно з числом Грема <f _{ω + 1} (64).