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
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
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 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
// 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
// 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)
forum.acam.ca
Liste des permutation d'une chaine de 4 caractères
etCombinaison("", tblEléments, i)
isteArrangements(tblEléments)