Існує 40 способів розташування спрямованого гамільтонового шляху на сітці 3 × 3. На

цій графіці ( спасибі Sp3000! ) Показано лише 20 непрямих шляхів. Проведіть кожну кольорову лінію в обох напрямках на 40 спрямованих контурах.

Виклик

Використовуючи лише друкований ASCII , запишіть сітку символів 3 × 3, наприклад:

ABC
DEF
GHI

Коли кожен з 40 спрямованих контурів читається з цієї сітки як 40 однорядних, 9-символьних програм, мета полягає в тому, щоб кожна програма виводила унікальне ціле число від 1 до 40. Зробити це для всіх 40 шляхів здається складно і малоймовірно, тому потрібно лише змусити його працювати стільки шляхів, скільки ви можете.

Виграш, подання якого 40-ти контурних програм виводить найбільш чіткі числа від 1 до 40. Tiereaker переходить до більш раннього подання.

Програми шляху, які помиляються або не виводять ціле число від 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, тому що існує 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 як 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 має обмежені можливості обробці рядків, тому займайтеся в основному масивами char (ака 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));
        )
       )
      )
     )
    )
   )
  )
 )
})

Мертва , 18

Це була фактично перша мова, яку я спробував, перш ніж я розглядав оператори інфіксації. Я розміщую це зараз для абсолютної веселості думки про те, що Deadfish може бути корисним для чогось.

iii
ios
sii

Для тих, хто не знає Deadfish, iприріст, sквадратний і oвиводиться, при цьому акумулятор починається з 0 (тут також 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, потім B, A, потім D і тільки потім. Отже, якщо наш код містив один "х", програма отримує два можливі програмні потоки, з яких ми можемо вибрати найбільш підходящу програму.

У мене є два або більше "х", тоді ми отримуємо нескінченну кількість можливих програмних потоків.

У нашому коді є п'ять "х" ес, тим більше, що кожен з них знаходиться у "вихідній комірці" Гамільтонових шляхів, а це означає, що кожна окрема програма починається з "х", і кожна програма буде мати структуру:

xAxBxCxDx

Де A, B, C, D належать {; , n, l, l} Це означає, що існує лише 12 унікальних програм. Крім того, оскільки ми завжди починаємо з «х», ми можемо подивитися на випадок, коли програма йде ліворуч, тому симетричні програми також можна вважати однаковими. До симетрії існує лише 6 різних можливих програм. Лише 4 з них зустрічаються в програмах, генерованих у вигляді гамільтонових шляхів:

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

Давайте подивимось на першу програму "xnxlxlx; x", якщо ми підемо прямо на першому кроці, ми потрапимо на команду print, яка призведе до помилки, оскільки у нас нічого не стоїть. Якщо ми підемо вліво, ми потрапили в команду для завершення програми. Тому ми не можемо вивести будь-яке число з цих програм.

Друга програма, "xlxnxlx; 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