プログラムを印刷するプログラム


13

チャレンジ

あなたの目標は、別のプログラムを印刷するプログラムを書くことです。その印刷されたプログラムは別のプログラムを印刷し、新しいプログラムは最後まで別のプログラムを印刷する必要があります。

ルール

  1. 各プログラムは256バイト未満でなければなりません。(これを変更する必要がある場合は、コメントを残してください)
  2. 最後のプログラムは空のプログラムでなければなりません。
  3. プログラムの数は有限である必要があるため、プログラムはクインになることはできません。
  4. プログラムはすべて同じ言語で実行する必要があります。
  5. 入力は許可されていません。
  6. 勝者プログラムは、可能な限り多くのプログラムを印刷し、それ自体をカウントするプログラムです。

幸運を!


最大スコアは2^2048、または3.2317e616です。
orlp

それが簡単に大きなスコアを比較することについては、フォームであなたのスコアに近似値を含めてくださいa*10^b場所1<=a<10b自然数です。
-flawr

2
実際、以前の計算は間違っていました。プログラムはバイト単位である必要があると仮定すると、可能な最大スコアは<コメントするには長すぎます>または1.2673e614です。
orlp

回答:


20

CJam、4.56×10 526プログラム

2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~

正確なスコア:254 219 + 254 192 + 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 3

ファイルサイズの制限に準拠するには、すべてのプログラムをISO-8859-1エンコードを使用して保存する必要があります。

バグを指摘し、ネスト手法を提案してくれた@ChrisDrostに感謝します。

CJamインタプリタでオンラインで試してください。

254 219 + 2≈4.56×10 526プログラム

スコアのラインシェアは、次のはるかに単純なプログラム1によって達成できます。

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

このプログラムを実行すると、プログラムが生成されます

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

そして254 219-さらに1回の反復の後、プログラム

{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

この最後の空ではないプログラムはエラー2で終了し、何も出力しません(空のプログラム)。

使い方

文字列が既にスタックにあると仮定します。

{      e# Push a code block.
  \    e# Swap the string on top of the code block.
       e# This will cause a runtime error if there is no string on the stack.
  256b e# Convert the string (treated as a base-256 number) to integer (I).
  _(   e# Copy the integer and decrement the copy.
  256b e# Convert the integer into the array of its base-256 digits.
  :c   e# Cast each base-256 digit to character. Converts from array to string.
  '\s  e# Push a string that contains a single backslash.
  `    e# Push its string representation, i.e., the array ['" '\ '\ '"].
  _:(  e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
  er   e# Perform transliteration to replace "s with !s and \s with [s.
       e# This skips characters that require escaping.
  `    e# Push its string representation, i.e., surround it with double quotes.
  Q    e# Push an empty string.
  ?    e# Select the first string if I is non-zero, the empty string otherwise.
  \    e# Swap the selected string with the code block.
  "_~" e# Push that string on the stack.
}      e#
_~     e# Push a copy of the code block and execute it.
       e# The stack now contains the modified string, the original code block
       e# and the string "_~", producing an almost exact copy of the source.

254の192 ≈5.35×10 461以上のプログラム

これは、物事が少し夢中になるところです。

最初のプログラムは高度に圧縮可能です。空のプログラムの代わりに最終的に上記のセクションから最初のプログラムを生成する同様のプログラムを作成することにより、254 192プログラム3のスコアを改善できます。

プログラム

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~

前のセクションの最初のプログラムに似ており、前者とその出力を254 192回繰り返して実行すると後者が生成されます。

文字列が既にスタック上にあると仮定します。

{                           e# Push a code block.
  "\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
                            e# The characters inside it behave exactly as
                            e# they did in the previous section.
  :T~                       e# Save the string in T and evaluate it.
  {                         e# If the integer I is non-zero, keep the generated
                            e# string; else:
    ;                       e#   Pop the code block from the stack.
    219'ÿ*`                 e#   Push a string of 219 ÿ's (with double quotes).
    {Q?\"_~"}               e#   Push that block on the stack.
    s                       e#   Push its string representation.
    (\                      e#   Shift out the { and swap it with the tail.
    T                       e#   Push T.
  }?                        e#
  \                         e# Swap the selected string with the code block
                            e# or T with the tail of the code block.
  "_~"                      e# Push that string on the stack.
}                           e#
_~                          e# Push a copy of the code block and execute it.

モアープログラム

前のセクションの最初のプログラムは依然として圧縮率が高いため、同様の方法を適用して、254 166回の反復後に前述のプログラムを生成するプログラムを作成できます。

255バイトの制限に達するまでこの手法を何度も繰り返し、合計254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 1≈1.59×10 399プログラムを追加できます。前のセクションのもの。


1 明確にするために改行が追加されました。
2 Metaのコンセンサスごとに、これはデフォルトで許可されています。
3 または0.0000000000000000000000000000000000000000000000000000000000000000000012%



5

JavaScript、1000プログラム

x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
    x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
      : ``
)

これが有効かどうかは、3番目のルールを正確に理解する方法に依存します。


同一のコピーではなく、独自のソースコードの修正バージョンを出力するため、技術的にはクインではありません。明らかに、クインのようなテクニックを使用します。@TheTurtleからの説明が必要だと思います。
JohnE

5
@JohnE and Ypnypnこれは私が想像したようなものです。これは動作します。
カメ

6
まだコードの長さの制限を十分に下回っています。999をもっと大きなものに変えてみませんか?
DankMemes

4

Ruby、1.628×10 ^ 237プログラム

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;_="a=%#x-1;_=%p;puts _%%[a,_]if a";puts _%[a,_]if a

Perlの答えと同じアプローチですが、Rubyは既に大きな整数を処理しているため、16進数として保存する方が簡単です。


Ruby、9.277×10 ^ 90プログラム

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;b=0xf;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-("%x"%a).length));_="a=%#x;b=%#x;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-('%%x'%%a).length));_=%p;puts _%%[a,b-1,_]if a";puts _%[a,b-1,_]if a

したがって、この試みは以前のクインライクとはわずかに異なるバリエーションですが、すべての余分な機能のために、他の関数と同じくらい高い数になっていません...別のアプローチを試してみるのは面白かったです!


4

Python 2、9.7 * 10 ^ 229プログラム

O=0
if len(hex(O))<191:print"O=0x%x"%(O+1)+open(__file__).read()[-68:]

ニース、文字列の繰り返しを考えていませんでした!
ドムヘイスティングス

2

C、2.2 * 10 ^ 177プログラム

#define S(s)char*q=#s,n[]="#####################################################################################################";i;s
S(main(){while(n[i]==91)n[i++]=35;i==101?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})

完璧ではありませんが、かなり良いです。255つまり、まさにバイト長で、同じ長さのプログラムを生成します。おそらく、いくつかのプログラムを取得するためにもう少し調整することができますが、今のところはそのままにします。

このプログラムは、単純なCクインに基づいています。さらに、char配列のすべての可能な値をカウントする非常に単純なカウントアルゴリズムがありますn。文字列の順列と同数のプログラムがありますn

charの範囲は、#(= 35)〜[=(91)の範囲に制限されています。それのは、私がどのたくないので、"または\、彼らはエスケープする必要があるため、文字列の中に。

char配列のすべての値が場合、プログラムの生成が終了nしています[。次に、単純なダミープログラムmain(){}を出力しますが、それ自体は何も出力しません。

#define  S(s) char *q = #s; /* have the source as a string */ \
char n[] = "#####################################################################################################"; \ 
int i; \
s /* the source itself */
S(main() {
    while(n[i]=='[') /* clear out highest value, so next array element be incremented */
        n[i++]='#'; 
    i==101 /* end of array reached? output dummy program */
        ? q = "main(){}"
        : n[i]++; /* count one up in the whole array */
    printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)", n, q);
})

それが機能することを示すデモとして、制限を変更しただけなので、ASCIIコード35との間の文字のみ36が使用され、4つの配列要素のみが使用されます。

結果のプログラムは

% echo > delim; find -iname 'program_*.c' | xargs -n1 cat delim

#define S(s)char*q=#s,n[]="####";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$###";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="###$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$##$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="####";i;s
S(main(){})

これにより、2^4 + 1 = 17異なるプログラムが出力されます。

したがって、上記のプログラムは((91-35)+1)^101 + 1 = 57^101 + 1 ~= 2.2 * 10^177異なるプログラムを出力します。これが重要なのか、計算が正しいのか、はっきりとはわかりません


1
これが2.2 * 10^177(比較したい人のために)約であることを含めていただけます か?
flawr

これを計算する方法を知りませんでしたが、私はそれを含めました
;


1

Perl、1×10 ^ 163

それ以外の場合、これは非常に基本的なクインであり、可能な限り少ない文字数に縮小され、カウンターがそうでない間のみ実行され0ます。

use bigint;$i=9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999||die;$_=<<'e';eval
print"use bigint;\$i=$i-1||die;\$_=<<'e';eval
${_}e
"
e

1

Common Lisp、10113 -1

(LET ((X
       99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999))
  (WHEN #1=(PLUSP X)
    #2=(SETF *PRINT-CIRCLE* T)
    #3=(PRINT (LIST 'LET `((X ,(1- X))) (LIST 'WHEN '#1# '#2# '#3#)))))
  • 113ナインがあります。
  • 次のプログラムには112のナインがあり、その後に8が続きます
  • 次のプログラムには112のナインがあり、その後に7
  • ...

9の数は、プリンターによって導入されるスペースを考慮して、コードの最大サイズ256によって制限されます


1

Perl、1.4 * 10 ^ 225

use bignum;open$F,__FILE__;$_=<$F>;s/0x\w+/($&-1)->as_hex/e;0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff&&print

Pythonへの同様のアプローチ。同じ結果!


0

> <>、65534(?)プログラム

65533を印刷できることをまだ確認していないので、65533の横に疑問符を追加しました(信じるべき理由はありますが)。もう少し時間があれば、それをテストする方法を見つけます。

":?!;1-r00gol?!;a0.�

こちらからオンライン試すことができます

このプログラムの要点は、最後に文字の出力を変更し、印刷前に数値を減らすことです。コードの最後の文字のASCII値が65533であるため、65534個のプログラムを取得しました。したがって、65534を持つ最初のプログラムをカウントします(空のプログラム65535をカウントすると、私は推測します)。「返される」最後のプログラムは何もありません。文字値が0になったときに終了します。

すべての反復で文字を印刷できると確信しています:> <>で印刷できる文字数の明確なソースは見つかりませんでしたが、数値で65533のすぐ下に文字があります。

この実装に問題がある場合はお知らせください。私は私のエントリーの有効性について少し確信が持てません。


説明

単一引用符を使用して> <> wikiから疑似クインを作成するという考えと、ここで一度見たコメントを恥知らずに盗みました。

":?!;1-r00gol?!;a0.�
"                     begins string parsing
 :?!;                 terminates program if final character is 0, numerically
     1-               decrements final character by 1
       r              reverses stack
        00g           grabs quotation mark (fancy way of putting " ")
           ol?!;      prints and terminates if stack is empty
                a0.   jumps back to o to loop 

引用符の後のすべてを文字として解析し、最後の文字をデクリメントします。そこから(正しい順序で印刷するように)スタックを反転し、スタックに引用符を押して、スタックが空になるまで印刷します。


0

Python、1×10 ^ 194プログラム

n=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
if n:print open(__file__).read().replace(str(n),str(n-1))

これは、ファイルから実行されなければなりません、インタラクティブrepl、ます。それは馬ではありません。

@The Turtleに3バイトの節約を助けてくれたことに感謝します。
2バイトの節約を支援してくれた@pokeに感謝します。


@ Cheese Lover if n!=0は冗長です。ただ書くことができますif n
タートル

2つのスペースも削除できます。後if n:との間replaceの引数。
突く

0

Bash、52プログラム

全く霊感を受けていない、そして(できれば)しっかりと最後の場所に。

echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.