Дехто з вас, можливо, знайомий з виграшем BigNum , який закінчився досить цікаво. Ціль може бути більш-менш сформульована як написання програми С, випуск якої був би найбільшим за певних обмежень і теоретичних умов, наприклад, комп’ютера, який міг би запускати програму.

У цьому ж дусі я ставлю перед собою подібний виклик, відкритий для всіх мов. Умови такі:

• Максимум 512 байт .

• Кінцевий результат повинен бути надрукований в STDOUT. Це ваш рахунок. Якщо буде надруковано кілька цілих чисел, вони будуть об'єднані.

• Вихід повинен бути цілим числом. (Примітка. Нескінченність не є цілим числом .)

• Немає вбудованих констант більше 10, але цифри / цифри є нормальними (наприклад, константа Авогадро (як вбудована константа) недійсна, але 10000 - ні.)

• Програма повинна припинитись, якщо забезпечено достатню кількість ресурсів для запуску.

• Друкований вихід повинен бути детермінованим, коли забезпечується достатня кількість ресурсів для запуску.

• Вам передбачено достатньо великих цілих чисел або bigints для запуску вашої програми. Наприклад, якщо ваша програма вимагає застосовувати основні операції до чисел, менших від 10 ^{000 000} , то ви можете припустити, що комп'ютер, на якому працює це, може працювати з числами щонайменше до 10 ^{000 000} . (Примітка. Ваша програма може також запускатися на комп'ютері, який обробляє числа до ^10000000 , тому просто виклик максимального цілого числа, з яким може працювати комп'ютер, не призведе до детермінованих результатів.)

• Вам надається достатня обчислювальна потужність для вашої програми, щоб закінчити виконання за 5 секунд. (Тому не хвилюйтеся, якщо ваша програма працює на вашому комп’ютері протягом години і не закінчиться незабаром.)

• Ніяких зовнішніх ресурсів, тому не думайте про імпорт цієї функції Ackermann, якщо вона не є вбудованою.

Усі магічні предмети тимчасово запозичуються у щедрого божества.

Надзвичайно великий з невідомою межею

• Стівен Н , Піт f _{3 + B³F + ω²} (256 ²⁶ )

де B³F - церковно-Клінова ординала з фундаментальною послідовністю

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

Табло:

1. Просто красиве мистецтво , Ruby f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

2. Стівен Н , Піт f _{ψ (Ω ^Ω ) + ω² + 183} (256 ^27! )

3. Leaky Nun , Python 3 f _{ε 0} (9 ^{9 9} )

4. fejfo , Python 3 f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999))

5. Стівен Н , Пітон 3 f _{ω ^ω + ω²} (9 ^{9 9 99} )

6. Просто красиве мистецтво , Ruby f _{ω + 35} (9 ^{9 99} )

7. i .. , Python 2 , f ₃ (f ₃ (141))

Деякі бічні примітки:

Якщо ми не можемо перевірити ваш результат, ми не можемо розмістити його в таблиці лідерів. Тож ви, можливо, захочете трохи роз’яснити свою програму.

Так само, якщо ви не розумієте, наскільки велика ваша кількість, поясніть свою програму, і ми спробуємо її розробити.

Якщо ви використовуєте тип програми навантажувача , я перенесу вас до окремої категорії під назвою "Надзвичайно велика з невідомою межею" , оскільки номер навантажувача не має нетривіальної верхньої межі з точки зору швидко зростаючої ієрархії для " стандартні 'фундаментальні послідовності.

Числа будуть класифіковані за швидко зростаючою ієрархією .

Для тих, хто хотів би навчитися використовувати швидко зростаючу ієрархію для наближення дійсно великих чисел, я розміщую сервер Discord саме для цього. Також є кімната для чатів: звичайність .

Подібні виклики:

Найбільша кількість для друку

Гольф на номер більше TREE (3)

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

Для тих, хто хоче побачити декілька простих програм, які виводять швидко зростаючу ієрархію для малих значень, ось вони:

Ruby: швидко зростаюча ієрархія

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

тощо.

Щоб перейти від f_xдо f_(x+1), додамо одну петлю n.times{...}.

Інакше ми діагоналізуємось проти всіх попередніх, наприклад

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)

тощо.

Ruby, f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

де M - перша «порядкова» Махло, X - функція чі (функція руйнування Махло), а ψ - порядкова функція руйнування.

f=->a,n,b=a,q=n{c,d,e=a;!c ?[q]:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Спробуйте в Інтернеті!

Розбивка коду:

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

Розбивка математики:

fскорочується aна основі n,b,q.

Основна ідея - мати надзвичайно вкладене aі скорочувати його багаторазово, поки воно не зменшиться до a=0. Для простоти, нехай

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

Поки що, давайте лише хвилюватися n.

Для будь-якого цілого числа kми отримуємо f[k,n]=k-1, тому ми можемо це бачити

g[k,n]=n+k

Тоді ми маємо для будь-якого d, f[[0,d],n]=nтак ми можемо бачити , що

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

Тоді ми маємо для будь-якого c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Наприклад,

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

Тоді ми маємо для будь-якого c,d,eтак , щоб він не впав в попередньому випадку, f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. Тут воно починає ускладнюватися. Кілька прикладів:

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

Звідти швидко підскакує. Деякі визначні пам'ятки:

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

Врешті-решт, введення більше аргументів fфункції, а також більше випадків для масиву дозволяє перевершити більшість названих обчислювальних позначень. Деякі особливо відомі:

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function

Pyth, f _{ψ (Ω ^Ω ) + ω ² +183} (~ 256 ^27! )

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

Потрібен будь-який не порожній вхід, але його значення не використовується.

Пояснення (для нової та фактично обґрунтованої версії):

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

Мені дуже важко обчислити розмір цього, в основному тому, що пізно вдень, і я не дуже добре знайомий зі швидко зростаючими ієрархіями або як я навіть намагаюся зрозуміти, скільки разів Q проходить через y()розкручувач. Хоча я тепер знаю більше про порядкові порядки, я все ще не маю уявлення, як обчислити значення порядкового числа, представленого рекурсивним визначенням у моїй програмі. Я б приєднався до сервера Discord, але це під псевдонімом, я краще не буду пов’язаний зі своїм справжнім іменем.

На жаль, оскільки я знаю відносно мало про стрімко зростаючі ієрархії, я, ймовірно, вже втратив відповідь Рубі. Мені важко сказати. Можливо, я побив відповідь Рубі, але я не впевнений на 100%. ¯ \ _ (ツ) _ / ¯

Pyth, f _{3 + σ -1 + ω ²} (256 ²⁶ )

Де σ _m [n] - функція зайнятого Бівера Σ порядку, що mвикликається n: σ _m [n] = Σ _m (n). Порядок -1полягає в тому, щоб вказати, що тут зайнятого бобра не викликають справжню машину Тюрінга, а наближення з кінцевою обгортковою стрічкою Qелементів. Це дозволяє вирішити проблему зупинки для цих програм.

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

TL; DR полягає в тому, що це створює всі можливі програми BrainF ** k довжини Q, запускає їх у середовищі, де максимальне значення цілого числа дорівнює Q, а довжина стрічки - Q, і збирає всі стани з цих операцій разом до додайте (ось це 3+) до Q, повторивши вище сказане на шкалі f _{ω ²} .

У мене ще є ~ половина персонажів, з якими я працюю, якби хотів зробити щось більше, але поки ми не з'ясуємо, де це, я просто залишу це як є.

пітон, f ₃ (f ₃ (141)), 512 байт

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

Це насправді не є вірною відповіддю, але я хотів опублікувати її все одно. Швидкий пробіг:

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

У всякому разі, я не знаю, чи відповідь це технічно законним, але писати було цікаво. Не соромтесь редагувати будь-які помилки, виявлені в коді.

Рубі, ймовірно, ~ f _{ω + 35} (9 ^{9 99} )

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

Спробуйте в Інтернеті!

Приблизне математичне пояснення:

Нижче приблизно дорівнює програмі, наведеній вище, але спрощена, щоб її було легше зрозуміти.

G(0,k) = k є нашою базовою функцією.

Для оцінки G(n,k)ми беремо kі записуємо як G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Потім змініть всі G(x,1)'s на G(x,2)' і відніміть 1з усього результату.

Перепишіть його у вищенаведеній формі, використовуючи G(x,2), де x<n, а залишок залиште в кінці. Повторіть, перейшовши G(x,2)на G(x,3)тощо.

Коли результат досягне -1, поверніть базу (те, bщо було б G(x,b)).

Приклади:

G (1,1):

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

G (1,2):

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

G (1,3):

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

G (2,5):

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

Займаючись математикою, я виявив це

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

А крім цього воно, як правило, трохи волохате.

Загалом, у нас є

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.

Пітон 3, f _{ω ^ω + ω * ω} (9 ^{9 9 99} )

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

Я скоро отримаю пояснення.

Python 3 , ~ f _{ε 0} (9 ^{9 9} )

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

Спробуйте в Інтернеті!

Python 3, 323 байти, g ^9e9 (9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

Спробуйте в Інтернеті!

Пояснення

Python 3 - це справді рекурсивна мова, це означає, що не тільки функція може викликати саму функцію, а функція також може приймати інші функції як функції введення або виведення. Використання функцій для покращення себе - це те, на чому базується моя програма.

f = лямбда x, a: [a (x), e (x) ((x, a)) [1]]

Визначення

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

Визначення пояснено

a(x)=9^x a є базовою функцією, я вибрав цю функцію, оскільки x> 0 => a (x)> x`, яка уникає фіксованих точок.

b(x,f)=a(x), f^xb - загальна поліпшувальна функція, вона бере будь-яку функцію і виводить її кращу версію. b можна навіть застосувати до себе:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

але для повного використання сили bпокращення bвам потрібно взяти вихід b і використовувати його як новий b, це робить c0:

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

більш загальна функція c (n) приймає n останній аргумент (починаючи з 0), так c(1)(…,f,a)=f(…,f,a)і c(2)(…,f,a,b)=f(…,f,a,b). *lозначає, що l є масивом і l[~n]приймає n останній аргумент

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld використовує c0 для оновлення b і b для оновлення всіх інших функцій введення (яких може бути будь-яка кількість через список)
d(x,b,c,d)>9^x,b^x,c^x,d^xіd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

але d стане ще кращим, якщо поєднувати його з c:
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

чим більше c (x) ви додаєте в кінці, тим сильнішим він стає. Перший c0 завжди залишається d: c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
Але другий залишає ітераційні версії позаду:

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

Коли d^xнарешті c4буде розраховано , dнаступного разу візьмемо значно більш ітераційну версію . Коли c4^xнарешті c3буде обчислено, буде взята набагато більш ітератована версія c4, ...
Це створює дійсно потужну версію ітерації, оскільки d:

1. Покращує bвикористанняc0
2. Покращує c0використанняb
3. Покращує всі шари вкладення, використовуючи b Самі поліпшення, покращуючись, це означає, що d стає більш потужним, коли воно більше повторюється.

Створення цього довгого ланцюга c - це те, що e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]робить.
Він використовує c0^xдля обходу, який c0би просто дав d.
Це [1]означає, що він врешті поверне другий вихід d^…. Отже b^….

На даний момент я не міг придумати нічого, що стосується e (x), щоб значно збільшити його вихід, крім збільшення введення.

Таким чином, f(x,a)=a(x),e(a(x))(x,a)[1](x)використовується b^…згенерований шляхом e(x)для виведення кращої базової функції і використовує цю базову функцію для виклику e(x)з більшим входом.

g(x)=e(x)(x,f)[1](x,a)[1](x)використовує остаточне e(x)гніздування fі виробляє дійсно потужну функцію.

Fgh наближення

Мені знадобиться допомога з наближенням цього числа з будь-якими страхами.

Стара версія : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), спробуйте в Інтернеті! Історія редагування пояснення

Ruby, f _{ε 0 2} (5), 271 байт

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

Спробуйте в Інтернеті!

Це ґрунтується на відміну від m (n) карти .

Пояснення:

m[0][f0][k] = f0[f0[...f0[k]...]]з kітераціями f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]з kітераціями f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]з kітераціями f0.

В цілому, m[n]приймають n+2аргументи, перебирає перший аргумент, f0, kраз на другий аргумент, а потім застосовує отриману функцію на третій аргумент (якщо вона існує), потім застосовує отриману функцію на четвертий аргумент (якщо вона існує), тощо.

Приклади

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

В цілому m[0][n↦n+1] = n↦2n.

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

В цілому m[0][m[0][n↦n+1]] = n↦n*2^n.

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

Загалом m[1][m[0]][n↦n+1] = f_ωу швидко зростаючій ієрархії.

g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

і кінцевий вихід є

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]