ソースコードの2倍化に関連するいくつかの課題がありました：こことここです。ここでのタスクは少し難しいですが、ほぼすべての言語で実行できるはずです。

このチャレンジでは、任意の正の整数を取り込みます。プログラムはその整数をdoubledで出力する必要があります。ソースコードを2倍にすると、正の整数が取り込まれ、2乗して出力されます。ます。

ソースコードはどのように2倍になりましたか？さて、あなたはそれをあなたの方法で持つことができます。つまり、ソースコードを任意の等しい長さのバイトまたは文字列（またはトークン化された言語のトークン）に分割できます。各チャンクを連続して2回繰り返す。

の初期プログラムABCDEFGHIJKL（長さ12）の場合、考えられるすべての二重化されたプログラムは次のとおりです。

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

これは、素数のプログラムは2つの方法でしか倍増できないことに注意してください。すべての文字が倍増するか、プログラム全体が2回繰り返されます。

ルール：

• コードは完全なプログラムまたは機能でなければなりません。
• 標準的な抜け穴は禁止されています。
• 標準のI / Oメソッドが許可されます。
• 空白や改行を含むすべての文字/バイトは、コードの長さでカウントされ、チャンクに寄与します。
• あなたは入力とその四角はあなたの言語のint型/整数型で表すことができることを前提としています。
• あなたはないかもしれません末尾の改行やその他の文字を想定する。
• バイト数の後の見出しにチャンクサイズを指定します。
• これはコードゴルフですなので、短いプログラムの方が優れています！2つのプログラムの長さが同じである場合、小さいチャンク長を使用するプログラムが優先されます。（短いチャンク長を使用する長いプログラムがある場合は、投稿する価値もあります！）
• プログラムが2番目の入力/行を必要とする場合、その値について何も仮定しません。特に、2番目の入力が空の場合、最初の入力と同じ場合、または異なる整数の場合、プログラムは動作するはずです。プログラムが2番目の入力/行を必要としない場合、この制限を無視できます。

サンドボックスリンク

Perl 5、8バイト（チャンクサイズ4）

$_*=~~+2

オンラインで試すか、2倍のバージョンをお試しください。

単項~はビット単位の否定であるため、2回適用するのは無意味です。したがって、基本プログラムは単純に$_（暗黙的な入出力変数）に2を掛けます。

バイナリ~~はsmartmatchであり、ブール値を返します。~~+2~~+2として解析し(~~+2) ~~ (+2)ます。2は2に等しいので、これはtrue（1）を生成します。したがって、二重化されたプログラムは、最初に1を乗算$_し、次に$_それ自体を乗算します。

05AB1E、4バイト（チャンクサイズ2または4）

·Inr

オンラインで試すか、単一の4バイトチャンクとして2倍にするか、2つの2バイトチャンクとして2倍にします。

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3、26バイト（チャンクサイズ13）

lambda n:"and n*n#"and 2*n

オンラインでお試しください！

倍増：

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

このソリューションは、@ Grimyによって提供されます。

Pythonの3、32 30 28バイト（チャンク・サイズ16 15 14）

lambda n:bool(0)*n*n or  2*n

オンラインでお試しください！

@negativeSevenのおかげで-4バイト

倍増：

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

オンラインでお試しください！

関数は、このチャレンジの一意のチャンクルールを利用します。

Befunge-98（FBBI）、8バイト（チャンク長2）

;&:#* +q

オンラインでお試しください！

;&;&:#:#* * +q+q

オンラインでお試しください！（倍増）

制御フローを除くと、最初のプログラムは実行&:+q（入力、スタックの先頭を複製、追加、リターンコードで終了）、2番目のプログラムは実行（入力、スタックの&:*+q先頭を複製、乗算、加算（暗黙の0で合計）、リターンで終了コード）

六角形、14バイト（チャンクサイズ14）

?"+==*/}=+!@!<

拡張：

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

オンラインでお試しください！

倍増

?"+==*/}=+!@!<?"+==*/}=+!@!<

拡張：

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

オンラインで倍増してみてください！

六角形は、この課題において少し奇妙な立場にあります。実際にタスクを達成することは、2つの個別のプログラムを書くことができるよりもそれほど難しくないからです。しかし、ソリューションをゴルフでプレイすることはかなり難しいことがわかりました。

この解決策は、私が収まる最短形式の些細なアイデアですが、もっと短くて賢い答えがあると思います。このバージョンでは、ソースが2倍になっているかどうかに応じて、入力に2つの値を非常に単純に設定し、それらを合計または乗算します。唯一のコードの再利用は"+、元のプログラムの未使用スペースに収まるように、2倍のプログラムのコピーコードを十分に短くすることです。

IP変更命令[]を使用すると、パーツの分離が容易になると思いますが、真に理想的なソリューションは、2つの間で多くのコードを再利用します。ヘキサゴニーソースコードを2倍にするヘルパープログラムを作成しました。末尾のno-opを削除するため、最後にプレースホルダーのno-opを使用する場合は、他の文字を入力してから変更してください。さまざまなチャンクサイズを処理できますが、可能な各プログラムを出力するコードはまだ作成していません（Hexagonyは、チャンクサイズ全体を使用するのに適しているようです）。

六角形、12バイト（チャンクサイズ4）

?"2+...}=*!@

オンラインでお試しください！

フォーマット済み：

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

そして、2倍にして、フォーマットしました：

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

基本的に、これは最初のエッジを入力に設定し、次に2番目のエッジを2入力のいずれかまたはコピーに設定し、それらの2つのエッジを3番目のエッジに乗算し、印刷して終了します。実行された命令のリストはただ

?"2}=*!@

そして

?"2+}=*!@

唯一の違いは、2番目のプログラムの+オーバーライド2です。

JavaScript（ES6）、 24  22バイト

珍しい形式にもかかわらず、これは匿名関数の定義であり、直接呼び出すか、変数に割り当てることができます。

+(g=x=>x*x)?g:(x=>x*2)

オンラインでお試しください！

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

オンラインで2倍にしてみてください！

どうやって？

+関数に単項式を適用すると、それを数値に強制する試みとして解釈され、結果としてNaNになります。したがって、+(g=x=>x*x)両方のバージョンで先頭が偽物です。

一方、+2つの関数間でバイナリを適用すると、文字列になります。したがって、(x=>x*2)+(g=x=>x*x)2倍のバージョンでは真実です。

Perl 6、8バイト（チャンクサイズ1）

* *<1 2>

オンラインでお試しください！ 倍にしてみてください！

数字を受け取り、最初のプログラムの数字と2番目のプログラムのシングルトンリストを返すWhatever / HyperWhateverラムダ。基本的に、これはまったく同じロジックを保持しますが、乗算演算子（*）が指数演算子（）に置き換えられ**ます。

**  **<<11  22>>

Whateverリテラル（紛らわしくaで表される*）は**、リスト上にマップされることを除いて基本的に同じHyperWhatever（）に倍増されます。Whateverリテラルと乗算を分離するにはスペースが必要であり、2倍にすると無視されます。単に2（2倍になる22）の代わりに、数値コンテキストで2に評価される2つの要素を含むリストを使用します。<>補間を用いてリストに倍増することができ、2つの要素が内部倍、どちらもそれらの変更リストの長さです。

Runic Enchantments、9バイト（チャンクサイズ3）

i3?:*@:+@

オンラインでお試しください！
倍にしてみてください！

3?その結果、次の3つの命令をスキップ（実行）i3?...:+@。2倍にすると、3つのNOP命令を表すi3?...:*@whereが実行され.ます。@「スタック全体を印刷して終了する」です。

C＃（Visual C＃Interactive Compiler） / Javascript、22バイト、チャンクサイズ11

m=>/*      /2*m//*/m*2

オンラインでお試しください！

Brain-Flak、48 30バイト（チャンクサイズ10）

(({}))<>( {({}[()])}{}<>{}{}) 

オンラインでお試しください！ 倍にしてみてください！

これには基本的に3つのステップが必要で、doubleを実行するとそれらのステップがそれぞれ2回実行されます。初期プログラムは次のとおりです。

1. TOSを複製し、スタックを切り替えて、値のプッシュを開始します
2. TOSの三角数n *（n-1）/ 2を取得します
3. TOSをポップし、スタックを切り替えて2回ポップし、結果をプッシュします。

n倍増プログラムへの入力の場合、これは次のようになります。

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

2倍のプログラムの場合：

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

Brain-Flak、76バイト、76バイトのチャンク

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

オンラインでお試しください！

倍増（わかりやすくするために改行を使用）

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

オンラインでお試しください！

これは、より複雑な倍増手順を使用するバージョンです。サイズ15の5つのチャンクを実行します。ただし、コードは46バイトですが、必要なパディングのためにかなり長くなっています。

105 90バイト、15バイトのチャンク

(              {<><({}()())><><><            <>>({})({}[()])}{}            )<>            

オンラインでお試しください！

倍増（わかりやすくするために改行を使用）

(              (              
{<><({}()())><>{<><({}()())><>
<><            <><            
<>>({})({}[()])<>>({})({}[()])
}{}            }{}            
)<>            )<>            

オンラインでお試しください！

Cubix、18 14バイト（チャンク長9 7）

*OI$|:/@O+:I. 

末尾のスペースに注意してください。オンラインでお試しください！

倍増：

*OI$|:/*OI$|:/@O+:I. @O+:I. 

繰り返しますが、末尾にスペースが1つあります。オンラインでお試しください！

説明

主なアイデアは、コードを2倍にするとキューブが大きくなるため、命令ポインターは別のシンボルから始まるということです。追加プログラムは、辺の長さが1の立方体には配置できないため、辺の長さは2になります。さらに、2倍のコードは、辺の長さが3の立方体にある必要があるため、2倍のコードは少なくとも25バイトでなければなりません。これは、コードの長さが少なくとも13バイトでなければならないことを意味します。そのため、最大で1バイトを保存できます。

実際のコードに移ります。最初の観察は、上面（つまり、最初の4文字）が追加プログラムによって使用されないことです。さらに、5番目のキャラクターにキューブの周りのIPを反映させると、さらに2つのキャラクターを解放できます。これらの文字を使用して、2乗プログラムを配置します。

モーニングトンクレセント、656バイト（チャンクサイズ328）

これはほとんどすべての言語で解決できるという理論に重みを加えるだけです...

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

（末尾の改行は重要です）

シングルバージョンをお試しください！...または... 2倍のバージョンをお試しください！

ここでの理論は単純です：単一バージョンでは、 'Bounds Green'はランダムな文字列で埋められますが、2倍バージョンでは、2乗入力で埋められます。チャンクが終了すると、両方のバージョンで「入力」が2倍になりますが、コードの2倍になったバージョンでは、入力が0に置き換えられます。

この結果はBounds Greenに戻され、結果に出力される前にmax（）操作を2回実行します。単一バージョンでは、倍増は変更されません（intと文字列は前後に切り替えられます）が、倍増バージョンでは、0が既にBounds Greenに格納されている二乗結果に置き換えられます。

JavaScript（Node.js）、15 12バイト（チャンクサイズ：6）

x=>/**/2*(x)

オンラインでお試しください！

シングルケース：

x=>/**/2*(x)

ダブルケース：

x=>/**x=>/**/2*(x)/2*(x)

C＃、およびJavaに変更=>する場合はJavaでも動作するよう->です

R、42 35 28バイト（チャンクサイズ4）

チャンクが小さくなり、エラーがなくなりました。チャンクサイズ3の長いソリューションもあります。下記参照。

チャンクサイズ1または2のR回答を書くことは不可能だと思います。私が間違っていることを証明した人には喜んで賞金を差し上げます。

s =scan#
n=s()# 
  
n/2*4#  

オンラインでお試しください！

これ#はRのコメント用です。3行目はスペースのみであり、改行+ 2スペース+改行のチャンクを作成するため、前と次のチャンクに改行を含めることはできません。

倍になり、次のようになります。

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

オンラインでお試しください！

単一バージョンは計算します$\frac n2\times4=2n$$\frac n2\times \frac n2\times4=n^2$

少し長いソリューションですが、チャンクサイズは3です。

R、39バイト（チャンクサイズ3）

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

オンラインでお試しください！

倍増：

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

オンラインでお試しください！

Giuseppeには別の R回答があり、1つのチャンクが30バイトであることに注意してください。

R、59 30バイト（チャンクサイズ59 30）

F=F+1;f=function(n)n*c(2,n)[F]

オンラインでお試しください！

クレジットロビン・ライダーこれを鼓舞するために、F毎回増加し、関数fは適切な出力を選択します。

これは特に興味深いものではありませんが、間違いなくチャンクサイズを操作する巧妙なものが考えられます。予想どおり、Robin Ryderはこれを思いつきました。

PowerShell、22バイト（チャンクサイズ11）

param($p)
#   /
2 * $p

オンラインでお試しください。

倍増：

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

このソリューションは、@ ShieruAsakotoのソリューションに基づいています。

PowerShellに変換された@Grimy ソリューション、26バイト（チャンクサイズ13）

param($p)$t=';$p*$p#';$p*2

オンラインでお試しください。

倍増：

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Perl 5（-p）、22 15バイト

グリミーのおかげで-7バイト

$_*=$'/4||2;//;

TIO

炭、13バイト

ＰＩ×Ｉθ⎇υＩθ²⊞υω

オンラインでお試しください！説明：事前定義された空のリストは偽であるため、入力は2倍になります。2倍にすると、2番目のパスで空の文字列がリストにプッシュされ、代わりに入力が乗算されます。オンラインでお試しください！詳細な構文では、これはに対応しMultiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);ます。

Pythonの3、56の、53バイト

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

私のpythonのスキルちょっとに基づいて...そう、間違いなくgolfedすることができ、吸うでPythonの答え「あなたは二重の出力、Iダブルソース！」挑戦。

チャンク長53。

オンラインそれを試してみたり、それがオンライン倍増してみてください。

Java 8、62バイト

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

チャンク長62。

オンラインそれを試してみたり、それがオンライン倍増してみてください。

説明：

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

Javaでは、利用可能なコメントはあり// commentや/* comment */。ここで組み合わせて、特定の部分を上書きします。Javaの強調表示により、これらのコメントがどのように機能するかを確認してください。

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

二重化されたプログラムは、カスタムByteクラスとその値を作成しSIZE=9、デフォルトjava.lang.Byteクラスとその値を上書きしますSIZE=8。

Japt、7 5 バイト

*N²jJ

それを試してください | 倍増

²2を入力の配列にプッシュし、インデックスの要素（つまり、新しく挿入された）を削除して返し、入力にNそれを乗算します。jJ=-12

2倍にすると、Jが乗算される2ため、インデックスの要素-2（入力）が返されj、乗数として使用されます。

ゼリー、8 6バイト（チャンク長3）

Ḥ;²3ị 

オンラインでお試しください！

倍増

良い解決策：Lua、66バイト（チャンクサイズ66バイト）

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

オンラインでお試しください！（自分で2倍にすると、それほど難しくありません）

そうそう、これに対する短い解決策があることはかなり確かですが、この方法を思いついたのは最高です。入力を最初の引数として受け取ります。

簡単な説明：とのビジネス全体aは誰にとっても非常に明白ですが、2番目の部分xはより興味深いものです。基本的に、__gcプログラムを終了するときに呼び出されるファイナライザー（メタメソッド）を使用して、テーブルを作成（または既存のテーブルを2回目のパスで更新）します。

ラメソリューション：Lua、60バイト（チャンクサイズ30バイト）

a=a and...^2 or ...*2;                     print(a)os.exit()

オンラインでお試しください！またはそれを2倍にしてみてください！

小さく、より良いチャンクを使用しますが、巧妙なトリックなしで、最終的には退屈で足の不自由です。このコメントは必要ないと確信しています。

J、^{15 10} 9バイト

+: :(*-:)

オンラインでお試しください！

ダブルバージョン：オンラインでお試しください！

f : gf1つの引数でg呼び出されたとき、および2 つの引数で呼び出されたときに実行される動詞を作成します。したがって+:、元のソースを使用*-:して、ソースが2倍になったときにdouble を実行します。

これは、Jの2つの動詞の列がフックになり、yが元の入力f fとして実行されるためにy f (f y)機能します。さらに、*-:それ自体*は左引数-:に右引数の半分を掛けることによって機能する「ダイアディックフック」です。左の引数は元の入力になり、右の引数は2倍になった入力になるため、元の入力の2乗が生成されます。

元の答え

J、15のバイト

*:@]`(+:@])@.=~

オンラインでお試しください！

ダブルバージョン：オンラインでお試しください！

単一バージョンでは、アジェンダ@.を使用してif ... thenロジックを実行する単一の動詞があります。引数がそれ自体=~に等しい場合、引数を取り、それを2倍にし(+:@[)ます。

ただし、コードを2倍にすると、Jフックが取得されます。動詞fと入力を呼び出しますy。次に、フックf fは次のように実行されます。

y f (f y)

これは、元の入力が左引数になり、右引数が2倍になったことを意味します。これらは等しくないため、=~今回はfalseを返します。次に、アジェンダの他の分岐、つまり、*:@]「正しい引数の2乗」を実行します。また~、二項動詞の入力が逆になるため、正しい引数が元の入力になります。

Python 3、60バイト

チャンクサイズ6。
優れたソリューションではありませんが、機能します。これは非常にユニークな挑戦であり、異なる視点から考えるようになります。

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

オンラインでお試しください！

倍増：

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

オンラインでお試しください！

カスケード、13バイト（チャンクサイズ13）

]
&/2
#
*
 2&

オンラインでお試しください！

]
&/2
#
*
 2&]
&/2
#
*
 2&

倍にしてみてください！

これは非常に困難でした。これの基本的な要点は2、最初のプログラムの入力を乗算し、2番目のプログラム2の入力のコピーで置き換えることです。

説明：

最初のプログラムの実行部分は次のようになります

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

二重化されたプログラムは、基本的に]最後の行の最後に最初の行を追加するため、プログラムはの代わりにその行にラップアラウンドし&ます。これはそれを

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Zsh、30バイト（チャンクサイズ10）

m=$m[1]*2
x=$[$1$m]
return $x

オンラインでお試しください！ 倍にしてみてください！

$varin $[$var]が最初に展開され、次に算術コンテキストで評価されるという事実を悪用します。

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

誰かがこれを下げることでクラックを望んでいるなら、ここに24/8私が手に入れた解決策に最も近いものがあります（x^2+22倍にしたときの出力）