Tulis program yang berjalan selamanya dan alokasikan lebih banyak memori pada heap, semakin lama berjalan, setidaknya sampai Anda mencapai batas sistem operasi pada jumlah memori yang dapat dialokasikan.

Banyak kernel tidak akan mencadangkan memori yang Anda alokasikan sampai Anda menggunakannya untuk sesuatu, jadi jika program Anda menggunakan bahasa C atau bahasa tingkat rendah lainnya, Anda harus memastikan Anda menulis sesuatu untuk setiap halaman. Jika Anda menggunakan bahasa yang ditafsirkan, Anda mungkin tidak perlu khawatir tentang ini.

Kode terpendek menang.

Funge-98 ( cfunge), 1 byte

9

Saya akan memposting ini sebelumnya, tetapi memutuskan untuk mengujinya, dan butuh beberapa saat untuk mengembalikan komputer saya ke status yang dapat digunakan. cfungemenyimpan tumpukan Funge pada tumpukan sistem operasi (yang mudah diverifikasi dengan menjalankan program dengan batas memori kecil, sesuatu yang seharusnya saya lakukan sebelumnya!), sehingga tumpukan yang tumbuh tanpa batas (seperti dengan program ini, yang hanya mendorong 9berulang kali; Program Funge yang dibungkus dari ujung garis kembali ke awal secara default) akan mengalokasikan memori selamanya. Program ini kemungkinan juga bekerja di beberapa implementasi Befunge-93.

Lebih menarik:

"NULL #(4

Ini adalah ide pertama saya, dan merupakan alokasi tak terbatas yang tidak bergantung pada tumpukan Funge (meskipun tumpukan Funge juga meledak). Untuk mulai dengan, "perintah mendorong salinan sisa program ke stack (itu adalah string, dan program membungkus, sehingga kutipan tutup juga berfungsi sebagai kutipan terbuka). Kemudian Nmencerminkan (tidak memiliki arti secara default), menyebabkan program berjalan mundur. The "berjalan lagi, dan mendorong program untuk stack - sebaliknya saat ini, dengan Ndi atas tumpukan - maka program membungkus di sekitar, memuat perpustakaan dengan nama 4 huruf ( 4(, yang NULLperpustakaan merupakan bagian dari cfungeperpustakaan standar). NULLmendefinisikan semua huruf besar untuk melakukan refleksi, sehingga Lmencerminkan, the#melewatkan beban pustaka dalam perjalanan kembali, 4sampah yang tidak kita pedulikan ke stack dan seluruh program mengulangi dari awal. Mengingat bahwa memuat pustaka beberapa kali memiliki efek, dan mengharuskan daftar perintah pustaka untuk disimpan satu kali untuk setiap salinan pustaka (ini tersirat oleh semantik Funge-98), itu bocor memori melalui penyimpanan non-stack (yang merupakan metode alternatif mendefinisikan "heap", relatif terhadap bahasa daripada OS).

Brainfuck, 5 byte

+[>+]

Ini membutuhkan juru bahasa yang tidak memiliki batasan panjang rekaman.

Bash + coreutils, 5

atau

Ruby, 5

`yes`

yesmenghasilkan output tanpa akhir. Dimasukkan ke yesdalam backticks memberitahu shell untuk menangkap semua output dan kemudian jalankan output itu sebagai perintah. Bash akan terus mengalokasikan memori untuk string tanpa akhir ini hingga tumpukan habis. Tentu saja output yang dihasilkan akan berakhir menjadi perintah yang tidak valid, tetapi kita harus kehabisan memori sebelum itu terjadi.

Terima kasih kepada @GB untuk menunjukkan ini juga polyglot di ruby.

Python, 16 byte

Tetap bersarang asampai kesalahan tercapai:

a=0
while 1:a=a,

Beberapa iterasi pertama (sebagai tupel) terlihat seperti ini:

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

dan seterusnya dan seterusnya.

> <> (Ikan), 1 byte

0

Coba di sini!

0 sebenarnya bisa diganti dengan angka heksadesimal 1-f.

Penjelasan

0di> <> cukup membuat kotak kode 1x1 agar ikan bisa berenang. Ini terus-menerus menambahkan 0ke tumpukan, berenang ke kanan, yang dilingkarkan ke belakang 0, menambahkannya ke tumpukan lagi. Ini akan berlangsung selamanya.

Java 101 byte

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

Menangkap Program utama dalam Loop tanpa akhir setelah membuat dan membuang objek. Pengumpulan sampah melakukan pekerjaan bocor dengan membuat 2 objek untuk setiap yang dihapus

Perl, 12 byte

{$"x=9;redo}

Dalam perl, xoperator, dengan string di sebelah kiri dan angka di kanan, menghasilkan string yang berulang. Jadi "abc" x 3dievaluasi untuk "abcabcabc".

The x=Operator bermutasi argumen kiri, menggantikan isi dari variabel di sebelah kiri dengan hasil mengulangi isi itu sebanyak sisi kanan menunjukkan.

Perl memiliki sejumlah variabel bawaan yang dinamai aneh, salah satunya adalah $", yang nilai awalnya adalah ruang tunggal.

The redoOperator melompat ke awal melampirkan tersebut {}.

Pertama kali x=operator selesai, ia mengubah nilai $"dari " ""menjadi " ", yaitu 9 spasi.

Kali kedua x=operator selesai, ia mengubah nilai $"menjadi " ", yaitu 81 spasi.

Ketiga kalinya, $"menjadi string ruang panjang 729 byte.

Saya pikir Anda bisa melihat ke mana arahnya ini :).

sed, 5 byte

Golf

H;G;D

Penggunaan (input apa pun akan dilakukan)

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

Dijelaskan

#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

Tangkapan layar

Cobalah secara Online!

Haskell, 23 19 byte

main=print$sum[0..]

Cetak jumlah daftar yang tak terbatas

C ++ (menggunakan kompiler g ++), 27 23 15 byte

Terima kasih kepada Neop untuk membantu saya menghapus 4 byte

Solusi ini tidak benar-benar membocorkan memori apa pun karena ia mengalokasikan semua yang ada di stack dan dengan demikian menyebabkan stack overflow. Itu hanya rekursif tanpa batas. Setiap rekursi menyebabkan sebagian memori dialokasikan hingga stack meluap.

main(){main();}

Solusi alternatif

Solusi ini sebenarnya kebocoran memori.

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

Valgrind output

Ini adalah output Valgrind setelah menghentikan program beberapa detik dalam waktu berjalan. Anda dapat melihat bahwa itu tentu saja memori yang bocor.

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

JAVA (HotSpot) 71 70 byte

Lebih pendek dari jawaban Java lainnya pada saat saya memposting (81, kemudian 79 byte):

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

Seperti yang disarankan oleh @Olivier Grégoire, byte lebih lanjut dapat disimpan:

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

Menempatkan x+=x.intern()sebagai kenaikan for loop tidak akan membantu apa pun, karena titik koma masih diperlukan untuk mengakhiri pernyataan for.

Seperti yang disarankan oleh @ETHproductions, hanya menggunakan x+=xkarya juga:

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

Yang juga dapat memanfaatkan tip @Olivier Grégoire:

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

Satu-satunya keraguan saya tentang hal itu adalah bahwa tidak dijamin untuk mengalokasikan data pada heap , karena JVM yang efisien dapat dengan mudah menyadari bahwa xtidak pernah lepas dari fungsi lokal. Menggunakan intern()menghindari masalah ini karena string diinternir akhirnya disimpan di bidang statis. Namun, HotSpot memang menghasilkan OutOfMemoryErrorkode untuk itu, jadi saya kira tidak apa-apa.

Pembaruan: @Olivier Gregoire juga menunjukkan bahwa x+=xkode dapat berjalan ke dalam StringIndexOutOfBoundsExceptiondaripada OOMketika banyak memori tersedia. Ini karena Java menggunakan tipe 32-bit intuntuk mengindeks array (dan Strings hanyalah array char). Ini tidak mempengaruhi x+=x.intern()solusi karena memori yang diperlukan untuk yang terakhir adalah kuadrat dalam panjang string, dan karenanya harus ditingkatkan menjadi urutan 2 ^ 62 byte yang dialokasikan.

Perl 6 , 13 byte

@= eager 0..*

Penjelasan:

@ = simpan hasilnya ke dalam array tanpa nama

eager buat daftar berikut menjadi bersemangat

0 .. * rentang tak terbatas mulai dari nol

///, 7 byte

/a/aa/a

Ganti terus-menerus adengan aa, ad nauseum.

Python 3, 16 byte

i=9
while 1:i*=i

Ini berasal dari kenyataan bahwa tidak ada batasan untuk ukuran integer di Python 3; sebagai gantinya, bilangan bulat dapat mengambil memori sebanyak yang dapat ditangani oleh sistem (jika sesuatu tentang pemahaman saya tentang hal ini salah, lakukan koreksi pada saya).

Karat, 46 byte

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

Perhatikan sesuatu yang menarik tentang program Rust ini, bocornya alokasi tumpukan hingga kehabisan memori?

Itu benar, tidak ada blok yang tidak aman. Karat menjamin keamanan memori dalam kode aman (tidak ada pembacaan data yang tidak diinisialisasi, baca setelah bebas, ganda gratis dll), tetapi kebocoran memori dianggap sangat aman. Bahkan ada fungsi eksplisit untuk membuat kompiler lupa tentang pembersihan RAII dari variabel luar ruang lingkup, yang saya gunakan di sini.

TI-83 Hex Assembly, 7 byte

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

Membuat appvars tanpa batas waktu sampai ERR:MEMORYdilemparkan oleh OS. Jalankan dengan Asm(prgmM). Saya menghitung setiap pasangan angka hex sebagai satu byte.

Python, 8 byte

2**9**99

The OP telah memungkinkan teknis dari sebuah program yang tidak secara teknis menjalankan "selamanya", tapi mengalokasikan memori lebih dari komputer manapun mungkin bisa menangani. Ini bukan googolplex (artinya 10**10**100, 11 byte), tetapi secara naif, basis log 2 dari nomor tersebut adalah

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

yaitu, 10 ^ 94 bit untuk mewakilinya. WolframAlpha menyatakan bahwa 10 ^ 76 lebih besar dari jaring dalam (ingatlah bahwa ada sekitar 10 ^ 80 atom di alam semesta ).

Mengapa 2 bukannya 9 yang Anda tanyakan? Itu tidak membuat banyak perbedaan (menggunakan 9 hanya akan meningkatkan jumlah bit dengan faktor log2(9) = 3.2, yang bahkan tidak mengubah eksponen). Tetapi di sisi lain, program ini berjalan lebih cepat dengan 2, karena perhitungannya lebih sederhana. Ini berarti memori langsung terisi, tidak seperti versi 9, yang membutuhkan waktu lebih lama karena perhitungan yang diperlukan. Tidak perlu, tetapi baik jika Anda ingin "menguji" ini (yang saya lakukan).

Jelly , 3 2 byte

-1 byte berkat Dennis ( Wmembungkus)

Wß

Tautan (yaitu fungsi atau metode), yang juga berfungsi sebagai program lengkap, yang secara rekursif memasukkan inputnya ke dalam daftar.

Input dimulai sebagai nol sehingga pass pertama menciptakan daftar [0]
Pass kedua kemudian membuat ini [[0]]
Pass ketiga kemudian membuat ini [[[0]]]
dan seterusnya ...

3 byter sebelumnya, yang bocor jauh lebih cepat:

;Ẇß

secara rekursif menggabungkan semua sublist yang berdekatan yang tidak kosong dari inputnya ke inputnya.
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]dan seterusnya ...

Java 7, 106 byte

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

Kurang Golf

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

The finalizemetode ini disebut pada objek oleh kolektor sampah ketika pengumpulan sampah menentukan bahwa tidak ada lagi referensi ke objek. Saya hanya mendefinisikan ulang metode ini untuk mengulang selamanya sehingga pengumpul sampah tidak pernah benar-benar membebaskan memori. Dalam mainloop saya membuat objek baru yang tidak akan pernah dibersihkan sehingga pada akhirnya ini akan menggunakan semua memori yang tersedia.

Java 7 (alternatif yang menyenangkan), 216 byte

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

Kurang Golf

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

Ini lebih menyenangkan daripada yang lainnya. Jawaban ini memanfaatkan Unsafeperpustakaan Sun yang merupakan API internal tidak berdokumen. Anda mungkin perlu mengubah pengaturan kompiler untuk mengizinkan API terbatas. Unsafe.allocateMemorymengalokasikan jumlah byte tertentu (tanpa pemeriksaan batas) yang tidak ada di heap dan tidak di bawah manajemen pengumpul sampah java sehingga memori ini akan bertahan sampai Anda menelepon Unsafe.freeMemoryatau sampai jvm kehabisan memori.

Haskell, 24 byte

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

Masalah utama dalam Haskell adalah untuk mengalahkan kemalasan. mainperlu memiliki beberapa IOjenis, jadi hanya menelepon main=f 9tidak akan berfungsi. Menggunakan main=pure(f 9)mengangkat tipe f 9ke IOtipe. Namun menggunakan konstruksi seperti main=pure 9tidak melakukan apa-apa, 9dikembalikan atau ditampilkan di mana-mana tetapi dibuang begitu saja, sehingga tidak perlu mengevaluasi argumen pure, karenanya main=pure(f 9)tidak menyebabkan memori apa pun dialokasikan sebagaimana ftidak dipanggil. Untuk menegakkan evaluasi, $!operator ada. Itu hanya berlaku fungsi untuk argumen tetapi mengevaluasi argumen terlebih dahulu. Jadi menggunakan main=pure$!f 9mengevaluasi fdan karenanya terus mengalokasikan lebih banyak memori.

dc, 7 byte

[ddx]dx

[ddx]mendorong string yang berisi "ddx" ke stack. dxduplikat lalu jalankan sebagai kode (meninggalkan satu salinan di tumpukan). Ketika dieksekusi, itu membuat dua duplikat kemudian mengeksekusi satu, meninggalkan satu salinan lagi di stack setiap kali.

Haskell (menggunakan ghc 8.0.1), 11 byte

m@main=m>>m

Rekursi non-ekor. mainmenyebut dirinya sendiri lalu kembali lagi.

C (linux), 23 byte

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

sbrk()menambah bagian atas segmen data dengan jumlah byte yang diberikan, sehingga secara efektif meningkatkan jumlah memori yang dialokasikan untuk program - setidaknya seperti yang dilaporkan dalam VIRTbidang topoutput. Ini hanya bekerja di Linux - implementasi macOS tampaknya merupakan emulasi yang hanya memungkinkan alokasi hingga 4MB.

Jadi jawaban yang sedikit lebih umum:

C, 25 byte

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

Saya menontonnya di Monitor Aktivitas macOS. Semua berjalan hingga sekitar 48GB, kemudian pada akhirnya proses tersebut menerima sinyal SIGKILL. FWIW macbook pro saya memiliki 16GB. Sebagian besar memori yang digunakan dilaporkan sebagai terkompresi.

Perhatikan bahwa pertanyaan ini secara efektif mengharuskan setiap alokasi ditulis, yang tidak terjadi secara eksplisit di sini. Namun penting untuk dicatat bahwa untuk setiap malloc(9)panggilan, bukan hanya 9 byte yang diminta pengguna yang dialokasikan. Untuk setiap blok yang dialokasikan akan ada header malloc yang juga dialokasikan dari suatu tempat di heap, yang harus ditulis oleh malloc()internal.

Perl, 4 byte

do$0

Jalankan sendiri, dalam juru bahasa saat ini. Setelah selesai, eksekusi kembali ke skrip panggilan, yang membutuhkan tumpukan panggilan.

Racket, 13 byte

(let l()(l)1)

Saya tidak sepenuhnya yakin apakah jawaban saya termasuk dalam pertanyaan ini. Tolong beri tahu saya jika saya harus menghapus jawaban ini.

JavaScript 22 21 17 16 15 Bytes

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

Disimpan 4 byte dengan membungkus daftar di daftar lain seperti pada jawaban Jelly @ Jonathan Jon.

Disimpan 1 byte berkat @ETHProductions

Solusi alternatif 15 Bytes (hanya berfungsi dengan panggilan ekor yang tepat)

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

Ruby, 11 byte

loop{$*<<9}

Terus mendorong 9ke $*, yang merupakan array awalnya memegang argumen baris perintah untuk proses Ruby.

05AB1E , 2 byte

[A

Cobalah online! Hanya akan terus mendorong abcdefghijklmnopqrstuvwyxzke tumpukan untuk selamanya.

Semua kemungkinan solusi 2-byte:

[  # 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 byte

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

a tidak pernah dirilis dan semakin besar sampai Anda menekan tombol MemoryError

Anda dapat melihat eksekusi di Python Tutor .

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(semua token 1-byte, dan dua baris baru)

Ini secara terus-menerus membocorkan memori karena aliran kontrol terstruktur seperti Whilediantisipasi ditutup oleh Enddan mendorong sesuatu pada tumpukan (bukan tumpukan OS, tumpukan terpisah di memori tumpukan) untuk melacaknya. Tapi di sini kita gunakan Gotountuk meninggalkan loop (jadi tidak ada Endyang dieksekusi untuk menghapus hal itu dari stack), Whileterlihat lagi, benda itu didorong lagi, dll. Jadi itu terus mendorong mereka sampai Anda mendapatkanERR:MEMORY