บทนำ

คุณอาจคุ้นเคยกับzip bombs , XML bombsและอื่น ๆ กล่าวง่ายๆคือมันเป็นไฟล์ขนาดเล็ก (ค่อนข้าง) ซึ่งให้ผลลัพธ์มหาศาลเมื่อตีความโดยซอฟต์แวร์ไร้เดียงสา ความท้าทายที่นี่คือการใช้คอมไพเลอร์ในทางที่ผิด

ท้าทาย

เขียนซอร์สโค้ดที่มีขนาด 512 ไบต์หรือน้อยกว่าและคอมไพล์ลงในไฟล์ที่มีพื้นที่ว่างมากที่สุด ไฟล์ที่ส่งออกที่ใหญ่ที่สุดชนะ!

กฎระเบียบ

ตกลงดังนั้นจึงมีคำอธิบายคำจำกัดความและข้อ จำกัด ที่สำคัญบางประการ

• ผลลัพธ์ของการคอมไพล์ต้องเป็นไฟล์ELF , Windows Portable Executable (.exe), หรือ bytecode เสมือนสำหรับ JVM หรือ CLR ของ. Net (CLTC เสมือนจริงประเภทอื่น ๆ ก็น่าจะตกลงถ้าถาม) อัปเดต: เอาต์พุตของ Python .pyc / .pyo ก็มีผลเช่นกัน
• หากภาษาที่คุณเลือกไม่สามารถรวบรวมได้โดยตรงในรูปแบบใดรูปแบบหนึ่งก็อนุญาตให้ทำการ transpilation ตามด้วยการคอมไพล์ได้ด้วย ( อัปเดต: คุณสามารถ transpile ได้หลายครั้งตราบใดที่คุณไม่เคยใช้ภาษาเดียวกันมากกว่าหนึ่งครั้ง )
• ซอร์สโค้ดของคุณอาจประกอบด้วยไฟล์หลายไฟล์และแม้แต่ไฟล์ทรัพยากร แต่ขนาดรวมของไฟล์เหล่านี้ต้องไม่เกิน 512 ไบต์
• คุณไม่สามารถใช้อินพุตอื่นนอกเหนือจากไฟล์ต้นฉบับและไลบรารี่มาตรฐานของภาษาที่คุณเลือก การเชื่อมโยงคงที่ห้องสมุดมาตรฐานก็โอเคเมื่อได้รับการสนับสนุน ไม่มีไลบรารีบุคคลที่สามหรือไลบรารี OS
• ต้องเป็นไปได้ที่จะเรียกใช้การคอมไพล์ของคุณโดยใช้คำสั่งหรือชุดคำสั่ง หากคุณต้องการที่เฉพาะเจาะจงธงเมื่อรวบรวมเหล่านี้นับรวมในวงเงินไบต์ของคุณ (เช่นหากสายการคอมไพล์ของคุณคือgcc bomb.c -o bomb -O3 -lmการ-O3 -lmมีส่วนร่วม (7 bytes) จะถูกนับ (หมายเหตุพื้นที่ชั้นนำเริ่มต้นจะไม่นับ)
• ตัวประมวลผลล่วงหน้าอนุญาตเฉพาะในกรณีที่เป็นตัวเลือกการรวบรวมมาตรฐานสำหรับภาษาของคุณ
• สภาพแวดล้อมขึ้นอยู่กับคุณ แต่เพื่อประโยชน์ในการตรวจสอบนี้โปรดยึดตามเวอร์ชั่นล่าสุดของคอมไพเลอร์และระบบปฏิบัติการ (และมีการระบุอย่างชัดเจนว่าคุณกำลังใช้)
• มันจะต้องรวบรวมโดยไม่มีข้อผิดพลาด (คำเตือนก็โอเค) และการล่มของคอมไพเลอร์จะไม่นับรวมทุกอย่าง
• สิ่งที่โปรแกรมของคุณทำไม่เกี่ยวข้องจริง ๆแม้ว่ามันจะไม่เป็นอันตรายอะไรก็ตาม มันไม่จำเป็นต้องเริ่มด้วยซ้ำ

ตัวอย่างที่ 1

โปรแกรม C

main(){return 1;}

คอมไพล์ด้วยApple LLVM version 7.0.2 (clang-700.1.81)บน OS X 10.11 (64 บิต):

clang bomb.c -o bomb -pg

สร้างไฟล์ขนาด 9228 ไบต์ ขนาดแหล่งที่มาทั้งหมดคือ 17 +3 (สำหรับ-pg) = 20 ไบต์ซึ่งเป็นขนาดที่ จำกัด ได้ง่าย

ตัวอย่างที่ 2

โปรแกรม Brainfuck:

++++++[->++++++++++++<]>.----[--<+++>]<-.+++++++..+++.[--->+<]>-----.--
-[-<+++>]<.---[--->++++<]>-.+++.------.--------.-[---<+>]<.[--->+<]>-.

transpiled ด้วยawibถึง c ด้วย:

./awib < bomb.bf > bomb.c

คอมไพล์แล้วด้วยApple LLVM version 7.0.2 (clang-700.1.81)บน OS X 10.11 (64 บิต):

clang bomb.c

สร้างไฟล์ 8464 ไบต์ อินพุตทั้งหมดที่นี่คือ 143 ไบต์ (เนื่องจาก@lang_cเป็นค่าเริ่มต้นสำหรับ awib ซึ่งไม่จำเป็นต้องเพิ่มลงในไฟล์ต้นฉบับและไม่มีแฟล็กพิเศษสำหรับคำสั่งใดคำสั่งหนึ่ง)

โปรดทราบว่าในกรณีนี้ไฟล์ bomb.c ชั่วคราวคือ 802 ไบต์ แต่สิ่งนี้นับรวมทั้งขนาดแหล่งข้อมูลและขนาดเอาต์พุต

หมายเหตุสุดท้าย

หากการส่งออกมากกว่า 4GB จะประสบความสำเร็จ (บางทีถ้าใครพบทัวริง preprocessor สมบูรณ์) การแข่งขันก็จะเป็นแหล่งที่มีขนาดเล็กที่สุดซึ่งเป็นผู้ผลิตไฟล์อย่างน้อยขนาดว่า (มันเป็นเพียงไม่ปฏิบัติเพื่อทดสอบการส่งที่ได้รับมากเกินไปขนาดใหญ่) .

C, (14 + 15) = 29 ไบต์, 17,179,875,837 (16 GB) ปฏิบัติการได้ไบต์

ขอบคุณ @viraptor สำหรับการปิด 6 ไบต์

ขอบคุณ @hvd สำหรับ 2 ไบต์และขนาด x4 ที่สามารถเรียกใช้งานได้

สิ่งนี้นิยามmainฟังก์ชันเป็นอาร์เรย์ขนาดใหญ่และเริ่มต้นองค์ประกอบแรก สิ่งนี้ทำให้ GCC เก็บอาร์เรย์ทั้งหมดในการปฏิบัติการที่เกิดขึ้น

เนื่องจากอาร์เรย์นี้มีขนาดใหญ่กว่า 2GB เราจึงต้องระบุการ-mcmodel=mediumตั้งค่าสถานะให้กับ GCC 15 ไบต์พิเศษเพิ่มเติมจะรวมอยู่ในคะแนนตามกฎ

main[-1u]={1};

อย่าคาดหวังว่ารหัสนี้จะทำสิ่งที่ดีเมื่อทำงาน

รวบรวมกับ:

gcc -mcmodel=medium cbomb.c -o cbomb

ฉันใช้เวลาสักครู่เพื่อทดสอบการแนะนำของ @ hvd - และหาเครื่องที่มีน้ำผลไม้เพียงพอที่จะจัดการกับมัน ในที่สุดฉันก็พบ RedHat 5.6 ที่ไม่ใช่การผลิตแบบเก่ากับ VM 10GB RAM, 12GB swap และ / tmp ถูกตั้งค่าเป็นพาร์ติชั่นโลคัลขนาดใหญ่ รุ่น GCC คือ 4.1.2 เวลาในการรวบรวมทั้งหมดประมาณ 27 นาที

เนื่องจาก CPU และโหลด RAM, ฉันแนะนำต่อการทำเช่นนี้รวบรวมบนเครื่องการผลิตที่เกี่ยวข้องใด

C # ประมาณ 1 นาทีในการคอมไพล์ไบนารีเอาต์พุต 28MB:

class X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

การเพิ่ม Y มากขึ้นจะเป็นการเพิ่มขนาดแบบเอ็กซ์โพเนนเชียล

คำอธิบายโดย Pharap ตามคำขอของ @Odomontois:

คำตอบนี้เป็นการเหยียดหยามการสืบทอดและพารามิเตอร์ชนิดเพื่อสร้างการเรียกซ้ำ เพื่อให้เข้าใจถึงสิ่งที่เกิดขึ้นง่ายขึ้นในการทำให้ปัญหาง่ายขึ้น พิจารณาclass X<A> { class Y : X<Y> { Y y; } }ซึ่งจะสร้างชั้นทั่วไปซึ่งมีระดับชั้นX<A> สืบทอดจึงยังมีระดับชั้นซึ่งเป็นแล้ว สิ่งนี้ยังมีคลาสภายในและคลาสภายในนั้นมีคลาสชั้นในฯลฯ ซึ่งหมายความว่าคุณสามารถใช้การแก้ปัญหาขอบเขต ( ) infinitum โฆษณาและทุกครั้งที่คุณใช้คอมไพเลอร์จะต้องอนุมานอีกระดับของการสืบทอดและพารามิเตอร์ประเภท .YX<A>.YX<Y>X<A>.YYX<A>.Y.YYYY.

โดยการเพิ่มพารามิเตอร์ประเภทเพิ่มเติมงานที่คอมไพเลอร์ต้องทำในแต่ละขั้นตอนจะเพิ่มขึ้นอีก

พิจารณากรณีต่อไปนี้
ในclass X<A> { class Y : X<Y> { Y y;} }ประเภทพระรามมีประเภทของA ในประเภทพระรามมีประเภทของ ในประเภทพระรามมีประเภทของ ในประเภทพระรามเป็นและเป็น ในประเภทพระรามเป็นและเป็น ในประเภทพระรามเป็นและเป็นX<A>.Y
class X<A> { class Y : X<Y> { Y.Y y;} }AX<X<A>.Y>.Y
class X<A> { class Y : X<Y> { Y.Y.Y y;} }AX<X<X<A>.Y>.Y>.Y
class X<A,B> { class Y : X<Y,Y> { Y y;} }AX<A,B>.YBX<A,B>.Y
class X<A> { class Y : X<Y> { Y.Y y;} }AX<X<A,B>.Y, X<A,B>.Y>.YBX<X<A,B>.Y, X<A,B>.Y>.Y
class X<A> { class Y : X<Y> { Y.Y.Y y;} }AX<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.YBX<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y

ต่อไปนี้รูปแบบนี้เพียงคนเดียวที่สามารถจินตนาการ¹การทำงานของคอมไพเลอร์จะต้องทำอย่างไรเพื่อที่จะอนุมานสิ่งAที่จะEอยู่ในในความหมายY.Y.Y.Y.Y.Y.Y.Y.Yclass X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

¹คุณสามารถหาคำตอบได้ แต่คุณต้องใช้ความอดทนเป็นอย่างมากและ Intellisense จะไม่ช่วยคุณที่นี่

Python 3, 13 byte source, 9,057,900,463 byte (8.5GiB) .pyc-file

(1<<19**8,)*2

แก้ไข : เปลี่ยนรหัสเป็นเวอร์ชันด้านบนหลังจากที่ฉันรู้ว่ากฎบอกว่าขนาดเอาต์พุตเกิน 4GiB ไม่สำคัญและรหัสสำหรับขนาดนี้จะสั้นกว่านี้เล็กน้อย รหัสก่อนหน้า - และที่สำคัญกว่านั้นคือคำอธิบายสามารถดูได้ที่ด้านล่าง

Python 3, 16 byte source,> 32TB .pyc-file (หากคุณมีหน่วยความจำเพียงพอ, พื้นที่ดิสก์และความอดทน)

(1<<19**8,)*4**7

คำอธิบาย: Python 3 ทำการพับอย่างต่อเนื่องและคุณจะได้ตัวเลขจำนวนมากอย่างรวดเร็วด้วยการยกกำลัง รูปแบบที่ใช้โดยไฟล์. pyc เก็บความยาวของการแทนค่าจำนวนเต็มโดยใช้ 4 ไบต์และในความเป็นจริงแล้วขีด จำกัด ดูเหมือนจะเป็นเช่น2**31นั้นดังนั้นการใช้เลขชี้กำลังเพื่อสร้างเลขจำนวนมากจะมีขีด จำกัด ที่ดูเหมือนว่าจะสร้าง 2GB ไฟล์ pyc จากแหล่งที่มา 8 ไบต์ ( 19**8ค่อนข้างขี้อาย8*2**31ดังนั้น1<<19**8มีการแสดงไบนารีเพียงแค่ภายใต้ 2GB; การคูณด้วยแปดเป็นเพราะเราต้องการไบต์ไม่ใช่บิต)

อย่างไรก็ตามสิ่งอันดับยังไม่เปลี่ยนรูปและคูณ tuple ยังคงพับเพื่อให้เราสามารถทำซ้ำที่ 2GB หยดหลายครั้งตามที่เราต้องการที่เพิ่มขึ้นอย่างน้อย2**31ครั้งอาจ การ4**7ได้รับไปที่ 32TB นั้นถูกเลือกเพียงเพราะมันเป็นเลขชี้กำลังแรกที่ฉันพบว่าเอาชนะคำตอบ 16TB ก่อนหน้านี้

โชคไม่ดีที่ฉันมีหน่วยความจำในคอมพิวเตอร์ของฉันเองฉันสามารถทดสอบได้เพียง 2 ตัวคูณเท่านั้นนั่นคือ (1<<19**8,)*2ซึ่งสร้างไฟล์ 8.5GB ซึ่งฉันหวังว่าจะแสดงให้เห็นว่าคำตอบนั้นเป็นจริง (เช่นขนาดไฟล์ไม่ จำกัด ที่ 2 ** 32 = 4GB)

นอกจากนี้ฉันไม่รู้ว่าทำไมขนาดไฟล์ที่ฉันได้รับเมื่อทำการทดสอบคือ 8.5GB แทนที่จะเป็น 4GB-ish ที่ฉันคาดไว้และไฟล์มีขนาดใหญ่พอที่ฉันไม่รู้สึกอยากจะแหย่มันในตอนนี้

หากการส่งออกมากกว่า 4GB ประสบความสำเร็จ (อาจจะมีใครบางคนพบว่าตัวประมวลผลสมบูรณ์ก่อน) การแข่งขันจะเป็นแหล่งที่เล็กที่สุดซึ่งสร้างไฟล์ที่มีขนาดอย่างน้อยที่สุดนั้น .

"เทมเพลต Haskell" อนุญาตให้สร้างรหัส Haskell ในเวลาคอมไพล์โดยใช้ Haskell ดังนั้นจึงเป็นตัวประมวลผลล่วงหน้าที่สมบูรณ์

นี่คือความพยายามของฉันซึ่งแปรตามนิพจน์ตัวเลขโดยพลการFOO:

import Language.Haskell.TH;main=print $(ListE .replicate FOO<$>[|0|])

ความมหัศจรรย์คือรหัสภายใน $(...)"ประกบ" สิ่งนี้จะถูกดำเนินการในเวลาคอมไพล์เพื่อสร้าง Haskell AST ซึ่งจะถูกต่อกิ่งเข้ากับ AST ของโปรแกรมแทนการประกบกัน

ในกรณีนี้เราทำให้ AST ง่ายเป็นตัวแทนของตัวอักษร0ที่เราทำซ้ำFOOครั้งที่จะทำรายการแล้วเราใช้ListEจากLanguage.Haskell.THโมดูลที่จะเปิดรายการนี้ลงใน asts AST [0, 0, 0, 0, 0, ...]ขนาดใหญ่ที่เป็นตัวแทนของตัวอักษร

โปรแกรมดังกล่าวเทียบเท่ากับmain = print [0, 0, 0, ...]กับการเกิดซ้ำของFOO0

วิธีรวบรวม ELF:

$ ghc -XTemplateHaskell big.hs
[1 of 1] Compiling Main             ( big.hs, big.o )
Linking big ...
$ file big
big: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /nix/store/mibabdfiaznqaxqiy4bqhj3m9gaj45km-glibc-2.21/lib/ld-linux.so.2, for GNU/Linux 2.6.32, not stripped

นี้น้ำหนักในที่ 83 ไบต์ (66 สำหรับรหัส Haskell และ 17 สำหรับ-XTemplateHaskellอาร์กิวเมนต์) FOOบวกความยาวของ

เราสามารถหลีกเลี่ยงข้อโต้แย้งของคอมไพเลอร์และเรียบเรียงด้วยghcแต่เราต้องใส่{-# LANGUAGE TemplateHaskell#-}จุดเริ่มต้นซึ่งกระแทกรหัสได้ถึง 97 ไบต์

นี่คือตัวอย่างของนิพจน์FOOและขนาดของไบนารีผลลัพธ์:

FOO         FOO size    Total size    Binary size
-------------------------------------------------
(2^10)      6B          89B           1.1MB
(2^15)      6B          89B           3.6MB
(2^17)      6B          89B           12MB
(2^18)      6B          89B           23MB
(2^19)      6B          89B           44MB

ฉันใช้ RAM ที่คอมไพล์(2^20)แล้ว

นอกจากนี้เรายังสามารถสร้างรายการที่ไม่มีที่สิ้นสุดใช้repeatแทนreplicate FOOแต่นั่นทำให้คอมไพเลอร์หยุดทำงาน;)

C ++, 250 + 26 = 276 ไบต์

template<int A,int B>struct a{static const int n;};
template<int A,int B>const int a<A,B>::n=a<A-1,a<A,B-1>::n>::n;
template<int A>struct a<A,0>{static const int n=a<A-1,1>::n;};
template<int B>struct a<0,B>{static const int n=B+1;};
int h=a<4,2>::n;

นี่คือฟังก์ชัน Ackermann ที่ใช้ในเทมเพลต ฉันไม่สามารถคอมไพล์ด้วยเครื่องh=a<4,2>::n;เล็ก ๆ (6GB) ของฉันได้ แต่ฉันจัดการh=a<3,14>ไฟล์เอาต์พุต 26M คุณสามารถปรับค่าคงที่เพื่อให้ถึงขีด จำกัด ของแพลตฟอร์มของคุณ - ดูบทความ Wikipedia ที่เชื่อมโยงเพื่อขอคำแนะนำ

ต้อง-gตั้งค่าสถานะเพื่อ GCC (เพราะเป็นสัญลักษณ์การแก้ปัญหาทั้งหมดที่ใช้พื้นที่จริง ๆ ) และความลึกของแม่แบบที่ใหญ่กว่าค่าเริ่มต้น บรรทัดการคอมไพล์ของฉันสิ้นสุดลงเมื่อ

g++ -ftemplate-depth=999999 -g -c -o 69189.o 69189.cpp

ข้อมูลแพลตฟอร์ม

g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
Linux 3.13.0-46-generic #79-Ubuntu SMP x86_64 GNU/Linux

ASM, 61 ไบต์ (ซอร์ส 29 ไบต์, 32 ไบต์สำหรับแฟล็ก), 4,294,975,320 ไบต์

.globl main
main:
.zero 1<<32

รวบรวมกับ gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold

นี่คือคำตอบ C ของฉันจากปี 2005 จะสร้างไบนารี 16TB หากคุณมี RAM ขนาด 16TB (คุณไม่มี)

struct indblock{
   uint32_t blocks[4096];
};

struct dindblock {
    struct indblock blocks[4096];
};

struct tindblock {
    struct dindblock blocks[4096];
};

struct inode {
    char data[52]; /* not bothering to retype the details */
    struct indblock ind;
    struct dindblock dint;
    struct tindblock tind;
};

struct inode bbtinode;

int main(){}

ตัวประมวลผลล่วงหน้า C แบบธรรมดาธรรมดา: อินพุต 214 ไบต์, เอาต์พุต 5MB

แรงบันดาลใจจาก preprocessor โลกแห่งความจริงของฉันล้มเหลวที่นี่

#define A B+B+B+B+B+B+B+B+B+B
#define B C+C+C+C+C+C+C+C+C+C
#define C D+D+D+D+D+D+D+D+D+D
#define D E+E+E+E+E+E+E+E+E+E
#define E F+F+F+F+F+F+F+F+F+F
#define F x+x+x+x+x+x+x+x+x+x

int main(void) { int x, y = A; }

การทดลองแสดงให้เห็นว่าแต่ละระดับของความ#defineประสงค์ (ตามที่คาดไว้) ทำให้การส่งออกมีขนาดใหญ่ขึ้นประมาณสิบเท่า แต่เนื่องจากตัวอย่างนี้ใช้เวลามากกว่าหนึ่งชั่วโมงในการรวบรวมฉันจึงไม่เคยไปที่ "G"

Java, 450 + 22 = 472 ไบต์แหล่งไฟล์คลาส ~ 1GB

B.java (เวอร์ชั่นนักกอล์ฟเตือนระหว่างการรวบรวม)

import javax.annotation.processing.*;@SupportedAnnotationTypes("java.lang.Override")public class B extends AbstractProcessor{@Override public boolean process(java.util.Set a,RoundEnvironment r){if(a.size()>0){try(java.io.Writer w=processingEnv.getFiler().createSourceFile("C").openWriter()){w.write("class C{int ");for(int i=0;i<16380;++i){for(int j=0;j<65500;++j){w.write("i");}w.write(i+";int ");}w.write("i;}");}catch(Exception e){}}return true;}}

B.java (เวอร์ชั่นที่ไม่ดี)

import java.io.Writer;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;

@SupportedAnnotationTypes("java.lang.Override")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class B extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (annotations.size() > 0) {
            try (Writer writer = processingEnv.getFiler().createSourceFile("C").openWriter()) {
                writer.write("class C{int ");
                for (int i = 0; i < 16380; ++i) {
                    for (int j = 0; j < 65500; ++j) {
                        writer.write("i");
                    }
                    writer.write(i + ";int ");
                }
                writer.write("i;}");
            } catch (Exception e) {
            }
        }
        return true;
    }
}

การรวบรวม

javac B.java
javac -J-Xmx16G -processor B B.java

คำอธิบาย

ระเบิดนี้ใช้ตัวประมวลผลคำอธิบายประกอบ มันต้องการคอมไพล์พาส 2 ครั้ง Bครั้งแรกผ่านการสร้างระดับการประมวลผล ในระหว่างการส่งครั้งที่สองตัวประมวลผลจะสร้างไฟล์ต้นฉบับใหม่C.javaและคอมไพล์ไฟล์นั้นC.classด้วยขนาดของ1,073,141,162ไบต์

มีข้อ จำกัด หลายประการเมื่อพยายามสร้างไฟล์คลาสใหญ่:

• การสร้างตัวระบุนานกว่าประมาณ 64k error: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant poolผลลัพธ์ใน:
• การสร้างตัวแปร / ฟังก์ชั่นที่มากกว่า 64k ผลลัพธ์: error: too many constants
• นอกจากนี้ยังมีข้อ จำกัด ประมาณ 64k สำหรับขนาดรหัสของฟังก์ชัน
• ดูเหมือนว่าจะมีข้อ จำกัด ทั่วไป (ข้อผิดพลาด?) ในคอมไพเลอร์ java ประมาณ 1GB สำหรับ.classไฟล์ ถ้าผมเพิ่ม16380ไป16390ในโค้ดข้างต้นคอมไพเลอร์ไม่เคยส่งกลับ
• นอกจากนี้ยังมีข้อ จำกัด เกี่ยวกับ.javaไฟล์1GB เพิ่มขึ้น16380ไป16400ในผลโค้ดข้างต้นใน: ตามมาด้วยAn exception has occurred in the compiler (1.8.0_66). Please file a bug ...java.lang.IllegalArgumentException

C, ซอร์ส 26 ไบต์, 2,139,103,367 ไบต์เอาต์พุต, โปรแกรมที่ถูกต้อง

const main[255<<21]={195};

รวบรวมโดยใช้: gcc cbomb.c -o cbomb(รุ่น gcc 4.6.3, Ubuntu 12.04, ~ 77 วินาที)

ฉันคิดว่าฉันจะลองดูว่าฉันสามารถสร้างโปรแกรมที่ถูกต้องได้โดยไม่ต้องใช้ตัวเลือกบรรทัดคำสั่งใด ๆ ฉันได้แนวคิดจากคำตอบนี้: https://codegolf.stackexchange.com/a/69193/44946โดย Digital Trauma ดูความคิดเห็นที่นั่นเป็นสาเหตุที่รวบรวมนี้

วิธีการทำงาน: การconstลบการตั้งค่าสถานะการเขียนออกจากหน้าในกลุ่มเพื่อให้สามารถดำเนินการหลัก นี่195คือรหัสเครื่อง Intel สำหรับการส่งคืน และเนื่องจากสถาปัตยกรรมของ Intel นั้นมีขนาดเล็กมากจึงเป็นไบต์แรก โปรแกรมจะออกจากสิ่งที่รหัสเริ่มต้นใส่ใน eax register น่าจะเป็น 0

เพียงประมาณ 2 กิ๊กเนื่องจากตัวเชื่อมโยงใช้ค่าที่เซ็นชื่อ 32 บิตสำหรับการออฟเซ็ต มันมีขนาดเล็กกว่า 2 เมกะไบต์ 8 กิกะไบต์เนื่องจากคอมไพเลอร์ / ลิงเกอร์ต้องการพื้นที่ในการทำงานและนี่คือขนาดที่ใหญ่ที่สุดที่ฉันสามารถรับได้โดยไม่มีข้อผิดพลาดตัวลิงก์ - ymmv

Boo , 71 ไบต์ เวลารวบรวม: 9 นาที 134,222,236 ไบต์ปฏิบัติการได้

macro R(e as int):
 for i in range(2**e):yield R.Body
x = 0
R 25:++x

ใช้มาโครR(สำหรับการทำซ้ำ) เพื่อทำให้คอมไพเลอร์เพิ่มจำนวนคำสั่งที่เพิ่มขึ้นเป็นจำนวนครั้งโดยพลการ ไม่ต้องการแฟล็กคอมไพเลอร์พิเศษ เพียงบันทึกไฟล์เป็นbomb.booและเรียกคอมไพเลอร์ด้วยbooc bomb.booเพื่อสร้าง

Kotlin , แหล่ง 90 ไบต์, 177416 ไบต์ (173 KB) ที่รวบรวม JVM ไบนารี

inline fun a(x:(Int)->Any){x(0);x(1)}
fun b()=a{a{a{a{a{a{a{a{a{a{a{println(it)}}}}}}}}}}}

ในทางเทคนิคคุณสามารถทำสิ่งนี้ได้นานขึ้นโดยการซ้อนการแสดงออกเพิ่มเติม อย่างไรก็ตามคอมไพเลอร์ล้มเหลวด้วยStackOverflowข้อผิดพลาดถ้าคุณเพิ่มการสอบถามซ้ำ

C ++, 214 ไบต์ (ไม่จำเป็นต้องมีตัวเลือกการรวบรวมพิเศษ)

#define Z struct X
#define T template<int N
T,int M=N>Z;struct Y{static int f(){return 0;}};T>Z<N,0>:Y{};T>Z<0,N>:Y{};T,int M>Z{static int f(){static int x[99999]={X<N-1,M>::f()+X<N,M-1>::f()};}};int x=X<80>::f();

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

ไฟล์อ็อบเจ็กต์ที่สร้างด้วยg++ 4.9.3 x86_64-pc-cygwin2567355421 ไบต์ (2.4GiB)

การเพิ่มค่าเริ่มต้นที่สูงกว่า 80 จะทำให้ตัวแบ่ง cygwin gcc (มีเซกเมนต์มากเกินไป)

นอกจากนี้ยัง99999สามารถถูกแทนที่ด้วย9<<19หรือคล้ายกันสำหรับขนาดที่เพิ่มขึ้นโดยไม่ต้องเปลี่ยนซอร์สโค้ด ... แต่ฉันไม่คิดว่าฉันต้องใช้พื้นที่ดิสก์มากกว่าที่ฉันเป็นอยู่แล้ว)

Scala - 70 ไบต์แหล่ง 22980842 ผลไบต์ (หลังจาก jar)

import scala.{specialized => s}
class X[@s A, @s B, @s C, @s D, @s E]

สิ่งนี้จะสร้างไฟล์คลาสพิเศษ9 ⁵ (ประมาณ 59,000) ซึ่งบรรจุลงในขวดขนาดประมาณ 23 MB ในหลักการคุณสามารถทำต่อไปได้หากคุณมีระบบไฟล์ที่สามารถจัดการกับไฟล์จำนวนมากและหน่วยความจำที่เพียงพอ

(หากคำสั่ง jar ต้องถูกรวมไว้มันคือ 82 ไบต์)

C, 284 ไบต์ +2 สำหรับ-cin gcc bomb.c -o bomb.o -c; เอาต์พุต: 2 147 484 052 ไบต์

#define a 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
#define b a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a
#define c b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b
#define d c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c
#define e d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d
#define f e,e,e,e,e,e,e,e,e,e,e,e,e,e,e,e
__int128 x[]={f,f,f,f,f,f,f,f};

Boo มากกว่าที่คุณคาดหวังจากสิ่งนี้

macro R(e as int):for i in range(9**e):yield R.Body
x = 0
R 99:++x

Python 3:

9**9**9**9**9

ระเบิด Tetration