Некоторые из вас могут быть знакомы с BigNum Bakeoff , который закончился довольно интересно. Цель может быть более или менее резюмирована как написание программы на C, выход которой будет самым большим, при некоторых ограничениях и теоретических условиях, например, на компьютере, который может запустить программу.

В том же духе я ставлю похожую задачу, открытую для всех языков. Условия:

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

• Окончательный результат должен быть напечатан в STDOUT. Это ваш счет. Если напечатано несколько целых чисел, они будут объединены.

• Вывод должен быть целым числом. (Примечание: бесконечность не является целым числом .)

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

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

• Печатная продукция должна быть детерминированной, если для ее запуска достаточно ресурсов.

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

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

• Никаких внешних ресурсов, поэтому не думайте об импорте этой функции Аккермана, если она не встроена.

Все магические предметы временно заимствуются у щедрого божества.

Очень большой с неизвестным пределом

• Стивен Х , Пиф 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

Leaderboard:

1. Просто Красивое Искусство , Рубин 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. фейфо , питон 3 f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999))

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

6. Просто прекрасное искусство , Рубин х _{ω + 35} (9 ^{- 99} )

7. то есть , Python 2 , f ₃ (f ₃ (141))

Некоторые примечания:

Если мы не сможем подтвердить ваш счет, мы не сможем поставить его в таблицу лидеров. Так что вы можете ожидать объяснения вашей программы.

Аналогичным образом, если вы не понимаете, насколько велико ваше число, объясните свою программу, и мы постараемся решить ее.

Если вы используете программу с типом номера Loader , я помещу вас в отдельную категорию, которая называется «Чрезвычайно большой с неизвестным пределом» , поскольку номер Loader не имеет нетривиальной верхней границы в терминах быстро растущей иерархии для ' стандартные фундаментальные последовательности.

Числа будут ранжироваться через быстро растущую иерархию .

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

Похожие проблемы:

Самый большой номер для печати

Гольф число больше, чем TREE (3)

Самая короткая завершающая программа, выходной размер которой превышает число Грэма

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

Рубин: быстрорастущая иерархия

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

и т.п.

Рубин, f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

где М - первый «ординал» Мало, 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

Math Breakdown:

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

Пиф, 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, но это под псевдонимом, я бы не хотел связываться с моим настоящим именем.

К сожалению, поскольку я относительно мало знаю об этих быстрорастущих иерархиях, я, вероятно, уже проиграл ответу Ruby. Мне сложно сказать. Возможно, я победил ответ Ruby, но я не уверен на 100%. ¯ \ _ (ツ) _ / ¯

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

Там , где σ _т [п] Занято бобра функция Σ порядка 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)на 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.

Python 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(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^…сгенерированный by e(x)для вывода лучшей базовой функции и использует эту базовую функцию для вызова e(x)с большим вводом.

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

Fgh приближение

Мне понадобится помощь, чтобы приблизить это число с любым видом ФГГ.

Старая версия : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), попробуйте онлайн! История изменений объяснения

Рубин, 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]