编写一个程序，接受N到1到9之间的一个数字。2如果N是1，4如果N是2，6如果N是3，则程序应以其本机形式输出N + NEg输出。

当程序中的每个字符在适当位置被复制，那么它应该是一个程序，在N取（仍从1到9），并输出N×NEG输出1如果N 1，4如果N 2，9如果N 3，等等。

当程序中的每个字符都一式三份时，它应该是一个程序，1如果N为1，4则输入N（仍从1到9），并输出N ^ NEg输出，如果N为2，27如果N为3，387420489如果N为9，等等

不需要9以上的数字，因为10 ^ 10超出了许多语言通常的整数范围。

例

如果您的初始程序是

My_Program!
Exit();

那么它应该能够吸收N并输出N + N。

此外，该程序

MMyy__PPrrooggrraamm!!

EExxiitt(());;

应该取N并输出N×N。

最后，程序

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

应该取N并输出N ^ N。

不需要四字符程序和其他程序。

规则

• 输入和输出应为普通格式的十进制数字。您可以使用不同的底数来回答，以炫耀您的代码，但是答案是非竞争性的。

• Windows用户可以将其\r\n视为一个字符，因为类似的事情是\r\r\n\n没有意义的，甚至是行不通的。

• 以字节为单位的最短本机程序（N + N个）获胜。

果冻，12 字节

N + N

“(ẹ+)‘FQṖṪỌv

在线尝试！

N×N

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv

在线尝试！

N ^ N

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv

在线尝试！

这个怎么运作

Jelly有几种不同类型的字符串文字。所有这些都以“。如果文字包含多个“字符串，则返回一个字符串数组，并将“字符串彼此分开。

例如，“abc“def”yields ['abc', 'def']。

根据文字的最后一个字符（当前未实现的任何”«»‘’，«），可以在不同类型的文字之间进行选择。对于‘，我们在Jelly的代码页中获得代码点，而不是相应的Unicode字符。

例如，“abc“def‘yields [[97, 98, 99], [100, 101, 102]]。

程序中的三个文字与以下代码点数组相对应。

“(ẹ+)‘           -> [40, 214, 43, 41]
““((ẹẹ++))‘      -> [[], [40, 40, 214, 214, 43, 43, 41, 41]]
“““(((ẹẹẹ+++)))‘ -> [[], [], [40, 40, 40, 214, 214, 214, 43, 43, 43, 41, 41, 41]]

N + N

“(ẹ+)‘FQṖṪỌv                          Main link. Argument: n

“(ẹ+)‘                                As before.
      F                               Flatten the array. Yields an integer array.
       Q                              Unique; deduplicate the integers.
                                      This yields [40, 214, 43, 41].
        Ṗ                             Pop; remove the last element.
         Ṫ                            Tail; extract the last element. 
                                      This yields 43, the Unicode code point of +.
          Ọ                           Unordinal; cast to character.
           v                          Eval; execute the character as a Jelly
                                      program with argument n.

N×N

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv              Main link. Argument: n

““((ẹẹ++))‘                           As before.
           ‘                          Increment all integers.
            FF                        Flatten the array. Yields an integer array.
              QQ                      Unique; deduplicate the integers.
                                      This yields [41, 215, 44, 42].
                ṖṖ                    Pop twice; remove the last two elements.
                  ṪṪ                  Tail; extract the last element.
                                      This yields 215, the Unicode code point of ×.
                    ỌỌ                Unordinal; cast to character.
                      v               Eval; execute the character as a Jelly
                                      program with argument n.
                       v              Eval; convert the return value (n×n) to a
                                      string and execute that string as a Jelly
                                      program with argument n. Since the string
                                      consists of a single integer literal, that
                                      integer is returned, ignoring the argument.

需要注意的是F，Q，Ṫ，和Ọ不改变一维数组，数组没有重复，整数和字符（分别）。

N ^ N

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv  Main link. Argument: n

“““(((ẹẹẹ+++)))‘                      As before.
                ‘‘                    Increment all integers twice.
                  FFF                 Flatten the array. Yields an integer array.
                     QQQ              Unique; deduplicate the integers.
                                      This yields [42, 216, 45, 43].
                        ṖṖṖ           Pop thrice; remove the last three elements.
                           ṪṪṪ        Tail; extract the last element.
                                      This yields 42, the Unicode code point of *.
                              ỌỌỌ     Unordinal; cast to character.
                                 v    Eval; execute the character as a Jelly
                                      program with argument n.
                                  vv  Eval twice. See N×N.

> <>，41个字节

\<
1:: :
&&* +
i*n n
c&
%:
4l
0(
.i
n}
&?

在线试用产品：N + N，N * N，N 1，N。假定STDIN输入正好是一个字符。

> <>是一种2D语言，因此我们可以利用以下事实：如果向下执行指令，则代码语义几乎不变-随之而来的多余空行只是无操作。例外情况是条件蹦床?会弹出一个值，如果该值不为零，则会跳过下一条指令-多余的换行符?由于插入的无操作而变得混乱，但是我们可以通过将?末尾放在一列，并利用包装。

要确定要执行的操作，关键是40.，哪个将IP传送到位置(4, 0)。由于代码的扩展，该x = 4列对应于+基本程序，*双倍程序和^三倍程序。不幸的是，> <>没有内置幂运算，这使程序占据了大部分。

[Setup]
\         Mirror: reflect IP direction to downwards
1&        Put 1 into the register
ic%       Push a code point of input, then take it mod 12. This maps the char '1' to the
          number 1, and so forth for '2' to '9'.
40.       Jump to (4, 0), still heading downwards

[N+N version]
:+        Duplicate then add
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N*N version]
:*        Duplicate then multiply
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N^N version]
:&*&      Multiply register by N
:l(       Push (N < length of stack + 1)
i         Push input, but since we're now at EOF this pushes -1 (stack length += 1)
}         Move -1 to the back
?<        If (N < length + 1) was 1, execute the < to move leftward. Otherwise, skip it.
          (Continue loop)

\         Mirror: reflect IP direction upwards
&n        Output register
.         Jump to (-1, N), which is invalid so the program errors out

TovTovTov（ Chicken的一种变异）：810147050字节

以下是两个建议的解决方案：一个是完整的解决方案，需要大量字节，另一个是部分解决方案（仅解决N + N和N * N个部分，仅需484字节），每种解决方案均采用不同的方法，并采用不同的解决方案一套很酷的技巧！:)

1.完整解决方案（810147050字节）

使用TovTovTov(TOV='hi',SEP=',')的TOV元素免疫到位重复字符（包括"hihihi"与"hhiihhiihhii"有三个"hi"在其中S，以及所有TovTovTov关心的是如何多TOV小号之间出现SEP多个）。

如果使用SEP=', '，整个程序将不受字符重复的影响（这很酷，但不能解决问题）。所以我们用SEP=','。

所以程序"hihihi,hi"，例如，编译为所述整数数组[3,1]，而"hhiihhiihhii,,hhii"编译到[3,0,1]和"hhiihhiihhii,,hhii"到[3,0,0,1]。这意味着命令本身在复制后不会改变其含义，但是总长度会随着字符复制而变化。低于溶液查询程序的长度，并使用此来决定是否打印N+N，N*N或N^N。

建议的完整解决方案（如ints数组）是： [6, 12, 9, 18, 9, 142, 11, 38, 8, 9, 260, 11, 73, 8, 22, 75, 7, 10, 14, 3, 1, 22, 24, 18, 15, 8, 10, 16, 3, 1, 22, 24, 18, 15, 8, 10, 45, 16, 7, 22, 3, 1, 22, 24, 18, 15, 8, 22, 3, 1, 22, 24, 18, 15, 8, 25, 3, 1, 22, 24, 18, 15, 8, 48, 3, 1, 22, 24, 18, 15, 8, 277, 3, 1, 22, 24, 18, 15, 8, 3146, 3, 1, 22, 24, 18, 15, 8, 46677, 3, 1, 22, 24, 18, 15, 8, 823564, 3, 1, 22, 24, 18, 15, 8, 16777237, 3, 1, 22, 24, 18, 15, 8, 387420510, 3, 1, 22, 24, 18, 15, 8]

作为一个字符串，它是一个相当长的程序，由810147050个字符组成，开头为： hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2.仅解决问题的N + N和N * N部分（484字节）

使用TovTovTov(TOV='1',SEP=', ')，这次SEPs可以避免重复（其中",, "仍然只有一个", "），因此以下建议的解决方案即使在重复字符后也始终具有33条命令：

1111, 111111111111111111111111111111111111111111111111, 1111111111, 1111111111, 1111111111, 111111, 111111111111, 111111111, 11111111111111, 111, 1, 1111111111111111111111, 111111111111111111111111, 111111111111111111, 111111111111111, 11111111, 111111111111, 1111111111111111, 111111111111111, 1111111111111111111111, 111111111111111111111111111111111111, 11, 1111111111111111111111111111, 111111, 111, 111111, 11111111111, 111111111111111111111111111, 1111, 1, 11111111, 1, 11111111

相应的int数组（上面33个命令中的每个命令中TOVs（1s 的数量））如下：[4,48,10,10,10,6,12,9,14,3,1,22,24,18,15,8,12,16,15,22,36,2,28,6,3,6,11,27,4,1,8,1,8]

复制这些字符会产生33个完全不同的命令的列表： [8,96,20,20,20,12,24,18,28,6,2,44,48,36,30,16,24,32,30,44,72,4,56,12,6,12,22,54,8,2,16,2,16]

原来整型数组（计算N + N）的设计精心，使以后的命令变换他们的意思，节目仍然是有意义的，但计算N * N。例如，第一个字符4（将其TovTovTov理解为“将下一个op作为转换为字符的ascii代码进行处理”）在字符复制到后会更改为8，这是完全不同的命令（“将Program Counter更改为从堆栈，如果紧随其后弹出的值为true”）。

Befunge-98，38个字节

vx:k:2-k*.@
20@
j3.
>^*
>:^
>:+.@

在线尝试：N + N，N * N，N ^ N

该程序不能立即使用，因为它要求在执行开始时将输入存储在堆栈中。通过用以下代码（添加三个字节）替换第一行，它将从stdin接收输入（尽管遗憾的是，这在tryitonline.net上不起作用）：

v
&x:k:2-

说明

设定

v       Redirect motion downward
02j     Jump over two instructions/spaces, executing the third
        If N=1, it will skip to the 6th line
        If N=2, it will skip to the 5th line
        If N=3, it will skip to the 4th line

N = 1

>       Move right
:+.@    Duplicate, add, print and exit

N = 2

>>::^^  Move right, duplicate twice, move up
*.@     Multiply, print and exit

N = 3

>>>^^^  Redirect motion
30x     Set instruction pointer delta to (3, 0), causing it to
        move right, executing every third instruction
:k:     Duplicate the number (we'll call it M) M+1 times
        The stack is now [M]*(M+2)
2-k*    Multiply things M-1 times (`k' is a quirky instruction)
.@      Print and exit