Существует 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формате, если это не является нормой для вашего языка. (Завершающий перевод строки в выводе в порядке.)
• Какие номера выводят ваши программы и в каком порядке они не имеют значения. Только количество различных целых чисел из допустимых программ имеет значение.

Все path-программы должны быть запущены на одном языке. Однако на самом деле «программы» могут быть функциями (без обязательных аргументов) или командами 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, потому что есть 14 различных целых чисел от 1 до 40, а именно 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 as gp -q -f program.gpили интерактивно в repl.

Выход

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 имеет ограниченные возможности по обработке строк, поэтому имеет дело в основном с массивами символов (иначе Vecsmall). Операторы испытанные являются +, -, *, \(пол дел), %,; (выражение сепаратора, по существу , отбрасывает все перед ним), и (пространство, как описано выше). ^Можно также добавить оператор экспоненты , но он становится слишком медленным для исчерпывающего тестирования.

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));
        )
       )
      )
     )
    )
   )
  )
 )
})

Deadfish , 18

На самом деле это был первый язык, который я попробовал, прежде чем рассматривать инфиксные операторы. Я выкладываю это сейчас для полной радости идеи, что Deadfish может быть полезен для чего-то.

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 чисел, и все готово. Думаю, было хорошо, пока это продолжалось.

(Для тех, кто не знаком с> <>, отличное введение можно найти здесь )

> <> это двумерный язык на основе стека. Это означает, что инструкции не выполняются линейно, как большинство традиционных языков - поток программы может быть вверх, вниз, влево или вправо!

Я решил использовать инструкцию «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 и только затем выходит. Таким образом, если наш код содержал один «x», программа получает два возможных программных потока, из которых мы можем выбрать наиболее подходящую программу.

Если существует два или более «х», то мы получаем бесконечное число возможных программных потоков.

В нашем коде есть пять «x» es, кроме того, каждый из них находится в «начальной ячейке» гамильтоновых путей, что означает, что каждая отдельная программа будет начинаться с «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 нечетных чисел, существует вероятность того, что в этом кодовом блоке будет 36 различных чисел в диапазоне от 1 до 40.

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