涉及源代码加倍的挑战很多：here和here。我们在这里要做的任务比较艰巨，但是应该可以用几乎所有语言来完成。

在此挑战中，您将输入一个任意正整数。你的程序必须输出整数一倍。当源代码加倍时，它将接受一个正整数，并将其输出为squared。

您的源代码如何增加一倍？好吧，你可以按照自己的方式去做。也就是说，你可以分割你的源代码成字节或字符的字符串（或标记化LANGS令牌）的任何等于你想要的长度，并且连续重复每个块的两倍。

对于初始程序ABCDEFGHIJKL，（长度为12），以下是所有可能的加倍程序：

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

请注意，这意味着素数长度的程序只能以两种方式加倍：每个字符加倍，或者整个程序重复两次。

规则：

• 代码必须是完整的程序或功能。
• 禁止出现标准漏洞。
• 允许使用标准I / O方法。
• 所有字符/字节（包括空格和换行符）都计入代码的长度，并有助于组成块。
• 您可以假设输入及其平方可以由您语言的int / integer类型表示。
• 您可能不假定尾随换行符或其他字符。
• 在字节数后的标题中提供块大小。
• 这是代码高尔夫，所以程序越短越好！如果两个程序的长度相同，则使用较小块长度的程序将获胜。（如果您有一个较长的程序，而该程序使用的块长度较小，那也值得发布！）
• 如果您的程序需要第二个输入/行，则可以不对其值进行任何假设。特别是，如果第二个输入为空，与第一个输入相同或为另一个整数，则您的程序应该可以工作。如果您的程序不需要第二个输入/行，则可以忽略此限制。

沙盒链接

Perl 5、8个字节（块大小为4）

$_*=~~+2

在线尝试，或尝试加倍版本。

一元~运算是按位取反的，因此两次应用该运算符是无效的。因此，基本程序只需将$_（隐式输入输出变量）乘以2。

Binary ~~是smartmatch，它返回一个布尔值。~~+2~~+2解析为(~~+2) ~~ (+2)。由于2等于2，因此得出true（1）。因此，加倍的程序首先乘以$_1，然后再乘以$_自身。

05AB1E，4个字节（块大小2或4）

·Inr

在线尝试或将其作为单个4字节块加倍或将其作为两个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

在线尝试！

-4个字节，感谢@negativeSeven

翻倍：

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（输入，堆栈顶部重复，加法，以返回码退出），第二个程序执行&:*+q（输入，堆栈顶部重复，乘以，加法（总和为隐式0），返回返回码）

六角形，14个字节（块大小为14）

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

展开：

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

在线尝试！

加倍

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

展开：

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

在线尝试加倍！

六边形在这个挑战中处于一个奇怪的位置，因为实际上完成任务并不比简单地编写两个单独的程序难得多。然而，打高尔夫球的解决方案被证明相当困难。

这个解决方案是我可以采用的最短形式的琐碎想法，但我怀疑答案更短，更聪明。此版本非常幼稚地将两个值设置为输入，然后将它们相加或相乘，具体取决于源是否加倍。唯一的代码重用就是这样，"+这使得加倍程序的复制代码足够短，以适合原始程序的未使用空间。

我怀疑使用IP更改指令[]会使隔离各部分变得更加容易，但是真正理想的解决方案是在两者之间重用大量代码。我制作了一个帮助程序来将六角形源代码加倍。请注意，它会删除结尾的无操作，因此如果您想在末尾使用占位符无操作，则只需填写其他字符，然后再将其更改回即可。它可以处理不同的块大小，尽管我尚未编写代码来输出每个可能的程序（Hexagony似乎适合使用完整的块大小）。

六边形，12字节（块大小4）

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

在线尝试！

格式：

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

然后加倍，然后格式化：

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

基本上，这会将第一个边设置为输入，然后将第二个边设置为输入中的一个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)

在线尝试加倍！

怎么样？

将一元+应用于函数被解释为试图将其强制为数字并导致NaN。因此，+(g=x=>x*x)在两个版本中，领导都是虚假的。

另一方面，+在2个函数之间应用二进制将产生一个字符串。因此，(x=>x*2)+(g=x=>x*x)在加倍版本中是真实的。

Perl 6、8个字节（块大小为1）

* *<1 2>

在线尝试！ 尝试加倍！

取数字并返回第一个程序的数字和第二个程序的单例列表的Whatever / HyperWhatever lambda。基本上，这保持了完全相同的逻辑，只是乘法运算符（*）被指数运算符（）代替**。

**  **<<11  22>>

将Whatever字面量（也由表示*）也加倍为一个HyperWhatever（**），该基本相同，只是它映射到列表上。需要使用空格来将Whatever文字与乘法分开，并且在加倍时会被忽略。我们使用的是一个包含两个元素的列表，而不仅仅是一个元素2（将变成的两倍22），它在数字上下文中的值为2。<>可以通过插值将_ 翻倍为一个列表，并且将其中的两个元素加倍，但是这两个元素均不会更改列表的长度。

符文符文，9字节（块大小3）

i3?:*@:+@

在线尝试！
尝试加倍！

该3?跳过下一指令3，从而导致（执行）i3?...:+@。如果加倍，它将导致执行i3?...:*@，其中.代表3条NOP指令。@是“打印整个堆栈并终止。”

C＃（Visual C＃交互式编译器） / Javascript，22字节，块大小11

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

在线尝试！

脑高射炮，48 30个字节（块大小10）

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

在线尝试！ 尝试加倍！

这基本上需要三个步骤，然后在两次执行时分别执行两次。初始程序是：

1. 复制TOS，切换堆栈并开始推送值
2. 获取TOS的三角数n *（n-1）/ 2
3. 弹出TOS，切换堆栈并弹出两次，然后推送结果。

对于未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:

对于加倍程序：

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字节块

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

在线尝试！

加倍（为清晰起见，使用换行符）

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

在线尝试！

这是一个使用更复杂的加倍过程的版本。它确实有5个大小为15的块。这里的代码是46个字节，但是由于需要填充，所以它实际上更长。

105 90字节，15字节块

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

在线尝试！

加倍（为清晰起见，使用换行符）

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

在线尝试！

Cubix，18 14字节（块长度9 7）

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

注意尾随空格。在线尝试！

翻倍：

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

同样，有一个尾随空间。在线尝试！

说明

主要思想是将代码加倍会导致多维数据集变大，因此指令指针从另一个符号处开始。由于加法程序不能放在边长为1的多维数据集上，所以边长将为2。此外，加倍的代码必须在边长为3的多维数据集上，因此加倍的代码必须至少为25个字节。这意味着代码必须至少13个字节长。这样，最多可以再保存1个字节。

现在到实际代码。第一个观察结果是加法程序未使用顶面（即前4个字符）。此外，如果使第5个字符反映立方体周围的IP，则可以再释放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

（尾随换行符很重要）

尝试单一版本！...或... 尝试加倍版本！

这里的理论很简单：在单一版本中，“ Bounds Green”用随机字符串填充，而在双重版本中，它用平方输入填充。块结束后，两个版本都将“输入”加倍，但是在代码的加倍版本中，输入已替换为0。

将该结果带回到Bounds Green，该Bounds Green在将结果带到输出之前会执行两次max（）操作。在单一版本中，这会使倍数保持不变（仅将int和string来回切换），但是在双重版本中，它将0替换为已经存储在Bounds Green中的平方结果。

JavaScript（Node.js），15个12字节（块大小：6）

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

在线尝试！

单箱：

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

双重情况：

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

似乎也可以在C＃和Java中工作（如果更改=>为）->？

R，42 35 28字节（块大小4）

现在有了一个较小的块，没有错误。我还有一个更长的解决方案，块大小为3；见下文。

我认为不可能写出大小为1或2的R答案。我会很高兴地向任何证明我做错了的人悬赏。

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

在线尝试！

的 #是对R.评论第三行是唯一的空间，使得换行+ 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答案，一个30字节的块。

R，59 30字节（块大小59 30）

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

在线尝试！

信贷罗宾莱德用于激励这一点; F每次递增，函数f选择适当的输出。

这并不是特别有趣，但是毫无疑问，会想到一些巧妙的操作块大小的方法。正如预期的那样，罗宾·莱德想出了这其中既短且有一些巧妙的块操作。

PowerShell，22字节（区块大小为11）

param($p)
#   /
2 * $p

在线尝试。

翻倍：

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

该解决方案基于@ShieruAsakoto的解决方案。

@Grimy 解决方案已转换为PowerShell，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个字节，感谢Grimy

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

蒂奥

木炭，13字节

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

在线尝试！说明：预定义的空列表为false，因此输入乘以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技能有点烂，因此绝对可以打高尔夫球。.根据“ 我将源代码加倍，将输出加倍！ ”。

块长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然后j删除并返回索引处的元素J=-1（即，新插入的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)'})

在线尝试！（自己加倍，并不难）

哦，是的，可以肯定的是，有一个更短的解决方案，但这是我能想到的最好的方法。将输入作为第一个参数。

简要说明：与a每个人的整个业务都很明显，而与第二部分x的业务更有趣。基本上，我创建带有终结器（__gc元方法）的表（或在第二遍更新现有表），该终结器在程序退出时被调用。

me脚的解决方案：Lua，60个字节（块大小为30个字节）

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

在线尝试！或尝试加倍！

较小且具有更好的分块，但最终无聊又la脚，没有任何巧妙的技巧。我敢肯定，此评论不需要评论。

J，^{15 10} 9字节

+: :(*-:)

在线尝试！

翻倍的版本：在线试用！

f : g创建一个动词，该动词f在使用一个参数g调用时和使用两个参数调用时执行。因此，我们+:将对原始源和*-:源加倍后执行double 。

之所以有效，是因为J中两个动词的组合成为一个钩子，因此 f f执行时y f (f y)y是原始输入。另外，*-:它本身就是一个“二元钩子”，通过将*左侧arg 乘以右侧arg的一半来工作-:。左边的arg将是原始输入，右边的arg将是输入的两倍，因此这将产生原始输入的平方。

原始答案

Ĵ，15个字节

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

在线尝试！

翻倍的版本： 在线试用！

在单一版本中，我们有一个使用议程的单一动词 @.执行if ... then逻辑：如果参数等于其自身=~，则采用参数并将其加倍(+:@[)。

但是，当我们将代码加倍时，会得到一个J钩。称谓词f和输入y。然后钩f f执行如下：

y f (f y)

这意味着现在原始输入是左arg，右arg是加倍的输入。由于这些将不相等，=~因此这次将返回false，现在我们将执行议程的另一分支，即，*:@]表示“对正确的arg求平方”。并且由于~反转了二元动词的输入，因此右arg将是原始输入。

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复制输入的副本。

说明：

第一个程序的执行部分看起来像

]     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+2翻倍时）