Ваша мета - надрукувати (до стандартного виводу) якомога більше число, використовуючи всього десять символів коду.

• Ви можете використовувати будь-які функції своєї мови, крім вбудованих функцій експоненції.
  • Так само ви не можете використовувати наукові позначення для введення числа. (Таким чином, ні 9e+99.)
• Програма повинна надрукувати номер без будь-якого введення користувачем. Аналогічно, жодне читання з інших файлів чи з Інтернету тощо.
• Ваша програма повинна обчислити єдине число та роздрукувати його. Ви не можете надрукувати рядок, а також не можете надрукувати одну і ту ж цифру тисячі разів.
• Ви можете виключити з обмеження 10 символів будь-який код, необхідний для друку будь-чого. Наприклад, у Python 2, який використовує print xсинтаксис, ви можете використовувати до 16 символів для вашої програми.
• Програма повинна насправді досягти успіху у виході. Якщо на найшвидшому в світі комп'ютері працює більше години, він недійсний.
• Вихід може бути в будь-якому форматі (так що ви можете роздрукувати 999, 5e+100і т.д.)
• Нескінченність - це абстрактне поняття , а не число. Тож це невірний вихід.

Вольфрамська мова

ack(9!,9!)

ак (9!, 9!) =

Вихід є в позначенні стрілки.

Perl,> 1.96835797883262e + 18

time*time

Можливо, це не найбільша відповідь ... сьогодні! Але чекайте достатньо тисячоліть, і це буде!

Для вирішення деяких коментарів "достатньо тисячоліть" я фактично маю на увазі п ^ять років.

Якщо чесно, якщо велика замерзання / теплова смерть Всесвіту закінчиться (за оцінками, відбудеться ~ 10 ¹⁰⁰ років), "остаточне" значення складе ~ 10 ²¹⁴ , що, безумовно, набагато менше, ніж деякі інші відповіді (хоча "випадкові квантові коливання або квантове тунелювання можуть призвести до іншого Великого вибуху за 10 ^{10 56} років"). Якщо ми скористаємося більш оптимістичним підходом (наприклад, циклічною або мультиверсійною моделлю), то час триватиме нескінченно, і тому якийсь день у якомусь Всесвіті, в якійсь бітовій архітектурі відповідь перевищить деякі інші.

З іншого боку, як вказувалося, timeнасправді обмежений розміром ціле / довге, тому насправді щось подібне ~0завжди дасть більше число, ніж time(тобто макс.time підтримуваний архітектурою).

Це була не найсерйозніша відповідь, але, сподіваюся, вам сподобалось!

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

Так, це мова! Він рухає задній план популярного сайту Wolfram Alpha. Це єдина мова, яку я знайшов, де функція Ackermann вбудована і скорочена до 6 символів.

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

$ ack(4,2)

200352993...719156733

Або ≅ 2,003529930 × 10 ^{19728 року}

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 , визначені наступним чином:

• a ₀ = 10

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

• b = 20 × a ₂₈

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

Фон

Це випливає з тієї ж ідеї, що і у відповіді Клавдіу , але вона не ґрунтується на ній. У мене була подібна ідея, яку я опублікував лише через кілька хвилин після того, як він опублікував свою , але я відкинув її, оскільки вона не дійшла ніде поблизу часового обмеження.

Однак пропозиція aditsu перейти на Java 8 та моя ідея використання повноважень 10 дозволили CJam обчислювати числа за межами досяжності GolfScript, що, мабуть, пояснюється деякими помилками / обмеженнями Bubum Ruby.

Як це працює

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,{)*_*}/

На моїй машині займає менше п'яти хвилин, тому вдосконалення ще є.

Це обчислює значення ₂₀ , яке визначається наступним чином:

• a ₀ = 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.                               ";
}/

Пітон 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 * журнал (16))> 10 ^ 18100795813

На 3 менші шістнадцяткові цифри, ніж вищевказаний розряд wc через початкові 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)

Однак моя сьогоднішня відповідь є найбільшим, хто хто подав, тож, мабуть, це досить добре. Крім того, це все припускаючи, що зміщення бітів допустимо. Здається, з інших відповідей, що використовують його.

Будь-яка мова з досить короткими постійними іменами, 18 цифр прибл.

99/sin(PI)

Я б опублікував це як відповідь PHP, але, на жаль, M_PIце робиться трохи занадто довго! Але PHP дає 8.0839634798317E + 17 для цього. В основному, він зловживає відсутністю абсолютної точності в PI: p

Хаскелл

Без жодних хитрощів:

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

К / Кона : 8.977649e261 1.774896e308

*/1.6+!170

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

Якби Кона підтримував квадратичну точність, я міг би зробити */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, але це також може вийти вище.

Гольфскрипт, 1е + 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 ^{855 705 554,} що значно більше, ніж більшість найкращих відповідей, і було обчислено приблизно за 2 секунди. bfloatФункція дає довільну точність .

Хаскелл, 4950

Aww man, це не багато! 10 символів починаються після знака долара.

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

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

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

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

Удар Haskell, насправді не серйозна відповідь.

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

і

.

Виводить кінцеве значення. Мені було б цікаво подивитися, чи є у когось кращі ідеї.

Я б краще розмістити це як коментар вище, але, мабуть, не можу, оскільки я ноб.

Пітон:

9<<(2<<29)

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

9<<(7<<27)

Єдина проблема з цим полягає в тому, що вони можуть не задовольняти правило 5.

Матлаб (1.7977е + 308)

Matlab зберігає значення найбільшого (подвійної точності) числа з плаваючою комою у змінній, що називається realmax. Викликаючи його у вікні команд (або в командному рядку), виводиться його значення:

>> realmax

ans =

  1.7977e+308

Пітон, бл. 1,26е1388

9<<(9<<9L)

Дає:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

Принаймні Python 3.5.0 (64-розрядна), більше 10 ^ 242944768872896860

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

В ідеальному світі це було б 9<<(1<<63)-1, але для цього недостатньо байтів. Це число настільки велике, що для його утримання потрібно майже 1 ЕБ пам'яті, що трохи більше, ніж у мене на комп’ютері. На щастя, вам потрібно використовувати лише 0,2% світового простору для зберігання, щоб утримувати його. Значення у двійковій 1001формі супроводжується 8070450532247928832 нулями.

Якщо Python вийде для 128-розрядних машин, максимум буде 9<<(9<<99), на що потрібно менше 1 МіГБ пам'яті. Це добре, тому що у вас буде достатньо адресного місця для зберігання інтерпретатора Python та операційної системи.

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

****"///**

Неконкурентований, тому що Cubix є новішим, ніж ця проблема. Ви можете перевірити його тут , але зауважте, що він насправді не друкує номер; Вам доведеться призупинити програму після *запуску двох останніх s, щоб побачити значення на стеку.

Як це працює

Cubix - двовимірний езоланг, де код обмотується навколо куба. Цей код точно еквівалентний наступній кубічній сітці, де .немає опціону:

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

Потім запускається код, при цьому вказівник інструкції (IP) починається з верхнього лівого кута крайньої лівої частини обличчя, зверненого праворуч. "вмикає рядовий режим, де всі зустрічаються символи до наступного "натискають свої char-коди на стек IP обертається навколо коду, натискаючи три /s (47), два *s (42) та два. s (46), перш ніж знову вийти з рядкового режиму.

Ось де це стає цікавим. Перше дзеркало /відображає IP, тому воно звернене вгору; Потім він обертається навколо куба, вражаючи ці знаки:

           
    * *
  /     *      
  .     .      
    . .

На три *s помножте два найкращих пункти на стеку. Тепер, на відміну від більшості мов на основі стека, де арифметичні оператори висувають свої аргументи, 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більші значення, поки не відчуєте, що це зайняло занадто багато часу або не зайняло занадто багато пам'яті.

На жаль, це занадто довго для межі цього завдання, і ви можете стверджувати, що результат 10 результату перетворюється на рядок, перш ніж він стає результатом, тому вираз насправді не дає числа. Але внутрішньо perl дійсно робить необхідну арифметику для перетворення вхідних даних у базу 10, що я завжди вважав досить акуратним.

TI-36 (не 84, 36), 10 байт, прибл. 9.999985426E99

Старі калькулятори також можуть бути запрограмовані в

69!58.4376

такій мірі;) Це дуже близько до максимального діапазону, який може відображати TI калькулятор:-1E100<x<1E100

Перл 6 , 456 574 цифри

[*] 1..ↈ

Немає TIO, оскільки для запуску потрібно 2 хвилини.