Bonjour,
Je cherche un algorithme à implémenter en C qui soit capable à partir
d'un mot de X caractères de trouver toutes les écritures possibles pour
0 à X majuscule(s) présente(s) dans ce mot.
Bonjour,
Je cherche un algorithme à implémenter en C qui soit capable à partir
d'un mot de X caractères de trouver toutes les écritures possibles pour
0 à X majuscule(s) présente(s) dans ce mot.
Bonjour,
Je cherche un algorithme à implémenter en C qui soit capable à partir
d'un mot de X caractères de trouver toutes les écritures possibles pour
0 à X majuscule(s) présente(s) dans ce mot.
Bonjour,
Je cherche un algorithme à implémenter en C qui soit capable à partir d'un
mot de X caractères de trouver toutes les écritures possibles pour 0 à X
majuscule(s) présente(s) dans ce mot.
Exemple pour le mot 'test':
test
tesT
teSt
teST
tEst
tEsT
tESt
tEST
Test
TesT
TeSt
TeST
TEst
TEsT
TESt
TEST
Merci
Bonjour,
Je cherche un algorithme à implémenter en C qui soit capable à partir d'un
mot de X caractères de trouver toutes les écritures possibles pour 0 à X
majuscule(s) présente(s) dans ce mot.
Exemple pour le mot 'test':
test
tesT
teSt
teST
tEst
tEsT
tESt
tEST
Test
TesT
TeSt
TeST
TEst
TEsT
TESt
TEST
Merci
Bonjour,
Je cherche un algorithme à implémenter en C qui soit capable à partir d'un
mot de X caractères de trouver toutes les écritures possibles pour 0 à X
majuscule(s) présente(s) dans ce mot.
Exemple pour le mot 'test':
test
tesT
teSt
teST
tEst
tEsT
tESt
tEST
Test
TesT
TeSt
TeST
TEst
TEsT
TESt
TEST
Merci
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
- Si vous avez la solution - une liste de mots - pour N lettres, il
suffit pour passer à N + 1 de "concatener" les termes de la
liste-solution successivement à minuscule() et majuscule() de la lettre
suppémentaire.
- La solution pour N = 1 est évidente.
(*) je ne suis pas sûr du vocabulaire. Je dirais que le raisonnement
est itératif, et le traitement POURRA être récursif.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
- Si vous avez la solution - une liste de mots - pour N lettres, il
suffit pour passer à N + 1 de "concatener" les termes de la
liste-solution successivement à minuscule() et majuscule() de la lettre
suppémentaire.
- La solution pour N = 1 est évidente.
(*) je ne suis pas sûr du vocabulaire. Je dirais que le raisonnement
est itératif, et le traitement POURRA être récursif.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
- Si vous avez la solution - une liste de mots - pour N lettres, il
suffit pour passer à N + 1 de "concatener" les termes de la
liste-solution successivement à minuscule() et majuscule() de la lettre
suppémentaire.
- La solution pour N = 1 est évidente.
(*) je ne suis pas sûr du vocabulaire. Je dirais que le raisonnement
est itératif, et le traitement POURRA être récursif.
Je cherche un algorithme à implémenter en C qui soit capable à
partir d'un mot de X caractères de trouver toutes les écritures
possibles pour 0 à X majuscule(s) présente(s) dans ce mot.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
<snip>
Voici une tentative en C.
<snip mode d'emploi>
inline void souhappeCase(char* s, int offset)
{
assert(isalpha(s[offset]));
s[offset] = islower(s[offset]) ? toupper(s[offset])
: tolower(s[offset]);
void afficheRecurs(char* s, int index)
{
if(index >= 0){
afficheRecurs(s, index - 1);
souhappeCase(s, index);
//puts(s);
mydebugputs(s);
afficheRecurs(s, index - 1);
}
int main(int argc, char *argv[])
<snip init>
for(curseur = 0; curseur < taille; curseur++){
if(! isalpha(argv[1][curseur])){
fprintf(stderr, "Le mot ne doit contenir que des lettres!");
return EXIT_SUCCESS;
Je cherche un algorithme à implémenter en C qui soit capable à
partir d'un mot de X caractères de trouver toutes les écritures
possibles pour 0 à X majuscule(s) présente(s) dans ce mot.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
<snip>
Voici une tentative en C.
<snip mode d'emploi>
inline void souhappeCase(char* s, int offset)
{
assert(isalpha(s[offset]));
s[offset] = islower(s[offset]) ? toupper(s[offset])
: tolower(s[offset]);
void afficheRecurs(char* s, int index)
{
if(index >= 0){
afficheRecurs(s, index - 1);
souhappeCase(s, index);
//puts(s);
mydebugputs(s);
afficheRecurs(s, index - 1);
}
int main(int argc, char *argv[])
<snip init>
for(curseur = 0; curseur < taille; curseur++){
if(! isalpha(argv[1][curseur])){
fprintf(stderr, "Le mot ne doit contenir que des lettres!");
return EXIT_SUCCESS;
Je cherche un algorithme à implémenter en C qui soit capable à
partir d'un mot de X caractères de trouver toutes les écritures
possibles pour 0 à X majuscule(s) présente(s) dans ce mot.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
<snip>
Voici une tentative en C.
<snip mode d'emploi>
inline void souhappeCase(char* s, int offset)
{
assert(isalpha(s[offset]));
s[offset] = islower(s[offset]) ? toupper(s[offset])
: tolower(s[offset]);
void afficheRecurs(char* s, int index)
{
if(index >= 0){
afficheRecurs(s, index - 1);
souhappeCase(s, index);
//puts(s);
mydebugputs(s);
afficheRecurs(s, index - 1);
}
int main(int argc, char *argv[])
<snip init>
for(curseur = 0; curseur < taille; curseur++){
if(! isalpha(argv[1][curseur])){
fprintf(stderr, "Le mot ne doit contenir que des lettres!");
return EXIT_SUCCESS;
En news:, Pierre Maurette va escriure:Je cherche un algorithme à implémenter en C qui soit capable à
partir d'un mot de X caractères de trouver toutes les écritures
possibles pour 0 à X majuscule(s) présente(s) dans ce mot.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
<snip>
Oui.Voici une tentative en C.
<snip mode d'emploi>
<snip #include>inline void souhappeCase(char* s, int offset)
{
assert(isalpha(s[offset]));
Pourquoi cet assert() ? le programme n'est pas susceptible de traiter un mot
comme 'casse-pied' ?
Par ailleurs, isalpha a un comportement indéfini ici (par exemple lorsque
char est signed).s[offset] = islower(s[offset]) ? toupper(s[offset])
: tolower(s[offset]);
void afficheRecurs(char* s, int index)
{
if(index >= 0){
afficheRecurs(s, index - 1);
souhappeCase(s, index);
//puts(s);
mydebugputs(s);
afficheRecurs(s, index - 1);
}
Non. Si la lettre ne change pas dans l'appel à souhappeCasse() (cas d'un
tiret, ou d'un caractère accentué bas-de-casse dont la capitale n'est pas
disponible dans le jeu de caractère actuel, disons par exemple un ß), tu vas
afficher deux fois la même forme, et ce n'est pas correct.
int main(int argc, char *argv[]) <snip init>
for(curseur = 0; curseur < taille; curseur++){
if(! isalpha(argv[1][curseur])){
Manque un appel à setlocale() avant cette ligne.fprintf(stderr, "Le mot ne doit contenir que des lettres!");
return EXIT_SUCCESS;
Ce doit être un succès pour tromper l'ennemi...
Enfin, ton implémentation modifie la chaîne en place, ce qui suppose qu'il
existe une bijection entre les capitales et les bas-de-casses, ce qui n'est
pas obligatoirement le cas (par exemple ÿ en iso-8859-1).
En news:mn.72337d7bc7d4cdbf.79899@wanadoo.fr, Pierre Maurette va escriure:
Je cherche un algorithme à implémenter en C qui soit capable à
partir d'un mot de X caractères de trouver toutes les écritures
possibles pour 0 à X majuscule(s) présente(s) dans ce mot.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
<snip>
Oui.
Voici une tentative en C.
<snip mode d'emploi>
<snip #include>
inline void souhappeCase(char* s, int offset)
{
assert(isalpha(s[offset]));
Pourquoi cet assert() ? le programme n'est pas susceptible de traiter un mot
comme 'casse-pied' ?
Par ailleurs, isalpha a un comportement indéfini ici (par exemple lorsque
char est signed).
s[offset] = islower(s[offset]) ? toupper(s[offset])
: tolower(s[offset]);
void afficheRecurs(char* s, int index)
{
if(index >= 0){
afficheRecurs(s, index - 1);
souhappeCase(s, index);
//puts(s);
mydebugputs(s);
afficheRecurs(s, index - 1);
}
Non. Si la lettre ne change pas dans l'appel à souhappeCasse() (cas d'un
tiret, ou d'un caractère accentué bas-de-casse dont la capitale n'est pas
disponible dans le jeu de caractère actuel, disons par exemple un ß), tu vas
afficher deux fois la même forme, et ce n'est pas correct.
int main(int argc, char *argv[]) <snip init>
for(curseur = 0; curseur < taille; curseur++){
if(! isalpha(argv[1][curseur])){
Manque un appel à setlocale() avant cette ligne.
fprintf(stderr, "Le mot ne doit contenir que des lettres!");
return EXIT_SUCCESS;
Ce doit être un succès pour tromper l'ennemi...
Enfin, ton implémentation modifie la chaîne en place, ce qui suppose qu'il
existe une bijection entre les capitales et les bas-de-casses, ce qui n'est
pas obligatoirement le cas (par exemple ÿ en iso-8859-1).
En news:, Pierre Maurette va escriure:Je cherche un algorithme à implémenter en C qui soit capable à
partir d'un mot de X caractères de trouver toutes les écritures
possibles pour 0 à X majuscule(s) présente(s) dans ce mot.
L'algo, qui n'a pas trop à voir avec le C, s'impose de lui-même et il
est itératif(*):
<snip>
Oui.Voici une tentative en C.
<snip mode d'emploi>
<snip #include>inline void souhappeCase(char* s, int offset)
{
assert(isalpha(s[offset]));
Pourquoi cet assert() ? le programme n'est pas susceptible de traiter un mot
comme 'casse-pied' ?
Par ailleurs, isalpha a un comportement indéfini ici (par exemple lorsque
char est signed).s[offset] = islower(s[offset]) ? toupper(s[offset])
: tolower(s[offset]);
void afficheRecurs(char* s, int index)
{
if(index >= 0){
afficheRecurs(s, index - 1);
souhappeCase(s, index);
//puts(s);
mydebugputs(s);
afficheRecurs(s, index - 1);
}
Non. Si la lettre ne change pas dans l'appel à souhappeCasse() (cas d'un
tiret, ou d'un caractère accentué bas-de-casse dont la capitale n'est pas
disponible dans le jeu de caractère actuel, disons par exemple un ß), tu vas
afficher deux fois la même forme, et ce n'est pas correct.
int main(int argc, char *argv[]) <snip init>
for(curseur = 0; curseur < taille; curseur++){
if(! isalpha(argv[1][curseur])){
Manque un appel à setlocale() avant cette ligne.fprintf(stderr, "Le mot ne doit contenir que des lettres!");
return EXIT_SUCCESS;
Ce doit être un succès pour tromper l'ennemi...
Enfin, ton implémentation modifie la chaîne en place, ce qui suppose qu'il
existe une bijection entre les capitales et les bas-de-casses, ce qui n'est
pas obligatoirement le cas (par exemple ÿ en iso-8859-1).
si la récursion n'est pas le thème du devoir, tu peux aussi compter de 0
à 2^N-1 et mettre une majuscule à l'emplacement i du mot lorsque le bit
i de l'index est à 1 et une minuscule lorsqu'il est à 0.
si la récursion n'est pas le thème du devoir, tu peux aussi compter de 0
à 2^N-1 et mettre une majuscule à l'emplacement i du mot lorsque le bit
i de l'index est à 1 et une minuscule lorsqu'il est à 0.
si la récursion n'est pas le thème du devoir, tu peux aussi compter de 0
à 2^N-1 et mettre une majuscule à l'emplacement i du mot lorsque le bit
i de l'index est à 1 et une minuscule lorsqu'il est à 0.
typedef struct _variant {
unsigned int size ;
char * str ;
} variant ;
int variant_init(variant * v, const char * s)
{
memset(v, ' ', sizeof *v) ;
v->size = strlen(s) ;
if(v->size > sizeof(unsigned int)*8 - 1)
return -1 ;
*(next+pos) = step & 1 << pos ? toupper(first->str[pos]) :
int main(int argc, char ** argv)
[...]
result = malloc(variant.size * sizeof(char)) ;
typedef struct _variant {
unsigned int size ;
char * str ;
} variant ;
int variant_init(variant * v, const char * s)
{
memset(v, ' ', sizeof *v) ;
v->size = strlen(s) ;
if(v->size > sizeof(unsigned int)*8 - 1)
return -1 ;
*(next+pos) = step & 1 << pos ? toupper(first->str[pos]) :
int main(int argc, char ** argv)
[...]
result = malloc(variant.size * sizeof(char)) ;
typedef struct _variant {
unsigned int size ;
char * str ;
} variant ;
int variant_init(variant * v, const char * s)
{
memset(v, ' ', sizeof *v) ;
v->size = strlen(s) ;
if(v->size > sizeof(unsigned int)*8 - 1)
return -1 ;
*(next+pos) = step & 1 << pos ? toupper(first->str[pos]) :
int main(int argc, char ** argv)
[...]
result = malloc(variant.size * sizeof(char)) ;
void PrintSolutionN(char * mot, int len, long index)
sol[i] = toupper(mot[i]);
int N = strlen(mot);
long total = 1<<N;
int index;
printf("Analyse pour %s: %ld solutions.n", mot, total);
for(index=0; index < total; index++)
void PrintSolutionN(char * mot, int len, long index)
sol[i] = toupper(mot[i]);
int N = strlen(mot);
long total = 1<<N;
int index;
printf("Analyse pour %s: %ld solutions.n", mot, total);
for(index=0; index < total; index++)
void PrintSolutionN(char * mot, int len, long index)
sol[i] = toupper(mot[i]);
int N = strlen(mot);
long total = 1<<N;
int index;
printf("Analyse pour %s: %ld solutions.n", mot, total);
for(index=0; index < total; index++)
int variant_init(variant * v, const char * s)
{
memset(v, ' ', sizeof *v) ;
v->size = strlen(s) ;
Problème potentiel lorsque strlen() retourne une valeur supérieure à
UNIT_MAX (en supposant par exemple que size_t est un type plus grand que
unsigned.)
if(v->size > sizeof(unsigned int)*8 - 1)
return -1 ;
Intéressant. Tu limites la taille à N-1 (N le nombre de bits dans un entier,
je néglige ici les cas particuliers du genre char sur 9 bits), alors que ton
algorithme devrait pouvoir être utilisé avec une lettre de plus. Je sais
bien que tel que tu l'as programmé il va probablement avoir des soucis si on
augmente la taille d'un, mais à mon sens c'est justement cela qui est
intéressant, non ?
*(next+pos) = step & 1 << pos ? toupper(first->str[pos]) :
Bzzz. str est un char*, str[pos] est éventuellement signé ; toupper() attend
un int avec soit la valeur EOF, soit une valeur représentable comme unsigned
char. Bisbille.
Le mieux est d'utiliser des unsigned char partout dans ton programme (et
d'expliquer pourquoi).
int main(int argc, char ** argv)
[...]result = malloc(variant.size * sizeof(char)) ;
Mmmh... et un malloc() sans vérifier le retour, un !
int variant_init(variant * v, const char * s)
{
memset(v, ' ', sizeof *v) ;
v->size = strlen(s) ;
Problème potentiel lorsque strlen() retourne une valeur supérieure à
UNIT_MAX (en supposant par exemple que size_t est un type plus grand que
unsigned.)
if(v->size > sizeof(unsigned int)*8 - 1)
return -1 ;
Intéressant. Tu limites la taille à N-1 (N le nombre de bits dans un entier,
je néglige ici les cas particuliers du genre char sur 9 bits), alors que ton
algorithme devrait pouvoir être utilisé avec une lettre de plus. Je sais
bien que tel que tu l'as programmé il va probablement avoir des soucis si on
augmente la taille d'un, mais à mon sens c'est justement cela qui est
intéressant, non ?
*(next+pos) = step & 1 << pos ? toupper(first->str[pos]) :
Bzzz. str est un char*, str[pos] est éventuellement signé ; toupper() attend
un int avec soit la valeur EOF, soit une valeur représentable comme unsigned
char. Bisbille.
Le mieux est d'utiliser des unsigned char partout dans ton programme (et
d'expliquer pourquoi).
int main(int argc, char ** argv)
[...]
result = malloc(variant.size * sizeof(char)) ;
Mmmh... et un malloc() sans vérifier le retour, un !
int variant_init(variant * v, const char * s)
{
memset(v, ' ', sizeof *v) ;
v->size = strlen(s) ;
Problème potentiel lorsque strlen() retourne une valeur supérieure à
UNIT_MAX (en supposant par exemple que size_t est un type plus grand que
unsigned.)
if(v->size > sizeof(unsigned int)*8 - 1)
return -1 ;
Intéressant. Tu limites la taille à N-1 (N le nombre de bits dans un entier,
je néglige ici les cas particuliers du genre char sur 9 bits), alors que ton
algorithme devrait pouvoir être utilisé avec une lettre de plus. Je sais
bien que tel que tu l'as programmé il va probablement avoir des soucis si on
augmente la taille d'un, mais à mon sens c'est justement cela qui est
intéressant, non ?
*(next+pos) = step & 1 << pos ? toupper(first->str[pos]) :
Bzzz. str est un char*, str[pos] est éventuellement signé ; toupper() attend
un int avec soit la valeur EOF, soit une valeur représentable comme unsigned
char. Bisbille.
Le mieux est d'utiliser des unsigned char partout dans ton programme (et
d'expliquer pourquoi).
int main(int argc, char ** argv)
[...]result = malloc(variant.size * sizeof(char)) ;
Mmmh... et un malloc() sans vérifier le retour, un !