PureBasic

Forums PureBasic
Nous sommes le Mer 21/Aoû/2019 23:35

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 15 messages ] 
Auteur Message
 Sujet du message: Le Compte est bon
MessagePosté: Lun 31/Déc/2018 16:41 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 556
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:
;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+

_________________
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.


Dernière édition par PAPIPP le Jeu 03/Jan/2019 12:52, édité 4 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Lun 31/Déc/2018 17:50 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2157
Localisation: 50200 Coutances
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 GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Jeu 03/Jan/2019 11:14 
Hors ligne
Avatar de l’utilisateur

Inscription: Sam 23/Sep/2006 18:32
Messages: 6644
Localisation: Isere
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


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 04/Jan/2019 2:39 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 08/Déc/2005 5:19
Messages: 936
Localisation: Guadeloupe
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 !


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 04/Jan/2019 22:12 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 29/Juil/2004 16:33
Messages: 2784
Localisation: Klyntar
Bravo PAPIPP,

En voila un joli code. Merci du partage.






@++

_________________
Windows 10 x64, PureBasic 5.71 Beta 1 x86 & x64
GPU : radeon HD6370M, CPU : p6200 2.13Ghz


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 04/Jan/2019 23:31 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 556
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:
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+

_________________
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.


Dernière édition par PAPIPP le Lun 07/Jan/2019 10:28, édité 2 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Sam 05/Jan/2019 7:46 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2157
Localisation: 50200 Coutances
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 GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Sam 05/Jan/2019 20:14 
Hors ligne
Avatar de l’utilisateur

Inscription: Ven 11/Fév/2005 17:34
Messages: 4222
Localisation: Arras, France
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... ;)


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Sam 05/Jan/2019 23:56 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 556
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.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Dim 06/Jan/2019 16:59 
Hors ligne
Avatar de l’utilisateur

Inscription: Ven 11/Fév/2005 17:34
Messages: 4222
Localisation: Arras, France
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 ;)


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 11/Jan/2019 10:58 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 556
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:
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+

_________________
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.


Dernière édition par PAPIPP le Ven 11/Jan/2019 23:01, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 11/Jan/2019 16:45 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2157
Localisation: 50200 Coutances
Excuse-moi, mais il y a une erreur à la ligne 159 :
Citation:
_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 GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 11/Jan/2019 22:33 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 29/Juil/2004 16:33
Messages: 2784
Localisation: Klyntar
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.71 Beta 1 x86 & x64
GPU : radeon HD6370M, CPU : p6200 2.13Ghz


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Ven 11/Jan/2019 23:10 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 556
Bonjour à tous

et merci micoute

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

Code:
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.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Le Compte est bon
MessagePosté: Sam 12/Jan/2019 6:58 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2157
Localisation: 50200 Coutances
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 GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 15 messages ] 

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 2 invités


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages

Rechercher:
Aller à:  

 


Powered by phpBB © 2008 phpBB Group | Traduction par: phpBB-fr.com
subSilver+ theme by Canver Software, sponsor Sanal Modifiye