හැදින්වීම

සිප් බෝම්බ , එක්ස්එම්එල් බෝම්බ ආදිය ගැන ඔබ බොහෝ විට හුරුපුරුදු ය . සරලව කිවහොත්, ඒවා (සාපේක්ෂව) නව මෘදුකාංග මගින් අර්ථ නිරූපණය කිරීමේදී දැවැන්ත ප්‍රතිදානයක් ලබා දෙන කුඩා ලිපිගොනු ය. මෙහි ඇති අභියෝගය වන්නේ සම්පාදකයෙකු එකම ආකාරයකින් අපයෝජනය කිරීමයි.

අභියෝගය

බයිට් 512 ක් හෝ ඊට අඩු ප්‍රමාණයක් ඇති සහ හැකි ඉඩ ප්‍රමාණයක් ඇති ගොනුවකට සම්පාදනය කරන ප්‍රභව කේත කිහිපයක් ලියන්න. විශාලතම ප්‍රතිදාන ගොනුව ජය ගනී!

නීති

හරි, එබැවින් වැදගත් පැහැදිලි කිරීම්, අර්ථ දැක්වීම් සහ සීමාවන් කිහිපයක් තිබේ;

• සම්පාදනයේ ප්‍රතිදානය ඊඑල්එෆ් ගොනුවක්, වින්ඩෝස් අතේ ගෙන යා හැකි ක්‍රියාත්මක කළ හැකි (.exe) හෝ ජේවීඑම් හෝ .නෙට් හි සීඑල්ආර් සඳහා අථත්ය බයිට් කේතයක් විය යුතුය (වෙනත් වර්ගවල අථත්ය බයිට් කේතය ඉල්ලුවහොත් හරි වනු ඇත). යාවත්කාලීන කිරීම: පයිතන්ගේ .pyc / .pyo ප්‍රතිදානය ද ගණන් කරයි.
• ඔබේ තේරීමේ භාෂාව එම ආකෘතිවලින් එකකට කෙලින්ම සම්පාදනය කළ නොහැකි නම්, සම්පාදනය කිරීමෙන් පසුව සම්ප්‍රේෂණය කිරීමට ද අවසර දෙනු ලැබේ ( යාවත්කාලීන කිරීම: ඔබට එකම භාෂාව එක වරකට වඩා භාවිතා නොකරන තාක් කල් ඔබට කිහිප වතාවක් සම්ප්‍රේෂණය කළ හැකිය ).
• ඔබේ ප්‍රභව කේතයට බහු ලිපිගොනු වලින් සමන්විත විය හැකි අතර සම්පත් ලිපිගොනු පවා තිබිය හැක, නමුත් මෙම සියලු ගොනු වල සාරාංශ ප්‍රමාණය බයිට් 512 නොඉක්මවිය යුතුය.
• ඔබේ මූලාශ්‍ර ගොනුව සහ ඔබේ තේරීමේ භාෂාවේ සම්මත පුස්තකාලය හැර වෙනත් ආදානයක් භාවිතා කළ නොහැක. සම්මත පුස්තකාල සඳහා ස්ථිතික සම්බන්ධ කිරීම සහය දක්වන විට හරි. විශේෂයෙන්, තෙවන පාර්ශවීය පුස්තකාල හෝ මෙහෙයුම් පද්ධති පුස්තකාල නොමැත.
• විධානයක් හෝ විධාන මාලාවක් භාවිතා කරමින් ඔබේ සම්පාදනය කිරීමට හැකි විය යුතුය. සම්පාදනය කිරීමේදී ඔබට නිශ්චිත කොඩි අවශ්‍ය නම්, මේවා ඔබේ බයිට් සීමාව දෙසට ගණනය කරයි (උදා: ඔබේ සම්පාදන රේඛාව නම් gcc bomb.c -o bomb -O3 -lm, -O3 -lmකොටස (බයිට් 7) ගණනය කරනු ලැබේ (ආරම්භක ප්‍රමුඛ අවකාශය ගණන් නොගනී).
• පෙර සැකසුම්කරුවන්ට අවසර දී ඇත්තේ ඒවා ඔබේ භාෂාව සඳහා සම්මත සම්පාදන විකල්පයක් නම් පමණි .
• පරිසරය ඔබට භාරයි, නමුත් මෙය සත්‍යාපනය කිරීමේ අවශ්‍යතාවයන් සඳහා, කරුණාකර මෑත කාලීන (එනම් ලබා ගත හැකි) සම්පාදක අනුවාද සහ මෙහෙයුම් පද්ධති වෙත ඇලී සිටින්න (සහ පැහැදිලිවම ඔබ භාවිතා කරන්නේ කුමක්ද යන්න සඳහන් කරන්න).
• එය දෝෂයකින් තොරව සම්පාදනය කළ යුතුය (අනතුරු ඇඟවීම් හරි), සහ සම්පාදකයා බිඳ වැටීම කිසිවක් සඳහා ගණන් නොගනී.
• ඔබගේ වැඩසටහන ඇත්ත වශයෙන්ම කරන දෙය අදාළ නොවේ, එය අනිෂ්ට කිසිවක් විය නොහැක. එය ආරම්භ කිරීමට පවා හැකියාවක් නැත.

උදාහරණ 1

සී වැඩසටහන

main(){return 1;}

Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11 (64-bit) සමඟ සම්පාදනය කර ඇත:

clang bomb.c -o bomb -pg

බයිට් 9228 ක ගොනුවක් නිෂ්පාදනය කරයි. මුළු ප්‍රභව ප්‍රමාණය 17 + 3 (සඳහා -pg) = බයිට් 20 වන අතර එය පහසුවෙන් ප්‍රමාණයේ සීමාව තුළ වේ.

උදාහරණ 2

බ්‍රේන්ෆක් වැඩසටහන:

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

ඇවිබ් සමඟ සී සමඟ පරිවර්තනය කර ඇත්තේ:

./awib < bomb.bf > bomb.c

ඉන්පසු Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11 (64-bit) සමඟ සම්පාදනය කරයි :

clang bomb.c

බයිට් 8464 ක ගොනුවක් නිෂ්පාදනය කරයි. මෙහි සම්පූර්ණ ආදානය බයිට් 143 කි ( @lang_cඅවීබ් සඳහා පෙරනිමිය බැවින් එය ප්‍රභව ගොනුවට එක් කිරීමට අවශ්‍ය නොවීය, තවද එක් විධානයක විශේෂ කොඩි නොමැත).

මෙම අවස්ථාවේ දී, තාවකාලික බෝම්බ සී ගොනුව බයිට් 802 ක් වන නමුත් මෙය ප්‍රභවයේ ප්‍රමාණයට හෝ ප්‍රතිදාන ප්‍රමාණයට ගණන් නොගනී.

අවසාන සටහන

4GB කට වඩා වැඩි නිමැවුම් (කවුරුහරි වූ ටියුරින්ග් සම්පූර්ණ preprocessor සම්බ සමහර විට නම්) ලබා ගෙන ඇත නම්, තරඟය සඳහා වනු ඇත කුඩාම ප්රභවය වූ බව ඊයේ ප්රමාණයේ ගොනුවක් නිපදවන (එය පමණක් ලබා ඇති ටෙස්ට් කරුණු ඉදිරිපත් කිරීමට ප්රායෝගික දෙයක් ද විශාල) .

සී, (14 + 15) = 29 බයිට් ප්‍රභවය, 17,179,875,837 (16 GB) බයිට් ක්‍රියාත්මක කළ හැකි

බයිට් 6 ක් කපා හැරීම සඳහා @viraptor ට ස්තූතියි.

බයිට් 2 ක් කපා හැරිය හැකි සහ ක්‍රියාත්මක කළ හැකි ප්‍රමාණය x4 සඳහා @hvd ට ස්තූතියි.

මෙය mainශ්‍රිතය විශාල අරාවක් ලෙස අර්ථ දක්වන අතර එහි පළමු අංගය ආරම්භ කරයි. මෙහි ප්‍රති G ලයක් ලෙස ක්‍රියාත්මක කළ හැකි මුළු අරාම GCC ගබඩා කරයි.

මෙම අරාව 2GB ට වඩා විශාල බැවින් අපි -mcmodel=mediumධජය GCC වෙත සැපයිය යුතුය . අමතර බයිට් 15 ක් නීතිරීතිවලට අනුව ලකුණු වලට ඇතුළත් කර ඇත.

main[-1u]={1};

මෙම කේතය ක්‍රියාත්මක වන විට හොඳ දෙයක් කරයි කියා බලාපොරොත්තු නොවන්න.

සමඟ සම්පාදනය කරන්න:

gcc -mcmodel=medium cbomb.c -o cbomb

V hvd ගේ යෝජනාව පරීක්ෂා කිරීමට සහ එය හැසිරවීමට ප්‍රමාණවත් යුෂ සහිත යන්ත්‍රයක් සොයා ගැනීමට මට යම් කාලයක් ගත විය. අවසානයේදී 10GB RAM, 12GB swap, සහ / tmp විශාල දේශීය කොටසකට සකසා ඇති පැරණි නිෂ්පාදන නොවන RedHat 5.6 VM එකක් මට හමු විය. 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 එකතු කිරීමෙන් ප්‍රමාණය on ාතීය ලෙස වැඩි වේ.

O ඔඩොමොන්ටොයිස්ගේ ඉල්ලීම අනුව ෆරාප් විසින් පැහැදිලි කිරීමක්:

මෙම පිළිතුර පුනරාවර්තනය නිර්මාණය කිරීම සඳහා උරුමය අනිසි ලෙස භාවිතා කිරීම සහ පරාමිතීන් ටයිප් කිරීම ය. සිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීමට, පළමුව ගැටළුව සරල කිරීම පහසුය. අභ්‍යන්තර පංතියක් class X<A> { class Y : X<Y> { Y y; } }ඇති ජනක පන්තිය ජනනය කරන සලකා බලන්න . අනුන , ඒ නිසා ද අභ්යන්තර පන්තියට පසුව වන, . මෙය පසුව අභ්‍යන්තර පංතියක් ද ඇති අතර අභ්‍යන්තර පන්තියට අභ්‍යන්තර පංතියක් ඇත . මෙයින් අදහස් කරන්නේ ඔබට විෂය පථය විභේදනය ( ) දැන්වීම් අනන්තය භාවිතා කළ හැකි බවත්, ඔබ එය භාවිතා කරන සෑම අවස්ථාවකම සම්පාදකයාට තවත් උරුමයක් සහ වර්ග පරාමිතිකරණයක් අඩු කළ යුතු බවත්ය. .X<A>YX<A>.YX<Y>X<A>.YYX<A>.Y.YYYY.

අතිරේක වර්ග පරාමිතීන් එකතු කිරීමෙන්, එක් එක් අදියරේදී සම්පාදකයා විසින් කළ යුතු කාර්යයන් තවදුරටත් වැඩි වේ.

පහත සඳහන් කාරණා සලකා බැලීම:
දී class X<A> { class Y : X<Y> { Y y;} }වර්ගය param Aවර්ගයක් ඇත X<A>.Y.
දී class X<A> { class Y : X<Y> { Y.Y y;} }වර්ගය param Aවර්ගයක් ඇත X<X<A>.Y>.Y.
දී class X<A> { class Y : X<Y> { Y.Y.Y y;} }වර්ගය param Aවර්ගයක් ඇත X<X<X<A>.Y>.Y>.Y.
දී class X<A,B> { class Y : X<Y,Y> { Y y;} }වර්ගය param Aවේ X<A,B>.Yහා Bවන X<A,B>.Y.
දී class X<A> { class Y : X<Y> { Y.Y y;} }වර්ගය param Aවේ X<X<A,B>.Y, X<A,B>.Y>.Yහා Bවන X<X<A,B>.Y, X<A,B>.Y>.Y.
දී class X<A> { class Y : X<Y> { Y.Y.Y y;} }වර්ගය param Aවේ X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Yහා Bවන X<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.Yඑම අර්ථ දැක්වීම 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;}}.

¹ ඔබට එය වටහා ගත හැකිය, නමුත් ඔබට බොහෝ ඉවසීම අවශ්‍ය වනු ඇත, සහ අභිප්‍රාය මෙහි ඔබට උදව් නොකරයි.

පයිතන් 3, බයිට් 13 ප්‍රභවය, බයිට් 9,057,900,463 (8.5GiB) .පයික්-ගොනුව

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

සංස්කරණය කරන්න : 4GiB ඉක්මවා නිමැවුම් ප්‍රමාණය වැදගත් නොවන බව නීති රීති තේරුම් ගත් පසු ඉහත අනුවාදයට කේතය වෙනස් කළේය, මේ සඳහා වන කේතය තරමක් කෙටි වේ; පෙර කේතය - සහ වඩා වැදගත් ලෙස පැහැදිලි කිරීම - පහත සොයාගත හැකිය.

පයිතන් 3, 16 බයිට් ප්‍රභවය,> 32TB .pyc-file (ඔබට ප්‍රමාණවත් මතකයක් තිබේ නම්, තැටි අවකාශය සහ ඉවසීම)

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

පැහැදිලි කිරීම: පයිතන් 3 නිරන්තරයෙන් නැමීම සිදු කරන අතර on ාතීයකරණයෙන් ඔබට විශාල සංඛ්‍යාවක් වේගයෙන් ලැබේ. .Pyc ලිපිගොනු භාවිතා කරන ආකෘතිය බයිට් 4 ක් භාවිතා කරමින් පූර්ණ සංඛ්‍යා නිරූපණයේ දිග ගබඩා කරයි, නමුත් යථාර්ථයේ දී සීමාව වඩා සමාන බව පෙනේ 2**31, එබැවින් එක් විශාල සංඛ්‍යාවක් ජනනය කිරීම සඳහා on ාතයක් භාවිතා කිරීමෙන් සීමාව 2GB ජනනය කරන බව පෙනේ. පයික් ගොනුව බයිට් 8 ක ප්‍රභවයකින්. ( 19**8ටිකක් ලැජ්ජයි 8*2**31, 1<<19**8ද්විභාෂා නිරූපණය 2GB ට අඩුයි; අටකින් ගුණ කිරීම අපට අවශ්‍ය වන්නේ බයිට් මිස බිටු නොවේ)

කෙසේ වෙතත්, ටුපල් ද වෙනස් කළ නොහැකි අතර ටුපල් ගුණ කිරීම ද නිරන්තරයෙන් නැවී ඇත, එබැවින් අපට 2GB බ්ලොබ් එක අපට අවශ්‍ය වාර ගණනක් අනුපිටපත් කළ හැකිය, අවම වශයෙන් 2**31වාර ගණනක් දක්වා. මෙම 4**732TB ලබා ගැනීමට එය මම ගුටි පෙර 16TB පිළිතුර සොයා ගත හැකි පළමු නිපුනයා පමණින් තෝරා ගන්නා ලදී.

අවාසනාවකට මෙන්, මගේ පරිගණකයේ ඇති මතකය සමඟ, මට මෙය පරීක්ෂා කළ හැක්කේ 2 ක ගුණකයක් දක්වා පමණි, එනම්. (1<<19**8,)*2, එය 8.5GB ගොනුවක් ජනනය කළ අතර, එය යථාර්ථවාදී බව පෙන්නුම් කරයි (එනම් ගොනු විශාලත්වය 2 ** 32 = 4GB ට සීමා නොවේ).

එසේම, පරීක්‍ෂා කිරීමේදී මා ලබාගත් ගොනු ප්‍රමාණය 4GB-ish වෙනුවට 8.5GB වූයේ මන්දැයි මා දන්නේ නැත, සහ ගොනුව විශාල බැවින් මේ මොහොතේ එය වටා එබී බැලීමට මට දැනෙන්නේ නැත.

4GB ට වඩා වැඩි ප්‍රතිදානයක් ලබා ගත හොත් (සමහර විට යමෙකු සම්පූර්ණ පෙර සැකසුම් යන්ත්‍රයක් සොයා ගන්නේ නම්), තරගය අවම වශයෙන් එම ප්‍රමාණයෙන් යුත් ගොනුවක් නිපදවන කුඩාම ප්‍රභවය සඳහා වනු ඇත (එය විශාල වන ඉදිරිපත් කිරීම් පරීක්ෂා කිරීම ප්‍රායෝගික නොවේ) .

"සැකිල්ල හස්කල්" මඟින් හස්කල් කේතය සම්පාදක වේලාවේදී ජනනය කිරීමට ඉඩ දෙයි, එම නිසා එය පෙර සැකසුම් ක්‍රියාවලියකි.

අත්තනෝමතික සංඛ්‍යාත්මක ප්‍රකාශනයකින් පරාමිතිගත කර ඇති මගේ උත්සාහය මෙන්න FOO:

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

මැජික් යනු "භේදය" තුළ ඇති කේතයයි $(...). හැස්කෙල් ඒඑස්ටී උත්පාදනය කිරීම සඳහා මෙය සම්පාදනය කරන වේලාවේදී ක්‍රියාත්මක කරනු ලැබේ.

මෙම අවස්ථාවෙහිදී, අපි වචනානුසාරයෙන් නිරූපණය කරන සරල AST එකක් සාදන්නෙමු , ලැයිස්තුවක් සෑදීම සඳහා 0අපි මේ FOOවතාවේ නැවත නැවත කරන්නෙමු , ඉන්පසු අපි මොඩියුලයෙන් භාවිතා ListEකරමින් මෙම Language.Haskell.THAST ලැයිස්තුව එක් විශාල AST බවට හරවා වචනාර්ථයෙන් නියෝජනය කරමු [0, 0, 0, 0, 0, ...].

එහි ප්‍රති ing ලයක් ලෙස ඇති වැඩසටහන පුනරාවර්තනය main = print [0, 0, 0, ...]සමඟ සමාන FOOවේ 0.

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 ක් සහ -XTemplateHaskellතර්කය සඳහා 17 ක් ) වන අතර දිග FOO.

අපට සම්පාදක තර්කය වළක්වාගෙන සම්පාදනය කළ හැකිය ghc, නමුත් අපි {-# LANGUAGE TemplateHaskell#-}මුලදී තැබිය යුතුය , එය කේතය බයිට් 97 ක් දක්වා වැඩි කරයි.

මෙන්න නිදර්ශන ප්‍රකාශන කිහිපයක් FOO, සහ එහි ප්‍රති ing ලයක් ලෙස ද්විමය ප්‍රමාණය:

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, නමුත් එමඟින් සම්පාදකයා නතර වීම වළක්වයි;)

සී ++, 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 ප්‍රතිදාන ගොනුවක් සඳහා කළමනාකරණය කළෙමි . ඔබේ වේදිකාවේ සීමාවන්ට පහර දීම සඳහා ඔබට නියතයන් සුසර කළ හැකිය - මඟ පෙන්වීම සඳහා සම්බන්ධිත විකිපීඩියා ලිපිය බලන්න.

-gGCC වෙත ධජය අවශ්‍ය වේ (මන්දයත් එය ඕනෑම ඉඩක් පරිභෝජනය කරන දෝශ නිරාකරණ සංකේත වන නිසා) සහ පෙරනිමි අච්චු ගැඹුරට වඩා විශාලය. මගේ සම්පාදක රේඛාව අවසන් විය

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

ඒඑස්එම්, බයිට් 61 (බයිට් 29 ප්‍රභවය, කොඩි සඳහා බයිට් 32), ක්‍රියාත්මක කළ හැකි බයිට් 4,294,975,320

.globl main
main:
.zero 1<<32

සමඟ සම්පාදනය කරන්න gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold

මෙන්න 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 ප්‍රතිදානය

මගේ සැබෑ ලෝකයේ පෙර සැකසුම්කරුගේ ආනුභාවයෙන් මෙහි අසමත් වේ.

#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(අපේක්ෂිත පරිදි) ප්‍රතිදානය දළ වශයෙන් දස ගුණයකින් විශාල වන බවයි. නමුත් මෙම උදාහරණය සම්පාදනය කිරීමට පැයකට වඩා ගත වූ බැවින් මම කිසි විටෙකත් "ජී" වෙත නොගියෙමි.

ජාවා, 450 + 22 = බයිට් 472 ප්‍රභවය, GB 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ප්‍රමාණයෙන් a ට සම්පාදනය කරයි 1,073,141,162.

විශාල පන්ති ගොනුවක් සෑදීමට උත්සාහ කිරීමේදී සීමාවන් කිහිපයක් තිබේ:

• 64k ට වඩා දිගු හඳුනාගැනීම් නිර්මාණය කිරීමෙන් ප්‍රති results ල : error: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant pool.
• 64k විචල්‍යයන් / ශ්‍රිත වලට වඩා වැඩි ප්‍රමාණයක් නිර්මාණය කිරීමෙන් ප්‍රති results ල ලැබේ: error: too many constants
• ශ්‍රිතයක කේත ප්‍රමාණය සඳහා 64k පමණ සීමාවක් ද ඇත.
• ජාවා සම්පාදකයා තුළ .classගොනුව සඳහා 1GB පමණ සාමාන්‍ය සීමාවක් (දෝෂ?) ඇති බව පෙනේ . මම වැඩි නම් 16380කිරීමට 16390කවදාවත් ප්රතිලාභ සම්පාදකවරයා ඉහත කේතයේ.
• .javaගොනුව සඳහා 1GB පමණ සීමාවක් ද ඇත . ඉහත කේතයට වැඩි 16380වීමෙන් 16400ප්‍රති results ල ලැබේ: An exception has occurred in the compiler (1.8.0_66). Please file a bug ...ඉන්පසු a java.lang.IllegalArgumentException.

සී, බයිට් 26 ප්‍රභවය, බයිට් 2,139,103,367, වලංගු වැඩසටහන

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

භාවිතයෙන් සම්පාදනය කරන ලද්දේ: gcc cbomb.c -o cbomb(gcc අනුවාදය 4.6.3, උබුන්ටු 12.04, තත්පර 77 තත්පර)

කිසිදු විධාන රේඛා විකල්පයක් භාවිතා නොකර වලංගු වැඩසටහනක් සෑදිය හැකි දැයි බැලීමට මම සිතුවෙමි. මෙම පිළිතුරෙන් මට අදහස ලැබුණි: https://codegolf.stackexchange.com/a/69193/44946 ඩිජිටල් කම්පනය. මෙය සම්පාදනය කරන්නේ මන්දැයි එහි ඇති අදහස් බලන්න.

එය ක්‍රියාත්මක වන ආකාරය: කොටසේ constපිටු වලින් ලිවීමේ ධජය ඉවත් කරයි, එබැවින් ප්‍රධාන වශයෙන් ක්‍රියාත්මක කළ හැකිය. මෙම 195ආපසු සඳහා ඉන්ටෙල් යාන්ත්රික කේත ඇත. ඉන්ටෙල් ගෘහ නිර්මාණ ශිල්පය එතරම් එන්ඩියන් නොවන බැවින් මෙය පළමු බයිටය වේ. ආරම්භක කේතය eax ලේඛනයේ තබා ඇති ඕනෑම දෙයක් සමඟ වැඩසටහන පිටව යනු ඇත.

එය ගිග් 2 ක් පමණ වන බැවින් සම්බන්ධකය ඕෆ්සෙට් සඳහා බිට් 32 අත්සන් කළ අගයන් භාවිතා කරයි. එය ගිග් 2 ට වඩා මෙගා 8 ක් කුඩා වන බැවින් සම්පාදකයාට / සම්බන්ධකයට වැඩ කිරීමට යම් ඉඩක් අවශ්‍ය වන අතර සම්බන්ධක දෝෂ නොමැතිව මට එය ලබා ගත හැකි විශාලතම දේ මෙයයි - ymmv.

බූ , බයිට් 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එය තැනීමට සම්පාදකයාට ආරාධනා කරන්න .

කොට්ලින් , බයිට් 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ඔබ පුනරාවර්තනය වැඩි කරන්නේ නම් සම්පාදකයා දෝෂයක් සමඟ බිඳ වැටේ .

සී ++, බයිට් 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-cygwinබයිට් 2567355421 (2.4GiB) වේ.

ආරම්භක අගය 80 ට වඩා වැඩි කිරීමෙන් සිග්වින් ජීසීසී එකලස් කරන්නා (බොහෝ කොටස්) බිඳ දමයි.

එසේම, 99999ප්රතිස්ථාපනය කළ හැක 9<<19හෝ මූල කේතය වෙනස් නොකර වැඩි ප්රමාණය සමාන ... නමුත් මම දැනටමත් මම වඩා මම තවත් තැටියේ ඉඩ භාවිතා කිරීමට අවශ්ය හිතන්නේ නැහැ;)

පරිමාණය - බයිට් 70 ප්‍රභවය, 22980842 බයිට් ප්‍රති result ලය (බඳුනට පසු)

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

මෙය විශේෂිත පන්ති ලිපිගොනු 9 ^{5 ක්} (59,000 ක් පමණ) නිපදවන අතර එය MB 23 ක් පමණ භාජනයකට ඇසුරුම් කරයි. ඔබට බොහෝ ගොනු සහ ප්‍රමාණවත් මතකය හැසිරවිය හැකි ගොනු පද්ධතියක් තිබේ නම් ඔබට ප්‍රතිපත්තිමය වශයෙන් ඉදිරියට යා හැකිය.

(භාජන විධානය ඇතුළත් කළ යුතු නම් එය බයිට් 82 කි.)

සී, සඳහා 284 බයිට් + 2 -cදී 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};

බූ, ඔබට මෙයින් බලාපොරොත්තු විය හැකි ප්‍රමාණයට වඩා වැඩිය

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

පයිතන් 3:

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

ටෙට්රේෂන් බෝම්බය