コンパイラボムをビルドする


372

前書き

zip爆弾XML爆弾などはおなじみでしょう。簡単に言えば、それらは(比較的)ナイーブソフトウェアによって解釈されたときに膨大な出力を生成する小さなファイルです。ここでの課題は、同じ方法でコンパイラを悪用することです。

チャレンジ

512バイト以下を占有し、可能な限りスペースを占有するファイルにコンパイルするソースコードを記述します。最大の出力ファイルが勝ちます!

ルール

わかりましたので、いくつかの重要な説明、定義、制限があります。

  • コンパイルの出力は、ELFファイル、Windows Portable Executable(.exe)、またはJVMまたは.NetのCLRの仮想バイトコードである必要があります(要求された場合、他のタイプの仮想バイトコードでも大丈夫です)。更新:Pythonの.pyc / .pyo出力もカウントされます。
  • 選択した言語をこれらの形式のいずれかに直接コンパイルできない場合は、コンパイルとそれに続くコンパイルも許可されます(更新:同じ言語を複数回使用しない限り、複数回トランスコンパイルできます)。
  • ソースコードは複数のファイル、さらにはリソースファイルで構成できますが、これらすべてのファイルの合計サイズは512バイトを超えてはなりません。
  • ソースファイルと選択言語の標準ライブラリ以外の入力は使用できません。静的リンク標準ライブラリは、サポートされていれば問題ありません。具体的には、サードパーティのライブラリやOSライブラリはありません。
  • コマンドまたは一連のコマンドを使用してコンパイルを呼び出すことが可能でなければなりません。コンパイル時に特定のフラグが必要な場合、これらはバイト制限にカウントされます(たとえば、コンパイル行がのgcc bomb.c -o bomb -O3 -lm場合、-O3 -lmパート(7バイト)がカウントされます(最初の先行スペースはカウントされないことに注意してください)。
  • プリプロセッサは、言語の標準コンパイルオプションである場合のみ許可されます。
  • 環境はあなた次第ですが、これを検証可能にするために、最新の(つまり、利用可能な)コンパイラーのバージョンとオペレーティングシステムに固執してください(そして明らかに使用しているものを指定してください)。
  • エラーなしでコンパイルする必要があり(警告は問題ありません)、コンパイラのクラッシュは何もカウントしません。
  • あなたのプログラムが実際に行うことは無関係ですが、悪意のあることはできません。開始する必要さえありません。

例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プログラム:

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

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以上の出力が達成された場合(おそらく誰かが完全なプリプロセッサを探している場合)、少なくともそのサイズのファイルを生成する最小のソースを競います(大きすぎる提出物をテストすることは実際的ではありませ) 。


トランスパイラーを使用する場合、出力ソースコードは入力ソースコードと同様に512バイト未満である必要がありますか?
-trichoplax

3
繰り返しの翻訳は許可されていますか?
orlp

3
@ LegionMammal978はい、指定したファイルタイプのいずれかを生成する必要があります。しかし、インタプリタ言語よりも仮想マシンのようなものを見つけたと思う場合は、具体的に質問してください。それを許可することもできます(少し主観的ですそれを開くの))
デイブ

3
@trichoplax私はそれを知りませんでしたが、いくつかの読書からはそうのように見えます。Pythonバイトコードへのコンパイルは絶対に重要です。したがって、Pythonの場合、出力サイズはすべてのpyc / pyoファイルの合計サイズになります。これらのコメントベースの更新で質問をすぐに更新します。
デイブ

2
@MartinRosenau-WGroleauはすでに同様の質問をしました。チャレンジの開始時にすでに存在していたものを使用できることが、チャレンジのコーディングの標準です。
デイブ

回答:


441

C、(14 + 15)= 29バイトのソース、17,179,875,837(16 GB)バイトの実行可能ファイル

6バイトオフの@viraptorに感謝します。

@hvdに2バイトのオフと実行可能サイズx4のおかげです。

これは、main関数を大きな配列として定義し、その最初の要素を初期化します。これにより、GCCは配列全体を結果の実行可能ファイルに保存します。

この配列は2GBより大きいため、-mcmodel=mediumGCCにフラグを提供する必要があります。ルールに従って、余分な15バイトがスコアに含まれます。

main[-1u]={1};

実行時にこのコードが何か良いことをすると期待しないでください。

コンパイル:

gcc -mcmodel=medium cbomb.c -o cbomb

@hvdの提案をテストするのに時間がかかり、それを処理するのに十分なジュースのあるマシンを見つけるのに時間がかかりました。最終的に、10GB RAM、12GBスワップ、および/ tmpが大きなローカルパーティションに設定された古い非実稼働RedHat 5.6 VMを見つけました。GCCバージョンは4.1.2です。合計コンパイル時間は約27分です。

CPUとRAMの負荷のため、リモートで生産関連のマシンでこのコンパイルを行わないことをお勧めします。



13
私はここで自分の解決策と戦っていますが、...あなたは必要ありませんa。あなただけを使用することができますmain[1<<30]={1};
-viraptor

38
ああ。これは悪です。Xはそのコードをコンパイルしようとして数分間フリーズしました。sshに戻ってgccプロセスを強制終了して別のコンピューターを探し始め、それがついに復活しました。ところで あなたがより大きな値にしたい場合は1<<30、その後7<<28のオプションである可能性があります。
カスペルド

33
> 4GB?それは急速にエスカレートした
ウェインワーナー

18
:これはコンパイルする理由の場合、誰が疑問に思っているstackoverflow.com/questions/34764796/...
TC

206

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を追加すると、サイズが指数関数的に増加します。

@OdomontoisのリクエストによるPharapの説明:

この答えは、再帰を作成するために継承と型パラメーターを乱用しています。何が起こっているのかを理解するには、最初に問題を単純化するほうが簡単です。考えてみましょう。これは、内部クラスを持つ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;} }typeのparam Aの型がありますX<A>.Y
ではclass X<A> { class Y : X<Y> { Y.Y y;} }typeのparam Aの型がありますX<X<A>.Y>.Y
ではclass X<A> { class Y : X<Y> { Y.Y.Y y;} }typeの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>.YBされます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>.YBされます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>.YBされますX<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y

このパターンに続き、1しか想像できる1コンパイラが何を推測するために行う必要があります作業AEている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;}}

1あなたはそれを理解することができましたが、あなたは多くの忍耐を必要とするでしょう、そしてインテリセンスはここであなたを助けません。


14
これは私が期待していたような狂気のようなものです!私はモノを再インストールするためにオフだように...見える
デイブ

31
そのような悪名高い効果について説明してもらえますか?
オドモントワ

16
+1は、大きな配列を初期化するだけではありません。
スティグヘマー

6
Try Roslynとわずか3 Yを使用した例を次に示します。
コビ

10
この質問を見て、すぐにあなたのことを考えました。いいね!
エリックリッパー

154

Python 3、13バイトのソース、9,057,900,463バイト(8.5GiB).pycファイル

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

編集:4GiBを超える出力サイズは重要ではないとルールに気づいた後、コードを上記のバージョンに変更しました。前のコード、さらに重要な説明は以下にあります。


Python 3、16バイトソース、32 TBを超える.pycファイル(十分なメモリ、ディスクスペース、忍耐力がある場合)

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

説明:Python 3は定数畳み込みを行い、べき乗を使用して大きな数を高速に取得します。.pycファイルで使用される形式は、4バイトを使用して整数表現の長さを格納しますが、実際には制限はより似ているよう2**31に見えるため、指数を使用して1つの大きな数を生成すると、制限は2GBを生成するようです。 8バイトのソースからのpycファイル。(19**8は少し恥ずかしがり屋な8*2**31ので1<<19**8、2GB未満のバイナリ表現があります。8倍するのは、ビットではなくバイトが必要なためです)

ただし、タプルも不変であり、タプルの乗算も一定に折りたたまれているため、その2GBのBLOBを必要な2**31回数(少なくとも最大で)複製できます。4**732TBに到達するためには、それが私はそれが前の16TBの答えを打つ見つけることができる最初の指数だったという理由だけで選ばれました。

残念ながら、自分のコンピューターにあるメモリでは、乗数2までしかテストできませんでした。(1<<19**8,)*2、8.5GBファイルを生成しました。これが答えが現実的であることを証明することを望みます(つまり、ファイルサイズは2 ** 32 = 4GBに制限されません)。

また、テスト時に得られたファイルサイズが、予想した4GBの代わりに8.5GBだった理由がわかりません。また、ファイルが十分に大きいので、現時点ではそれをいじる気は​​ありません。


2
+1、しかし、そうしないのはなぜ(1<<19**8,)*2ですか?4GBで十分です。
アカンカ

2
@ChristianIrwan:ええ、私はそのルールを忘れていましたが、ほんの数分前にそれを実現しただけで、どのような編集を行うべきかまだわかりませんでした。:-)
アレクシトルハモ

1
いいね これは13バイトしかないため、最初に投稿された回答に対する挑戦者がいよいよ登場します!私は確認することができるだけだった1<<18私のマシン(1.5ギガバイト)の上に、私は私はそれが完全な8ギガバイト(32TBのバージョンをしようとするつもりはない!)で動作します期待していた場合、後でLinux上でそれをテストします
デイブ

1
@Dave:正確なサイズはバージョンに依存する可能性があります(ただし、1.5GBは何であれ奇妙に聞こえます)。Python 3.3.5を使用python -m py_compile asd.pyしていて、.pycファイルの生成に使用しました。
アレクシトルハモ

3
IIRC、Pythonは整数表現で32ビットワードごとに30ビットを使用します

130

4GB以上の出力が達成された場合(おそらく誰かが完全なプリプロセッサを探している場合)、少なくともそのサイズのファイルを生成する最小のソースを競います(大きすぎる提出物をテストすることは実際的ではありません) 。

「テンプレートHaskell」を使用すると、Haskellを使用してコンパイル時にHaskellコードを生成できるため、完全なプリプロセッサです。

これは、任意の数値式によってパラメーター化された私の試みFOOです。

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

魔法は、「スプライス」内のコード$(...)です。これはコンパイル時に実行され、スプライスの代わりにプログラムのASTに移植されるHaskell ASTを生成します。

この場合、リテラルを表す単純なASTを作成し、0今回複製しFOOてリストを作成ListEし、Language.Haskell.THモジュールからこのASTのリストをリテラルを表す1つの大きなASTに変換し[0, 0, 0, 0, 0, ...]ます。

得られたプログラムは、と等価である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バイト(Haskellコードの場合は66、-XTemplateHaskell引数の場合は17 )に加えて、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、これによりコンパイラが停止するのを防ぎます;)


46
プログラミングパズルとコードゴルフへようこそ。これは、特にこのサイトの新規ユーザーにとって素晴らしい回答です。助けが必要な場合(疑わしい)、お気軽にお問い合わせください。
-wizzwizz4

3
@ wizzwizz4:ええ、それは素晴らしい答えです。Haskellでは、メタプログラミングを機能させるために特別なコンパイラディレクティブが必要であることを除いて、基本的には私のものと同じです。;)
メイソンウィーラー

2
GHC 7.8.3でコンパイルすると、「スコープ内にありません: '<$>'」(コードをに設定[...].replicate (2^10)<$>[|0|]))が表示されます。Haskellの経験はありません。これをコンパイルする方法に関するヒントはありますか?
デイブ

38
haskellのテンプレートが遅すぎると、無限の実行可能ファイルをストリーミングするのに十分ではありません。
PyRulez

1
やあ、@ Daveは<$>Haskellで広く使われているが、GHC 7.10では "prelude"(デフォルトで利用可能な関数のセット)にしか移動しなかった。以前のバージョンではimport Control.Applicative;、exising importステートメントの後に追加する必要があります。GHC 7.8.4で試したところ、うまくいきました。
ウォーボ

80

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;

これは、テンプレートに実装されたアッカーマン関数です。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

私はこれが本当に好きですが、ELF / .exe / etcと言ったので、.o出力を受け入れることができるかどうかわかりません。(そして、これをコンパイルすると完全に最適化されます!)。それでも、+ 1(および確認)
デイブ

4
更新:ベン・フォークトは彼の答えで指摘するように、Linux上のGCCはないの.o出力としてELFファイルを生成し、私はうんそう、それを<3,14>バリアントを確認することができました-これが有効です。
デイブ

17
私は、C ++テンプレートから何か馬鹿げたものが出てくることを期待していました。私はいませんでしたアッカーマン関数を期待します。
マーク

フィボナッチはより小さなコードとより良い出力サイズ制御を提供しませんか?
ネスウィル

1
しかし、より大きなコードが必要です!フィボナッチは、純粋な線形コードとほぼ同じサイズを提供します(ただし、線形よりも長いコンパイル時間)。あなたは確かにサイズの静的配列を楽しんでいる可能性がありA+B、各クラスで、今私はそれについて考える...
トビースパイツ

65

ASM、61バイト(29バイトのソース、32バイトのフラグ)、4,294,975,320バイトの実行可能ファイル

.globl main
main:
.zero 1<<32

コンパイルする gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold


5
1<<30これはアセンブラなので、サイズはバイト単位です。
viraptor

2
@viraptor私のシステムには32GBのRAMがあり、キックのためにコードをビルドしようとしました。as何とかに引き渡しましたがld、これでld失敗します-mcmodel=medium助けにもならないようです。
Iwillnotexist Idonotexist

2
goldリンカの使用を強制してください: gcc -fuse-ld=gold ...コンパイル/リンク... eek!1:29(89秒)で終了し、サイズは1,073,748,000バイトです。
lornix

2
ついにこれを呼び出して、64ビットUbuntu 15.10でアセンブルしましたgcc -o g g.s -mcmodel=large -Wl,-fuse-ld=gold。最終集計:4,294,975,320 bytesのプログラム長に32バイト追加され-mcmodel=large -Wl,-fuse-ld=goldます。ヘッダーが間違っていることに注意してください。ソースは29バイトです(追加のフラグは追加されません)。
メゴ

3
割り当てをに増やす1<<33ことで、8,589,942,616バイト実行可能ファイルになりました。
メゴ

60

2005年からの私のCの答えは次のとおりです。

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

19
「16TBのRAMがあれば、16TBのバイナリを生成します(そうしません)。」-16TBのハードドライブもありません!これを実際に確認することはできませんが、それでもクールです。
デイブ

5
私は偶然これを発見し、アドレス空間を使い果たしたときにコンパイラが倒れるのを見ました。
ジョシュア

8
このエントリをゴルフしようとしないでください。ゴルフはコードサンプルの意図を打ち負かしますが、とにかくそうすることによるスコアの利点はありません。コードは2005
ジョシュア

6
@BenVoigt関係なく、他の人のコードを編集することはここでは決して受け入れられません。問題がある場合はコメントを残してください。関連メタポスト:meta.codegolf.stackexchange.com/questions/1615/...
MEGO

2
@ジョシュア:マークダウン差分を確認してください。Megoは強調表示のヒントのみを追加しました。
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

25

従来の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; }

実験では、#definesの各レベルが(予想どおり)出力を約10倍大きくすることが示されています。しかし、この例ではコンパイルに1時間以上かかったため、「G」に進むことはありませんでした。


9
これはちょっとXML爆弾のようなものです
ハサミムシ

9
具体的には、元の「Billion Laughs」の実装です。
mınxomaτ

これは非常にシンプルですが簡単です。
ヴァヒドアミリ

2
うわー、これは実際にGCC 4.9およびClangでセグメンテーション違反を引き起こします。どのコンパイラーを使用しましたか?
デイブ

1
@デイブ:奇妙な。makeを使用してコンパイルするとコンパイルされますが、makeが使用するコマンドとまったく同じコマンドを入力するとクラッシュします。そして、それは環境変数に関係していないようです。
トーマスパドロンマッカーシー

24

Java、450 + 22 = 472バイトのソース、最大1 GBのクラスファイル

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。2回目のパスで、プロセッサは新しいソースファイルを作成し、バイトサイズC.javaのにコンパイルします。C.class1,073,141,162

大きなクラスファイルを作成しようとすると、いくつかの制限があります。

  • 約64kより長い識別子を作成すると、次の結果になりますerror: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant pool
  • 約64kを超える変数/関数を作成すると、次の結果になります。 error: too many constants
  • 関数のコードサイズには約64kの制限もあります。
  • Javaコンパイラには、.classファイルに対して約1GBの一般的な制限(バグ?)があるようです。上記のコードでを増やす1638016390、コンパイラは戻りません。
  • .javaファイルには約1GBの制限もあります。増加1638016400上記のコードの結果に:An exception has occurred in the compiler (1.8.0_66). Please file a bug ...が続きますjava.lang.IllegalArgumentException

10
きちんとした; 基本的に、サイズ制限内で、カスタムプリプロセッサをネイティブにサポートするコンパイラを使用した言語で、独自のプリプロセッサを作成しました。ルールの範囲内です。最終的なクラスは0.5GBしかありませんでしたが、メソッドを確認できます。
デイブ

ジャワの他の例habrahabr.ru/post/245333 -それは、ネストされた使用try..finally(最後にブロックが正常と例外的なケースのために複製されるのコード)および初期化ブロック(初期化ブロックからのコードは、各コンストラクタに追加され)
ビクター

私は置き換えäiと数字を調整しました。これで、爆弾は、エンコードの問題なしに、どのシステムでも1GBクラスを作成するはずです。ただし、より多くのメモリが必要になりました。
Sleafar

?TypeElementを拡張しますか?!?

1
ここを参照してください@cat:angelikalanger.com/GenericsFAQ/FAQSections/...
Sleafar

22

C、26バイトのソース、2,139,103,367バイトの出力、有効なプログラム

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

使用してコンパイル:gcc cbomb.c -o cbomb(gccバージョン4.6.3、Ubuntu 12.04、約77秒)

コマンドラインオプションを使用せずに有効なプログラムを作成できる大きさを確認しようと思いました。この答えからアイデアを得ました:Digital Traumaによるhttps://codegolf.stackexchange.com/a/69193/44946 これがコンパイルされる理由についてのコメントを参照してください。

仕組み:constは、セグメント内のページから書き込みフラグを削除するため、mainを実行できます。これ195は、戻り用のIntelマシンコードです。また、Intelアーキテクチャはリトルエンディアンであるため、これが最初のバイトです。プログラムは、eaxレジスタに設定された起動コード(おそらく0)で終了します。

リンカはオフセットに32ビットの符号付き値を使用しているため、わずか2ギガです。コンパイラ/リンカーが動作するためにいくらかのスペースを必要とするため、2ギガよりも8メガバイト小さく、これはリンカエラーなしで取得できる最大のものです-ymmv。


3
興味深いことに、出力は最大圧縮= 1029:1圧縮率でgzip圧縮された2,078,451バイトです。
ザキプ

20

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(Repeat用)を使用して、コンパイラーに任意の回数、インクリメントステートメントを乗算させます。特別なコンパイラフラグは必要ありません。ファイルを名前を付けて保存しbomb.boo、コンパイラを呼び出しbooc bomb.booてビルドします。


2**e-これは何ですか?やってみて9**e
wchargin

1
@WChargin:メタプログラミングの面白いところは、どれだけ簡単にカスタマイズできるかです!
メイソンウィーラー

booのインストールに少し問題があります...インストールを管理するときに、これを確認します。
デイブ

@Daveどんな問題がありますか?
メイソンウィーラー

16

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再帰を増やすと、コンパイラはエラーでクラッシュします。


SIプレフィックスが一致しません。それは177416キロバイト= 173 MB、または177416バイト= 173 kBですか?
ベンフォークト

1
@BenVoigtそれを指摘してくれてありがとう:D
TheNumberOne

印象的な、+ 1を持っている
Jアトキン

Kotlin 1.2.20をコンパイルするには、1つの深さを削除する必要があり、最大で104kBです。元々どのバージョンを使用しましたか?
TWiStErRob

15

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

これは、かなり単純な2次元テンプレート再帰です(再帰の深さは、放出されるテンプレートの合計の平方根になるため、プラットフォームの制限を超えません)。それぞれに少量の静的データがあります。

生成されたオブジェクトファイルg++ 4.9.3 x86_64-pc-cygwinは2567355421バイト(2.4GiB)です。

初期値を80より大きくすると、cygwin gccアセンブラーが壊れます(セグメントが多すぎます)。

また、ソースコードを変更せずにサイズを大きくするために99999置き換えることができ9<<19ます...


確認済みです(実際、clangで2.56GBです)が-c、リンカーを停止するためのコンパイルフラグ(2バイト余分)が必要です。それでも、私はそれが好きなので、+ 1。
デイブ

@Dave:gcc .oファイルはELF形式ではありませんか?
ベンフォークト

わからない。それらは、生成するときにELFマジックナンバーから始まりません。後で調査します。
デイブ

@デイブ:まあ、cygwin gccはELFファイルを生成していません。(私は、コードの異なる部分から1で探していますが)、Linuxのgccがに思える
ベンフォークト

はい、Kubuntu上のGCC 5.2.1は実際にELFファイルを生成していますが、それはわずか9MBです!他のコンパイラと比較して、どのように圧縮されているのかはわかりません。GCC 4.9は2GBのELFファイルを作成するでしょう。
デイブ

6

Scala-70バイトのソース、22980842バイトの結果(jarの後)

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

これにより、9 5(約59,000)の特殊なクラスファイルが生成され、約23 MBのjarにパックされます。その数のファイルと十分なメモリを処理できるファイルシステムがあれば、原則として続行できます。

(jarコマンドを含める必要がある場合、82バイトです。)


コンパイルできませんでした:error: java.lang.OutOfMemoryError: GC overhead limit exceeded。コンパイルに必要なコマンドも文書化できますか?
P.Peter

@P.Péter-コンパイラにより多くのメモリを与える必要があります。たとえばscalac -J-Xmx12G X.scala、私が使用したものです。実際に必要な量はテストしませんでした。
レックスカー

まだ悲しいことに、コンパイルしていない:( error: error while loading AnnotatedElement, class file '/usr/lib/jvm/java-8-openjdk-amd64/jre/lib/rt.jar(java/lang/reflect/AnnotatedElement.class)' is broken (bad constant pool tag 18 at byte 76) one error foundあなたは(あまりにも多分プラットフォーム)のScalaとJavaのバージョンを指定することができます私は、Debian 8のx86-64上で、scalac 2.9.2とOpenJDKの1.8.0_66-内部-B17を使用?。
P.Péter

Ubuntuの15.10、 java version "1.8.0_72-ea" Java(TM) SE Runtime Environment (build 1.8.0_72-ea-b05) Java HotSpot(TM) 64-Bit Server VM (build 25.72-b05, mixed mode) $ scala -version Scala code runner version 2.11.7 -- Copyright 2002-2013, LAMP/EPFL
レックスカー

2

C、-cinの場合は284バイト+ 2 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};

0

ブー、これから期待できる以上の方法

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

これは、いくつかの小さな変更(??)を加えたMason Wheelerの回答のように見えます。同じ回答に個別に到達しましたか、または変更した値に重要なものがありますか(もしそうであれば、回答を編集してそれらが重要である理由を説明してください)。
デイブ

0

Python 3:

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

爆弾爆弾


2
エントリが他のエントリとどのように比較されるかを確認するには、出力のバイト数を指定する必要があります。
-Sanchises

PPCGへようこそ!誤って2つのアカウントを作成し、この回答を2回投稿したようです。他の答えは削除しました。Sanchisesが言ったように、この課題はコンパイルされたプログラムのサイズによって記録されます。そのため、そのサイズをプライマリスコアとして回答に含める必要があります。また、実際のプログラムはそれほど大きくなく、メモリ内に作成している式のみであるため、別のアプローチを検討することもできます。
マーティンエンダー

1
@MartinEnderは、コンパイル時にPythonがいくつかの式を評価し、任意の精度で数値を格納する方法のため、これは(理論上)かなり大きな実行可能ファイルを持ちます。しかし、Aleksi Torhamo(彼の答えの一部に同じテクニックを使用した)が指摘したように、これには2GB前後の制限があります。 )。OPがコンパイルを取得し、コンパイルされたサイズを(生成に必要なコマンドとともに)ポストできる場合、それは有効です。アレクシの既存の答えとの類似性は、私には偶然のように見えます。
デイブ
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.