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

Отже, скажімо, ви надрукували, 10000000і ваш код 100довгий в байтах. Ваш остаточний рахунок буде 10000000 / 100^3 = 10.

Для того, щоб зробити цей виклик трохи складніше, слід дотримуватися інших правил.

• Ви не можете використовувати цифри у своєму коді (0123456789);
• Ви можете використовувати математичні / фізичні / тощо. константи, але лише якщо вони менші від 10. (наприклад, ви можете використовувати Pi ~ = 3,14, але ви не можете використовувати константу Avogadro = 6e23)
• Рекурсія дозволена, але згенероване число повинно бути кінцевим (тому нескінченне не приймається як рішення. Ваша програма повинна завершитись правильно, передбачаючи необмежений час та пам'ять, і генерувати запитуваний вихід);
• Ви не можете використовувати операції *(множити), /(ділити), ^(потужність) та будь-який інший спосіб їх позначення (наприклад 2 div 2, не дозволено);
• Ваша програма може вивести більше, ніж одне число, якщо вам це потрібно . Тільки найвищий вважатиметься за бали;
• Однак ви можете об'єднати рядки: це означає, що будь-яка послідовність суміжних цифр буде розглядатися як одне число;
• Ваш код запуститься як є. Це означає, що кінцевий користувач не може редагувати жоден рядок коду, а також не може вводити номер чи щось інше;
• Максимальна довжина коду - 100 байт.

Таблиця лідерів

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

_{Виноски}

1. ^{Якби кожен електрон у Всесвіті був кубітом, і кожен його суперпозиція міг би з користю використовуватись для зберігання інформації (яка, поки ви фактично не знаєте , що зберігається, теоретично можливо), для цієї програми потрібно більше пам'яті, ніж могло б можливо, існує, і тому не може бути запущено - зараз, або в будь-який можливий момент у майбутньому. Якщо автор мав намір надрукувати значення більше, ніж ≈3 ↑↑ 3,28 відразу, ця умова застосовується.}
2. ^{Для цієї програми потрібно більше пам’яті, ніж зараз існує, але не стільки, щоб теоретично її не можна було зберігати на мізерній кількості кубітів, і тому один день може існувати комп'ютер, який міг би запустити цю програму.}
3. ^{Усі доступні в даний час перекладачі видають помилку під час виконання програми, або програма іншим чином не виконає виконання, як задумав автор.}
4. ^{Запуск цієї програми завдасть непоправної шкоди вашій системі.}

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

Пояснення цього позначення:

Якщо 0 ≤ b < 1, то .a↑↑b = ab

Якщо b ≥ 1, то .a↑↑b = aa↑↑(b-1)

Якщо b < 0, то .a↑↑b = loga(a↑↑(b+1))

GolfScript; оцінка принаймні f _{ε_0 + ω + 1} (17) / 1000

Слідом за пропозицією Res використати відповідь на життя протягом черв'яка для цього питання, я представляю дві програми, які значно покращують його виведення рішення Говарда.

Вони мають спільний префікс, по модулю ім'я функції:

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

обчислює, g(g(1)) = g(5)де g(x) = worm_lifetime(x, [x])зростає приблизно як f _{ε 0} (що відзначає res - це "функція в швидко зростаючої ієрархії, яка росте приблизно з тією ж швидкістю, що і функція Гудштайна").

Трохи простіше (!) Проаналізувати

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

.{foo}*карти xдо foo^x x.

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

таким чином дає g^(g(5)) ( g(5) ); наступні 8 рівнів ітерації схожі на прикування стрілок. Висловити простими словами: якщо h_0 = gі h_{i+1} (x) = h_i^x (x)тоді обчислюємо h_10 (g(5)).

Я думаю, що ця друга програма майже напевно забиває набагато краще. Цього разу мітка, призначена функції, gє новим рядком (sic).

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

Цього разу я краще використовую ^як іншу функцію.

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

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

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

ПРИМІТКА: НЕ ПОВЕРНУЙТЕСЯ ЦІЙ

Збережіть наступне у пакетному файлі та запустіть його як адміністратор.

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

Вихід під час роботи на 4-ти ТБ накопичувальному жирі з першим друкованим номером.

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

GolfScript, оцінка: шлях надто багато

Гаразд, наскільки велику кількість ми можемо надрукувати за кілька символів GolfScript?

Почнемо із наступного коду ( спасибі, Бен! ), Який друкує 126:

'~'(

Далі повторимо це 126 разів, даючи нам число, рівне приблизно 1,226126 × 10 ³⁷⁷ :

'~'(.`*

(Це рядкове повторення, а не множення, тому воно повинно бути нормально за правилами.)

Тепер повторимо, що 378-значний номер трохи більше 10 ³⁷⁷ разів:

'~'(.`*.~*

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

Але припустимо, що у нас є власний Божий інтерпретатор GolfScript, здатний виконувати такий розрахунок, і що ми все ще не задоволені. Гаразд, зробимо це ще раз!

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

Вихід цієї програми, якщо він міг би завершитися, мав би близько 10 ^{10 383} цифр, і так би дорівнював приблизно 10 ^{10 10 383} .

Але зачекайте! Ця програма стає настільки повторюваною ... чому б ми не перетворили її на цикл?

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

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

Але ми ще не закінчили. Додамо ще одну петлю!

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

Щоб навіть правильно записати наближення таких чисел, потрібні езотеричні математичні позначення. Наприклад, у нотації стрілки вгору Кнут число (теоретично), виведене програмою вище, повинно бути приблизно 10 ↑ ³ 10 ³⁷⁷ , дати або взяти кілька (або 10 ³⁷⁷ ) потужностей десять, якщо припустити, що я зробив математику правильно.

Такі цифри виходять за рамки просто "неймовірно величезних" і переходять у царину "немислимого". Як і в тому, що не тільки неможливо порахувати чи записати такі числа (ми перейшли за межі цієї точки вже на третьому прикладі вище), але вони буквально не мають можливого використання чи існування поза абстрактною математикою. Ми можемо довести, з аксіом математики , що такі числа існують, так само , як ми можемо довести , з специфікації GolfScript , що Програма вище буде їх обчислювати, якщо межі реальності і доступного дискового простору не втручалися), але немає буквально нічого в фізичний всесвіт, що ми могли б використовувати їх для підрахунку чи вимірювання в будь-якому сенсі.

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

JavaScript 44 символи

Це може здатися трохи підступним:

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

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

C, оцінка = 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

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

Я ціную допомогу в забиванні балів. Будь-які розуміння чи виправлення оцінюються. Ось мій метод:

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

l = 98 символів коду

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

Вимога: Потрібно працювати на 64-бітному комп'ютері, де sizeof(long) == 8. Mac і Linux це зроблять.

Python 3 - 99 знаків - (швидше за все) значно більший за число Грема

Я придумав більш швидко зростаючу функцію, засновану на розширенні функції Ackermann.

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

(а має бути принаймні 1, тому він повинен бути сильнішим)

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

Моя функція гарантовано врешті припинить повторення, оскільки вона завжди або: видаляє аргумент, зменшує перший аргумент, або зберігає той самий перший аргумент і зменшує другий аргумент.

Аналіз розміру

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

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

Де a ↑^(n)b - позначення стрілки вгору.

Так само:

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

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

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

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

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

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

Оскільки g^64(4)це число Грема, і якщо припустити, що моя математика є правильною, то вона менша A(1,64,100), моє число значно більше, ніж число Грема.

Будь ласка, вкажіть будь-які помилки в моїй математиці - хоча якщо таких немає, це має бути найбільша кількість обчислених досі, щоб відповісти на це питання.

Perl - оцінка ≈ 10 ↑↑ 4.1

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

Ще раз зловживаючи регекс-двигуном Perl, щоб перемолоти незбагненну кількість комбінацій, цього разу використовуючи рекурсивний спуск.

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

З чим ми закінчимось:

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

... повторено 671088640 разів, загалом 12750684161 - що досить ретельно ставить перед сором мою попередню спробу 23 гніздування. Примітно, що perl навіть не задихається від цього (знову ж таки, використання пам'яті стабільно становить близько 1,3 ГБ), хоча пройде досить багато часу, перш ніж перша заява про друк навіть буде видана.

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

А якщо ми запитаємо wolframalpha :

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

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

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

Зловживаючи двигуном perge regex, щоб зробити для нас комбінаторику. Вбудований блок-код
(??{print})буде вставляти його результат безпосередньо в регулярний вираз. Оскільки $_повністю складається з 2s (і результат printє завжди 1), це ніколи не може відповідати, і надсилає perl спінінг через усі можливі комбінації, яких досить багато.

Константи, що використовуються

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

$_то рядок, що містить цифру, 2повторену 671088640 разів. Використання пам'яті постійне, близько 1,3 Гб, вихід починається негайно.

Аналіз

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

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

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

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

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

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

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

Загалом, формулу можна узагальнити так:

де

Тобто, лівий Факторіал від до , тобто сума всіх факториалов менше , ніж до (див A003422 ).

Я не зміг визначити закриті форми для D _k і E _k , але це не має великого значення, якщо ми це спостерігатимемо

і

З 23 гнізд, це дає нам приблизний бал:

Насправді це має бути майже точно.

Але, щоб помістити це в позначення, які трохи простіше уявити, ми можемо наблизити основу внутрішнього показника:

а потім і сам показник:

а потім запитайте wolframalpha :

який ви можете просто зателефонувати 10 ↑↑ 4 і зробити це з ним.

Javascript, 10 ↑↑↑↑ 210

100 символів:

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

Виходячи із зауваження, що максимальна ітерація fє оптимальним способом, я замінив 13 викликів на f3 рівні виклику вкладених циклів f, zраз у кожний (при цьому fпостійно збільшуєтьсяz ).

Я оцінив оцінку аналітично на аркуші паперу - я наберу її, якщо хтось зацікавлений у цьому.

Покращена оцінка: 10 ↑↑ 13

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

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

Це покращує мою оригінальну відповідь трьома способами -

1. Визначення zглобальної сфери рятує нас від необхідності вводити o.zкожен раз.

2. Можна визначити геттер у глобальній області (вікно) та ввести fзамість o.f.

3. Маючи більше ітерацій f, варто більше, ніж починати з більшої кількості, тому замість (Math.E+'').replace('.','')(= 2718281828459045, 27 символів) краще використовувати ~~Math.E+''(= 2, 11 символів) і використовувати врятовані символи, щоб зателефонувати ще fбагато разів.

Оскільки, як проаналізовано далі, кожна ітерація отримує з числа в порядку величини М більше число в порядку величини 10 ^М , цей код виробляється після кожної ітерації

1. 210 ∼ O (10 ² )
2. О (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 1-значні числа

У 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 1-значні числа

Цю суму можна представити формулою,

де Z позначає початкове число ( наприклад, 2718281828459045), а O _Z позначає його порядок ( наприклад, 15, оскільки Z ∼ 10 ¹⁵ ). Використовуючи еквіваленти для кінцевих сум , вищезазначене можна виразити явно як

який, якщо взяти 9 ≈ 10, ще більше знижується до

і, нарешті, розширюючи терміни і впорядковуючи їх зменшуючи порядок, ми отримуємо

Тепер, оскільки нас цікавить лише порядок величини результату, замінимо Z на "число в порядку величини O _Z ", тобто 10 ^{O _Z} -

Нарешті, 2-й і 3-й терміни скасовуються, і останні два терміни можна скинути (їх розмір є тривіальним), залишивши нас з

з якого виграє перший термін

Перезапущений, fприймає число в порядку величини М і видає число приблизно в порядку величини М (10 ^М ).

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

Зазначаючи, що M не є значущим фактором M (10 ^М ), порядок величини результату кожної ітерації, відповідно, випливає з простої схеми тетрації:

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

Джерела LaTeX

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

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

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

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

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

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

APL, 10 ↑↑ 3.4

Ось моя переглянута спроба:

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

Програма 100 char / byte *, що працює на поточному апаратному забезпеченні (використовує мізерний об'єм пам’яті та звичайні 32-бітні змінні int), хоча для завершення знадобиться дуже багато часу.

Ви можете запустити його на інтерпретаторі APL, і він почне друкувати цифри. Якщо буде дозволено завершити, воно надрукує число з 10 цифрами 10 × 123456789 ⁴⁴ цифри.

Таким чином, оцінка становить 10 ^{10 × 123456789 44} /100 ³ ≈ 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 ² рази
• {⍞←n}⍣n⍣n⍣nзробить це n ³ рази
• Я міг би там поміститися 44 ⍣n, тож він друкує n ⁴⁴ рази рядок '0123456789'.

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

Хаскелл, оцінка: (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. Він надрукує четверте число Ackermann, зрештою, споживаючи всю наявну енергію, матерію та час Всесвіту і далі в процесі (таким чином, трохи перевищуючи м'яку межу в 5 секунд).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (позначення стрілки вгору Knuth)

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

Напевно, жоден комп’ютер не має достатньої пам’яті, щоб успішно це запустити, але це насправді не винна програма. При задоволенні мінімальних системних вимог це працює.

Так, це робить перехід бітів на булеві значення. Trueпримушується до 1цього контексту. Python має цілі числа довільної довжини.

GolfScript 3.673e + 374

'~'(.`*

Я думаю, що *дозволено, оскільки воно вказує на повторність рядків, а не на множення.

Пояснення: '~'(залишить 126 (значення ASCII "~") у стеці. Потім скопіюйте число, перетворіть його в рядок і зробіть повторення рядка 126 разів. Це дає, 126126126126...що приблизно 1.26 e+377. Рішення - 7 символів, тому розділіть їх 7^3на приблизно приблизно3.673e+374

Рубі, імовірнісно нескінченний, 54 символи

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

x ініціалізується до 97. Потім ми повторюємо наступну процедуру: Створюємо x випадкових чисел між 0 і 1. Якщо вони всі однакові, то закінчуємо та друкуємо x. В іншому випадку подвійно x і повторити. Оскільки випадкові числа Рубі мають 17 цифр точності, шанси закінчення на будь-якому кроці дорівнюють 1 (10e17) ^ x. Тому ймовірність закінчення в межах n кроків - це сума для x = 1 до n (1 / 10e17) ^ (2 ^ n), яка сходиться до 1 / 10e34. Це означає, що для будь-якого числа, незалежно від того, наскільки велике, ця програма видає меншу кількість.

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

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

Це безсоромно адаптовано з іншої відповіді @Howard і містить пропозиції @Peter Taylor.

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

Моє розуміння GolfScript обмежене, але я вважаю, що *і^ оператори вище НЕ арифметичні операції , заборонені ОП.

(Я щасливо видалю це, якщо @Howard захоче подати свою власну версію, яка, безсумнівно, буде кращою для цієї.)

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

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

Єдині використовувані тут арифметичні оператори - додавання та віднімання.

EDIT: як обіцяно в коментарях, ось детальна робота цього коду:

[            # 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 . Як результат, він обчислює значення, які трохи вище, ніж вони повинні бути, але це не велика справа, оскільки ми прагнемо до більшої кількості. :)

EDIT: Я щойно помітив, що цифра потрапила в код випадково, в макрос, який виконує збільшення кроків для n=0. Я видалив його, замінивши його на "F" (15), що має побічний ефект масштабування кожної операції збільшення на 15. Я не впевнений, наскільки це впливає на кінцевий результат, але, мабуть, це набагато більше.

Більше немає обмеження на час виконання? Добре тоді.

Чи потрібно програму виконувати на сучасних комп’ютерах?

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

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

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

88 символів.

Щоб полегшити ці формули, я використаю t = 2^64-1 = 18446744073709551615.

mainбуде дзвонити fз параметром t, який буде циклічно tразів, щоразу надруковуючи значення t, і викликаючи fз параметром t-1.

Всього цифра надрукувала: 20 * t.

Кожен з цих викликів fз параметром t-1волі повторюватиме tчас, друкуючи значення tта викликаючи f з параметром t-2.

Загальна кількість роздрукованих цифр: 20 * (t + t*t)

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

Загальна кількість роздрукованих цифр: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Я не впевнений, як обчислити (2 ⁶⁴ -1) ^{2 64} . Це підсумок менший, ніж (2 ⁶⁴ ) ^{2 64} , і мені потрібна сила двох, щоб зробити цей розрахунок. Тому я прорахую (2 ⁶⁴ ) ^{2 64 -1} . Він менший за реальний результат, але оскільки це потужність у два, я можу перетворити його на потужність 10 для порівняння з іншими результатами.

Хтось знає, як виконати це підсумовування або як перетворити (2 ⁶⁴ -1) ^{2 64} в 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
ділимо цей показник на базу журналу 2 на 10, щоб переключити базу експонента на потужність 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Але пам’ятайте, це кількість роздрукованих цифр. Значення цілого числа 10 піднімається до цієї потужності, тому 10 ^ 10 ^ 355393490465494856447

Ця програма матиме глибину стеку 2 ^ 64. Це 2 ^ 72 байти пам'яті просто для зберігання лічильників циклу. Це 4 мільярди Терабайт лічильників циклу. Не кажучи вже про інші речі, які виходили б на стек протягом 2 ^ 64 рівнів рекурсії.

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

Редагування 2: Зачекайте секунду, у мене є цикл, у якого printf знаходиться поза. Давайте це виправимо. Додано ініціалізацію i.

Редагування 3: Наспівав, я накрутив математику на попередньому редагуванні. Виправлено.

Цей буде працювати на сучасних комп’ютерах, хоча він не закінчиться найближчим часом.

С: 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= 1453677448591213780547019529026486359825087615481303750744349513987271378009622757102790327068067244563877561877830370518204280054218750000

Округлення програми довжиною до 100 символів, Оцінка = друкована кількість / 1 000 000

Оцінка = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

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

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

буде надруковано [відтворення тут лише на початку]:

403624169270483442010614603558397222347416148937479386587122217348........

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

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

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

Вихід: 10 ^ 3 ↑↑↑↑ 3

Підказки:

G- це функція, де G (64) - число Грема. Введення - ціле число. Вихід - це одинарна рядок, записана з 0. Видалено для стислості.

K- це функція стрілки вгору Knuth a ↑ ⁿ b, де a неявно 3. Введення n, одинарна рядок і b, одинарна рядок. Вихід - одинарна рядок.

u є "1".

v є "0000", або G (0)

e є "000".

С

(З вибаченнями Даррен Стоун)

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

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

l = 100 символів коду

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

[Оцінка = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)]

Зауважте, що я заслуговую на те, щоб мене немилосердно лукали за цю відповідь, але не втримався. Я не рекомендую діяти, як я, на stackexchange з очевидних причин. :-P

EDIT: Було б навіть важче протистояти спокусі йти з чимось подібним

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

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

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

де f _α (n) - швидко зростаюча ієрархія.

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

Спробуйте в Інтернеті!

The *nЄ тільки рядки і масив множення, тому вони повинні бути добре.

Невикористаний код:

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

де b.-b<=>0повертає ціле число, яке 1ближче до 0ніж b.

Пояснення:

Він друкується nна початку кожного дзвінкаH .

H[[]]подвійний n( nраз), тобтоn = n<<n .

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

H[[k+1,a,b,c,...,z]]дзвінки H[[k]*n+[a,b,c,...,z]]( nчаси), куди [k]*n = [k,k,...,k].

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

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

H[k] = H[[k]].

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

Приклади:

H[[0]]зателефонує, H[[]]що застосовується n = n<<n(n раз).

H[[0,0]]зателефонує H[[0]](n раз).

H[[1]]зателефонує H[[0]*n](n раз).

H[[-1]]зателефонує H[[n]*n](n раз).

H[[-1,-1]]зателефонує H[[n]*n+[-1]](n раз).

H[[-3]]зателефонує H[[-2]*n](n раз).

Спробуйте в Інтернеті!

Дивіться версії інших цікавих речей.

Функція Haskell - Ackermann застосована до її результату 20 разів - 99 символів

Це найкраще рішення haskell, яке я можу створити на основі функції ackermann - ви можете помітити деякі схожість з рішенням nm, i = круглий $ 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,
• a (61,61),
• a (a (61,61), a (61,61)) --- це будемо називати ₂ (61), або ₄ (1) ---
• a ₃ (61)
• ...
• a ₁₈ (61), або ₂₀ (1). Я думаю, що це приблизно g ₁₈ (див. Нижче).

Щодо оцінки, wikipedia говорить:

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

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

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

Якщо вони приблизно еквівалентні, то a ₂₀ (1) ~ = g ₁₈ . Кінцевий член у a _n , (a _n-1 ) набагато більший за 3, тому потенційно він перевищує g ₁₈ . Я побачу, чи зможу я зрозуміти, чи сприятиме це навіть одній ітерації та звіту.

машинний код x86 - 100 байт (зібрано як файл MSDOS .com)

Примітка: може трохи згорнути правила

Ця програма виведе 2 ^{(65536 * 8 + 32)} дев'яти, які б поставили бал у (10 ^{2 524320} -1) / 1000000

В якості лічильника ця програма використовує весь стек (64кіБ) плюс два 16-бітні регістри

Зібраний код:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Збірка:

ORG 0x100

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

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

С

Розмір файлу - 45 байт.

Програма:

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

А кількість вироблених перевищує 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Файл, на який я перенаправив std, наразі перевищує 16 Гбіт і все ще зростає.

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

Моя оцінка незрівнянна з плаваючою точкою з подвійною точністю.

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

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

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

64-розрядний UNIX:

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

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

C, 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 непідписаних цілих чисел. Це не могло бути неподписаним довго, тому що це робило програму занадто довгою. Вони не підписані, тому що я не хочу використовувати невизначене поведінку, цей код є правильним C (крім відсутності повернення від main ()) і буде компілюватись і працювати на будь-якій звичайній машині, він буде тривати довгий час, хоча . Цей розмір є найбільшим, що ми можемо законно висловити, не використовуючи символи, що не належать до асції.

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

Ось приклад коду, який показує принцип у більш обмеженому діапазоні даних:

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

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

Результат приблизно 10 ^ 10 ^ 2485766, поділений на мільйон, що все ще приблизно 10 ^ 10 ^ 2485766.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

На це потрібно набагато більше 5 секунд.

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

Він витягує та поєднує довжину байтів кожного файлу на вашому поточному диску. Regex викреслює будь-які нецифрові символи.

Python 3, оцінка = ack (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, до якої у мене достатньо простору.

Редагувати: раніше "else n + 1", що було порушенням правил виклику - куди просто красиве мистецтво.

JavaScript 98 символів

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

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

Для балу трохи більше 2,718e + 239622331 ≈ 10 ↑↑ 2,9232195197

який найбільший, я можу зробити це без збоїв браузера.

(console.log (a) покаже вам повний вихід)

Не запускайте їх:

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

виведемо 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (він же 2.718 * 10 ^ (1.213 * 10 ^ 12) для порівняння з довшою відповіддю:

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

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

Пітон 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('~'))))

Ефективно, Е зменшує перший аргумент, збільшуючи решту аргументів, за винятком того, що замість того, щоб ставити -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**ab.

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

• ~ 20 Гб вихід
• 41 символ (41 ^ 3 нічого не означає)

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

Незважаючи rand()на вихід є детермінованим, тому що немає функції насіння.