Ваша цель - вывести (на стандартный вывод) максимально возможное число, используя всего десять символов кода.

• Вы можете использовать любые функции вашего языка, кроме встроенных функций возведения в степень.
  • Точно так же вы не можете использовать научную запись для ввода числа. (Таким образом, нет 9e+99.)
• Программа должна распечатать номер без какого-либо ввода от пользователя. Точно так же нет чтения из других файлов или из Интернета, и так далее.
• Ваша программа должна рассчитать одно число и распечатать его. Вы не можете напечатать строку, и вы не можете напечатать одну и ту же цифру тысячи раз.
• Вы можете исключить из ограничения в 10 символов любой код, необходимый для печати чего-либо. Например, в Python 2, который использует print xсинтаксис, вы можете использовать до 16 символов для вашей программы.
• Программа должна на самом деле преуспеть в выводе. Если запуск на самом быстром компьютере в мире занимает больше часа, он недействителен.
• Вывод может быть в любом формате (чтобы вы могли печатать 999, 5e+100и т. Д.)
• Бесконечность - это абстрактное понятие , а не число. Так что это неверный вывод.

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =

Вывод в обозначении стрелки.

Perl,> 1,96835797883262e + 18

time*time

Не может быть самым большим ответом ... сегодня! Но подождите достаточно тысячелетий и так будет!

Чтобы ответить на некоторые комментарии, под «достаточным количеством тысячелетий» я на самом деле имею в виду n ¹⁰⁰ лет.

Справедливости ради следует отметить, что если смерть вселенной из-за заморозков и жары закончит существование вселенной (по оценкам, произойдет ~ 10 ¹⁰⁰ лет), то «окончательное» значение будет ~ 10 ²¹⁴ , что, безусловно, намного меньше, чем некоторые из другие ответы (хотя, «случайные квантовые флуктуации или квантовое туннелирование могут произвести другой Большой Взрыв через 10 ^{10 56} лет»). Если мы выберем более оптимистичный подход (например, циклическую или мультивселенную модель), тогда время будет бесконечно, и когда-нибудь в какой-то вселенной, в какой-то высокобитовой архитектуре, ответ будет превосходить некоторые другие.

С другой стороны, как указывалось, timeдействительно ограничено размером целое / длинное, поэтому в действительности что-то вроде ~0всегда будет производить большее число, чем time(то есть максимальное, timeподдерживаемое архитектурой).

Это был не самый серьезный ответ, но, надеюсь, вам, ребята, понравилось!

Вольфрам ≅ 2.003529930 × 10 ¹⁹⁷²⁸

Да, это язык! Он управляет бэк-эндом популярного сайта Wolfram Alpha. Это единственный язык, который я нашел, где функция Аккермана встроена и сокращена до 6 символов.

В восьми символах:

$ ack(4,2)

200352993...719156733

Или 00 2,003529930 × 10 ¹⁹⁷²⁸

ack(4,3)и ack(5,2)т. д. намного больше, но слишком велико. ack(4,2)это, вероятно, самое большое число Аккермана, которое может быть полностью рассчитано менее чем за час.

Большие числа отображаются в символической форме, например:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

Правила говорят, что любой выходной формат разрешен, так что это может быть допустимым. Это больше, чем 10 ^{10 19727} , что больше, чем любая другая запись здесь, за исключением повторного факториала.

Тем не мение,

$ ack(9,9)

2↑⁷12 - 3

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

$ ack(99,99)

2↑⁹⁷102 - 3

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

Оболочка Python2, 3,010,301 цифр

9<<9999999

Вычисление длины: Python добавит «L» к этим длинным числам, поэтому он сообщает на 1 символ больше, чем результат содержит цифры.

>>> len(repr( 9<<9999999 ))
3010302

Первые и последние 20 цифр:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^{268 435 457}

A28{_*}*K*

Это вычисляет b , определенный следующим образом:

• ₀ = 10

• a _n = a _{n - 1} ²

• b = 20 × ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Фон

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

Тем не менее, предложение aditsu перейти на Java 8 и моя идея об использовании степеней 10 позволили CJam вычислять числа вне досягаемости GolfScript, что, по-видимому, связано с некоторыми ошибками / ограничениями Ruby's Bignum.

Как это устроено

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, ≈ 8,1 × 10 ^1,826,751

KK,{)*_*}/

Занимает меньше пяти минут на моей машине, так что еще есть возможности для улучшения.

Это вычисляет ₂₀ , определенное следующим образом:

• ₀ = 20

• a _n = (n × a _{n - 1} ) ²

Как это устроено

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18 100 795 813

9 * 2 ^ (2 ^ 35)> 10 ^ 10 343 311 894

Изменить: мой новый ответ:

9<<(7<<33)

Старый ответ для потомков:

9<<(1<<35)

Десять символов точно.

Я печатаю число в шестнадцатеричном виде, и

Вы можете исключить из ограничения в 10 символов любой код, необходимый для печати чего-либо. Например, в Python 2, который использует синтаксис print x, вы можете использовать до 16 символов для вашей программы.

Поэтому мой настоящий код:

print(hex(9<<(7<<33)))

Доказательство того, что он работает в указанное время и генерирует число указанного размера:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

Мой номер> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

-Меньше шестнадцатеричные цифры , чем выше туалет распечатки из - за начальными 0x9.

Python 3 необходим, потому что в python 2 7<<33он будет длинным и <<не будет длинным в качестве входных данных.

Я не могу использовать 9 << (1 << 36) вместо этого, потому что:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Таким образом, это самое большое количество возможных форм для a<<(b<<cd)печати на моем компьютере.

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

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

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

Любой язык с достаточно короткими именами констант, ок.

99/sin(PI)

Я бы опубликовал это как ответ PHP, но, к сожалению, M_PIслишком долго! Но PHP дает 8.0839634798317E + 17 для этого. В основном, это злоупотребляет отсутствием абсолютной точности в PI: p

Haskell

Без всяких хитростей:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Возможно, ничего не вычисляя:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Приспосабливая ответ Ниета :

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Умножает на 99 Пебибайт на 9 000 000 000 Пебибайт.

J ( ((((((((9)!)!)!)!)!)!)!)!)

Да, это много. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))быть не очень точным.

!!!!!!!!9x

K / Kona : 8,977649e261 1,774896e308

*/1.6+!170

• !170 создает вектор чисел от 0 до 169
• 1.6+ добавляет один к каждому элементу вектора и преобразует в реалы (диапазон от 1,6 до 170,6)
• */ умножает каждый элемент массива вместе

Если бы Kona поддерживал четкую четкость, я мог бы сделать */9.+!999и обойти 1e2584. К сожалению, это не так, и я ограничен двойной точностью.

старый метод

*/9.*9+!99

• !99 создает вектор чисел от 0 до 98
• 9+ добавляет 9 к каждому элементу вектора (теперь в диапазоне от 9 до 107)
• 9.* умножает каждый элемент на 9,0 (неявно преобразуя в реалы, т.е. с 81,0 до 963,0)
• */ умножает каждый элемент вектора вместе

HTML, 9999999999

9999999999

.. Успешно справился.

Python - Варьируется, до 13916486568675240 (пока)

Не совсем серьезно, но я подумал, что это будет забавно.

print id(len)*99

Из всех вещей, которые я пробовал, lenнаиболее последовательно получал большие идентификаторы.

Получил 13916486568675240 (17 цифр) на моем компьютере и 13842722750490216 (также 17 цифр) на этом сайте . Я полагаю, что это может дать вам 0, но оно также может повыситься.

Golfscript, 1e + 33,554,432

10{.*}25*

Вычисления 10 ^ (2 ^ 25)без использования показателей выполняются за 96 секунд:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

Он может вычислять до 9 ^ (2 ^ 9999), если только дать достаточно времени, но при увеличении внутреннего показателя на единицу он занимает в три раза больше времени, поэтому предел в один час будет достигнут довольно скоро.

Пояснение :

Используя предыдущую версию с той же идеей:

8{.*}25*

Разбивая это:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

Стек в начале каждого блока состоит из одного номера, текущего номера. Это начинается как 8. Затем:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

Таким образом, стек, шаг за шагом, выглядит так:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... и т. д. Написано в математической записи, прогрессия:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima ~ 3x10 ^{49 948} (или 10 8 ^{565 705 514} )

999*13511!

Выход

269146071053904674084357808139[49888 digits]000000000000000000000000000000

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

bfloat(99999999!)

Выход

9.9046265792229937372808210723818b8565705513

Это примерно 10 8 ^{565 705 514,} что значительно больше, чем у большинства популярных ответов, и было вычислено примерно за 2 секунды. bfloatФункция дает произвольную точность .

Хаскелл, 4950

Ой человек, это не много! 10 знаков начинаются после знака доллара.

main=putStr.show$sum[1..99]

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Десять символов точно.

Оболочка Python, 649539 999890001

Бьет Хаскелл, не очень серьезный ответ.

99999*9999

Wolfram Alpha (сайт считается языком)?

9! ! ! ! !

выходы

10^(10^(10^(10^(10^(6.27...))))

спасибо Кори за подсказку, что места работают так же, как и паренсы.

Befunge-93 (1,853,020,188,851,841)

Рад, что никто не сделал Befunge (это моя ниша), но, черт возьми, я не могу найти какой-нибудь хитрый прием, чтобы увеличить число.

9:*:*:*:*.

Так что это 9 ^ 16.

:*

В основном умножает значение в верхней части стека на себя. Итак, значение на вершине стека идет:

9
81
6561
43046721
1853020188851841

а также

.

Выводит окончательное значение. Мне было бы интересно узнать, есть ли у кого-нибудь лучшие идеи.

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

Python:

9<<(2<<29)

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

9<<(7<<27)

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

Matlab (1.7977e + 308)

Matlab хранит значение наибольшего (двойной точности) числа с плавающей точкой в ​​переменной с именем realmax. Вызов его в командном окне (или в командной строке) печатает его значение:

>> realmax

ans =

  1.7977e+308

Питон, ок. 1.26e1388

9<<(9<<9L)

дает:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

По крайней мере, Python 3.5.0 (64-разрядный), более 10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

В идеальном мире это было бы 9<<(1<<63)-1, но для этого недостаточно байтов. Это число настолько велико, что для его хранения требуется почти 1 EiB памяти, что немного больше, чем у меня на компьютере. К счастью, вам нужно всего лишь около 0,2% мирового хранилища для обмена. За двоичным значением 1001следуют 8070450532247928832 нуля.

Если Python выйдет для 128-битных машин, максимум будет 9<<(9<<99), что требует менее 1 МБ памяти. Это хорошо, потому что у вас будет достаточно адресуемого пространства для хранения интерпретатора Python и операционной системы.

Cubix , 9.670457478596419e + 147 (не конкурирует)

****"///**

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

Как это устроено

Cubix - это двумерный esolang, где код оборачивается вокруг куба. Этот код в точности эквивалентен следующей сети кубов, где .нет операции:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Затем выполняется код, указатель инструкции (IP) начинается в верхнем левом углу самой левой грани и направлен вправо. "включает строковый режим, в котором все встречающиеся символы до следующего "помещают свои кодовые символы в стек. IP полностью оборачивает код, помещая три /s (47), два *s (42) и два .s (46) в стек, прежде чем снова выйти из строкового режима.

Вот где это становится интересным. Первое зеркало /отражает IP, поэтому оно обращено вверх; затем он вращается вокруг куба, ударяя эти символы:

           
    * *
  /     *      
  .     .      
    . .

Три *с умножают два верхних элемента в стеке. Теперь, в отличие от большинства основанных на стеке языков, где арифметические операторы выводят свои аргументы, Cubix оставляет предыдущие значения в стеке. Так что это означает, что это рассчитывает 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Когда IP /снова достигает , он поворачивается направо. Затем он попадает в следующее зеркало и следует по этому пути:

    *  
    *  
    /         .
    .         .
    .  
    .  

Две звездочки умножают два верхних элемента еще раз. Затем зеркало снова направляет IP-адрес, а третье зеркало повторяет процесс еще раз:

      *
      *
      /     .  
      .     .  
      .
      .

Наконец, IP покидает раздел зеркала, направляясь на восток. Две финальные звездочки умножаются еще два раза, оставляя результат 9,670457478596419e + 147 в стеке. Это может быть напечатано с помощью O, но нет простого способа сделать это, так как практически каждое место на кубе уже используется.

Скала, 2 ⁶³ -1

Бедная, бедная Скала. Требуется не менее 8 символов, чтобы получить BigIntзначение, которое не оставляет достаточно места, чтобы его увеличить.

Но с помощью всего 7 символов (подсчитанного) кода мы можем вывести максимально возможный положительный результат Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Если вы игнорируете тот факт, что большинство компиляторов и интерпретаторов выводят данные как эквивалентные ascii (будьте осторожны, это то, чем они являются;))} , это вернет максимальное значение типа данных интерпретатора / компилятора.

В некоторых системах это всего 256, хотя в некоторых (например, у меня) это максимальное значение 32-разрядного целого числа, то есть 2 147 483 647.

Редактировать:

-.

Напечатает то же самое в гораздо меньшем количестве символов

Perl, не конкурирующий

Я использую это для того, чтобы выделить немного знания Perl.

Perl не может конкурировать на этом, потому что у него нет встроенных bignums (конечно, вы можете загрузить библиотеку bignum).

Но то, что все знают, не совсем верно. Одна основная функция может обрабатывать большие числа.

packФормат wфактически может преобразовать любой размер натурального числа между основанием 10и основанием 128. Основное целое число 128, однако, представлено в виде строковых байтов. Битовая строка xxxxxxxyyyyyyyzzzzzzzстановится байтами: 1xxxxxxx 1yyyyyyy 0zzzzzzz(каждый байт начинается с 1, кроме последнего). И вы можете преобразовать такую ​​строку в базу 10 с распаковкой. Таким образом, вы можете написать код, как:

unpack w,~A x 4**4 .A

который дает:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

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

К сожалению, это слишком долго для предела этой задачи, и вы можете утверждать, что результат base 10 преобразуется в строку, прежде чем он становится результатом, поэтому выражение на самом деле не производит число. Но внутренне perl действительно делает необходимую арифметику для преобразования входных данных в базу 10, что я всегда считал довольно аккуратным.

TI-36 (не 84, 36), 10 байтов, ок. 9.999985426E99

Старые калькуляторы также могут быть запрограммированы;)

69!58.4376

Это очень близко к максимальному диапазону, который может отображать калькулятор TI:-1E100<x<1E100

Perl 6 , 456 574 цифры

[*] 1..ↈ

Нет TIO, потому что это занимает 2 минуты, чтобы бежать.