Ваша цель - написать программу, которая печатает число. Чем больше число, тем больше очков вы получите. Но будь осторожен! Длина кода ограничена и сильно взвешена в функции оценки. Ваш напечатанный номер будет разделен на куб числа байтов, которые вы использовали для вашего решения .

Итак, допустим, вы напечатали, 10000000и ваш код длиной в 100байты. Ваш окончательный счет будет 10000000 / 100^3 = 10.

Есть и другие правила, которым нужно следовать, чтобы усложнить задачу.

• Вы не можете использовать цифры в своем коде (0123456789);
• Вы можете использовать математические / физические / и т.д. константы, но только если они меньше 10. (например, Вы можете использовать Pi ~ = 3.14, но вы не можете использовать постоянную Авогадро = 6e23)
• Рекурсия разрешена, но сгенерированное число должно быть конечным (поэтому бесконечное не принимается как решение. Ваша программа должна корректно завершаться, предполагая неограниченное время и память, и генерировать запрошенный вывод);
• Вы не можете использовать операции *(умножение), /(деление), ^(власть) или любой другой способ указать их (например 2 div 2, не допускается);
• Ваша программа может выводить более одного числа, если вам это нужно . Только самый высокий будет засчитан для выигрыша;
• Тем не менее, вы можете объединять строки: это означает, что любая последовательность соседних цифр будет рассматриваться как одно число;
• Ваш код будет запущен как есть. Это означает, что конечный пользователь не может редактировать какую-либо строку кода и не может вводить число или что-либо еще;
• Максимальная длина кода составляет 100 байтов.

Leaderboard

1. Стивен Х. , Пайт ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Просто Красивое Искусство , Рубин ≈ f _{φ 121 (ω)} (126) ^[1]
3. Питер Тейлор , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0)} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))))) ^[1]
5. Просто Красивое Искусство , Рубин ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Юлия ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ¹⁶⁶⁶⁶⁶⁵ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Пурпурный , Python, ≈ ack (126 126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Кендалл Фрей , ECMAScript 6, ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Илмари Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. рекурсивный , Python, ≈ 2↑↑ 11/95 ³ ≈ 10 ↑↑ 8,63297 ^{[1] [3]}
15. нм , Haskell, ≈ 2↑↑ 7/100 ³ ≈ 10 ↑↑ 4,63297 ^[1]
16. Дэвид рыскания , C ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. Primo , Perl ≈ 10 ^{(+12750684161!) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4,11369
18. Искусство , C ≈ 10 ^{10 2 × 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Роберт Сёрли , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Тобия , АПЗ, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Даррен Стоун , C, ≈ 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C ≈ 10 ^{2 320} на / 100 ³ ≈ 10 ↑↑ 3,29749
23. Адам Спейт , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28039
24. Джошуа , удар, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_Сноски

1. ^{Если бы каждый электрон во вселенной был кубитом, и каждая его суперпозиция могла бы с пользой использоваться для хранения информации (что, если вам на самом деле не нужно знать, что хранится, теоретически возможно), эта программа требует больше памяти, чем могла бы возможно, существуют, и поэтому не могут быть запущены - сейчас или в любой мыслимой точке в будущем. Если автор намеревался напечатать значение, большее, чем ≈ 3 ↑↑ 3,28 одновременно, это условие применяется.}
2. ^{Эта программа требует больше памяти, чем существует в настоящее время, но не настолько, чтобы теоретически ее нельзя было хранить на скудном количестве кубитов, и поэтому однажды может появиться компьютер, который может запустить эту программу.}
3. ^{Все доступные в настоящее время интерпретаторы выдают ошибку времени выполнения, иначе программа не будет выполнена так, как задумал автор.}
4. ^{Запуск этой программы нанесет непоправимый ущерб вашей системе.}

Edit @primo : я обновил часть табло, используя, надеюсь, более удобную для сравнения запись с десятичными знаками для обозначения логарифмического расстояния до следующей более высокой степени. Например, 10 ↑↑ 2,5 = 10 ^{10 √10} . Я также изменил некоторые оценки, если считаю, что анализ пользователя неверен, не стесняйтесь оспаривать любой из них.

Объяснение этой записи:

Если 0 ≤ b < 1тогда .a↑↑b = ab

Если b ≥ 1тогда .a↑↑b = aa↑↑(b-1)

Если b < 0тогда .a↑↑b = loga(a↑↑(b+1))

GolfScript; оценка не менее f _{ε_0 + ω + 1} (17) / 1000

После разрешения «ы предложения использовать Lifetime червячного ответа на этот вопрос, я две программы , которые значительно улучшают его вывод решения Говарда.

Они имеют общий префикс по модулю имени функции:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

вычисляет, g(g(1)) = g(5)где g(x) = worm_lifetime(x, [x])растет примерно как f _{ε 0} (то есть примечания - это «функция в быстрорастущей иерархии, которая растет примерно с той же скоростью, что и функция Гудштейна»).

Немного легче (!) Анализировать

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*карты xдля foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

таким образом дает g^(g(5)) ( g(5) ); остальные 8 уровней итерации аналогичны цепочке стрелок. Чтобы выразить в простых терминах: если h_0 = gи h_{i+1} (x) = h_i^x (x)тогда мы рассчитаем h_10 (g(5)).

Я думаю, что эта вторая программа почти наверняка намного лучше. На этот раз метка, назначенная функции, gявляется новой строкой (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

На этот раз я лучше использую ^в качестве другой функции.

.['.{
}*'n/]*zip n*~

берет xна стек и оставляет xпосле себя строку, содержащую xкопии, .{за которой gследуют xкопии }*; Затем он оценивает строку. Так как у меня было лучшее место для записи запасных персонажей, мы начинаем с j_0 = g; если j_{i+1} (x) = j_i^x (x)тогда первая оценка ^вычислений j_{g(5)} (g(5))(которая, я уверен, уже превосходит предыдущую программу). Затем я выполняю еще ^16 раз; так что если k_0 = g(5)и k_{i+1} = j_{k_i} (k_i)тогда он рассчитывает k_17. Я благодарен (опять же) за то, чтобы оценить, что k_i>> f _{ε_0 + ω + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

ПРИМЕЧАНИЕ: НЕ НАЧИНАЙТЕ ЭТОГО!

Сохраните следующее в командный файл и запустите его от имени администратора.

CD|Format D:/FS:FAT/V/Q

Выводится при запуске на диске 4 ТБ с первым напечатанным номером, выделенным жирным шрифтом.

Вставьте новый диск для диска D:
и нажмите ENTER, когда будете готовы ... Тип файловой системы - NTFS.
Новая файловая система FAT.
QuickFormatting 3907172M
Объем слишком велик для FAT16 / 12.

GolfScript, оценка: путь слишком много

Хорошо, насколько большое число мы можем напечатать в нескольких символах GolfScript?

Давайте начнем со следующего кода ( спасибо, Бен! ), Который печатает 126:

'~'(

Далее, давайте повторим это 126 раз, дав нам число, равное примерно 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(Это повторение строк, а не умножение, поэтому в соответствии с правилами все должно быть в порядке.)

Теперь давайте повторим это 378-значное число чуть более 10 ³⁷⁷ раз:

'~'(.`*.~*

Вы никогда не увидите, чтобы эта программа завершилась, поскольку она пытается вычислить число с примерно 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ цифрами. Ни один когда-либо созданный компьютер не мог хранить такое большое число, и при этом не мог бы быть построен такой компьютер, используя известную физику; число атомов в наблюдаемой Вселенной оценивается приблизительно 10 ⁸⁰ , так что даже если бы мы могли каким - то образом использовать всю материю во Вселенной , чтобы сохранить это огромное количество, мы бы до сих пор как - то втиснуть около 10 ⁺³⁸⁰ / 10 ⁸⁰ = 10 ³⁰⁰ цифр в каждый атом!

Но давайте предположим, что у нас есть собственный Божий интерпретатор GolfScript, способный выполнять такие вычисления, и что мы все еще не удовлетворены. ОК, давайте сделаем это снова!

'~'(.`*.~*.~*

Выходные данные этой программы, если бы она могла завершиться, имели бы около 10 ^{10 383} цифр и, следовательно, равнялись бы примерно 10 ^{10 10 383} .

Но ждать! Эта программа становится несколько повторяющейся ... почему бы нам не превратить ее в цикл?

'~'(.`*.{.~*}*

Здесь тело цикла получает работать около 10 ³⁷⁷ раз, что дает нам теоретический выход , состоящему из примерно 10 ^{10⋰ 10 377} цифр или около того , где башни итерированных полномочий от 10 составляет около 10 ³⁷⁷ длиной шага. (На самом деле, это грубая недооценка, так как я пренебрегаю тем фактом, что число, которое повторяется, также увеличивается каждый раз, но, условно говоря, это незначительная проблема.)

Но мы еще не закончили. Давайте добавим еще один цикл!

'~'(.`*.{.{.~*}*}*

Чтобы даже правильно записать приближение таких чисел, необходимы эзотерические математические обозначения. Например, в нотации со стрелкой вверх по Кнуту число (теоретически), выводимое вышеприведенной программой, должно составлять примерно 10 ↑ ³ 10 ³⁷⁷ , давать или брать несколько (или 10 ³⁷⁷ ) степеней из десяти, предполагая, что я правильно сделал математику.

Числа, подобные этому, выходят далеко за пределы просто «невероятно огромного» и попадают в область «немыслимого». Например, не только невозможно сосчитать или записать такие числа (мы перешли за эту точку уже в третьем примере выше), но они буквально не имеют никакого возможного использования или существования вне абстрактной математики. Мы можем доказать, из аксиом математики , что такие числа существуют, так же , как мы можем доказать , из спецификации GolfScript , что Программа выше будет их вычислять, если пределы реальности и доступного дискового пространства не вмешивались), но нет буквально ничего в физическая вселенная, которую мы могли бы использовать для подсчета или измерения в любом смысле.

Тем не менее, математики иногда используют еще большие числа . (Теоретически) вычислительные числа , что большое занимает немного больше работы - вместо того , чтобы просто гнезжусь более петли один за другим, мы должны использовать рекурсию для телескопа глубины вложенных циклов. Тем не менее, в принципе, должна быть возможность написать короткую программу на языке GolfScript (я бы ожидал, что ее размер меньше 100 байт), чтобы (теоретически) вычислить любое число, выражаемое, скажем, в цепочечной нотации Конвея ; детали оставлены в качестве упражнения. ;-)

JavaScript 44 символа

Это может показаться немного обманчивым:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Оценка = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004

C, балл = 10 ^{10 97,61735} / 98 ³ ≈ 10 ↑↑ 2,29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

Я ценю помощь в оценке. Любые идеи или исправления приветствуются. Вот мой метод:

n = конкатенация каждого числа от 1 до 2 ⁶⁴ -1, повторяется (2 ⁶⁴ -1) ⁴ раза . Во-первых, вот как я оцениваю (низко) совокупное число цифр от 1 до 2 ⁶⁴ -1 («подпоследовательность»): последнее число в последовательности подпоследовательности составляет 2 ⁶⁴ -1 = 18446744073709551615с 20 цифрами. Таким образом, более 90% чисел в подпоследовательности (начинающихся с 1.. 9) имеют 19 цифр. Давайте предположим, что оставшиеся 10% в среднем 10 цифр. Это будет гораздо больше, но это низкая оценка для легкой математики и без обмана. Эта подпоследовательность повторяется (2 ⁶⁴ -1) ⁴ раза, поэтому длинаиз n будет не менее (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ цифр. В комментариях ниже @primo подтверждает, что длина n равна 4.1433x10 ⁹⁷ . Таким образом, само n будет 10 к этой степени, или 10 ^{10 97,61735} .

L = 98 символов кода

оценка = н / л ³ = 10 ^{10 97,61735} / 98 ³

Требование: Должен работать на 64-битном компьютере, где sizeof(long) == 8. Mac и Linux сделают это.

Python 3 - 99 символов - (скорее всего) значительно больше числа Грэма

Я придумал более быстро растущую функцию, основанную на расширении функции Аккермана.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 вдохновил меня, но вам не нужно заглядывать туда, чтобы понять мой номер.

Вот модифицированная версия функции ackermann, которую я буду использовать в своем анализе:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Моя функция Aв приведенном выше коде технически не совпадает, но на самом деле она сильнее, с помощью следующего оператора, заменяющего третью строку приведенного выше определения:

A(a,0,...)=A(a-1,a,...)

(a должно быть не менее 1, поэтому оно должно быть сильнее)

Но для моих целей я буду предполагать, что он такой же, как и более простой, потому что анализ уже частично сделан для функции Аккермана и, следовательно, для этой функции, когда у нее есть два аргумента.

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

Анализ размера

Число Грэма, AFAIK, можно представить как G(64):

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Где ↑^(n)b - обозначение стрелки Кнута.

Также:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

Число , выраженное в программе выше A(0,1,2,3,4,...,123,124,125).

Так как g^64(4)это число Грэма, и предполагая мою математику правильно , то это меньше , чем A(1,64,100)мое число значительно больше , чем число Грэма.

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

Perl - оценка ≈ 10 ↑↑ 4,1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Еще раз злоупотребляя движком регулярных выражений Perl, чтобы перебирать невообразимое количество комбинаций, на этот раз используя рекурсивный спуск.

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

В итоге мы получим следующее:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... повторялось 671088640 раз, в общей сложности 12750684161 вложений - что довольно тщательно опускает мою предыдущую попытку 23 вложений. Примечательно, что Perl даже не подавляется этим (опять же, использование памяти остается стабильным на уровне около 1,3 ГБ), хотя пройдет еще некоторое время, прежде чем будет выпущено первое выражение для печати.

Из моего предыдущего анализа ниже, можно сделать вывод , что количество цифр вывода будет на порядок (!) 12750684161 ^671088640 , где ! К является левой Факториал от к (см A003422 ). Мы можем приблизить это как (k-1)! , что строго меньше, но на тот же порядок величины.

И если мы спросим wolframalpha :

... который почти не меняет мою оценку. Я думал наверняка, что это будет по крайней мере 10 ↑↑ 5 . Я думаю, что разница между 10 ↑↑ 4 и 10 ↑↑ 4.1 намного больше, чем вы думаете.

Perl - оценка ≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Злоупотребление движком Perl Regex для создания комбинаторики для нас. Встроенный кодовый блок
(??{print})вставит свой результат непосредственно в регулярное выражение. Так $_как полностью состоит из 2s (а результат printвсегда 1), он никогда не может совпадать и посылает perl, вращающийся через все возможные комбинации, которых довольно много.

Константы, используемые

• $^F- максимальный дескриптор системного файла, как правило 2.
• $]- номер версии perl, аналогичный 5.016002.

$_затем строка, содержащая цифру, 2повторенную 671088640 раз. Использование памяти постоянно около 1,3 ГБ, выход начинается немедленно.

Анализ

Давайте определим P _k (n) как число выполнений оператора print, где k - количество вложений, а n - длина строки плюс один (просто потому, что мне не хочется писать n + 1 везде).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

и т.д. В общем, формула может быть обобщена следующим образом:

где

То есть, левый Факториал от к , то есть сумма всех факториалов меньше , чем к (см A003422 ).

Я не смог определить замкнутые формы для D _k и E _k , но это не имеет большого значения, если мы заметим, что

а также

С 23 вложениями это дает нам приблизительную оценку:

Это должно быть почти точно, на самом деле.

Но чтобы поместить это в нотацию, которую немного проще визуализировать, мы можем приблизить основание внутреннего показателя степени:

а затем сам показатель:

а затем спросите вольфрамальфу :

что вы можете также просто позвонить 10 ↑↑ 4 и покончить с этим.

Javascript, 10 ↑↑↑↑ 210

100 символов:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Основываясь на наблюдении, что максимальная итерация f- это оптимальный путь, я заменил 13 вызовов на f3 уровня вызовов вложенных циклов f, zкаждый раз (пока fпродолжает расти z).

Я оценил результат аналитически на листе бумаги - я напишу его, если кому-то интересно посмотреть.

Улучшенный счет: 10 ↑↑ 13

Javascript, точно в 100 символов, опять же:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

Это улучшает мой первоначальный ответ тремя способами:

1. Определение zглобального контекста избавляет нас от необходимости o.zкаждый раз печатать .

2. Можно определить геттер для глобальной области видимости (окна) и типа fвместо o.f.

3. Больше итераций fстоит больше, чем начинать с большего числа, поэтому вместо (Math.E+'').replace('.','')(= 2718281828459045, 27 символов) лучше использовать ~~Math.E+''(= 2, 11 символов) и использовать спасенные символы для вызова fмного раз.

Поскольку, как будет проанализировано ниже, каждая итерация выдает из числа порядка M большее число, порядка 10 ^M , этот код выдает после каждой итерации.

1. 210 ∼ O (10 ² )
2. O (10 ^{10 2} ) ∼ O (10 ↑↑ 2)
3. O (10 ^{10 ± 2} ) = O (10 × 3)
4. O (10 ^{10 3} ) = O (10 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 5} ) = O (10 6)
7. O (10 ^{10 6} ) = O (10 7)
8. O (10 ^{10 7} ) = O (10 8)
9. O (10 ^{10 8} ) = O (10 9)
10. O (10 ^{10 9} ) = O (10 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 11} ) = O (10 12)
13. O (10 ^{10 12} ) = O (10 13)

Оценка: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

Javascript, ровно 100 символов:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Каждый o.fвызывает цикл while, всего 5 циклов. Только после первой итерации счет уже превысил 10 ^{42381398144233621} . Во второй итерации Mathematica не смогла вычислить даже количество цифр в результате.

Вот пошаговое руководство по коду:

В этом

Начните с 2718281828459045, удалив десятичную точку из Math.E.

Итерация 1

Объединить убывающую последовательность чисел,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

сформировать новый (гигантский) номер,

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Сколько цифр в этом номере? Ну, это объединение

• 1718281828459046 16-значные номера
• 900000000000000 15-значные номера
• 90000000000000 14-значные номера,
• 9000000000000 13-значные номера
• ...
• 900 3-значных номеров
• 90 2-значных номеров
• 10 однозначных чисел

В Mathematica,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

Другими словами, это 2.72⋅10 ^{42381398144233625} .

Делая мой счет, только после первой итерации, 2.72⋅10 ^{42381398144233619} .

Итерация 2

Но это только начало. Теперь повторите шаги, начиная с гигантского числа ! То есть объединить убывающую последовательность чисел,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0

Итак, каков мой новый счет, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Итерация 3

Повторение.

Итерация 4

Повторение.

Итерация 5

Повторение.

Аналитическая оценка

На первой итерации мы вычислили количество цифр в конкатенации убывающей последовательности, начиная с 2718281828459045, подсчитав количество цифр в

• 1718281828459046 16-значные номера
• 900000000000000 15-значные номера
• 90000000000000 14-значные номера,
• 9000000000000 13-значные номера
• ...
• 900 3-значных номеров
• 90 2-значных номеров
• 10 однозначных чисел

Эта сумма может быть представлена ​​формулой,

где Z обозначает начальный номер ( например, 2718281828459045), а O _Z обозначает его порядок величины ( например, 15, поскольку Z ¹⁵ 10 ¹⁵ ). Используя эквивалентности для конечных сумм , вышесказанное может быть явно выражено как

что, если мы возьмем 9 ≈ 10, еще больше уменьшится до

и, наконец, расширив термины и упорядочив их по убыванию, мы получим

Теперь, поскольку нас интересует только порядок величины результата, давайте заменим Z на «число в порядке величины O _Z », то есть 10 ^{O _Z} -

Наконец, 2-й и 3-й термины отменяются, и последние два условия могут быть отброшены (их размер тривиален), оставляя нас с

из которого выигрывает первый член.

Повторно, fпринимает число в порядке величины М и производит число примерно в порядке величины М (10 ^М ).

Первая итерация может быть легко проверена вручную. 2718281828459045 - это число порядка 15, поэтому fдолжно быть получено число порядка 15 (10 ¹⁵ ) ¹⁶ 10 ¹⁶ . Действительно, произведенное число составляет 2,72⋅10 ^{42381398144233625,} то есть 10 ^{42381398144233625 25} 10 ^{10 16} .

Отмечая, что М не является значимым фактором в М (10 ^М ), порядок величины результата каждой итерации, следовательно, следует простой схеме тетратации:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

LaTeX источники

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Вот моя пересмотренная попытка:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

Программа на 100 символов / байт *, работающая на текущем оборудовании (использует незначительный объем памяти и обычные 32-битные переменные типа int), хотя ее выполнение займет очень много времени.

Вы можете запустить его на интерпретаторе APL, и он начнет печатать цифры. Если разрешено завершить, он напечатает число с 10 × 123456789 ⁴⁴ цифры.

Таким образом, оценка 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

объяснение

• ⎕D предопределенная константная строка, равная '0123456789'
• n←⍎⎕Dопределяет n как число, представленное этой строкой: 123456789 (который <2 ³¹ и, следовательно, может использоваться как переменная управления циклом)
• {⍞←⎕D} выведет 10 цифр на стандартный вывод без перевода строки
• {⍞←⎕D}⍣nбудет делать это n раз ( ⍣это «оператор питания»: это ни *, /, ни ^, потому что это не математическая операция, это своего рода цикл)
• {⍞←n}⍣n⍣nбудет повторять предыдущую операцию n раз, поэтому печать 10 цифр n ² раза
• {⍞←n}⍣n⍣n⍣nбудет делать это п ³ раза
• Я мог бы поместиться 44 ⍣nв там, так что печатает п ⁴⁴ раза струнные '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL может быть записан в своей собственной (устаревшей) однобайтовой кодировке, которая отображает символы APL в верхние 128-байтовые значения. Следовательно, для целей оценки программа из N символов, в которой используются только символы ASCII и символы APL, может рассматриваться как длина N байтов.}

Haskell, оценка: (2 ^{2 2 65536} -3) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

Эта программа содержит ровно 100 байт чистого кода на Haskell. Он напечатает четвертое число Аккермана, в конечном итоге потребляя всю доступную энергию, материю и время Вселенной и за ее пределами в процессе (таким образом, слегка превышая мягкий предел в 5 секунд).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (обозначение стрелки вверх)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

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

Да, это делает сдвиг битов на булевых значениях. Trueполучает принуждение 1в этом контексте. Python имеет произвольные длины целых чисел.

GolfScript 3.673e + 374

'~'(.`*

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

Объяснение: '~'(оставит 126 (значение ASCII "~") в стеке. Затем скопируйте число, преобразуйте его в строку и повторите строку 126 раз. Это дает 126126126126...примерно 1.26 e+377. Решение состоит из 7 символов, поэтому разделите на 7^3, чтобы получить оценку примерно3.673e+374

Рубин, вероятностно бесконечный, 54 символа

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

Значение x инициализируется значением 97. Затем мы повторяем следующую процедуру: Генерируем x случайных чисел от 0 до 1. Если они все одинаковые, завершаем работу и печатаем x. В противном случае удвойте x и повторите. Поскольку случайные числа Руби имеют 17 цифр точности, вероятность завершения на любом шаге равна 1 в (10e17) ^ x. Следовательно, вероятность завершения в течение n шагов является суммой для x = 1 - n из (1 / 10e17) ^ (2 ^ n), которая сходится к 1 / 10e34. Это означает, что для любого числа, независимо от его размера, крайне маловероятно, что эта программа выдаст меньшее число.

Теперь, конечно, философский вопрос состоит в том, можно ли когда-либо завершать программу, у которой есть шанс на завершение шага n менее 1 на 10 ^ 34 для любого n. Если мы предполагаем не только бесконечное время и мощность, но и то, что программе дается возможность работать с возрастающей скоростью со скоростью, превышающей скорость, с которой вероятность завершения уменьшается, я полагаю, что на самом деле мы можем сделать вероятность завершение по времени t произвольно близко к 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0)} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))))

Это бесстыдно адаптировано из другого ответа @Howard и включает в себя предложения @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

Мое понимание GolfScript ограничено, но я считаю, что операторы *and ^выше не являются арифметическими операторами, запрещенными OP.

(Я с удовольствием удалю это, если @Howard хочет представить свою собственную версию, которая в любом случае, несомненно, будет лучше этой.)

Эта программа вычисляет число , которое примерно е _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (126)))))) ))) - девятикратная итерация f _{ε 0} - где f _{ε 0} - функция в быстрорастущей иерархии, которая растет примерно с той же скоростью, что и функция Гудштейна. ( _{е 0}растет настолько быстро, что темпы роста n-k-функции Фридмана и k-кратных стрелок Конвея практически незначительны даже по сравнению с одним не повторным f _{ε 0.} )

100 символов

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Учитывая достаточно времени и память, это вычислит число около 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Я первоначально реализован гипероператором функции, но для этого требуется слишком много символов для этой проблемы, поэтому я снял n = 2, b = 0и n >= 3, b = 0условие, превращая n = 1, b = 0состояние в n >= 1, b = 0.

Здесь используются только арифметические операторы: сложение и вычитание.

РЕДАКТИРОВАТЬ: как и обещано в комментариях, вот разбивка того, что делает этот код:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

Как уже отмечалось, это отличается от функции гипероперации тем, что базовые сценарии для умножения и выше заменяются базовыми сценариями для сложения. Этот код ведет себя как будто a*0 = a^0 = a↑0 = a↑↑0 ... = aвместо математически правильного a*0 = 0и a^0 = a↑0 = a↑↑0 ... = 1. В результате он вычисляет значения, которые немного выше, чем они должны быть, но это не имеет большого значения, так как мы стремимся к большим числам. :)

РЕДАКТИРОВАТЬ: я только что заметил, что цифра случайно попала в код в макросе, который выполняет приращение для n=0. Я удалил его, заменив его на «F» (15), что имеет побочный эффект масштабирования каждой операции приращения на 15. Я не уверен, насколько это повлияет на конечный результат, но сейчас, вероятно, он намного больше.

Нет больше ограничений на время выполнения? Хорошо, тогда.

Нужно ли запускать программу на современных компьютерах?

Оба решения используют 64-битную компиляцию, так что longэто 64-битное целое число.

C: больше 10 ^{(2 64 -1) 2 64} , что само по себе больше 10 ^{10 355393490465494856447} ≈ 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 символов.

Чтобы сделать эти формулы проще, я буду использовать t = 2^64-1 = 18446744073709551615.

mainбудет вызывать fс параметром t, который будет tвремя цикла , каждый раз печатая значение t, и вызывая fс параметром t-1.

Всего цифра напечатала: 20 * t.

Каждый из этих вызовов fс параметром t-1будет повторять tвремя, печатая значение tи вызывая f с параметром t-2.

Всего напечатанных цифр: 20 * (t + t*t)

Я попробовал эту программу, используя эквивалент 3-битных целых чисел (я установил i = 8и имел основной вызов f(7)). Он ударил по заявлению о печати 6725600 раз. Это работает, 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7поэтому, я считаю, что это окончательный счет для полной программы:

Всего напечатанных цифр: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Я не уверен, как рассчитать (2 ⁶⁴ -1) ^{2 64} . Это суммирование меньше, чем (2 ⁶⁴ ) ^{2 64} , и мне нужна степень два, чтобы сделать этот расчет. Поэтому я вычислю (2 ⁶⁴ ) ^{2 64 -1} . Это меньше, чем реальный результат, но так как это степень двойки, я могу преобразовать ее в степень 10 для сравнения с другими результатами.

Кто-нибудь знает, как выполнить это суммирование или как преобразовать (2 ⁶⁴ -1) ^{2 64} в 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
разделите этот показатель на логарифмическую базу 2 из 10, чтобы переключить базу экспоненты в степени 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Но помните, это количество напечатанных цифр. Значение целого числа 10 повышается до этой степени, поэтому 10 ^ 10 ^ 355393490465494856447

Эта программа будет иметь глубину стека 2 ^ 64. Это 2 ^ 72 байта памяти только для хранения счетчиков цикла. Это 4 миллиарда терабайт счетчиков циклов. Не говоря уже о других вещах, которые будут идти в стеке для 2 ^ 64 уровней рекурсии.

Редактировать: исправил пару опечаток и использовал более точное значение для log2 (10).

Редактировать 2: Подождите секунду, у меня есть цикл, за пределами которого printf. Давайте это исправим. Добавлена ​​инициализация i.

Правка 3: Черт возьми, я облажался с предыдущей правкой. Исправлена.

Этот будет работать на современных компьютерах, но не скоро закончится.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 персонажей.

Это будет печатать побитовое обратное нуля, 2 ^ 64-1, один раз для каждой итерации. 2 ^ 64-1 - это 20-значное число.

Количество цифр = 20 * (2^64-1)^7= 145367744859121378054701952902648635982508761548130375074434951398727137800962275710279032227571027903270680672445638775618778303705182042800542187500

Округление длины программы до 100 символов, счет = напечатанное число / 1 000 000

Счет = 10 ^ 1453677448591213780547019529026486359825087615481303750744349513987271378009622757102790327075802424638775618778303705182042800542187494

R - 49 41 символов кода, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

распечатает [воспроизведение здесь только начало]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 - G (1), где G (64) - число Грэма)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Выход: 10 ^ 3 ↑↑↑↑ 3

подсказки:

Gявляется функцией, где G (64) является числом Грэма. Ввод является целым числом. Вывод - унарная строка, написанная с 0. Удалено для краткости.

Kявляется функцией Кнута со стрелкой вверх a ↑ ⁿ b, где a неявно 3. Входные данные - это n, унарная строка, и b, унарная строка. Выход представляет собой одинарную строку.

u это "1".

v равно "0000" или G (0)

e это "000".

С

(С извинениями перед Дарреном Стоуном)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64-значный номер (9 ...)

L = 100 символов кода

оценка ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[Score = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)]

Обратите внимание, что я заслуживаю того, чтобы меня безжалостно пороли за этот ответ, но не удержался. Я не рекомендую вести себя как я на stackexchange по очевидным причинам. :-П

РЕДАКТИРОВАТЬ: было бы еще сложнее противостоять искушению пойти с чем-то вроде

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

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

Новый Рубин: оценка ~ f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

где f _α (n) - быстро растущая иерархия.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

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

Это *nпросто умножение строк и массивов, поэтому они должны быть в порядке.

Ungolfed код:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

где b.-b<=>0возвращает целое число, которое 1ближе к 0чем b.

Объяснение:

Он печатается nв начале каждого вызова H.

H[[]]двойники n( nраз), то есть n = n<<n.

H[[0,a,b,c,...,z]]звонки H[[a,b,c,...,z]]( nраз).

H[[k+1,a,b,c,...,z]]звонки H[[k]*n+[a,b,c,...,z]]( nраз), где [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]звонки H[[n]*n+[a,b,c,...,z]]( nраз).

H[[-(k+1),a,b,c,...,z]]звонки H[[-k]*n+[a,b,c,...,z]]( nраз).

H[k] = H[[k]],

Моя программа инициализируется n = 126, затем вызывает H[-n-1]126 ² 2 ¹²⁶ раз.

Примеры:

H[[0]]позвонит, H[[]]который применяется n = n<<n( nраз).

H[[0,0]]позвоню H[[0]]( nраз).

H[[1]]позвоню H[[0]*n]( nраз).

H[[-1]]позвоню H[[n]*n]( nраз).

H[[-1,-1]]позвоню H[[n]*n+[-1]]( nраз).

H[[-3]]позвоню H[[-2]*n]( nраз).

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

Смотрите редакции для других интересных вещей.

Haskell - функция Аккермана, примененная к его результату 20 раз - 99 символов

Это лучшее решение для haskell, которое я могу придумать на основе функции ackermann - вы можете заметить некоторые сходства с решением nm, отсюда i = round $ log pi, а остальное совпадение: D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Она запускает функцию ackermann сама по себе 20 раз, начиная с одной, последовательность

• 1,
• 3,
• 61,
• а (61,61),
• a (a (61,61), a (61,61)) --- мы будем называть это ₂ (61) или ₄ (1) ---
• а ₃ (61)
• ...
• ₁₈ (61), или ₂₀ (1). Я думаю, что это примерно г ₁₈ (см. Ниже).

Что касается оценки, википедия говорит:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

Отсюда видно, что a3 (1) = a (61,61) = 2 ⁵⁹ 64 + 3, что явно больше, чем g1 = 3 ⁴ 3, если только 3 в начале не намного важнее, чем я думаю. После этого каждый уровень выполняет следующее (отбрасывая незначительные константы в _n ):

• g _n = 3 ^{_n g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Если они приблизительно эквивалентны, то a ₂₀ (1) ~ = g ₁₈ . Последний член в a _n , (a _n-1 ) намного больше, чем 3, поэтому он потенциально выше, чем g ₁₈ . Я посмотрю, смогу ли я выяснить, увеличит ли это хотя бы одну итерацию и доложит.

машинный код x86 - 100 байт (собран в виде файла MSDOS .com)

Примечание: может немного изменить правила

Эта программа выведет 2 ^{(65536 * 8 + 32)} девятки, которые поставят счет в (10 ^{2 524320} -1) / 1000000

В качестве счетчика эта программа использует весь стек (64 кБ) плюс два 16-битных регистра

Собранный код:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Монтаж:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

С

Размер файла составляет 45 байт.

Программа является:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

И полученное число больше 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Файл, на который я перенаправил std out, в настоящее время превышает 16 Гб и продолжает расти.

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

Мой счет не вычислим с плавающей запятой двойной точности.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 в любой разумной системе. SHLVL - это небольшое положительное целое число (обычно 1 или 2 в зависимости от того, является ли / bin / sh bash или нет).

Только 64-битная UNIX:

Оценка: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

С, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

Мы создаем массив из 258048 целых чисел без знака. Это не может быть неподписанным longs, потому что это делает программу слишком длинной. Они не подписаны, потому что я не хочу использовать неопределенное поведение, этот код является правильным C (кроме отсутствия возврата из main ()) и будет компилироваться и запускаться на любой нормальной машине, хотя он будет работать долго , Этот размер является самым большим, который мы можем выразить юридически без использования символов, отличных от ascii.

Мы перебираем массив, начиная с последнего элемента. Мы печатаем цифры 2^32-1, увеличиваем элемент и сбрасываем цикл, если элемент не обернут в 0. Таким образом, мы будем повторять (2^32 - 1)^254048 = 2^8257536циклы, печатая 10 цифр каждый раз.

Вот пример кода, который показывает принцип в более ограниченном диапазоне данных:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

Результат равен примерно 10 ^ 10 ^ 2485766, разделенному на миллион, что по-прежнему примерно 10 ^ 10 ^ 2485766.

Powershell (2,53e107976 / 72³ = 6,78e107970 ≈ 10 ↑↑ 1,701853371)

Это займет гораздо больше, чем 5 секунд, чтобы бежать.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Он извлекает и объединяет длину в байтах каждого файла на вашем текущем диске. Regex удаляет любые нецифровые символы.

Python 3, оценка = подтверждение (126 126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

Функция f - это функция ackermann, которой у меня достаточно места для вызова.

Изменить: ранее "иначе n + 1", который был в нарушение правил вызова - слава просто красивому искусству.

JavaScript 98 символов

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

генерирует 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Для оценки чуть более 2.718e + 239622331 ≈ 10 ↑↑ 2.9232195197

это самое большое, что я могу сделать без сбоя браузера.

(console.log (a) покажет вам полный вывод)

Не запускайте это:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

выдаст 2,718 + e121333054704 ≈ 10 ↑↑ 3,0189898069 (он же 2,718 * 10 ^ (1,213 * 10 ^ 12) для сравнения с более длинным ответом:

более экстремальная версия, если она не сломала ваш браузер: (80 символов)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

что бы создать число примерно того же размера, что и e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Изменить: обновленный код оригинальное решение только генерируется 2.718e + 464

Python 3: 98 символов, ≈ 10 ↑↑ 256

Используя функцию с переменным аргументом:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

По сути, E уменьшает первый аргумент, увеличивая остальные аргументы, за исключением того, что вместо ввода -1 в аргументах он отбрасывает аргумент. Поскольку каждый цикл либо уменьшает первый аргумент, либо уменьшает количество аргументов, это гарантированно завершится. Используется возрастающая функция int ("% d% d"% (k, k)), которая дает результат от k ** 2 + 2 * k до 10 * k ** 2 + k. Мой код использует символ * - но не для умножения. Он используется для работы с переменным числом аргументов, что, я думаю, должно следовать правилам, поскольку ясной целью правил было ограничение конкретных операций, а не самих символов.

Некоторые примеры того, как быстро увеличивается размер E:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Только первые два из них могут быть запущены на моем компьютере в разумные сроки.

Затем E вызывается E(*range(ord('~')))- что означает:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

Я не совсем уверен, насколько он велик (я пытался приблизиться к нему безрезультатно), но очевидно, что он ~ действительно ~ большой.

Например, около двенадцати циклов, результат примерно: (технически немного больше, чем)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Оценка результата:

Если аппроксимировать увеличение шаг за шагом lambda k: 10 * k**2, функция может быть описана как

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

Соответствующее, что мы делаем здесь, - это построение башни из десяти сил, поэтому конечный счет может быть приблизительно равен 10 ↑↑ 256.

Лучшая (хотя и частичная) оценка результата:

Это использует то же самое 10 * k**2как другая оценка.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

По предыдущей оценке это будет:

E(a, b) = 10**(a**2/a) * b**(2*a)

Который значительно меньше, чем фактическое значение, поскольку он использует a**2вместо 2**a10 и использует a*2вместо 2**aдля б.

C (оценка ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3.005558275)

• Выход ~ 20 ГБ
• 41 символ (41 ^ 3 ничего не значит)

main(){for(;rand();printf("%d",rand()));}

Несмотря на то, rand()что результат является детерминированным, потому что нет функции начального числа.