Le Compte est bon
Publié : lun. 31/déc./2018 16:41
Bonjour à tous
Bonne année et bonne santé et mes meilleurs vœux pour l’année 2019.
Je pense que tout un chacun connait le jeu le compte est bon de l’émission des chiffres et des lettres.
Je vais ici rappeler les règles de ce jeu.
On tire au hasard 6 plaquettes dans un jeu de 28 possibilités composées comme ci-dessous :
20 plaques numérotées de 1 à 10 (2 par nombre)
2 plaques de 25
2 plaques de 50
2 plaques de 75
2 plaques de 100
On tire ensuite au hasard un nombre compris entre 100 et 999 comme objectif.
Le joueur doit, avec les 4 opérations et les 6 plaquettes de départ en ne choisissant qu’une seule fois chaque plaquette, obtenir le nombre tiré comme objectif.
Il faut trouver la solution en faisant des opérations mathématiques sur les 6 premiers nombres en ne les utilisant qu'une fois. On reste dans le domaine des entiers naturels (donc positifs). On dispose de quatre opérations : " +, -, *, / ". La division ne doit pas avoir de reste supérieur à 0.
Il existe certains jeux pour lesquels il n'est pas possible d'utiliser une stratégie. Le jeu du "Compte est bon" en est une bonne illustration.
Déterminons une stratégie de solution.
Si l’on prend 2 nombres parmi les 6 plaquettes on peut leurs appliquer théoriquement les 4 opérations
Et si nous remplaçons le résultat pour ces 2 nombres nous avons réduit le pb à 5 plaquettes.
En suivant ce principe aux 5 nombres on peut le réduire à 4 plaquettes.
Et ainsi de suite jusqu’à n’avoir plus qu’un nombre en testant à chaque opération si le nombre objectif est trouvé.
Nous pouvons calculer le nombre d’opérations théoriques maximales à réaliser.
Pour la réduction de 6 à 5 la combinaison de 2 pour 6 COMB(6,2=15 5*6/2=15 chaque couple peut supporter théoriquement les 4 opérations donc 15*4=60.
Pour la réduction de 5 à 4 la combinaison de 2 pour 5 COMB(5,2=10 5*4/2=10 chaque couple peut supporter théoriquement les 4 opérations donc 10*4=40.
(Nous avons 60 combinaisons à réduire de 5 à 4)
Continuons à réduire jusqu’à 1 seul nombre.
Nous aurons comb(2,6)*4*Comb(2,5)*4*Comb(2,4)*4*Comb(2,3)*4*comb(2,2)*4
60*40*24*12*4= 2 764 800 opérations maximales.
On voit apparaitre une répétition dans la réduction et la récursivité saute aux yeux.
C’est la première idée qui m’est venue. Mal m’en pris le pb n’est pas aussi simple qu’il y parait.
Je ne désespère pas d’y arriver, mais je vous propose ici une solution plus classique.
Vous pourrez remarquer que les procédures : solution, solution5 solution4 solution3 solution2 sont des procédures identiques qui peuvent être réalisées en programmation récursive.
Je vous laisse la possibilité de réaliser cette procédure récursive.
Principe de fonctionnement du prg Le compte est bon
Pour conserver les règles du jeu télévisé laisser les 3 checkbox qui suivent :
(Tri Tri ascendant Pas de valeur double) Tri et Tri ascendant peuvent être cochés mais ‘’ pas de valeur double’’ n’est pas conforme à la règle du jeu car toutes les plaquettes peuvent être doublées.
Le fait que 2 plaquettes d’origine puissent être en double multiplie le nombre de solutions.
Les solutions sont présentées en commençant par celles qui utilisent le moins d’opérations possibles.
Pour rester dans les règles du jeu.
Cliquez sur ‘’Change tout’’ et sur ‘’recherche solution’’.
Vous pouvez tout en gardant les plaquettes :
Changer l’objectif Cliquez sur ‘’ Change objectif ‘’ et sur ‘’recherche solution’’.
Amusez vous bien.
En dehors des règles du jeu vous pouvez par exemple placez dans les plaquettes 7 pour toutes les plaquettes et comme objectif 100 vous obtenez comme résultat unique.
7+7=14
14*7=98
7+7=14
14/7=2
98+2=100 CQFD
Le compte est bon 1080 solutions en 5 opérations en fait chaque plaquette est considérée par le prg comme unique or comme une plaquette peut être remplacée par une autre il n’y a qu’une seule solution. Si vous déroulez les solutions par suivant vous obtiendrez toujours la même solution.
En effet 7(1) 7(2) 7(3) 7(4) 7(5) et 7(6) sont considérés par le prg comme différents.
Donc toutes le combinaisons entre eux ainsi que les résultats entre résultats intermédiaires sont superflues.
D’une manière générale s’il existe 2 plaquettes identiques au moins il y aura des solutions identiques.
C’est pourquoi j’ai placé la checkbox ‘Pas de valeur double ‘’ en tirage aléatoire
A+
Bonne année et bonne santé et mes meilleurs vœux pour l’année 2019.
Je pense que tout un chacun connait le jeu le compte est bon de l’émission des chiffres et des lettres.
Je vais ici rappeler les règles de ce jeu.
On tire au hasard 6 plaquettes dans un jeu de 28 possibilités composées comme ci-dessous :
20 plaques numérotées de 1 à 10 (2 par nombre)
2 plaques de 25
2 plaques de 50
2 plaques de 75
2 plaques de 100
On tire ensuite au hasard un nombre compris entre 100 et 999 comme objectif.
Le joueur doit, avec les 4 opérations et les 6 plaquettes de départ en ne choisissant qu’une seule fois chaque plaquette, obtenir le nombre tiré comme objectif.
Il faut trouver la solution en faisant des opérations mathématiques sur les 6 premiers nombres en ne les utilisant qu'une fois. On reste dans le domaine des entiers naturels (donc positifs). On dispose de quatre opérations : " +, -, *, / ". La division ne doit pas avoir de reste supérieur à 0.
Il existe certains jeux pour lesquels il n'est pas possible d'utiliser une stratégie. Le jeu du "Compte est bon" en est une bonne illustration.
Déterminons une stratégie de solution.
Si l’on prend 2 nombres parmi les 6 plaquettes on peut leurs appliquer théoriquement les 4 opérations
Et si nous remplaçons le résultat pour ces 2 nombres nous avons réduit le pb à 5 plaquettes.
En suivant ce principe aux 5 nombres on peut le réduire à 4 plaquettes.
Et ainsi de suite jusqu’à n’avoir plus qu’un nombre en testant à chaque opération si le nombre objectif est trouvé.
Nous pouvons calculer le nombre d’opérations théoriques maximales à réaliser.
Pour la réduction de 6 à 5 la combinaison de 2 pour 6 COMB(6,2=15 5*6/2=15 chaque couple peut supporter théoriquement les 4 opérations donc 15*4=60.
Pour la réduction de 5 à 4 la combinaison de 2 pour 5 COMB(5,2=10 5*4/2=10 chaque couple peut supporter théoriquement les 4 opérations donc 10*4=40.
(Nous avons 60 combinaisons à réduire de 5 à 4)
Continuons à réduire jusqu’à 1 seul nombre.
Nous aurons comb(2,6)*4*Comb(2,5)*4*Comb(2,4)*4*Comb(2,3)*4*comb(2,2)*4
60*40*24*12*4= 2 764 800 opérations maximales.
On voit apparaitre une répétition dans la réduction et la récursivité saute aux yeux.
C’est la première idée qui m’est venue. Mal m’en pris le pb n’est pas aussi simple qu’il y parait.
Je ne désespère pas d’y arriver, mais je vous propose ici une solution plus classique.
Vous pourrez remarquer que les procédures : solution, solution5 solution4 solution3 solution2 sont des procédures identiques qui peuvent être réalisées en programmation récursive.
Je vous laisse la possibilité de réaliser cette procédure récursive.
Principe de fonctionnement du prg Le compte est bon
Pour conserver les règles du jeu télévisé laisser les 3 checkbox qui suivent :
(Tri Tri ascendant Pas de valeur double) Tri et Tri ascendant peuvent être cochés mais ‘’ pas de valeur double’’ n’est pas conforme à la règle du jeu car toutes les plaquettes peuvent être doublées.
Le fait que 2 plaquettes d’origine puissent être en double multiplie le nombre de solutions.
Les solutions sont présentées en commençant par celles qui utilisent le moins d’opérations possibles.
Pour rester dans les règles du jeu.
Cliquez sur ‘’Change tout’’ et sur ‘’recherche solution’’.
Vous pouvez tout en gardant les plaquettes :
Changer l’objectif Cliquez sur ‘’ Change objectif ‘’ et sur ‘’recherche solution’’.
Amusez vous bien.
En dehors des règles du jeu vous pouvez par exemple placez dans les plaquettes 7 pour toutes les plaquettes et comme objectif 100 vous obtenez comme résultat unique.
7+7=14
14*7=98
7+7=14
14/7=2
98+2=100 CQFD
Le compte est bon 1080 solutions en 5 opérations en fait chaque plaquette est considérée par le prg comme unique or comme une plaquette peut être remplacée par une autre il n’y a qu’une seule solution. Si vous déroulez les solutions par suivant vous obtiendrez toujours la même solution.
En effet 7(1) 7(2) 7(3) 7(4) 7(5) et 7(6) sont considérés par le prg comme différents.
Donc toutes le combinaisons entre eux ainsi que les résultats entre résultats intermédiaires sont superflues.
D’une manière générale s’il existe 2 plaquettes identiques au moins il y aura des solutions identiques.
C’est pourquoi j’ai placé la checkbox ‘Pas de valeur double ‘’ en tirage aléatoire
Code : Tout sélectionner
;DisableExplicit
EnableExplicit
Global Window_1
Global Texte_1
Enumeration FormGadget
#Checkbox_0
#Checkbox_1
#Checkbox_2
#Combo_2
#Combo_2_Copy1
#Combo_2_Copy2
#Combo_2_Copy3
#Combo_2_Copy4
#Combo_2_Copy5
#Button_0
#Editor_0
#Text_1
#Button_1
#Button_1_Copy1
#ListView_0_Copy1
#Text_4
#Text_4_Copy1
#Text_4_Copy1_Copy1
#Text_4_Copy1_Copy1_Copy1
#Text_4_Copy1_Copy1_Copy1_Copy1
#Button_4
#Button_4_Copy1
EndEnumeration
Procedure OpenWindow_1(x = 0, y = 0, width = 630, height = 470)
Window_1 = OpenWindow(#PB_Any, x, y, width, height, "", #PB_Window_SystemMenu)
Texte_1 = TextGadget(#PB_Any, 20, 20, 550, 25, " L E C O M P T E E S T B O N", #PB_Text_Center)
CheckBoxGadget(#Checkbox_0, 30, 60, 170, 20, "Tri")
CheckBoxGadget(#Checkbox_1, 210, 60, 190, 20, "Tri ascendant")
CheckBoxGadget(#Checkbox_2, 410, 60, 180, 20, "Pas de valeur double")
ComboBoxGadget(#Combo_2, 30, 120, 70, 20)
; AddGadgetItem(#Combo_2, -1, "1")
ComboBoxGadget(#Combo_2_Copy1, 130, 120, 70, 20)
; AddGadgetItem(#Combo_2_Copy1, -1, "2")
ComboBoxGadget(#Combo_2_Copy2, 230, 120, 70, 20)
; AddGadgetItem(#Combo_2_Copy2, -1, "3")
ComboBoxGadget(#Combo_2_Copy3, 330, 120, 70, 20)
; AddGadgetItem(#Combo_2_Copy3, -1, "4")
ComboBoxGadget(#Combo_2_Copy4, 430, 120, 70, 20)
; AddGadgetItem(#Combo_2_Copy4, -1, "5")
ComboBoxGadget(#Combo_2_Copy5, 530, 120, 70, 20)
; AddGadgetItem(#Combo_2_Copy5, -1, "6")
ButtonGadget(#Button_0, 190, 170, 170, 30, "Change TOUT")
EditorGadget(#Editor_0, 190, 240, 50, 20)
TextGadget(#Text_1, 190, 220, 50, 20, "Objectif")
ButtonGadget(#Button_1, 260, 240, 100, 20, "Change Objectif")
ButtonGadget(#Button_1_Copy1, 190, 270, 170, 30, "Cherche Solution")
ListViewGadget(#ListView_0_Copy1, 350, 320, 210, 100)
TextGadget(#Text_4, 30, 320, 260, 20, "")
TextGadget(#Text_4_Copy1, 30, 350, 260, 20, "")
TextGadget(#Text_4_Copy1_Copy1, 30, 380, 260, 20, "")
TextGadget(#Text_4_Copy1_Copy1_Copy1, 30, 410, 260, 20, "")
TextGadget(#Text_4_Copy1_Copy1_Copy1_Copy1, 30, 440, 260, 20, "")
ButtonGadget(#Button_4, 350, 430, 90, 30, "Précédent")
ButtonGadget(#Button_4_Copy1, 470, 430, 90, 30, "Suivant")
EndProcedure
; Procedure Window_1_Events(event)
; Select event
; Case #PB_Event_CloseWindow
; ProcedureReturn #False
;
; Case #PB_Event_Menu
; Select EventMenu()
; EndSelect
;
; Case #PB_Event_Gadget
; ; debug eventGadget()
; Select EventGadget()
; EndSelect
; EndSelect
; ProcedureReturn #True
; EndProcedure
; 20 plaques numérotées de 1 à 10 (2 par nombre)
; 2 plaques de 25
; 2 plaques de 50
; 2 plaques de 75
; 2 plaques de 100
structure solutpart
; NB.l
plag.l[7]
object.l
diff.L
Nbopmin.l
structureunion
solut_alpa.s{80}
solut_alp.s{16}[5]
endstructureunion
endstructure
structure restei
StructureUnion
va.a[8]
vq.q
EndStructureUnion
endstructure
; structure isav
; nb.l
; i.l
; j.l
; adres.l
; endstructure
; procedure initgen()
; dim plaqorig.i(7)
global dim nbtrouv(5)
global diff_min.q=$7FFFFFFFFFFFFFFF
global newlist result.solutpart()
global resultpart.solutpart
; global dim tabind.isav(6)
; plaqorigo.solutpart
; openconsole()
global flag_nbu=0 ;;; si 1 les nombres sont uniques, avec 0 on peut avoir 2 nombres identiques
global flag_nbt=0 ;;; si 1 les nombres sont triés, avec 0 il n'y a pas de tri
global flag_nbta=0 ;;; si 1 les nombres sont triés en ordre ascendant, avec 0 il ya un tri descendant
; global *adplaqor61=AllocateMemory(sizeof(solutpart))
; global *adplaqor62=AllocateMemory(sizeof(solutpart))
global plaqorigo.s{80}
; procedure impp(*plaqo.solutpart)
; static imp$, imp
; imp$=""
; for imp=0 to *plaqo\plag[0]
; imp$+" "+str(*plaqo\plag[imp])
; Next
; imp$+" "+_n(*plaqo\object)+" "+_s(*plaqo\solut_alpa)
; ; debug _nl+_n(*plaqo)+_s( imp$)
; endprocedure
procedure init(*PLAqori.solutpart)
EnableExplicit
static tab$,nbi,i,x,jj
;_________0____-----1----_____2____-----3----_____4____-----5----_____6____-----7----_____8____-----9----_____A____-----B
;_____1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345
tab$="001,001,002,002,003,003,004,004,005,005,006,006,007,007,008,008,009,009,010,010,025,025,050,050,075,075,100,100"
dim tabtir.i(27)
dim tabplaq(5)
nbi=0
for i=1 to 6
LAB1: ;;; boucle pour ne prendre qu'une seule fois le nombre qui malgré tout peut être en double
nbi+1
x= random(27,0)
; x= random(6,0)
if tabtir(x)=0 ;; and x%2=0
; debug _n(x)+_s(mid(tab$,x*4+1,3))+_n(x*4+1)
; *plaqori\solut_alpa=mid(tab$,x*4+1,3)
*plaqori\plag[i]=val(mid(tab$,x*4+1,3))
tabplaq(i-1)=*plaqori\plag[i]
; debug _n(x)
tabtir(x)+1
;;;;******************** Test pour n'avoir qu'un seul et même nombre ***************************
if flag_nbu=1 ;;;; si 1 les nombres sont uniques avec 0 opeut avoir 2 nombres identiques
if x%2=1
tabtir(x-1)+1
else
tabtir(x+1)+1
endif
endif
;;;;******************** Test pour n'avoir qu'un seul et même nombre ***************************
else
GOTO LAB1 ;;;;fin de la boucle
endif
; debug _n(x)+_n(nbi)+_n(val(mid(tab$,x*4+1,3)))+_n(tabtir(x))
next
if flag_nbt=1 ;;;;; avec 1 test pour trier les nombres avec 0 pas de tri
; SortArray(tabplaq(),#PB_Sort_Ascending )
if flag_nbta=0
SortArray(tabplaq(),#PB_Sort_Descending)
Else
SortArray(tabplaq(),#PB_Sort_Ascending )
endif
endif
for jj=0 to 5
*plaqori\plag[jj+1]=tabplaq(jj)
; debug _n(combo_2+jj)+_n(tabplaq(jj))
SetGadgetText(#Combo_2+jj,str(tabplaq(jj)))
next
*plaqori\plag[0]=6
*plaqori\object=random(999,100)
SetGadgetText(#Editor_0,str(*plaqori\object))
;;; force les valeurs 2 75 10 19 25 1 888
; *plaqori\plag[1]=2
; *plaqori\plag[2]=75
; *plaqori\plag[3]=10
; *plaqori\plag[4]=10
; *plaqori\plag[5]=1
; *plaqori\object=889
DisableExplicit
EndProcedure
procedure.q reste(i,j,nb)
EnableExplicit
static res.restei,rest$,r
static dim treste.i(7)
; res.restei
rest$=""
res\va[0]=0
for r=1 to nb
if r=i or r=j
else
res\va[0]+1
res\va[res\va[0]+1]=r
; rest$ +str(r)+" "
endif
next
res\va[0]+1
procedurereturn res\vq
endprocedure
procedure.l operationposs(nb1,nb2)
EnableExplicit
define result
;;opérations possibles
;; 8 add possible
;; 4 mult possible
;; 2 sous possible
;; 1 div possible
;; 16 division possible en inversant les 2 termes
;; l'addition est toujours possible
result=8
if abs(nb1-nb2)>0
result+2
endif
if nb1>1 and nb2>1
result+4
; if nb1<> nb2
if nb1%nb2=0
result+1
Elseif nb2%nb1=0
result+16
endif
endif
; endif
procedurereturn result
DisableExplicit
endprocedure
procedure solution2(*plaqor.solutpart)
EnableExplicit
static i ,j , imp$,imp
EnableExplicit
static result.q, diff.q
static rest.restei, result$, rst,nb1,nb2,oper,jj,orig$, nbmut,nbop,nbrest,nb
static dim tabres2.solutpart(5,3)
nb=*plaqor\plag[0]
nbmut=0
macro zcom2
copymemory ( tabres2(0,nbmut), tabres2(nbop,nbmut),sizeof(solutpart))
tabres2(nbop,nbmut)\plag[0]=Nbrest
tabres2(nbop,nbmut)\plag[1]=Result
tabres2(nbop,nbmut)\solut_alpa=result$
diff=abs(result-*plaqor\object)
tabres2(nbop,nbmut)\diff=diff
if diff=0
tabres2(nbop,nbmut)\Nbopmin=6-tabres2(nbop,nbmut)\plag[0]
nbtrouv(6-tabres2(nbop,nbmut)\plag[0])+1
AddElement(result())
CopyMemory(tabres2(nbop,nbmut),result(),sizeof(solutpart))
elseif diff<diff_min
copymemory(tabres2(nbop,nbmut),@resultpart,sizeof(solutpart))
diff_min=diff
resultpart\diff=diff
endif
endmacro
;*********************** début de la boucle des indices pour le premier opérateur choisi ***************
for i=1 to nb
;*********************** début de la boucle des indices pour le deuxième opérateur choisi **************
for j=i+1 to nb
nbmut+1
nbop=0
rest\vq=reste(i,j,nb)
Nbrest=rest\va[0]
; CopyMemory(@rest\va[0],@tabres2(1,nbmut)\plag[0],8)
;******* boucle pour retrouver les nombres qui restent à partir des indices autres que i et j choisis pour réaliser l'une des opérations
for rst=2 to Nbrest
tabres2(nbop,nbmut)\plag[rst]=*plaqor\plag[rest\va[rst]]
next
tabres2(0,nbmut)\object=*plaqor\object
; tabres2(0,nbmut)\solut_alpa=*plaqor\solut_alpa
;********* Recherche de nombres à partir des indices i et j choisis pour réaliser l'une des opérations ****************
tabres2(nbop,nbmut)\plag[0]=*plaqor\plag[i]
tabres2(nbop,nbmut)\plag[1]=*plaqor\plag[j]
;;; types d'opérations sur les 2 nombres choisis
nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
Result=nb1+nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
zcom2
OPER=operationposs(nb1,nb2)
;;; les 4 opération +=8 *=4 -=2 /=1 ou inverse /=16
if (oper&4)=4
;;; *************************************************************************** multiplication
nbop+1
Result=nb1*nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
zcom2
endif
;;;; ********************************************************************************************* soustraction
if (oper&2)=2
Result=abs(nb1-nb2)
if nb1>nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
else
result$=*plaqor\solut_alpa+left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
endif
nbop+1
zcom2
endif
;;;; ***********************************************************************************************FIN soustraction
if (oper&1)=1
;;;;; ************************************************************************************************** division 1
Result=nb1/nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
nbop+1
zcom2
endif
;;;;; **************************************************************************************************FIN division 1
;;;;; ************************************************************************************************** division 2
if (oper&16)=16
Result=nb2/nb1
result$=*plaqor\solut_alpa+left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
nbop+1
zcom2
endif
;;;;; **************************************************************************************************FIN division 2
;;; ********************************************************************************************** addition
;;; **************************************************************************** ******************FIN addition
next
next
DisableExplicit
EndProcedure
procedure solution3(*plaqor.solutpart)
EnableExplicit
static i ,j , imp$,imp
EnableExplicit
static result.q, diff.q
static rest.restei, result$, rst,nb1,nb2,oper,jj,orig$, nbmut,nbop,nbrest,nb
static dim tabres3.solutpart(5,3)
nb=*plaqor\plag[0]
nbmut=0
macro zcom3
copymemory ( tabres3(0,nbmut), tabres3(nbop,nbmut),sizeof(solutpart))
tabres3(nbop,nbmut)\plag[0]=Nbrest
tabres3(nbop,nbmut)\plag[1]=Result
tabres3(nbop,nbmut)\solut_alpa=result$
diff=abs(result-*plaqor\object)
tabres3(nbop,nbmut)\diff=diff
if diff=0
tabres3(nbop,nbmut)\Nbopmin=6-tabres3(nbop,nbmut)\plag[0]
nbtrouv(6-tabres3(nbop,nbmut)\plag[0])+1
AddElement(result())
CopyMemory(tabres3(nbop,nbmut),result(),sizeof(solutpart))
elseif diff<diff_min
copymemory(tabres3(nbop,nbmut),@resultpart,sizeof(solutpart))
diff_min=diff
resultpart\diff=diff
endif
solution2(@tabres3(nbop,nbmut))
endmacro
;*********************** début de la boucle des indices pour le premier opérateur choisi ***************
for i=1 to nb
;*********************** début de la boucle des indices pour le deuxième opérateur choisi **************
for j=i+1 to nb
nbmut+1
nbop=0
rest\vq=reste(i,j,nb)
Nbrest=rest\va[0]
; CopyMemory(@rest\va[0],@tabres3(1,nbmut)\plag[0],8)
;******* boucle pour retrouver les nombres qui restent à partir des indices autres que i et j choisis pour réaliser l'une des opérations
for rst=2 to Nbrest
tabres3(nbop,nbmut)\plag[rst]=*plaqor\plag[rest\va[rst]]
next
tabres3(0,nbmut)\object=*plaqor\object
; tabres3(0,nbmut)\solut_alpa=*plaqor\solut_alpa
;********* Recherche de nombres à partir des indices i et j choisis pour réaliser l'une des opérations ****************
tabres3(nbop,nbmut)\plag[0]=*plaqor\plag[i]
tabres3(nbop,nbmut)\plag[1]=*plaqor\plag[j]
;;; types d'opérations sur les 2 nombres choisis
nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
Result=nb1+nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
zcom3
OPER=operationposs(nb1,nb2)
;;; les 4 opération +=8 *=4 -=2 /=1 ou inverse /=16
; debug "*******"+_n(nb1)+_n(nb2)+_hq(rest\vq)
if (oper&4)=4
;;; *************************************************************************** multiplication
nbop+1
Result=nb1*nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
zcom3
endif
;;;; ********************************************************************************************* soustraction
if (oper&2)=2
Result=abs(nb1-nb2)
; result$=*plaqor\solut_alpa+left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
if nb1>nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
else
result$=*plaqor\solut_alpa+left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
endif
nbop+1
zcom3
endif
;;;; ***********************************************************************************************FIN soustraction
if (oper&1)=1
;;;;; ************************************************************************************************** division 1
Result=nb1/nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
nbop+1
zcom3
endif
;;;;; **************************************************************************************************FIN division 1
;;;;; ************************************************************************************************** division 2
if (oper&16)=16
Result=nb2/nb1
result$=*plaqor\solut_alpa+left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
nbop+1
zcom3
endif
;;;;; **************************************************************************************************FIN division 2
;;; ********************************************************************************************** addition
;;; **************************************************************************** ******************FIN addition
next
next
DisableExplicit
EndProcedure
procedure solution4(*plaqor.solutpart)
EnableExplicit
static i ,j , imp$,imp
EnableExplicit
static result.q, diff.q
static rest.restei, result$, rst,nb1,nb2,oper,jj,orig$, nbmut,nbop,nbrest,nb
static dim tabres4.solutpart(5,6)
nb=*plaqor\plag[0]
nbmut=0
macro zcom4
copymemory ( tabres4(0,nbmut), tabres4(nbop,nbmut),sizeof(solutpart))
tabres4(nbop,nbmut)\plag[0]=Nbrest
tabres4(nbop,nbmut)\plag[1]=Result
tabres4(nbop,nbmut)\solut_alpa=result$
diff=abs(result-*plaqor\object)
tabres4(nbop,nbmut)\diff=diff
if diff=0
tabres4(nbop,nbmut)\Nbopmin=6-tabres4(nbop,nbmut)\plag[0]
nbtrouv(6-tabres4(nbop,nbmut)\plag[0])+1
AddElement(result())
CopyMemory(tabres4(nbop,nbmut),result(),sizeof(solutpart))
elseif diff<diff_min
copymemory(tabres4(nbop,nbmut),@resultpart,sizeof(solutpart))
diff_min=diff
resultpart\diff=diff
endif
solution3(@tabres4(nbop,nbmut))
endmacro
;*********************** début de la boucle des indices pour le premier opérateur choisi ***************
for i=1 to nb
;*********************** début de la boucle des indices pour le deuxième opérateur choisi **************
for j=i+1 to nb
nbmut+1
nbop=0
rest\vq=reste(i,j,nb)
Nbrest=rest\va[0]
; CopyMemory(@rest\va[0],@tabres4(1,nbmut)\plag[0],8)
;******* boucle pour retrouver les nombres qui restent à partir des indices autres que i et j choisis pour réaliser l'une des opérations
for rst=2 to Nbrest
tabres4(nbop,nbmut)\plag[rst]=*plaqor\plag[rest\va[rst]]
next
tabres4(0,nbmut)\object=*plaqor\object
; tabres4(0,nbmut)\solut_alpa=*plaqor\solut_alpa
;********* Recherche de nombres à partir des indices i et j choisis pour réaliser l'une des opérations ****************
tabres4(nbop,nbmut)\plag[0]=*plaqor\plag[i]
tabres4(nbop,nbmut)\plag[1]=*plaqor\plag[j]
;;; types d'opérations sur les 2 nombres choisis
nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
Result=nb1+nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
zcom4
OPER=operationposs(nb1,nb2)
;;; les 4 opération +=8 *=4 -=2 /=1 ou inverse /=16
; debug "*******"+_n(nb1)+_n(nb2)+_hq(rest\vq)
if (oper&4)=4
;;; *************************************************************************** multiplication
nbop+1
Result=nb1*nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
zcom4
endif
;;;; ********************************************************************************************* soustraction
if (oper&2)=2
Result=abs(nb1-nb2)
if nb1>nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
else
result$=*plaqor\solut_alpa+left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
endif
nbop+1
zcom4
endif
;;;; ***********************************************************************************************FIN soustraction
if (oper&1)=1
;;;;; ************************************************************************************************** division 1
Result=nb1/nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
nbop+1
zcom4
endif
;;;;; **************************************************************************************************FIN division 1
;;;;; ************************************************************************************************** division 2
if (oper&16)=16
Result=nb2/nb1
result$=*plaqor\solut_alpa+left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
nbop+1
zcom4
endif
;;;;; **************************************************************************************************FIN division 2
;;; ********************************************************************************************** addition
;;; **************************************************************************** ******************FIN addition
next
next
DisableExplicit
EndProcedure
procedure solution5(*plaqor.solutpart)
EnableExplicit
static i ,j , imp$,imp
EnableExplicit
static result.q, diff.q
static rest.restei, result$, rst,nb1,nb2,oper,jj,orig$, nbmut,nbop,nbrest,nb
static dim tabres5.solutpart(5,10)
nb=*plaqor\plag[0]
nbmut=0
macro zcom5
copymemory ( tabres5(0,nbmut), tabres5(nbop,nbmut),sizeof(solutpart))
tabres5(nbop,nbmut)\plag[0]=Nbrest
tabres5(nbop,nbmut)\plag[1]=Result
tabres5(nbop,nbmut)\solut_alpa=result$
diff=abs(result-*plaqor\object)
tabres5(nbop,nbmut)\diff=diff
if diff=0
tabres5(nbop,nbmut)\Nbopmin=6-tabres5(nbop,nbmut)\plag[0]
nbtrouv(6-tabres5(nbop,nbmut)\plag[0])+1
AddElement(result())
CopyMemory(tabres5(nbop,nbmut),result(),sizeof(solutpart))
elseif diff<diff_min
copymemory(tabres5(nbop,nbmut),@resultpart,sizeof(solutpart))
diff_min=diff
resultpart\diff=diff
endif
solution4(@tabres5(nbop,nbmut))
endmacro
;*********************** début de la boucle des indices pour le premier opérateur choisi ***************
for i=1 to nb
;*********************** début de la boucle des indices pour le deuxième opérateur choisi **************
for j=i+1 to nb
nbmut+1
nbop=0
rest\vq=reste(i,j,nb)
Nbrest=rest\va[0]
; CopyMemory(@rest\va[0],@tabres5(1,nbmut)\plag[0],8)
;******* boucle pour retrouver les nombres qui restent à partir des indices autres que i et j choisis pour réaliser l'une des opérations
for rst=2 to Nbrest
tabres5(nbop,nbmut)\plag[rst]=*plaqor\plag[rest\va[rst]]
next
tabres5(0,nbmut)\object=*plaqor\object
; tabres5(0,nbmut)\solut_alpa=*plaqor\solut_alpa
;********* Recherche de nombres à partir des indices i et j choisis pour réaliser l'une des opérations ****************
tabres5(nbop,nbmut)\plag[0]=*plaqor\plag[i]
tabres5(nbop,nbmut)\plag[1]=*plaqor\plag[j]
;;; types d'opérations sur les 2 nombres choisis
nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
Result=nb1+nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
zcom5
OPER=operationposs(nb1,nb2)
;;; les 4 opération +=8 *=4 -=2 /=1 ou inverse /=16
if (oper&4)=4
;;; *************************************************************************** multiplication
nbop+1
Result=nb1*nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
zcom5
endif
;;;; ********************************************************************************************* soustraction
if (oper&2)=2
Result=abs(nb1-nb2)
if nb1>nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
else
result$=*plaqor\solut_alpa+left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
endif
nbop+1
zcom5
endif
;;;; ***********************************************************************************************FIN soustraction
if (oper&1)=1
;;;;; ************************************************************************************************** division 1
Result=nb1/nb2
result$=*plaqor\solut_alpa+left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
nbop+1
zcom5
endif
;;;;; **************************************************************************************************FIN division 1
;;;;; ************************************************************************************************** division 2
if (oper&16)=16
Result=nb2/nb1
result$=*plaqor\solut_alpa+left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
nbop+1
zcom5
endif
;;;;; **************************************************************************************************FIN division 2
;;; ********************************************************************************************** addition
;;; **************************************************************************** ******************FIN addition
next
next
DisableExplicit
EndProcedure
procedure solution(*plaqor.solutpart)
EnableExplicit
static imp$,imp
static result.q, diff.q, i,j
static rest.restei, result$, rst,nb1,nb2,oper,jj,orig$, nbmut,nbop,nbrest,nb
static dim tabres6.solutpart(5,15)
;;;; impression de *plaqor
; debug _nl+" impp"
; impp(*plaqor)
;;;; Fin impression
nb=*plaqor\plag[0]
nbmut=0
macro zcom
copymemory ( tabres6(0,nbmut), tabres6(nbop,nbmut),sizeof(solutpart))
tabres6(nbop,nbmut)\plag[0]=Nbrest
tabres6(nbop,nbmut)\plag[1]=Result
tabres6(nbop,nbmut)\solut_alpa=result$
diff=abs(result-*plaqor\object)
tabres6(nbop,nbmut)\diff=diff
if diff=0
tabres6(nbop,nbmut)\Nbopmin=6-tabres6(nbop,nbmut)\plag[0]
nbtrouv(6-tabres6(nbop,nbmut)\plag[0])+1
AddElement(result())
CopyMemory(tabres6(nbop,nbmut),result(),sizeof(solutpart))
elseif diff<diff_min
copymemory(tabres6(nbop,nbmut),@resultpart,sizeof(solutpart))
diff_min=diff
resultpart\diff=diff
endif
solution5(@tabres6(nbop,nbmut))
endmacro
; tabres6(nbop,nbmut)\Nbopmin=tabres6(nbop,nbmut)\plag[0]
;*********************** début de la boucle des indices pour le premier opérateur choisi ***************
for i=1 to nb
;*********************** début de la boucle des indices pour le deuxième opérateur choisi **************
for j=i+1 to nb
nbmut+1
nbop=0
result$=""
rest\vq=reste(i,j,nb)
Nbrest=rest\va[0]
;******* boucle pour retrouver les nombres qui restent à partir des indices autres que i et j choisis pour réaliser l'une des opérations
for rst=2 to Nbrest
tabres6(nbop,nbmut)\plag[rst]=*plaqor\plag[rest\va[rst]]
next
;;; ********************************************************************************************** addition
tabres6(0,nbmut)\object=*plaqor\object
;********* Recherche de nombres à partir des indices i et j choisis pour réaliser l'une des opérations ****************
tabres6(nbop,nbmut)\plag[0]=*plaqor\plag[i]
tabres6(nbop,nbmut)\plag[1]=*plaqor\plag[j]
;;; types d'opérations sur les 2 nombres choisis
nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
Result=nb1+nb2
result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
zcom
OPER=operationposs(nb1,nb2)
;;; les 4 opération +=8 *=4 -=2 /=1 ou inverse /=16
;;; **************************************************************************** ******************FIN addition
if (oper&4)=4
;;; *************************************************************************** multiplication
nbop+1
Result=nb1*nb2
result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
zcom
endif
;;;; ********************************************************************************************* soustraction
if (oper&2)=2
Result=abs(nb1-nb2)
if nb1>nb2
result$=left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
else
result$=left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
endif
nbop+1
zcom
endif
;;;; ***********************************************************************************************FIN soustraction
if (oper&1)=1
;;;;; ************************************************************************************************** division 1
Result=nb1/nb2
result$=left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
nbop+1
zcom
endif
;;;;; **************************************************************************************************FIN division 1
;;;;; ************************************************************************************************** division 2
if (oper&16)=16
Result=nb2/nb1
result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
nbop+1
zcom
endif
;;;;; **************************************************************************************************FIN division 2
next
next
SortStructuredList(result(),#PB_Sort_Ascending ,OffsetOf(solutpart\Nbopmin),typeof(solutpart\Nbopmin))
DisableExplicit
EndProcedure
procedure init_glob()
EnableExplicit
if resultpart\diff<>0
global dim nbtrouv(5)
global diff_min.q=$7FFFFFFFFFFFFFFF
ClearList(result())
global resultpart.solutpart
global flag_nbu=0 ;;; si 1 les nombres sont uniques, avec 0 on peut avoir 2 nombres identiques
global flag_nbt=0 ;;; si 1 les nombres sont triés, avec 0 il n'y a pas de tri
global flag_nbta=0 ;;; si 1 les nombres sont triés en ordre ascendant, avec 0 il ya un tri descendant
ClearGadgetItems(#ListView_0_Copy1)
endif
DisableExplicit
endprocedure
procedure boutonplaq()
ClearGadgetItems(#ListView_0_Copy1)
for jj=0 to 4
setgadgettext(#Text_4+jj," ")
next
DisableExplicit
endprocedure
Procedure BoutonFlag()
select eventgadget()
Case 0
if GetGadgetState(0)=#PB_CheckBox_Checked
flag_nbt=1
Else
flag_nbt=0
endif
Case 1
if GetGadgetState(1)=#PB_CheckBox_Checked
flag_nbta=1
Else
flag_nbta=0
endif
Case 2
if GetGadgetState(2)=#PB_CheckBox_Checked
flag_nbu=1
Else
flag_nbu=0
endif
endselect
DisableExplicit
EndProcedure
Procedure BoutonChargeAleas()
EnableExplicit
static jj
ClearGadgetItems(#ListView_0_Copy1)
for jj=0 to 4
setgadgettext(#Text_4+jj," ")
next
init(@plaqorigo)
DisableExplicit
EndProcedure
Procedure ObjectifAlea()
EnableExplicit
static jj,*PLAqori.solutpart
ClearGadgetItems(#ListView_0_Copy1)
for jj=0 to 4
setgadgettext(#Text_4+jj," ")
next
*PLAqori.solutpart=@plaqorigo
*plaqori\object=random(999,100)
SetGadgetText(#Editor_0,str(*plaqori\object))
DisableExplicit
EndProcedure
Procedure SOLUTIONx()
EnableExplicit
static jj,nbt,a,*PLAqori.solutpart,it,totplaq.q=0
if val(getGadgetText(#Editor_0))<>0
init_glob()
*PLAqori.solutpart=@plaqorigo
for jj=0 to 5
*plaqori\plag[jj+1]=val(getGadgetText(#Combo_2+jj))
totplaq + *plaqori\plag[jj+1]
if jj<5
setgadgettext(#Text_4+jj," ")
endif
next
*plaqori\plag[0]=6
*plaqori\object=val(getGadgetText(#Editor_0))
solution(@plaqorigo)
if ListSize(result())
ResetList(result())
nbt=0
for it=0 to 5
if nbtrouv(it)<>0
SetGadgetText(#Text_4+nbt, "Le compte est bon "+str(nbtrouv(it))+" solutions en "+ str(it)+ " opérations")
nbt+1
endif
next
NextElement(result())
For a=0 To 4
AddGadgetItem (#ListView_0_Copy1,-1, result()\solut_alp[a]) ; défini le contenu de la boîte de liste
Next
else
AddGadgetItem (#ListView_0_Copy1,-1, " résultat partiel diff="+str(resultpart\diff))
For a=0 To 4
AddGadgetItem (#ListView_0_Copy1,-1, resultpart\solut_alp[a]) ; défini le contenu de la boîte de liste
Next
endif
if totplaq=0
SetGadgetText(#Text_4+1, " IL N'Y A QU'UNE OU AUCUNE PLAQUETTE ")
endif
Else
SetGadgetText(#Text_4, " IL N'Y A AUCUN OBJECTIF ")
; debug totplaq
; if totplaq<1
; SetGadgetText(#Text_4+1, " IL N'Y A QU'UNE OU AUCUNE PLAQUETTE ")
; endif
endif
DisableExplicit
EndProcedure
procedure Avance_recule()
EnableExplicit
static jj,resultat,a
if ListSize(result())
if EventGadget()=#Button_4_Copy1
Resultat = NextElement(result())
endif
if EventGadget()=#Button_4
Resultat = PreviousElement(result())
endif
if resultat<>0
ClearGadgetItems(#ListView_0_Copy1)
For a=0 To 4
AddGadgetItem (#ListView_0_Copy1,-1, result()\solut_alp[a]) ; défini le contenu de la boîte de liste
Next
endif
endif
DisableExplicit
endprocedure
procedure EDIT_OBJECT()
EnableExplicit
static jj
ClearGadgetItems(#ListView_0_Copy1)
for jj=0 to 4
setgadgettext(#Text_4+jj," ")
next
DisableExplicit
endprocedure
OpenWindow_1()
;_________0____-----1----_____2____-----3----_____4____-----5----_____6____-----7----_____8____-----9----_____A____-----B
;_____1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345
tab$="001,001,002,002,003,003,004,004,005,005,006,006,007,007,008,008,009,009,010,010,025,025,050,050,075,075,100,100"
for i=0 to 27 step 2
if i=0
ii=0
Else
ii=1
endif
AddGadgetItem(#Combo_2, -1*ii,str(val(mid(tab$,i*4+1,3))) )
AddGadgetItem(#Combo_2_Copy1,-1*ii,str(val(mid(tab$,i*4+1,3))) )
AddGadgetItem(#Combo_2_Copy2,-1*ii,str(val(mid(tab$,i*4+1,3))) )
AddGadgetItem(#Combo_2_Copy3,-1*ii,str(val(mid(tab$,i*4+1,3))) )
AddGadgetItem(#Combo_2_Copy4,-1*ii,str(val(mid(tab$,i*4+1,3))) )
AddGadgetItem(#Combo_2_Copy5,-1*ii,str(val(mid(tab$,i*4+1,3))) )
next
BindgadgetEvent( #Checkbox_0,@BoutonFlag())
BindgadgetEvent( #Checkbox_1,@BoutonFlag())
BindgadgetEvent( #Checkbox_2,@BoutonFlag())
BindgadgetEvent( #Combo_2,@boutonplaq())
BindgadgetEvent( #Combo_2_Copy1,@boutonplaq())
BindgadgetEvent( #Combo_2_Copy2,@boutonplaq())
BindgadgetEvent( #Combo_2_Copy3,@boutonplaq())
BindgadgetEvent( #Combo_2_Copy4,@boutonplaq())
BindgadgetEvent( #Combo_2_Copy5,@boutonplaq())
BindgadgetEvent(#Button_0,@BoutonChargeAleas())
BindgadgetEvent(#Button_1,@ObjectifAlea())
BindgadgetEvent(#Button_1_Copy1,@SOLUTIONx())
BindgadgetEvent(#Button_4,@Avance_recule())
BindgadgetEvent(#Button_4_Copy1,@Avance_recule())
BindgadgetEvent(#Editor_0,@EDIT_OBJECT())
setgadgetstate(#Checkbox_0,#PB_CheckBox_Unchecked)
setgadgetstate(#Checkbox_1,#PB_CheckBox_Unchecked)
setgadgetstate(#Checkbox_2,#PB_CheckBox_Unchecked)
Repeat
; debug WaitWindowEvent(1)
Until WaitWindowEvent(1) = #PB_Event_CloseWindow
A+