@clem0338
Dans le vrai jeu non, mais dans le code de aardman/BruNews ça peut arriver. Ça change pas grand chose...
J'ai fixé ce problème en mettant le plus grand chiffre à gauche dans les calculs, comme ça on a plus de chiffre négatif.

if (a>b)
{
   res1 = a - b;
   res2 = a + b;
   res3 = a * b;
   res4 = a / b; // plus test si la solution est un nombre entier...
}
else
{  
   res1 = b - a;
   res2 = b + a;
   res3 = b * a;
   res4 = b / a; // plus test si la solution est un nombre entier...
}

un autre pour la route :

    numbers : 4 2 5 7 9 100
    number to find : 564


---------------------------------------------
        mon code :
946 calculs en 94 (millisecondes)
calculs :
   7 +  4 = 11
   100 +  11 = 111
   111 *  5 = 555
   555 +  9 = 564

---------------------------------------------
        autre code :
51426 calculs en 16 (millisecondes)
calculs :
   4 * 2 = 8
   7 * 9 = 63
   5 - 63 = -58
   8 * -58 = -464
   100 - -464 = 564

Je me suis amusé a comparer les 2 codes :
je place un compteur quand on check le résultat actuel et la solution (a chaque fois qu'on fait un calcul en fait)
je place un chrono sur chaque code (entre debut et fin du calcul)

j'ai obtenu cet exemple, assez significatif...
exemple :
numbers : 8 9 6 10 100 7
number to find : 306

---------------------------------------------
        mon code :
325 calculs en 47 (millisecondes)
calculs :
   7 *  6 = 42
   42 -  8 = 34
   34 *  9 = 306


---------------------------------------------
        autre code :
7807 calculs en 0 (millisecondes)
calculs :
   8 + 9 = 17
   6 * 17 = 102
   10 - 7 = 3
   102 * 3 = 306


conclusion:
mon code résous le problème "mieux" (3 lignes contre 4 lignes)
mon code effectue moins de calculs aussi (300 contre 7000 ...)
Mais, il est 100 fois plus lent (47 contre 0)...

C'est la fête ...

@ BruNews
Joli.
Les deux code réalisent le même travail, mais de manière différentes. Mais dans ce cas, la récursivité est beaucoup plus rapide.

J'ai basé mon code sur l'idée de ne jamais avoir a refaire un calcul : calcul effectué une fois, stocké dans un conteneur set, puis réutilisable par un n½ud de l'arbre plus profond que le n½ud actuel.
De même, ton code ne refait pas 2 fois le même calcul, mais la manière dont sont stockés les calculs temporaires et relancés pour de nouveaux calcul sont terriblement plus efficace...

Je pense que le ralentissement vient du fait que je crée une multitude de conteneur ???

Jolie la manière pour garder une trace des résultats dans un tableau de char.