Napisz program, który działa wiecznie i przydziela coraz więcej pamięci na stercie, im dłużej działa, przynajmniej dopóki nie osiągniesz limitu systemu operacyjnego na ilość pamięci, którą można przydzielić.

Wiele jąder nie rezerwuje faktycznie przydzielonej pamięci, dopóki jej nie wykorzystasz, więc jeśli twój program jest w C lub innym języku niskiego poziomu, musisz upewnić się, że napisałeś coś na każdej stronie. Jeśli używasz tłumaczonego języka, prawdopodobnie nie będziesz musiał się tym martwić.

Najkrótszy kod wygrywa.

Funge-98 ( cfunge), 1 bajt

9

Opublikowałbym to wcześniej, ale postanowiłem to przetestować i zajęło mi trochę czasu, aby przywrócić komputer do stanu używalności. cfungeprzechowuje stos Funge na stercie systemu operacyjnego (który można łatwo zweryfikować, uruchamiając program z małym limitem pamięci, co powinienem był zrobić wcześniej!), a więc nieskończenie rosnący stos (jak w przypadku tego programu, który po prostu naciska 9wielokrotnie; Domyślnie zawijanie programów od końca linii z powrotem do początku) przydzieli pamięć na zawsze. Ten program prawdopodobnie działa również w niektórych implementacjach Befunge-93.

Bardziej interesujące:

"NULL #(4

To był mój pierwszy pomysł i jest to nieskończona alokacja, która nie opiera się na stosie Funge (chociaż wysadza też stos Funge). Na początek "polecenie wypycha kopię pozostałej części programu na stos (jest to ciąg znaków, a program jest zawijany, więc cytat zamykający służy również jako cytat otwarty). Następnie Nodbija się (domyślnie nie ma znaczenia), co powoduje, że program działa wstecz. Do "ponownie biegnie i pcha program na stosie - okrągłe ten czas w inny sposób, przy czym Nna wierzchu stosu - to program otacza, ładuje bibliotekę o nazwie 4-literowego ( 4(, a NULLbiblioteka jest częścią cfungestandardowa biblioteka). NULLokreśla wszystkie wielkie litery do odzwierciedlenia, więc Lodzwierciedla,#pomija ładowanie biblioteki w drodze powrotnej, 4wypycha śmieci, które nas nie obchodzą, do stosu, a cały program powtarza się od początku. Biorąc pod uwagę, że wielokrotne ładowanie biblioteki ma efekt i wymaga, aby lista poleceń biblioteki była przechowywana raz dla każdej kopii biblioteki (wynika to z semantyki Funge-98), wycieka ona z pamięci przez pamięć bez stosu (która jest alternatywna metoda definiowania „sterty” w odniesieniu do języka, a nie systemu operacyjnego).

Brainfuck, 5 bajtów

+[>+]

Wymaga to interpretera, który nie ma ograniczenia długości taśmy.

Bash + coreutils, 5

lub

Ruby, 5

`yes`

yesprodukuje nieskończoną moc wyjściową. Wstawienie yesbackticksa każe powłoce przechwycić wszystkie dane wyjściowe, a następnie wykonać je jako polecenie. Bash będzie kontynuował przydzielanie pamięci dla tego niekończącego się ciągu, aż skończy się stos. Oczywiście wynikowy wynik byłby niepoprawnym poleceniem, ale powinniśmy zabraknąć pamięci, zanim to nastąpi.

Dzięki @GB za wskazanie, że jest to również poliglot w rubinie.

Python, 16 bajtów

Utrzymuje zagnieżdżanie, aaż do osiągnięcia błędu:

a=0
while 1:a=a,

Pierwsze kilka iteracji (jako krotki) wygląda następująco:

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

i tak dalej i tak dalej.

> <> (Ryba), 1 bajt

0

Wypróbuj tutaj!

0 można faktycznie zastąpić dowolną liczbą szesnastkową 1-f.

Wyjaśnienie

0in> <> po prostu tworzy szafkę kodową 1x1, w której ryby mogą pływać. Ciągle dodaje 0stos do stosu, pływa w prawo, co powoduje pętlę do tyłu 0, dodając go ponownie do stosu. Trwa to wiecznie.

Java 101 bajtów

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

Łapanie programu głównego w niekończącej się pętli po utworzeniu i wyrzuceniu obiektu. Wyrzucanie elementów bezużytecznych wykonuje wyciek, tworząc 2 obiekty dla każdego usuniętego

Perl, 12 bajtów

{$"x=9;redo}

W perlu xoperator z ciągiem po lewej stronie i liczbą po prawej tworzy ciąg powtarzający się. Tak "abc" x 3ocenia do "abcabcabc".

x=Operator mutuje lewy argument, zastępując zawartość zmiennej z lewej z wynikiem powtarzając jego zawartość tyle razy, ile jego prawej stronie wskazuje.

Perl ma pewną liczbę dziwnie nazwanych wbudowanych zmiennych, z których jedną jest $", której początkową wartością jest pojedyncza spacja.

redoOperator przeskakuje do początku załączania {}.

Przy pierwszym wykonaniu x=operator zmienia wartość $"z " "„na” " ", czyli 9 spacji.

Przy drugim wykonaniu x=operator zmienia wartość $"na " ", czyli 81 spacji.

Za trzecim razem $"staje się ciągiem spacji o długości 729 bajtów.

Myślę, że widać, dokąd to zmierza :).

sed, 5 bajtów

Grał w golfa

H;G;D

Użycie (wystarczy dowolne wejście)

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

Wyjaśniono

#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

Zrzut ekranu

Wypróbuj online!

Haskell, 23 19 bajtów

main=print$sum[0..]

Wydrukuj sumę nieskończonej listy

C ++ (przy użyciu kompilatora g ++), 27 23 15 bajtów

Dzięki Neop za pomoc w usunięciu 4 bajtów

To rozwiązanie tak naprawdę nie przecieka pamięci, ponieważ alokuje wszystko na stosie, a zatem powoduje przepełnienie stosu. Jest po prostu nieskończenie rekurencyjny. Każda rekurencja powoduje, że część pamięci zostaje przydzielona do momentu przepełnienia stosu.

main(){main();}

Alternatywne rozwiązanie

To rozwiązanie przecieka pamięć.

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

Wyjście Valgrind

Jest to wyjście Valgrind po zakończeniu programu na kilka sekund przed uruchomieniem. Widać, że z pewnością przecieka pamięć.

==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

JAWA, 81 79 78 bajtów

JAVA (HotSpot) 71 70 bajtów

Krótszy niż inne odpowiedzi Java w momencie, gdy publikowałem (81, później 79 bajtów):

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

Jak sugeruje @Olivier Grégoire, można zapisać kolejny bajt:

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

Umieszczenie x+=x.intern()jako przyrost pętli for nic by nie pomogło, ponieważ średnik jest nadal wymagany do zakończenia instrukcji for.

Jak sugeruje @ETHproductions, samo użycie x+=xrównież działa:

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

Które mogą również skorzystać z porady @Olivier Grégoire:

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

Moje jedyne wątpliwości co do tego polega na tym, że nie ma gwarancji przydzielenia danych na stercie , ponieważ wydajna maszyna JVM może łatwo zdać sobie sprawę, że xnigdy nie ucieka od funkcji lokalnej. Użycie intern()pozwala uniknąć tego problemu, ponieważ internowane łańcuchy ostatecznie są przechowywane w polu statycznym. Jednak HotSpot generuje OutOfMemoryErrordla tego kodu, więc myślę, że jest w porządku.

Aktualizacja: @Olivier Gregoire wskazał również, że x+=xkod może się uruchamiać, StringIndexOutOfBoundsExceptiona nie OOMkiedy jest dużo pamięci. Wynika to z faktu, że Java używa typu 32-bitowego intdo indeksowania tablic (a ciągi to tylko tablice char). Nie wpływa to na x+=x.intern()rozwiązanie, ponieważ pamięć wymagana dla tego drugiego jest kwadratowa pod względem długości łańcucha i dlatego powinna być skalowana w górę do 2 ^ 62 przydzielonych bajtów.

Perl 6 , 13 bajtów

@= eager 0..*

Wyjaśnienie:

@ = zapisz wynik w nienazwanej tablicy

eager spraw, aby poniższa lista była chętna

0 .. * nieskończony zakres, zaczynając od zera

///, 7 bajtów

/a/aa/a

Stale wymieniać az aaad nauseum.

Python 3, 16 bajtów

i=9
while 1:i*=i

Wynika to z faktu, że w Pythonie 3 nie ma ograniczenia rozmiaru liczb całkowitych; zamiast tego liczby całkowite mogą zająć tyle pamięci, ile system może obsłużyć (jeśli coś w moim rozumieniu tego jest błędne, popraw mnie).

Rdza, 46 bajtów

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

Zauważasz coś interesującego w tym programie Rust, przecieki przydziałów sterty aż do braku pamięci?

Zgadza się, nie ma niebezpiecznego bloku. Rdza gwarantuje bezpieczeństwo pamięci w bezpiecznym kodzie (brak odczytu niezainicjowanych danych, odczyt po wolnym, podwójnym wolnym itd.), Ale wycieki pamięci są uważane za całkowicie bezpieczne. Istnieje nawet wyraźna funkcja pozwalająca kompilatorowi zapomnieć o czyszczeniu RAII zmiennych poza zakresem, których tutaj używam.

Zestaw sześciokątny TI-83, 7 bajtów

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

Tworzy appvars w nieskończoność, dopóki system ERR:MEMORYoperacyjny nie wyrzuci znaku an . Uruchom z Asm(prgmM). Liczę każdą parę cyfr szesnastkowych jako jeden bajt.

Python, 8 bajtów

2**9**99

OP pozwoliło na technicyzacji programu, który nie technicznie prowadzony „na zawsze”, ale przydziela więcej pamięci niż jakikolwiek komputer mógłby obsłużyć. To nie jest całkiem googolplex (to byłoby 10**10**10011 bajtów), ale naiwnie, podstawa logarytmiczna 2 liczby to

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

tj. 10 ^ 94 bitów do jego przedstawienia. WolframAlpha twierdzi, że jest o 10 ^ 76 większy niż głęboka sieć (pamiętaj, że we wszechświecie jest około 10 ^ 80 atomów ).

Dlaczego pytasz 2 zamiast 9? Nie robi to dużej różnicy (użycie 9 zwiększyłoby tylko liczbę bitów o współczynnik log2(9) = 3.2, co nawet nie zmienia wykładnika). Ale z drugiej strony program działa znacznie szybciej z 2, ponieważ obliczenia są prostsze. Oznacza to, że natychmiast zapełnia pamięć, w przeciwieństwie do wersji 9, która zajmuje nieco dłużej ze względu na wymagane obliczenia. Nie jest to konieczne, ale miło, jeśli chcesz to „przetestować” (co zrobiłem).

Galaretka , 3 2 bajty

-1 bajt dzięki Dennisowi ( Wokłady)

Wß

Link (tj. Funkcja lub metoda), który działa również jako pełny program, który rekurencyjnie zawija swoje dane wejściowe na listę.

Dane wejściowe zaczynają się od zera, więc pierwsze przejście tworzy listę [0]
Drugie przejście następnie powoduje, że [[0]]
Trzecie przejście następnie czyni to [[[0]]]
i tak dalej ...

Poprzednie 3 bajty, które przeciekają znacznie szybciej:

;Ẇß

rekurencyjnie łączy wszystkie niepuste ciągłe podlisty swoich danych wejściowych z danymi wejściowymi.
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]i tak dalej ...

Java 7, 106 bajtów

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

Mniej golfa

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

finalizeWywoływana jest metoda na obiekcie przez śmieciarza, gdy stwierdzi, że zbieranie śmieci nie ma już odniesienia do obiektu. Po prostu przedefiniowałem tę metodę, aby zapętlała się w nieskończoność, aby śmieciarz nigdy nie zwalnia pamięci. W mainpętli tworzę nowe obiekty, które nigdy nie zostaną oczyszczone, więc ostatecznie zużyje całą dostępną pamięć.

Java 7 (fajna alternatywa), 216 bajtów

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

Mniej golfa

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

To jest zabawne bardziej niż cokolwiek innego. Ta odpowiedź korzysta z Unsafebiblioteki Sun, która jest nieudokumentowanym wewnętrznym interfejsem API. Może być konieczna zmiana ustawień kompilatora, aby umożliwić ograniczone interfejsy API. Unsafe.allocateMemoryalokuje określoną liczbę bajtów (bez sprawdzania granic), która nie znajduje się na stercie i nie jest zarządzana przez moduł zbierający elementy bezużyteczne Javy, więc ta pamięć pozostanie do czasu wywołania Unsafe.freeMemorylub do wyczerpania się pamięci JVM.

Haskell, 24 bajty

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

Głównym problemem w Haskell jest pokonanie lenistwa. mainmusi mieć jakiś IOtyp, więc zwykłe dzwonienie main=f 9nie zadziała. Użycie main=pure(f 9)podnosi typ f 9do IOtypu. Jednak używanie konstrukcji typu main=pure 9nic nie robi, 9jest zwracane lub wyświetlane nigdzie, ale po prostu odrzucane, więc nie trzeba oceniać argumentu pure, a zatem main=pure(f 9)nie powoduje przydzielania pamięci, ponieważ fnie jest wywoływana. Aby wymusić ocenę, $!operator istnieje. Po prostu stosuje funkcję do argumentu, ale najpierw ocenia argument. Tak więc używanie main=pure$!f 9ewaluuje, fa zatem stale przydziela więcej pamięci.

dc, 7 bajtów

[ddx]dx

[ddx]wypycha na stos ciąg zawierający „ddx”. dxduplikuje go, a następnie wykonuje jako kod (pozostawiając jedną kopię na stosie). Po wykonaniu tworzy dwa duplikaty, a następnie wykonuje jeden, pozostawiając za każdym razem jeszcze jedną kopię na stosie.

Haskell (przy użyciu ghc 8.0.1), 11 bajtów

m@main=m>>m

Rekurencja bez ogona. mainwywołuje siebie, a potem siebie ponownie.

C (linux), 23 bajty

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

sbrk()zwiększa górną część segmentu danych o podaną liczbę bajtów, tym samym skutecznie zwiększając ilość pamięci przydzielonej programowi - przynajmniej tak, jak podano w VIRTpolu danych topwyjściowych. Działa to tylko w systemie Linux - implementacja macOS jest najwyraźniej emulacją, która pozwala na alokację do 4 MB.

Więc nieco bardziej ogólna odpowiedź:

C, 25 bajtów

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

Oglądałem to na monitorze aktywności macOS. Poszło aż do około 48 GB, a następnie proces otrzymał sygnał SIGKILL. FWIW mój MacBook Pro ma 16 GB. Większość użytej pamięci zgłoszono jako skompresowaną.

Pamiętaj, że pytanie skutecznie wymaga zapisania każdego przydziału, co nie zdarza się tutaj wyraźnie. Należy jednak pamiętać, że dla każdego malloc(9)połączenia przydzielane są nie tylko 9 bajtów żądanych przez użytkownika. Dla każdego przydzielonego bloku będzie nagłówek malloc, który jest również przydzielany gdzieś na stercie, do którego koniecznie zapisują elementy malloc()wewnętrzne.

Perl, 4 bajty

do$0

Wykonuje się w bieżącym tłumaczu. Po zakończeniu wykonanie powraca do skryptu wywołującego, który wymaga stosu wywołań.

Rakieta, 13 bajtów

(let l()(l)1)

Nie jestem całkowicie pewien, czy moja odpowiedź mieści się w tym pytaniu. Daj mi znać, czy powinienem usunąć tę odpowiedź.

JavaScript 22 21 17 16 15 bajtów

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

Zaoszczędzono 4 bajty, zawijając listę na inną listę, jak w odpowiedzi Jelly'ego Allana na galaretkę.

Zaoszczędzono 1 bajt dzięki @ETHProductions

Alternatywne rozwiązanie 15 bajtów (działa tylko z odpowiednimi wywołaniami ogona)

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

Rubinowy, 11 bajtów

loop{$*<<9}

Naciska 9na $*, która jest tablicą początkowo przechowującą argumenty wiersza poleceń dla procesu Ruby.

05AB1E , 2 bajty

[A

Wypróbuj online! Będzie po prostu naciskać abcdefghijklmnopqrstuvwyxzna stos na wieczność.

Wszystkie możliwe rozwiązania 2-bajtowe:

[  # 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 bajtów

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

a nigdy nie jest wypuszczany i tylko staje się większy, dopóki nie trafisz MemoryError

Możesz zobaczyć wykonanie w Python Tutor .

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(wszystkie 1-bajtowe tokeny i dwa znaki nowej linii)

Powoduje to ciągłe wycieki pamięci, ponieważ ustrukturyzowany przepływ sterowania, taki jak Whileprzewidywane zamknięcie przez Endi, wypycha coś na stos (nie na stos operacyjny, oddzielny stos w pamięci stosu), aby to śledzić. Ale tutaj używamy Gotodo opuszczenia pętli (więc nie Endjest wykonywane żadne polecenie usunięcia rzeczy ze stosu), to Whilejest ponownie widoczne, rzecz jest ponownie wypychana itp. Więc po prostu ją popycha, dopóki nie pojawi sięERR:MEMORY