Discussion :

[eric1970]

Bonjour à tous,
J'ai besoin d'un peu d'aide. Je ne demande PAS une solution, car ce n'est pas le but du forum, mais juste des idées, où s'il existe des méthodes pour réaliser ce que je veux.
Voilà, je voudrais lister tous les cas possibles de représentation d'un mot. J'explique : J'ai le mot suivant : ABC (la casse n'est pas importante). je voudrais avoir :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
ABC
ABB
ACC
A
B
CAA
CBB
AB
AC
CA
...
...

Merci de votre aide

[Zavonen]

Il s'agit de toutes les applications de {1} dans {A,B,C}
puis toutes les applications de {1,2} dans {A,B,C}
puis toutes les applications de {1,2,3} dans {A,B,C}
Ton problème est résolu dès que tu sais générer l'ensemble des applications de E dans F où E et F sont des ensembles finis.
Pour cela va voir, par exemple, mon cours sur les applications, et les exemples donnés en Python.

[ToTo13]

Bonjour,

d'un point de vue plus informatique, il te faut une récursivité.
A chaque appel de la fonction tu parcours toutes les lettre possibles.
Tu t'arrêtes à une profondeur égale au nombre de lettre dans ton ensemble.

[Zavonen]

Une récursivité n'est pas indispensable:

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# -*- coding: cp1252 -*-
 
def power(n,F):
    G=[[x] for x in F]
    for i in range (0,n-1):
        G= [y+[x] for y in G for x in F]
    return G
 
def main():
    F=['A','B','C']
    print power(1,F)+power(2,F)+power(3,F)
 
if __name__ == '__main__':
    main()

[kmdkaci]

Bonjour,
Moi aussi je suis intéressé par cette idée.

Zavonen, peux-tu expliquer ou traduire ton bout de code en Algon notamment la fonction power. Comme je viens de Java, j'avoue que je n'arrive pas à saisir ta manipulation.

merci

[Zavonen]

Bon, je te la fais plus simple avec des chaines de caractères.
G contient une liste de chaines. Au départ elle contient seulement la chaîne vide.
Dans ta boucle i va de 0 à 3 ici F='ABC'
A près le premier tour de boucle
G vaut ['A', 'B', 'C']
Après le second :
G vaut ['AA','BA','CA','AB','BB','CB','AC','BC','CC']
et ainsi de suite:
A chaque tour tu reprends tous les éléments de G et tu 'append' à chacun les éléments de F un à un.
Ce qui permet une syntaxe simple ici ce sont les comprehension lists de python. Je ne sais pas si cela existe en java, mais tu peux très bien t'en tirer avec une itération simple.

Code python :

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

1
2
3
4
5
6
7
8
9
10
# -*- coding: cp1252 -*-
#générer toutes les applications de {1,2,..n} dans F 
 
def power(n,F):
    G=['']
    for i in range (0,n):
        G= [y+x for y in G for x in F]
    return G
 
print power(4,'ABC')