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

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

Ви можете припустити, що:

• Всесвіт загине від ентропії через 10 ¹⁰⁰⁰ років.
• Ваш комп'ютер:
  • Переживе Всесвіт, тому що він зроблений з Unobtainium .
  • Має нескінченну межу пам'яті / стека / рекурсії.
  • Його процесор має обмежену швидкість.

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

Застосовуються стандартні лазівки .

Це виклик для гольфу з кодом, тому виграє найкоротший код, що задовольняє критеріям.

Редагувати :

На жаль, (через 30 хвилин) було встановлено, що поле неймовірності Unobtainium втручається у внутрішній годинник комп'ютера, роблячи його марним. Тому програми, засновані на часі, негайно зупиняються. (Хто б у будь-якому разі залишив програму, яка просто чекає її живої спадщини?).

Комп'ютерний процесор схожий на Intel i7-4578U, тому один із способів виміряти час роботи - це запустити свою програму на подібному комп'ютері з меншим входом (сподіваюся) та екстраполювати час її роботи.

Подіум

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

_{* Оновлення 31/08}

CJam, 5 байт

0{)}h

Як це працює

 0   " Push 0.                                 ";
 {   "                                         ";
   ) " Increment the Big Integer on the stack. ";
 }h  " Repeat if the value is non-zero.        ";

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

На моєму комп’ютері розмір купи за замовчуванням становить 4 176 623 936 байт (Java 8 на Fedora). Його можна збільшити до довільного значення за допомогою -Xmx, тому єдиним реальним обмеженням є доступна основна пам'ять.

Час смерті

Якщо припустити, що інтерпретатору потрібні х біт пам'яті для зберігання негативного великого цілого числа менше 2 ^х , ми повинні рахувати до 2 ^{8 × 4,179,623,936} = 2 ^{33,436,991,488} . З одним приростом на тактовий цикл і моїм Core i7-3770 (3,9 ГГц з турбо) це займе 2 ^{33,436,991,488} ÷ 3 400 000 000> 10 ^10656537393 секунд, що перевищує 10 ^10656537855 років.

JavaScript, 39

(function f(x){for(;x!=++x;)f(x+1)})(0)

Пояснення

Оскільки JavaScript точно не представляє великі цілі числа, цикл for(;x!=++x;)завершується один раз xзверненням 9007199254740992.

Тіло циклу для циклу буде виконано Fib(9007199254740992) - 1раз, де Fib(n)знаходиться число n-го напруги.

Після тестування я знаю, що мій комп'ютер буде робити менше 150 000 ітерацій в секунду. Насправді це буде працювати набагато повільніше, тому що стека зростатиме дуже великою.

Таким чином, (Fib(9007199254740992) - 1) / 150000для запуску програми знадобиться не менше секунд. Я не зміг обчислити, Fib(9007199254740992)тому що він настільки великий, але я знаю, що він набагато більший за 10 ¹⁰⁰⁰ * 150 000.

EDIT: Як зазначається в коментарях, Fib(9007199254740992)це приблизно 4.4092 * 10 ^{1882393317509686} , що дійсно досить велике.

Пітон (9)

9**9**1e9

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

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

Редагувати: Полювали два знаки, видаливши паролі завдяки @ user2357112. ТИЛЬ, що Python трактує послідовні експоненти як вежу влади.

GolfScript ( 12 7 символів)

9,{\?}*

Це обчислює і друкує 8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 183230. Щоб надрукувати його (не маючи на увазі обчислення) за 10 ^ 1000 років ~ = 10 ^ 1007,5 секунди, йому потрібно надрукувати приблизно 10 ^ (10 ^ 10 ^ 10 ^ 183230 - 10 ^ 3) цифр в секунду.

Marbelous 68 66 байт

}0
--@2
@2/\=0MB
}0@1\/
&0/\>0!!
--
@1
00@0
--/\=0
\\@0&0

Marbelous - це 8-бітова мова зі значеннями, представленими лише мармурами в машині, подібній до Руба Голдберга, тому це було не дуже просто. Цей підхід приблизно еквівалентний наступному псевдокоду:

function recursiveFunction(int i)
{
    for(int j = i*512; j > 0; j--)
    {
        recursiveFunction(i - 1);
    }
}

оскільки максимальне значення - 256, (представлене 0 у програмі Marbleous, яка обробляється по-різному в різних місцях), рекурсивнаФункція (1) буде називатися загальною величиною, 256!*512^256яка дорівнює приблизно 10^1200, досить легко пережити всесвіт.

У Marbelous не дуже швидкий перекладач, схоже, він може працювати на 10^11виклики цієї функції на рік, а це означає, що ми спостерігаємо час виконання 10^1189.

Подальше пояснення дошки Marbelous

00@0
--/\=0
\\@0&0

00- мова буквальна (або мармур), представлена ​​шістнадцятковою (так 0). Цей мармур падає вниз --, який зменшує будь-який мармур на 1 (00 обертається і перетворюється на FF або 255 у десятковій частині). Мармур з теперішнім значенням FF падає вниз на той, \\який засуває його на одну колонку праворуч, на нижню @0. Це портал і телепортує мармур на інший @0пристрій. Там мармур приземляється на /\пристрій, який є копіювачем, він кладе одну копію мармуру --ліворуч (цей мармур буде тримати петлю між порталами та зменшуватись на кожній петлі) та один - =0праворуч.=0порівнює мармур із значенням нуля і дозволяє мармуру провалюватися, якщо він рівний, і, якщо ні, підштовхує його вправо. Якщо мармур має значення 0, він сідає на &0синхронізатор, про що я поясню далі, пізніше.

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

}0@1
&0/\>0!!
--
@1

}0- це пристрій введення, спочатку введення командного рядка n-го (база 0) при виклику програми розміщується в кожному }nпристрої. Тож якщо ви зателефонуєте до цієї програми за допомогою введення командного рядка 2, мармур значення 02 замінить це }0. Потім цей мармур потрапляє в &0пристрій, інший синхронізатор, &nсинхронізатори тримають мармур, поки не &nбудуть подані також усі інші відповідні . Потім мармур зменшується, телепортується та дублюється так само, як у раніше поясненому циклі. Потім правильна копія перевіряється на нерівність з нулем ( >0), якщо вона не 0, вона пропадає. Якщо вона дорівнює 0, вона висувається праворуч і приземляється !!, що закінчує дошку.

Гаразд, поки що у нас є цикл, який постійно відлічується від 255 до 0 і дозволяє інший, подібний цикл (подається введенням командного рядка) запускатися один раз щоразу, коли він потрапляє в 0. Коли цей другий цикл працює n разів (максимум 256 ) програма припиняється. Отже, це максимум 65536 пробігів циклу. Не майже достатньо, щоб пережити світобудову.

}0
--@2
@2/\=0MB

Це повинно почати виглядати знайомим, вхід зменшується один раз, потім це значення обводиться і копіюється (зауважте, що мармур зменшується лише один раз, а не на кожному циклі циклу). Потім він перевіряється на рівність 0, і якщо це не нульове значення MB. Це функція в Marbelous, кожен файл може містити кілька дощок, і кожна дошка є функцією, кожна функція повинна бути названа попередньою сіткою :[name]. Кожна функція, крім першої функції у файлі, яка має стандартну назву: MB. Таким чином, цей цикл постійно безперервно викликає основну плату зі значенням, n - 1де n - це значення, з якого був названий цей екземпляр функції.

То чому n*512?

Ну, перший цикл працює в 4 кліща (і 256 разів), а другий цикл працює n разів до того, як плата закінчиться. Це означає, що на дошці працює близько n*4*256кліщів. Останній цикл (який виконує рекурсивну функцію виклику) є компактним і працює в 2 тики, а значить, йому вдається викликати функцію n*4*256/2 = n*512раз.

Які символи ви не згадали?

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

Бонус

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

Perl, 66 58 символів

sub A{($m,$n)=@_;$m?A($m-1,$n?A($m,$n-1):1):$n+1;}A(9,9);

Викладене вище є реалізацією функції Акермана-Петера . Я поняття не маю, наскільки великий A (9,9), але я впевнений, що це займе надзвичайно багато часу.

MATLAB, 58 52 символи

Нам потрібно щонайменше одне арифметичне рішення з кінцевою точністю, отже:

y=ones(1,999);while y*y',y=mod(y+1,primes(7910));end

x = ті (1,999); y = x; тоді як будь-який (y), y = mod (y + x, primes (7910)); кінець

( завдяки спасибі @DennisJaheruddin за збір 6 символів )

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

Математика, 25 19 байт

Це рішення було розміщено до дискваліфікації часових функцій.

While[TimeUsed[]<10^10^5]

TimeUsed[]повертає секунди з початку сеансу, і Mathematica використовує типи довільної точності. Щорічно буває 10 ⁷ секунд, тому очікування 10 ¹⁰⁰⁰⁰ секунд повинно вистачити.

Коротша / простіша (/ дійсна) альтернатива:

For[i=0,++i<9^9^9,]

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

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

Пітон 3 - 49

Це робить щось корисне: обчислює Пі з небаченою точністю, використовуючи нескінченний ряд Грегорі-Лейбніца.

Про всяк випадок, коли вам було цікаво, ця програма циклічно 10**10**10**2.004302604952323.

sum([4/(i*2+1)*-1**i for i in range(1e99**1e99)])

Довільна точність: 78

from decimal import*
sum([Decimal(4/(i*2+1)*-1**i)for i in range(1e99**1e99)])

Джерело зображення

Термінальне дихання

Через величезні обчислення, які відбуваються, 1e99**1e99ітерації займають трохи менше 1e99**1e99років. Тепер (1e99**1e99)-1e1000майже нічого не має. Це означає, що ця програма буде працювати набагато довше, ніж смерть нашого Всесвіту.

Відродження

Зараз вчені пропонують, що у 10**10**56 yearsВсесвіті відродиться через квантові коливання чи тунелювання. Отже, якщо кожен Всесвіт точно такий самий, скільки Всесвіту проживе моя програма?

(1e99**1e99)/(1e10+1e1000+10**10**56)=1e9701

Якщо припустити, що Всесвіт завжди буде жити 1e10+1e1000роками, а потім потрібні 10**10**56роки, щоб "перезавантажитися", моя програма переживе 1e9701всесвіти. Це, звичайно, припускаючи, що унобтаїній може прожити через Великий вибух.

Python 59 (працює більшу частину часу)

Я не втримався

from random import*
while sum(random()for i in range(99)):0

Незважаючи на те, що це теоретично може закінчитися протягом мілісекунди, середній час роботи значно перевищує 10^400вказаний термін життя Всесвіту. Завдяки @BetaDecay, @undergroundmonorail та @DaboRoss за те, що вони зменшили його на 17 символів.

J - 5 символів, я думаю

Зауважимо, що все наступне є арифметикою довільної точності, оскільки число 9 завжди має трохи xпоруч.

У семи символів у нас є !^:!!9x, що начебто як біг

n = 9!
for i in range(n!):
    n = n!

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

У шести символах ми також можемо записати ^/i.9x, що обчислює кожен проміжний результат 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8. Вольфрам | Альфа каже 2^3^4^5^6^7^8приблизно 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185, що, ймовірно, також очищає перевірку.

У нас також є п’ять знаків !!!9x, що якраз ((9!)!). W | A каже 10 ^ 10 ^ 10 ^ 6.2695, що це все-таки повинно бути досить великим ... Це наче 1.6097e1859933-значні цифри, що напевно більше, ніж 3.154e1016кількість наносекунд у Всесвіті, але я зізнаюся, я не маю уявлення, як би це можна було зрозуміти реальні терміни виконання цих речей.

Друк сам по собі повинен тривати досить довго, щоб прослужити довше, ніж Всесвіт, тому воно повинно бути добре.

C, 63 56 символів

f(x,y){return x?f(x-1,y?f(x,y-1):1):y+1;}main(){f(9,9);}

Це засновано на ідеї хлопця на ім’я Вільгельм. Мій єдиний внесок - це зведення коду до цієї короткої (і нечитабельної) деталі.

Доведення, що воно припиняється, здійснюється індукцією.

• Якщо x дорівнює 0, воно негайно припиняється.
• Якщо він закінчується для x-1 і будь-якого y, він також закінчується для x, це може бути показано індукцією.

Доведення етапу індукції за допомогою індукції:

• Якщо y дорівнює 0, існує лише один рекурсивний виклик з x-1, який закінчується припущенням індукції.
• Якщо f (x, y-1) закінчується, тоді f (x, y) також припиняється, оскільки найпотужніший виклик f є саме f (x, y-1), а самий зовнішній виклик закінчується відповідно до індукційного гіптезу.

Очікуваний час роботи - A (9,9) / 11837 секунд. Це число має більше цифр, ніж кількість кварків у спостережуваному Всесвіті.

Матлаб ( 10 8 символів)

1:9e1016

IMHO, більшість записів надто намагаються, обчислюючи великі, складні речі. Цей код просто ініціалізує масив розміром 9x10 ¹⁰¹⁶ double с, рахуючи від 1, який займає 7,2х10 ^ ¹⁰¹⁷ байт. На сучасному процесорі з максимальною пропускною здатністю пам’яті 21 ГБ / с або 6,63х10 ^ ¹⁷ байт / рік знадобиться щонайменше 1,09х10 ¹⁰⁰⁰ років, щоб навіть ініціалізувати масив, не кажучи вже про спробу надрукувати його, оскільки я не турбував придушення виводу за допомогою крапки з комою. (;

старий розчин (и)

nan(3e508)

Як варіант

inf(3e508)

Цей код просто створить квадратну матрицю NaNs / нескінченності розміром 3e508x 3e508 = 9e10168-байтових пар або 7.2e1017байтів.

Perl, 16 чол

/$_^/for'.*'x1e9

Це створює рядок, що повторює ". *" В мільярд разів, а потім використовує його як голку, так і стоги сіна в регулярному збігу. Це, у свою чергу, змушує механізм регулярного вибору намагатися здійснити кожне можливе розділення рядка довжиною два мільярди символів. Відповідно до цієї формули з Вікіпедії , існує близько 10 ³⁵²¹⁸ таких розділів.

Вищевказане рішення має 16 символів, але вимагає близько 2 Гб пам'яті, а значить, його можна запустити на реальному комп'ютері. Якщо припустити нескінченну пам'ять і обмежений розмір регістра (що, мабуть, не має сенсу), його можна скоротити до 15 символів, при цьому різко збільшуючи час виконання:

/$_^/for'.*'x~0

(Я не тестував його, але думаю, що він може працювати з 32-розрядним Perl, побудованим на 64-бітній машині з принаймні 6 Гб оперативної пам’яті.)

Примітки:

• x є оператором повторення рядків.
• forне є фактичним цикл; він використовується лише для збереження одного символу (порівняно з $_=".*"x1e9;/$_^/).
• фінал ^у регулярному виразі гарантує, що може відповідати лише порожній рядок; оскільки кількісні показники регулярних викидів за замовчуванням жадібні, це останнє, що спробує двигун.
• орієнтири на моєму комп’ютері для значень (1..13) дозволяють припустити, що час роботи фактично є O (exp (n)), що навіть більше, ніж O (exp (sqrt (n))) у формулі Wikipedia.

J (12)

(!^:(!!9))9x

Про що це зводиться в Python (припускаючи !роботи):

a = 9 
for i in range((9!)!):
    a = a!

Редагувати:

Що ж, програма може зайняти, максимум, 2 × 10^-1858926секунди за цикл, щоб виконати протягом необхідного часу. Порада: це навіть не буде працювати протягом першого циклу, не маючи на увазі останній;).

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

C # 217

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

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

Перша спроба кодового гольфу, але ось тут.

VBA - 57 45

x=0
do
if rnd()*rnd()<>0 then x=0
x=x+1
while 1=1

Таким чином, X піде вгору на одиницю, якщо відбудеться подія 1 на 2 ^ 128, і якщо вона не відбудеться, скинеться. Код закінчується, коли ця подія відбувається 2 ^ 64 + 1 раз підряд. Я не знаю, як почати обчислювати час, але я гадаю, що це величезна кількість.

EDIT: Я розробив математику, і ймовірність того, що це станеться в кожному циклі, становить 1 на 2 ^ 128 ^ (1 + 2 ^ 64), що становить приблизно 20000 цифр. Якщо припустити 1000000 циклів / сек (пробіг з числа тонкого повітря) і 30000000 с / год, що становить 3 * 10 ^ 13 циклів на рік, час 10 ^ 1000 років залишилося 3 * 10 ^ 1013 циклів, так що це, ймовірно, триватиме приблизно в 20 разів більше Залишився час у Всесвіті. Я радий, що моя математика підкріплює мою інтуїцію.

C, 30 символів

main(i){++i&&main(i)+main(i);}

Якщо припустити переповнення підписаних двох компліментів та 32-бітові вкладиші, це призведе до приблизно 2 ^{2 32} викликів функцій, що має мати достатньо часу для завершення роботи Всесвіту.

GolfScript, 13 символів

0{).`,9.?<}do

Ця програма нараховує від 0 до 10 ^{9 9 −1} = 10 ^387420488 . Оптимістично припускаючи, що комп'ютер працює на частоті 100 ГГц і може виконувати кожну ітерацію програми за один цикл, програма запуститься протягом 10 ^{9 9 −12} секунд, або приблизно 3 × 10 ^{9 9 −20} = 3 × 10 ^387420469 років.

Щоб протестувати програму, ви можете замінити на 9a 2, що змусить її зупинитися на 10 ^{2 2 −1} = 10 ³ = 1000. (Використання а 3замість 2заклику зробить зупинку на 10 ^{3 3 −1} = 10 ²⁶ , що , навіть при наведених вище оптимістичних припущеннях він не досягне принаймні декількох мільйонів років.)

Автоматична клавіша 37

loop {
if (x+=1)>10^100000000
break
}

Хаскелл, 23

main=interact$take$2^30

Ця програма припиняється після читання 1073741824 символів з stdin. Якщо це запускається без підключення будь-яких даних stdin, вам доведеться набрати цю кількість символів на клавіатурі. Якщо припустити, що на вашій клавіатурі є 105 клавіш, кожна з яких оцінюється на 100 тис. Механічних циклів і запрограмована для генерування не мертвих натискань клавіш, автоматичне повторення вимкнено, а розетка клавіатури дозволяє 100 циклів підключення, це дає максимальну кількість натискань клавіш на час роботи комп'ютера - 1050000000, тобто недостатньо для завершення програми.

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

~ ATH, 56

У вигаданому мовою ~ ATH :

import universe U;
~ATH(U) {
} EXECUTE(NULL);
THIS.DIE()

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

Що багато ~ ATH-кодерів роблять, це імпортувати кінцеві конструкції та прив’язувати петлі до їхньої тривалості. Наприклад, головна петля тут закінчиться загибеллю Всесвіту з позначкою U. Таким чином, вам потрібно лише чекати мільярди років, щоб він закінчився, а не назавжди.

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

Якщо когось цим насправді розвеселили, детальніше: (1) , (2) , (3) , (4)

Рубін (34)

Лінія ([0]*9).permutation.each{print}займає приблизно 2,47 секунди за 9! друкує на моїй машині, в той час як лінійка ([0]*10).permutation.each{print}займає приблизно 24,7 секунди протягом 10! друкує, так що, мабуть, я можу екстраполювати тут і обчислити, (24.7/10!)*470! seconds in yearsщо становить 6,87 * 10 ^ 1040, який повинен бути часом виконання:

([0]*470).permutation.each{print}

JavaScript 68 62 символів

(function a(m,n){return m==0?n+1:a(m-1,n==0?1:a(m,n-1))})(5,1)

Для цього використовується функція Ackermann, яку можна записати як

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

Час його виконання збільшується в експоненціальному масштабі і тому обчислювати потрібно дуже багато часу. Незважаючи на те, що це не англійська мова, тут ви можете отримати огляд його повернених значень. Згідно таблиці, яка ackermann(5,1)дорівнює, 2↑↑(65533)-3що, ви знаєте, дуже велика.

Befunge '93 - 40 байт

(Програма 20x2)

v<<<<<<<<<<<<<<<<<<<
>??????????????????@

Ця програма покладається на випадкові числа, щоб дати їй затримку. Оскільки перекладачі Befunge досить повільні, ця програма повинна відповідати рахунку. І якщо цього не відбувається, ми завжди можемо розширити його по горизонталі. Я не точно впевнений, як рухатись до розрахунку очікуваного часу роботи цієї програми, але я знаю, що кожен? має шанс 50/50 перейти або змінити горизонтальне положення на 1. Є 18? Я думаю, що це має бути щось, що відповідає (18 ^ 2)!

РЕДАКТИРУЙТЕ: У жодному разі я не помітив іншої відповіді Befunge, це моя перша публікація тут. Вибачте.

APL, 10

Я не думаю, що це правильна відповідь (оскільки це не детерміновано), але все одно ......

{?⍨1e9}⍣≡1

Ця програма обчислює випадкову перестановку чисел 1e9 ( ?⍨1e9) і повторюється, поки два послідовні виходи не будуть рівними ( ⍣≡)

Отже, кожен раз, коли розраховується перестановка, вона має 1 на 1000000000! шанс припинити. І 1000000000! становить щонайменше 10 ^{10 8} .

Час, необхідний для обчислення перестановки, стає масовим 1000000000! Але деякі тестування показують, що це так, O(n)і екстраполяція дає приблизно 30 секунд.

Однак мій перекладач відмовляється приймати входи до випадкової функції, що перевищує 2 ³¹ -1 (тому я використовував 1e9), і генеруючи перестановки 1000000000 чисел, дав робочій області повну помилку. Однак, концептуально це можна зробити за допомогою ідеального перекладача APL з нескінченною пам'яттю.

Це приводить нас до можливості використання 2 ⁶³ -1 замість 1e9 для зменшення часу роботи щонайменше до 10 ^{10 20} , припускаючи 64-бітну архітектуру.

Але зачекайте, чи актуальна архітектура в ідеальному перекладачі? Пекло ні, так що насправді немає верхньої межі часу роботи !!

R, 45 байт

(f=function(x)if(x)f(x-1)+f(x-1)else 0)(9999)

Це стара нитка, але я не бачу відповіді на відповідь, і ми не можемо цього мати!

Час виконання для мене становило близько 1 секунди, коли х було 20, що передбачає час виконання 2 ^ 9979 секунд.

Якщо ви заміните нуль на одиничний, то вихід буде дорівнює 2 ^ х, але, як він стоїть, вихід дорівнює нулю, будь-який з x (уникне проблем із переповненням).

Javascript, 120 байт

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

Це може бути зроблено з мінімальним обсягом пам'яті (можливо, менше половини мегабайт), але для зупинки потрібно (ймовірно) приблизно 10 ^{8 750} років.

Неодноразово збільшується база малої ендіан-9 BigInteger, поки вона не досягне 9 ^{10 4 -1} .

Пітон 3, 191 байт

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

По-перше, f - рекурсивна факторіальна функція і надто повільна. Потім є 9 * 10⁹⁹⁹ порошок з собою, що генерує OverflowError, але цього не відбувається на цьому комп'ютері Unobtanium. For-Loop ітератує 9E999! ^ (9E999 ^ 9E999)! разів, і це переходить лише до наступної ітерації, якщо 9E999! +1 випадкові вставки між 0 і 9E99 * ^ i! всі 0, і в кожній ітерації циклу while встановлюється значення (9E999 ^ s) !. Так, я забув, що друк з s займає muuuuccchhhhh час ...
Я знаю, що це не найкоротший дозвіл, але я думаю, що це дійсно ефективно. Чи може хтось допомогти мені обчислити час роботи?

Машина Тьюрінга, але набагато гірша , 167 байт

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

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

Потрібно запустити 6-штатний 2-символ Зайнятий бобер зі сторінки Вікіпедії .

$7.412 \times 10^{36534}$