有40点的方式定向汉弥尔顿路径可以设置在3×3的网格：

该图形（感谢SP3000！ ）仅示出了20条无向路径。在两个方向上遍历每条彩色线，以获得40条有向路径。

挑战

仅使用可打印的ASCII，编写一个3×3的字符网格，例如：

ABC
DEF
GHI

当从该网格中读取40个有向路径中的每一个作为40个单行9个字符的程序时，目标是使每个程序输出从1到40的唯一整数。对所有 40条路径执行此操作似乎很困难，而且不太可能，因此，您只需要使它适用于尽可能多的路径即可。

提交者的40个路径程序输出的数字从1到40最为不同。Tiebreaker转到了较早的提交。

错误或不输出从1到40的整数或输出已经覆盖的另一个路径程序的整数的路径程序不计算在内。特别：

• 在编译，运行或退出时发生错误的程序不计在内。警告可以。
• 不输出的整数从1到40或输出什么程序略微畸形如-35或35 36不计数。
• 需要用户输入才能产生输出的程序不计算在内。
• 永不结束的程序不计算在内。
• 从现在开始，不算确定性的程序就不算在内。
• 否则，将不输出已经输出另一个有效程序的从1到40的整数的有效程序。（第一程序被计数。）
• 只有输出整数表示形式（从1到40（含））的程序才计入总数。这些数字应采用通常的1，，2... 39，40格式，除非这不是您所用语言的规范。（输出中的尾随换行符就可以了。）
• 程序输出的数字和它们的顺序无关紧要。只有有效程序中不同整数的数量才重要。

所有路径程序必须以相同的语言运行。但是，“程序”实际上可以是打印或返回其目标整数的函数（没有必需的参数）或REPL命令以及完整程序。您可以在函数，REPL命令和完整程序之间混合使用。

您的9个可打印ASCII字符不需要区分。

例

如果您的3×3网格是

ABC
DEF
GHI

您的40个程序和输出看起来像这样

ABCFEDGHI -> 26
ABCFIHEDG -> 90
ABCFIHGDE -> 2
ABEDGHIFC -> syntax error
ADEBCFIHG -> prints 40 but then errors
ADGHEBCFI -> 6
ADGHIFCBE -> 6
ADGHIFEBC -> 6
CBADEFIHG -> runtime error
CBADGHEFI -> 3
CBADGHIFE -> 4
CFEBADGHI -> -32
CFIHEBADG -> 38.0
CFIHGDABE -> "36"
EDABCFIHG -> 33
EFCBADGHI -> no output
EHGDABCFI -> compilation error
EHIFCBADG -> 8
GDABCFEHI -> 22
GHEDABCFI -> 41
IHGDEFCBA -> 0
GDEHIFCBA -> '9'
EDGHIFCBA -> +10
CFIHGDEBA -> 11
GHIFCBEDA -> error
IFCBEHGDA -> error
EBCFIHGDA -> prints 23 but then loops infinitely
CBEFIHGDA -> randomly prints either 24 or 44
GHIFEDABC -> error
IFEHGDABC -> 30
EFIHGDABC -> 39
IHGDABEFC -> 7
GDABEHIFC -> 29
EBADGHIFC -> -1
GHIFCBADE -> 26
IHGDABCFE -> 1
IFCBADGHE -> error
GDABCFIHE -> no output
IHEFCBADG -> no output
IFCBADEHG -> "quack"

您的分数将为14，因为有效输出的1至40之间有14个不同的整数，即26 2 6 3 4 33 8 22 11 30 39 7 29 1。

PARI / GP-24

1%1
 8
2+3

PARI / GP会忽略数字之间的空格，因此1 8 2，例如将其视为182。通过用下划线替换空格，对于perl也可以使用相同的方法。我没有用尽整个搜索空间，因此可能会有更好的候选人。

可以将程序作为gp -q -f program.gp或交互输入给gp 。

输出量

1%1 8 2+3 -> 4
1%1 3+8 2 -> 83 # invalid
1%1 3+2 8 -> 29
1%8 2+3 1 -> 32
1 8%1 3+2 -> 7
1 2+8%1 3 -> 20
1 2+3 1%8 -> 19
1 2+3 8%1 -> 12
1%1 8 3+2 -> 3
1%1 2+8 3 -> 84 # invalid
1%1 2+3 8 -> 39
1 8%1 2+3 -> 9
1 3+8%1 2 -> 21
1 3+2 1%8 -> 18
8 1%1 3+2 -> 5
8 1%1 2+3 -> 12 # dup
8+2 1%1 3 -> 16
8+3 1%1 2 -> 15
2 1%1 8+3 -> 6
2+8 1%1 3 -> 5  # dup
3+2 8 1%1 -> 3  # dup
2 8+3 1%1 -> 28
8 2+3 1%1 -> 82 # invalid
1 3+2 8%1 -> 13
2+3 1%8 1 -> 33
3 1%8+2 1 -> 28 # dup
8%1 3+2 1 -> 29 # dup
1%8 3+2 1 -> 22
2+3 8 1%1 -> 2
3 8+2 1%1 -> 38
8 3+2 1%1 -> 83 # invalid
3+2 1%8 1 -> 24
2 1%8+3 1 -> 36
8%1 2+3 1 -> 39 # dup
2+3 1%1 8 -> 15 # dup
3+2 1%1 8 -> 6  # dup
3 1%1 2+8 -> 15 # dup
2 1%1 3+8 -> 16 # dup
3+8 1%1 2 -> 12 # dup
3 1%1 8+2 -> 15 # dup

除4个值外，所有值均在所需范围内，并包含12个重复的条目。

更新资料

我已经完成了运算，有六个不同的23，只有一个24（按行读取）：

23 1%1 6 2+3 [2, 3, 4, 5, 7, 8, 11, 12, 13, 14, 16, 17, 18, 19, 22, 24, 26, 27, 32, 33, 34, 36, 37]
23 1 2%3+2*8 [2, 5, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 25, 26, 29, 31, 32, 37, 40]
23 2 3%1+8 2 [2, 4, 6, 7, 10, 11, 12, 13, 14, 15, 16, 20, 21, 23, 24, 28, 29, 30, 31, 32, 33, 34, 40]
23 4%6%5*7+6 [2, 4, 5, 6, 7, 8, 9, 12, 13, 19, 21, 23, 24, 26, 29, 31, 32, 33, 34, 37, 38, 39, 40]
23 5%6%4*7+6 [2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 25, 26, 29, 31, 33, 34, 37, 38, 39, 40]
23 5%6%4*8+6 [1, 3, 5, 6, 8, 9, 10, 12, 14, 15, 18, 22, 24, 25, 27, 29, 30, 32, 34, 36, 37, 39, 40]

24 1%1 8 2+3 [2, 3, 4, 5, 6, 7, 9, 12, 13, 15, 16, 18, 19, 20, 21, 22, 24, 28, 29, 32, 33, 36, 38, 39]

我用于处理的程序如下。PARI / GP的字符串处理能力有限，因此主要处理char数组（又名Vecsmall）。测试的操作符是+，-，*，\（地板DIV）， ，%（;式分离器，它之前基本上丢弃一切），和（空间，如以上所描述的）。^也可以添加指数运算符，但是它变得太慢而无法穷举测试。

perms = {[
  [1, 2, 3, 6, 5, 4, 7, 8, 9], [1, 2, 3, 6, 9, 8, 5, 4, 7], [1, 2, 3, 6, 9, 8, 7, 4, 5], [1, 2, 5, 4, 7, 8, 9, 6, 3],
  [1, 4, 5, 2, 3, 6, 9, 8, 7], [1, 4, 7, 8, 5, 2, 3, 6, 9], [1, 4, 7, 8, 9, 6, 3, 2, 5], [1, 4, 7, 8, 9, 6, 5, 2, 3],
  [3, 2, 1, 4, 5, 6, 9, 8, 7], [3, 2, 1, 4, 7, 8, 5, 6, 9], [3, 2, 1, 4, 7, 8, 9, 6, 5], [3, 6, 5, 2, 1, 4, 7, 8, 9],
  [3, 6, 9, 8, 5, 2, 1, 4, 7], [3, 6, 9, 8, 7, 4, 1, 2, 5], [5, 4, 1, 2, 3, 6, 9, 8, 7], [5, 6, 3, 2, 1, 4, 7, 8, 9],
  [5, 8, 7, 4, 1, 2, 3, 6, 9], [5, 8, 9, 6, 3, 2, 1, 4, 7], [7, 4, 1, 2, 3, 6, 5, 8, 9], [7, 8, 5, 4, 1, 2, 3, 6, 9],
  [9, 8, 7, 4, 5, 6, 3, 2, 1], [7, 4, 5, 8, 9, 6, 3, 2, 1], [5, 4, 7, 8, 9, 6, 3, 2, 1], [3, 6, 9, 8, 7, 4, 5, 2, 1],
  [7, 8, 9, 6, 3, 2, 5, 4, 1], [9, 6, 3, 2, 5, 8, 7, 4, 1], [5, 2, 3, 6, 9, 8, 7, 4, 1], [3, 2, 5, 6, 9, 8, 7, 4, 1],
  [7, 8, 9, 6, 5, 4, 1, 2, 3], [9, 6, 5, 8, 7, 4, 1, 2, 3], [5, 6, 9, 8, 7, 4, 1, 2, 3], [9, 8, 7, 4, 1, 2, 5, 6, 3],
  [7, 4, 1, 2, 5, 8, 9, 6, 3], [5, 2, 1, 4, 7, 8, 9, 6, 3], [7, 8, 9, 6, 3, 2, 1, 4, 5], [9, 8, 7, 4, 1, 2, 3, 6, 5],
  [9, 6, 3, 2, 1, 4, 7, 8, 5], [7, 4, 1, 2, 3, 6, 9, 8, 5], [9, 8, 5, 6, 3, 2, 1, 4, 7], [9, 6, 3, 2, 1, 4, 5, 8, 7]
]}

ops = Vecsmall("+-*\\%; ")

ms = 1

for(c = 48, 57, {
 for(d = c, 57,
  for(f = d, 57,
   for(g = c, 57,
    for(e = 48, 57,
     print1(Strchr([c,d,e,f,g,13]));
     for(h = 1, #ops,
      for(i = 1, #ops,
       for(j = 1, #ops,
        for(k = 1, #ops,
         a = Vecsmall([c, ops[h], d, ops[i], e, ops[j], f, ops[k], g]);
         s = Set();
         for(m = 1, #perms,
          v = Strchr(vecextract(a, perms[m]));
          iferr(b = eval(v), E, b = 0);
          if(b >= 1 && b <= 40, s = setunion(s, [b]))
         );
         if(#s >= ms, ms = min(23, #s); print(#s, " ", Strchr(a), " ", s));
        )
       )
      )
     )
    )
   )
  )
 )
})

死鱼，18

实际上，这是我在考虑中缀运算符之前尝试的第一种语言。我现在发布该文章是出于“死鱼可能对某些东西有用”这一想法的狂热。

iii
ios
sii

对于那些不了解Deadfish的人来说，它i是增量，s是正方形并且o是输出，累加器从0开始（这里还有第4条d关于减量的指令未在此处使用）。我们没有自动打印并且需要使用的事实o是一个主要缺点，但是令人惊讶的是，考虑到所有因素，Deadfish在这里的表现并不十分糟糕。事实证明，输出运算符的最佳位置在中间。

iiisoisii 9
iiisiiois 11
iiisiisio 122
iioisiisi 2
iioiisiis 2
iisioiisi 5
iisiisiio 38
iisiisoii 36
iiiiosiis 4
iiiisiosi 17
iiiisiiso 324
isoiiisii 1
isiioiiis 3
isiisiiio 12
oiiiisiis 0
osiiiisii 0
oisiiiisi 0
oiisiiiis 0
siiiisoii 16
sioiiiisi 1
iisiosiii 5
sioiisiii 1
oisiisiii 0
isiisioii 10
siisiioii 6
isiioisii 3
oiisiisii 0
iiosiisii 2
siisoiiii 4
isoisiiii 1
osiisiiii 0
iisiiiosi 7
siiioiisi 3
oiiisiisi 0
siisiiiio 8
iisiiiiso 64
isiiiisio 26
siiiisiio 18
iiosiiiis 2
isiiiiois 5

Python REPL等22 23

6+7
*5%
6%4

关键观察：如果您像棋盘格一样为网格着色，则路径会随着网格颜色的变化交替变化，并以相同的颜色开始和结束。

仍然要强求更好。不幸的是，尝试使用+*%（甚至**对于^幂运算的语言）也没有发现任何更好的结果。我还尝试使用按位运算符，只有^（xor）似乎有帮助，但是搜索时间太长，因此我放弃了。

6+7%5*6%4 6
6+7%4%5*6 24
6+7%4%6*5 21
6+5*6%4%7 8
6*5+7%4%6 33
6*6%5+7%4 4
6*6%4%7+5 5
6*6%4%5+7 7
7+6*5%4%6 9
7+6*6%5%4 8
7+6*6%4%5 7
7%5+6*6%4 2
7%4%5+6*6 39
7%4%6*6+5 23
5*6+7%4%6 33
5%7+6*6%4 5
5%6*6+7%4 33
5%4%7+6*6 37
6*6+7%5%4 38
6%5*6+7%4 9
4%6*5%7+6 12
6*5%4%7+6 8
5*6%4%7+6 8
7%4%6*5+6 21
6%4%7+5*6 32
4%7+5%6*6 34
5+7%4%6*6 23
7+5%4%6*6 13
6%4%5*6+7 19
4%5%6*6+7 31
5%4%6*6+7 13
4%6*6+5%7 29
6*6+5%4%7 37
5+6*6%4%7 5
6%4%7+6*5 32
4%6*6+7%5 26
4%7+6*6%5 5
6*6+7%4%5 39
4%5%7+6*6 40
4%7+6*5%6 4

J，15

2 + 1
* 3 *
2 + 3

这仅输出有效数字，但是很多是重复的。唯一值是17 11 16 28 31 23 13 10 21 33 18 24 22 29 27。您绝对可以通过更改运算符和所涉及的整数来做得更好。

2+1*3*2+3 -> 17
2+1*3+3*2 -> 11
2+1*3+2*3 -> 11
2+3*2+3*1 -> 17
2*3+1*3+2 -> 16
2*2+3+1*3 -> 16
2*2+3*1+3 -> 28
2*2+3*3+1 -> 28
1+2*3*3+2 -> 31
1+2*2+3*3 -> 23
1+2*2+3*3 -> 23
1*3+2*2+3 -> 13
1*3+3+2*2 -> 10
1*3+2*2+3 -> 13
3*2+1*3+2 -> 21
3*1+2*2+3 -> 33
3+2*2+1*3 -> 13
3+3*1+2*2 -> 18
2*2+1*3+3 -> 16
2+3*2+1*3 -> 17
3+2*3*1+2 -> 21
2*3+3*1+2 -> 24
3*2+3*1+2 -> 33
1*3+2*3+2 -> 13
2+3*1+3*2 -> 23
3*1+3+2*2 -> 24
3+1*3+2*2 -> 10
1+3*3+2*2 -> 22
2+3*3*2+1 -> 29
3*3+2*2+1 -> 27
3*3+2*2+1 -> 27
3+2*2+3*1 -> 13
2*2+3+3*1 -> 16
3+2*2+3*1 -> 13
2+3*1+2*3 -> 23
3+2*2+1*3 -> 13
3*1+2*2+3 -> 33
2*2+1*3+3 -> 16
3+3*1+2*2 -> 18
3*1+2*3+2 -> 33

> <>，​​36 *

如果您足够幸运！

x;x
lxl
xnx

由于挑战并不要求代码具有确定性，我们只需要证明有可能（即使不可能）返回36个数字就可以了。我猜这很不错。

（对于不熟悉> <>的人，可以在这里找到一个很好的介绍）

> <>是基于堆栈的2D语言。这意味着指令不会像大多数传统语言那样线性执行-程序流可以向上，向下，向左或向右！

我决定在> <>中使用“ x”指令，该指令将指令指针的方向随机更改为上，下，左或右。由于我们的代码只有一行，这意味着我们只能查看它向右或向左移动的情况，因为如果指针向上或向下移动，它只会再次命中“ x”指令。

“ n”指令将数字弹出到堆栈顶部并进行打印。但是，如果堆栈为空并且没有弹出的内容，则会引发错误。

“ l”指令只是将堆栈的长度压入堆栈（对我们来说很幸运，如果堆栈为空，它不会发送错误），例如，如果堆栈为空并且将调用“ l”，会将0压入堆栈。如果我们现在再次调用“ l”，则由于堆栈中有一个元素（0），它将把1推到堆栈的顶部，这意味着堆栈中将有两件事，这意味着如果再次调用“ l”，则将2压入堆栈，依此类推。因此，可以使用“ l”通过前面显示的方法将任意数字压入堆栈。

“;” 指令结束程序。

使用“ x”的想法是，例如，如果代码中只有一个“ x”（其中A，B，C，D是一些指令）：

ABCx;D

程序将先执行A，然后执行B，然后执行C，到达“ x”后，我们将有两种可能：代码要么继续正确执行，然后按“;”。然后退出，或者它走了，然后依次执行C，B，A，D，D。因此，如果我们的代码包含一个“ x”，则该程序将获得两个可能的程序流，我们可以从中选择最适合的程序。

如果有两个或多个“ x”，那么我们获得了无限数量的可能程序流。

我们的代码有五个“ x”，而且每个都位于汉密尔顿路径的“起始单元”中，这意味着每个程序都将以“ x”开头，并且每个程序都具有以下结构：

xAxBxCxDx

其中A，B，C，D属于{; ，n，l，l}这意味着只有12个唯一的程序。此外，由于我们始终以“ x”开头，因此我们可以看一下程序离开时的情况，因此对称程序也可以视为相同。到对称为止，只有6种不同的可行程序。它们中只有4个出现在以汉密尔顿路径生成的程序中：

xnxlxlx;x
xlxnxlx;x
xnxlx;xlx
xlxnx;xlx

让我们看一下第一个程序“ xnxlxlx; x”，如果我们在第一步中正确执行的话，我们按下print命令，由于堆栈上没有任何东西，这将引发错误。如果我们走了，我们点击结束程序命令。因此，我们无法从这些程序中输出任何数字。

第二个程序“ xlxnxlx; x”更有希望，因为在开始时向右走时，堆栈上会放一个零，如果我们然后在下一个“ x”处往左走，则我们的堆栈会得到一个，然后再次右移，我们可以打印出2，然后继续右移以结束程序。我们可以观察到实际上可以打印任何偶数，因为在开始的“ xlx”部分中，我们可以通过先右后左再右再达到一定次数来达到任意大小。

类似地可以看出，第三个程序xnxlx; xlx可以输出任何奇数，方法是在开始处向左走，然后仅此一次向左然后向右然后向左重复“ xlx”例程。

第四个程序与第二个程序基本相同，并且可以输出任何偶数。

因此，对于所需的程序，我们有：

x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)

那是4个不能输出数字的程序，20个可以输出任何偶数的程序，16个可以输出任何奇数的程序。由于在1到40的范围内恰好有20个偶数和至少16个奇数，因此有一定的可能性存在此代码块输出的在1到40范围内的36个不同的数。

GolfScript，8岁

192
6#7
281

目前得分最高的解决方案。：P持续很不错。

程式

1927#6281 1927
192718#62 192718
19271826# 19271826
19#628172 19
16#927182 16
1628#9271 1628
16281729# 16281729
162817#92 162817
2916#7182 2916
291628#71 291628
29162817# 29162817
27#916281 27
2718#9162 2718
27182619# 27182619
#61927182 
#72916281 
#82619271 
#81729162 
261927#81 261927
28#619271 28
1826#7291 1826
26#817291 26
#62817291 
271826#91 271826
281729#61 281729
1729#8261 1729
#92718261 
29#718261 29
2817#6192 2817
17#826192 17
#71826192 
182619#72 182619
2619#8172 2619
#91628172 
28172916# 28172916
18261927# 18261927
17291628# 17291628
26192718# 26192718
18#729162 18
172916#82 172916

CJam，14岁

3(4
;];
0)1

在工作程序下方：

3(4;];0)1 = 11
3(4;1)0;] = 22
3(];0)1;4 = 14
3;0)](4;1 = 11
3;0)1;4(] = 13
3;0)1;](4 = 14
4(3;];1)0 = 20
4(3;0)];1 = 1
4(3;0)1;] = 31
4;1)](3;0 = 20
4;1)0;3(] = 22
0;3(4;])1 = 21
0)];3(4;1 = 21
1)0;];4(3 = 33
4;1)0;](3 = 23
0)1;4(];3 = 3
1;4(])0;3 = 33
4(];1)0;3 = 23
0)1;];3(4 = 24
1)0;3(];4 = 4
0;3(])1;4 = 24
0)1;4(3;] = 13
1)0;3(4;] = 22
1;4(3;0)] = 31
0;3(4;1)] = 22
1)];4(3;0 = 30
1;4(3;])0 = 30

生成的值是：[1、3、4、11、13、14、20、21、22、23、24、30、31、33]

直流（20）

2+3
*p+
4+5

ABCFEDGHI -> 2+3+p*4+5 -> 5     $ **
ABCFIHEDG -> 2+3+5+p*4 -> 10    $ **
ABCFIHGDE -> 2+3+5+4*p -> 40    $ **
ABEDGHIFC -> 2+p*4+5+3 -> 2     $ **
ADEBCFIHG -> 2*p+3+5+4 -> 2       **
ADGHEBCFI -> 2*4+p+3+5 -> 6     $ **
ADGHIFCBE -> 2*4+5+3+p -> 14    $ **
ADGHIFEBC -> 2*4+5+p+3 -> 11    $ **
CBADEFIHG -> 3+2*p+5+4 -> 6       **
CBADGHEFI -> 3+2*4+p+5 -> 10      **
CBADGHIFE -> 3+2*4+5+p -> 15    $ **
CFEBADGHI -> 3+p+2*4+5 -> 3     $ **
CFIHEBADG -> 3+5+p+2*4 -> 8     $ **
CFIHGDABE -> 3+5+4*2+p -> 34    $ **
EDABCFIHG -> p*2+3+5+4 -> 
EFCBADGHI -> p+3+2*4+5 -> 
EHGDABCFI -> p+4*2+3+5 -> 
EHIFCBADG -> p+5+3+2*4 -> 
GDABCFEHI -> 4*2+3+p+5 -> 9     $ **
GHEDABCFI -> 4+p*2+3+5 -> 4     $ **
IHGDEFCBA -> 5+4*p+3+2 -> 20    $ **
GDEHIFCBA -> 4*p+5+3+2 -> 4       **
EDGHIFCBA -> p*4+5+3+2 -> 
CFIHGDEBA -> 3+5+4*p+2 -> 32    $ **
GHIFCBEDA -> 4+5+3+p*2 -> 12    $ **
IFCBEHGDA -> 5+3+p+4*2 -> 8       **
EBCFIHGDA -> p+3+5+4*2 -> 
CBEFIHGDA -> 3+p+5+4*2 -> 3       **
GHIFEDABC -> 4+5+p*2+3 -> 9       **
IFEHGDABC -> 5+p+4*2+3 -> 5       **
EFIHGDABC -> p+5+4*2+3 -> 
IHGDABEFC -> 5+4*2+p+3 -> 22    $ **
GDABEHIFC -> 4*2+p+5+3 -> 6       **
EBADGHIFC -> p+2*4+5+3 -> 
GHIFCBADE -> 4+5+3+2*p -> 24    $ **
IHGDABCFE -> 5+4*2+3+p -> 25    $ **
IFCBADGHE -> 5+3+2*4+p -> 20      **
GDABCFIHE -> 4*2+3+5+p -> 14      **
IHEFCBADG -> 5+p+3+2*4 -> 5       **
IFCBADEHG -> 5+3+2*p+4 -> 16    $ **

32个输出，其中20个不同（标有$）

2，3，4，5，6，8，9，10，11，12，14，15，16，20，22，24，25，32，34，40