เขียนโปรแกรมที่รันตลอดไปและจัดสรรหน่วยความจำมากขึ้นเรื่อย ๆ บนฮีปให้นานขึ้นอย่างน้อยที่สุดจนกว่าคุณจะถึงขีด จำกัด ของระบบปฏิบัติการกับจำนวนหน่วยความจำที่สามารถจัดสรรได้

เมล็ดจำนวนมากจะไม่จองหน่วยความจำที่คุณจัดสรรจนกว่าคุณจะใช้มันเพื่อบางอย่างดังนั้นหากโปรแกรมของคุณเป็นภาษา 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) ทำให้หน่วยความจำรั่วผ่านหน่วยความจำที่ไม่ใช่สแต็ก ทางเลือกวิธีการกำหนด "heap" สัมพันธ์กับภาษามากกว่าระบบปฏิบัติการ)

Brainfuck, 5 ไบต์

+[>+]

สิ่งนี้ต้องการล่ามที่ไม่จำกัดความยาวของเทป

Bash + coreutils, 5

หรือ

ทับทิม, 5

`yes`

yesสร้างผลลัพธ์ที่ไม่มีที่สิ้นสุด ใส่yesbackticks บอกเปลือกเพื่อจับภาพเอาท์พุททั้งหมดแล้วดำเนินการเอาท์พุทที่เป็นคำสั่ง Bash จะดำเนินการจัดสรรหน่วยความจำสำหรับสตริงที่ไม่รู้จักนี้ต่อไปจนกว่าฮีพจะหมด แน่นอนผลลัพธ์ที่ออกมาจะกลายเป็นคำสั่งที่ไม่ถูกต้อง แต่เราควรมีหน่วยความจำไม่เพียงพอก่อนที่จะเกิดขึ้น

ขอบคุณ @GB สำหรับการชี้ให้เห็นว่านี่เป็นรูปหลายเหลี่ยมในทับทิมเช่นกัน

Python ขนาด 16 ไบต์

คงการทำรังaไว้จนกว่าจะเกิดข้อผิดพลาด:

a=0
while 1:a=a,

การวนซ้ำสองสามครั้งแรก (เป็นสิ่งอันดับ) มีลักษณะดังนี้:

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

และอื่น ๆ และอื่น ๆ.

> <> (ปลา) 1 ไบต์

0

ลองที่นี่!

0 สามารถทดแทนได้จริงสำหรับเลขฐานสิบหกใด ๆ 1-f

คำอธิบาย

0ใน> <> สร้างกล่องโค้ดขนาด 1x1 เพื่อให้ปลาลงแหวกว่ายโดยจะเพิ่ม0สแต็กลงไปในสแต็กว่ายไปทางขวาซึ่งวนรอบย้อน0กลับไปที่ สิ่งนี้จะดำเนินต่อไปตลอดกาล

Java 101 bytes

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 ไบต์

แข็งแรงเล่นกอล์ฟ

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

JAVA, 81 79 78 ไบต์

JAVA (ฮอตสปอต) 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

ตามที่แนะนำโดย @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รหัสนั้นขึ้นมาดังนั้นฉันคิดว่าไม่เป็นไร

Update: @Olivier Gregoire ยังชี้ให้เห็นว่าx+=xรหัสสามารถทำงานได้StringIndexOutOfBoundsExceptionดีกว่าOOMเมื่อมีหน่วยความจำมากมาย นี่เป็นเพราะ Java ใช้intชนิด32 บิตเพื่อทำดัชนีอาร์เรย์ (และ Strings เป็นเพียงอาร์เรย์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 ซึ่งฉันใช้ที่นี่

แอสเซมบลี Hex ของ TI-83, 7 ไบต์

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

สร้าง appvars ไปเรื่อย ๆ จนกว่าERR:MEMORYจะถูกโยนโดยระบบปฏิบัติการ Asm(prgmM)ทำงานด้วย ฉันนับเลขฐานสิบหกแต่ละคู่เป็นหนึ่งไบต์

Python 8 ไบต์

2**9**99

OPได้รับอนุญาตให้วิชาของโปรแกรมที่ไม่ได้ในทางเทคนิคเรียกใช้ "ตลอดไป" แต่จัดสรรหน่วยความจำมากกว่าเครื่องคอมพิวเตอร์ใด ๆ ที่อาจจะจัดการกับ นี่ไม่ใช่ googolplex (นั่น10**10**100คือ 11 ไบต์) แต่อย่างไร้เดียงสา log ฐาน 2 ของจำนวนคือ

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

เช่น 10 ^ 94 bits เพื่อเป็นตัวแทน WolframAlphaระบุว่ามีขนาดใหญ่กว่าเว็บลึกถึง 10 ^ 76 (โปรดทราบว่ามีอะตอมประมาณ 10 ^ 80 ในจักรวาล )

ทำไมต้องเป็น 2 แทนที่จะเป็น 9 ที่คุณถาม มันไม่ได้สร้างความแตกต่างมากนัก (การใช้ 9 จะเพิ่มจำนวนบิตโดยปัจจัยlog2(9) = 3.2ซึ่งไม่ได้เปลี่ยนเลขชี้กำลัง) แต่ในทางกลับกันโปรแกรมจะรันเร็วกว่าด้วย 2 เนื่องจากการคำนวณนั้นง่ายกว่า ซึ่งหมายความว่าจะเติมหน่วยความจำทันทีโดยไม่เห็นด้วยกับเวอร์ชั่น 9 ซึ่งใช้เวลานานกว่าเล็กน้อยเนื่องจากการคำนวณที่จำเป็น ไม่จำเป็น แต่ก็ดีถ้าคุณต้องการ "ทดสอบ" สิ่งนี้ (ซึ่งฉันทำ)

เยลลี่ , 3 2 ไบต์

-1 ไบต์ขอบคุณเดนนิส ( Wwraps)

Wß

ลิงค์ (เช่นฟังก์ชั่นหรือวิธีการ) ซึ่งยังทำงานเป็นโปรแกรมเต็มรูปแบบซึ่งจะแทรกอินพุตซ้ำเข้าไปในรายการ

อินพุตเริ่มต้นเป็นศูนย์ดังนั้นการผ่านครั้งแรกจะสร้างรายการ[0]
การส่งผ่านครั้งที่สองจากนั้นทำให้[[0]]
เป็นการส่งผ่านครั้งที่สามจากนั้นทำเช่นนี้[[[0]]]
...

3 byter ก่อนหน้าซึ่งรั่วเร็วกว่ามาก:

;Ẇß

เชื่อมโยงรายการย่อยที่ต่อเนื่องกันทั้งหมดของอินพุตเข้ากับอินพุตซ้ำ
[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();}}

หัก Golfed

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

หัก Golfed

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จัดสรรจำนวนไบต์ที่ระบุ (โดยไม่มีการตรวจสอบขอบเขต) ซึ่งไม่ได้อยู่ในฮีปและไม่อยู่ภายใต้การจัดการขยะของจาวาดังนั้นหน่วยความจำนี้จะติดไปเรื่อย ๆ จนกว่าคุณจะโทรออก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และจัดสรรหน่วยความจำอย่างต่อเนื่อง

dc, 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 นั้นเป็นการจำลองที่อนุญาตให้จัดสรรได้มากถึง 4MB

ดังนั้นคำตอบทั่วไปเพิ่มเติมเล็กน้อย:

C, 25 ไบต์

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

ฉันดูมันบน macOS Activity Monitor มันไปถึงประมาณ 48GB จากนั้นในที่สุดกระบวนการได้รับสัญญาณ SIGKILL FWIW macbook pro ของฉันมี 16GB หน่วยความจำส่วนใหญ่ที่ใช้ถูกรายงานว่าถูกบีบอัด

โปรดทราบว่าคำถามนั้นต้องการการเขียนแต่ละการจัดสรรอย่างมีประสิทธิภาพซึ่งไม่ได้เกิดขึ้นอย่างชัดเจนที่นี่ อย่างไรก็ตามเป็นสิ่งสำคัญที่จะต้องทราบว่าสำหรับการmalloc(9)โทรทุกครั้งมันไม่ได้เป็นเพียงแค่ผู้ใช้ 9 คนที่ร้องขอไบต์ที่ถูกจัดสรร สำหรับแต่ละบล็อกที่จัดสรรจะมีส่วนหัว malloc ที่ถูกจัดสรรจากที่ใดที่หนึ่งบนฮีปซึ่งจำเป็นต้องเขียนโดยmalloc()internals

Perl, 4 ไบต์

do$0

ดำเนินการเองในล่ามปัจจุบัน เมื่อเสร็จสิ้นการดำเนินการจะกลับไปที่สคริปต์การโทรซึ่งต้องการสแต็กการโทร

แร็กเก็ต, 13 ไบต์

(let l()(l)1)

ฉันไม่แน่ใจทั้งหมดหากคำตอบของฉันอยู่ภายใต้คำถามนี้ โปรดแจ้งให้เราทราบหากฉันควรลบคำตอบนี้

JavaScript 22 21 17 16 15 ไบต์

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

บันทึก 4 ไบต์ด้วยการตัดรายการในรายการอื่นเช่นเดียวกับใน @Jonathan Allan Jelly answer

บันทึกแล้ว 1 ไบต์ขอบคุณ @ETHProductions

ทางเลือกอื่น 15 ไบต์ (ใช้ได้กับการโทรแบบหางเท่านั้น)

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

Ruby, 11 ไบต์

loop{$*<<9}

ช่วยผลักดัน9ลงบน$*ซึ่งเป็นอาร์เรย์แรกถืออาร์กิวเมนต์บรรทัดคำสั่งไปยังขั้นตอนทับทิม

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

คุณสามารถดูการดำเนินการเกี่ยวกับงูหลามกวดวิชา

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(โทเค็นขนาด 1 ไบต์และสองบรรทัดใหม่)

สิ่งนี้รั่วหน่วยความจำอย่างต่อเนื่องเนื่องจากโฟลว์ควบคุมโครงสร้างเช่นWhileคาดว่าจะถูกปิดโดยEndและผลักบางสิ่งบางอย่างบนสแต็ก (ไม่ใช่สแต็ก OS, สแต็กแยกในหน่วยความจำฮีป) เพื่อติดตามสิ่งนั้น แต่ที่นี่เรากำลังใช้Gotoเพื่อออกจากลูป (ดังนั้นจึงไม่มีEndการดำเนินการเพื่อลบสิ่งออกจากสแต็ก) Whileจะเห็นอีกครั้งสิ่งที่ถูกผลักอีกครั้ง ฯลฯ ดังนั้นมันจึงผลักมันเรื่อย ๆ จนกว่าคุณจะได้รับERR:MEMORY