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

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

Самый короткий код выигрывает.

Funge-98 ( cfunge), 1 байт

9

Я бы опубликовал это раньше, но решил протестировать его, и потребовалось некоторое время, чтобы вернуть мой компьютер в рабочее состояние. cfungeхранит стек Funge в куче операционной системы (которую легко проверить, запустив программу с небольшим ограничением памяти, что я и должен был сделать раньше!), таким образом, бесконечно растущий стек (как с этой программой, которая просто выдвигает 9несколько раз; Программы Funge, перенесенные с конца строки на начало по умолчанию, будут выделять память навсегда. Эта программа, вероятно, также работает в некоторых реализациях Befunge-93.

Интереснее:

"NULL #(4

Это была моя первая идея, и она представляет собой бесконечное распределение, которое не зависит от стека Funge (хотя оно также разрушает стек Funge). Для начала, "команда помещает копию остальной части программы в стек (это строка, и программа оборачивается, поэтому закрывающая кавычка также служит открытой кавычкой). Затем Nотражается (по умолчанию это не имеет смысла), вызывая запуск программы в обратном направлении. В "пробеги снова, и толкает программу в стек - наоборот это время, с Nна вершине стека - то программа обтекает, загружая библиотеку с именем 4-буквенного ( 4(, а NULLбиблиотека является частью cfungeстандартная библиотека). NULLопределяет все заглавные буквы , чтобы сделать отражать, так что Lотражает, то#скачет библиотеки нагрузки на пути обратно, 4выталкивает барахло мы не заботимся о том, чтобы стек и всей программе повторяется с самого начала. Учитывая, что загрузка библиотеки несколько раз имеет эффект, и требует, чтобы список команд библиотеки хранился один раз для каждой копии библиотеки (это подразумевается семантикой Funge-98), это приводит к утечке памяти через не стековое хранилище (которое является альтернативный метод определения «кучи», относительно языка, а не ОС).

Brainfuck, 5 байтов

+[>+]

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

Bash + coreutils, 5

или же

Руби, 5

`yes`

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

Спасибо @GB за указание, что это полиглот и в рубине.

Python, 16 байт

Сохраняет вложение, aпока не будет достигнута ошибка:

a=0
while 1:a=a,

Первые несколько итераций (в виде кортежей) выглядят так:

0
(0,)
((0,),)
(((0,),),)

и так далее и тому подобное.

> <> (Рыба), 1 байт

0

Попробуй это здесь!

0 может на самом деле заменить любое шестнадцатеричное число 1-е.

объяснение

0in> <> просто создает кодовое поле 1x1, в котором рыба может плавать. Она постоянно добавляет 0в стек, плавает вправо, что делает возврат в обратном направлении 0, снова добавляя его в стек. Это будет продолжаться вечно.

Java 101 байт

class A{public void finalize(){new A();new A();}public static void main(String[]a){for(new A();;);}}

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

Perl, 12 байт

{$"x=9;redo}

В Perl xоператор со строкой слева и числом справа создает повторяющуюся строку. Так "abc" x 3оценивает "abcabcabc".

x=Оператор мутирует левый аргумент, заменяя содержимое переменной на ее слева, в результате повторения его содержание , как много раз , как его правая рука указывает.

В Perl есть ряд встроенных переменных со странным именем, одна из которых $", чье начальное значение - один пробел.

redoОператор переходит к началу ограждающих {}.

В первый раз, когда x=оператор выполняется, он меняет значение $"с " "«на» " ", что составляет 9 пробелов.

Во второй раз, когда x=оператор выполняется, он меняет значение $"на " ", которое составляет 81 пробел.

В третий раз $"получается строка длиной 729 байт.

Я думаю, что вы можете видеть, куда это идет :).

sed, 5 байт

Golfed

H;G;D

Использование (любой вход будет делать)

sed 'H;G;D' <<<""

Разъяснения

#Append a newline to the contents of the hold space, 
#and then append the contents of the pattern space to that of the hold space.
H

#Append a newline to the contents of the pattern space, 
#and then append the contents of the hold space to that of the pattern space. 
G

#Delete text in the pattern space up to the first newline, 
#and restart cycle with the resultant pattern space.
D

Скриншот

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

Haskell, 23 19 байтов

main=print$sum[0..]

Распечатать сумму бесконечного списка

C ++ (с использованием компилятора g ++), 27 23 15 байт

Спасибо Neop за помощь в удалении 4 байтов

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

main(){main();}

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

Это решение на самом деле утечки памяти.

main(){for(;;new int);}

Выход Valgrind

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

==2582== LEAK SUMMARY:
==2582==    definitely lost: 15,104,008 bytes in 3,776,002 blocks
==2582==    indirectly lost: 0 bytes in 0 blocks
==2582==      possibly lost: 16 bytes in 4 blocks
==2582==    still reachable: 4 bytes in 1 blocks
==2582==         suppressed: 0 bytes in 0 blocks

ЯВА, 81 79 78 байт

JAVA (HotSpot) 71 70 байт

Короче, чем другие ответы Java на момент публикации (81, позднее 79 байт):

class A{public static void main(String[]a){String x="1";for(;;)x+=x.intern();}}

По предложению @Olivier Grégoire можно сохранить еще один байт:

class A{public static void main(String[]a){for(String x="1";;)x+=x.intern();}}

Размещение x+=x.intern()в качестве приращения цикла for ничего не поможет, потому что точка с запятой все еще требуется для завершения оператора for.

Как предлагает @ETHproductions, x+=xтоже просто работает работает:

class A{public static void main(String[]a){String x="1";for(;;)x+=x;}}

Который может также извлечь выгоду из подсказки @Olivier Grégoire:

class A{public static void main(String[]a){for(String x="1";;)x+=x;}}

Мое единственное опасение по этому поводу состоит в том, что не гарантируется выделение данных в куче , поскольку эффективная JVM может легко понять, что xникогда не ускользнет от локальной функции. Использование intern()позволяет избежать этой проблемы, потому что интернированные строки в конечном итоге хранятся в статическом поле. Однако HotSpot генерирует OutOfMemoryErrorдля этого кода, так что я думаю, что все в порядке.

Обновление: @Olivier Gregoire также отметил, что x+=xкод может работать, StringIndexOutOfBoundsExceptionа не OOMкогда много памяти доступно. Это потому, что Java использует 32-битный intтип для индексации массивов (а строки - это просто массивы char). Это не влияет на x+=x.intern()решение, так как память, необходимая для последнего, является квадратичной по длине строки и, следовательно, должна увеличиваться до порядка 2 ^ 62 выделенных байтов.

Perl 6 , 13 байт

@= eager 0..*

Объяснение:

@ = сохранить результат в безымянный массив

eager сделать следующий список нетерпеливым

0 .. * бесконечный диапазон, начинающийся с нуля

///, 7 байт

/a/aa/a

Постоянно заменить aс aa, объявление тошноты.

Python 3, 16 байт

i=9
while 1:i*=i

Это связано с тем, что в Python 3 нет ограничений на целочисленный размер; вместо этого целые числа могут занимать столько памяти, сколько может обработать система (если что-то в моем понимании этого неверно, исправьте меня).

Ржавчина, 46 байт

fn main(){loop{std::mem::forget(Box::new(1))}}

Заметили что-нибудь интересное в этой программе Rust, утечка выделений кучи до нехватки памяти?

Это верно, нет небезопасного блока. Rust гарантирует безопасность памяти в безопасном коде (без чтения неинициализированных данных, чтения после освобождения, двойного освобождения и т. Д.), Но утечки памяти считаются совершенно безопасными. Есть даже явная функция, которая заставит компилятор забыть об очистке RAII от переменных вне области видимости, которые я здесь использую.

TI-83 Hex Assembly, 7 байтов

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

Создает appvars бесконечно, пока ERR:MEMORYОС не выбрасывает их. Беги с Asm(prgmM). Я считаю каждую пару шестнадцатеричных цифр одним байтом.

Python, 8 байт

2**9**99

О.П. позволило техничность программы , которая технически не запустить «навсегда», но выделяет больше памяти , чем любой компьютер мог справиться. Это не совсем googolplex (то есть 10**10**10011 байт), но наивно, лог-база 2 числа

>>> 9**99.
2.9512665430652752e+94

то есть, 10 ^ 94 бит, чтобы представить это. Вольфрам Альфа считает, что это на 10 ^ 76 больше, чем глубокая паутина (имейте в виду, что во вселенной около 10 ^ 80 атомов ).

Почему 2 вместо 9 ты спрашиваешь? Это не имеет большого значения (использование 9 увеличит количество битов только в два раза log2(9) = 3.2, что не изменит показатель степени). Но с другой стороны, программа работает намного быстрее с 2, так как расчет проще. Это означает, что он немедленно заполняет память, в отличие от версии 9, которая занимает немного больше времени из-за необходимых вычислений. Не обязательно, но приятно, если вы хотите «проверить» это (что я и сделал).

Желе , 3 2 байта

-1 байт благодаря Денису ( Wобертывания)

Wß

Ссылка (то есть функция или метод), которая также работает как полная программа, которая рекурсивно оборачивает свои входные данные в список.

Входные данные начинаются с нуля, поэтому первый проход создает список. [0]
Затем второй проход делает это [[0]]
. Третий проход делает это [[[0]]]
и так далее ...

Предыдущие 3 байта, которые протекают намного быстрее:

;Ẇß

рекурсивно объединяет все непустые смежные подсписки своего ввода с его вводом.
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]и так далее ...

Java 7, 106 байт

class A{public void finalize(){for(;;)Thread.yield();}public static void main(String[]a){for(;;)new A();}}

Меньше гольфа

class A{
    @Override
    public void finalize(){
        for(;;) {
            Thread.yield();
        }
    }
    public static void main(String[]a){
        for(;;){
            new A();
        }
    }
}

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

Java 7 (забавная альтернатива), 216 байт

import sun.misc.*;class A{public static void main(String[]a)throws Exception{java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");f.setAccessible(1>0);for(;;)((Unsafe)f.get(null)).allocateMemory(9);}}

Меньше гольфа

import sun.misc.*;
class A{
    public static void main(String[]a)throws Exception{
        java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe u = (Unsafe)f.get(null);
        for(;;) {
            u.allocateMemory(9);
        }
    }
}

Это весело больше всего на свете. Этот ответ использует Unsafeбиблиотеку Sun, которая является недокументированным внутренним API. Возможно, вам придется изменить настройки компилятора, чтобы разрешить API с ограниченным доступом. Unsafe.allocateMemoryвыделяет определенное количество байтов (без какой-либо проверки границ), которые не находятся в куче и не находятся под управлением java-сборщика мусора, поэтому эта память будет сохраняться до тех пор, пока вы не вызовете Unsafe.freeMemoryили пока jvm не исчерпает память

Haskell, 24 байта

f x=f$x*x
main=pure$!f 9

Основная проблема в Haskell - победить лень. mainдолжен иметь какой-то IOтип, поэтому простой вызов main=f 9не будет работать. Использование main=pure(f 9)поднимает тип f 9к IOтипу. Однако использование таких конструкций, как main=pure 9ничего не делает, 9возвращается или отображается нигде, а просто отбрасывается, поэтому нет необходимости оценивать аргумент pure, следовательно main=pure(f 9), не вызывает выделение какой-либо памяти, как fэто не вызывается. Для обеспечения оценки $!оператор существует. Он просто применяет функцию к аргументу, но сначала оценивает аргумент. Таким образом, использование main=pure$!f 9оценивает fи, следовательно, постоянно выделяет больше памяти.

постоянный ток, 7 байтов

[ddx]dx

[ddx]толкает строку, содержащую «ddx» в стек. dxдублирует его, затем выполняет его как код (оставляя одну копию в стеке). При выполнении он создает две копии, затем выполняет одну, оставляя еще одну копию в стеке каждый раз.

Haskell (использует ghc 8.0.1), 11 байт

m@main=m>>m

Нехвостая рекурсия. mainназывает себя, а потом снова себя.

C (linux), 23 байта

main(){while(sbrk(9));}

sbrk()увеличивает верхнюю часть сегмента данных на заданное количество байтов, тем самым эффективно увеличивая объем памяти, выделенной программе - по крайней мере, как указано в VIRTполе topвывода. Это работает только в Linux - реализация macOS, по-видимому, является эмуляцией, которая позволяет выделять только до 4 МБ.

Итак, немного более общий ответ:

C, 25 байтов

main(){while(malloc(9));}

Я смотрел это на мониторе активности MacOS. До 48 ГБ, а затем процесс получил сигнал SIGKILL. FWIW мой MacBook Pro имеет 16 ГБ. Большая часть используемой памяти была сообщена как сжатая.

Обратите внимание, что этот вопрос фактически требует записи каждого выделения, что здесь явно не происходит. Однако важно отметить, что для каждого malloc(9)вызова выделяются не только 9 запрошенных пользователем байтов. Для каждого выделенного блока будет заголовок malloc, который также выделяется где-то в куче, что обязательно записывается malloc()внутренними компонентами.

Perl, 4 байта

do$0

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

Ракетка, 13 байт

(let l()(l)1)

Я не совсем уверен, подпадает ли мой ответ под этот вопрос. Пожалуйста, дайте мне знать, если я должен удалить этот ответ.

JavaScript 22 21 17 16 15 байт

for(a=0;;)a=[a]

Сохраните 4 байта, обернув список в другой список, как в ответе @Jonathan Allan's Jelly.

Сохранено 1 байт благодаря @ETHProductions

Альтернативное решение 15 байт (работает только с правильными оконечными вызовами)

f=a=>f([a]);f()

Рубин, 11 байт

loop{$*<<9}

Продолжает нажимать 9на $*массив, который изначально содержит аргументы командной строки для процесса Ruby.

05AB1E , 2 байта

[A

Попробуйте онлайн! Просто буду продолжать давить abcdefghijklmnopqrstuvwyxzна стек на вечность.

Все возможные 2-байтовые решения:

[  # Infinite loop.
 A # Push alphabet.
 0 # Push 0.
 1 # Push 1.
 2 # Push 2.
 3 # Push 3.
 4 # Push 4.
 5 # Push 5.
 6 # Push 6.
 7 # Push 7.
 8 # Push 8.
 9 # Push 9.
 T # Push 10.
 X # Push 1.
 Y # Push 2.
 ® # Push -1.
 ¶ # Push \n.
 º # Push len(stack) > 0, so 0 once then 1 for eternity.
 ð # Push a space.
 õ # Push an empty string.
 ¾ # Push 0.
 ¯ # Push [].
 M # Push -inf.
 ) # Wrap current stack in an array.

Python, 35 байт

def f(a=[]):a.append(a)
while 1:f()

a никогда не выпускается и просто становится больше, пока вы не нажмете MemoryError

Вы можете посмотреть исполнение на Python Tutor .

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(все 1-байтовые токены и две строки)

Это постоянно приводит к утечке памяти, потому что структурированный поток управления, такой как Whileожидаемое закрытие, Endи помещает что-то в стек (не в стек ОС, а в отдельный стек в кучной памяти), чтобы отслеживать это. Но здесь мы используем, Gotoчтобы выйти из цикла (так что no Endвыполняется, чтобы удалить объект из стека), Whileснова виден, объект снова перемещается и т. Д. Так что он просто продолжает нажимать их, пока вы не получитеERR:MEMORY