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

113

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

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

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

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

Leaderboard

  1. Стивен Х. , Пайт ≈ f φ (1,0,0) +7 (256 26 ) / 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, 20 (1) / 99 3 [1]
  9. Fraxtil , dc, ≈ 15 ¹⁶⁶⁶⁶⁶⁵ ¹⁶⁶⁶⁶⁶⁵ 15/100 3 [3]
  10. Пурпурный , Python, ≈ ack (126 126) / 100 3 ≈ 10 ↑ 124 129
  11. Кендалл Фрей , ECMAScript 6, ≈ 10 3 ↑ 4 3 /100 3 [1]
  12. Илмари Karonen , GolfScript, ≈ 10 ↑ 3 10 377 /18 3 [1]
  13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 3
  14. рекурсивный , Python, ≈ 2↑↑ 11/95 3 ≈ 10 ↑↑ 8,63297 [1] [3]
  15. нм , Haskell, ≈ 2↑↑ 7/100 3 ≈ 10 ↑↑ 4,63297 [1]
  16. Дэвид рыскания , C ≈ 10 10 4 × 10 22 /83 3 ≈ 10 ↑↑ 4,11821 [2]
  17. Primo , Perl ≈ 10 (+12750684161!) 5 × 2 27 /100 3 ≈ 10 ↑↑ 4,11369
  18. Искусство , C ≈ 10 10 2 × 10 6 /98 3 ≈ 10 ↑↑ 3,80587
  19. Роберт Сёрли , x86, ≈ 10 2 2 19 +32 / 100 3 ≈ 10 ↑↑ 3.71585
  20. Тобия , АПЗ, ≈ 10 10 353 /100 3 ≈ 10 ↑↑ 3,40616
  21. Даррен Стоун , C, ≈ 10 10 97.61735 / 98 3 ≈ 10 ↑↑ 3.29875
  22. ecksemmess , C ≈ 10 2 320 на / 100 3 ≈ 10 ↑↑ 3,29749
  23. Адам Спейт , vb.net, ≈ 10 5000 × (2 64 ) 4 /100 3 ≈ 10 ↑↑ 3,28039
  24. Джошуа , удар, ≈ 10 10 15 /86 3 ≈ 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))

Vereos
источник
16
Кто-то прямо сказал «база 10»?
Кешлам
1
Считается ли большое число, если оно сказано 12e10(12 * 10 ^ 10) как 12*10^10?
hichris123
4
Я думаю, что лучшим ограничением вместо запрета *, / и ^ было бы разрешение только линейных операций, например +, -, ++, -, + =, - = и т. Д. В противном случае кодеры могут воспользоваться библиотеки стрелок вверх / Аккермана Кнута, если они доступны на выбранном ими языке, что кажется обманом.
Эндрю Чонг
14
Я все еще жду, чтобы кто-нибудь заработал сноску [4].
Брайан Минтон
1
Скажите, если моя программа печатает 500b, это неверно? То есть можем ли мы игнорировать все нечисловые элементы, которые печатает программа? И если да, то будет ли что-то подобное 50r7считаться 507?
Просто Красивое Искусство

Ответы:

20

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

Питер Тейлор
источник
Если я не ошибаюсь, число, которое вычисляет ваша программа (назовите его n), можно записать как n = f ^ 9 (g (3)), где f (x) = g ^ (4x) (x) и g ( х) время жизни червя [х]. Если мы будем рассматривать g как то же самое, что и f_eps_0 в быстро растущей иерархии, то мои расчеты «за пределами конверта» показывают, что f_ (eps_0 + 2) (9) <n <f_ (eps_0 + 2) (10 ). Конечно, это текущий победитель - безусловно.
Рез
@res, я думаю, что это сильно недооценивает. .{foo}*карты xдля foo^x (x). Если мы возьмем, h_0 (x) = g^4 (x)а h_{i+1} (x) = h_i^x (x)затем значение рассчитывается h_9 (g(3)). Ваш f(x) = g^(4x) (x) = h_0^x (x) = h_1 (x).
Питер Тейлор
(Это относится к вашей исходной программе - я только что видел, что вы внесли некоторые изменения.) Оооо ... Я неправильно понял, как *работает. Можно с уверенностью сказать, что h_0 (x) = g ^ 4 (x) >> f_eps_0 (x); следовательно, отношение h_ {i + 1} (x) = h_i ^ x (x) эффективно определяет «ускоренную» быстрорастущую иерархию, такую ​​что h_i (x) >> f_ (eps_0 + i) (x). Т.е. вычисленное число h_9 (g (3)), безусловно, намного больше, чем f_ (eps_0 + 9) (g (3)). Что касается g (3), я думаю, что могу показать, что он больше, чем g_4, четвертое число в последовательности g_i, используемое для определения числа Грэма (то есть g_64).
Рез
@res, так j_i ~ f_{eps_0 + i}; это делает k_i ~ f_{eps_0 + i omega + i^2}?
Питер Тейлор
Учитывая, что вы написали, я получаю k_i ~ f_{ε_0 + ω}^i (k_0). Вот причина: k_ {i + 1} = j_ {k_i} (k_i) = j_ω (k_i) ~ f_ {ε_0 + ω} (k_i) ~ f_ {ε_0 + ω} ^ 2 (k_ {i-1}) ... ~ f_ {ε_0 + ω} ^ {i + 1} (k_0), поэтому k_i ~ f_ {ε_0 + ω} ^ i (k_0). Тогда получается очень консервативная нижняя граница k_i, полностью в терминах быстрорастущей иерархии k_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i).
Res
91

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

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

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

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

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

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

Hand-E-Food
источник
19
Чистый настоящий гений!
WallyWest
7
Я думаю, что вы должны кубизировать длину решения, в которой я получаю около 321 баллаYour printed number will be divided for the number of bytes you used for your solution^3.
Cruncher
1
77 голосов, и все же ... Я отмечаю, что счет 321 ...
Просто Красивое Искусство
3
@SimplyBeautifulArt, это не оценка, а путешествие. :-D
Hand-E-Food
4
Видимо так, тот, который заставил многих посмеяться. Теперь, если бы только мы могли получить это в таблице лидеров ... кто-то должен заработать тег "непоправимый ущерб";)
Simply Beautiful Art
87

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

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

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

'~'(

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

'~'(.`*

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

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

'~'(.`*.~*

Вы никогда не увидите, чтобы эта программа завершилась, поскольку она пытается вычислить число с примерно 10 380 ≈ 2 1140 цифрами. Ни один когда-либо созданный компьютер не мог хранить такое большое число, и при этом не мог бы быть построен такой компьютер, используя известную физику; число атомов в наблюдаемой Вселенной оценивается приблизительно 10 80 , так что даже если бы мы могли каким - то образом использовать всю материю во Вселенной , чтобы сохранить это огромное количество, мы бы до сих пор как - то втиснуть около 10 +380 / 10 80 = 10 300 цифр в каждый атом!

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

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

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

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

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

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

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

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

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

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

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

Илмари Каронен
источник
9
"...No computer ever built could store a number that big...Поправьте меня, если я ошибаюсь, но я не думаю, что это применимо здесь. Разве это не просто многократно «хранить» и печатать 3 цифры за раз (?), Поэтому нет необходимости сохранять конечный результат.
Кевин Феган
12
@KevinFegan: Это правда - число невероятно повторяющееся, поэтому его будет легко сжать. Но тогда мы больше не храним само число, а скорее некоторую абстрактную формулу, из которой теоретически можно вычислить число; действительно, одна из самых компактных таких формул - это, вероятно, приведенная выше программа GolfScript, которая ее генерирует. Кроме того, если мы сделаем еще один шаг к следующей программе, даже «печать» цифр по одной перед тем, как их выбросить, становится непрактичной - просто не существует никакого известного способа выполнить такое множество этапов классических вычислений во вселенной.
Ильмари Каронен
GolfScript @ IlmariKaronen только что дал Googol клин!
WallyWest
5
Как насчет того, чтобы довести это до предела, посмотреть, насколько точно вы можете сделать это в GolfScript за 100 символов? На самом деле ваш результат меньше числа Грэма (которое «приближает» моё решение на Haskell ), но, как вы говорите, GolfScript, вероятно, может пойти еще дальше.
перестал поворачивать против часовой стрелки
3
@leftaroundabout: мне удалось написать оценщик обозначений стрелок Конвея в 80 символах GolfScript, хотя он не отвечает всем требованиям этой задачи (он использует числовые константы и арифметические операторы). Возможно, это можно улучшить, но я подумал, что могу представить это как новый вызов.
Илмари Каронен
42

JavaScript 44 символа

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

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

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

Уолли Уэст
источник
9
Правила не сгибаются вообще:;) * Невозможно использовать 0123456789 [check] * Используйте любой язык, на котором цифры являются действительными символами; [проверить] * Вы можете использовать математические / физические / и т.д. константы <10. [check, used 2] * Рекурсия разрешена, но сгенерированное число должно быть конечным; [проверить, нет рекурсии] Не могу использовать *, /, ^; [проверить] Ваша программа может выводить более одного числа; [проверить] Вы можете объединить строки; [проверить] Ваш код будет работать как есть; [проверить] Максимальная длина кода: 100 байт; [проверить] Необходимо прекратить w / i 5 сек. [проверить]
WallyWest
Избавьтесь от 2 символов, передав "."вместо них замену/\./g
gengkev
1
@gengkev К сожалению, только использование .replace (".", "") удаляет только первое. характер; Я должен использовать глобальную замену, чтобы заменить ВСЕ. символы из строки ...
WallyWest
Вы можете сделать m=Math,p=m.PI,e=m.E,s="",alert((p*p*p+s+e*e*e).replace(/\./g,s))вместо этого, ваш счет тогда 3100627668029981620085536923187664/63 ^ 3 = 1.240017943838551e + 28
AMK
1
@Cory С одной стороны, я не собираюсь повторять константу, иначе все бы ее использовали ... Во-вторых, у меня действительно нет второго аргумента ...
WallyWest
28

C, балл = 10 10 97,61735 / 98 3 ≈ 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 64 -1, повторяется (2 64 -1) 4 раза . Во-первых, вот как я оцениваю (низко) совокупное число цифр от 1 до 2 64 -1 («подпоследовательность»): последнее число в последовательности подпоследовательности составляет 2 64 -1 = 18446744073709551615с 20 цифрами. Таким образом, более 90% чисел в подпоследовательности (начинающихся с 1.. 9) имеют 19 цифр. Давайте предположим, что оставшиеся 10% в среднем 10 цифр. Это будет гораздо больше, но это низкая оценка для легкой математики и без обмана. Эта подпоследовательность повторяется (2 64 -1) 4 раза, поэтому длинаиз n будет не менее (0,9 × (2 64 -1) × 19 + 0,1 × (2 64 -1) × 10) × (2 64 -1) 4 = 3,86613 × 10 97 цифр. В комментариях ниже @primo подтверждает, что длина n равна 4.1433x10 97 . Таким образом, само n будет 10 к этой степени, или 10 10 97,61735 .

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

оценка = н / л 3 = 10 10 97,61735 / 98 3

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

Даррен Стоун
источник
2
В С 'z'это постоянная величина 122. Правильно?
Прим
1
Я думаю, printf("%d",n)что сделает число намного больше. Кроме того, 64-битный компьютер не означает 64-битную длину, например, Windows использует модель LLP64, так что длина по-прежнему составляет 32 бита
phuclv
3
это не должно иметь значения . Целочисленное переполнение со знаком - неопределенное поведение в C, поэтому невозможно предсказать, что произойдет, когда ваш код будет выполнен. Это может нарушить требование конечности.
Деннис
1
Я думаю, что анализ может быть немного не так. Длина конкатенации 0..2^64-1ровно 357823770363079921190. Повторное (2^64-1)^4время составляет 4.1433x10 ^ 97. Возьмем 10 к этой мощности 10^10^97.61735≈ 10 ↑↑ 3.29875. Я думаю, что вы претендуете на степень десяти, которой у вас нет (обратите внимание, где это 3.866×10^97стало 3.866^10^97.
Примо
2
Привет @ Примо. Спасибо, что нашли время, чтобы проверить это. Ценить это. Я понимаю, что вы говорите. Мой последний показатель неверен. Это должно быть 2.0вместо 97. 10^10^10^2.00= 10^10^97.6. Я буду отражать это в моем счете сейчас.
Даррен Стоун
19

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)мое число значительно больше , чем число Грэма.

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

Чел скеггс
источник
4
Выглядит отлично; по-видимому, ваш «модифицированный Аккерманн» - именно тот, кто оценивает цепочку Конвея .
перестал поворачиваться против часовой стрелки
1
@leftaroundabout Не совсем, но я думаю, что у него примерно такая же рекурсивная сила. Кроме того, нули недопустимы в цепочках, поэтому вам нужно будет сбросить ноль из цепочки Конвея в списке результатов.
Чел Скеггс,
1
Почему ты это сделал range(ord('~'))? Не могли бы вы сделать range(125)для меньшего количества байтов, что позволило бы вам сжать большее число, как range(A(9,9,9))?
Esolanging Fruit
1
@ Challenger5: правило 1 гласит: «Вы не можете использовать цифры в своем коде (0123456789)»
Cel Skeggs
@CelSkeggs: О, я забыл об этом.
Esolanging Fruit
18

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 2 (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

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

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

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

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

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

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

где

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


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

а также

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

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

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

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

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

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

Примо
источник
1
Таким образом, это будет правильным решением, только если номер версии остается ниже 10?
Мистер Листер
3
@MrLister Да. К счастью, не существует основной версии выше 6, и даже она не считается полностью «готовой», несмотря на то, что она была первоначально объявлена ​​в 2000 году.
primo
@primo Вы понимаете, что вам придется пересмотреть этот ответ, как только Perl перейдет на номер версии> 10, верно? ;)
WallyWest
3
@ Eliseod'Annunzio Если я все еще жив, когда наступит этот день - если вообще когда-нибудь - я обещаю вернуться и исправить это.
Прим
2
Текущее решение, которое превосходит 10 ↑↑ 4. Это поразительно. Браво!
Tobia
16

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 )
  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 15 10 15 ). Используя эквивалентности для конечных сумм , вышесказанное может быть явно выражено как

        введите описание изображения здесь

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

        введите описание изображения здесь

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

        введите описание изображения здесь

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

        введите описание изображения здесь

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

        введите описание изображения здесь

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

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

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

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

  1. 10 16
  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}
Эндрю Чонг
источник
Мои расчеты по поводу вашего счета основаны на наблюдении, которое fделает что-то вроде принятия числа zв свои руки . Это что-то вроде ↑↑↑. Конечно, оценка не 2↑↑↑2 извините ... больше похоже, 2↑↑↑5+1кажется. Согласитесь, я должен поставить это в таблицу лидеров?
перестал поворачиваться против часовой стрелки с
@leftaroundabout - Спасибо, что заглянули в него снова. Я не чувствую себя достаточно комфортно с нотацией со стрелкой вверх, чтобы сказать, правильно ли звучит ваше предложение, но я вычислил порядок величины моего балла (см. Редактирование), если вы хотите обновить таблицу лидеров с этим.
Эндрю Чонг
Отлично! Я не совсем тверд с стрелками вверх. Так что на самом деле у вас есть «только» башня силы; Боюсь, это ставит вас на два места ниже в рейтинге. Слава за правильный анализ результата; в моих оценках, возможно, еще больше недостатков, но я чувствовал, что кто-то должен хотя бы попытаться навести порядок в ответах.
перестал поворачиваться против часовой стрелки
1
Ваша оценка неверна. Всякий раз, когда вы начинаете цикл с i=o.z;while(i--)...вами, вы не выполняете время цикла o.z, потому что цикл основан на целочисленной переменной и o.zсодержит строку, превышающую наибольшее представимое целое число, в зависимости от размера слова вашего интерпретатора. Предположим, что ваш интерпретатор не прекратит преобразовывать такую ​​строку в int, iбудет начинать каждый раз с ее наибольшего представимого целочисленного значения, скажем, 2 ^ 63, а не с текущего значения o.z.
Тобия
2
@ acheong87 Не удаляйте себя, вы просто должны пересчитать свой счет, ограничив переменные цикла до 2 ^ 63 или около того. PS: оставьте свою аналитическую оценку здесь, это очень поучительно!
Tobia
14

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 44 цифры.

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

объяснение

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

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

Тобия
источник
Ваш напечатанный номер будет разделен на количество байтов, которые вы использовали для вашего решения ^ 3. Вы делите на 100 прямо сейчас.
ToastyMollows
2
@ToastyMallows - выглядит 100 cubed(100 ^ 3) для меня.
Кевин Феган
1
Я знаю, но это байты, а не символы.
ToastyMallows
1
@ToastyMallows Прочитайте примечания к ответу.
Просто Красивое Искусство
Изменение {⍞←⎕D}в ⍞←котором экономит вам три байта , которые вы можете использовать , чтобы добавить еще один ⍣nи сделать ⊢n←⍎⎕Dв ⌽⍕n←⍎⎕Dтечение 80-кратного увеличения. Если вы разрешите работать с, ⎕PP←17то используйте ×⍨вместо ⌽⍕которого почти удваивает количество напечатанных цифр.
Адам
12

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 секунд).

нм
источник
o=length[]!qв конце получает вас дополнительно и экономит на этом байты.
Хулдрасет на'Барья
9

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

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

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

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

рекурсивный
источник
Ваш код не работает. Только print True<<(True<<(True<<(True<<True<<True)))делает, и это выводит строку 19 КБ.
Гейб
Каковы эти минимальные системные требования?
Дунайский моряк
8
Не могли бы вы сделать его короче, определив, t=Trueа затем используя tпосле?
Боб
1
А еще лучше, просто сделайте цикл, который делает эти вложения для вас.
Просто Красивое Искусство
Это не для меня:$python -c 'print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))' Traceback (most recent call last): File "<string>", line 1, in <module> OverflowError: long int too large to convert to int
Брайан Минтон,
8

GolfScript 3.673e + 374

'~'(.`*

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

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

Бен Райх
источник
7

Рубин, вероятностно бесконечный, 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.

histocrat
источник
3
это зависит от генератора чисел, который на большинстве языков вряд ли сможет сгенерировать в 97 раз больше числа
трещотка урод
1
Хороший вопрос, поэтому в дополнение к предположению о непрерывно быстро растущей вычислительной мощности, мне также нужно предположить идеальный источник случайности и реализацию Ruby, которая его использует.
гистократ
7

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

Рез
источник
'',:o;'oo',:t;просто присваивает значения 0к oи 2к t; если это просто для обхода недостатка цифр, то его можно сильно сократить ,:o)):t;, за исключением того, что tв первую очередь нет причин его удалять, потому что вы можете написать expr:t;{...}:f;[[[t]f]f]fкак [[[expr:t]{...}:f~]f]fсохранение еще 3 символов.
Питер Тейлор
По-прежнему не нужно всплывать o: я уверен, что [0 126]fон будет больше, чем [126]fвы, поэтому вы сохраняете символ и увеличиваете результат. Несмотря на то, что вы оставляете там пустую строку, которая, вероятно, ломает вещи: может быть, лучше начать[[,:o'~'=]
Питер Тейлор
Да, и [они не нужны, так как в стеке больше ничего нет.
Питер Тейлор
Ха ... прокручивая эти ответы, и тогда я вижу это ... и затем я замечаю принятый ответ ... хм ......
Просто Красивое Искусство
@SimplyBeautifulArt Я не уверен, что вы имеете в виду, но принятый ответ вычисляет намного большее число, чем этот (при условии, что оба соответствуют заявленным).
Рез
7

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. Я не уверен, насколько это повлияет на конечный результат, но сейчас, вероятно, он намного больше.

Fraxtil
источник
Я понятия не имею, что делает этот код ... могу только предположить, что он правильный. Возможно, вы могли бы немного объяснить?
перестал поворачиваться против часовой стрелки с
Я объясню код по частям, когда у меня будет время сегодня вечером.
Fraxtil
Ну, я остановился на этом объяснении, но я добавил его сейчас. Надеюсь, это прояснит ситуацию.
Fraxtil
DC-1.06.95-2 немедленно прекращает работу, ничего не печатая.
Прим
1
Я не ожидал, что он будет работать на любой существующей машине, учитывая величину стоимости, которую он будет пытаться сгенерировать. У меня такая же версия dc, и через несколько секунд она перестала работать. Я предполагаю, что «теоретически правильные» ответы разрешены здесь, поскольку нет никаких критериев для потребления ресурсов.
Fraxtil
6

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

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

Оба решения используют 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 64 -1) 2 64 . Это суммирование меньше, чем (2 64 ) 2 64 , и мне нужна степень два, чтобы сделать этот расчет. Поэтому я вычислю (2 64 ) 2 64 -1 . Это меньше, чем реальный результат, но так как это степень двойки, я могу преобразовать ее в степень 10 для сравнения с другими результатами.

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

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

Дэвид Йо
источник
Может быть. %uпечатал 32-битные числа даже с 64-битной компиляцией, поэтому я просто llвыучился писать 32-битный компилятор.
Дэвид Йо
Я думаю, что %lluбыло бы long long, и %luбудет правильным для long.
Tomlogic
Исправлена. Сила привычки: %uвсегда 32-битная, %lluвсегда 64-битная, компилируемая как 32-битная или 64-битная. Однако решение здесь требует, чтобы он longбыл 64-битным, так что вы правы, %luдостаточно.
Дэвид Йо
Ваши переменные в стеке не обязательно будут инициализированы равными 0. Во второй программе просто поместите их вне какой-либо функции. В первом вам придется инициализировать i.
Art
Кроме того, длинное переполнение - это неопределенное поведение, и многие современные компиляторы просто его оптимизируют, если обнаружат, вы, вероятно, захотите использовать unsigned long.
Art
5

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

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

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

403624169270483442010614603558397222347416148937479386587122217348........
lebatsnok
источник
2
Я не думаю, что вам нужно указывать номер в сообщении. Он также занимает много места на мобильных устройствах.
полностью человек
@totallyhuman Я согласен, возможно, первые 100 цифр, максимум
tuskiomi
@totallyhuman хорошо, спасибо, сделано :)
lebatsnok
catэто странно функция в том , что первый аргумент .... Таким образом, все до первого именованного аргумента отправляется ...(и будет cat'ed), поэтому sepдолжно быть названо - в противном случае его можно сократить какcat(abs(.Random.seed),,"")
lebatsnok
5

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 ↑ n b, где a неявно 3. Входные данные - это n, унарная строка, и b, унарная строка. Выход представляет собой одинарную строку.

u это "1".

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

e это "000".

Кендалл Фрей
источник
Maximum code length is 100 bytes;В противном случае это почти непобедимо
Cruncher
@Cruncher Ааа, я пропустил это
Кендалл Фрей
Ах, я ненавижу тебя сейчас. Каждый раз, когда я пытаюсь понять размер числа Грэма, у меня болит голова.
Cruncher
Кроме того, число Грэма не считается постоянной> 10?
serakfalcon
1
Теперь, чтобы определить, бьет ли мой Илмари.
Кендалл Фрей,
5

С

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

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');}

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

ecksemmess
источник
1
#DEFINE C while (- long n, o, p, q, r, s, t; main () {Cn) {Co) {Cp) {Cq) {Cr {Cs {Ct) {putchar ('z' -'A ');}}}}}}}}
RobAu
@RobAu Ты гений! Сделай это ответом. Я уверен, что это будет победителем. Я думаю, что вы забыли пару ), но ничего страшного, потому что сейчас у вас всего 96 символов.
Эндрю Ларссон
Для всех, кто не получил сарказм: см. Codegolf.stackexchange.com/a/18060/7021 для еще лучшего решения;)
RobAu
5

Новый Рубин: оценка ~ f ω ω2 +1 (126 2 2 126 )

где 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 2 126 раз.


Примеры:

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раз).

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


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

Просто Красивое Искусство
источник
Это на самом деле 103 байта, я думаю, у вас был завершающий перевод строки.
Rɪᴋᴇʀ
@Riker Я думаю, ты скопировал и вставил отсюда. Обратите внимание, что во второй строке должен быть непечатаемый символ, следовательно, 104 байта.
Просто Красивое Искусство
@SimplyBeautifulArt ах, ладно. Я думал, что скопировал персонаж. Сожалею.
Rɪᴋᴇʀ
@Riker Нет, его даже нет, потому что Stackexchange не позволяет мне прятать невидимых персонажей повсюду.
Просто Красивое Искусство
4

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)) --- мы будем называть это 2 (61) или 4 (1) ---
  • а 3 (61)
  • ...
  • 18 (61), или 20 (1). Я думаю, что это примерно г 18 (см. Ниже).

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

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

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

  • g n = 3 n g n-1 3
  • a n ~ = 2 ↑ a n-1 (a n-1 )

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

Toeofdoom
источник
Ваш анализ правильный, и g <sub> 18 </ sub> - хорошее приближение.
Просто Красивое Искусство
length"a"сохраняет пару байтов и позволяет вам другой.a
Khuldraeseth na'Barya
4

машинный код 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'
Роберт Сёрли
источник
Вы, очевидно, никогда не запускали это. Он перезаписывает свой код и вылетает.
Джошуа
4

С

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

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

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

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

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

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

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

iWiggins
источник
4

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'
Джошуа
источник
SHLVL - это уровень bash как subbash:bash -c 'bash -c "echo \$SHLVL"'
F. Hauri
stat --printfне работает Попробуйтеstat -c %s
Ф. Хаури
@ F.Hauri: --printf работает для меня, но так -c так, что побрил несколько байтов. Благодарю.
Джошуа
4

С, 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.

Искусство
источник
Лучшая реализация C, безусловно. Зачем использовать 5 переменных, когда вы можете использовать массив 258048 ?
Примо
4

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

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

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

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

Hand-E-Food
источник
Правило 1 говорит, что цифры не допускаются, у вас есть 0там.
Кайл Канос
Блин, я тоже. Там идет мой счет персонажа.
Hand-E-Food
Вы можете использовать, -ea(+'')чтобы уменьшить размер ( ''преобразованный в число 0, значение которого равно enum SilentlyContinue). Вы можете использовать \Dдля замены регулярное выражение, которое совпадает с [^\d]. И вы можете просто использовать %{$_.Length}вместо select Lengthкоторого избавляется от заголовков столбцов. И затем вы можете избавиться от « -splitи» -replace, оставив вас на -join(gci \ -ea(+'')-r|%{$_.Length})37 символов короче (я также изменил порядок параметров, потому что скобки нужны в любом случае из-за +'').
Джои
4

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", который был в нарушение правил вызова - слава просто красивому искусству.

фуксин
источник
Вы можете увеличить свой номер, изменив f(m-g,g)на f(m-g,m).
Просто Красивое Искусство
или f(m-g,i). Кроме того, в конце первой строки вы используете номер. Я полагаю, что вы хотели использовать n+g, после чего я укажу, n+nбудет больше.
Просто Красивое Искусство
Вы можете сэкономить несколько байтов, изменив len ('' ') на True
Брайан Минтон
И используйте ord ('^?') (Где ^? Символ DEL, ASCII 127) для большего числа. Редактировать не берите в голову, это не "Для печати".
Брайан Минтон
@BrianMinton Кто сказал, что это должно быть напечатано?
Просто Красивое Искусство
4

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

serakfalcon
источник
3

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для б.

Чел скеггс
источник
Я оценил ваш результат, не стесняйтесь не соглашаться.
перестал поворачиваться против часовой стрелки с
Я должен не согласиться с этим результатом. Один момент, пока я печатаю свои рассуждения.
Чел Скеггс
Вот и мы. Как я сказал в обновлении, ваша оценка, по-видимому, значительно меньше, чем фактическая стоимость.
Чел Скеггс
Справедливо, но, во всяком случае, нам нужна рекурсивно-индуктивная / единовременная оценка, а не просто один шаг, чтобы включить этот ответ в список очков. Я уверен, что ваш результат лучше, чем у рекурсивного , но также уверен, что не лучше, чем у Ильмари Каронена (который в любом случае очень расширяем, используя только 18 символов), поэтому я думаю, что мои оценки достаточно хороши для цель забил.
перестал поворачиваться против часовой стрелки с
Я согласен. Я посмотрю, смогу ли я поработать над этим и, по крайней мере, придумать более точную нижнюю границу для результата.
Чел Скеггс
3

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

  • Выход ~ 20 ГБ
  • 41 символ (41 ^ 3 ничего не значит)
main(){for(;rand();printf("%d",rand()));}

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

ybeltukov
источник
Если вам не повезло, то ваша программа останавливается после одной итерации, и вызов rand()условия завершения делает ее недетерминированной. Кроме того, вызов rand()в каждой итерации должен сделать ее очень медленной. Вместо этого используйте что-то вроде LONG_MAXопределенного в limits.h.
klingt.net
Хорошо, я беру non deterministicобратно, потому что нет такого семени, как ты написал.
klingt.net
1
Как насчет ~' 'того rand(), чтобы печатать %u? На два байта меньше исходного и более высокое значение.
MSalters