Le Compte est bon

Programmation d'applications complexes
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Le Compte est bon

Message par PAPIPP »

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

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+
Dernière modification par PAPIPP le jeu. 03/janv./2019 12:52, modifié 4 fois.
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Avatar de l’utilisateur
Micoute
Messages : 2522
Inscription : dim. 02/oct./2011 16:17
Localisation : 35520 La Mézière

Re: Le Compte est bon

Message par Micoute »

Très bon ça, merci pour le partage et bonne année et tout ce qu'on peut souhaiter de bon pour l'anné prochaine.
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce RTX 3080 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.73 PB 6.00 LTS (x64)
Un homme doit être poli, mais il doit aussi être libre !
Avatar de l’utilisateur
Kwai chang caine
Messages : 6962
Inscription : sam. 23/sept./2006 18:32
Localisation : Isere

Re: Le Compte est bon

Message par Kwai chang caine »

Waooouuh !!! impressionnant on reconnait le matheux qui sommeille en toi, que de formules !!! 8O
Une oreillette et hop..PAPIPP champion de la télé :lol:

J'adore ce genre de codes qui peuvent faire à ma place ce que je déteste faire :oops:
Et principalement les résolveurs comme le tiens, le 2048 ou le SUDOKU (Comme il y a sur le forum), etc .. 8) enfin tous ces jeux qui me dépassent, si quelqu'un pouvait créer celui du rubik's cube qui sera resté un mystère toute ma vie, en PB :idea:

Merci beaucoup de ce partage, quand tu vois le temps que ton code met pour trouver 31 solutions, 8O ça ferait pâlir le plus grand champion de cette catégorie :?
Si je peut me permettre, tu as oublié un "J" dans le bouton et l'ajout d'un TextBox indiquant le n° de la solution au dessus serait super cool :wink:

Encore bravo et merci du partage 8)
ImageLe bonheur est une route...
Pas une destination

PureBasic Forum Officiel - Site PureBasic
Avatar de l’utilisateur
Huitbit
Messages : 939
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

Re: Le Compte est bon

Message par Huitbit »

Waooouuh bis !
Superbe !
J'étais sans internet depuis 10 jours, je me connecte, et je tombe sur
ce code, ça fait du bien :P
Bravo, l'année 2019 commence bien !

Hasta la vista !
Elevé au MSX !
Avatar de l’utilisateur
venom
Messages : 3071
Inscription : jeu. 29/juil./2004 16:33
Localisation : Klyntar
Contact :

Re: Le Compte est bon

Message par venom »

Bravo PAPIPP,

En voila un joli code. Merci du partage.






@++
Windows 10 x64, PureBasic 5.73 x86 & x64
GPU : radeon HD6370M, CPU : p6200 2.13Ghz
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Le Compte est bon

Message par PAPIPP »

Bonjour à tous

Et merci a ceux qui ont répondu.

J’ai essayé d’accélérer la vitesse de résolution.

1) Dans un premier temps j’ai supprimé les tables qui enregistraient les différentes combinaisons.

2) J’ai ensuite nettoyé le code pour le rendre un peu moins sombre (ou un peu plus claire)

3) Dans l’espoir de réaliser un programme récursif j’ai rendu les différentes procédures ‘’Solutionx’’ identiques
Et j’ai aussi essayé de n’utiliser qu’une seule macro (en commentaire elle est notée Zcom(niv) et peut être appelée par zcom(nbrest).
J’ai renoncé à cette dernière solution car les temps d’exécution étaient plus importants.

4) Enfin j’ai un peu modifié la forme de présentation.

Les résultats sont identiques au prg précédent.

Code : Tout sélectionner

DisableExplicit

EnableExplicit
Global Window_1
Global Texte_1
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

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_Copy2
  #Text_4_Copy3
  #Text_4_Copy4
  #Button_4
  #Button_4_Copy1
EndEnumeration


Procedure OpenWindow_1(x = 0, y = 0, width = 640, height = 420)
  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, 10, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy1, 90, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy2, 170, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy3, 250, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy4, 330, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy5, 410, 120, 70, 20, #PB_ComboBox_Editable)

  ButtonGadget(#Button_0, 220, 160, 170, 30, "Change TOUT")
  EditorGadget(#Editor_0, 490, 120, 50, 20)
  TextGadget(#Text_1, 490, 100, 50, 20, "Objectif")
  ButtonGadget(#Button_1, 550, 120, 80, 20, "Change Objectif")
  ButtonGadget(#Button_1_Copy1, 220, 210, 170, 30, "Cherche Solution")
  ListViewGadget(#ListView_0_Copy1, 350, 260, 210, 100)
  TextGadget(#Text_4, 30, 260, 260, 20, "")
  TextGadget(#Text_4_Copy1, 30, 290, 260, 20, "")
  TextGadget(#Text_4_Copy2, 30, 320, 260, 20, "")
  TextGadget(#Text_4_Copy3, 30, 350, 260, 20, "")
  TextGadget(#Text_4_Copy4, 30, 380, 260, 20, "")
  ButtonGadget(#Button_4, 350, 370, 90, 30, "Précédent")
  ButtonGadget(#Button_4_Copy1, 470, 370, 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  
global dim nbtrouv(5)
global diff_min.q=$7FFFFFFFFFFFFFFF
global newlist result.solutpart()
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
global  plaqorigo.s{80}
declare solution5(*plaqor.solutpart)
declare solution4(*plaqor.solutpart)
declare solution3(*plaqor.solutpart)
declare solution2(*plaqor.solutpart)

;********************************************************************************************
; macro zcom (niv)
;     tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
;     tabres6nbopnbmut\plag[1]=Result
;     tabres6nbopnbmut\solut_alpa+result$ 
;     diff=abs(result-*plaqor\object)
;     tabres6nbopnbmut\diff=diff
;     if diff=0
;       tabres6nbopnbmut\Nbopmin=6-tabres6nbopnbmut\plag[0]
;       nbtrouv(6-tabres6nbopnbmut\plag[0])+1
;       AddElement(result())
;       CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
;     elseif  diff<diff_min
;       copymemory(tabres6nbopnbmut,@resultpart,sizeof(solutpart))
;       diff_min=diff
;       resultpart\diff=diff
;     endif 
;   endmacro

;*********************************************************************************************

; 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)
    if tabtir(x)=0 ;; and x%2=0
      *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
    
  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)
;       debug "tri descendant"
    Else
      SortArray(tabplaq(),#PB_Sort_Ascending )
    endif
  endif
  for jj=0 to 5
    *plaqori\plag[jj+1]=tabplaq(jj) 
    SetGadgetText(#Combo_2+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 9 25 1  888 ou 889
  ; *plaqori\plag[1]=2
  ; *plaqori\plag[2]=75
  ; *plaqori\plag[3]=10
  ; *plaqori\plag[4]=10
  ; *plaqori\plag[5]=1
  ; *plaqori\plag[6]=9
  ; *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)
;   static  imp$,imp
  static result.q, diff.q, i,j
  static rest.restei, result$, rst,nb1,nb2,oper, nbrest,nb
;   static dim tabres6.solutpart(5,15)
 static  tabres6nbopnbmut.solutpart,tabres60.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
  macro zcom2
    tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
    tabres6nbopnbmut\plag[1]=Result
    tabres6nbopnbmut\solut_alpa+result$ 
    diff=abs(result-*plaqor\object)
    tabres6nbopnbmut\diff=diff
    if diff=0
      tabres6nbopnbmut\Nbopmin=6-tabres6nbopnbmut\plag[0]
;       nbtrouv(6-tabres6nbopnbmut\plag[0])+1
       nbtrouv(5)+1
     AddElement(result())
      CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
    elseif  diff<diff_min
      copymemory(tabres6nbopnbmut,@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
      result$=""
      
 ;;************************* Les instructions suivantes sont inutiles pour la dernière procédure puisqu'il n'y a plus que 2 nombres  *************     
; ;       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
; ;         tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
; ;       next
; ;       tabres6nbopnbmut\plag[0]=NBrest
; ;       tabres6nbopnbmut\plag[0]=1
      ;;; **********************************************************************************************   addition 
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************      
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom2
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      ;       debug "*******"+_n(nb1)+_n(nb2)+_hq(rest\vq) 
      
       ;;; **************************************************************************** ******************FIN    addition 

      if  (oper&4)=4    
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=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$=left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
        else  
          result$=left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
        endif        
        zcom2
      endif
      ;;;; ***********************************************************************************************FIN soustraction
      
      if  (oper&1)=1 
        
        ;;;;; **************************************************************************************************   division 1
        Result=nb1/nb2
        result$=left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
        zcom2
      endif
      ;;;;; **************************************************************************************************FIN  division 1
      ;;;;; **************************************************************************************************   division 2
      if  (oper&16)=16 
        Result=nb2/nb1
        result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
        zcom2
      endif
      ;;;;; **************************************************************************************************FIN  division 2
      
    next
  next
  DisableExplicit
EndProcedure



procedure solution3(*plaqor.solutpart)
;   static  imp$,imp
  static result.q, diff.q, i,j
  static rest.restei, result$, rst,nb1,nb2,oper,nbrest,nb
  static dim tabres6.solutpart(5,15)
 static  tabres6nbopnbmut.solutpart,tabres60.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
    macro zcom3
    tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
    tabres6nbopnbmut\plag[1]=Result
    tabres6nbopnbmut\solut_alpa+result$ 
    diff=abs(result-*plaqor\object)
    tabres6nbopnbmut\diff=diff
    if diff=0
      tabres6nbopnbmut\Nbopmin=6-tabres6nbopnbmut\plag[0]
      nbtrouv(6-tabres6nbopnbmut\plag[0])+1
      AddElement(result())
      CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
    elseif  diff<diff_min
      copymemory(tabres6nbopnbmut,@resultpart,sizeof(solutpart))
      diff_min=diff
      resultpart\diff=diff
    endif 
        solution2(@tabres6nbopnbmut)
  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
      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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition 
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************      
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom3
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      
       ;;; **************************************************************************** ******************FIN    addition 

      if  (oper&4)=4    
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
        zcom3
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2  
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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        
        zcom3
      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
        zcom3
      endif
      ;;;;; **************************************************************************************************FIN  division 1
      ;;;;; **************************************************************************************************   division 2
      if  (oper&16)=16 
        Result=nb2/nb1
        result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
        zcom3
      endif
      ;;;;; **************************************************************************************************FIN  division 2
    next
  next
  DisableExplicit
EndProcedure


procedure solution4(*plaqor.solutpart)
;   static  imp$,imp
  static result.q, diff.q, i,j
  static rest.restei, result$, rst,nb1,nb2,oper,nbrest,nb
;   static dim tabres6.solutpart(5,15)
 static  tabres6nbopnbmut.solutpart,tabres60.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
      macro zcom4
    tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
    tabres6nbopnbmut\plag[1]=Result
    tabres6nbopnbmut\solut_alpa+result$ 
    diff=abs(result-*plaqor\object)
    tabres6nbopnbmut\diff=diff
    if diff=0
      tabres6nbopnbmut\Nbopmin=6-tabres6nbopnbmut\plag[0]
      nbtrouv(6-tabres6nbopnbmut\plag[0])+1
      AddElement(result())
      CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
    elseif  diff<diff_min
      copymemory(tabres6nbopnbmut,@resultpart,sizeof(solutpart))
      diff_min=diff
      resultpart\diff=diff
    endif 
       solution3(@tabres6nbopnbmut)
  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
      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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition 
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************      
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom4
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      
       ;;; **************************************************************************** ******************FIN    addition 

      if  (oper&4)=4    
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=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$=left(str(nb1)+"-"+str(nb2)+"="+str(result)+space(16),16)
        else  
          result$=left(str(nb2)+"-"+str(nb1)+"="+str(result)+space(16),16)
        endif        
        zcom4
      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
        zcom4
      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
        zcom4
      endif
      ;;;;; **************************************************************************************************FIN  division 2
    next
  next
  DisableExplicit
EndProcedure


; 
procedure solution5(*plaqor.solutpart)
;   static  imp$,imp
  static result.q, diff.q, i,j
  static rest.restei, result$, rst,nb1,nb2,oper, nbrest,nb
;   static dim tabres6.solutpart(5,15)
 static  tabres6nbopnbmut.solutpart,tabres60.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
        macro zcom5
    tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
    tabres6nbopnbmut\plag[1]=Result
    tabres6nbopnbmut\solut_alpa+result$ 
    diff=abs(result-*plaqor\object)
    tabres6nbopnbmut\diff=diff
    if diff=0
      tabres6nbopnbmut\Nbopmin=6-tabres6nbopnbmut\plag[0]
      nbtrouv(6-tabres6nbopnbmut\plag[0])+1
      AddElement(result())
      CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
    elseif  diff<diff_min
      copymemory(tabres6nbopnbmut,@resultpart,sizeof(solutpart))
      diff_min=diff
      resultpart\diff=diff
    endif 
      solution4(@tabres6nbopnbmut)
  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
      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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition 
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************      
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom5
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      ;       debug "*******"+_n(nb1)+_n(nb2)+_hq(rest\vq) 
      
       ;;; **************************************************************************** ******************FIN    addition 

      if  (oper&4)=4    
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
        zcom5
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2  
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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        
        zcom5
      endif
      ;;;; ***********************************************************************************************FIN soustraction
      
      if  (oper&1)=1 
        
        ;;;;; **************************************************************************************************   division 1
        Result=nb1/nb2
        result$=left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
        zcom5
      endif
      ;;;;; **************************************************************************************************FIN  division 1
      ;;;;; **************************************************************************************************   division 2
      if  (oper&16)=16 
        Result=nb2/nb1
        result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
        zcom5
      endif
      ;;;;; **************************************************************************************************FIN  division 2
    next
  next
  DisableExplicit
EndProcedure

procedure solution(*plaqor.solutpart)
;   static  imp$,imp
  static result.q, diff.q, i,j
  static rest.restei, result$, rst,nb1,nb2,oper, nbrest,nb
;   static dim tabres6.solutpart(5,15)
 static  tabres6nbopnbmut.solutpart,tabres60.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
         macro zcom6
    tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
    tabres6nbopnbmut\plag[1]=Result
    tabres6nbopnbmut\solut_alpa+result$ 
    diff=abs(result-*plaqor\object)
    tabres6nbopnbmut\diff=diff
    if diff=0
      tabres6nbopnbmut\Nbopmin=6-tabres6nbopnbmut\plag[0]
      nbtrouv(6-tabres6nbopnbmut\plag[0])+1
      AddElement(result())
      CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
    elseif  diff<diff_min
      copymemory(tabres6nbopnbmut,@resultpart,sizeof(solutpart))
      diff_min=diff
      resultpart\diff=diff
    endif 
       solution5(@tabres6nbopnbmut)
  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
      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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition 
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************      
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom6
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      
       ;;; **************************************************************************** ******************FIN    addition 

      if  (oper&4)=4    
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
        zcom6
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2  
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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        
        zcom6
      endif
      ;;;; ***********************************************************************************************FIN soustraction
      
      if  (oper&1)=1 
        
        ;;;;; **************************************************************************************************   division 1
        Result=nb1/nb2
        result$=left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
        zcom6
      endif
      ;;;;; **************************************************************************************************FIN  division 1
      ;;;;; **************************************************************************************************   division 2
      if  (oper&16)=16 
        Result=nb2/nb1
        result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
        zcom6
      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
    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)
  ClearList(result())
  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,tdep.q,temps.q
  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))
  tdep.q=ElapsedMilliseconds()
  solution(@plaqorigo)
  Temps.q=(ElapsedMilliseconds()-tdep)
  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  ")
endif
SetGadgetText(#Text_4_Copy4, "  Temps en milli secondes="+str(temps))
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+
Dernière modification par PAPIPP le lun. 07/janv./2019 10:28, modifié 2 fois.
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Avatar de l’utilisateur
Micoute
Messages : 2522
Inscription : dim. 02/oct./2011 16:17
Localisation : 35520 La Mézière

Re: Le Compte est bon

Message par Micoute »

Merci PAPIPP pour le partage de ce chef-d'œuvre de mathématiques, j'adore.
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce RTX 3080 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.73 PB 6.00 LTS (x64)
Un homme doit être poli, mais il doit aussi être libre !
Avatar de l’utilisateur
djes
Messages : 4252
Inscription : ven. 11/févr./2005 17:34
Localisation : Arras, France

Re: Le Compte est bon

Message par djes »

Pfff. Magnifique. PAPIPP au meilleur de sa forme commence l'année 2019 en beauté. Chapeau ! 8O

Un tout petit bug(?) dans les résultats qui sont parfois en double ou très proches (lignes inversées). Je sais que tu es perfectionniste alors... ;)
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Le Compte est bon

Message par PAPIPP »

Bonjour à tous

@ djes


J’avais déjà fait la remarque dans le premier message.

D’une manière générale s’il existe 2 plaquettes identiques au moins, il y aura des solutions identiques. Vous pouvez même avoir au maximum 3 doublons en tirage aléatoire ce qui fait quelques combinaisons identiques.
C’est pourquoi j’ai placé la checkbox ‘Pas de valeur double ‘’ en tirage aléatoire.

En effet s’il y a au moins 2 valeurs identiques il y aura des résultats en double
Car si x(1)=X(2), ils sont considérés par le prg comme différents.

Pour corriger cette petite répétition il faudrait analyser les solutions dans le détail et éliminer les résultats identiques. C’est une opération assez lourde car comme le permet le prg vous pouvez changer vous-même les plaquettes et ainsi introduire 1, 2, 3, 4, 5 ou 6 répétitions.

Comme j’avais fait la remarque dans le premier message en exemple ci-dessous

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 les combinaisons entre eux ainsi que les résultats entre résultats intermédiaires sont superflues.

Certaines solutions inversent les résultats car les solutions sont indépendantes les unes des autres.
Et comme pour les répétitions des plaquettes la correction serait assez lourde pour comparer les opérations dans le détail car certains opérateurs sont commutatifs A*B=B*A et A+B = B+A et pour analyser il faudrait trier les solutions non seulement dans l'ordre dans lesquels ils ont été réalisés mais aussi pour les opérateurs commutatifs les trier dans un ordre identique.
L'ordre d'exécution du choix des opérandes et des opérateurs peut être important pour le résultat.
Ce serait une correction assez lourde pour un résultat mineur.

Par contre j’ai corrigé quelques petits bugs dans le dernier prg

A+
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Avatar de l’utilisateur
djes
Messages : 4252
Inscription : ven. 11/févr./2005 17:34
Localisation : Arras, France

Re: Le Compte est bon

Message par djes »

Ah ok, je n'avais pas bien lu. De toutes façons c'est déjà très bien comme ça. Vivement l'année prochaine ;)
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Le Compte est bon

Message par PAPIPP »

Bonjour à tous

Après quelques recherches pour éliminer le plus de solutions superflus.

Voici le dernier jus de cette recherche.

S’il reste encore quelques solutions redondantes, pouvez vous me les signaler ?
Merci d'avance.

Code : Tout sélectionner

DisableExplicit

EnableExplicit
Global Window_1
Global Texte_1
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 y a un tri descendant

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_Copy2
  #Text_4_Copy3
  #Text_4_Copy4
  #Button_4
  #Button_4_Copy1
EndEnumeration


Procedure OpenWindow_1(x = 0, y = 0, width = 640, height = 420)
  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, 10, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy1, 90, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy2, 170, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy3, 250, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy4, 330, 120, 70, 20, #PB_ComboBox_Editable)
  ComboBoxGadget(#Combo_2_Copy5, 410, 120, 70, 20, #PB_ComboBox_Editable)
  
  ButtonGadget(#Button_0, 220, 160, 170, 30, "Change TOUT")
  EditorGadget(#Editor_0, 490, 120, 50, 20)
  TextGadget(#Text_1, 490, 100, 50, 20, "Objectif")
  ButtonGadget(#Button_1, 550, 120, 80, 20, "Change Objectif")
  ButtonGadget(#Button_1_Copy1, 220, 210, 170, 30, "Cherche Solution")
  ListViewGadget(#ListView_0_Copy1, 350, 260, 210, 100)
  TextGadget(#Text_4, 30, 260, 260, 20, "")
  TextGadget(#Text_4_Copy1, 30, 290, 260, 20, "")
  TextGadget(#Text_4_Copy2, 30, 320, 260, 20, "")
  TextGadget(#Text_4_Copy3, 30, 350, 260, 20, "")
  TextGadget(#Text_4_Copy4, 30, 380, 260, 20, "")
  ButtonGadget(#Button_4, 350, 370, 90, 30, "Précédent")
  ButtonGadget(#Button_4_Copy1, 470, 370, 90, 30, "Suivant")
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 
global dim nbtrouv(5)
global diff_min.q=$7FFFFFFFFFFFFFFF
global newlist result.solutpart()
global newmap Mresult.solutpart()
global resultpart.solutpart
global resultblanc.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
global  plaqorigo.s{80}
global dim tabresPrec.solutpart(5)

declare solution5(*plaqor.solutpart)
declare solution4(*plaqor.solutpart)
declare solution3(*plaqor.solutpart)
declare solution2(*plaqor.solutpart)
declare impp(*plaqo.solutpart)
;********************************************************************************************
macro Ztrouv
  nbtrouv(nbop+1)+1
  AddElement(result())
  CopyMemory(tabres6nbopnbmut,result(),sizeof(solutpart))
  CopyMemory(tabres6nbopnbmut,tabresprec(nbop),sizeof(solutpart))
  copymemory(tabres6nbopnbmut,Mresult(tabres6nbopnbmut\solut_alp[nbop]),sizeof(solutpart))
  
endmacro  
macro zcom 
  tabres6nbopnbmut\solut_alpa=*plaqor\solut_alpa
  tabres6nbopnbmut\plag[1]=Result
  tabres6nbopnbmut\solut_alpa+result$
  diff=abs(result-*plaqor\object)
  tabres6nbopnbmut\diff=diff
  if diff=0 
    nbop=5-tabres6nbopnbmut\plag[0]
    tabres6nbopnbmut\Nbopmin=nbop+1
    ;;;;************* Partie permettant d'éliminer les résultats superflus ***********************     
    if  tabresprec(nbop)\solut_alpa<> tabres6nbopnbmut\solut_alpa or  tabresprec(nbop)\solut_alpa=""
      if tabresprec(nbop)\solut_alp[nbop]<>tabres6nbopnbmut\solut_alp[nbop]
        If FindMapElement(Mresult(),tabres6nbopnbmut\solut_alp[nbop] )=0
          Ztrouv
        Else
          ;;;;;*************** Pour éviter d'éliminer les solutions singulières ****************         
          if tabres6nbopnbmut\Nbopmin<Mresult()\Nbopmin
   ;         impp(tabres6nbopnbmut)
            Ztrouv
          endif  
        endif  
      Else
        ;;;;;*************** Pour éviter d'éliminer les solutions singulières ****************         
        if tabres6nbopnbmut\Nbopmin<tabresprec(nbop)\Nbopmin
    ;      impp(tabres6nbopnbmut)
          Ztrouv
        endif  
      endif
    else 
    endif  
    ;;;;************* Fin de Partie permettant d'éliminer les résultats superflus ***********************     
  elseif  diff<diff_min
    copymemory(tabres6nbopnbmut,@resultpart,sizeof(solutpart))
    diff_min=diff
    resultpart\diff=diff
  endif
endmacro

;*********************************************************************************************

;procedure impp(*plaqo.solutpart)
;  static imp$, imp
;  imp$=""
;  for imp=0 to 6
;    imp$+" "+str(*plaqo\plag[imp])
;  Next
;  imp$+" "+_n(*plaqo\object)+" "+_n(*plaqo\Nbopmin)+" "+_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)
    if tabtir(x)=0 ;; and x%2=0
      *plaqori\plag[i]=val(mid(tab$,x*4+1,3))
      tabplaq(i-1)=*plaqori\plag[i]
      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
    
  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)
    SetGadgetText(#Combo_2+jj," ")
    SetGadgetText(#Combo_2+jj,str(tabplaq(jj)))
  next
  *plaqori\plag[0]=6
  *plaqori\object=random(999,100)
  SetGadgetText(#Editor_0,str(*plaqori\object))
  DisableExplicit
EndProcedure


procedure.q  reste(i,j,nbr)
  EnableExplicit
  static res.restei,rest$,r
  ;   static dim treste.i(7)
  ;   res.restei
  rest$=""
  res\va[0]=0
  for r=1 to nbr
    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 toujours 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)
  ;   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)
  static  tabres6nbopnbmut.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
  
  ;*********************** 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
      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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************     
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      if nb1<nb2
        swap nb1,nb2
      endif       
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom
      ;;; 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)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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       
        zcom
      endif
      ;;;; ***********************************************************************************************FIN soustraction
      
      if  (oper&1)=1
        ;;;;; **************************************************************************************************   division 1
        Result=nb1/nb2
        result$=left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
        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
  DisableExplicit
EndProcedure



procedure solution3(*plaqor.solutpart)
  ;   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)
  static  tabres6nbopnbmut.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
  ;*********************** 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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************     
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      if nb1<nb2
        swap nb1,nb2
      endif       
      
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom
      solution2(@tabres6nbopnbmut)
      
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      
      ;;; **************************************************************************** ******************FIN    addition
      
      if  (oper&4)=4   
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
        zcom
        solution2(@tabres6nbopnbmut)
        
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2 
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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       
        zcom
        solution2(@tabres6nbopnbmut)
      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
        solution2(@tabres6nbopnbmut)
      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
        solution2(@tabres6nbopnbmut)
      endif
      ;;;;; **************************************************************************************************FIN  division 2
    next
  next
  DisableExplicit
EndProcedure


procedure solution4(*plaqor.solutpart)
  ;   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)
  static  tabres6nbopnbmut.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
  ;*********************** 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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************     
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      if nb1<nb2
        swap nb1,nb2
      endif       
      OPER=operationposs(nb1,nb2)
      
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom
      solution3(@tabres6nbopnbmut)
      
      ;;; 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
        solution3(@tabres6nbopnbmut)
        
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2 
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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
        solution3(@tabres6nbopnbmut)
        
      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
        solution3(@tabres6nbopnbmut)
        
      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
        solution3(@tabres6nbopnbmut)
        
      endif
      ;;;;; **************************************************************************************************FIN  division 2
    next
  next
  DisableExplicit
EndProcedure


;
procedure solution5(*plaqor.solutpart)
  ;   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)
  static  tabres6nbopnbmut.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
  ;*********************** 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
      ;       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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************     
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      if nb1<nb2
        swap nb1,nb2
      endif       
      
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom
      solution4(@tabres6nbopnbmut)
      
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      
      ;;; **************************************************************************** ******************FIN    addition
      
      if  (oper&4)=4   
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
        zcom
        solution4(@tabres6nbopnbmut)
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2 
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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
        solution4(@tabres6nbopnbmut)
        
      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
        solution4(@tabres6nbopnbmut)
        
      endif
      ;;;;; **************************************************************************************************FIN  division 1
      ;;;;; **************************************************************************************************   division 2
      if  (oper&16)=16
        Result=nb2/nb1
        result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
        zcom
        solution4(@tabres6nbopnbmut)
        
      endif
    next
  next
  DisableExplicit
EndProcedure

procedure solution(*plaqor.solutpart)
  ;   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)
  static  tabres6nbopnbmut.solutpart
  nb=*plaqor\plag[0]
  tabres6nbopnbmut\object=*plaqor\object
  
  ;*********************** 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
      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
        tabres6nbopnbmut\plag[rst]=*plaqor\plag[rest\va[rst]]
      next
      tabres6nbopnbmut\plag[0]=Nbrest
      ;;; **********************************************************************************************   addition
      ;********* Recherche de nombres à partir des indices i et j  choisis pour réaliser l'une des opérations ****************     
      ;;; types  d'opérations sur les 2 nombres choisis
      nb1=*plaqor\plag[i]: nb2=*plaqor\plag[J]
      if nb1<nb2
        swap nb1,nb2
      endif       
      
      OPER=operationposs(nb1,nb2)
      Result=nb1+nb2
      result$=left(str(nb1)+"+"+str(nb2)+"="+str(result)+space(16),16)
      zcom
      solution5(@tabres6nbopnbmut)
      
      ;;; les 4 opération +=8 *=4 -=2 /=1  ou inverse /=16
      
      ;;; **************************************************************************** ******************FIN    addition
      
      if  (oper&4)=4   
        ;;;  ***************************************************************************     multiplication
        Result=nb1*nb2
        result$=left(str(nb1)+"*"+str(nb2)+"="+str(result)+space(16),16)
        zcom
        solution5(@tabres6nbopnbmut)
        
      endif       
      ;;;; ********************************************************************************************* soustraction
      if  (oper&2)=2 
        Result=abs(nb1-nb2)
        ;         result$=left("abs("+str(nb1)+"-"+str(nb2)+")="+str(result)+space(16),16)
        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
        solution5(@tabres6nbopnbmut)
        
      endif
      ;;;; ***********************************************************************************************FIN soustraction
      
      if  (oper&1)=1
        
        ;;;;; **************************************************************************************************   division 1
        Result=nb1/nb2
        result$=left(str(nb1)+"/"+str(nb2)+"="+str(result)+space(16),16)
        zcom
        solution5(@tabres6nbopnbmut)
      endif
      ;;;;; **************************************************************************************************FIN  division 1
      ;;;;; **************************************************************************************************   division 2
      if  (oper&16)=16
        Result=nb2/nb1
        result$=left(str(nb2)+"/"+str(nb1)+"="+str(result)+space(16),16)
        zcom
        solution5(@tabres6nbopnbmut)
        
      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
  ;   global newlist result.solutpart()
  ;   global resultblanc.solutpart
  CopyMemory(resultblanc,resultpart,sizeof(solutpart))
  global resultpart.solutpart
  ClearList(result())
  ClearGadgetItems(#ListView_0_Copy1)
  global  plaqorigo.s{80} 
  freearray (tabresPrec())
  global dim tabresPrec.solutpart(5)
  freearray(nbtrouv())
  global dim nbtrouv(5)
  clearmap(Mresult())
  
  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
  init_glob()
  for jj=0 to 4
    setgadgettext(#Text_4+jj," ")
  next
  init(@plaqorigo)
  DisableExplicit
EndProcedure

Procedure ObjectifAlea()
  EnableExplicit
  static jj,*PLAqori.solutpart
  init_glob()
  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
  global dim tabresPrec.solutpart(5)
  static jj,nbt,a,*PLAqori.solutpart,it,totplaq.q=0,tdep.q,temps.q
  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))
    tdep.q=ElapsedMilliseconds()
    solution(@plaqorigo)
    Temps.q=(ElapsedMilliseconds()-tdep)
    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  ")
  endif
  SetGadgetText(#Text_4_Copy4, "  Temps en milli secondes="+str(temps))
  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
Until WaitWindowEvent(1) = #PB_Event_CloseWindow
A+
Dernière modification par PAPIPP le ven. 11/janv./2019 23:01, modifié 1 fois.
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Avatar de l’utilisateur
Micoute
Messages : 2522
Inscription : dim. 02/oct./2011 16:17
Localisation : 35520 La Mézière

Re: Le Compte est bon

Message par Micoute »

Excuse-moi, mais il y a une erreur à la ligne 159 :
_n() n'est pas une fonction, un tableau, une macro ou une liste.
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce RTX 3080 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.73 PB 6.00 LTS (x64)
Un homme doit être poli, mais il doit aussi être libre !
Avatar de l’utilisateur
venom
Messages : 3071
Inscription : jeu. 29/juil./2004 16:33
Localisation : Klyntar
Contact :

Re: Le Compte est bon

Message par venom »

djes a écrit :Vivement l'année prochaine ;)
J’espère que PAPIPP ne va pas nous faire mijoté comme sa 1 ans sans donner d'autres codes aussi sympathique. :D
Aller courage PAPIPP :wink:






@++
Windows 10 x64, PureBasic 5.73 x86 & x64
GPU : radeon HD6370M, CPU : p6200 2.13Ghz
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Le Compte est bon

Message par PAPIPP »

Bonjour à tous

et merci micoute

_n() et _s() sont des macros résidentes dans mon environnement.

Code : Tout sélectionner

Macro _q_t_
"
EndMacro

Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro

Macro _s (__S)
_q_t_#__S#=_q_t_+__S+" "
EndMacro
Mais comme ces macros ne servent que pour la mise au point , j'ai placé la procédure impp() en commentaire dans le prg précédent.

vous pouvez utiliser ces macros avec la procédure Impp().

A+
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Avatar de l’utilisateur
Micoute
Messages : 2522
Inscription : dim. 02/oct./2011 16:17
Localisation : 35520 La Mézière

Re: Le Compte est bon

Message par Micoute »

Bonjour PAPIPP et merci beaucoup, car ça fonctionne beaucoup mieux à présent.
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce RTX 3080 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.73 PB 6.00 LTS (x64)
Un homme doit être poli, mais il doit aussi être libre !
Répondre