Salut à tous^^

Voilà j'ai un algorithme à faire pour demain dont voilà l'énoncer:

"Choisir un entier P non nul et choisir un entier n non nul. 2crire l'algorithme permettant d'afficher la liste des nombres n construit de la manière suivante:
.Le premier nombre de la liste est P
.On passe d'un nombre de la liste au suivant en le divisant par deux si il est pair,sinon on lui ajoute 3"

J'ai donc construit l'algorithme mais ce qui m'embête c'est n, je ne sais pas pourquoi on doit le saisir. Enfaite, je ne sais pas si il faut faire une initialisation. Voilà ce que j'ai écris:

Entrée: Saisir P non nul
Saisir n non nul

Traitement: Pour i allant de 1 jusqu'à n
Si P est pair, alors R prend la valeur P/2
Sinon R prend la valeur P+3
Fin de si
Fin de pour

Sortie: Afficher R

Donc là l'ennui c'est que si j'ai bien capté, avec la boucle jusqu'à n, l'algorithme s'arrête lorsque le nombre P devient le nombre n (Genre si P=100 et que n=50 il faut juste diviser). Mais si n est un nombre que l'on ne peut pas rencontrer en utilisant l'algorithme sur P, alords mon algorithme n'est plus valable. Mais si je fais une initialisation et que je rentre la valeure n, alors P sera forcément entre 1 et n, non? Désoler si je suis pas clair je sais que j'explique mal. Bref je veux juste savoir si mon algorithme et juste et un petit indice sur ce qu'il faut faire si il est faux.

Merci d'avance^^

Non, la boucle sera faite n fois (50 dans ton exemple) et te donnera donc n (50) nombres.

Maintenant, les modifs à apporter :
- il ne faut pas la variable R, mais remplacer directement P (ou alors, à la fin de ta boucle, il faut que P prenne la valeur de R)
- comme P est censé être le premier nombre de la liste, il faut l'afficher avant tout traitement, donc il faut mettre un "afficher P" avant ta boucle "pour"
- comme on veut n nombres et que P est le premier, il n'y a en fait que n-1 nombres à calculer (donc il faut modifier la boucle "pour")
- ton algorithme, comme il est écrit, ne t'affichera qu'une valeur, la dernière. Il faut que l'affichage se trouve dans la boucle "pour"

Je suis pas sûr qu'on ai appris tout ça xD. Là je dois admettre que je suis largue. En classe on 'a jamais afficher P.

Donc ça veut dire:

Entrée: Saisir n
Saisir P

Traitement: Afficher P
Pour i allant de 1 jusqu'à n
Si P pair, alors R prend la valeur P/2
Sinon, R prend la valeur P+3
P prend la valeur de R
Afficher P
Fin de Si
Fin de pour

Sortie: Afficher P

Je pense que c'est faux mais je n'ai pas bien compris ce que tu m'as dit. En classe on n'a pas fait tous ces trucs. Que veux tu dire par "modifier la boucle"? En fait j'ai juste compris qu'il fallait que j'affiche P en dehors et dans la boucle.

Quand je disais "modifier la boucle", c'était en fait "modifier le compteur de la boucle". Parce que vu comment il est pour l'instant, la boucle va se faire n fois, alors que tu n'as besoin que de calculer n-1 valeurs (vu que la 1ère valeur est P, qu'on connaît à la base).

Pour essayer de te faire comprendre, je vais te montrer ce que ferait ton algo de ton 1er message :
n=4
P=10

R=5
R=5
R=5
R=5

"5" (là, c'est ce qu'il t'affiche à l'écran)

Alors, pourquoi on a 4 fois la même ligne ? Parce qu'on fait 4 fois la boucle avec à chaque fois les mêmes valeurs : au début de chacune des boucles, P valait 10, et donc à chaque fois on obtient R = 5.
Pourquoi on a qu'une valeur d'affichée ? Comme je l'ai dit dans l'autre message, tu ne demande l'affichage qu'après la boucle, donc il ne t'affiche que la dernière valeur de R qu'il a calculée.

putin c'est plus facile que chez moi vos algos

Bah ouais mais moi j'ai toujours été entrainer à faire des boucles juste avec n indiquant le nombre de fois où l'on répère l'opération. Donc là je dois faire comment? je n'ai pas appris et je vois pas trop comment faire. Il faut que j'écrive: "Pour i de 1 jusqu'à n-1"

Il faut aussi ajouter le pas. Pour i de 1 à n+1 par pas de 1 .

Je comporends rien. Pourquoi +1? Donc en fait je met:

Entrée: Saisir P
Saisir n

Traitement: Afficher P
Pour i de 1 jusqu'à n+1
Si P est pair, alors R prend la valeur P/2
Sinon R prend la valeur P+3
Fin de si
P prend la valeur R (Ou alors au lieu de dire R je dis P depuis le début?)
Fin de pour

Sortie: Afficher P

??

Non, c'est bien n-1.
Et le "Afficher P" que tu as mis à la fin doit en fait se trouver à la fin de la boucle "pour" pour qu'il t'affiche à chaque fois le nombre qu'il a calculé. Si tu le laisses à la toute fin, il ne t'affichera que le dernier nombre.

Ok alors je retente une dernière fois:

Entrée: Saisir P
Saisir n

Traitement: Afficher P
Pour i de 1 jusqu'à n-1
Si P est pair, alors R prend la valeur P/2
Sinon, R prend la valeur P+3
Fin de si
P prend la valeur de R
Afficher P
Fin de pour

Sortie: Afficher P

Et cette fois c'est bon?

Début
P,N,i,R entiers
Saisir P non nul
Lire P
Saisir N non nul
Lire N
Afficher P
Pour i allant de P+1 à N faire
R prends la valeur i
si R est pair alors R = R/2
sinon R=R+3
Afficher R
Fin pour
Fin

Pour i allant de P+1 à N par pas de 1 faire *

Tu mets les saisis et les lecture dans la partie "Entrée"?

Parce que tu mets Saisir P non nul, Lire P non nul et tu enchaines par Saisir N...

Alors que dans les entrées normalement c'est juste les saisis non?

Rokusu Enlève le "Afficher P" à la toute fin.

parkas_1 Je ne comprends pas ta boucle "for" : qu'est-ce que P vient faire dans le compteur alors qu'on veut n nombres ?

Bah oui mais le prof il nous a dit que un algorithme c'était Entrée, traitement et sortie, et nous on a toujours afficher le résultat dans sortie, pas dans le traitement.

Ah ouai j'ai mal compris l'énoncé je crois.
J'essayais tous les nombres de P+1 à N

Donc je mets quoi au final xD

En fait, ta sortie est dans la boucle : tu entres P et n (entrées), il t'affiche P (sortie), il calcule le nombre suivant (traitement), te l'affiche (sortie), calcule le nombre suivant (traitement),...

Ok bah merci beaucoup pour votre aide^^