Ваша задача - создать самую медленную растущую функцию из не более 100 байтов.

Ваша программа будет принимать в качестве входных данных неотрицательное целое число и выводить неотрицательное целое число. Давайте назовем вашу программу P.

Он должен соответствовать этим двум критериям:

• Его исходный код должен быть меньше или равен 100 байтам.
• Для каждого K существует N, такое что для каждого n> = N, P (n)> K. Другими словами, lim _{(n-> ∞)} P (n) = ∞ . (Это то, что значит «расти».)

Ваша «оценка» - это скорость роста основной функции вашей программы.

Более конкретно, программа P растет медленнее, чем Q, если существует N, такое что для всех n> = N, P (n) <= Q (n), и существует по меньшей мере одно n> = N, такое что P (n). ) <Q (n). Если ни одна из программ не лучше, чем другая, они связаны. (По сути, какая программа медленнее, основана на значении lim _{(n-> ∞)} P (n) -Q (n).)

Самая медленная функция роста определяется как функция, которая растет медленнее, чем любая другая функция, согласно определению в предыдущем абзаце.

Это скорость роста , поэтому выигрывает самая медленная программа роста!

Заметки:

• Чтобы помочь в оценке, постарайтесь указать, какую функцию рассчитывает ваша программа в ответе.
• Также добавьте некоторые (теоретические) входные и выходные данные, чтобы помочь людям понять, насколько медленно вы можете идти.

Haskell, 98 байт, оценка = f _{ε 0} ^-1 ( n )

_#[]=0
k#(0:a)=k#a
k#(a:b)=1+(k#(([1..k]>>fst(span(>=a)b)++[a-1])++b))
f n=[k|k<-[0..],k#[k]>n]!!0

Как это работает

Это вычисляет инверсию очень быстро растущей функции, связанной с игрой червя Беклемишева . Скорость его роста сравнима с f _{ε 0} , где f _α - быстрорастущая иерархия, а ε ₀ - первое эпсилонное число .

Для сравнения с другими ответами обратите внимание, что

• возведение в степень сравнимо с f ₂ ;
• повторное возведение в степень ( тетрация или ↑↑ ) сравнимо с f ₃ ;
• ↑↑ ⋯ ↑↑ с m стрелками сравнимо с f _{m + 1} ;
• Функция Аккермана сравнима с f _ω ;
• в повторяющихся итерациях функции Аккермана (конструкции типа числа Грэма ) по-прежнему преобладает f _{ω + 1} ;
• ε ₀ - предел всех башен ω ^{ω ω ⋰ ω} .

Брахилог , 100 байт

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Попробуйте онлайн!

Вероятно, это далеко не так медленно, как некоторые другие причудливые ответы, но я не мог поверить, что никто не пробовал этот простой и красивый подход.

Просто мы вычисляем длину входного числа, затем длину этого результата, затем длину этого другого результата ... в 100 раз.

Это растет так же быстро, как log (log (log ... log (x)), со 100 журналами base-10.

Если вы введете свой номер в виде строки , он будет работать очень быстро на любом входе, который вы можете попробовать, но не ожидайте, что когда-либо увидите результат выше 1: D

JavaScript (ES6), обратная функция Аккермана *, 97 байт

* если я все сделал правильно

A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1
a=(m,n=m,i=1)=>{while(A(i,m/n|0)<=Math.log2(n))i++;return i-1}

Функция A- это функция Аккермана . Функция aдолжна быть обратной функцией Аккермана . Если я реализовал это правильно, Википедия говорит, что это не ударит, 5пока не будет mравных 2^2^2^2^16. Я получаю StackOverflowвокруг 1000.

Использование:

console.log(a(1000))

Пояснения:

Функция Аккермана

A=(m,n)=>                           Function A with parameters m and n
         m?                   :n+1  If m == 0, return n + 1; else,
           A(m-1,n?        :1)       If n == 0, return A(m-1,1); else,
                   A(m,n-1)          return A(m-1,A(m,n-1))

Обратная функция Аккермана

a=(m,n=m,i=1)=>{                                                Function a with parameter m, with n preinitialized to m and i preinitialized to 1
                while(A(i,m/n|0)<=Math.log2(n))                 While the result of A(i, floor(m/n)) is less than log₂ n,
                                               i++;             Increment i
                                                   return i-1}  Return i-1

Чистое Зло: Eval

a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1

Оператор внутри eval создает строку длиной 7 * 10 ^{10 10 10 10 10 8.57,} которая состоит из не более чем дополнительных вызовов лямбда-функции, каждый из которых будет создавать строку одинаковой длины, до тех пор, пока в конечном итоге не yстанет 0. Якобы это имеет ту же сложность, что и метод Эшью, описанный ниже, но вместо того, чтобы полагаться на логику управления «если и / или», он просто объединяет гигантские строки (и в результате получается больше стеков… вероятно?).

Наибольшее yзначение, которое я могу предоставить и вычислить без Python, выдающего ошибку, равно 2, что уже достаточно, чтобы уменьшить ввод max-float для возврата 1.

Строка длины 7,625,597,484,987 слишком велик: OverflowError: cannot fit 'long' into an index-sized integer.

Я должен остановиться.

Eschew Math.log: Переходя к (10-му) корню (проблемы), Score: функция эффективно неотличима от y = 1.

Импорт математической библиотеки ограничивает количество байтов. Давайте покончим с этим и заменим log(x)функцию чем-то примерно эквивалентным: x**.1и которая стоит примерно столько же символов, но не требует импорта. Обе функции имеют сублинейный вывод относительно ввода, но x ^0,1 растет еще медленнее . Однако нас это не сильно волнует, мы заботимся только о том, чтобы у него была одинаковая базовая схема роста по отношению к большим числам при одновременном потреблении сопоставимого количества символов (например, x**.9такое же количество символов, но растет быстрее, поэтому это некоторая ценность, которая будет демонстрировать точно такой же рост).

Теперь, что делать с 16 символами. Как насчет ... расширения нашей лямбда-функции, чтобы иметь свойства последовательности Аккермана? Этот ответ для большого числа вдохновил это решение.

a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1

В этой z**zчасти я не могу запускать эту функцию в местах, близких к нормальным входам для yи z, наибольшие значения, которые я могу использовать, равны 9 и 3, для которых я получаю значение 1,0, даже для наибольшего числа с плавающей запятой, поддерживаемого Python (примечание: пока 1,0 численно больше, чем 6.77538853089e-05, повышенные уровни рекурсии перемещают выход этой функции ближе к 1, оставаясь больше 1, тогда как предыдущая функция перемещала значения ближе к 0, оставаясь больше 0, таким образом, даже умеренная рекурсия для этой функции приводит к такому количеству операций, что число с плавающей запятой теряет все значащие биты).

Переконфигурирование исходного лямбда-вызова для получения значений рекурсии 0 и 2 ...

>>>1.7976931348623157e+308
1.0000000071

Если сравнение выполняется для «смещения от 0» вместо «смещения от 1», эта функция возвращает значение 7.1e-9, которое определенно меньше, чем 6.7e-05.

Реальная базовая рекурсия программы (значение z) имеет глубину 10 ^{10 10 10 1,97} уровня, и как только y исчерпывает себя, она сбрасывается с 10 ^{10 10 10 10 1,97} (именно поэтому начальное значение 9 достаточно), поэтому я не буду Я даже не знаю, как правильно рассчитать общее количество рекурсий, которые произошли: я достиг конца своих математических знаний. Точно так же я не знаю, улучшило бы число рекурсий перемещение одного **nвозведения в степень от начального входа к вторичному z**z(или наоборот).

Пойдем еще медленнее с еще большей рекурсией

import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1

• n//1 - экономит 2 байта int(n)
• import math, math.сохраняет 1 байтfrom math import*
• a(...) более 8 байтов m(m,...)
• (y>0)*x сохраняет байт за кадромy>0and x
• 9**9**99увеличивается количество байт на 4 и увеличивает глубину рекурсии примерно , 2.8 * 10^xгде xстарая глубина (или глубина приближается к гуголплексу в размере: 10 ^{10 94} ).
• 9**9**9e9увеличивает количество байтов на 5 и увеличивает глубину рекурсии на ... безумное количество. Глубина рекурсии теперь 10 ^{10 10 9,93} , для справки, googolplex - 10 ^{10 10 2} .
• Лямбда декларация увеличивает рекурсию на дополнительный шаг: m(m(...))на a(a(a(...)))затраты 7 байт

Новое выходное значение (на глубине 9 рекурсий):

>>>1.7976931348623157e+308
6.77538853089e-05

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

• Оригинал называется log25 раз
• Первое улучшение называет это 81 раз
  • Текущая программа будет называть его 1e99 ² или около 10 ^{10 2,3} раза
• Эта версия называет это 729 раз
  • Текущая программа будет называть его (9 ^{- 99} ) ³ или немного меньше , чем 10 ^{10 95} раз).

Lambda Inception, оценка: ???

Я слышал, что вы любите лямбды, так что ...

from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))

Я даже не могу запустить это, я переполняю стек даже с 99 уровнями рекурсии.

Старый метод (ниже) возвращает (пропуская преобразование в целое число):

>>>1.7976931348623157e+308
0.0909072713593

Новый метод возвращает, используя только 9 слоев вторжения (а не полный гугол из них):

>>>1.7976931348623157e+308
0.00196323936205

Я думаю, что это имеет ту же сложность, что и последовательность Акермана, только маленькая, а не большая.

Также благодаря ETHproductions для 3-байтовой экономии в пространствах, которые я не знал, можно было удалить.

Старый ответ:

Целочисленное усечение функции log (i + 1) повторялось 20 25 раз (Python), используя лямбда-лямбды.

Ответ PyRulez можно сжать, введя вторую лямбду и сложив ее:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))

99 100 символов используется.

В результате получается итерация 20 25 по сравнению с исходной 12. Кроме того, он сохраняет 2 символа, используя int()вместо floor()которых допускается дополнительный x()стек. Если пробелы после лямбды можно убрать (я не могу проверить в данный момент), то y()можно добавить пятую. Возможный!

Если есть способ пропустить from mathимпорт, используя полностью определенное имя (например x=lambda i: math.log(i+1))), это позволило бы сохранить еще больше символов и позволить другой стек, x()но я не знаю, поддерживает ли Python такие вещи (я подозреваю, что нет). Выполнено!

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

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))

Это наименьшая возможная рекурсия с 3 лямбдами, которая превышает вычисленную высоту стека в 2 лямбды (сокращение любой лямбды до двух вызовов снижает высоту стека до 18, по сравнению с версией с 2 ​​лямбдами), но, к сожалению, требует 110 символов.

Haskell , 100 байт

f 0 a b=a^b
f c a b=foldr(f$c-1)a$[0..b]>>[a]
i=length.show
0#x=i x
y#x=i$(y-1)#x
g=(f(f 9 9 9)9 9#)

Попробуйте онлайн!

Это решение не принимает инверсию быстро растущей функции, вместо этого оно принимает довольно медленно растущую функцию, в этом случае length.show, и применяет ее несколько раз.

Сначала мы определим функцию f. fЭто ублюдочная версия нотации Кнута, которая растет немного быстрее (немного преуменьшает, но числа, с которыми мы имеем дело, настолько велики, что в общем плане вещей ...). Мы определяем базовый случай, f 0 a bчтобы быть a^bили aв силу b. Затем мы определяем общий случай, который будет (f$c-1)применяться к b+2экземплярам a. Если бы мы определяли нотацию Кнута со стрелкой вверх, как конструкцию, мы применили бы ее к bэкземплярам a, но b+2на самом деле она более гольфистская и имеет преимущество в том, что она быстрее растет.

Затем мы определим оператор #. a#bопределяется для length.showприменения ко b aвремени. Каждое применение length.showпримерно равно log ₁₀ , что не очень быстро растущая функция.

Затем мы приступаем к определению нашей функции, gкоторая принимает целое число и применяет его length.showк целому ряду раз. Чтобы быть конкретным, это относитсяlength.show к входу f(f 9 9 9)9 9. Прежде чем мы перейдем к тому, насколько это большое, давайте посмотрим f 9 9 9. f 9 9 9это больше , чем 9↑↑↑↑↑↑↑↑↑9 (девять стрелок), массивный край. Я считаю, что это где-то между 9↑↑↑↑↑↑↑↑↑9(девять стрел) и 9↑↑↑↑↑↑↑↑↑↑9(десять стрел). Теперь это невообразимо большое число, которое может храниться на любом существующем компьютере (в двоичной записи). Затем мы берем это и ставим это в качестве первого аргумента нашего, fчто означает, что наша ценность больше, чем 9↑↑↑↑↑↑...↑↑↑↑↑↑9сf 9 9 9стрелки между ними. Я не собираюсь описывать это число, потому что оно настолько велико, что я не думаю, что смогу сделать это справедливо.

Каждый length.showпримерно равен взятию логарифмической базы 10 целого числа. Это означает, что большинство чисел вернет 1, когда fприменяется к ним. Наименьшее число, возвращающее что-то, отличное от 1, равно 10↑↑(f(f 9 9 9)9 9)2. Возвращается на минутку. Столь же отвратительно, как и то число, которое мы определили ранее, наименьшее число, которое возвращает 2, во много раз превосходит 10. То 1, за которым следуют 10↑(f(f 9 9 9)9 9)нули.

Для общего случая nнаименьшего входного вывода любой заданный n должен быть (10↑(n-1))↑↑(f(f 9 9 9)9 9).

Обратите внимание, что эта программа требует огромного количества времени и памяти даже для небольшого n (больше, чем во вселенной много раз), если вы хотите проверить это, я предлагаю заменить f(f 9 9 9)9 9на гораздо меньшее число, попробуйте 1 или 2, если хотите когда-нибудь получить какой-либо вывод, кроме 1.

APL, Apply log(n + 1), e^9^9...^9времена, когда длина цепи равна e^9^9...^9длине цепи минус 1 раз, и так далее.

⌊((⍟1+⊢)⍣((*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣⊢)))))))))))))))))))))9))⊢

MATL , 42 байта

iXI:`2*.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx

Попробуйте онлайн!

Эта программа основана на серии гармоник с использованием постоянной Эйлера-Маскерони. Когда я читал документацию @LuisMendo на его языке MATL (заглавными буквами, так что это выглядит важно), я заметил эту константу. Выражение функции медленного роста выглядит следующим образом:

где εk ~ 1 / 2k

Я протестировал до 10000 итераций (в Matlab, поскольку он слишком велик для TIO), и его оценки ниже 10, поэтому он очень медленный.

Пояснения:

 iXI      % ask user input (number of iterations)

:`2*.]    % do...while loop, multiply by 2

X{        % convert numeric array into cell array

o         % convert to double precision array 

XH1H/     % copy to clipboard H and divide by 1: now we have an array of 1/2k

16L       % Euler–Mascheroni constant 

+         % addition (element-wise, singleton expansion)

XKxI:`    % save, clear the stack, do...while loop again

  Yl      % logarithm 

  .]      % break, ends the loop

K+XK      % paste from clipboard K, sum all

Xd        % trim: keep the diagonal of the matrix 

Xz        % remove all zeros

XG        % plot (yes it plots on-line too!)

x         % clear the stack
          % (implicit) display

Эмпирическое доказательство: (ln k ) + 1 красным цветом всегда выше ln k + γ + εk синим цветом.

Программа для (ln k ) + 1 была сделана в

Matlab, 47 18 14 байтов

n=input('')
A=(1:n)
for k=1:n
A(k)=log(k)+1
end

Интересно отметить, что истекшее время для n = 100 составляет 0.208693 с на моем ноутбуке, но только 0.121945 с d=rand(1,n);A=d*0;и даже меньше, 0.112147 с A=zeros(1,n). Если нули - пустая трата пространства, это экономит скорость! Но я отклоняюсь от темы (вероятно, очень медленно).

Редактировать: спасибо Стьюи за помощь в сокращении выражения Matlab до простого:

 @(n)log(1:n)+1

Python 3 , 100 байт

Этаж журнала функций (i + 1) повторяется 99999999999999999999999999999999999 раз.

Можно использовать показатели, чтобы сделать указанное число еще больше ...

from math import *
s=input()
exec("s=log(s+1);"*99999999999999999999999999999999999)
print(floor(s))

Попробуйте онлайн!

Этаж функции log (i + 1) повторяется 14 раз (Python)

import math
x=lambda i: math.log(i+1)
print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input())))))))))))))))

Я не ожидаю, что это будет очень хорошо, но я подумал, что это хорошее начало.

Примеры:

• e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n -> ~ n (приблизительно n)

Ruby, 100 байт, оценка ^-1 = f _{ω ^{ω + 1}} (n ² )

В основном заимствовано из моего самого большого номера для печати , вот моя программа:

->k{n=0;n+=1 until(H=->z,a=[0]*z{b,*c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]*z+c]:z};z};H[n*n]>k);n}

Попробуйте онлайн

В основном вычисляет инверсию f _{ω ^{ω + 1}} (n ² ) в быстро растущей иерархии. Первые несколько значений

x[0] = 1
x[1] = 1
x[2] = 1
x[3] = 1
x[4] = 2

А потом он продолжает выводить 2очень долго. Даже x[G] = 2, где номер GГрэма.

Mathematica, 99 байтов

(при условии, что ± занимает 1 байт)

0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)&

Первые 3 команды определяют x±yдля оценки Ackermann(y, x).

Результатом функции является количество раз, которое f(#)=#±#±#±#±#±#±#±#необходимо применить к 1, прежде чем значение достигнет значения параметра. Поскольку f(#)=#±#±#±#±#±#±#±#(то есть f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) растет очень быстро, функция растет очень медленно.

Clojure, 91 байт

(defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur(* r v)(Math/log v))))))))

Вид вычисляет тот sum 1/(n * log(n) * log(log(n)) * ...), который я нашел отсюда . Но функция закончилась длиной 101 байт, поэтому мне пришлось отбросить явное количество итераций, и вместо этого выполнять итерацию, пока число больше единицы. Пример выходов для входов 10^i:

0 1
1 3.3851305685279143
2 3.9960532565317575
3 4.232195089969394
4 4.370995106860574
5 4.466762285601703
6 4.53872567524327
7 4.595525574477128
8 4.640390570825608

Я предполагаю, что этот модифицированный ряд все еще расходится, но теперь знаю, как это доказать.

Третья серия на самом деле требует googolplex числа терминов, прежде чем частичные термины превышают 10.

Javascript (ES6), 94 байта

(p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log)

Пояснение :

Idотносится к x => xследующему.

Давайте сначала посмотрим на:

p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))

p(Math.log) примерно равно log*(x).

p(p(Math.log))примерно равно log**(x)(количество раз, которое вы можете взять, log*пока значение не будет больше 1).

p(p(p(Math.log)))примерно равно log***(x).

Обратная функция Аккермана alpha(x)приблизительно равна минимальному количеству раз, которое вам нужно сочинять, pпока значение не станет максимум 1.

Если мы тогда используем:

p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x))

тогда мы можем написать alpha = p(Id)(Math.log).

Это довольно скучно, поэтому давайте увеличим количество уровней:

p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x))

Это похоже на то, как мы строили alpha(x), за исключением того log**...**(x), что мы делаем сейчас alpha**...**(x).

Зачем здесь останавливаться?

p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x))

Если предыдущая функция есть f(x)~alpha**...**(x), то эта сейчас ~ f**...**(x). Мы делаем еще один уровень, чтобы получить наше окончательное решение.