基于这一挑战。

在节奏游戏osu中！，难度修改器“两次”实际上只能将速度提高50％。

您的任务是编写一个输出正偶数（大于0）的程序，当源代码中的每个字节/字符（您选择的哪个）重复时，它应输出乘以1.5的数字。

例如，如果您的源代码是ABC，并且输出6，AABBCC则应输出9。

遵循原始挑战的规则：

规则

• 您必须构建一个完整的程序。
• 初始源必须至少为1个字节长。
• 两个整数都必须以10为底（禁止以其他任何底数或以科学计数法输出）。
• 您的程序不得接受输入（或具有未使用的空输入），并且不得引发任何错误（编译器警告不视为错误）。
• 允许输出带有尾随/前导空格的整数。
• 您可能不会在源副本之间使用换行符。
• 这是代码高尔夫球，因此每种语言中最少的字节都是成功的！
• 默认漏洞适用。

我想这将比最初的挑战要简单得多，但是希望我们会看到一些创造性和独特的答案！

主塔，7 5 4字节

在TIO上选择了一种随机语言

46vt

说明：

在线尝试！

46    # Stack is [4, 6]

v     # Reverse the stack [6, 4]

t     # take top of stack 4

翻倍：

4466   # Stack is [4, 4, 6, 6]

vv     # Reverse the stack twice so it's the same [4, 4, 6, 6]

tt     # take top of stack 6 and again which is 6 again

感谢Officialaimm，节省了2个字节

Veedrac节省了1个字节

果冻，2个字节

!‘

在线尝试！

说明：

!‘ Implicit 0
!  Factorial
 ‘ Increment

翻倍的版本：

!!‘‘

在线尝试！

说明：

!!‘‘ Implicit 0
!    Factorial
 !   Factorial
  ‘  Increment
   ‘ Increment

LibreOffice Calc，8个字节

=A2+3
19

将其另存为*.csv，然后在LibreOffice Calc中将其打开。您将在A1中获得22分。

将它们加倍：

==AA22++33

1199

您将在A1中获得33

MATL，3个字节

TnQ

在线尝试！或翻倍的版本。

说明

在MATL中，标量值（数字，字符，逻辑值）与包含该值的1×1数组相同。

普通版：

T    % Push true
n    % Number of elements of true: gives 1
Q    % Add 1: gives 2

翻倍的版本：

TT   % Push [true, true]
n    % Number of elements of [true, true]: gives 2
n    % Number of elements of 2: gives 1
Q    % Add 1: gives 2
Q    % Add 1: gives 3

vim，5岁

i1<esc>X<C-a>

不加倍：

i1<esc>  insert the literal text "1"
X        delete backwards - a no-op, since there's only one character
<C-a>    increment, giving 2

加倍：

ii11<esc>   insert the literal text "i11"
<esc>       escape in normal mode does nothing
XX          since the cursor is on the last character, delete "i1"
<C-a><C-a>  increment twice, giving 3

不确定此答案是否有效。只要在这里发布，以防有​​人从这里得到想法。

具有-p标志的Node.js，7个字节

由亚历克斯·瓦尔加：

3/3*22

33//33**2222

带有-p标志的Node.js，11个字节

旧的：

3*2*0/1+22

33**22**00//11++2222

输出22和33。

Python 2 REPL，11个字节

(3/1)*(2/1)

这仅计算为3 * 2 = 6。复制，是

((33//11))**((22//11))

计算得出3 ** 2，即3的2的幂或9。

APL，7个字节

⊃⍕⌊3×⍟2

印刷品2。

⊃⊃⍕⍕⌊⌊33××⍟⍟22

印刷品3。

在线尝试！

Waaat？

单：

3×⍟2         → 2.079441542  ⍝  3 * ln 2
⌊2.079441542 → 2            ⍝  floor
⊃⍕           → '2'          ⍝  format and take first character

双：

⍟⍟22          → 1.128508398  ⍝  ln ln 22
×1.128508398  → 1            ⍝ signum
33×1          → 33           ⍝  33 * 1
⌊⌊33          → 33           ⍝  floor
⊃⊃⍕⍕          → '3'          ⍝  format and take first character

实际上，3个字节

1u*

在线尝试！

说明：

1u* Errors are ignored
1   Push 1
 u  Increment
  * Multiply

翻倍的版本：

11uu**

在线尝试！

说明：

11uu** Errors are ignored
1      Push 1
 1     Push 1
  u    Increment
   u   Increment
    *  Multiply
     * Multiply

CJam，4个字节

],))

正常尝试！

尝试加倍！

说明

正常：

]     e# Wrap the stack in an array: []
 ,    e# Get its length: 0
  ))  e# Increment twice: 2

双：

]         e# Wrap the stack in an array: []
 ]        e# Wrap the stack in an array: [[]]
  ,       e# Get its length: 1
   ,      e# Get the range from 0 to n-1: [0]
    )     e# Pull out its last element: 0
     )))  e# Increment 3 times: 3

05AB1E，2个字节

X>

在线尝试！

说明：

X> Only top of stack is printed
X  Push X (default 1)
 > Increment

翻倍的版本：

XX>>

在线尝试！

说明：

XX>> Only top of stack is printed
X    Push X (default 1)
 X   Push X (default 1)
  >  Increment
   > Increment

Neim，2个字节

𝐓>

在线尝试！

说明：

𝐓> Implicit 0
𝐓  Factorial
 > Increment

翻倍的版本：

𝐓𝐓>>

在线尝试！

𝐓𝐓>> Implicit 0
𝐓    Factorial
 𝐓   Factorial
  >  Increment
   > Increment

Pyth，3个字节

he1

在这里尝试。

说明：

he1
h   Increment
 e   Last digit
  1   1

翻倍的版本：

hhee11

在这里尝试。

说明：

hhee11
h      Increment
 h      Increment
  e      Last digit
   e      Last digit
    11     11

R，11个字节

8*(!0)+1*!1

在线尝试！

!是取反，**是幂（的别名^）。数字将转换为booleans：0到FALSE，其他所有转换为TRUE。布尔地转化为整数：FALSE对0，TRUE对1，所以!0==1，!1==0，!!00==0和!!11==1。

$8\times 1 + 1\times 0=8$$88^0+11^1=12$

Cubix，6个字节

O.1)W@

印刷品2。

  O
. 1 ) W
  @

推动1，)递增，W向左跳转至O输出2，并@完成程序。

加倍，显然是OO..11))WW@@，在多维数据集上是：

    O O
    . .
1 1 ) ) W W @ @
. . . . . . . .
    . .
    . .

它按下1两次，)增加两次，W再次跳到左边，然后将其放在O向北的右边，输出3，然后下一个命令@终止该程序。

在线尝试！

在线翻倍！

克莱因，8 6字节

/3+@4\

单人，双人

说明

对于单一程序，程序遵循非常简单的路径。第一个镜像将其偏转到第二个镜像，第二个镜像将其偏转4到程序的末尾。

双重有点复杂。这里是：

//33++@@44\\

前两个镜像的工作原理相同，但是由于加倍，因此出现了一个新镜像，它将ip偏转回开始，它被第一个镜像的副本捕获并向末端偏转。运行的全部是，33++结果为6。

TI基本，3个字节

单：

int(√(8

最后一个表达式是在TI-Basic中隐式返回/打印的，因此可以打印 2

翻倍：

int(int(√(√(88

退货/打印3

TI-Basic是一种标记化语言；int(，√(和8分别是内存中的一个字节。

Ruby REPL，8个字节

";3#";22

REPL仅打印最后评估的值：22。

翻倍：

"";;33##"";;22

这次33是最后评估的值。该字符串将再次被丢弃，并且a #开始注释。

> <>，19 8字节

32b*!{n;

打印22
在线尝试！

说明：

32b   push literals onto the stack: [3,2,11]
*     multiply the top two values: [3,22]
!     skip the next instruction
{     (skipped)
n     pop and print the top value from the stack (22)
;     end execution

翻倍：

3322bb**!!{{nn;;

打印33
在线尝试！

说明：

3322bb push literals onto the stack: [3,3,2,2,11,11]
**     multiply top values (twice): [3,3,2,242]
!      skip next instruction
!      (skipped)
{{     rotate the stack to the left (twice): [2,242,3,3]
nn     pop and print the top two values from the stack (33)
;      end execution

旧版本：
普通：

11+!vn;
    n
    ;

打印2
在线尝试！

说明：

1    push 1 on the stack: [1]
 1    push 1 on the stack: [1,1]
  +    add top two values of the stack: [2]
   !    skip the next instruction
    v    (skipped)
     n    print the top value of the stack (2)
      ;    end execution

翻倍：

1111++!!vvnn;;
        nn
        ;;

打印3
在线尝试！

说明：

1111    push four 1's on the stack: [1,1,1,1]
    +    add top two values of the stack: [1,1,2]
     +    add top two values of the stack: [1,3]
      !    skip the next instruction
       !    (skipped)
        v    change direction of execution (down)
         n    print the top value of the stack (3)
          ;    end execution

Zsh，14个字节

<:|echo 22
3
:

在线尝试！

要获得一种使用非在线语言的完整程序来打印任何源代码重复的东西，这是一个挑战。Zsh对此非常有用，因为文件和heredocs被隐式传递给cat。让我们看一下两种情况下的第一行：

<:|echo 22            # Give the file : on stdin to cat. cat pipes to 'echo 22', which ignores stdin
<<::||eecchhoo  2222  # Start heredoc on following lines with EOF string '::', pass to cat.
                      # Since cat exits 0, 'eecchhoo 2222' is not executed

只要3不是程序，第一个程序只会打印22。第二个程序将打印33出来，并带有多余的换行符（由于重复）。

如果3是函数/程序/别名，则此18字节的解决方案仍然有效！

<:|echo 22\\c\
3
:

在线尝试！

最后\是行继续，因此换行符被丢弃，有效地使echo语句 echo '22\c3'。的\c原因回声停止打印后22（这也恰好抑制换行）。

Perl 6、14个字节

'|d 3#';say 22

在线尝试！ 尝试加倍！

这使用方便命名的调试功能dd将加倍的程序输出到STDERR。为了分离逻辑，我们将加倍的程序用引号引起来，然后将加倍的程序互相抵消，并加上注释字符#以注释掉现在无效的普通程序。

Stax，3个字节

UJ^

运行并调试

运行并调试加倍的代码

U推-1。 J方块。 ^增量。

MathGolf，2个字节

▬)

在线尝试！ 尝试加倍

与其他答案类似，第一个指令1在加倍时产生偶数，第二个指令将其递增。在这种情况下，我使用了逆幂运算（0**0 = 0**0**0 = 1），但它也可能是任何!£≤°指令，甚至可能是我错过的更多指令。

Japt，2 个字节

另一个“阶乘+1”解决方案。

ÊÄ

测试一下

ÊÊÄÄ

测试一下