[Résolu] Permutation de groupes de caractères

[falsam]

mon code lui fonctionnera pour n'importe quelle longueur !!

Tout à fait

Mais je ne resterais pas sur une défaite.

Code : Tout sélectionner

;Désactiver le support unicode dans les options de compilation

Procedure.s SetPermutation(Pattern.s, n)
  Protected i, Factorial = 1, Temp
  
  For i = 2 To Len(Pattern)
    Factorial * (i - 1)
    Temp = PeekB(@Pattern + (i - ((n / Factorial) % i) - 1))
    PokeB(@Pattern + (i - ((n / Factorial) % i) - 1), PeekB(@Pattern + i - 1))
    PokeB(@Pattern + i - 1, Temp)
  Next
  
  ProcedureReturn Pattern
EndProcedure

Procedure GetCombination(Groupe.s)
  Protected i,j
  Protected Pattern.s       ;Composer d'une séquence de chiffres (Exemple : 1234)  
  Protected Permutation.s   ;Permutation retournée par la procédure SetPermutation. Exemple (2413)
  Protected Result.s        ;Résultat à afficher
  
  ;Compter le nombre de groupe
  For i = 1 To CountString(Groupe, "~") + 1
    Pattern + Chr(64 + i) ;La lettre A commence à 65
  Next
  
  ;Générer les permutations pour la pattern
  i=1
  
  Repeat
    Result = ""
    Permutation = SetPermutation(Pattern, i)
    
    ;Construire le nouveau groupe en fonction de la pattern obtenue
    For j = 1 To Len(Permutation)
      Result + StringField(Groupe, Asc(Mid(Permutation,j,1)) - 64, "~")+"~"
    Next
    
    ;Afficher le résultat
    Debug LSet(Result, Len(Result) - 1)
    
    ;Permutation suivante
    i + 1
  Until Permutation = Pattern
EndProcedure

;Donne les combinaison de ce groupe 
GetCombination("158~200~25~75")

@Shadow : Il y a de quoi faire

[Micoute]

Voici ma solution:

Code : Tout sélectionner

; Créer par Micoute le 22/02/2016.

BASE_PERM$ = ""
Base_Groupe$ = "1~9~21~54~79~90~143~172~232~250"
Nb_Groupes = CountString(Base_Groupe$, "~") + 1

Global Dim tableau.s(Nb_Groupes - 1)
For i = 1 To Nb_Groupes
  tableau(i - 1) = StringField(Base_Groupe$, i, "~")
  BASE_PERM$ + Chr(i)
Next i  

Dim COMPTEUR_PERM.l(Len(BASE_PERM$)+1)

While BASE_PERM$>""
  ;  MessageRequester("",BASE_PERM$)
  PERM$ = BASE_PERM$
  BASE$ = tableau(Asc(Left(BASE_PERM$,1))-1)+"~"
  For i = 2 To Len(BASE_PERM$) - 1
    BASE$ + tableau(Asc(Mid(BASE_PERM$,i,1))-1)+"~"
  Next i
  BASE$ + tableau(Asc(Right(BASE_PERM$,1))-1)
  Debug BASE$
  Gosub PERMUTATION
Wend

End


;========== la Routine ==========
PERMUTATION:
  If POS_PERM.l=0
    COMPTEUR_PERM.l=0
    QUEUE_PERM$=""
    LONG_PERM.l = Len(BASE_PERM$)
  EndIf
  POS_PERM.l = 1
  NIVEAU_PERMUT:
  If COMPTEUR_PERM.l(POS_PERM.l)>=POS_PERM.l
    PERM_P.l = POS_PERM.l+1
    While Asc(QUEUE_PERM$)<PERM_P.l And QUEUE_PERM$>""
      POS_PERM.l = Asc(QUEUE_PERM$)
      QUEUE_PERM$ = Right(QUEUE_PERM$,Len(QUEUE_PERM$)-1)
      Gosub CHANGE_PERMUT
    Wend
    POS_PERM.l = PERM_P.l
    While PERM_P.l
      PERM_P.l = PERM_P.l-1
      COMPTEUR_PERM.l(PERM_P.l) = 0
    Wend
    If POS_PERM.l<LONG_PERM.l
      Goto NIVEAU_PERMUT
    EndIf
    BASE_PERM$=""
    POS_PERM.l=0
    Return
  EndIf
  Gosub CHANGE_PERMUT
  QUEUE_PERM$ = Chr(POS_PERM.l)+QUEUE_PERM$
  COMPTEUR_PERM.l(POS_PERM.l) = COMPTEUR_PERM.l(POS_PERM.l)+1
Return

CHANGE_PERMUT:
  BASE_PERM$ = Mid(BASE_PERM$,POS_PERM.l+1,1)+Left(BASE_PERM$,POS_PERM.l)+Right(BASE_PERM$,Len(BASE_PERM$)-(POS_PERM.l+1))
Return

[falsam]

Merci pour toutes vos réponses, le problème c'est qu'on est limité à 10 dimensions, parce qu'à la ligne 25 on a Pattern + Str(i), donc jusqu'à 9 il n'y a qu'un caractère.

26 dimensions ça ira ?

[Micoute]

Oh que oui !

[Shadow]

De toutes façon Micoute à dis plusieurs millions de "Groupe" chose qui est impossible !
Plus le nombre de groupe est grand et plus ça met de temps !

Mais ya peut être un moyen pour accélérer ?!

[cage]

Avez-vous essayé de calculer 1000.000! soit (1*2*3*......*1000.000)

Alors des millions de groupe.

[Shadow]

Effectivement
Moi pour 12 objet (Groupe) il met plus de 900 secondes sans le débogueur activée

Ya pas un moyen d'aller plus vite ?
Ya pas moyen d'utiliser plusieurs thread en même temps ?

[Shadow]

Merci à tous pour votre aide.
Le code le plus rapide semble être celui de Micoute !

10 Groupe = 195~210~215~220~225~230~240~245~250~255
Celui de Micoute = 5 seconde débogueur désactivé
Celui de Falsam = 7 secondes débogueur désactivé
Celui de Dobro en .... pas réussi à le faire fonctionné

Y à t-il moyen de faire plus rapide, qui dit mieux ?

[Shadow]

Le code le plus rapide reste le code n°1 de Micoute, le tous premier.

[falsam]

Merci à tous pour votre aide.

Faut il comprendre que Micoute a posté ce topic pour une demande d'aide qui te concerne ?

Le code le plus rapide reste le code n°1 de Micoute, le tous premier.

Tu as utilisé un chronomètre pour les tests ? ^^

Celui de Dobro en .... pas réussi à le faire fonctionné

La réponse est là :

Code : Tout sélectionner

phrase.s="125~256~521~566~78~987~ta mere~le pere noel~87~21~5~78~98~54~"

Ceci dit je pense que niveau temps il est dans les choux.

[Shadow]

Faut il comprendre que Micoute a posté ce topic pour une demande d'aide qui te concerne ?

En faite je lui est demander de l'aide, puis il m'as passé son code et ya eu des problèmes
car ça ne marchais pas, je lui est proposer de demander de l'aide sur le fofo
ensuite j'ai donner des information pour l'aider.

J'allais pas demander de l'aide sur son propre code quand même ça ne se fais pas, c'est son code !
Aurais-je fais une boulette ?

Tu as utilisé un chronomètre pour les tests ? ^^

Oui j'ai chronométrer avec ElapsedMilliseconds()
Voilla

[SPH]

Je m'excuse a l'avance mais : lol koi

[Micoute]

Bonjour SPH, je ne te le fais pas dire !

[falsam]

Celui de Micoute = 5 seconde débogueur désactivé

5 secondes pour trouver 3.628.801 ça me semble pas mal.

Questions:
- Quel CPU sur ton PC ?
- Par curiosité, quel est l'objectif de ce code ?

[falsam]

En tout cas j'ai bien ri : C'est l'histoire d'un mec ...

Dis moi Micoute, combien de "Groupe" doit gérer ton algorithme ?
10, 100, 1000 ?

L'algo dois en gros calculer toutes les permutations
des dit "Groupe" si j'ai bien compris ?

Tu sais que plus y aura de groupe et plus se serra long !

Sachant que c'est toi en fait Shadow qui demande de l'aide à Micoute, c'est amusant que tu poses cette question.

Oui, bien entendu, mais en fait la limite, c'est la mémoire qui l'impose car elle n'est pas illimitée, sinon je pense qu'on pourrait aller jusqu'à plusieurs millions !

Plusieurs millions ?

Avez-vous essayé de calculer 1000.000! soit (1*2*3*......*1000.000) Alors des millions de groupe.

Pardonne leurs Cage. Ils ne savent pas ce qu'ils font

10 Groupe = 195~210~215~220~225~230~240~245~250~255

Pour calculer le nombre de combinaison possibles, tu vas faire un calcul de Factoriel soit 1*2*3*4*5*6*7*8*9*10 le résultat sera 3.628.800 possibilités de combinaisons.

La fonction Factoriel n'existant pas je te donne une petite procédure de calcul bien pratique.

Code : Tout sélectionner

;Source http://www.phpsources.org/scripts208-PHP.htm
Procedure.q Factoriel(n.q) 
  If n=0
    ProcedureReturn #True
  Else
    ProcedureReturn n*Factoriel(n-1)
  EndIf
EndProcedure 

Debug Factoriel(10)

Essayez avec 20 pour voir le nombre de combinaisons

Merci pour ce moment.