Esistono 40 modi in cui un percorso Hamiltoniano diretto può essere organizzato su una griglia 3 × 3:

Questo grafico ( grazie a Sp3000! ) Mostra solo i 20 percorsi non indirizzati. Attraversa ogni linea colorata in entrambe le direzioni per i 40 percorsi diretti.

Sfida

Utilizzando solo ASCII stampabile , scrivi una griglia di caratteri 3 × 3, come ad esempio:

ABC
DEF
GHI

Quando ciascuno dei 40 percorsi diretti viene letto da questa griglia come 40 programmi a riga singola di 9 caratteri, l'obiettivo è far sì che ciascun programma generi un numero intero unico compreso tra 1 e 40. Fare ciò per tutti i 40 percorsi sembra difficile e improbabile, quindi devi solo farlo funzionare per tutti i percorsi che puoi.

La proposta i cui 40 programmi di percorso producono i numeri più distinti da 1 a 40 saranno i vincitori. Tiebreaker va alla presentazione precedente.

Non vengono conteggiati i programmi di percorso che presentano errori o che non generano un numero intero compreso tra 1 e 40 o che generano un numero intero che un altro programma di percorso già coperto. In particolare:

• I programmi che presentano errori durante la compilazione, l'esecuzione o l'uscita non vengono conteggiati. Gli avvertimenti sono ok.
• I programmi che non generano un numero intero compreso tra 1 e 40 o che generano qualcosa di leggermente malformato come -35o 35 36non vengono conteggiati.
• I programmi che richiedono l'input dell'utente per produrre l'output non vengono conteggiati.
• I programmi che non finiscono mai non vengono conteggiati.
• D' ora in poi , i programmi che non sono deterministici non vengono conteggiati.
• In caso contrario, i programmi validi che generano un numero intero compreso tra 1 e 40 che un altro programma valido ha già emesso non vengono conteggiati. ( Viene conteggiato il primo programma .)
• Solo i programmi che generano rappresentazioni di numeri interi compresi tra 1 e 40 (incluso) vengono conteggiati per il totale. I numeri dovrebbero essere nel solito 1, 2, ..., 39, 40format, a meno che non è la norma per la lingua. (Una nuova riga finale nell'output va bene.)
• Non importa quale sia il numero dei programmi emessi e l'ordine in cui si trovano. È importante solo il numero di numeri interi distinti da programmi validi.

Tutti i programmi di percorso devono essere eseguiti nella stessa lingua. Tuttavia, i "programmi" possono in effetti essere funzioni (senza argomenti richiesti) o comandi REPL , nonché programmi completi, che stampano o restituiscono il loro intero di destinazione. È possibile combinare funzioni, comandi REPL e programmi completi.

I tuoi 9 caratteri ASCII stampabili non devono essere distinti.

Esempio

Se la tua griglia 3 × 3 fosse

ABC
DEF
GHI

e i tuoi 40 programmi e output sembravano così

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"

il tuo punteggio sarebbe 14, perché ci sono 14 interi distinti da 1 a 40 validamente emessi, ovvero 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP ignora gli spazi tra le cifre, in modo che 1 8 2, ad esempio, venga trattato come 182. Lo stesso potrebbe funzionare per perl sostituendo gli spazi con caratteri di sottolineatura. Non ho esaurito l'intero spazio di ricerca, quindi potrebbero esserci candidati migliori.

Un programma può essere alimentato in gp as gp -q -f program.gpo interattivamente in sostituzione.

Produzione

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

Tutti tranne 4 sono all'interno dell'intervallo richiesto, con 12 voci duplicate.

Aggiornare

Ho finito lo scricchiolio, ci sono sei 23 distinti e solo uno 24 (come letto dalle righe):

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]

Il programma che ho usato per lo scricchiolio è di seguito. PARI / GP ha capacità di elaborazione delle stringhe limitate, quindi si occupa principalmente di array di caratteri (aka Vecsmall). Gli operatori sono testati +, -, *, \(piano div) %, ;(separatore espressione, essenzialmente rigetti tutto prima di esso), e (spazio, come descritto sopra). L'operatore esponente ^potrebbe anche essere aggiunto, ma diventa troppo lento per eseguire un test esaustivo.

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

Pesce morto , 18

Questa è stata in realtà la prima lingua che ho provato prima di considerare gli operatori infix. Lo sto pubblicando ora per la pura e semplice follia dell'idea che Deadfish potrebbe essere utile per qualcosa.

iii
ios
sii

Per coloro che non conoscono Deadfish, iè incrementale, squadrato ed oemesso, con l'accumulatore che parte da 0 (c'è anche una quarta istruzione dper il decremento non usata qui). Il fatto che non abbiamo la stampa automatica e che dobbiamo usare oè un grosso svantaggio, ma sorprendentemente Deadfish non fa troppo terribilmente qui, tutto sommato. Si scopre che il posizionamento ottimale dell'operatore di output è nel mezzo.

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 e molti altri, 22 23

6+7
*5%
6%4

Osservazione chiave: se colora la griglia come una scacchiera, il percorso alterna i colori della griglia mentre procede e inizia e termina con lo stesso colore.

Forza bruta ancora per il meglio. Provare con +*%(e anche **per le lingue in cui ^è esponenziale) non ha rivelato nulla di meglio, sfortunatamente. Ho anche provato a lanciare operatori bit a bit e solo ^(xor) sembrava leggermente aiutare, ma la ricerca stava impiegando troppo tempo, quindi ho rinunciato.

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

Questo produce solo numeri validi, ma molti sono duplicati. I valori univoci sono 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Puoi sicuramente fare di meglio cambiando gli operatori e gli interi coinvolti.

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 *

Se sei abbastanza fortunato!

x;x
lxl
xnx

Poiché la sfida non richiede che il codice sia deterministico, dobbiamo solo dimostrare che è possibile (anche se improbabile) restituire 36 numeri e il gioco è fatto.È stato bello finché è durato credo.

(Per chi non ha familiarità con> <>, una grande introduzione può essere trovata qui )

> <> è un linguaggio 2D basato su stack. Ciò significa che le istruzioni non vengono eseguite in modo lineare come la maggior parte dei linguaggi tradizionali: il flusso del programma può essere su, giù, sinistra o destra!

Ho deciso di usare l'istruzione "x" in> <>, che cambia la direzione dei puntatori dell'istruzione in su, in giù, a sinistra oa destra in modo casuale. Poiché il nostro codice sarà solo una riga, ciò significa che possiamo guardare i casi solo quando va a destra o a sinistra, poiché se il puntatore sale o scende, premerà nuovamente l'istruzione "x".

L'istruzione "n" apre il numero nella parte superiore della pila e lo stampa. Tuttavia, se lo stack è vuoto e non c'è nulla da pop, viene generato un errore.

L'istruzione "l" spinge semplicemente la lunghezza dello stack sullo stack (e fortunatamente per noi non invia un errore se lo stack è vuoto), quindi ad esempio se lo stack fosse vuoto e si chiamerebbe "l", spingerebbe 0 nello stack. Se ora chiamassimo di nuovo "l", allora poiché lo stack ha un elemento (0), spingerebbe 1 in cima allo stack e ora significherebbe che ci sarebbero due cose nello stack e ciò significherebbe che se dovessimo chiamare di nuovo "l", inseriremmo 2 nello stack ecc. Quindi possiamo usare "l" per spingere un numero arbitrario nello stack tramite il metodo mostrato in precedenza.

Il ";" l'istruzione termina il programma.

L'idea con l'uso di "x" è che, ad esempio, se nel codice fosse presente solo una "x" (dove A, B, C, D sono alcune istruzioni):

ABCx;D

Il programma eseguirà A, poi B, poi C, e al raggiungimento di "x" avremmo due possibilità: il codice continua a funzionare correttamente e preme ";" ed esce oppure va a sinistra ed esegue C poi B poi A poi D e solo allora esce. Quindi se il nostro codice conteneva una "x", il programma guadagna due possibili flussi di programma da cui possiamo scegliere il programma più adatto.

Se ci sono due o più "x" es allora otteniamo un numero infinito di possibili flussi di programma.

Il nostro codice ha cinque "x" es, inoltre ciascuno di essi si trova in una "cella di partenza" dei percorsi hamiltoniani, il che significa che ogni singolo programma inizierà con una "x" e ogni programma avrà la struttura:

xAxBxCxDx

Dove A, B, C, D appartengono a {; , n, l, l} Ciò significa che ci sono solo 12 programmi unici. Inoltre, dato che iniziamo sempre con una "x", possiamo considerare il caso in cui il programma va a sinistra, quindi anche i programmi simmetrici possono essere considerati uguali. Fino alla simmetria ci sono solo 6 diversi programmi possibili. Solo 4 di questi si verificano nei programmi generati come percorsi hamiltoniani:

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

Diamo un'occhiata al primo programma "xnxlxlx; x" se andiamo a destra al primo passo, premiamo il comando di stampa che genererà un errore poiché non abbiamo nulla nello stack. Se andiamo a sinistra, premiamo il comando di fine programma. Quindi non possiamo emettere alcun numero da questi programmi.

Il secondo programma, "xlxnxlx; x", è molto più fiducioso, poiché andando a destra all'inizio uno zero viene messo in pila, se poi andiamo a sinistra alla successiva "x", il nostro stack ne guadagna uno, quindi andando di nuovo a destra abbiamo un 2 che possiamo quindi stampare e continuare andando a destra per terminare il programma. Possiamo osservare che possiamo effettivamente stampare qualsiasi numero pari , poiché nella parte "xlx" all'inizio possiamo raggiungere un numero di dimensioni arbitrarie andando a destra poi a sinistra e poi di nuovo a destra un certo numero di volte.

Allo stesso modo si può vedere che il terzo programma xnxlx; xlx può produrre qualsiasi numero dispari , andando a sinistra all'inizio e quindi ripetendo la routine "xlx" solo questa volta andando a sinistra poi a destra poi a sinistra.

E il quarto programma è essenzialmente lo stesso del secondo programma e può produrre qualsiasi numero pari .

Quindi per i programmi richiesti abbiamo:

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)

Sono 4 programmi che non possono emettere numeri, 20 che possono emettere qualsiasi numero pari, 16 che possono emettere qualsiasi numero dispari. Dato che ci sono esattamente 20 numeri pari e almeno 16 numeri dispari nell'intervallo da 1 a 40, allora con una certa probabilità esiste la possibilità che ci siano 36 numeri diversi nell'intervallo da 1 a 40 in uscita da questo blocco di codice.

GolfScript, 8

192
6#7
281

Attualmente la soluzione con il punteggio più alto. : P È stato bello finché è durato.

programmi

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

Di seguito i programmi di lavoro:

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

I valori generati sono: [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 uscite, 20 delle quali distinte (contrassegnate con una $)

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