รหัสสั้นที่สุดที่จะทำให้เกิดการล้นสแต็คคืออะไร? [ปิด]

เพื่อเป็นการระลึกถึงการเปิดตัวสแต็คโอเวอร์โฟลว์สาธารณะรหัสที่สั้นที่สุดในการทำให้สแต็คโอเวอร์โฟลว์คืออะไร ยินดีต้อนรับทุกภาษา

การทางพิเศษแห่งประเทศไทย: เพียงเพื่อให้ชัดเจนในคำถามนี้เห็นว่าฉันเป็นผู้ใช้โครงการเป็นครั้งคราว: หางเรียก "เรียกซ้ำ" คือการทำซ้ำจริงๆและวิธีการแก้ปัญหาใด ๆ ที่สามารถแปลงเป็นโซลูชั่นซ้ำค่อนข้างโดยคอมไพเลอร์ที่ดี ถูกนับ :-P

ETA2: ตอนนี้ฉันเลือก“ คำตอบที่ดีที่สุด” แล้ว ดูโพสต์นี้เพื่อเหตุผล ขอบคุณทุกคนที่มีส่วนร่วม! :-)

คำตอบเหล่านี้ทั้งหมดและไม่มี Befunge? ฉันจะเดิมพันในจำนวนที่พอเหมาะซึ่งเป็นวิธีแก้ปัญหาที่สั้นที่สุดของพวกเขาทั้งหมด:

1

ไม่ได้ล้อเล่น. ลองด้วยตัวคุณเอง: http://www.quirkster.com/iano/js/befunge.html

แก้ไข: ฉันเดาว่าฉันต้องอธิบายเรื่องนี้ 1 ตัวถูกดำเนินการผลัก 1 ลงบนสแต็กภายในของ Befunge และการขาดสิ่งอื่นทำให้มันอยู่ในการวนซ้ำภายใต้กฎของภาษา

ด้วยการใช้ล่ามที่มีให้คุณจะได้ในที่สุดและฉันหมายถึงในที่สุด -จุดที่อาร์เรย์ Javascript ที่แสดงถึง Befunge stack จะใหญ่เกินไปสำหรับเบราว์เซอร์ที่จะจัดสรรใหม่ หากคุณมีล่าม Befunge ง่าย ๆ ที่มีสแต็กขนาดเล็กและล้อมรอบ - เช่นเดียวกับกรณีของภาษาส่วนใหญ่ด้านล่าง - โปรแกรมนี้จะทำให้เกิดการโอเวอร์โฟลว์ที่สังเกตเห็นได้เร็วขึ้น

อ่านบรรทัดนี้และทำในสิ่งที่มันบอกว่าเป็นครั้งที่สอง

คุณสามารถลองใน C # .net

throw new StackOverflowException();

Nemerle :

สิ่งนี้ขัดข้องคอมไพเลอร์ด้วย StackOverflowException:

def o(){[o()]}

ปัจจุบันที่ดีที่สุดของฉัน (ในการชุมนุม x86) คือ:

push eax
jmp short $-1

ซึ่งส่งผลให้เป็นรหัสวัตถุ 3 ไบต์ ( 50 EB FD) สำหรับรหัส 16 บิตสิ่งนี้อาจเป็นไปได้ด้วย:

call $

ซึ่งส่งผลให้ 3 ไบต์ ( E8 FD FF)

PIC18

PIC18 คำตอบที่ได้รับจากการเรียนรู้ TKผลลัพธ์ในคำแนะนำดังต่อไปนี้ (binary):

overflow
   PUSH
   0000 0000 0000 0101
   CALL overflow
   1110 1100 0000 0000
   0000 0000 0000 0000

อย่างไรก็ตาม CALL เพียงอย่างเดียวจะทำการล้นสแต็ก:

CALL $
1110 1100 0000 0000
0000 0000 0000 0000

เล็กกว่าเร็วกว่า PIC18

แต่ RCALL (การโทรแบบสัมพัทธ์) ยังคงมีขนาดเล็กกว่า (ไม่ใช่หน่วยความจำแบบโกลบอลดังนั้นไม่จำเป็นต้องมี 2 ไบต์เพิ่มเติม):

RCALL $
1101 1000 0000 0000

ดังนั้นขนาดที่เล็กที่สุดของ PIC18 จึงเป็นคำสั่งเดียว 16 บิต (สองไบต์) นี่จะใช้เวลา 2 รอบคำสั่งต่อวง ที่ 4 รอบนาฬิกาต่อรอบการสอนคุณมี 8 รอบรอบ PIC18 มีสแต็กระดับ 31 ดังนั้นหลังจากวน 32 ครั้งมันจะล้นสแต็คในรอบนาฬิกา 256 ที่ 64MHz คุณจะล้นสแต็คใน 4 วินาทีไมโครและ 2 ไบต์

PIC16F5x (ยิ่งเล็กและเร็วกว่า)

อย่างไรก็ตามซีรีย์ PIC16F5x ใช้คำสั่ง 12 บิต:

CALL $
1001 0000 0000

อีกรอบสองคำแนะนำต่อวง 4 นาฬิกาต่อคำสั่งดังนั้น 8 รอบนาฬิกาต่อวง

อย่างไรก็ตาม PIC16F5x มีสแต็กสองระดับดังนั้นในลูปที่สามมันจะล้นใน 24 คำแนะนำ ที่ 20MHz ก็จะล้นใน 1.2 วินาทีและ 1.5 ไมโครไบต์

Intel 4004

Intel 4004มีการเรียนการสอนโทร subroutine 8 บิต:

CALL $
0101 0000

สำหรับผู้อยากรู้อยากเห็นที่สอดคล้องกับ ascii 'P' กับสแต็คระดับ 3 ที่ใช้เวลา 24 รอบนาฬิการวมเป็น32.4 วินาทีและไมโครหนึ่งไบต์ (เว้นแต่คุณจะโอเวอร์คล็อก 4004 ของคุณ - มาเลยคุณรู้ว่าคุณต้องการ)

ซึ่งมีขนาดเล็กเท่ากับคำตอบ befunge แต่เร็วกว่าโค้ด befunge มากที่ทำงานในล่ามปัจจุบัน

ค#:

public int Foo { get { return Foo; } }

บีบแตรมากเกินไป!

//              v___v
let rec f o = f(o);(o)
//             ['---']
//             -"---"-

ทุกงานต้องการเครื่องมือที่เหมาะสม พบกับภาษาSO Overflowซึ่งได้รับการปรับปรุงเพื่อสร้างสแต็คโอเวอร์โฟลว์

so

เท็กซ์:

\def~{~.}~

ผลลัพธ์ใน:

! เกินความจุของ TeX ขออภัย [ขนาดสแต็กอินพุต = 5000]
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
...
<*> \ def ~ {~.} ~

น้ำยาง:

\end\end

ผลลัพธ์ใน:

! เกินความจุของ TeX ขออภัย [ขนาดสแต็กอินพุต = 5000]
\ end # 1 -> \ csname end # 1
                      \ endcsname \ @checkend {# 1} \ expandafter \ endgroup \ if @ e ...
<*> \ end \ end

แอสเซมเบลอร์ Z-80 - ที่ตำแหน่งหน่วยความจำ 0x0000:

rst 00

one byte - 0xC7 - วนซ้ำไม่สิ้นสุดของการผลักดันพีซีปัจจุบันไปยังสแต็กและกระโดดไปยังที่อยู่ 0x0000

เป็นภาษาอังกฤษ:

recursion = n. See recursion.

อีกตัวอย่าง PHP:

<?
require(__FILE__);

วิธีการเกี่ยวกับสิ่งต่อไปนี้ในภาษาเบสิก:

10 GOSUB 10

(ฉันไม่มีล่ามพื้นฐานฉันเกรงว่าจะเป็นการเดา)

ฉันชอบคำตอบของโคดี้ดังนั้นนี่คือผลงานที่คล้ายกันของฉันใน C ++:

template <int i>
class Overflow {
    typedef typename Overflow<i + 1>::type type;
};

typedef Overflow<0>::type Kaboom;

ไม่ใช่รายการรหัสกอล์ฟโดยวิธีการใด ๆ แต่ก็ยังมีอะไรให้เมตาโฟลว์ล้น! :-P

นี่คือผลงาน C ของฉันซึ่งมีน้ำหนัก 18 ตัว:

void o(){o();o();}

นี้เป็นจำนวนมากยากที่จะเพิ่มประสิทธิภาพหาง-Call! :-P

การใช้แบตช์ไฟล์ของ Window ชื่อ "s.bat":

call s

จาวาสคริ

หากต้องการตัดตัวละครออกไปอีกสองสามตัวและเพื่อกำจัดตัวเองออกจากร้านค้าซอฟแวร์มากขึ้นไปด้วย:

eval(i='eval(i)');

Groovy:

main()

$ groovy stack.groovy:

Caught: java.lang.StackOverflowError
    at stack.main(stack.groovy)
    at stack.run(stack.groovy:1)
 ...

โปรดบอกฉันว่าตัวย่อ " GNU " ย่อมาจากอะไร

Person JeffAtwood;
Person JoelSpolsky;
JeffAtwood.TalkTo(JoelSpolsky);

หวังว่าจะไม่มีการเรียกซ้ำแบบหางเลย!

C - ไม่ใช่สั้นที่สุด แต่ไม่มีการเรียกซ้ำ มันไม่ใช่แบบพกพา: มันล้มเหลวบน Solaris แต่การใช้งาน alloca () บางอย่างอาจส่งคืนข้อผิดพลาดที่นี่ (หรือโทร malloc ()) จำเป็นต้องเรียกใช้ printf ()

#include <stdio.h>
#include <alloca.h>
#include <sys/resource.h>
int main(int argc, char *argv[]) {
    struct rlimit rl = {0};
    getrlimit(RLIMIT_STACK, &rl);
    (void) alloca(rl.rlim_cur);
    printf("Goodbye, world\n");
    return 0;
}

Perl ใน 12 ตัวอักษร:

$_=sub{&$_};&$_

ทุบตีใน 10 ตัวอักษร (พื้นที่ในฟังก์ชั่นเป็นสิ่งสำคัญ):

i(){ i;};i

ลองและวางมากกว่า 4 ไส้บนเบอร์เกอร์เดียว ล้นล้น

งูหลาม :

so=lambda:so();so()

อีกวิธีหนึ่งคือ:

def so():so()
so()

และถ้า Python ปรับหางให้เหมาะสมจะเรียก ... :

o=lambda:map(o,o());o()

ฉันกำลังเลือก "คำตอบที่ดีที่สุด" หลังจากโพสต์นี้ แต่ก่อนอื่นฉันต้องการรับทราบการมีส่วนร่วมที่เป็นต้นฉบับ:

1. คนของ aku แต่ละคนสำรวจวิธีการใหม่และเป็นต้นฉบับที่ทำให้เกิดการล้นสแต็ค แนวคิดของการทำ f (x) ⇒ f (f (x)) คือสิ่งที่ฉันจะสำรวจในรายการถัดไปของฉันด้านล่าง :-)
2. โคดี้คือคอมไพเลอร์ที่ทำให้ Nemerle คอมไพล์โอเวอร์โฟลว์
3. และ (เล็กน้อยไม่น่าพอใจ) หนึ่งใน GateKiller เกี่ยวกับการโยนข้อยกเว้นสแต็คล้น :-P

เท่าที่ฉันชอบข้างต้นความท้าทายเกี่ยวกับการทำรหัสกอล์ฟและเพื่อความเป็นธรรมกับผู้ตอบแบบสอบถามฉันต้องให้รางวัล“ คำตอบที่ดีที่สุด” สำหรับรหัสสั้นที่สุดซึ่งเป็นรายการ Befunge; ฉันไม่เชื่อว่าทุกคนจะสามารถเอาชนะได้ (ถึงแม้ว่าคอนราดจะพยายามอย่างแน่นอน) ดังนั้นขอแสดงความยินดีกับแพทริค!

เมื่อเห็นการแก้ปัญหาสแต็ค - โอเวอร์ - บาย - เคอร์ชั่นจำนวนมากฉันประหลาดใจที่ไม่มีใครมี (จากการเขียนในปัจจุบัน) ได้นำ combinator Y ขึ้นมา (ดูเรียงความของ Dick Gabriel, The Why of Yสำหรับไพรเมอร์) ฉันมีโซลูชันแบบเรียกซ้ำที่ใช้ Y combinator รวมถึงวิธี f (f (x)) ของ aku :-)

((Y (lambda (f) (lambda (x) (f (f x))))) #f)

นี่คืออีกหนึ่งที่น่าสนใจจากโครงการ:

((แลมบ์ดา (x) (xx)) (แลมบ์ดา (x) (xx)))

ชวา

โซลูชัน Java รุ่นที่สั้นกว่าเล็กน้อย

class X{public static void main(String[]a){main(a);}}

xor esp, esp
ret

3 ไบต์:

label:
  pusha
  jmp label

ปรับปรุง

ตามเอกสาร (เก่า) ของ Intel (?)นี่เป็น 3 ไบต์ด้วย:

label:
  call label