Если программа завершается, и ее никто не видит, она останавливается?


99

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

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

Вы можете предположить, что:

  • Вселенная умрет от энтропии через 10 1000 лет.
  • Твой компьютер:
    • Будет переживать вселенную, потому что она сделана из 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      

* Upvotes 31/08


40
У меня возник соблазн создать тег [slowest-code] для этого вопроса. : P
Дверная ручка

5
Богосорт не будет работать, потому что, хотя это невероятно невероятно, что он никогда не закончится, ему может потребоваться бесконечное количество времени, чтобы закончить. Однако существует множество ужасных регулярных выражений на основе NFA, которые могут удовлетворять критериям «закончим, но не до того, как вселенная умрет».
DavidO

49
Ваш заголовок должен быть футболкой
user-2147482637

4
Хороший вопрос, но разве это не должен быть конкурс на популярность?
IazertyuiopI

Ответы:


34

CJam, 5 байтов

0{)}h

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

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

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

Размер кучи по умолчанию на моем компьютере составляет 4 179 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 10 065 537 393 секунды, что превышает 10 10 065 537 385 лет.


14
Я не думаю, что вы можете полагаться на ограниченные ресурсы, поскольку вопрос гласит: «У вашего компьютера бесконечный предел памяти / стека / рекурсии».
Грег Хьюгилл

4
Бесконечная память, !=бесконечные типы данных. Если у меня есть терабайт оперативной памяти, 8-разрядное целое число без знака по-прежнему может
доходить

6
@GregHewgill: с неограниченными ресурсами вы можете увеличить максимальный размер кучи Java до любого произвольного значения, но оно всегда будет конечным.
Деннис

2
@Dennis, но затем просто добавляйте строку каждый раз через цикл, чтобы удвоить размер кучи. Это забавная вещь о бесконечностях :-)
Карл Виттофт

9
@CarlWitthoft: Вы не можете сделать это изнутри программы.
Деннис

62

JavaScript, 39

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

объяснение

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

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

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

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

РЕДАКТИРОВАТЬ: Как отмечено в комментариях, Fib(9007199254740992)составляет примерно 4,4092 * 10 1882393317509686 , что действительно достаточно велико.


9
Поскольку fib(n)может быть аппроксимирован phi^n, мы можем использовать, log((sqrt(5) + 1)/2)*9007199254740992чтобы вычислить, сколько цифр fib(9007199254740992)получается 1.8823933*10^15.
переиздание

11
@overactor, по словам Вольфрама Альфа, Fib(9007199254740992)(используя непрерывную форму с phi) примерно 4.4092... * 10^1882393317509686. Расчет
Брайан С.

1
наращивание стека не снижает скорость процессора ... если вы не учитываете ограниченную ширину адресной строки памяти / неограниченную ширину адреса (в этом случае замедление по-прежнему линейно по длине адреса при условии разумного кодирования) или даже физические ограничения в памяти и скорость света (в этом случае замедление в значении адреса cbrtic при условии пространственного хранения; даже уровни плотности данных ДНК в конечном итоге начинают складываться, даже если вы управляете произвольным доступом с эффективным использованием пространства)
Джон Дворжак

1
@JamesKhoury Нет, функция, которую вы только что написали, эквивалентна for(x=0;x!=++x;)и повторяется только 9007199254740992 раза.
Питер Олсон

4
@SylvainLeroux архитектура с бесконечными объемами ОЗУ, вероятно, просто чередует кучу и стек и заставит их обоих расти вверх.
Джон Дворжак

47

Python (9)

9**9**1e9

Это имеет более 10 ** 10000000 битов, поэтому вычисление этого должно перенести нас далеко после тепловой смерти.

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

Редактировать: Гольф два символа, удаляя паренсов благодаря @ user2357112. TIL, что Python рассматривает последующие показатели как энергетическую башню.


4
Ошибка переполнения: (34, «Результат слишком велик»)
apple16

93
@ apple16 Может быть на вашем компьютере, но у моего "бесконечный лимит памяти / стека / рекурсии".
xnor

64
Все нормально, ребята. Я запустил его в прошлой вселенной и получил ...82528057365719799011536835265979955007740933949599830498796942400000000009(2,6 * 10 ^ 954242509 цифр пропущено, чтобы избежать коллапса черной дыры ). Вы должны действительно перейти на Unobtanium.
xnor

10
Экспонирование является ассоциативным справа, поэтому вы можете опустить скобки.
user2357112

10
Стоит отметить, что 9**9**9e9он такой же короткий и требует немного больше длины вселенной для вычисления, а также выглядит немного лучше.
abarnert

35

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) цифр в секунду.


22
Но это прекратится задолго до этого с сообщением «принтер из бумаги» ...
Флорис

1
@ Флорис, кто, черт возьми, использует физические носители в эти дни?
Джон Дворак

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

2
@PeterTaylor - может быть , не совсем , что старый, но я являюсь достаточно стар , чтобы напомнить о представлении «пакетных заданий» на «компьютер» (в те дни , когда не было никаких сомнений, в студенческой популяции 20k, что компьютер вы имели в виду), и собирать распечатку на следующий день. Вы (и 7 других) правильно предположили, что это была попытка юмора, а не серьезная критика вашего превосходного и смехотворно короткого сценария.
Флорис

35

Marbelous 68 66 байт

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

Marbelous - это 8-битный язык со значениями, представленными шариками только на машине, похожей на Rube Goldberg, так что это было не очень легко. Этот подход примерно эквивалентен следующему псевдокоду:

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

поскольку максимальное значение равно 256 (в программе Marbleous оно представлено 0, который обрабатывается по-разному в разных местах), recursiveFunction (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будут поданы все остальные соответствующие . Затем мрамор уменьшается, телепортируется и дублируется, как в ранее описанном цикле. Правильная копия затем проверяется на неравенство с помощью zero ( >0), если она не равна 0, она проваливается. Если он равен 0, он сдвигается вправо и приземляется !!, что завершает доску.

Итак, пока у нас есть цикл, который непрерывно ведет обратный отсчет от 255 до 0 и позволяет другому, аналогичному циклу (запитанному входом командной строки) запускаться один раз каждый раз, когда он достигает 0. Когда этот второй цикл выполняется n раз (максимум 256) ) программа завершается. Так что это максимум 65536 циклов цикла. Не достаточно, чтобы пережить вселенную.

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

Это должно выглядеть знакомо, входные данные уменьшаются один раз, затем это значение циклично оборачивается и копируется (обратите внимание, что мрамор уменьшается только один раз, а не при каждом запуске цикла). Затем он проверяется на равенство 0 и, если он не равен нулю, попадает на MB. Это функция в Marbelous, каждый файл может содержать несколько досок, и каждая доска - это функция, каждая функция должна быть названа перед сеткой :[name]. Каждая функция, кроме первой функции в файле, которая имеет стандартное имя: МБ. Таким образом, этот цикл непрерывно вызывает основную плату снова со значением, n - 1где n - это значение, с которым был вызван этот экземпляр функции.

Так почему же n*512?

Итак, первый цикл выполняется за 4 такта (и 256 раз), а второй цикл выполняется n раз до завершения платы. Это означает, что доска работает около n*4*256тиков. Последний цикл (который выполняет рекурсивный вызов функции) является компактным и выполняется в 2 такта, что означает, что ему удается вызывать функцию n*4*256/2 = n*512раз.

Какие символы вы не упомянули?

\/ Это мусорное ведро, которое удаляет шарики с доски, это гарантирует, что сброшенные шарики не будут мешать другим шарикам, которые зацикливаются в цикле, и предотвращают завершение программы.

бонус

Так как шарики, которые падают с нижней части мраморной доски, выводятся в STDOUT, эта программа печатает множество символов ASCII во время работы.


2
Отличное объяснение, спасибо!
бета-распад

2
Вау, это блестящая идея! Marbelous язык так весело!
Рубик

2
+1 Как раз то, что я хотел увидеть. Сумасшедший язык, чем BrainFuck :) Есть ли веб-сайт с учебником и дополнительной информацией о нем? (Кажется, в названии ссылки меньше документов, чем в вашем ответе)
Сильвестр

2
@Sylwester, я рад, что вам это нравится, Marbelous в настоящее время все еще находится в стадии разработки, но мы ожидаем, что он будет в более стабильном состоянии в ближайшем будущем, и на этом этапе учебники, более обширная документация, стандартные библиотеки и, надеюсь, онлайн-переводчик следовать.
Сверхактор

21

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), но я уверен, что для его оценки потребуется поразительно много времени.


5
+1 ... Я пытался найти язык со встроенной функцией Аккермана, но не смог сделать это, пока у меня не закончилось терпение. : D
Мартин Эндер

3
$n?A($m-1,A($m,$n-1)):A($m-1,1)позволяет легко сохранять 8 символов, нажимая на троичного оператора.
Питер Тейлор

3
Я почти уверен, что число цифр в A (9,9) больше, чем объем наблюдаемой вселенной, измеренный в кубических длинах Планка.
Касперд

6
@kasperd Это довольно серьезное преуменьшение. Объем наблюдаемой вселенной составляет лишь порядка 10 ^ 184 планковых объемов. Для сравнения, в числе, описывающем количество цифр в A (4,4), есть что-то вроде 10 ^ 19700 цифр, что, в свою очередь, непостижимо мало по сравнению с A (9,9).
user19057

3
@ user19057 Звучит так, будто называть заявление Касперда «массовым занижением» - это серьезное занижение. : P
Нику Стирка,

20

MATLAB, 58 52 символа

Нам нужно по крайней мере одно арифметическое решение конечной точности, следовательно:

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

x = единицы (1,999); y = x; в то время как any (y), y = mod (y + x, простые числа (7910)); конец

( спасибо @DennisJaheruddin за то, что он сбил 6 символов )

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


+1 Мне понадобилось время, чтобы увидеть, что ты там делаешь. Приятно!
Фиксированная точка

+1 ЭЛТ, не так ли?
flawr

Хорошо, я думаю, что некоторые символы могут быть сохранены следующим образом: y = единицы (1,999), тогда как y * y ', y = mod (y + 1, простые числа (7910)); конец
Деннис Джаэруддин

@DennisJaheruddin: блестящее сокращение. Я обновлю.
COTO

Хотя это уже не одно и то же решение, оно все равно должно быть достаточно похожим, и снова немного короче:p=1:9e9;y=p;while+y*y',y=mod(y+1,p),end
Деннис Джаэруддин

19

Mathematica, 25 19 байтов

Это решение было опубликовано до того, как временные функции были дисквалифицированы.

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

TimeUsed[]возвращает секунды с начала сеанса, а Mathematica использует типы произвольной точности. В году около 10 7 секунд, поэтому достаточно 10 10000 секунд.

Более короткая / простая (/ действительная) альтернатива:

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

Давайте просто посчитаем вместо этого. Нам придется посчитать немного дальше, потому что мы можем сделать довольно много приращений в секунду, но верхний предел на самом деле не стоит символов.

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


Любить это! Этот ответ заставил меня смеяться вслух с широкой улыбкой на лице.
Тодд Леман

1
Извините, ради творчества мне пришлось отказаться от решений, основанных на времени (как и ваше первое). Пожалуйста, не ненавидь меня. :)
kb_sou

5
@kbsou Ну, я победил его с другим, так что мне все равно. Но в противном случае дисквалификация ответов ретроспективно для изменений правил не круто, хотя. ;)
Мартин Эндер

1
Действительно ли Mathematica настолько медленный, что вычисление 9^9^9занимает больше 10^1000лет? По моим оценкам, 9^9^9для использования моего U7300 с частотой 1,3 ГГц bcпотребуется менее 6 месяцев. (На основе экстраполяции времени для вычисления 9^200000и 9^400000.)
kasperd

2
@ArtOfCode Mathematica использует типы произвольной точности, поэтому он на самом деле попытается определить правильное значение.
Мартин Эндер

16

Питон 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вселенные. Это предполагает, конечно, что unobtainium может пережить Большой взрыв.


3
он заканчивается, как только достигает конца диапазона @Philipp. да, это заканчивается, в конце концов.
Малахи

1
1000**1000это 1e3000не 1e2000.
Кукурузные початки

1
@ Cornstalks Спасибо, у меня не было достаточно хорошего калькулятора, чтобы найти его, поэтому я сделал предположение, основываясь на том факте, что 100**100=1E200.
бета-распад

1
@BetaDecay: я мог бы предложить Wolfram | Alpha в качестве онлайн-калькулятора . Если вы никогда не использовали его, это очень здорово!
Кукурузные початки

2
@anyoneinterested Or 1000 ^ 1000 = (10 ^ 3) ^ 1000 = (10 * 10 * 10) * (10 * 10 * 10) * ... * (10 * 10 * 10) [1000 раз] = 10 ^ 3000
IazertyuiopI

12

Python 59 (работает большую часть времени)

Я не смог устоять

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

Хотя теоретически это может прекратиться менее чем за миллисекунду, среднее время выполнения значительно превышает 10^400указанный срок жизни юниверса. Спасибо @BetaDecay, @undergroundmonorail и @DaboRoss за сокращение до 17 символов или около того.


Чтобы уменьшить его до 71, вы можете заменить continueнаpass
Beta Decay

@BetaDecay Хороший улов
KSab

3
Я думаю, поскольку вопрос требует ожидаемого времени выполнения, это не проблема, что это может закончиться рано. Большая проблема заключается в том, что это не может быть доказано, чтобы прекратить вообще.
user19057

4
@ user19057 Предполагая, что сказал KSab, ожидаемое время выполнения конечно, и программа завершается с вероятностью 100%. Конечно, случайный модуль на самом деле использует PRNG, который является циклическим, поэтому, скорее всего, он никогда не завершится.
Джером Баум

1
Я думаю, что вы можете обрезать 3 символа, заменив «pass» на «0».
Даборосс

8

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. Wolfram | Alpha говорит, что 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число наносекунд во вселенной, но я должен признать, что понятия не имею, как можно выяснить реальные времена этих вещей.

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


7

C 63 56 символов

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

Это основано на идее парня по имени Вильгельм. Мой единственный вклад - сжатие кода до этой короткой (и нечитаемой) части.

Доказательство того, что это заканчивается, делается по индукции.

  • Если х равен 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 секунд. Это число имеет больше цифр, чем число кварков в наблюдаемой вселенной.


(Ab) использовать препроцессор и определить m = main, r = return и z = 99999, затем переписать вашу программу как, f (x, y) {rx? F (x-1, y? F (x, y- 1): 1): y + 1;} m () {f (z, z);}, что займет невероятно много времени :-)
ChuckCottrill

5
@ChuckCottrill Если правила разрешают программы, которые требуют определенных макросов препроцессора, а те не учитывают длину программы, то любая задача может быть решена одним символом.
Касперд

6

Matlab ( 10 8 символов)

1:9e1016

ИМХО, большинство записей слишком стараются, вычисляя большие, сложные вещи. Этот код просто инициализирует массив 9x10 1016 double с, считая с 1, что занимает 7,2x10 ^ 1017 байт. На современном процессоре с максимальной пропускной способностью памяти 21 ГБ / с или 6,63x10 ^ 17 байт / год даже инициализация массива займет не менее 1,09x10 1000 лет, не говоря уже о том, чтобы попытаться напечатать его, поскольку я не беспокоился подавление вывода завершающей точкой с запятой. (;


старое решение

nan(3e508)

альтернативно

inf(3e508)

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


1
Что это? 1016? Это должно быть 9999! (Или я что-то не так понял?)
Mega Man

@MegaMan В проблемной подсказке запрашивается нижняя граница времени выполнения 10 ^ 1000 лет. Поскольку я играл в гольф, я не хотел быть расточительным и вычислять слишком долго, поэтому попытался остановить его как можно скорее после достижения порога. :)
Нику Стирка

ах, ладно, не знал этого правила
Mega Man

5

Perl, 16 символов

/$_^/for'.*'x1e9

Это создает строку, повторяющую «. *» Миллиард раз, а затем использует ее как иглу и стог сена в совпадении с регулярным выражением. Это, в свою очередь, заставляет механизм регулярных выражений пытаться выполнить каждый возможный раздел строки длиной два миллиарда символов. Согласно этой формуле из Википедии , существует около 10 35218 таких разделов.

Вышеупомянутое решение имеет длину 16 символов, но требует только около 2 ГБ памяти, что означает, что его можно запустить на реальном компьютере. Если мы предполагаем бесконечную память и конечный размер регистра (что, вероятно, не имеет смысла), его можно сократить до 15 символов, в то же время значительно увеличив время выполнения:

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

(Я не тестировал его, но думаю, что он может работать с 32-битным Perl, построенным на 64-битной машине с не менее 6 ГБ ОЗУ.)

Примечания:

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

4

J (12)

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

К чему это сводится в Python (при условии !работы):

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

РЕДАКТИРОВАТЬ:

Ну, программа может занять не более 2 × 10^-1858926секунд за цикл, чтобы завершить в течение требуемого времени. Совет: это не сработает даже для первого цикла, не говоря уже о последнем;).

Кроме того: этой программе может потребоваться больше памяти, чем энтропии во вселенной ...


3
«может потребоваться больше памяти, чем есть энтропия во вселенной» - Вы можете сократить это с помощью xrange();)
Stefan Majewsky

1
Кроме того, !не работает в Python. Вам нужно import mathи math.factorial().
daviewales

4

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

Вы можете сохранить 10 байтов, переименовав ackфункцию в одно-символьное имя, например a.
pppery

4

Первая попытка кода гольф, но здесь идет.

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

РЕДАКТИРОВАТЬ: Я разработал математику, и вероятность этого в каждом цикле составляет 1 в 2 ^ 128 ^ (1 + 2 ^ 64), что составляет около 20000 цифр в длину. Предполагая, что 1000000 циклов в секунду (приблизительное число), 30000000 с / год, что составляет 3 * 10 ^ 13 циклов в год, оставшееся 10 ^ 1000 лет - это 3 * 10 ^ 1013 циклов, так что это, вероятно, будет длиться примерно в 20 раз больше оставшееся время осталось во вселенной. Я рад, что моя математика поддерживает мою интуицию.


Я думаю, что последняя строка должна быть While x=1, верно? (иначе это бесконечный цикл). Кроме того, вы можете сбрить 12 символов при замене Dim x As Doubleна x=0(VBA не требует объявления переменных, если вы не укажете Option Explicit)
kb_sou

Я не смотрю на это как на бесконечный цикл, так как он разрывается, когда x переполняется, что в конечном итоге.
Майлз Хорн

Это определенно не работает, пока x = 1, так как это обычно препятствует выполнению цикла.
Майлз Хорн

Если разрыв цикла таким образом не соответствует критерию «нет бесконечных циклов», WHILE 1 = 1 может измениться на WHILE ISNUMERIC (X).
Майлз Хорн

4

C, 30 символов

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

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


Вы выйдете из стека задолго до этого, хотя.
Спарр

1
@Sparr Одно из правил - предполагать бесконечный размер стека и кучи.
Scragar

3

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 3 = 1000. (Использование 3вместо a 2остановит ее на 10 3 3 −1 = 10 26 , что даже с оптимистическими предположениями, изложенными выше, оно не достигнет хотя бы нескольких миллионов лет.)



3

Хаскелл, 23

main=interact$take$2^30

Эта программа завершает работу после прочтения 1073741824 символов из stdin. Если он выполняется без передачи данных stdin, вам нужно будет набрать это количество символов на клавиатуре. Предполагая, что ваша клавиатура имеет 105 клавиш, каждая из которых рассчитана на 100 тыс. Механических циклов и запрограммирована для генерации не мертвых нажатий клавиш, автоповтор отключен, а гнездо для клавиатуры допускает 100 циклов подключения, что дает максимальное количество нажатий клавиш на один компьютер во время безотказной работы 1050000000, что составляет недостаточно для завершения программы.

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


Что делать, если вы будете менять клавиатуру в процессе работы?
Томас

Это покрыто 100 циклами подключения разъема клавиатуры.
TheSpanishInquisition

Но суть проблемы в том, что программа действительно завершается где-то после тепловой смерти вселенной. Эта программа не может быть завершена; как только энтропия станет достаточно высокой, у вас никогда не будет другой клавиатуры для подключения.
abarnert

1
Я до сих пор не уверен. Если вы запускаете программу удаленно (или в виртуальной машине), то вы не ограничены аппаратными возможностями одного компьютера, и 1 миллиард ударов действительно не так уж много. Кроме того, проблема говорит о том, что компьютер сделан из unobtainium, и поэтому клавиатура также должна быть, следовательно, она может обрабатывать 2 ^ 30 нажатий клавиш ...
Томас

3

~ ATH, 56

На вымышленном языке ~ ATH :

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

~ ATH - невыносимый язык для работы. Его логика состоит из ничего, кроме бесконечных циклов или, в лучшем случае, циклов эффективно бесконечной конструкции.

То, что делают многие кодеры ~ ATH, это импортирование конечных конструкций и привязка циклов к их продолжительности жизни. Например, основной цикл здесь закончится смертью вселенной, помеченной как U. Таким образом, вам нужно только ждать миллиарды лет, чтобы она закончилась, а не навсегда.

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

Если кого-то это действительно позабавило, подробности: (1) , (2) , (3) , (4)


2

Рубин (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}

2

JavaScript 68 62 символа

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

При этом используется функция Аккермана, которая может быть записана как

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что, вы знаете, очень большой.


2
Это может принести пользу от некоторых из тех же оптимизаций, что и более ранняя реализация функции Perl Ackermann.
Питер Тейлор

Должно быть, я упустил из виду решение Perl. Спасибо что подметил это.
henje

вместо n==0?X:Y, вы всегда можете сделатьn?Y:X
Cyoce

2

Befunge '93 - 40 байт

(Программа 20х2)

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

Эта программа полагается на случайные числа, чтобы дать ей задержку. Поскольку переводчики Befunge работают довольно медленно, эта программа должна отвечать всем требованиям. И если это не так, мы всегда можем расширить его по горизонтали. Я не совсем уверен, как рассчитать ожидаемое время выполнения этой программы, но я знаю, что каждый? имеет шанс 50/50 либо начать сначала, либо изменить горизонтальное положение на 1. Есть 18? Я думаю, что это должно быть что-то вроде (18 ^ 2) !, который Google Calculator говорит, что "Бесконечность"

РЕДАКТИРОВАТЬ: Ой, я не заметил другой ответ Befunge, это мой первый пост здесь. Сожалею.


Эй, не беспокойтесь о другом ответе befubnge, или, или вообще, используя тот же язык, что и кто-то другой. Я имею в виду, что никто не собирается побеждать в математике, так что все остальные представления о веселье. Мой был.
AndoDaan

2

APL, 10

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

{?⍨1e9}⍣≡1

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

Таким образом, каждый раз, когда вычисляется перестановка, она имеет 1 в 1000000000! шанс прекратить. И 1000000000! составляет не менее 10 10 8 .

Время, необходимое для вычисления перестановки, не имеет значения из-за массивности 1000000000 !. Но некоторые тесты показывают, что это так, O(n)и экстраполяция дает около 30 секунд.

Однако мой интерпретатор отказывается принимать входные данные для случайной функции, превышающей 2 31 -1 (поэтому я использовал 1e9), и генерация перестановок чисел 1000000000 дала ошибку полной рабочей области. Однако концептуально это можно сделать с помощью идеального интерпретатора APL с бесконечной памятью.

Это приводит нас к возможности использования 2 63 -1 вместо 1e9, чтобы увеличить время работы по крайней мере до 10 10 20 , предполагая 64-битную архитектуру.

Но подождите, уместна ли архитектура в идеальном интерпретаторе? Черт, нет, поэтому на самом деле нет верхней границы времени выполнения !!


2

R, 45 байт

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

Это старая ветка, но я не вижу ответа R, и мы не можем этого иметь!

Время выполнения для меня было около 1 с, когда х было 20, предлагая время выполнения 2 ^ 9979 секунд.

Если вы замените ноль на единицу, то результат будет 2 ^ x, но, как он есть, выход равен нулю, каким бы x ни был (избегает проблем переполнения).


1

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 лет, чтобы остановиться.

Многократно увеличивает BigInteger с начальным порядком байтов до 9, пока не достигнет 9 10 4 -1 .


1

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


1

Машина Тьюринга, но гораздо хуже , 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

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

Следует запустить Busy Beaver из 6 символов с двумя состояниями со страницы Википедии .

Как сказано на странице Википедии, он работает в 7,412×1036534шаги. Это намного больше, чем тепловая смерть, при условии, что она выполняет каждую команду более чем на одну наносекунду или равна ей.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.