Sonsuza kadar çalışan ve ne kadar uzun çalışırsa, en azından tahsis edilebilecek bellek miktarına göre işletim sisteminin sınırına ulaşana kadar, daha fazla bellek ayıran bir program yazın.

Çoğu çekirdek, bir şey için kullanana kadar ayırdığınız belleği ayırmaz, bu nedenle programınız C veya başka bir düşük seviyeli dilde ise, her sayfaya bir şeyler yazdığınızdan emin olmanız gerekir. Tercüme edilmiş bir dil kullanıyorsanız, muhtemelen bu konuda endişelenmenize gerek kalmayacak.

En kısa kod kazanır.

Funge-98 ( cfunge), 1 bayt

9

Bunu daha önce göndermiştim, ama denemeye karar verdim ve bilgisayarımı tekrar kullanılabilir bir duruma getirmek biraz zaman aldı. cfungeFunge yığınını işletim sisteminin öbeğine (programı küçük bir bellek sınırıyla çalıştırarak kolayca doğrulanabilir olan, daha önce yapmam gereken bir şey!) depolar; böylece sürekli artan bir yığın (bu programda olduğu gibi, 9tekrar tekrar iter ; Funge programları bir satırın sonundan başlayarak varsayılana geri döner) sonsuza kadar bellek ayırır. Bu program muhtemelen bazı Befunge-93 uygulamalarında da çalışıyor.

Daha ilginç:

"NULL #(4

Bu benim ilk fikrimdi ve Funge yığınına dayanmayan sonsuz bir dağıtımdır (Funge yığınını da havaya uçurmasına rağmen). Başlamak için, "komut programın geri kalanının bir kopyasını yığına iter (bu bir dizedir ve program tamamıyla sarılır, bu nedenle yakın teklif aynı zamanda açık teklif olarak da işlev görür). Sonra Nyansıtır (varsayılan olarak bir anlamı yoktur), programın geriye doğru çalışmasına neden olur. Yine "çalışır ve programı yığına iter - bu sefer tersi yönde, yığının Ntepesinde olacak şekilde - daha sonra program sarılır, 4 harfli bir kitaplığı yükler ( 4(; NULLkütüphane cfungestandart kütüphane). NULLyansıtılacak tüm büyük harfleri tanımlar L;#geri dönerken kütüphane yükünü atlar, 4umursamadığımız önemsiz yığını iter ve tüm program baştan tekrar eder. Bir kitaplığın birden çok kez yüklenmesinin bir etkisi olduğu ve kitaplığın her bir kopyası için kitaplığın komut listesinin bir kez kaydedilmesini gerektirdiği göz önüne alındığında (bu, Funge-98'in semantiği ile belirtilir), İşletim sistemi yerine dile göre "öbek" tanımının alternatif yöntemi).

Brainfuck, 5 bayt

+[>+]

Bu, bandın uzunluğu için sınırı olmayan bir tercüman gerektirir.

Bash + coreutils, 5

veya

Yakut, 5

`yes`

yessonsuz çıktı üretir. Geri yestepme çubuklarına koymak , kabuğa tüm çıktıları yakalamasını ve ardından bu çıktıyı komut olarak çalıştırmasını söyler. Bash, bitene kadar bu bitmeyen dize için bellek ayırmaya devam edecek. Tabii ki sonuçta ortaya çıkan çıktı geçersiz bir komut olacaktı, ama gerçekleşmeden önce hafızamız tükenmeli.

Bu işaret için @ GB sayesinde çok yakut içinde bir polyglot olduğunu.

Python, 16 bayt

aBir hataya ulaşılıncaya kadar yuvalamayı tutar :

a=0
while 1:a=a,

İlk birkaç yineleme (tuples gibi) şöyle görünür:

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

ve diğerleri ve diğerleri.

> <> (Balık), 1 bayt

0

Burada dene!

0 aslında herhangi bir onaltılık sayı 1-f ile ikame edilebilir.

açıklama

0in> <> balığın içinde yüzmesi için 1x1'lik bir kod kutusu yapar. Yığına sürekli ekler 0, sağa doğru yüzer, bakteri çevreleyen 0, tekrar yığına ekler. Bu sonsuza dek sürecek.

Java 101 bayt

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

Bir nesne yaratıp attıktan sonra ana programı sonsuz bir döngüde yakalamak. Çöp toplama işlemi, silinen her biri için 2 nesne oluşturarak sızıntı yapıyor

Perl, 12 bayt

{$"x=9;redo}

Perl'de, xoperatör, solda bir dize ve sağda bir sayı ile tekrarlanan bir dize üretir. Bu yüzden "abc" x 3değerlendirir "abcabcabc".

x=Operatör sağ taraftaki gösterir gibi içindekilerin gibi birçok Zamanlar tekrarlayarak sonucu ile sol değişkenin içeriğini değiştirerek, sol argüman dönüşüyor.

Perl, bir tanesi garip bir şekilde, değişkenleri yerleşik adında, biri başlangıç değeri tek bir boşluk $"olan bir takım değişkenlere sahiptir .

redoOperatör kapatmakta olan başlangıcına atlar {}.

x=Operatör ilk yapıldığında, değerini 9 alan olan " $"dan " "" a değiştirir " ".

İkincisinde x=operatör yapılır, bu değeri değişir $"için " "81 boşluk olan.

Üçüncü zaman, $"729 baytlık uzun uzay dizisi olur.

Bunun nereye gittiğini görebildiğini düşünüyorum :).

sed, 5 bayt

golfed

H;G;D

Kullanımı (herhangi bir giriş yapacak)

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

Açıklaması

#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

Ekran görüntüsü

Çevrimiçi Deneyin!

Haskell, 23 19 bayt

main=print$sum[0..]

Sonsuz bir listenin toplamını yazdır

C ++ (g ++ derleyici kullanılarak), 27 23 15 bayt

Neop'a, 4 byte'ı çıkarmama yardım ettiğin için teşekkürler.

Bu çözüm gerçekte herhangi bir hafıza sızdırmaz, çünkü her şeyi yığına tahsis eder ve böylece yığın taşmasına neden olur. Bu sadece sonsuz özyinelemelidir. Her özyineleme, yığın taşana kadar bir miktar bellek tahsis edilmesine neden olur.

main(){main();}

Alternatif çözüm

Bu çözüm aslında hafızayı sızdırıyor.

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

Valgrind çıkışı

Bu, programı birkaç saniye çalıştırma süresi içinde sonlandırdıktan sonra Valgrind çıkışıdır. Bunun kesinlikle bellek sızdırıyor olduğunu görebilirsiniz.

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

JAVA, 81 79 78 bayt

JAVA (HotSpot) 71 70 bayt

Gönderdiğim sırada diğer Java cevaplarından daha kısa (81, sonra 79 bayt):

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

@ Olivier Grégoire tarafından önerildiği gibi, başka bir byte kaydedilebilir:

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

x+=x.intern()For loop artışı olarak yerleştirmek hiçbir şeye yardımcı olmaz, çünkü for deyimini sonlandırmak için hala noktalı virgül gerekir.

@ETHproductions'un önerdiği gibi, sadece x+=xeserleri kullanmak :

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

Ayrıca @Olivier Grégoire'nin bahşişinden de yararlanabilirsiniz:

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

Bununla ilgili tek endişem , verimli bir JVM'nin yerel işlevden asla kaçamayacağının kolayca fark edebileceğinden öbek üzerinde veri tahsis edilmesinin garanti edilmemesidir x. Kullanımı intern(), bu endişeyi ortadan kaldırır, çünkü interned dizeler sonuçta statik bir alanda depolanır. Ancak, HotSpot OutOfMemoryErrorbu kod için bir kod oluşturuyor , bu yüzden sanırım tamam.

Güncelleme: @Olivier Gregoire ayrıca x+=x, StringIndexOutOfBoundsExceptionçok fazla OOMhafıza olması yerine kodun çalıştırılabileceğini belirtti . Bunun nedeni, Java intdizileri dizine almak için 32 bit türünü kullanmasıdır (ve Dizeler yalnızca dizilerdir char). x+=x.intern()Sonuncusu için gerekli olan bellek, dizenin uzunluğunda ikinci dereceden olduğu için bu çözümü etkilemez ve bu nedenle 2 ^ 62 ayrılmış bayt sırasına göre ölçeklendirilmelidir.

Perl 6 , 13 bayt

@= eager 0..*

Açıklama:

@ = sonucu adsız bir diziye kaydetme

eager aşağıdaki listeyi istekli yapmak

0 .. * sıfırdan başlayan sonsuz aralık

///, 7 bayt

/a/aa/a

Sürekli aolarak aa, reklam müzesi ile değiştirin .

Python 3, 16 bayt

i=9
while 1:i*=i

Bu Python 3'te tamsayı büyüklüğünde bir sınır bulunmamasından kaynaklanıyor; bunun yerine, tamsayılar sistemin kaldırabildiği kadar belleği alabilir (eğer bu konuda bir fikrim yanlışsa beni düzeltin).

Pas, 46 bayt

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

Bellek programına kadar yığın tahsisleri sızdıran bu Rust programında ilginç bir şey farkettiniz mi?

Bu doğru, güvenli olmayan blok yok. Rust, güvenli kodda hafıza güvenliğini garanti eder (başlatılmamış verileri okumak, ücretsiz sonra okumak, ücretsiz çift okumak vb.), Ancak hafıza sızıntılarının tamamen güvenli olduğu düşünülür. Derleyicinin, burada kullandığım kapsam dışı değişkenlerden RAII temizliğini unutmasını sağlayan açık bir işlev bile var.

TI-83 Hex Meclisi, 7 bayt

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

Bir ERR:MEMORYişletim sistemi tarafından atılana kadar süresiz appvarlar oluşturur . İle koş Asm(prgmM). Her onaltılık hane çiftini bir bayt olarak sayıyorum.

Python, 8 bayt

2**9**99

OP teknik olarak "sonsuza dek" çalışmaz bir programın technicality izin verilir, ancak herhangi bir bilgisayar muhtemelen kaldırabileceğinden daha fazla bellek ayırır gelmiştir. Bu tam bir googolplex değil (ki 10**10**100, 11 byte), ama neticede, sayının 2 log tabanı

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

yani, onu temsil etmek için 10 ^ 94 bit. WolframAlpha , derin ağdan 10 ^ 76 daha büyük olduğunu ( evrende yaklaşık 10 ^ 80 atom olduğunu unutmayın ).

Neden 9 yerine 2 soruyorsun? Çok fazla farketmez (9'u kullanmak, bit sayısını yalnızca katsayısını log2(9) = 3.2değiştirmeyen bir faktörle artırabilir ). Ancak, diğer yandan, hesaplama daha basit olduğu için program 2 ile daha hızlı çalışır. Bu, gerekli hesaplamalar nedeniyle biraz daha uzun süren 9 versiyonun aksine hemen belleği doldurduğu anlamına gelir. Gerekli değil, fakat bunu "test etmek" istiyorsanız (ki ben yaptım).

Jöle , 3 2 bayt

Dennis sayesinde 1 byte ( Wtamamladı)

Wß

Tam bir program olarak da çalışan, girişini yinelemeli olarak bir listeye saran bir link (yani fonksiyon veya yöntem).

Giriş sıfır olarak başlar, böylece ilk geçiş liste oluşturur [0]
İkinci geçiş daha sonra bunu yapar [[0]]
Üçüncü geçiş daha sonra bunu yapar [[[0]]]
ve ...

Daha hızlı sızan önceki 3 bayt:

;Ẇß

girişindeki boş olmayan bitişik tüm listeleri tekrarlı olarak girişine birleştirir.
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]vb.

Java 7, 106 bayt

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

Daha Az Golf

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

finalizeÇöp toplama nesneye daha başvuruları vardır belirlediğinde yöntem çöp toplayıcı tarafından bir nesne olarak adlandırılır. Bu yöntemi sonsuza dek döngülemek için yeniden tanımladım, böylece çöp toplayıcı hiçbir zaman belleği boşaltmaz. Gelen maindöngü Öyle sonunda bu tüm kullanılabilir belleği kullanacak temizlenir asla yeni nesneler yaratmak.

Java 7 (eğlenceli alternatif), 216 bayt

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

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

Bu eğlenceli bir şey değil her şeyden daha. Bu cevap, Unsafebelgelenmemiş bir iç API olan Sun kütüphanesinden faydalanmaktadır . Kısıtlı API'lere izin vermek için derleyici ayarlarınızı değiştirmeniz gerekebilir. Unsafe.allocateMemoryjava'nın çöp toplayıcı yönetimi altında olmayan , yığın üzerinde olmayan (sınır denetimi olmayan) belirli bir miktarda bayt Unsafe.freeMemoryayırır;

Haskell, 24 bayt

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

Haskell'deki asıl sorun tembellikten kurtulmak. mainbazı IOtür olması gerekiyor , bu yüzden sadece arama main=f 9işe yaramaz. Kullanılması main=pure(f 9)asansörler tipi f 9bir etmek IOtip. Bununla birlikte, benzeri yapıların kullanılması main=pure 9hiçbir şey yapmaz, 9hiçbir yere döndürülmez veya hiçbir yere gösterilmez, ancak basitçe atılır, bu purenedenle argümanını değerlendirmeye gerek yoktur , bu nedenle çağrılmadığı main=pure(f 9)gibi herhangi bir belleğin tahsis edilmesine neden folmaz. Değerlendirmeyi zorlamak için $!operatör var. Sadece bir işlevi bir argümana uygular, ancak önce argümanı değerlendirir. Yani kullanarak main=pure$!f 9değerlendirir fve böylece sürekli daha fazla hafıza tahsis eder.

dc, 7 bayt

[ddx]dx

[ddx]"ddx" içeren bir dize yığına iter. dxçoğaltır sonra kod olarak çalıştırır (yığında bir kopya bırakır). Çalıştırıldığında, iki kopya oluşturuyor, ardından bir tanesini çalıştırıyor, her seferinde yığında bir kopya daha bırakıyor.

Haskell (ghc 8.0.1 kullanarak), 11 bayt

m@main=m>>m

Kuyruksuz özyineleme. mainkendisini ve sonra kendini tekrar çağırır.

C (linux), 23 bayt

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

sbrk()veri bölümünün üstünü verilen bayt sayısı kadar arttırır, böylece programa ayrılan bellek miktarını etkin bir şekilde arttırır - en azından çıktı VIRTalanında rapor edildiği gibi top. Bu sadece Linux'ta çalışır - macOS uygulaması görünüşe göre sadece 4 MB'a kadar dağıtım yapılmasına izin veren bir öykünmedir.

Yani biraz daha genel bir cevap:

C, 25 bayt

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

MacOS Aktivite İzleyicisi'nde izledim. Tüm yol yaklaşık 48GB'a kadar çıktı, ardından süreç bir SIGKILL sinyali aldı. FWIW benim macbook pro 16GB var. Kullanılan belleğin çoğunun sıkıştırılmış olduğu bildirildi.

Sorunun, burada açıkça gerçekleşmeyen her tahsisatın etkili bir şekilde yazılmasını gerektirdiğini unutmayın. Ancak, her malloc(9)arama için, tahsis edilen sadece 9 kullanıcı tarafından istenen bayt olmadığını unutmayın. Tahsis edilen her blok için, öbek üzerinde bir yerden tahsis edilen ve mutlaka malloc()iç halk tarafından yazılmış bir malloc başlığı olacaktır .

Perl, 4 bayt

do$0

Geçerli tercümanda kendini yürütür. İşlem tamamlandığında, yürütme, bir çağrı yığını gerektiren çağrı koduna geri döner.

Raket, 13 bayt

(let l()(l)1)

Cevabım bu sorunun altına düşerse, tam olarak emin değilim. Lütfen bu cevabı kaldırmalı mıyım, bana bildirin.

JavaScript 22 21 17 16 15 Bayt

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

Listeyi @Jonathan Allan'ın Jelly cevabı gibi başka bir listeye kaydırarak 4 bayt kurtardı.

@ETHProductions sayesinde 1 bayt kaydedildi

Alternatif çözüm 15 Bayt (yalnızca uygun kuyruk çağrılarıyla çalışır)

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

Ruby, 11 bayt

loop{$*<<9}

İtme tutar 9üzerine $*başlangıçta Ruby işlemi için komut satırı bağımsız değişkenleri tutan bir dizi olan.

05AB1E , 2 bayt

[A

Çevrimiçi deneyin! abcdefghijklmnopqrstuvwyxzSonsuza dek yığına bastırmaya devam edecek .

Tüm olası 2 bayt çözümler:

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

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

a asla serbest bırakılmaz ve bir vuruşa kadar büyür. MemoryError

Üzerinde yürütme görebilirsiniz Python Tutor .

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(tüm 1 bayt jetonlar ve iki yeni satır)

Bu sürekli hafızaya sızar, çünkü Whilebeklendiği gibi yapısal kontrol akışı kapanır Endve bunu takip etmek için yığında bir şey (işletim sistemi yığını değil, yığın bellekte ayrı bir yığın) iter. Ama burada Gotodöngüden ayrılmak için kullanıyoruz (yani End, yığını yığıntan çıkarmak için çalıştırılmaz), Whiletekrar görülür, olay tekrar itilir, vb.ERR:MEMORY