选择您的语言支持的任何五个字符。有5个！= 5×4×3×2×1 = 120种方式可以将它们排列成5个字符的字符串，每个字符包含一次；120 个排列。

选择您的字符，以便在使用您的语言运行120个字符串中的每个字符串时，所产生的120个输出将是从1到120（含）之间尽可能多的唯一整数。

也就是说，对于产生可运行代码并输出一个数字的5个字符的120个置换中的每一个，您都希望所有这些数字的集合尽可能与1到120的整数集合匹配。

因此，理想情况下，你的第一个置换将输出1，下2，下3，一路最多120。但是对于大多数语言和字符来说，这种理想可能是不可能的。

5个字符的字符串可以按以下方式运行：

• 没有输入的程序
• 没有参数的函数
• 一个REPL命令

如果需要，可以以不同的方式运行不同的字符串

为了使输出计数，按常规方式，它必须是单个整数输出，例如：

• 被打印到标准输出
• 由函数返回
• REPL表达式的结果

该代码应正常终止（只要先输出该数字，就可能会出错）。根本不运行的代码很好，只是（不存在的）输出不计算在内。除非您的语言使用其他基数，否则输出的数字应为十进制。

该提交产生了从1到120获胜的最明显的数字。如果出现平局，则较早提交的文件将获胜。

笔记

• 您的5个字符并不需要都相同，但是，当然，重复的字符会减少排列的有效次数。
• 浮点输出，例如32.0count以及plain 32。（但32.01不会。）
• 前导零，例如032count和plain 32。
• 有效输出应该是确定性的，并且是不变的。
• 我们正在处理字符，而不是字节。

例

123+*对于Python（或许多语言）的REPL ，字符是合理的首选。产生的120个排列和输出为：

123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a

生成了36个数字，幸运的是，这些数字在1到120之间：

36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63

但是，其中只有8个是唯一的：

36, 26, 7, 5, 23, 32, 63, 62

因此，此类提交最多只能在满分120分中获得8分。

Python3，21个 27值

字符： 3479%

唯一编号： [1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]

根据要求，以下是排列在[1，120]范围内的排列。在线尝试！

347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9

05AB1E，27 38 41个号码

4·>Ìn

生成唯一编号：

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]

采用常量4与操作+1，+2，*2和^2。

Python，18个数字

237#-

产生有效结果：

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

编辑：我可以证明TuukkaX的解决方案最适合Python。我运行了以下代码，对5个可打印ASCII字符的所有可能组合进行了强制处理：

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

结果（对于近7小时的运转后）表明，最佳解决方案是实际上27个不同的数字，由三个不同的解决方案都使用四个数字以及mod（生产%）： %3479，%5679和%5789。

爪哇8，2个 4个数字

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

我们不期待Java的答案吗？

这是一个lambda，只能以两种方式（以及任意两个不同的数字！）中的一种进行排列，总共有两个唯一数字。其他所有内容都不是有效的lambda。

感谢评论的帮助，实际上改善了答案！没看到0无效，并且忘记了变量，您可能知道多个字符。我们有4个！

更糟糕的解决方案

()->1

但是，好的一面是，Java有两个独特的答案！

果冻26 30 32

‘’3²Ḥ

这个（和它的字谜）是完整的程序，不需要输入，并在标准输出上产生输出。

如果您要求120个程序的输出生成程序的排列，则它们按照Jelly生成它们的顺序排列：

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

如果仅按数字顺序获取唯一输出，则会得到：

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

其中许多都太小，而135又太大，但是仍然有32个在范围内。

基本思想是使用大多数单子指令（在仅具有单子和尼拉德的程序中，这些指令仅会转换先前的输出），并且使值快速变化。例外是with 3，它是零差（常数值为3）。如果它出现在程序的开始，则所有操作将从3开始。如果它出现在中间，则将程序分成两半，每个半均输出一个整数（并且它们分别打印为标准输出，结果最终被连接起来，从而使我们可以“连接”作为生成数字的附加操作）。

在程序生成它们的上下文中，我们在此处执行的操作是：增量；减量 常数3; 广场; 再加倍 不幸的是，增量和减量是相反的，而不幸的是，减量在第一部分倾向于产生-1或-2（因此导致整体为负数），但是与我尝试过的其他方法相比，这仍然提供了更大的输出范围。特别是，我们可以很好地分散数字的前半部分和后半部分（请注意，如果3程序中的第一个字符，则前半部分可以是空字符串）。

JavaScript，27个数字

与TuukkaX的答案非常相似，带有另一组数字。

5789%

27个不同的值是：

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87

Brachylog，26位数字

3+*^-

这将输出以下数字： [2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]

说明

• 3 显然是3。
• + 是增量
• * 是两倍
• ^ 是正方形
• - 递减

在很多情况下，程序会简单地出错：例如，*+^3-由于要求“取0，加倍，加倍，平方，该平方的结果为3，递减”而出错，这显然是错误的。

以结尾的任何程序3都将输出3或不工作。

任何开头的程序*3都将由于错误而无限循环（Brachylog试图查找子列表列表，其结果为3，这是不可能的）。

Vim，16个数字

i1234

打印

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

IA-32机器代码，8个数字

十六进制字节值：

2c 40 48 b0 c3

该代码作为一个函数运行，返回中的值al。

有效排列：

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

我进行了蛮力搜索，但有以下限制：

• 第一个字节是b0-初始化al寄存器
• 最后一个字节是c3-return; 以下字节被丢弃
• 可能的操作码字节为：
  • 0x04- add
  • 0x0c- or
  • 0x24- and
  • 0x2c- sub
  • 0x34- xor
  • 0xd4- aad
  • 0x40- inc
  • 0x48- dec

这仅留下3个可变字节，最多可能有15个结果。其中，最多可以区分9个（实际上，这仅发生在一组字节中！）。其中一个值超出范围，因此剩下8个值。还有另一组字节

34 40 48 b0 c3

它也提供8个不同的值-程序相同，除了用sub代替外xor，使两个可能的输出相同。

所有其他字节集给出7个或更少的可能结果。

果冻，33个数字

Ḥ23+c

Ḥ双（左）;
2字面量2;
3字面3；
+添加（左，右）; 和
c选择（左，右），即许多方式可供选择左边对象的集合就是对象。

一个示例程序产生的数字：

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

我尝试选择易于解析的解析器，但是其中一些解析很少，有些奇怪，例如23：

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

...并72和13使用隐式印刷：

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

请注意，Ḥ34+c还会在中生成33唯一值[1,120]。

脑爆裂 1

(())#

Brain-Flak需要大括号，因此仅当其中一个字符开始注释时，一个5字符的程序才有效。这给我们留了四个字符。其中必须有2个(，)否则任何东西都不会被压入堆栈。那些评论必须放在第一和第四，最后是（(..)#）。现在我们可以把()，{}，<>，或[]里面。{}，，<>和[]每个取值为0，但()均为1。这意味着这(())#是产生有效Brain-Flak程序的唯一5个字符串。

在线尝试！

如果问题是“ 6个最有力的角色是什么”，答案将是(){}[]Brain-Flak仅使用此子集来完成学习。

六角形，13个数字

)24!@

这些是13个可打印的数字，每个数字都有一个可能的程序：

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

这些程序应该是不言自明的。@终止程序，!打印当前值，对其进行)递增，2然后4将自身附加到当前值（初始值为0）上。源代码的实际六边形布局与此处无关，可以简单地从左到右读取程序。

这应该是最佳的，但不是2和4你可以选择任何一对数字x和y这样2 ≤ x ≤ y-2。

上面的解决方案是通过（几乎穷举）蛮力找到的，需要一个!（否则，它就不会打印任何东西），一个@（否则，程序将不会终止），并用来自（以下字符集：

#[]\/_|<>)!0123456789$

我看不到其他命令如何可能产生更多变化。

Perl，27个数字

3479%

Perl没有内置的REPL，因此可以re.pl从Devel :: REPL使用。

结果：

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

使用以下程序强行使用：

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}

R，15 18个数字

这不是一个很大的数字，但是用R可能是最好的选择。我搜索了digits 0..9，运算符+ - * / ^和comment char的所有组合，#随后的八个都输出了1到120之间的18个唯一整数。

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

举一个例子-#146。这是我们可以获得的18个整数：

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

如果您对用于测试所有可能组合的（丑陋的）代码感到好奇，那就是。对于每个长度为5的字符组合，它将在1和120之间的唯一整数的数量输出到当前工作目录中名为“ datafile”的文件中。

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)

八度，18

这是通过对符号的蛮力搜索发现的*+-/0123456789:;<\^|~%。但是计算时间太长了...

-139%

可能的输出：

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93

八度，15个数字

没有什么可夸耀的，但这是我可以在Octave中获得的最好的结果：

124+%

它给出了数字：

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

我也有16岁，但似乎与Sefa的答案相同...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43

PHP，15个数字

1230\r

使用php逐字打印其标签之外的任何内容的事实（不使用此功能，您可以使用精确地将1做为数字<?=1;）。也使用实际的回车符而不是\r。

创建（已排序，已删除的前导0）：

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

有效的唯一编号为：

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120

库比克斯，7个数字

"2)@O

输出以下数字：

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

任何有效的Cubix程序都必须具有O输出整数和@终止程序的功能（Cubix从未听说过“错误”）。这使我们可以使用3个字符来产生最多的输出。此外，由于Cubix在多维数据集上排列代码的方式，除非其他字符中的一个是定向字符，否则第一个字符将无用。

我发现生成多个数字的最有效方法是使用"将一串字符代码推入堆栈。通过仔细的重新排列，我们可以在最后一个位置容纳几个字符，并简单地输出它们的字符代码。通过使用)递增顶部项，我们可以从其中的几种排列中创建额外的输出。

这里使用两种基本程序类型。首先是这样的：

"2)O@

扩展到

  "
2 ) O @
  .

生成的程序压2入堆栈，用递增，用)输出O，并用终止@。

第二个是这样的：

2")O@

扩展到

  2
" ) O @
  .

将得到的程序推的炭码)，O以及@，增加最后一个与)，具有输出O和与终止@。

> <>，6个数字

凭借Teal Pelican获得了2个数字

1ln";

产生唯一的数字 [1, 4, 5, 49, 59, 108]

我们需要n打印一个数字。
我们需要;终止。

剩下的只有3个字符。

几个不同的value＆operator组合可"确认产生6个唯一值，但我发现没有比这更好的了。

Groovy，10个数字

Man JVM解决方案对此很不利...谁知道？

1200+

结果是：

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

等一下 你问这到底是怎么回事17？

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

商业秘密，在Groovy / Java中以0开头的整数是八进制。如果有人想击败我，我用于测试Groovy答案的代码：

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();​

MATL，15个数字

0123%

% 是注释运算符，因此它将在所有可能的位置“剪切”一次，从而帮助创建给定数字及其子集的所有可能组合：

1
2
3
10
12
13
20
21
23
30
31
32
102
103
120

J，16个数字

1234]

没什么花哨的，只是1234用所有合理的1个字符的动词进行了测试。]选择正确的参数。

产生的唯一数字是

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

其中16：

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

在[1,120]范围内。

经过测试

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'

Japt，41位数字

只是反复试验，所以可能会有更好的解决方案。使用整数3＆4和Japt快捷方式进行平方，加法1和乘以2。所有120个程序输出一个整数，>0但是只有78个输出，<=120而其中只有41个是唯一的。

34²ÄÑ

生成数字：

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

查看号码列表或有效程序的集合

说明

与Japt有关的一些注意事项如下：

1. 如果程序不是以（在这种情况下）一个数字开头，则第一个输入变量U（默认为0）会自动插入开头，
2. 如果两个数字中的一个或两个数字立即跟随其中一个数学运算的快捷方式，则会将它们附加到该数字上（例如3Ä4 = 3+14 = 17，类似地，4Ѳ = 4*2**2 = 16），并且，
3. 如果其中一位紧随²其后，则²以及之前的所有字符都会被忽略。

几个节目（生产的解释1，3，37和93分别）：

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄѲ3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3IJ  :Multiply 4 by 23 and add 1 squared

Befunge，11个数字

Befunge受到一些限制，因为它仅支持一位数字文字。因此，假设计算必须使我们只剩下一个且只有一个数字，那么我能想到的最好是11个数字。

最佳角色： 358*%

生成的数字：（每个仅一个示例）

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24

Python，16个数字

1234#

使用＃注释掉所有不必要的数字。

dc，19个数字

*3zO+

输出位于堆栈顶部，错误（包括堆栈下溢）将被忽略。有效排列为：

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

这是我用来显示这些结果的Python程序：

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

给出相同分数19的另外两个字符串是32d+*和*4zO+。

Smalltalk，26个号码

1235r

说明：12r35是使用基数12的符号，因此为3 * 12 + 5。
可以在Squeak中验证：

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

给出：

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

如果我们将最后一行替换为：

    sorted: #value ascending)

然后我们得到表达式：

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

我想作弊并在Integer中定义方法r为

Integer>>r
    ^self \\ 120 + 1

不幸的是，编译器在1235r上斩波，因为它可以识别未完成的基数，而不是发送给1235的消息
。

Mathematica，16个数字

;1234

不是很有趣，但是使用算术似乎找不到更好的方法。那唯一可能的工作是使用!的阶乘或双阶乘，但这是如此容易产生庞大的数字，这是不可能的蛮力。

从上述5个字符可以生成的16个数字（范围内）是：

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

符文附魔，19数字

234p@

本质上是3个文字，pow运算符和一个“打印整个堆栈并终止”命令。234p@打印812（3 ^ 4与2并置）。 完整排列列表，请注意@已替换为ak@，以便在每个结果之间生成换行符，并>添加了，以确保每行独立执行。还要注意，输出与生成它们的程序的顺序不同（因为某些程序可能会更快终止）。

许多排列不会打印任何内容（例如@234p或p234@），但19的确会在允许范围内输出。

可能的数字（以及产生结果的可能程序；.指示这些位置可能是未执行的其余任何字符）：

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94

TI-BASIC，12个数字

23+4!

很有可能是更好的组合，但是我找不到。

所有 $24$ 有效排列如下：

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

其中有 $12$ 唯一值：

$10,11,16,26,30,36,45,47,48,51,56,74$