Bonjour, ils sont de la forme 2n+1 donc une simple boucle Pour I allant de 1 à n et affichant 2I+1 fait l'affaire.

VARIABLES
  n EST_DU_TYPE NOMBRE
  i EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  LIRE n
  POUR i ALLANT_DE 1 A n
    DEBUT_POUR
    n PREND_LA_VALEUR 2*n+1
    AFFICHER n
    FIN_POUR
FIN_ALGORITHME

L'algorithme va s'arrêter un jour?

non ça n'est pas tout à fait ça, en écrivant n PREND_LA_VALEUR 2*n+1 tu perds la liste des nombres impairs. Il te faut une autre variable.

VARIABLES
n EST_DU_TYPE NOMBRE
i EST_DU_TYPE NOMBRE
x EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE n
POUR i ALLANT_DE 1 A n
DEBUT_POUR
x PREND_LA_VALEUR 2*i+1
AFFICHER* x
FIN_POUR
FIN_ALGORITHME

Ok merci. J'ai un deuxième exercice qui ressemble à ça.

Je dois écrire un programme qui calcule la sommes des n premiers nombres entiers impairs.

C'est presque pareil mais en plus tu crées une variable que tu appelles S et que tu initialises à 0 et tu glisses dans la boucle
S PREND_LA_VALEUR S+x juste après x PREND_LA_VALEUR 2*i+1
Fait commencer la boucle à 0 et pas à 1 sinon ça n'ajoutera pas le premier nombre impair 1

Fait commencer la boucle à 0 et fait la finir à n-1 sinon il y aura n+1 nombres impairs et pas n

VARIABLES
  n EST_DU_TYPE NOMBRE
  i EST_DU_TYPE NOMBRE
  x EST_DU_TYPE NOMBRE
  S EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  S PREND_LA_VALEUR 0
  LIRE n
  POUR i ALLANT_DE 1 A n
    DEBUT_POUR
    x PREND_LA_VALEUR 2*i+1
    S PREND_LA_VALEUR S+x
    AFFICHER* x
    FIN_POUR
FIN_ALGORITHME

Apres je ne comprends pas

Oui c'est ça, mais il faut que tu mette un AFFICHER* S après le FIN_POUR si tu veux la valeur de S.
tu ne comprends pas quoi ?

Je ne comprends pas pourquoi on fais ça pour calculer les nombres impaires

Pour calculer la somme des nombres impairs.

explique mieux ce que tu ne comprends pas parce que là je ne peux pas t'aider.

Bonjour,  Glapion,

Je suis nouvelle sur ce site et j'ai remarqué que tu avais l'air de bien géré tous ce qui est algorithme.

Je suis étudiante, et j'ai un exercice du même genre à faire, cependant malgré les différents essais, et l'explication que tu as donné ici je n'arrive pas à comprendre.

En espérant que tu lises ce message malgré le fait que ce topic date, et que tu puisses m'aider!

Bonne journée

Melia

Oui mais tu devrais créer ton propre topic (sauf si ton énoncé est exactement celui de ce topic ci ?).

Merci de ta réponse aussi rapide!

C'est le même exercice mais avec nombre paires

tu veux afficher les nombres pairs ? ou calculer leur somme ?
qu'est-ce que tu proposes alors comme algorithme en prenant modèle sur ceux de ce topic ?

Les deux, je veux tout d'abord
afficher les N premier nombre paire et faire la somme des N premier nombre paire

Je n'ai pour le moment absolument rien a proposer, je suis complètement perdu dans cette matière et même en lisant ce topic je n'arrive pas a savoir ce que représente i et x dans vos algorithmes ?

Alors essaye de comprendre cet algorithme qui est plutôt simple :
_{(tu peux le copier/coller dans algobox en mode éditeur de texte, ou bien directement en ligne dans proglab )}

VARIABLES 
  n EST_DU_TYPE NOMBRE 
  i EST_DU_TYPE NOMBRE 
  x EST_DU_TYPE NOMBRE 
  S EST_DU_TYPE NOMBRE 
DEBUT_ALGORITHME 
  S PREND_LA_VALEUR 0 
  AFFICHER* "on veut afficher et calculer la somme des nombres pairs de 2 à 2n. entrez n : "
  LIRE n 
  POUR i ALLANT_DE 1 A n 
    DEBUT_POUR 
    x PREND_LA_VALEUR 2*i 
    S PREND_LA_VALEUR S+x 
    AFFICHER* x 
    FIN_POUR
    AFFICHER "la somme des nombres est : "
    AFFICHER* S 
FIN_ALGORITHME

Merci beaucoup de ta réponse, j'ai compris à peu près mais j'ai beaucoup de mal a comprendre ce principe de la boucle et pour le I allant de tel à tel ...

Je ne comprend pas le principe.

Merci quand même à toi de ta précieuse précision qui m'a malgré tout permis de comprend une majorité de l'algorithme

En fait je comprend l'idée de la boucle en général mais ce que je ne cerne pas très bien, c'est pourquoi insérer ceci à la suite :

   x PREND_LA_VALEUR 2*i
    S PREND_LA_VALEUR S+x

POUR i ALLANT_DE 1 A n
DEBUT_POUR
--------------------
FIN_POUR

l'algorithme arrive sur POUR i ALLANT_DE 1 A n , il fait i = 1
il exécute toutes les instructions qu'il y a à la place des pointillés
il arrive à FIN_POUR, il remonte à POUR i ALLANT_DE 1 A n et il incrémente i, c.a.d il fait i = 2
et il parcourt la boucle à nouveau, etc... jusqu'à ce que i = n
il parcourt une dernière fois la boucle et puis il continue sur les instruction qu'il y a après le FIN_POUR.

tu devrais demander à algobox d'exécuter le code pas à pas , tu te rendrais alors exactement compte des valeurs que prennent les variables à chaque pas.

C'est très pratique, ça permet de demander à la machine de faire 10000 fois un même calcul, ce qui serait impossible à la main. Toutes les suites récurrentes peuvent se calculer de proche en proche de cette façon.

Oui oui ça c'est bon j'avais mis dès le départ sous le mode pas à pas et c'est clair ça permet de mieux comprendre!

J'ai juste une dernière question, il n'est pas obligatoire de mettre "afficher x" dans l'algo ?

Je te remercie pour ton aide en tout cas!

C'est vraiment très gentil

AFFICHER x dans la boucle permet d'afficher tous les nombres pairs.
Si tu ne veux que la somme, tu peux enlever l'instruction.

D'accord !

Merci beaucoup !