Exo algo inversement de chaine

Bonjour,

Quelque chose ne colle pas dans ton algo

Tu déclares a comme entier et il me semble qu'à la fin tu affiches a comme un mot ou un tableau de caractères
C'est pas bon. Il faut declarer a comme caractère et l'afficher au fur et à mesure que tu le tires de mot
ou encore tu peux t'en servir pour reconstituer un mot_inverse et afficher mot_inverse en une seule fois à la fin.

A+

En fait l'idéal ce serait que tu écrives le programme dans un langage que tu ferais tourner sur un ordinateur pour mieux sentir les choses, pour pouvoir tester etc.

Afficher "saisir mot ?";
Lire mot;
n <- longueur(mot);
Pour i = 0; i < n ; i = i +1
  it <- i + 1;
  Ecrire "iteration" it " : " sschaine( mot( n - i -1, 1) );
  Ecrire le caractère de retour à la ligne (std::endl en C++, \n dans la plupart des langages)
Fin pour
Ecrire "fin"

Ceci va donner pour "tapir" (avec t=caractère à l'index 0,a= caractère à l'index 1, ..., r = caractère à l'index 4) cette exécution en pas à pas. Je mets en gras ce qui apparaît à l'écran :

saisir mot ? tapir
// le mot est de longueur 5 (n=5)
// je rentre dans la boucle pour (i=0), cette valeur est <5 donc je rentre dans la boucle pour
// je mets i+1=1 dans it (it=1)
// j'écris le message sachant que n - i - 1 = 4, => 'r'
iteration 1 : r
// je mets i+1=2 dans i, qui est inférieur à n=5
// je rentre dans la boucle pour (i=1), cette valeur est <5 donc je rentre dans la boucle pour
// je mets i+1=2 dans it (it=1)
// j'écris le message sachant que n - i - 1 = 3, => 'i'
iteration 2 : i
// même raisonnement
iteration 3 : p
// même raisonnement
iteration 4 : a
// même raisonnement
iteration 5 : t
// cette fois-ci i=5 et donc on n'a plus i<n, donc je saute la boucle pour
// J'écris Fin
Fin

Ok maintenant si on utilise le programme :

Afficher "saisir mot ?";
Lire mot;
n <- longueur(mot);
Pour i = 0; i < n ; i = i +1
  Ecrire sschaine( mot( n - i -1, 1) );
Fin pour
Ecrire le caractère de retour à la ligne

Je vais bien écrire "ripat" à l'écran.
Est ce que c'est plus clair comme ça ?

Bonne chance

Ben justement tu écris bien les caractères un par un ! Rien ne t'oblige à écrire la chaîne d'un coup.
Exemple pour tapir :
itération 1 : tu écris r (sous chaîne de longueur 1 à partir de x = 5)
itération 2 : tu écris i (sous chaîne de longueur 1 à partir de x = 4)
itération 3 : tu écris p (sous chaîne de longueur 1 à partir de x = 3)
itération 4 : tu écris a (sous chaîne de longueur 1 à partir de x = 2)
itération 5 : tu écris t (sous chaîne de longueur 1 à partir de x = 1)
puis tu passes à la ligne, comme dans le code que je t'ai donné dans <1>

Bonne chance

Aprés un peu plus de plus de reflexion, voila ce que j'ai pu conclure...

5) Chaine inversée
*Variables :
mot : Chaine,
l, i, a :entiers

Afficher(« Saisir un mot »)
Saisir(mot)
l<-- LONGUEUR(mot)
a<-- sschaine(mot , l, 1)
Pour i de l à 0
a<- -a+sschaine(mot,l-1,1)
FinPour
Afficher (a)
Fin

Bon, Voila ce que je ferais:

*Variables :
mot, mot-inverse : Chaine,
l, i, :entiers
a: caractere

Afficher(« Saisir un mot »)
Saisir(mot)
l<-- LONGUEUR(mot)
Pour i de (l-1) à 0 <----pour une chaine de longueur=5 les caractères sont numérotés de 0 à 4.
a<-- mot[i] <-------- a prend la valeur du ième caractère de mot; i est l'indice du caractère (numéro d'ordre).
Afficher (a)
FinPour
Fin

Tu veux voir comment on reconstitue une chaine à inverse ou tu veux essayer tout seul?

Je vais essayer de t'expliquer:

Soit le mot 'BONJOUR'
c'est comme si c'était un tableau de caractères mot={B,O,N,J,O,U,R}
Dans son ensemble le tableau est une chaine (ou un mot). Tu peut aussi épeler le mot, première lettre B, deuxième lettre O, quatrième lettre J.... Bien souvent les elements d'un tableau sont numérotés à partir de 0.
0 -> B
1 -> O
2 -> N
3 -> J
4 -> O
5 -> U
6 -> R

c'est ce que fait la boucle Pour i de (l-1) à 0
dans ce cas l=7 alors
Pour i de (l-1) à 0 --------> l-1=6 ; i commence a 6 et termine à 0 ; à chaque tour on enleve 1 à i (i=i-1)
a<-- mot[i] --------> par exemple quand i = 3 ; mot[3]='J' ; a prend la valeur 'J'
Afficher (a)
FinPour

Pour faire une chaine inversée, on va l'appeler Mot-Inverse, plutot que d'afficher a on va le stocker dans mot-inverse
Pour i de (l-1) à 0 ;--------> l-1=6 ; i commence a 6 et termine à 0 ; à chaque tour on enleve 1 à i (i=i-1)
a<-- mot[i] ;--------> par exemple quand i = 4 ; mot[4]='O' ; a prend la valeur 'O'
mot-inverse[l - i - 1]<-a ;----> 7-4-1=2 donc Mot-Inverse[2]='O'
FinPour

0 -> R
1 -> U
2 -> O
3 -> J
4 -> N
5 -> O
6 -> B

A la fin Mot_Inverse={R,U,O,J,NO,B} et on l'affiche.

*Variables :
mot, mot-inverse : Chaine,
l, i, :entiers
a: caractere

Afficher(« Saisir un mot »)
Saisir(mot)
l<-- LONGUEUR(mot)
Pour i de (l-1) à 0
a<-- mot[i]
mot-inverse[l - i - 1]<-a
FinPour
Afficher(Mot-Inverse)
Fin

Voila, j'espère avoir été assez clair. Salut.

Justement j'ai fait exprès de ne pas te le donner en pseudo code pour qu'il te reste quelque chose à faire. Si tu as compris la démarche c'est facile.

Qu'est ce qui te bloque ?

En fait la vraie question n'est pas est ce que le programme doit faire 7 lignes ou 20, mais plutôt si tu as compris comment fonctionnait la solution que nous t'avons proposé. Est ce que tu as obtenue une réponse satisfaisante à ton problème ou est-ce que tu as encore besoin d'éclaircissements ou de précisions ?

Bonne chance

Pas de reponses autre??
Je ne sais pas comment faire cet exo en "pseudo langage...&