Il y a 40 façons un dirigé chemin hamiltonien peut être effectué sur une grille 3 x 3:

Ce graphique ( grâce SP3000! ) Ne montre que les 20 chemins non orientés. Parcourez chaque ligne de couleur dans les deux sens pour les 40 trajectoires dirigées.

Défi

En utilisant uniquement du code ASCII imprimable , écrivez une grille de caractères 3 × 3, telle que:

ABC
DEF
GHI

Lorsque chacun des 40 chemins dirigés sont lus à partir de cette grille 40 une seule ligne, les programmes 9 caractères, l'objectif est d'avoir chaque sortie de programme un entier unique de 1 à 40. Faire cela pour tous les 40 chemins semble difficile et peu probable, il vous suffit donc de le faire fonctionner pour autant de chemins que possible.

La soumission dont les 40 programmes de trajectoire génèrent les nombres les plus distincts de 1 à 40 sera gagnante. Tiebreaker va à la soumission précédente.

Les programmes de trajectoire qui génèrent une erreur ou ne génèrent pas un entier compris entre 1 et 40 ou un autre qu'un autre programme de trajectoire déjà traité ne sont pas comptés. Plus précisément:

• Les programmes qui rencontrent des erreurs lors de la compilation, de l'exécution ou de la sortie ne sont pas comptés. Les avertissements sont ok.
• Les programmes qui ne génèrent pas un entier compris entre 1 et 40 ni un élément légèrement mal formé tel que -35ou 35 36ne sont pas comptés.
• Les programmes qui nécessitent une entrée utilisateur pour produire la sortie ne sont pas comptés.
• Les programmes qui ne finissent jamais ne sont pas comptés.
• A partir de maintenant , les programmes qui ne sont pas déterministes ne sont pas comptés.
• Sinon, les programmes valides qui génèrent un nombre entier compris entre 1 et 40 et qui sont déjà générés par un autre programme valide ne sont pas comptés. (Le premier programme est compté.)
• Seuls les programmes qui produisent des représentations entières de nombres compris entre 1 et 40 (inclus) sont comptés dans votre total. Les chiffres devraient être l'habituel 1, 2..., 39, le 40format, à moins que ce n'est pas la norme pour votre langue. (Un retour à la ligne dans la sortie est acceptable.)
• Les numéros de sortie de vos programmes et leur ordre d'importance importent peu. Seul le nombre d'entiers distincts des programmes valables est important.

Tous les programmes de chemin doivent être exécutés dans la même langue. Cependant, les "programmes" peuvent en fait être des fonctions (sans arguments requis) ou REPL commandes , ainsi que des programmes complets, qui impriment ou renvoient leur entier cible. Vous pouvez combiner des fonctions, des commandes REPL et des programmes complets.

Vos 9 caractères ASCII imprimables ne doivent pas nécessairement être distincts.

Exemple

Si votre grille 3 × 3 était

ABC
DEF
GHI

et vos 40 programmes et sorties ressemblaient à ceci

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"

votre score serait de 14, car il y a 14 nombres entiers distincts de 1 à 40 validés, à savoir 26 2 6 3 4 33 8 22 11 30 39 7 29 1.

PARI / GP - 24

1%1
 8
2+3

PARI / GP ignore les espaces entre les chiffres, de sorte que 1 8 2, par exemple, est traité comme 182. La même chose pourrait fonctionner pour perl en remplaçant les espaces par des traits de soulignement. Je n'ai pas épuisé la totalité de l'espace de recherche, il pourrait donc y avoir de meilleurs candidats.

Un programme peut être transmis à gp en tant que gp -q -f program.gp, ou de manière interactive dans le repl.

Sortie

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

Toutes les valeurs sauf 4 se situent dans la plage requise, avec 12 entrées en double.

Mise à jour

J'ai fini de travailler, il y a six 23 différents, et un seul 24 (tel que lu par rangées):

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]

Le programme que j'ai utilisé pour le crunching est ci-dessous. PARI / GP a des capacités de traitement de chaîne limitées, il est donc préférable de traiter avec des tableaux de caractères (aka Vecsmall). Les opérateurs testés sont +, -, *, \(div étage), %, ;(séparateur d'expression, tout essentiellement les rejets avant), et (espace, tel que décrit ci - dessus). L'opérateur exposant ^pourrait également être ajouté, mais il devient trop lent pour effectuer un test exhaustif.

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

Les poissons morts , 18

C’était en fait la première langue que j’ai essayée avant de considérer les opérateurs infix. Je le publie maintenant pour la pure hilarité de l'idée que Deadfish pourrait être utile à quelque chose.

iii
ios
sii

Pour ceux qui ne connaissent pas Deadfish, l' iincrément, le scarré et la osortie, l'accumulateur commence à 0 (il y a aussi une 4ème instruction dde décrémentation non utilisée ici). Le fait que nous n’ayons pas d’impression automatique et que nous n’ayons pas besoin d’utiliser oest un inconvénient majeur, mais étonnamment, Deadfish n’a pas une très bonne image ici, tout bien considéré. Il s'avère que l'emplacement optimal de l'opérateur de sortie est au milieu.

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 et beaucoup d'autres, 22 23

6+7
*5%
6%4

Observation clé: si vous colorez la grille comme un damier, le chemin alterne les couleurs de la grille au fur et à mesure, et commence et se termine de la même couleur.

Toujours brute forçant pour le meilleur. Essayer avec +*%(et même **pour les langues où il ^y a une exponentiation) n’a malheureusement rien donné de mieux. J'ai également essayé de lancer dans les opérateurs de bitwise et seulement ^(xor) a semblé aider légèrement, mais la recherche prenait trop de temps alors j'ai abandonné.

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

Cela ne génère que des nombres valides, mais beaucoup sont des doublons. Les valeurs uniques sont 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Vous pouvez certainement faire mieux en changeant les opérateurs et les nombres entiers impliqués.

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 *

Si vous êtes assez chanceux!

x;x
lxl
xnx

Comme le défi ne nécessite pas que le code soit déterministe, il suffit de prouver qu'il est possible (même si cela est improbable) de renvoyer 36 nombres et nous avons terminé. C'était bien pendant que ça durait je suppose.

(Pour ceux qui ne connaissent pas> <>, une excellente introduction peut être trouvée ici )

> <> est un langage 2D basé sur une pile. Cela signifie que les instructions ne sont pas exécutées de manière linéaire comme dans la plupart des langages traditionnels - le déroulement du programme peut être ascendant, descendant, gauche ou droit!

J'ai décidé d'utiliser l'instruction "x" dans> <>, ce qui modifie la direction des pointeurs d'instruction en haut, en bas, à gauche ou à droite de manière aléatoire. Puisque notre code ne sera qu'une ligne, cela signifie que nous ne pouvons regarder que dans les cas où il va à droite ou à gauche, car si le pointeur monte ou descend, il ne fera que taper à nouveau sur l'instruction "x".

L'instruction "n" fait apparaître le numéro en haut de la pile et l'imprime. Cependant, si la pile est vide et qu'il n'y a rien à faire apparaître, une erreur est générée.

L'instruction "l" insère simplement la longueur de la pile dans la pile (et heureusement pour nous, elle n'envoie pas d'erreur si la pile est vide). Ainsi, par exemple, si la pile était vide et que "l" serait appelé, il pousserait 0 sur la pile. Si nous appelons à nouveau "l", alors comme la pile a un élément (0), elle pousserait 1 en haut de la pile et cela signifierait qu'il y aurait deux choses sur la pile et que cela signifierait que si nous devions appeler "l" à nouveau, nous appellerions 2 sur la pile, etc. Ainsi, nous pouvons utiliser "l" pour envoyer un nombre arbitraire sur la pile via la méthode indiquée précédemment.

Le ";" l'instruction termine le programme.

L'idée d'utiliser "x" est que, par exemple, s'il n'y avait qu'un "x" dans le code (où A, B, C, D sont des instructions):

ABCx;D

Le programme exécuterait A puis B puis C, et en atteignant "x", nous aurions deux possibilités: le code continue à aller à droite et frappe le ";" et quitte ou il va à gauche et exécute C puis B puis A puis D et seulement ensuite. Donc, si notre code contient un "x", le programme obtient deux flux de programme possibles parmi lesquels nous pouvons choisir le programme le mieux adapté.

Si il y a deux "x" ou plus, nous obtenons un nombre infini de flux de programme possibles.

Notre code a cinq "x", de plus, chacun d'entre eux est dans une "cellule de départ" des chemins hamiltoniens, ce qui signifie que chaque programme commence par un "x" et que chaque programme a la structure suivante:

xAxBxCxDx

Où A, B, C, D appartiennent à {; , n, l, l} Cela signifie qu'il n'y a que 12 programmes uniques. De plus, comme nous commençons toujours par un "x", nous pouvons examiner le cas où le programme va à gauche, ainsi les programmes symétriques peuvent également être considérés comme identiques. Jusqu'à la symétrie, il n'y a que 6 programmes possibles. Seuls 4 d’entre eux apparaissent dans les programmes générés sous forme de chemins hamiltoniens:

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

Regardons le premier programme "xnxlxlx; x" si nous allons directement à la première étape, nous appuyons sur la commande print qui provoquera une erreur car nous n’avons rien sur la pile. Si nous allons à gauche, nous frappons la commande du programme final. Nous ne pouvons donc générer aucun nombre à partir de ces programmes.

Le deuxième programme, "xlxnxlx; x", est beaucoup plus prometteur, puisqu’en allant au début, un zéro est placé sur la pile, si nous allons à gauche au prochain "x", notre pile gagne un, puis En reprenant à droite, nous avons un 2 que nous pouvons ensuite imprimer et continuer tout droit pour mettre fin au programme. Nous pouvons observer que nous pouvons réellement imprimer n'importe quel nombre pair , puisque dans la partie "xlx" au début, nous pouvons atteindre un nombre de taille arbitraire en allant à droite puis à gauche, puis à nouveau à droite un certain nombre de fois.

De même, on peut voir que le troisième programme xnxlx; xlx peut générer n’importe quel nombre impair , en allant à gauche au début, puis en répétant la routine "xlx" seulement cette fois en allant à gauche puis à droite puis à gauche.

Et le quatrième programme est essentiellement identique au deuxième programme et peut générer n'importe quel nombre pair .

Donc, pour les programmes requis, nous avons:

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)

C'est 4 programmes qui ne peuvent pas sortir des nombres, 20 qui peuvent sortir n'importe quel nombre pair, 16 qui peuvent sortir n'importe quel nombre impair. Puisqu'il y a exactement 20 nombres pairs et au moins 16 nombres impairs dans la plage allant de 1 à 40, il est possible, avec une certaine probabilité, qu'il y ait 36 ​​nombres différents dans la plage allant de 1 à 40 émis par ce bloc de code.

GolfScript, 8

192
6#7
281

Actuellement la solution la plus performante. : P était bien pendant que ça durait.

Programmes

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

Ci-dessous les programmes de travail:

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

Les valeurs générées sont: [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 sorties, 20 d’entre elles distinctes (marquées d’un $ )

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