Discussion :

[enibris]

Bonjour, voila le code que j'utilise

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
Public Function Komb1(ByVal tableau, ByVal Prefixe As String, ByVal min As Integer, ByVal max As Integer, ByVal n As Integer) As String
    Dim i As Integer
    Dim Resultat As String
 
    For i = min To max - n + 1
        If Prefixe = "-1" Then
            Resultat = tableau(i)
        Else
            Resultat = Prefixe & "*" & tableau(i)
        End If
 
        If n > 1 Then
            Komb1 tableau, Resultat, i + 1, max, n - 1
        Else
            If total1 = vbNullString Then
                total1 = Resultat
            Else
                total1 = total1 & "+" & Resultat
            End If
        End If
    Next
 
    Komb1 = total1
End Function

Rezultat=>
Combinaison de 2 element sur 5 (2/5) -> 10 combinaison possible
A*B+A*C+A*D+A*E+A*F+B*C+B*D+B*E+B*F+C*D+C*E+C*F+D*E+D*F+E*F


Mon probleme c'est que quand je dois calculer de grande combinaison (4/13) ->715 combinaisons possible, le temps de calcul est trop eleve, tout ce qui est superieur a 5s est trop eleve pour moi

Qu'elle est la meilleure maniere de faire ? Puis-je optimiser mon code,stocker dans un tableau, ou dans un fichier ?

Merci

[pseudocode]

c'est obligé de le faire en recursif ?

[enibris]

Bien sur que non

Si vous avez un algo plus rapide ou tout autre language.

Merci

[Jedai]

Bien sur que non

Si vous avez un algo plus rapide ou tout autre language.

Merci

Sérieux, tout autre langage ?
Du Haskell alors :

Code Haskell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
import List
 
combination 0 _ = [[]]
combination n xs = [e:es| e:ys <- tails xs, es <- combination (n-1) ys]
 
main = putStr . concat . intersperse "+" . map (intersperse '*') . combination 4 $ ['A'..'M']

Complètement instantanné, bien sûr !

(N'hésite pas à me demander des explications, mais j'aimerais bien avoir quelques détails sur tes connaissances et tes études (éventuelles) avant)

--
Jedaï

[pseudocode]

ah... Jedai. L'evangeliste Haskell

Bon sinon en imperatif, le principe c'est de faire toutes les listes de taille "p" telles que les nombres dans les listes soient toujours dans l'ordre croissant:

partition: p=2 / n=5:
(0,1), (0,2), (0,3), (0,4), (1,2), (1,3), (1,4), (2,3), (2,4), (3,4)

Ensuite il suffit d'utiliser ces nombres comme des "index" dans le tableau.

L'idée la plus simple est de faire des boucles for/next imbriquées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
For i=0 to 4
    For j=i+1 to 4
        ' ajouter la liste (i,j)
    Next j
Next i

Bien sur, le nombre de boucles imbriquées dépend du parametre "p".
Si ce parametre est une variable, il faut trouver une autre astuce pour generer les listes...

[enibris]

@jedai
La tu m'assasines. Avec BAC +2, ca etre tres dur.
Je pensais vb,deplhi,c & c++, algo..

C'est pour implementer dans VB

L'histoire des boucles je vais essayer. Au finale je depasse pas p=16/ n=16

Merci

[pseudocode]

L'histoire des boucles je vais essayer. Au finale je depasse pas p=16/ n=16

J'ai posté une version recursive dans la rubrique "contribuez", pour le cas ou "p" est une variable.

[acx01b]

salut

il y a une version itérative pour les combinaisons qui est bien pensée,
mais je lui préfère la version récursive qui est facile à écrire
(les tableaux commencent à l'indice 0)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
combinaison (tableau t, tablau combi, entier n, entier p, entier i, entier j) {
   si i = p alors afficher (combi)
   sinon 
      si n-j >= p-i alors // il reste suffisament d'éléments dans t
        combinaison (t, combi, n, p, i, j+1) // on n'a pas mis l'élément t[j] dans le tableau combi
        combi[i] <- t[j] // on met l'élément t[j] dans le tableau combi
        combinaison (t, combi, n, p, i+1, j+1)
      fin si
   fin si
}

le premier appel récursif:

combinaison ( tableau = {1,2,3,4...n}, combi = {}, n, p, 0, 0 )

le principe est qu'on met simplement en oeuvre la formule C(n,p) = C(n-1,p-1) + C(n-1,p)