これは、触発された、あなたのコードのネガプリントとゴルフ相互QUINE。

1. 印刷可能なASCII文字のみで構成されます
2. 両方とも1より大きい寸法
3. 各行と各列には、少なくとも1つのスペースが含まれます。
4. 各行と各列には、少なくとも1つの非スペース文字が含まれています。

たとえば、次は有効な6x4の長方形です。

%n 2e 
1  g 3
 &* __
 3  

この長方形の負の値は、すべてのスペースが非スペース文字で置き換えられ、すべての非スペース文字がスペースで置き換えられた、等しい寸法の長方形であると定義されます。上記の長方形の負の値は次のとおりです。

  f  ^
 33 > 
9  $  
^ }|Q'

スペースを置き換えるには、スペース以外の印刷可能なASCII文字を使用できます。

仕事

あなたの仕事は、長方形のソースコードを使用してプログラムを作成し、有効なネガをそれ自体に出力することです。出力されるネガも、オリジナルと同じ言語の有効なプログラムである必要があり、オリジナルのソースを出力する必要があります。

いずれかの出力の末尾にある単一の末尾の改行を除き、末尾の空白は追加または削除できません。これはオプションです。

どちらのプログラムも、どちらのソースコードも読み取ることはできません。また、REPL環境を想定することもできません。

得点

スコアは、コードの次元の積です（つまり、ソースコードが12 x 25の長方形の場合、スコアは12 * 15 = 180です）。さらに、コメントで使用される各文字について、スコアは2増加/* .. */します（コードで1回使用し、コードが10 x 10の長方形にある場合、スコアは10 * 10 + 8 * 2 = 116になります）。

最も低いスコアが勝ちます。

同点の場合、プログラム内のスペースの数が最も少ない（オリジナルまたはネガティブの、スペースが少ない方の）提出が勝ちです。

まだ同点が残っている場合は、以前の回答が勝ちとなります。

オリジナルとネガを組み合わせて通常のクインを生成する場合、-52％のボーナスがあります。例えば：

Original   Negative   Combined
 A A       B B        BABA
A A         B B       ABAB

CJam、（51 49 47 46 45 42 x 2）* 48％= 40.32

{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~ 
                                         R

上記のコードを実行すると、次の出力が得られます。

                                         R
{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~ 

これを実行すると、元のソースが印刷されます。

ソースと出力は単純に交換されたラインです。

今魔法が来る。

ソースと出力の結果を次のコードに重ねます：

{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~R
{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~R

これは完璧な馬です！

こちらからオンラインでお試しください

使い方

すべての印刷ロジックは最初の行自体にあり、後で説明する3つのケースすべてを処理します。

{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~
{                                     }_~   "Copy this code block and execute the copy";
 ]                                          "Wrap everything before it in array";
  )                                         "Pop the last element out of it";
   "_~"+                                    "Append string '_~' to the copied code block";
        S41*                                "Create a string of 41 spaces";
            'R+                             "Append character R to it";
               @,                           "Rotate the array to top and get its length";
                 [{   }{   }{     }]=~      "Get the corresponding element from this"
                                            "array and execute it";

上記の最後の行の配列は、3つのケースすべてに対応するコードブロックを持つ配列です。

事例1

{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~ 
                                         R

この場合、ブロックが実行されたとき、残りのスタックの長さは0でした。ブロック自体のコピーのみがあり、最初に上記の3番目のステップでポップアウトされました。したがって0、最後の配列からインデックスを取り出して実行します。

 {N@S}          "Note that at this point, the stack is something like:"
                "[[<code block that was copied> '_ '~ ] <41 spaces and R string>]";
  N             "Add newline to stack";
   @            "Rotate the code block to top of stack";
    S           "Put a trailing space which negates the original R";

この場合、出力の印刷に関する限り、2行目はノーオペレーションです。

事例2

                                         R
{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~ 

この場合、スタックにはすでに空の文字列が含まれていたため、コピーされたコードブロックを実行すると、空の文字列とコードブロック自体の2つの要素がありました。したがって1、最後の配列からインデックスを取り出して実行します。

{SN@}            "Note at this point, the stack is same as in case 1";
 SN              "Push space and newline to stack";
   @             "Rotate last three elements to bring the 41 spaces and R string to top";

事例3

{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~R
{])"_~"+S41*'R+@,[{N@S}{SN@}{W=N]_}]=~}_~R

この場合、スタックには6つの要素があります。したがって、最後のコードブロックをポップした後、残りの配列の長さは5 5です。配列からインデックスを取り出して実行します。（3要素の配列では、インデックス5はindex であることに注意してください5%3 = 2）

{W=N]_}          "Note at this point, the stack is same as in case 1";
 W=              "Take the last character out of the 41 spaces and R string, i.e. R";
   N]            "Add a new line to stack and wrap the stack in an array";
     _           "Copy the array to get back the source of Case 3 itself";

Python、97x2 + 2 = 196

開始するのに最適なソリューションではありませんが、少なくとも機能します（私は思う）。

c='o=1-%d;print("%%97s\\n%%97s"%%("#","c=%%r;exec(c%%%%%%d)\\40"%%(c,o),"#")[o:][:2])';exec(c%1) 
                                                                                                #

出力：

                                                                                                #
c='o=1-%d;print("%%97s\\n%%97s"%%("#","c=%%r;exec(c%%%%%%d)\\40"%%(c,o),"#")[o:][:2])';exec(c%0) 

CJam、（58 56 54 48 46 x 2）* 48％= 44.16

{`"_~"+{_,94\m2/S*a_+\*                       
                       N/23f/Wf%N*}_`'"#)!*}_~

印刷する

                       {`"_~"+{_,94\m2/S*a_+\*
N/23f/Wf%N*}_`'"#)!*}_~                       

各行のスペース以外の文字は、2つの相互のクイン間で同じままです。

しかし今、本当に甘い部分：

{`"_~"+{_,94\m2/S*a_+\*{`"_~"+{_,94\m2/S*a_+\*
N/23f/Wf%N*}_`'"#)!*}_~N/23f/Wf%N*}_`'"#)!*}_~

馬です！:)

ここでテストしてください。

使い方

一般的にCJamでのquiningの基本を説明しているので、最初に他の投稿の説明を読むことをお勧めします。

これは少し複雑です。相互クインの場合、他の場合と同様に、各行の前後にスペースを追加し、0を2に交換してブロックの文字列表現を変更し、結果のプログラムがスペースを反対側に配置するようにします。

スペースは相互のクインにまったく影響しないことに注意してください。1つ目はブロック内にあり、実際には使用されていません。2つ目は、コード全体を囲んでいます。

両方を組み合わせるときに通常のクインを取得するには、そのような変更をすべて行わないようにする方法を見つける必要があります。空白とコードの構造は、両方を組み合わせることで、1つのクイン全体をもう1つのクインに挿入することを意味することに注意してください。したがって、変更コード全体をブロックに入れると、実際の内容に応じてそのブロックを実行できます。

だから今、私はこのブロックを持っています...相互のクインのために、実際に実行したいコードだけが含まれています。結合されたクインの場合、それはまたクイン全体をランダムな位置に含みますが、これは意味がありません...しかし、それはブロックなので、自動的に実行されません。そのため、そのブロックの内容に基づいて文字列を変更するかどうかを判断できます。それ_`'"#)!が目的です。ブロックを複製し、それを文字列に変換し、文字を検索します"（相互にクインで、ブロックの外側にのみ表示されます）- -1文字が見つからない場合は検索が返され、そうでない場合は正の整数が返されます-結果をインクリメントします論理的に否定します。したがって、a "が見つかった場合、これは0それ以外の場合はを返し1ます。今やる*、結果が1の場合はブロックを1回実行し、それ以外の場合は実行しません。

最後に、これは修正コードの仕組みです：

_,94\m2/S*a_+\*N/23f/Wf%N*
_,                         "Duplicate the quine string and get its length.";
  94\m                     "Subtract from 94.";
      2/                   "Divide by two.";
        S*                 "Create a string with that many spaces. This will be
                            an empty string for the first mutual quine, and contain
                            23 spaces for the second mutual quine.";
          a_+              "Create an array that contains this string twice.";
             \*            "Join the two copies together with the quine string.";
               N/          "Split into lines.";
                 23f/      "Split each line into halves (23 bytes each).";
                     Wf%   "Reverse the two halves of each line.";
                        N* "Join with a newline.";

バウンティを請求する、（12 x 10）* 48％= 57.6

このコードは、いくつかの変更を加えると、非常に簡単に複数の行に分割できることがわかりました。2文字を追加して、48を連続して取得します。これを8で割ると、6文字のコードと6スペースの8行になります。そのためには、いくつかの数値を変更し、演算子を1つまたは2つ並べ替えて、両方の行に分割されないようにする必要もあります。これにより、サイズが12 x 8の作業バージョンが1つ必要になります。したがって、何もしない2行を追加するだけで（1を押す、1を押す、1を押す、1を押す...）、12 x 10になります。

{`"_~"      
      +{129X
$,m2/S      
      *a_+\*
N/6f/1      
      ;1;1;1
;1;1;1      
      ;Wf%N*
}_`'"#      
      )!*}_~

前のものとして、これは生成します

      {`"_~"
+{129X      
      $,m2/S
*a_+\*      
      N/6f/1
;1;1;1      
      ;1;1;1
;Wf%N*      
      }_`'"#
)!*}_~      

（補足：中間行で左右を交互に繰り返す必要はありません。最初と最後の行の位置のみが重要です。他のすべての行については、左右を任意に選択できます。）

そして、偶然の一致によって、完全なクインもまだ機能します

{`"_~"{`"_~"
+{129X+{129X
$,m2/S$,m2/S
*a_+\**a_+\*
N/6f/1N/6f/1
;1;1;1;1;1;1
;1;1;1;1;1;1
;Wf%N*;Wf%N*
}_`'"#}_`'"#      
)!*}_~)!*}_~

（偶然と言います。内側のコードを実行しないことに注意する部分は、今では他の馬に奇妙に散らばっていますが、それでもうまくいくことがあります。）

そうは言っても、1;賞金要件を満たすために最初の提出物に44行追加することもできましたが、12 x 10見た目はすっきりしています。;）

編集：ハハ、「純粋な偶然」と言ったとき、私はこれ以上スポットを当てることができなかったでしょう。最終的なクインが実際にどのように機能するかを調べましたが、それはまったくばかげています。ネストされたブロックは3つあります（実際には4つですが、最も内側のブロックは無関係です）。これらの3つのブロックの最も内側の唯一の重要な部分は、それが含まれていることです"（元の送信で行ったもの'"ではなく、最後にこの同じ文字をチェックするために使用されるものです）。したがって、クインの基本構造は次のとおりです。

{`"_~"{`"_~"+{___'"___}_`'"#)!*}_~)!*}_~

それを分析してみましょう：

{`"_~"                               }_~ "The standard CJam quine.";
      {`"_~"+                  }_~       "Another CJam quine. Provided it doesn't do 
                                          anything in the rest of that block, this 
                                          will leave this inner block as a string on 
                                          the stack.";
                                  )      "Slice the last character off the string.";
                                   !     "Negate... this yields 0.";
                                    *    "Repeat the string zero times.";

したがって、これは確かに面白い魔法を行いますが、内部ブロックがスタック上に単一の文字列を残すため、)!*たまたまそれを空の文字列に変えます。唯一の条件は、その後の内側のブロックにあるものが+スタックに対して他に何もしないということですので、それを見てみましょう。

             {___'"___}                  "Push a block which happens to contain 
                                          quotes.";
                       _`'"#)!*          "This is from the original code and just 
                                          removes the block if it does contain 
                                          quotes.";

CJam、42 37 33 x 2 = 66

{`As_W%er"_~"+S 33*F'Lt1{\}*N\}_~
               L                 

印刷する

               L                 
{`As_W%er"_~"+S 33*F'Lt0{\}*N\}_~

（行が入れ替わり、1がに変わり0ます。）

ここでテストしてください。

使い方

最初に、基本的なCJamクインを理解する必要があります。

{"_~"}_~

中括弧は、関数のように、すぐには実行されないコードのブロックを単に定義します。スタックに未実行のブロックが残っている場合、そのソースコード（ブレースを含む）が出力されます。_ブロックを複製し~、2番目のコピーを実行します。ブロック自体は、単にを含む文字列をプッシュします_~。したがって、このコードは、スタックを次の状態のままにします。

Stack: [{"_~"} "_~"]

ブロックと文字列は、プログラムの最後に単純に連続して印刷されるため、これは馬鹿げています。

これの利点は、ブロック内で必要なことは何でもできるということです。また、コードの各部分がブロックの内容に自動的に印刷されるため、それはそのままです。文字列表現を取得することでブロックを修正することもできます`（これはブレース付きのブロックの文字列です）。

次に、このソリューションを見てみましょう。相互QUINEのいずれかの部分が持つQUINEのようなブロックの含まれていることに注意してください_~、とL。L出力に寄与しないスタックに空の文字列を、プッシュします。ブロックが行うことは次のとおりです。

`                             "Convert block to its string representation.";
 As                           "Push 10 and convert to string.";
   _W%                        "Duplicate and reverse, to get another string 01.";
      er                      "Swap 0s and 1s in the block string.";
        "_~"+                 "Append _~.";
             S 33*            "Push a string with 33 spaces.";
                  F'Lt        "Set the character at index 15 to L.";
                      1{ }*   "Repeat this block once.";
                        \     "Swap the code string and the space string.";
                           N\ "Push a newline and move it between the two lines.";

したがって、これはクインの部分を実行しますが、1を0に交換し、またL、上記のコードにスペースがある別の行の前に追加します。キャッチは、これらの2行の順序が内部のスワッピングによって決定されること{ }*です。そして、相互のクインの外側の部分は0aで置き換えられているため1、このスワップは実行されず、元の順序が再び生成されます。

CJam、27×2 = 54

{ ` " _ ~ " + N - ) 2 * ' '
 > @ t s G B + / N * } _ ~ 

出力：

 { ` " _ ~ " + N - ) 2 * ' 
' > @ t s G B + / N * } _ ~

'A'B>文字AとBを比較し' '\n >ます。32> 10であるため1を' \n' >返し、2つのスペースが等しいため0 を返します。

CJam、30 29 x 2 = 58

{"_~"SN]_,4=S28*'R+\{N@}*}_~ 
                            R

出力：

                            R
{"_~"SN]_,4=S28*'R+\{N@}*}_~ 

元のソースを出力します。

これは、他のソリューションと同じプリンシパルに基づいています。

こちらからオンラインでお試しください