Chercher: Et Ou Phrase  
Dans:          


Menu non membre

Pour les nouveau visiteurs

Entrez ici

Chercher le Forum



 

 Les Forums
  Programmation avancée
Repondre a ce sujet  

Sujet Liste des permutation d'une chaine de 4 caractères
Message envoyé le 18-05-2021 par Yanson (Cameroun)  
Bonjour.
J'ai un souci et sollicite de l'aide.
En effet, je voudrais à partir d'un ensemble de caractères données (par exemple ABCDEF) afficher le nombre de permutation possibles d'une chaine de trois caractères.
On aura par exemple
ABC
ABD
ABE
...
...
FAC
...

Quelqu'un pourrait-il me fournir un code Windev permettant de réaliser cela?

Merci d'avance.

Message envoyé le 19-05-2021 par taoufik1_1 (Maroc)  
Bonjour
//
Chaineini est chaîne ="ABCDEF"
i est entier=Taille(Chaineini)
//
FOR z = 3 TO i
     
     Trace( Gauche(Chaineini, 2) + Milieu( Chaineini, z, 1) )
     
END



Message envoyé le 19-05-2021 par Yanson (Cameroun)  
Merci beaucoup. Mais ce code ne m'aide pas beaucoup. Il me ressort uniquement toutes les permutations commençant par "AB" :
ABC
ABD
ABE
ABF

Je veux un code qui va balayer toutes les possibilités:
ABC
ABD
...
CAB
FED
etc.

Message envoyé le 20-05-2021 par LePape (France)  
Essaye ceci
*********************
appel de la procédure
*********************

PR_CombinaisonChaine("ABCDEF")

*********
Procédure
*********
PROCÉDURE PR_CombinaisonChaine(sMaChaine)
sChaineNew est une chaîne
nNbPossibilite est un entier
nLongueur est un entier = Taille(sMaChaine)

ptabCaractUnik est un tableau dynamique
ptabPosition est un tableau dynamique

ptabCaractUnik = allouer un tableau dynamique de nLongueur chaînes
ptabPosition = allouer un tableau dynamique de nLongueur entier

// Transfert de chaque caractère dans le tableau
POUR I = 1 À nLongueur
     ptabCaractUnik = Milieu(sMaChaine,I,1)
FIN
// Mémorisation des positions
POUR I = 1 À nLongueur
     ptabPosition = 0
FIN
// Calcul de la valeur de fin de boucle la valeur de suppression des doublons
nFinBoucle est un entier = 1
bValeurCorrecte est un booléen
POUR I = 1 À nLongueur
     nFinBoucle = nFinBoucle * nLongueur
FIN

nPosIncrement est un entier // Colonne a incrémenter
nNvaleur est un entier
sChainePos est une chaîne

BOUCLE
     nPosIncrement = nLongueur
     POUR I = 1 À nLongueur
          SI I = nPosIncrement ALORS ptabPosition = ptabPosition+1
          SI ptabPosition > nLongueur ALORS
               ptabPosition= 1
               POUR J = nLongueur-1 À 1 PAS -1
                    ptabPosition[J] = ptabPosition[J] + 1
                    SI ptabPosition[J] > nLongueur ALORS
                         ptabPosition[J] = 1
                    SINON
                         SORTIR
                    FIN
               FIN
          FIN
     FIN
     nNvaleur = 1
     sChainePos = ""
     bValeurCorrecte = Vrai
     POUR J = 1 À nLongueur
          nNvaleur = nNvaleur*ptabPosition[J]
          sChainePos = sChainePos+ptabPosition[J]
     FIN
     POUR I = 1 À nLongueur
          SI ChaîneOccurrence(sChainePos,NumériqueVersChaîne(I)) > 1 OU ChaîneOccurrence(sChainePos,"0") > 0 ALORS
               bValeurCorrecte = Faux
          FIN
     FIN
     SI nNvaleur = nFinBoucle ALORS
          // On a fait le tour on arrête
          SORTIR
     FIN
     sChaineNew = ""
     SI bValeurCorrecte ALORS
          // Il n'y a pas de doublon on accepte cette valeur
          POUR I = 1 À nLongueur
               sChaineNew = sChaineNew+ptabCaractUnik[ptabPosition]
          FIN
     Trace(sChaineNew)
          
          nNbPossibilite++
     FIN
FIN
Trace("il y a "+nNbPossibilite+" possibillités")
**********************
LE PAPE


Message envoyé le 20-05-2021 par Voroltinquo (France)  
Bonjour,
Dans la série "bien bourrin", tu as aussi ça :
[Code]
FONCTION CréerPermut(saMaChaine est chaîne):tableau de chaîne
nNoCar1 est un entier
nNoCar2 est un entier
nNoCar3 est un entier
nNoCar4 est un entier
saPermut est chaîne
tabResultat est tableau de chaîne

POUR nNoCar1 = 1 _À_ Taille(saMaChaine)
     saPermut[1]=saMaChaine[nNoCar1]
     POUR nNoCar2 = 1 _À_ Taille(saMaChaine)
          SI nNoCar2<>nNoCar1 ALORS
               saPermut[2]=saMaChaine[nNoCar2]
               POUR nNoCar3 = 1 _À_ Taille(saMaChaine)
                    SI (nNoCar3<>nNoCar1) ET (nNoCar3<>nNoCar2) ALORS
                         saPermut[3]=saMaChaine[nNoCar3]
                         POUR nNoCar4 = 1 _À_ Taille(saMaChaine)
                              SI (nNoCar4<>nNoCar1) ET (nNoCar4<>nNoCar2) ET (nNoCar4<>nNoCar3) ALORS
                                   saPermut[4]=saMaChaine[nNoCar4]
                                   TableauAjoute(tabResultat,saPermut)
                              FIN
                         FIN
                    FIN
               FIN
          FIN
     FIN
FIN
RENVOYER tabResultat
[/CODE]

Message envoyé le 20-05-2021 par Voroltinquo (France)  
Le même mais en moins bourrin
[CODE]
// Résumé : Récupère toute les permutation de n caractères dans une chaine donnée
// Description des paramètres d'entrée/sortie de 'Permutation' :
//
// Syntaxe :
//Permutation ( est chaîne, est tableau, est entier [, est chaîne [, est entier]])
//
// Paramètres :
//     saChaineSource (chaîne ANSI) :
//     tabRésultat (tableau) : tableau de résultats
//     nTaille (entier) : Nombre de caractères des résultats
//     saPermutPrécédente (chaîne ANSI - valeur par défaut="") : Chaine partielle issue des appels précédent
//     nIndiceCar (entier - valeur par défaut=1) : Rang du caractère en cour de traitement
// Valeur de retour :
//      Aucune
//
// Utilisation
//
//tabPermutation est tableau de chaine
//saChaineSource est une chaîne
//
//saChaineSource=GénérerChaine(6)     //Extrait les 6 première lettres de l'alphabet
//PermutRécur(saChaineSource,tabPermutation,4)     //Récupère les permutations de 4 caractères issus de la chaine source dans le tableau
//
PROCÉDURE Permutation(saChaineSource est chaîne,tabRésultat est tableau de chaîne,nTaille est entier,saPermutPrécédente est chaîne="",nIndiceCar est entier=1)
nNoCar est entier     //Position du caractère dans la chaine initiale
saTravail est une chaîne

saTravail=saPermutPrécédente
POUR nNoCar=1 _À_ Taille(saChaineSource)
     SI PAS Position(saTravail,saChaineSource[nNoCar]) ALORS //Le caractère n'existe pas dans la chaine de travail
          saTravail[nIndiceCar]=saChaineSource[nNoCar]
          SI nIndiceCar+1<=nTaille ALORS
               Permutation(saChaineSource,tabRésultat,nTaille,saTravail,nIndiceCar+1)
          SINON
               SI Taille(saTravail)=nTaille ALORS
                    TableauAjoute(tabRésultat)
                    saTravail=saPermutPrécédente
               FIN
          FIN
     FIN
FIN
[/CODE]

Et le petit utilitaire :
[CODE]
FONCTION GénérerChaine(nTailleChaine est entier=6):chaîne
nNoCaractère est un entier
saRésultat est une chaîne
nValAscii est un entier

nValAscii=65     //A

POUR nNoCaractère=1 _À_ nTailleChaine
     SI nNoCaractère=1 ALORS
          saRésultat=Caract(nValAscii)
     SINON
          saRésultat=ChaîneConstruit("%1%2",saRésultat,Caract(nValAscii))
     FIN
     nValAscii++
FIN

RENVOYER saRésultat
[/CODE]

Message envoyé le 21-05-2021 par rominfo (Italie)  
[CODE]
ProcTest("ABCDEFG", 3)

     INTERNAL PROCEDURE ProcTest(LOCAL sTest is string, LOCAL nPerm is int)
          LOCAL
               arrAscii     is array of int
               arrString     is array of string
               arrResult     is array of string
               nLenStr          is int
               
          nLenStr = Length(sTest)
          
          // creazione dell'array con le string da permutare     
          FOR n = 1 _TO_ Length(sTest)
               arrAscii.Add(Asc(Middle(sTest, n, 1)))
          END
          
          // permutazione delle string base          
          arrString.Add(ArrayToString(arrAscii.Map(x => Charact(x)),""))
          FOR n = 2 _TO_ Length(sTest)
               arrAscii[1]++
               arrAscii[n]--
               arrString.Add(ArrayToString(arrAscii.Map(x => Charact(x)),""))
          END
          
          // Disposizioni semplici di n elementi a gruppi di k : D(n,k) n=length(sstring) k=nPerm
          Trace("Numero combinazioni possibili (singola stringa): [%count_combinations(nPerm, nLenStr)%]")
          Trace("Numero combinazioni possibili (tutte le stringhe): [%count_combinations(nPerm, nLenStr)*arrString.Count%]")
          FOR EACH sString, nCount of arrString
               Trace("Stringa [%nCount%] => [%sString%]")
               comb(sString,nPerm)
          END
          // cancella tutte le combinazioni duplicate...     
          arrResult.DeleteDuplicate()
          Trace("Numero di combinazioni distinte: [%arrResult.Count%]")
          
          
               INTERNAL PROCEDURE count_combinations(k is int, n is int)
                    RESULT Factorial(n) / (Factorial(k) * Factorial(n-k))
               END
          
               INTERNAL PROCEDURE comb(c is string, m is int, s is int = 1, k is int = 1,v is string="")
                    IF k <= m THEN
                         FOR i = s _TO_ Length(c)
                              v[[k]] = c[]
                              comb(c, m, i+1, k+1, v)
                         END
                    ELSE
                         arrResult.Add(v) // array dei risultati...     
                    END
               END
          
          
          
     END

[/CODE]

Message envoyé le 21-05-2021 par Gemini1961 (Belgique)  
Le code suivant
"
SI nNoCaractère=1 ALORS
          saRésultat=Caract(nValAscii)
     SINON
          saRésultat=ChaîneConstruit("%1%2",saRésultat,Caract(nValAscii))
     FIN
"
Peut-être remplacé par :
" saRésultat+= Caract(nValAscii)

Bien Cordialement

Message envoyé le 02-06-2021 par PhilDeDakar (Senegal)  
bonjour
une petite classe plus générale

clStat est une Classe
     tblListeDesCombinaisons est un tableau dynamique de 0 chaînes
     tblListeDesArrangements est un tableau dynamique de 0 chaînes
     StringSeparator est une chaîne
END

PROCÉDURE Constructeur()
Dimension(:tblListeDesCombinaisons, 0)
Dimension(:tblListeDesArrangements, 0)
:StringSeparator = TAB



PROCÉDURE Destructeur()
Dimension(:tblListeDesCombinaisons, 0)
Dimension(:tblListeDesArrangements, 0)



PROCÉDURE makeAllCombination(MyElements est une chaîne, Separator est une chaîne = TAB, SpaceAllowed est un booléen = False, DuplicateElementAllowed est un boolean = False):booléen
nbElement, i est un entier
TempMyElements, TempElement est une chaîne
tblEléments est un tableau de chaînes

:StringSeparator = Separator
Dimension(:tblListeDesCombinaisons, 0)

// Si on ne désire pas d'éléments vide ou composé d'espace...
IF not SpaceAllowed THEN
     TempMyElements = ""
     FOR ALL STRING TempElement OF MyElements SEPARATED BY :StringSeparator
          IF SansEspace(TempElement) <> "" THEN
               IF TempMyElements <> "" THEN TempMyElements += :StringSeparator
               TempMyElements += SansEspace(TempElement)
          END
     END
     MyElements = TempMyElements
END

// Transforme la chaine en tableau
ChaîneVersTableau(MyElements, tblEléments, :StringSeparator)

// Si on ne désire pas de doublon...
IF not DuplicateElementAllowed THEN TableauSupprimeDoublon(tblEléments)

// il faut au minimum 2 éléments pour avoir des combinaisons
nbElement = Dimension(tblEléments)
IF nbElement < 2 THEN RENVOYER False

FOR i = 1 _TO_ nbElement
     // les combinaisons sont stockées dans le tableau :tblListeDesCombinaisons
     // i correspond au nombre d'élément pris pour faire la combinaison
     etCombinaison("", tblEléments, i)
END

// Le nombre de combinaison de p éléments pris dans un ensemble de n éléments est donné par la fonction C(n,p) = n! / [p! (n-p)!]
// où ! représente la fonction factorielle n!=1*2*3*4*5*6...*n
// On démontre que 2 puissance n = Somme[C(n,p)] pour p variant de 0 à n
// le sous ensemble composé de 0 éléments ne nous intéressant pas
RENVOYER(Dimension(:tblListeDesCombinaisons) = Puissance(2, nbElement)-1)



PROCÉDURE PRIVÉE getCombinaison(Combinaison est une chaîne, TblSousElements est un tableau de chaîne, Level est un entier )
n, i est un entier
NewTbl est un tableau de chaînes

IF Level = 0 THEN
     Dimension(:tblListeDesCombinaisons, Dimension(:tblListeDesCombinaisons)+1)
     :tblListeDesCombinaisons[Dimension(:tblListeDesCombinaisons)] = Combinaison[[1 À Taille(Combinaison)-1]]
     RETOUR
ELSE
     n = Dimension(TblSousElements)
     FOR i = 1 _TO_ n
          TableauCopie(TblSousElements, NewTbl, i+1)
          etCombinaison(Combinaison+TblSousElements+:StringSeparator, NewTbl, Level-1)
     END
END



PROCÉDURE makeAllArrangements(MyElements est une chaîne, Separator est une chaîne = ";", SpaceAllowed est un booléen = False, DuplicateElementAllowed est un boolean = False):booléen

nbElement est un entier
TempMyElements, TempElement est une chaîne
tblEléments est un tableau de chaînes

:StringSeparator = Separator
Dimension(:tblListeDesArrangements, 0)

// Si on ne désire pas d'éléments vide ou composé d'espace...
IF not SpaceAllowed THEN
     TempMyElements = ""
     FOR ALL STRING TempElement OF MyElements SEPARATED BY :StringSeparator
          IF SansEspace(TempElement) <> "" THEN
               IF TempMyElements <> "" THEN TempMyElements += :StringSeparator
               TempMyElements += SansEspace(TempElement)
          END
     END
     MyElements = TempMyElements
END

// Transforme la chaine en tableau
ChaîneVersTableau(MyElements, tblEléments, :StringSeparator)

// Si on ne désire pas de doublon...
IF not DuplicateElementAllowed THEN TableauSupprimeDoublon(tblEléments)

// il faut au minimum 2 éléments pour avoir des arrangements différents
nbElement = Dimension(tblEléments)
IF nbElement < 2 THEN RENVOYER False

etArrangement(tblEléments)

// Le nombre d'arrangements de n éléments est : n!
RENVOYER(Dimension(:tblListeDesArrangements) = Factorielle(nbElement))



PROCÉDURE PRIVÉE getArrangement(tblEléments est un tableau de * chaîne)
Dimension(:tblListeDesArrangements, 0)
isteArrangements(tblEléments)
TableauTrie(:tblListeDesArrangements)



PROCÉDURE PRIVÉE ListeArrangements(tblEléments est un tableau de * chaînes, k est un entier = 1)
i, n est un entier

n = Dimension(tblEléments)

IF n-k < 1 THEN
     Dimension(:tblListeDesArrangements, Dimension(:tblListeDesArrangements)+1)
     :tblListeDesArrangements[Dimension(:tblListeDesArrangements)] = TableauVersChaîne(tblEléments, :StringSeparator)
     RETOUR
ELSE
     FOR i=1 _TO_ n-k+1
          :MakeCircularPermutation(tblEléments, k)
          isteArrangements(tblEléments, k+1)     
     END
END
RETOUR



PROCÉDURE PRIVÉE MakeCircularPermutation(tblEléments, PositionDeDépart=1)
ii,jj est un entier
temp est une chaîne

jj = Dimension(tblEléments)
IF PositionDeDépart >= jj THEN
     Erreur("Oup's")
     RETOUR
END

temp = tblEléments[PositionDeDépart]

FOR ii = PositionDeDépart+1 _TO_ jj
     tblEléments[ii-1] = tblEléments[ii]
END

tblEléments[jj] = temp




Exemple d'utilisation :
i, j sont des entiers
EnsembleDesEléments, Séparator est une chaîne
s est une clStat

Séparator = " "
EnsembleDesEléments = "il fait beau"
// Génération de toutes les combinaisons de 1 à n éléments dans :tblListeDesCombinaisons[]
IF s:makeAllCombination(EnsembleDesEléments, Séparator) THEN
     
     FOR i = 1 _TO_ Dimension(s:tblListeDesCombinaisons)
          
          IF Taille(s:tblListeDesCombinaisons) > 1 THEN
               // Si il y a au moins 2 éléments alors génération de tout les arrangements pour la combinaison
               s:makeAllArrangements(s:tblListeDesCombinaisons, Séparator)
               
               // Affichage
               FOR j = 1 _TO_ Dimension(s:tblListeDesArrangements)
                    Trace(s:tblListeDesArrangements[j])
               END
          END
     END

END

Donne :
fait il
il fait
beau il
il beau
beau fait
fait beau
beau fait il
beau il fait
fait beau il
fait il beau
il beau fait
il fait beau

Message envoyé le 02-06-2021 par PhilDeDakar (Senegal)  
etCombinaison <-> ':'getCombinaison
etArrangement(TblElements) <-> ':'getArrangement(TblElements)
isteArrangements(tblEléments) <-> ':'ListeArrangements(tblEléments)

Message envoyé le 03-06-2021 par Gracelmann (Congo)  
Il de quoi avoir peur des Codeurs en WLanguage avec autant de possibilités !!!

Wahou !!! Chapeau !!

Message envoyé le 05-06-2021 par Yanson (Cameroun)  
Je vous remercie tous pour vos différentes réactions.
J’avoue que j’étais à cours d’idée et après vous, j’ai un gros embarras du choix.
Merci.

Message envoyé le 05-06-2021 par diresm (Algérie)  
Initiation à windev (code source inclut)
https://youtu.be/ICm6jE8LlPI


Pour répondre à ce message vous devez être membre

Entrée membre    Enregistrer

  Post reply  



  
Retour © 2021 forum.acam.ca
  
Flag Counter