Bon, a la base si j'ai commence ce jeu c'etait pour le defi de la resolution de chaque situation.

C'est-a-dire, comment faire pour trouver la meilleure solution possible (ou meme le bon compte) au moins 4 fois sur 5, et ce en basic pur?
Evidemment, comme c'est du basic pur, rechercher toutes les combinaisons est exclu (et meme en asm ca aurait bien dure une bonne minute, voire deux ou trois).
Il faut donc proceder logiquement, meme si il faut prendre plusieurs choix possibles.
J'ai quelques idees sur comment je vais faire, mais je ne vais pas les exposer de suite afin de ne pas vous influencer sur vos suggestions.

Alors aidez moi, emettez vos idees!

mouais...
Je dirais d'abord trouver 2 nombres qui se multiplient et proches du résultat à obtenir. Ensuite utiliser des additions/soustractions pour ajuster...

Après ça dépendra des nombres en question

C'est dans l'idee de ce que je vais faire dans un premier temps. D'autres idees?

en même temps c'est assez dur de programmer un 'bot' pour ça...

Tester toutes les combinaisons possibles ...
ça ne vous convient pas ? Pourquoi ?

Bon, ok, je sors

Je viens d'avoir une idée, mais ça risque d'être vraiment très très lent ...

1/Tenter d'avoir par multiplication un nombre parfaitement égal à celui rechercher, en ne multipliant que 2 nombres.
2/Ajuster en additions soustractions
3/si ça ne marche pas, recommencer avec 2 multiplications, puis refaire l'étape 2
4/Puis 3 multiplications ...
5/Une fois arriver à un certain nombre de multiplications, on introduit les divisions, quand le résultat d'une opération est un certain nombre de fois plus grand que le nombre recherché explication :

Spoiler:

Voilà, un peu compliqué, mais j'ai pas réussi à faire mieux ^^

mouais c'est ce que j'ai proposé en "mieux"

Hum, vu que mon message précédent était vraiment compliqué, il a de fortes chances de donner des idées. C'est ce qui s'est passé ^^

Je vais l'exposer de façon mathématiques, et j'espère, simple.
(E signifie "appartient à")

Soit r (XD) le dernier résultat obtenu avec une opération quelconque
Soit A la liste des nombres tirés au sort, s le nombre recherché, h un nombre quelconque, le plus petit possible, et X la liste des nombres utilisés, devenus non utilisables.


On commence par prendre r=max(A)

Si 2r=s+h et 2EA\{X}, alors 2r->r
Sinon si 3r=s+h et 3EA\{X}, alors 3r->r
...
Sinon, si 50r=s+h et 50EA\{X}, alors 50r->r (je ne vais pas à 100, car 100 est forcément utiliser)

Ici, le même résonnement avec des divisions

Sinon, si |s-(r+max(A\{X}))<|s-r|, alors r+ max(A\{X}->r
Sinon, si |s-(r+max(A\{X,max(A)}))<|s-r|, alors r+max(A\{X,max(A)})->r
...

En gros, le programme commence par approcher le nombre avec des multiplications, puis ajuste avec des additions et soustractions, mais en fonction de là où l'on met les boucles, on peut très bien tenter de multiplier/diviser, puis de additionner/soustraire.

v2g>Arf le mathématicien
Syfo>il nous manque des précisions : combien de nombres et aussi de cb à cb ces nombres ?

Waw! Merci pour toutes ces precisions v2g. Le debut (multiplier puis aditionner est ce que j'ai ecrit sur ma feuille de philo ce matin mais en plus detaille) ressemble au mien. Mais la suite est une excellente idee et je compte m'en inspirer. Merci bcp.

Quelques precisions: 100<nombre a trouver <800
Les nombres donnes: 6 nombres choisis dans la liste {100,50,50,25,25,10,10,9*4,8*4,7*4,6*4,5*4,4*4,3*4,2*4,1*4}

mouais...
il peut y avoir des très gros chiffres alors...

OSEF, c'est la calto qui gère

c'est vrai
mais ça peut être plus dur pour les multiplications

ba c'est juste ca a la limite qui sera lent



Voila des sites proposant des algorithmes :

http://www.lucas-nussbaum.net/writings.php?lceb
http://www.developpez.net/forums/showthread.php?t=64124
http://eternitygames.free.fr/LeCompteEstBon.html
http://www.chambily.com/recursivite/chap_IV_7.htm

Merci bien, mais 1) c'est dur a comprendre
2) il y en a un qui est facilement comprehensible, mais les deux solutions proposes necessitent de 1 a 2 millions de possibilites (soit 2-3 jours de recherche en basic pur ^^)
3) mon but est de resoudre ce probleme moi meme, c'est a dire juste avec mon cerveau, et les votres si vous etes disponibles.

Donc merci mais ce n'est pas ce que je cherche.

En fait en ce moment, je joue avec mon jeu un max de fois en notant comment je resoud a chaque fois.
Et j'ai mis la main sur une technique ('la technique de Syfo' (R) ) qui permet de trouver le bon compte une fois sur 5, et de s'en rapprocher une fois sur 2.
Je vous en parlerait en detail demain.

ok pour les sites que j'tai donné, c'était juste pour avoir des idées ^^

ok pour ta technique (R)

xD

:) cool

Alors voila ma technique, qui permettra je pense de resoudre 50% des cas (pas totalement mais au moins d'en etre tres proche):
-J'ai remarque qu'on a moins de mal a s'en rapprocher avec les nombres 10,25,75,100, surtout le 100 d'ailleurs. Quand on a au moins un de ces nombres on a pas trop de problemes, ca va tout seul avec multiplications puis additions/soustractions etc. Donc pas de prob pour le bot.
-Quand on a pas de 10, 2 fois sur 3 on peux en 'creer' un (5*2,7+3,4+6,etc) avec deux nombres, et quasiment a chaque fois (4 fois sur 5 je dirais) avec 3 nombres.
-A partir de la, il est assez simple de 'creer' le nombre a multiplier par 10 pour obtenir un nombre compris entre (N est le nombre a trouver) N-9<N<N+9
-et la c'est fini! Si il reste des nombres on peux encore s'en approcher ou meme l'atteindre, mais en tout cas, on est proche du but.

Qu'en pensez vous?

bonne technique mais ça dépend des nombres qu'il reste

au fait, on est obligé de tout utiliser ?

ah oui bonne question !

Non j'pense pas, 'fin ça compliquerait encore plus les choses ...

tama a écrit:

bonne technique mais ça dépend des nombres qu'il reste

au fait, on est obligé de tout utiliser ?

Ca dépend des versions. La version actuellement la plus connue, c'est dans les chiffres et les lettres, et la SEULE solution, c'est de tout utiliser.

Ici, non. Si tu dois faire 300 et que tu as un '3' et un '100', tu n'utilises que ces deux la.
Mais j'avoue que tout utiliser serait plus dur (trop?)

bah ça change tout si on est pas obligé de tout utiliser...dans le jeu "officiel" c'est obligé il me semble

ya ça, en java, vous comprennez ?

class Solution {
int sol = 0;
int valeur = 0;
int[] chif_trav = new int[26];
int[] utilise = new int[26];
int nb_resultats_indermediaires = 0;
String[] etapes = new String[20];
int nb_etapes = 0;

Solution(int [] chiffres, int s) {
int temp = 0;
sol = s;
for (int i=0;i<26;i++) {
chif_trav[i] = 0;
}
for (int i=0;i<26;i++) {
utilise[i] = 0;
}
// On réparti les 6 chiffres d'une manière aléatoire
for (int i=0;i<6;i++) {
do {
temp =(int)Math.round((Math.random()*6));
if (temp==6) temp=0;
}
while (chif_trav[temp] != 0);
chif_trav[temp] = chiffres[i];
}
calcule();
}

public void calcule() {

int n1 = 0; int n2 = 0;
int nb1 = 0; int nb2 = 0;
int res = 0;int cpt = 0;
int op = 0;boolean ok = true;
int j=0;
while ((res != sol) && (cpt < 20) && (ok)) {
ok = false;
while (! ok) {
ok = true;
n1 = (int)Math.round((Math.random()*(6+ nb_resultats_indermediaires)));
if (n1>=6+nb_resultats_indermediaires) ok=false;
if (utilise[n1]==1) ok = false;
}
if (ok) utilise[n1]=1;
ok = false;
while (! ok) {
ok = true;
n2 = (int)Math.round((Math.random()*(6+ nb_resultats_indermediaires)));
if (n2>=6+nb_resultats_indermediaires) ok=false;
if (utilise[n2]==1) ok = false;
}
if (ok) utilise[n2]=1;
op = 0;
while (op == 0) {
nb1 = chif_trav[n1];
nb2 = chif_trav[n2];
op = (int)Math.round((Math.random()*4));
op = op + 1; // 1 = +, 2 = -, 3 = *, 4 = /

if (op>4) op=0; else
if ((op==4) && (nb2>nb1)) op=0; else
if ((op == 4) && ((nb1 % nb2) != 0)) op=0; else
if ( ((nb1==1) || (nb2==1)) && ((op==3) || (op==4))) op=0; else
if ( (nb2>=nb1) && (op==2)) op=0;

if (op != 0) {
String s = " "+nb1;
switch (op) {
case 1 : res = nb1 + nb2;s=s+" + ";break;
case 2 : res = nb1 - nb2;s=s+" - ";break;
case 3 : res = nb1 * nb2;s=s+" * ";break;
case 4 : res = nb1 / nb2;s=s+" / ";
}
if (res > 0) {
s=s+nb2+" = "+res;
etapes[cpt]=s;
cpt++;
chif_trav[6+nb_resultats_indermediaires]=res;
utilise[6+nb_resultats_indermediaires]=0;
nb_resultats_indermediaires++;
if ((valeur==0) || (get_diff() > Math.abs(res-sol))) {
valeur = res;
nb_etapes=cpt;
}
}
}
}
j=0;
ok=false;
for (int i=0;i<6+nb_resultats_indermediaires;i++)
if (utilise[i]==0) j++;
if (j>1) ok=true;
}
}

public int get_valeur() { return valeur;}

public int get_diff() { return Math.abs(valeur-sol
);}

Ca a l'air interessant. Mais j'ai vraiment du mal a tout comprendre.