您的任务（如果希望接受）是编写一个输出正整数（大于0）的程序。如果源代码重复，则输出必须保持不变。棘手的部分是，如果源代码键入了三次（三倍？），输出将乘以3。

规则

• 您必须构建一个完整的程序。也就是说，您的输出必须打印到STDOUT。

• 初始源必须至少为1个字节长。

• 两个整数都必须以10为底（禁止以其他任何底数或以科学计数法输出）。

• 您的程序不得接受输入（或具有未使用的空输入）。

• 允许输出带有尾随/前导空格的整数。

• 仅当位数一致时才允许前导零，例如：001-001-003或004-004-012

• 您可能不会在源副本之间使用换行符。

• 这是代码高尔夫球，因此每种语言中最短的（原始）代码胜出！

• 默认漏洞适用。

例

假设您的源代码为，Abc并且其对应的输出为4。如果我AbcAbc改为编写并运行它，则输出必须仍然是4。但是，如果我编写AbcAbcAbc并运行它，则输出必须为12。

无耻地被盗源于Xcoder先生的挑战

Wumpus，6个字节

{~)
@O

在线尝试！
尝试加倍！
尝试三倍！

打印1和3。

说明

我通过强力搜索找到了很多6字节的解决方案，但5字节没有找到。这不一定意味着在5个字节上没有任何字符，但是它们可能会使用奇怪的字符或其他内容。

我最终选择了这个解决方案，因为它不打印任何前导零（大多数都打印），并且它具有一些有趣的控制流。让我们从一个程序开始：

所以执行的代码是：

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

很简单。现在加倍程序。由于第一行被追加到第二行，因此网格扩展到宽度5（和高度3），这将显着改变控制流：

IP恰好绕过该循环一次，因此执行的代码为：

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

最后，三倍程序与双倍程序非常相似，但是我们在第三行上获得了一些更重要的命令：

所以执行的代码是：

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

外壳，5个字节

KΣK+1

在线尝试！

重复两次！

重复三次！

说明

在Husk中构造一个可重复的程序是非常困难的。由于类型系统禁止可应用于自身的函数，因此我必须以某种方式允许第一部分对函数求值，而其余部分对值求值，而现有内置类型的目的是为了防止这种情况的发生。有点模棱两可。该程序的令牌是

• K，它构造一个常量函数。K a b等同于a。
• Σ，它采用整数n并返回第n个三角数。
• +，将两个数字相加。
• 1，即文字1。

原始程序的解释如下：

   K Σ (K+) 1
== Σ 1
== 1

这(K+)是一种无意义的功能，被第一个功能所吞噬K。

两次重复的程序的解释如下：

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

括号中的函数再次被第一个吃掉K。

三次重复程序的解释如下：

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

果冻，7 5字节

»‘µ*Ḃ

在线尝试！

尝试加倍！

尝试三倍！

这个怎么运作

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell，24个字节

main=print.div 3$4
 -1--

打印1：在线尝试！

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

同时打印1：在线尝试！

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

打印3：在线尝试！

Cubix，5个字节

)<@OP

在线尝试：一次，两次，三次。

说明

Cubix是一种基于堆栈的语言，其指令被包装在多维数据集的外部。需要注意的重要一点是，堆栈最初填充了无限零，这使我们可以通过运算符“凭空抽出值”，而不是显式地推入它们。

我必须承认这是蛮力发现的。我永远不会独自找到它。实际上，@ MartinEnder是要求我尝试暴力破解的人，因为他一直在寻找这种没有运气的解决方案。这是蛮力找到的唯一解决方案，我相信这是Cubix中唯一也是唯一的解决方案。

单程序

观看它运行！

原始程序适合单位多维数据集。这是展开的网：

  )
< @ O P
  .

IP（指令指针）从<朝东的最左面（）开始。将<立即指向它西面，它会回绕到P。P是幂运算，并且由于堆栈上没有任何内容，因此解释器提取两个0，并计算出0 ⁰，根据JavaScript 值为1。O然后打印此值，并@结束程序。

双重程序

观看它运行！

)<@OP)<@OP

10字节的程序太长而无法容纳单位多维数据集，因此将其扩展为大小为2的多维数据集：

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

和以前一样，IP从最左侧的左上角开始。这次，第一个指令是P，它像以前一样推1。下一个是)，它使最上面的项目递增，将其变成2。然后<将IP转过来，然后)再次命中，将2转换为3。

这就是有趣的地方。P将自上而下的第二项提高到第一项的功效，得出0 ³ = 0。然后，IP绕到最右边的一面并经过两次无操作，.然后再击中另一个P。在这里，我们看到了Cubix的另一个怪癖：二进制运算符（例如P）不会从堆栈中删除其操作数。因此，由于堆栈现在为[3, 0]，我们计算3 ⁰ = 1，该O输出输出并@终止程序。

三重程序

观看它运行！

)<@OP)<@OP)<@OP

与double程序一样，triple可以放在2号立方体上：

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

该程序以与以前相同的方式开始：P按下1，)递增，<将IP指向西，)再次递增，然后P按下0。然后，将IP包裹到<最右边的，因为IP已经指向西，所以它什么也没做。

这是与double程序的一个区别：将栈顶)的0递增为1。当P再次执行其魔术时，这次它将计算3 ¹ = 3。O输出并@终止，我们最终证明了第三次确实是魅力。

Brain-Flak，10个字节

<>([]{}())

在线尝试！

尝试加倍！

尝试三倍！

说明：

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

当我们运行一次时，它将放入(0 + 0 + 1) == 1备用堆栈。再次运行，将其放入主堆栈。但是，如果第三次运行，它将求值为(1 + 1 + 1) == 3，并将其推入备用堆栈并隐式打印。

SQL，25 24 23字节

（-1字节 删除错误输入字符总是注释掉，无所事事）
（-1字节 改为SELECT以PRINT所推荐的勒兹万Socol）

PRINT 2/*
*2+1--*/-1
--

工作原理：
在SQL中，您可以注释掉注释标签，如下所示：

/*
'Comment'--*/

与

--/*
'Not Comment'--*/

1行代码，不包含注释：
第一次迭代：SELECT 2-1输出：1
第二次迭代：SELECT 2-1*2+1输出：1
第三次迭代：SELECT 2-1*2+1*2+1输出：3

SOGL V0.12，7 5 4 个字节

ē»«I

在这里尝试！

尝试加倍！

尝试三倍！

说明：

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E，6 5字节

.gDÈ+

在线尝试！ 或尝试加倍！或尝试三倍！

说明

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

单人：0 + (0 % 2 == 0) -> 1
双人：1 + (1 % 2 == 0) -> 1
三人：2 + (2 % 2 == 0) -> 3

> <>，9个字节

\5 n;
\\1

在线尝试！

尝试加倍！

尝试三倍！

我发现这样的运气很不错，它的哲学是“如果使鱼的路径曲折得足够多，那么最终就会起作用”。原始版本和加倍版本打印出5，而三倍打印出1，然后打印5，使15 = 3×5。以下是乘数版本，供您仔细阅读：

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2中， 46 45  39个字节

受到哈佛答案的启发。我很高兴我的挑战激发了新的挑战，我发现它更加有趣。感谢Kevin Cruijssen保存了6个字节。

print open(__file__,"a").tell()/79*3|1#

在线尝试！

尝试加倍！

尝试三倍！

工作方式（已过时）

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

倍增后，长度变为90，但是由于，新代码将被忽略#，因此k==90计算为True。布尔值是Python中整数的子类，因此k>>True等效于k>>1，其本质上是k / 2 = 45。当它增加三倍时，新代码将再次被忽略，因此新长度为135，因为k==90计算为False，so k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k和k不变，所以新长度不会移位。

Python 2，36个字节

这是艾丹·皮尔斯（Aidan F. Pierce）提出的38字节的建议，我打了2字节。我没有将其发布为主要解决方案，因为我自己没有提出。

0and""
True+=1
print True>3and 3or 1

在线尝试！ 尝试加倍！ 尝试三倍！

R，37 31 28字节

感谢朱塞佩（Giuseppe）打高尔夫球的最后3个字节。

length(readLines())%/%2*2+1

（以换行符结尾）。

尝试一次！

尝试两次！

尝试三次！

它使用了readLines()招由朱塞佩的答案8球的挑战，其中stdin重定向到源文件。这段代码基本上只计算第一行下面有多少行，1如果有1或3行（即代码是单行还是两倍），或者3有5行（即代码是三倍），则输出。

丢失，38个字节

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

在线尝试！

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

在线尝试！

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

在线尝试！

说明

迷失是应对这一挑战非常有趣的语言。通常的“丢失”技术是建立“陷阱”。陷阱是程序的一部分，旨在将所有ip捕获到一个位置，以便可以清除它们的堆栈，并可以控制它们沿特定方向移动。这使得在《迷失》中编写程序更加易于管理。但是，由于该程序是重复的，因此我们也需要避免陷阱重复。这就要求我们设计一个新的陷阱，该陷阱可以正常工作，但是当复制时，只有一个陷阱起作用。我的基本想法如下

v<<<<>
>%?!^^

当堆栈为非空时，?它将删除一个项目，如果该项目为非零，则会导致其跳回开头。这里的关键是，当它堆叠^^s线时

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

这意味着无论您如何输入，都将始终在同一位置退出。

从这里我们可以尝试从我的克莱因答案中实施相同的想法。

\\<<<<<v<<<<>
2>((1+@>?!^%^

我们程序的主干是向左推动数2s的一侧。每次我们添加该程序的副本时，2都会将另一个副本添加到该程序的主干中，这意味着将另外的2个推入堆栈。一旦脱离底部，它就会反弹\\>并执行代码

((1+@

这将删除前两个堆栈项，将一个添加到剩下的任何项，然后退出。一旦主干有3个2，我们将加1并得到3，如果我们有少于3个项目，我们将丢弃整个堆栈并返回1。

现在剩下的唯一问题是!程序中的in会导致无限循环。如果ip开始!向上移动，它将跳跃并直接回到原来的位置。这意味着我们必须在下面添加另一行以防止循环。

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

这有一个小问题，^就是在陷阱之间添加一些斜线。然而，奇迹般地，一切顺利。我们的ip会正确反弹，以至于不会改变。

Stax，5个字节

|dhH^

在线运行和调试！· 加倍 · 加倍

说明

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C（gcc），95 91 85字节

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

在线尝试！

Japt，8 6 5字节

-1个字节感谢@ETHproductions

°U-v

说明：

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

这评估为 1-0 = 1

加倍计算为 2-1 = 1

三倍评估为 3-0 = 3

纯Bash（否wc或其他外部工具），27

trap echo\ $[a++&2|1] EXIT

• 尝试一次。
• 尝试两次。
• 尝试三次。

Perl 5中，18个 15 13 12 11字节

-3字节归功于nwellnhof

say 1|
+.7#

一旦在线尝试！

两次在线试用！

三次在线尝试！

> <>，10 9 8字节

562gn|

在线尝试！

尝试加倍！

尝试三倍！

我确定那里有8字节的解决方案。

最后的unprintable具有ASCII值1，并且仅g在第三次迭代中由et命令获取。对于前两个，它先打印05，然后再打印15。

C（gcc），107个字节

我的第一个C语言（gcc）。太久了...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

TIO链接：单，双，三。

迷宫，12 11 9字节

：＃％！@
 7

TIO（1x），TIO（2x），TIO（3x）

JavaScript，81 77 74 70字节

^{由于Shaggy节省了4个字节}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

相当la脚的JS解决方案。[3,1,1]从右侧（pop()）消耗数组中的值。注册超时以显示将来的当前值。如果已经注册超时，请取消超时。依靠的肮脏性质var，它会提升变量声明。

两次：

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

三次：

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C（gcc），53 52字节

注意后面的空格#endif。

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

在线尝试！

木炭，12字节

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

在线尝试！链接是详细代码。

尝试加倍！

尝试三倍！

说明

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript，43 40字节

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2倍：

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3倍：

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell，54 48 45 44字节

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

在线尝试！

尝试加倍！

尝试三倍！

都有自己的调用路径与$PSCOMMANDPATH和执行gET- c上的文件ontent。If该文件的字符数小于99（通过wc -ccoreutils 检查），然后我们输出1和exit（即停止执行）。这说明了原始代码和加倍的代码。否则，我们输出3并退出。两倍或三倍部分中的实际代码是没有意义的，因为我们要么exit先了解它，要么在注释后面#。

Xcoder先生节省了6个字节Pavel
节省了3个 4字节

C＃（178字节）

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

疯狂的C＃解决方案，但我很高兴在C＃中完全可以在一行中完成。:)

对我而言，最困难的部分是拥有有效的C＃，该C＃可以初始化或递增相同的变量，因此我最终滥用ConfigurationManager，因为我需要一个全局静态NameValueCollection，并且我想到的唯一的ConfigurationManager是可以在内存中更新的。我喜欢的另一个选项是EnvironmentVariables，但它没有索引器，因此我不确定如何在一行中执行此操作，可以将其复制粘贴以生成符合规范的所需输出。

符文附魔，35字节

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

在线尝试！

处理这个问题使我可以在解析器中发现一个与新的延迟修饰符有关的错误，尽管最终结果最终不受其影响，因为我最终不需要它们。

由于最后一行没有尾随换行符（或就此而言，尾随空格）这一事实而起作用，从而允许重复的IP在不同的位置生成。左上角的一个最终在网格周围形成一个大循环，而第二个IP执行反射操作以用替换\第6行上的。然后，此IP将永远循环，并且不执行任何操作。

第三个IP也同时进行了相同的替换，但是由于它位于第13行，因此该反射器的副本将其向上发送，并执行1f'3w右上角的序列，第14个1由a 替换3行，恰好在原始IP执行之前，导致输出三倍程序3而不是输出1（值也可能是2和6，3和9，4和12，或5和，15因为a-f数字常数的可用性；1并且3是任意选择的）。然后将其置于无尽的循环中，执行更多的无反应的反射命令。

重复三次！

Perl 5中，28 25个字节

-3个字节，感谢@neil！

print"\e[D$a"if(++$a!=2);

向后移动光标（在行的开头不执行任何操作），并$a第一次和第三次打印值（即，第三次打印a 1，光标移动，并且在1的位置打印3）。

QBasic，19个字节

CLS
x=2^x
?x-1OR 1

源应包含尾随换行符。

说明

我们希望的输出1，1，3。请注意，这些数字比2的幂小1。因此：

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.