Giriş

Muhtemelen zip bombaları , XML bombaları vb. İle aşinasınızdır . Basitçe söylemek gerekirse, bunlar naif yazılım tarafından yorumlandığında çok büyük çıktılar üreten (nispeten) küçük dosyalardır. Buradaki zorluk, bir derleyiciyi aynı şekilde kötüye kullanmaktır.

Meydan okuma

512 bayt veya daha az yer kaplayan ve en fazla yer kaplayan bir dosyada derlenen bazı kaynak kodlarını yazın. En büyük çıktı dosyası kazanır!

kurallar

Tamam, birkaç önemli açıklama, tanım ve kısıtlama var;

• Derlemenin çıktısı bir ELF dosyası, bir Windows Taşınabilir Yürütülebilir (.exe) veya JVM veya .Net’in CLR’si için sanal bytecode olmalıdır (istendiğinde diğer sanal bytecode türlerinin de tamam olması olasıdır). Güncelleme: Python'un .pyc / .pyo çıktısı da sayılır .
• Seçtiğiniz dil doğrudan bu biçimlerden birinde derlenemezse, aktarımın ardından derlemeye de izin verilir ( Güncelleme: aynı dili hiçbir zaman bir defadan fazla kullanmayacağınız sürece), birden çok kez kopyalayabilirsiniz .
• Kaynak kodunuz birden fazla dosyadan ve hatta kaynak dosyalardan oluşabilir, ancak tüm bu dosyaların toplam boyutu 512 baytı geçmemelidir.
• Kaynak dosyalarınızdan ve seçtiğiniz dilinizin standart kitaplığından başka bir girdi kullanamazsınız. Statik bağlama standart kütüphaneler desteklendiğinde sorun yok. Özellikle, üçüncü taraf kütüphaneleri veya işletim sistemi kütüphaneleri yok.
• Derlemenizi bir komut veya bir komut dizisi kullanarak çağırmanız mümkün olmalıdır. Derleme sırasında belirli bayraklara ihtiyacınız varsa, bunlar bayt sınırınıza göre sayılır (örneğin, derleme satırınız ise gcc bomb.c -o bomb -O3 -lm, -O3 -lmkısım (7 bayt) sayılır (başlangıçtaki boşluğun sayılmadığına dikkat edin).
• Önişlemcilere sadece kendi diliniz için standart bir derleme seçeneği olması durumunda izin verilir .
• Çevre size kalmış, ancak bunu doğrulanabilir kılmak için lütfen yeni (yani mevcut) derleyici sürümlerine ve işletim sistemlerine bağlı kalın (ve hangisini kullandığınızı açıkça belirtin).
• Hatasız derleme yapmalıdır (uyarılar uygun) ve derleyicinin çökmesi bir şey sayılmaz.
• Programınızın gerçekte yaptığı şey alakasız, ancak zararlı bir şey olamaz. Başlayabilmesi bile gerekmez.

örnek 1

C programı

main(){return 1;}

İle Derleyen Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11 (64-bit) üzerinde:

clang bomb.c -o bomb -pg

9228 baytlık bir dosya üretir. Toplam kaynak büyüklüğü 17 + 3'tür (bunun için -pg) = 20 bayttır, kolayca boyut sınırı içindedir.

Örnek 2

Brainfuck programı:

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

Awib ile c ile transpillendi :

./awib < bomb.bf > bomb.c

Sonra Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11 (64 bit) ile derlendi :

clang bomb.c

8464 baytlık bir dosya üretir. Buradaki toplam giriş 143 bayttır (çünkü @lang_cawib için varsayılan değerdir, kaynak dosyaya eklenmesi gerekmez ve her iki komutta da özel bayrak yoktur).

Ayrıca, bu durumda, geçici bomb.c dosyasının 802 bayt olduğunu, ancak bunun kaynak boyutuna veya çıktı boyutuna sayılmadığını unutmayın.

Son not

4GB'tan daha fazla bir çıktı elde edilirse (belki birileri bir turing tam işlemciyi bulursa), rekabet en azından bu boyutta bir dosya üreten en küçük kaynak için olacaktır ( çok büyük olan gönderimleri test etmek pratik değildir ) .

C, (14 + 15) = 29 bayt kaynak, 17,179,875,837 (16 GB) bayt çalıştırılabilir

@Viraptor'a 6 byte kapalı teşekkür ederiz.

2 byte kapalı @hvd ve çalıştırılabilir boyut x4 sayesinde.

Bu, mainişlevi büyük bir dizi olarak tanımlar ve ilk öğesini başlatır. Bu, GCC'nin tüm diziyi sonuçtaki yürütülebilir dosyada saklamasına neden olur.

Bu dizi 2 GB'den büyük olduğundan, -mcmodel=mediumbayrağı GCC'ye vermemiz gerekir . Ekstra 15 bayt, kurallara göre puanlamaya dahil edildi.

main[-1u]={1};

Bu kodun çalıştırırken güzel bir şey yapmasını beklemeyin.

İle derleyin:

gcc -mcmodel=medium cbomb.c -o cbomb

@ Hvd'nin önerisini denemek için biraz zaman harcadım - ve onu işlemek için yeterli meyve suyuna sahip bir makine bulmam biraz zaman aldı. Sonunda, 10 GB RAM, 12 GB takas ve / tmp ile büyük bir yerel bölüme ayarlanmış eski bir üretim dışı RedHat 5.6 VM'yi buldum. GCC versiyonu 4.1.2'dir. Toplam derleme süresi yaklaşık 27 dakika.

CPU ve RAM yükü nedeniyle, bu derlemeyi uzaktan üretimle ilgili herhangi bir makinede yapmamanı tavsiye ederim .

C #, derlemek için yaklaşık 1 dakika, 28 MB çıkış ikili:

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

Daha fazla Y eklemek, katlanarak boyutu artıracak.

@Odomontois'in isteğine göre Pharap tarafından yapılan açıklama:

Bu cevap, kalıtımı kötüye kullanıyor ve özyineleme oluşturmak için parametreleri yazın. Neler olduğunu anlamak için, öncelikle sorunu basitleştirmek daha kolaydır. İç sınıfı olan class X<A> { class Y : X<Y> { Y y; } }jenerik sınıfı üreten düşünün . miras , dolayısıyla o zaman olan bir iç sınıfa sahiptir . Bu daha sonra da bir iç sınıfa sahip ve bu iç sınıf bir iç sınıfa sahip bu kapsama çözünürlüğünü (kullanabilecekleri anlamına gelir vs. ) sonsuza ve bunu her kullandığınızda, derleyici miras ve tip parametreleme başka seviyesini anlamak zorundadır .X<A>YX<A>.YX<Y>X<A>.YYX<A>.Y.YYYY.

İlave tip parametreleri eklenerek, derleyicinin her aşamada yapması gereken işler daha da arttırılır.

Aşağıdaki durumlarda düşünün:
In class X<A> { class Y : X<Y> { Y y;} }tipi param Abir türü vardır X<A>.Y.
Gelen class X<A> { class Y : X<Y> { Y.Y y;} }tipi param Abir türü vardır X<X<A>.Y>.Y.
Gelen class X<A> { class Y : X<Y> { Y.Y.Y y;} }tipi param Abir türü vardır X<X<X<A>.Y>.Y>.Y.
Gelen class X<A,B> { class Y : X<Y,Y> { Y y;} }türü param Aolduğunu X<A,B>.Yve Bbir X<A,B>.Y.
Gelen class X<A> { class Y : X<Y> { Y.Y y;} }türü param Aolduğunu X<X<A,B>.Y, X<A,B>.Y>.Yve Bbir X<X<A,B>.Y, X<A,B>.Y>.Y.
Gelen class X<A> { class Y : X<Y> { Y.Y.Y y;} }türü param Aolduğunu X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Yve Bbir X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y.

Bu desen sonra, tek hayal edebilirsiniz ¹ derleyici neyi anlamak için yapmak zorunda kalacak işe Aetmek Eiçindedir Y.Y.Y.Y.Y.Y.Y.Y.Ytanımında 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;}}.

¹ Bunu çözebilirdiniz, ama çok fazla sabra ihtiyacınız olacak ve istihbarat burada size yardımcı olmayacak.

Python 3, 13 bayt kaynak, 9,057,900,463 bayt (8,5 GIB) .pyc dosyası

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

Düzenleme : Kuralların 4GiB ötesindeki çıktı boyutunun önemli olmadığını söylediğini fark ettikten sonra yukarıdaki sürüme değiştirildi ve bunun kodunun çok az kısa olduğunu; Önceki kod - ve daha da önemlisi açıklama - aşağıda bulunabilir.

Python 3, 16 byte kaynak,> 32TB .pyc dosyası (eğer yeterli bellek, disk alanı ve sabrınız varsa)

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

Açıklama: Python 3 sabit katlama yapar ve hızlı bir şekilde üstel ile büyük sayılar elde edersiniz. .Pyc dosyaları tarafından kullanılan format, 4 byte kullanarak tamsayı gösteriminin uzunluğunu saklar, ancak gerçekte sınır daha fazla gibi görünmektedir 2**31, bu nedenle büyük bir sayı üretmek için sadece üstel kullanımı sınır 2GB gibi görünüyor. 8 bayt kaynağından pyc dosyası. ( 19**8biraz utangaçtır 8*2**31, bu yüzden 1<<19**82GB'nin hemen altında bir ikili gösterime sahiptir; sekize çarpma, bitleri değil bayt istediğimiz içindir)

Bununla birlikte, tüller de değişmezdir ve bir tuple de sabit katlanırsa çoğaltılır, bu nedenle bu 2GB'lık blob'u en az 2**31zamana kadar istediğimiz kadar çoğaltabiliriz . 4**7Ben önceki 16 TB cevabını yendi bulabildiğim ilk üs oldu sırf seçildi 32TB ulaşmak için.

Ne yazık ki, kendi bilgisayarımın hafızasında, bunu sadece 2 çarpanına kadar test edebildim, yani. (1<<19**8,)*28,5GB'lık bir dosya oluşturdu; umarım cevabın gerçekçi olduğunu gösterir (yani dosya boyutu 2 ** 32 = 4GB ile sınırlı değildir).

Ayrıca, test ederken aldığım dosya boyutunun neden beklediğim 4 GB-ish yerine 8,5 GB olduğu hakkında hiçbir fikrim yok ve dosya şu anda etrafta dolaşmak istemeyeceğim kadar büyük.

4GB'tan daha fazla bir çıktı elde edilirse (belki birileri bir turing tam işlemciyi bulursa), rekabet en azından bu boyutta bir dosya üreten en küçük kaynak için olacaktır (çok büyük olan gönderimleri test etmek pratik değildir) .

"Template Haskell", Haskell kodunun, Haskell kullanılarak derleme zamanında oluşturulmasına izin verir ve bu nedenle turing tam bir ön işlemcisidir.

İşte benim deneme, rastgele bir sayısal ifade ile parametreleştirildi FOO:

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

Sihir "ekleme" içindeki koddur $(...). Bu, derleme zamanında, programın AST'sine ek yerine yerinde aşılanmış bir Haskell AST üretmek için gerçekleştirilecektir.

Bu durumda, değişmezi temsil eden basit bir AST yaparız, bir liste yapmak için 0bu FOOsüreleri çoğaltırız , daha sonra bu AST listesini bu değişmezi temsil eden büyük bir AST'ye dönüştürmek ListEiçin Language.Haskell.THmodülden kullanırız [0, 0, 0, 0, 0, ...].

Ortaya çıkan program tekrarları main = print [0, 0, 0, ...]ile eşdeğerdir .FOO0

ELF'e derlemek için:

$ 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

Bu 83 byte ağırlığında (Haskell kodu için 66 ve -XTemplateHaskellargüman için 17 ) artı uzunluğu FOO.

Derleyici argümanından kaçınabiliriz ve sadece derleme ghcyaparız, fakat {-# LANGUAGE TemplateHaskell#-}en baştan koymalıyız ki bu kod 97 bayta kadar çıkar.

İşte FOOsonuçta ortaya çıkan ikili kodun birkaç örnek ifadesi ve boyutu:

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

Ben ile derleme RAM bitti (2^20).

Ayrıca repeatbunun yerine sonsuz bir liste yapabiliriz replicate FOO, ancak derleyicinin durmasını engeller;)

C ++, 250 + 26 = 276 bayt

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;

Bu, şablonlarda uygulanan Ackermann işlevidir . Birlikte derlemek mümkün değilim h=a<4,2>::n;benim küçük (6GB) makinede ama başardınız h=a<3,14>bir 26M çıkış dosyası için. Sabitleri platformunuzun sınırlarını aşacak şekilde ayarlayabilirsiniz - rehberlik için bağlantılı Wikipedia makalesine bakın.

GCC'ye -gbayrak gerektirir (çünkü gerçekte herhangi bir alanı tüketen tüm hata ayıklama sembolleridir) ve varsayılandan daha büyük bir şablon derinliğidir. Derleme satırım sona erdi

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

Platform bilgisi

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

ASM, 61 bayt (29 bayt kaynak, bayraklar için 32 bayt), 4.294.975.320 bayt çalıştırılabilir

.globl main
main:
.zero 1<<32

İle derleyin gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold

İşte 2005’ten gelen C cevabım. Eğer 16TB RAM’iniz olsaydı 16TB’lık bir ikili veri üretiyordu.

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(){}

Düz eski C önişlemcisi: 214 bayt giriş, 5 MB çıkış

Gerçek dünya önişlemcimden esinlenerek burada başarısız .

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

Deneyler, her #defines seviyesinin (beklendiği gibi) çıktının yaklaşık on kat daha büyük olacağını göstermektedir . Ancak bu örneğin derlenmesi bir saatten fazla sürdüğü için, asla "G" ye geçmedim.

Java, 450 + 22 = 472 bayt kaynak, ~ 1GB sınıf dosyası

B.java (golf versiyonu, derleme sırasında uyarı)

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 (ungolfed versiyonu)

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

Derleme

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

açıklama

Bu bomba Ek Açıklama İşlemcileri kullanır. 2 derleme geçidi gerekiyor. İlk geçiş işlemci sınıfını oluşturur B. İkinci geçişte işlemci yeni bir kaynak dosyası oluşturur C.javave onu bir bayt C.classbüyüklüğünde derler 1,073,141,162.

Büyük bir sınıf dosyası oluşturmaya çalışırken bazı sınırlamalar vardır:

• Artık yaklaşık 64k sonuçları daha tanımlayıcıları Oluşturma: error: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant pool.
• Yaklaşık 64k'dan fazla değişken / işlev oluşturmak aşağıdakilerle sonuçlanır: error: too many constants
• Bir işlevin kod boyutu için yaklaşık 64k'lık bir sınır vardır.
• Java derleyicisinde, .classdosya için yaklaşık 1 GB'lık bir genel sınır (hata?) Var . Ben artırırsanız 16380için 16390yukarıdaki kodda derleyici asla geri gelmez.
• Ayrıca .javadosya için yaklaşık 1GB'lık bir sınır vardır . Artan 16380için 16400yukarıdaki kod sonuçlarında: An exception has occurred in the compiler (1.8.0_66). Please file a bug ...Bir izledi java.lang.IllegalArgumentException.

C, 26 bayt kaynak, 2,139,103,367 bayt çıktı, geçerli program

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

Kullanılarak derlendi: gcc cbomb.c -o cbomb(gcc sürüm 4.6.3, Ubuntu 12.04, ~ 77 saniye)

Herhangi bir komut satırı seçeneği kullanmadan geçerli bir programın ne kadar büyük olabileceğini görmeyi deneyebileceğimi düşündüm. Bu cevaptan fikrimi aldım: Digital Trauma tarafından https://codegolf.stackexchange.com/a/69193/44946 . Bunun neden derlendiğine dair yorumları görün.

Nasıl çalışır: constYazma bayrağını segmentteki sayfalardan kaldırır, böylece ana çalıştırılabilir. 195Bir dönüş için Intel makine kodudur. Ve Intel mimarisi küçük endian olduğundan, bu ilk bayt. Program, eax siciline girilen başlama kodu ne olursa olsun, muhtemelen 0 olacaktır.

Sadece 2 gig çünkü linker ofsetler için 32 bit imzalı değerler kullanıyor. Derleyici / linker çalışmak için biraz alana ihtiyaç duyduğundan, 2 gig'den 8 meg daha küçüktür ve bu linker hataları olmadan elde edebileceğim en büyüğüdür - ymmv.

Boo , 71 bayt. Derleme süresi: 9 dakika. 134,222,236 bayt çalıştırılabilir

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

RDerleyicinin, artış bildirimini isteğe bağlı olarak çarpma sayısına neden olması için bir makro kullanır (Tekrarla için). Özel bir derleyici bayrağı gerekmez; basitçe dosyayı kaydedin bomb.boove derleyiciyi derlemek için booc bomb.booonu çağırın .

Kotlin , 90 bayt kaynak, 177416 bayt (173 KB) JVM ikiliyi derledi

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

Teknik olarak, ifadeyi daha da iç içe geçirerek daha da uzun yapabilirsiniz. Ancak, StackOverflowözyinelemeyi artırırsanız, derleyici bir hatayla kilitleniyor .

C ++, 214 bayt (özel derleme seçeneği gerekmez)

#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();

Oldukça basit, iki boyutlu bir şablon özyinelemesi (özyineleme derinliği, yayılan toplam şablonların karekökü olarak gider, bu nedenle platform sınırlarını aşmaz), her birinde az miktarda statik veri bulunur.

g++ 4.9.3 x86_64-pc-cygwin2567355421 bayt (2.4GiB) ile oluşturulan nesne dosyası .

İlk değeri 80’in üzerine çıkarmak cygwin gcc assembler’ı keser (çok fazla segment).

Ayrıca, kaynak kodunu değiştirmeden artan boyut için 99999değiştirilebilir 9<<19veya benzer olabilir ... ancak daha önce olduğundan daha fazla disk alanı kullanmam gerektiğini düşünmüyorum;)

Scala - 70 byte kaynak, 22980842 byte sonuç (kavanozdan sonra)

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

Bu 9 üretir ⁵ yaklaşık 23 MB'lık bir kavanoza paketi (yaklaşık 59.000) özel sınıf dosyaları. Prensipte bu kadar dosyayı ve yeterli belleği kaldırabilecek bir dosya sisteminiz varsa devam edebilirsiniz.

(Jar komutu eklendiyse, bu 82 bayttır.)

Cı, 284 bayt için + 2 -cin gcc bomb.c -o bomb.o -c; çıkış: 2 147 484 052 bayt

#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, bundan bekleyebileceğinden çok daha fazla

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 bombası