[RESOLU] Permutation_Combinaisons

[Ganagyre]

Bonjour à tous.

Pour le calcul et la recherche de permutation j'utilise ce code suivant :
(ce code parmi d'autres tout aussi intéressant dans d'anciens posts du forum) .

Code : Tout sélectionner

; 
Procedure Permute(n,Base)
  
  Pw = Pow(Base,n)  
  Dim A.l(n + Base-1) : Dim a$(Pw)
  
  For i = 1 To Pw
    P = 1
    
    For H = n To 1 Step -1
      If A(H) < 16
         a$(i) + Hex(A(H)+1)
      Else
         a$(i) + Chr(A + 55)
      EndIf
    Next H
    
    Debug"Permutation N° =  "+Str(i)+"  "+a$(i)
    
    If A(P) = Base-1
      
      Repeat
        A(P) = 0 
        P + 1
      Until A(P) < Base-1
      
    EndIf
    
    A(P)+1
    
  Next i
  
  Dim a$(0): Dim A.l(0)
  
EndProcedure

cbn    = 2     
nombre = 9 

Permute(cbn,nombre)

Le même style de code mais adapté au Combinaisons me rendrait service.

Du style

Code : Tout sélectionner

Procedure Combin(n,p)  
  
; n = longueur de la combinaison  
; p = nombre total de valeur en prendre en compte
; soit p >= n
; pour n = 2 et p = 5  // = (5*4) / (1*2) = 20/2 = 10 COMBINAISON
; 
  
EndProcedure

COMBIN(2;5) rendrait 20 Combinaisons

1 -A:B
2 -A:C
3 -A:D
4 -A:E
5 -A:F
6 -B:C
7 -B:D
ect..
20 -E:F

Vous remerciant pour tout exemple.

+

[PAPIPP]

Bonjour Ganagyre
Voici fait rapidement et pouvant très certainement être amélioré
Le prg récursif est basé sur le principe suivant d'une combinaison de N par 3

Code : Tout sélectionner

n=4
gr=3
For i=1 To n
  For j=i+1 To n
   For k=j+1 To n
   Debug Str(i)+Str(j)+Str(k)
   Next
  Next
Next  

Voici le code Combin (N,p) récursif

Code : Tout sélectionner

N=5
Global GP=3
Dim tab(n)
; Global deb$=""
Procedure combi(N,gr,ind,Array tab(1))
  If gr<>0 
    For i=ind To N
      tab(ind)=i
      combi(N,gr-1,ind+1,tab())
    Next
  Else  
    deb$="" 
    flag=0   
    For j=1 To GP
      If tab(j-1)<tab(j)
        deb$+Str(tab(j))
        Else
      flag+1
      EndIf
    Next
    If flag=0
    Debug deb$
    EndIf
  EndIf    
EndProcedure
combi(N,GP,1,tab())

A+

[Ganagyre]

Bonjour à tous.

Merci beaucoup PAPIPP, pour ces exemples.

L'étonnant model récursif je vais l'étudier à la loupe.


+

[PAPIPP]

Bonjour Ganagyre

Voici le prg amélioré sans filtre de sortie pour une procédure des combinaisons en extension.
J'ai ajouté une procédure plus classique du calcul de C(N,p) pour vérifier le nombre de combinaisons.

Code : Tout sélectionner

N=6
Global GP=2
Global nb
Dim tab(n)
;******** Procédure de calcul du Nombre de combinaisons C(N,p) *******
Procedure.d Combin(N,p)
  If p< =N
    If p<>0
      combinn.d=N-p+1
      For i=N-p+2 To N
        combinn*i
      Next
      combind.d=1
      For i=1 To p
        combind*i
      Next
    Else
      combinn=1
      combind=1
    EndIf
  Else
    combinn=0
  EndIf
  combinn=combinn/combind
  
  ProcedureReturn combinn
EndProcedure
;*************  Procédure de la réalisation des combinaisons de groupement de p objets sur un nombre n d'objets
Procedure combi_exp(N,gr,ind,Array tab(1))
  If gr<>0
    For i=tab(ind-1)+1 To N ;nn
      tab(ind)=i
      combi_exp(N,gr-1,ind+1,tab())
    Next
  Else
    deb$=""
      For j=1 To GP
      deb$+Str(tab(j))
    Next
    Debug deb$
    nb+1
  EndIf
EndProcedure
combi_exp(N,GP,1,tab())
Debug "NB occ:"+Str(nb)
Debug combin(N,gp)

A+

[Ganagyre]

Bonjour.


PAPIPP à nouveau un grand merci .
Les exemples avec récursivité qui permettent de réduire de belle façon le nombre de boucle, c'est subtil, léger, efficace

+