Istnieje 40 sposobów, w jakie ukierunkowana ścieżka hamiltonowska może być ułożona na siatce 3 × 3:

Ta grafika ( dzięki Sp3000! ) Pokazuje tylko 20 nieukierowanych ścieżek. Przemierzaj każdą kolorową linię w obu kierunkach dla 40 kierowanych ścieżek.

Wyzwanie

Używając tylko ASCII do wydruku , napisz siatkę znaków 3 × 3, na przykład:

ABC
DEF
GHI

Gdy każda z 40 kierowanych ścieżek jest odczytywana z tej siatki jako 40 jednowierszowych, 9-znakowych programów, celem jest, aby każdy program wyświetlał unikalną liczbę całkowitą od 1 do 40. Wykonanie tego dla wszystkich 40 ścieżek wydaje się trudne i mało prawdopodobne, więc musisz tylko sprawić, by działał na jak największej liczbie ścieżek.

Zwycięzcą zostanie zgłoszenie, którego 40 programów ścieżek wyprowadzi najbardziej wyraźne liczby od 1 do 40. Tiebreaker przechodzi do wcześniejszego zgłoszenia.

Programy ścieżek, które popełniają błąd lub nie wypisują liczb całkowitych od 1 do 40 lub wypisują liczby całkowite, których nie obejmuje już inny program ścieżek, nie są liczone. Konkretnie:

• Programy z błędami podczas kompilacji, uruchamiania lub wychodzenia nie są liczone. Ostrzeżenia są w porządku.
• Programy, które nie wypisują liczb całkowitych od 1 do 40 lub wyprowadzają coś nieznacznie zniekształconego, takie jak -35lub 35 36nie są liczone.
• Programy wymagające danych wejściowych od użytkownika, aby wygenerować dane wyjściowe, nie są liczone.
• Programy, które nigdy się nie kończą, nie są liczone.
• Od teraz na programy, które nie są deterministyczne nie są liczone.
• W przeciwnym razie prawidłowe programy, które generują liczbę całkowitą od 1 do 40, którą inny prawidłowy program już wypisał, nie są liczone. (Pierwszy program jest liczony.)
• Tylko programy, które generują liczby całkowite reprezentujące liczby od 1 do 40 (włącznie) są liczone do twojej sumy. Oczekuje się, że liczby będą miały zwykły 1, 2... 39, 40format, chyba że nie jest to normą dla twojego języka. (Końcowy znak nowej linii w wyjściu jest w porządku).
• Liczba numerów wyjściowych programów i ich kolejność nie ma znaczenia. Liczy się tylko liczba różnych liczb całkowitych z prawidłowych programów.

Wszystkie programy ścieżki muszą być uruchamiane w tym samym języku. Jednak „programami” mogą być w rzeczywistości funkcje (bez wymaganych argumentów) lub polecenia REPL , a także pełne programy, które wypisują lub zwracają docelową liczbę całkowitą. Możesz mieszać i dopasowywać funkcje, polecenia REPL i pełne programy.

Twoje 9 drukowalnych znaków ASCII nie musi być rozróżnionych.

Przykład

Jeśli twoja siatka 3 × 3 była

ABC
DEF
GHI

a twoje 40 programów i wyników wyglądało tak

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"

Twój wynik wyniósłby 14, ponieważ istnieje 14 różnych liczb całkowitych od 1 do 40 prawidłowych danych wyjściowych, a mianowicie 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP ignoruje spacje między cyframi, więc 1 8 2na przykład jest traktowany jako 182. To samo może działać dla Perla, zastępując spacje podkreśleniami. Nie wyczerpałem całej przestrzeni wyszukiwania, więc mogą być lepsi kandydaci.

Program może być dostarczony do gp jako gp -q -f program.gplub interaktywnie w repl.

Wydajność

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

Wszystkie wartości oprócz 4 mieszczą się w wymaganym zakresie, z 12 zduplikowanymi wpisami.

Aktualizacja

Skończyłem chrupanie, jest sześć różnych 23 i tylko jedna 24 (czytana wierszami):

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]

Program, którego użyłem do chrupania, jest poniżej. PARI / GP ma ograniczone możliwości przetwarzania łańcucha znaków, więc radzą sobie głównie z tablicami znaków (aka Vecsmall). Badane operatorzy +, -, *, \(Gr podłogi) %, ;(rozdzielacz ekspresji zasadniczo usuwa wszystko przed nim) i (miejsca, jak to opisano powyżej). ^Można również dodać operatora wykładnika , ale staje się on zbyt wolny, aby przeprowadzić wyczerpujące testy.

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

To był właściwie pierwszy język, którego wypróbowałem, zanim wziąłem pod uwagę operatorów infix. Publikuję to teraz dla samej wesołości na myśl, że Deadfish może być do czegoś przydatny.

iii
ios
sii

Dla tych, którzy nie znają Deadfisha, ijest to przyrost, sjest kwadratowy i ojest wyprowadzany, a akumulator zaczyna się od 0 (nie ma tu również czwartej instrukcji ddekrementacji). Fakt, że nie mamy automatycznego drukowania i musimy go używać, ojest główną wadą, ale zaskakująco Deadfish nie robi tutaj zbyt strasznie, biorąc pod uwagę wszystkie te kwestie. Okazuje się, że optymalne ustawienie operatora wyjściowego znajduje się na środku.

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 i wiele innych, 22 23

6+7
*5%
6%4

Najważniejsze spostrzeżenie: jeśli pokolorujesz siatkę jak szachownicę, ścieżka naprzemiennie zmienia kolor siatki, gdy idzie i zaczyna się i kończy na tym samym kolorze.

Wciąż brutalne wymuszanie na lepsze. Próbowanie z +*%(a nawet w **przypadku języków, w których ^występuje potęgowanie) niestety nie przyniosło nic lepszego. Próbowałem także wrzucać bitowe operatory i tylko ^(xor) wydawało się łagodnie pomagać, ale wyszukiwanie trwało zbyt długo, więc się poddałem.

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

Daje to tylko prawidłowe liczby, ale wiele z nich to duplikaty. Unikalne wartości to 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Możesz zdecydowanie lepiej, zmieniając operatorów i zaangażowane liczby całkowite.

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 *

Jeśli masz szczęście!

x;x
lxl
xnx

Ponieważ wyzwanie nie wymaga deterministycznego kodu, musimy jedynie udowodnić, że możliwe jest (nawet jeśli jest to nieprawdopodobne) zwrócenie 36 liczb i gotowe. To chyba dobrze, dopóki trwało.

(Dla tych, którzy nie znają> <>, świetne wprowadzenie można znaleźć tutaj )

> <> to język 2D oparty na stosie. Oznacza to, że instrukcje nie są wykonywane liniowo, jak większość tradycyjnych języków - przepływ programu może być w górę, w dół, w lewo lub w prawo!

Zdecydowałem się użyć instrukcji „x” w> <>, która losowo zmienia kierunek wskaźników instrukcji w górę, w dół, w lewo lub w prawo. Ponieważ nasz kod będzie tylko jedną linią, oznacza to, że możemy patrzeć tylko na przypadki, gdy idzie w prawo lub w lewo, ponieważ jeśli wskaźnik wzrośnie lub spadnie, po prostu ponownie uderzy w instrukcję „x”.

Instrukcja „n” wyskakuje na górze stosu i drukuje go. Jeśli jednak stos jest pusty i nie ma nic do wyskoczenia, pojawia się błąd.

Instrukcja „l” po prostu przesuwa długość stosu na stos (i na szczęście dla nas nie wysyła błędu, jeśli stos jest pusty), więc na przykład, jeśli stos byłby pusty i wywołano by „l”, to pchnąłby 0 na stosie. Gdybyśmy teraz ponownie wywołali „l”, to ponieważ stos zawiera jeden element (0), wypchnąłby 1 na górę stosu, a teraz oznaczałoby to, że na stosie byłyby dwie rzeczy, a to oznaczałoby, że jeśli mielibyśmy ponownie wywołać „l”, wcisnęlibyśmy 2 na stos itp. Możemy więc użyć „l”, aby wypchnąć dowolny numer na stos za pomocą metody pokazanej wcześniej.

„;” instrukcja kończy program.

Pomysł użycia „x” polega na tym, że na przykład, jeśli w kodzie było tylko jedno „x” (gdzie A, B, C, D to niektóre instrukcje):

ABCx;D

Program wykonałby A, a następnie B, a następnie C, a po osiągnięciu „x” mielibyśmy dwie możliwości: kod albo nadal idzie w prawo i uderza w „;” i wychodzi lub idzie w lewo i wykonuje C, a następnie A, a następnie D i dopiero potem wychodzi. Więc jeśli nasz kod zawiera jeden „x”, program uzyskuje dwa możliwe przepływy programu, z których możemy wybrać najbardziej odpowiedni program.

Jeśli są dwa lub więcej znaków „x”, wówczas uzyskujemy nieskończoną liczbę możliwych przepływów programu.

Nasz kod ma pięć znaków „x”, ponadto każdy z nich znajduje się w „początkowej komórce” ścieżek hamiltonowskich, co oznacza, że ​​każdy program rozpocznie się od „x”, a każdy program będzie miał strukturę:

xAxBxCxDx

Gdzie A, B, C, D należą do {; , n, l, l} Oznacza to, że istnieje tylko 12 unikalnych programów. Ponadto, ponieważ zawsze zaczynamy od litery „x”, możemy spojrzeć na przypadek, gdy program odchodzi w lewo, więc programy symetryczne można również traktować tak samo. Do symetrii istnieje tylko 6 różnych możliwych programów. Tylko 4 z nich występują w programach generowanych jako ścieżki hamiltonowskie:

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

Spójrzmy na pierwszy program „xnxlxlx; x”, jeśli pójdziemy od razu w pierwszym kroku, uderzymy w komendę print, która spowoduje błąd, ponieważ nie mamy nic na stosie. Jeśli pójdziemy w lewo, uderzymy w polecenie zakończenia programu. Dlatego nie możemy wyprowadzić żadnej liczby z tych programów.

Drugi program, „xlxnxlx; x”, jest o wiele bardziej obiecujący, ponieważ po przejściu w prawo na początku zero jest umieszczane na stosie, jeśli następnie pójdziemy w lewo przy następnym „x”, nasz stos zyskuje jeden, a następnie idąc znowu w prawo mamy 2, które możemy następnie wydrukować i kontynuować od razu, aby zakończyć program. Możemy zaobserwować, że faktycznie możemy wydrukować dowolną liczbę parzystą , ponieważ w części „xlx” na początku możemy osiągnąć pewną liczbę dowolnych rozmiarów, przechodząc w prawo, a potem w lewo, a następnie ponownie w określoną liczbę razy.

Podobnie można zauważyć, że trzeci program xnxlx; xlx może wypisać dowolną liczbę nieparzystą , przechodząc w lewo na początku, a następnie powtarzając procedurę „xlx” tylko tym razem w lewo, a potem w prawo, a potem w lewo.

Czwarty program jest zasadniczo taki sam jak drugi program i może generować dowolną liczbę parzystą .

Tak więc dla wymaganych programów mamy:

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)

To 4 programy, które nie mogą wyprowadzić liczb wyjściowych, 20, które mogą wypisać dowolną liczbę parzystą, 16, które mogą wypisać dowolną liczbę nieparzystą. Ponieważ istnieje dokładnie 20 liczb parzystych i co najmniej 16 liczb nieparzystych w zakresie od 1 do 40, to z pewnym prawdopodobieństwem istnieje możliwość, że przez ten blok kodu będzie 36 różnych liczb w zakresie od 1 do 40.

GolfScript, 8

192
6#7
281

Obecnie najwyższe rozwiązanie punktowe. : P Było miło, dopóki trwało.

Programy

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

Poniżej działających programów:

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

Generowane wartości to: [1, 3, 4, 11, 13, 14, 20, 21, 22, 23, 24, 30, 31, 33]

dc (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 wyjścia, 20 z nich odrębnych (oznaczonych a $)

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