Algorithme
Lolly
-
ccm81 Messages postés 10909 Date d'inscription Statut Membre Dernière intervention -
ccm81 Messages postés 10909 Date d'inscription Statut Membre Dernière intervention -
Bonjour,
Alors, voilà, j'ai un problème avec l'algorithme que je dois écrire..
Voici le sujet:
Soit la suite (Un) définie pour tout entier naturel n non nul par Un= [1+(1/n)]^n. Cette suite est convergente et sa limite vaut le nombre e. Écrire un algorithme qui donne le premier entier naturel n tel que (Un) est une approximation de e avec une précision choisie au départ.
J'ai peut-être quelque chose:
lire n (précision)
U prend la valeur 0
Tant que n<e:
Un prend la [1+(1/n)]^n
Fin du Tant que
Afficher n
Voilà. Après, je ne sais pas si c'est juste. Pouvez me dire si c'est correct et si ça ne l'est pas, ce qui est faux ?
Alors, voilà, j'ai un problème avec l'algorithme que je dois écrire..
Voici le sujet:
Soit la suite (Un) définie pour tout entier naturel n non nul par Un= [1+(1/n)]^n. Cette suite est convergente et sa limite vaut le nombre e. Écrire un algorithme qui donne le premier entier naturel n tel que (Un) est une approximation de e avec une précision choisie au départ.
J'ai peut-être quelque chose:
lire n (précision)
U prend la valeur 0
Tant que n<e:
Un prend la [1+(1/n)]^n
Fin du Tant que
Afficher n
Voilà. Après, je ne sais pas si c'est juste. Pouvez me dire si c'est correct et si ça ne l'est pas, ce qui est faux ?
A voir également:
- Algorithme
- Logiciel algorithme euromillion - Télécharger - Loisirs créatifs
- Logiciel algorithme gratuit - Télécharger - Édition & Programmation
- Algorithme euromillion excel gratuit - Forum Algorithmes / Méthodes
- Algorithme ajout rapide snapchat - Forum Snapchat
- Ajout rapide snap - Forum Snapchat
8 réponses
bonjour à tous, bonjour Lolly
quelques erreurs dans ton algorithme
en désordre quelques points importants
bon courage
quelques erreurs dans ton algorithme
en désordre quelques points importants
1. n n'est pas la précision mais une variable (entière) correspondant au rang des termes de la suite (Un)
2. la précision p est un réel du type 0.001, 0.0001 etc... qui marque la précision souhaitée (la différence entre la valeur exacte e et le terme Un de ta suite )
3. le calcul de Un doit continuer tant que |Un-e| > p
4. le corps de la boucle
4.1. mise à jour de n
4.2. calcul de la nouvelle valeur de Un (en fonction du n actuel)
5. tu supposes que e est connu, si ce n'est pas le cas, il te faut déclarer cette valeur de e comme une constante (e ~ 2.7182818284590)
6. tu dois déclarer les variables utilisées soit n (entier), Un (ou U) et p réels
7. ces variables doivent être initialisées
7.1. n et Un par une affectation (ex n prend la valeur 0)
7.2. p doit être fourni par l'utilisateur, donc il te faut une instruction lire p
8. il te faut aussi prévoir une sortie des résultats n et Un
bon courage
Bien joué Lolly, je crois que tu as tout compris. En plus tu as bien séparé les différentes parties de ton texte, c'est une très bonne habitude.
RQ1. les "nombreux" points que j'ai soulevés sont un "mal" nécessaire, c'est la partie analyse de la recherche, c'est à dire, identifier les différents points, pas forcément dans le bon ordre, et leur trouver une solution. Le passage à l'algorithme consistera à reprendre ces points et à les mettre dans le bon ordre
RQ2. tu as tout à fait le droit de nommer Un une variable, en fait on a toujours intérêt à donner un nom "parlant" aux variables, cela permet une lecture plus aisée. Il y a toutefois un problème avec les calculatrices, type T82-83-84, CASIO 35-65 qui n'acceptent qu'une lettre comme identifiant de variable, si tu dois programmer ton algorithme sur une telle machine, tu nommeras U la variable Un
bon courage pour la suite
RQ1. les "nombreux" points que j'ai soulevés sont un "mal" nécessaire, c'est la partie analyse de la recherche, c'est à dire, identifier les différents points, pas forcément dans le bon ordre, et leur trouver une solution. Le passage à l'algorithme consistera à reprendre ces points et à les mettre dans le bon ordre
RQ2. tu as tout à fait le droit de nommer Un une variable, en fait on a toujours intérêt à donner un nom "parlant" aux variables, cela permet une lecture plus aisée. Il y a toutefois un problème avec les calculatrices, type T82-83-84, CASIO 35-65 qui n'acceptent qu'une lettre comme identifiant de variable, si tu dois programmer ton algorithme sur une telle machine, tu nommeras U la variable Un
bon courage pour la suite
Je suis pas trop douée en math mais pas mal en algo.
Est-ce que tu peux juste m'aider à éclaircir le problème?
C'est quoi n ? Ta précision ou le premier entier de ta suite ?
Est-ce que tu peux juste m'aider à éclaircir le problème?
C'est quoi n ? Ta précision ou le premier entier de ta suite ?
Oui, je me suis embrouillée, merci de me l'avoir fait remarquer; d'après l'énoncé n le premier entier de la suite.. donc je pose p à la place de la précision. Mais je t'avouerais que c'est flou pour moi.
Parce que maintenant le soucis, c'est ; comment lui demander de faire un calcul avec n sans lui donner de valeur.. Ah si, j'ai peux être compris.
avec p= précision
n= 1er entier de la suite
lire p
n prend la valeur 0
U prend la valeur 0
Tant que p<e:
n prend la valeur n+1
Un prend la valeur [1+(1/n)]^n
Fin du Tant que
Afficher n
Ca serais mieux comme ca tu crois ?
Parce que maintenant le soucis, c'est ; comment lui demander de faire un calcul avec n sans lui donner de valeur.. Ah si, j'ai peux être compris.
avec p= précision
n= 1er entier de la suite
lire p
n prend la valeur 0
U prend la valeur 0
Tant que p<e:
n prend la valeur n+1
Un prend la valeur [1+(1/n)]^n
Fin du Tant que
Afficher n
Ca serais mieux comme ca tu crois ?
Je suis plus programmation donc je rajouterais une variable stop, qui correspond aux nombres de calculs que ton algo doit faire (puisqu'une suite va de 0 à infini).
lire p
lire stop
n=0
u0 = calcul avec n=0
afficher u0 et n
tant que stop>0 {
stop = stop - 1
n = n+1
un = calcul avec n
afficher un et n
}
c'est dingue cette lubie des profs a croire que l'informatique n'est fesable qu'avec des maths...
perso, ne comprenant rien a ton sujet je ne peux que te donner des infos sur la structure de ton algo:
ta ligne "Un prend la valeur [1+(1/n)]^n" ne sert strictement à rien, puisqu'au final tu affiche n (et donc n=e-p)
que signifie Un ? en programmation, on ne travail pas comme en math :) on n'affecte qu'une seule variable à la fois (donc dire U * n = 15 par exemple, c'est faux)
perso, ne comprenant rien a ton sujet je ne peux que te donner des infos sur la structure de ton algo:
ta ligne "Un prend la valeur [1+(1/n)]^n" ne sert strictement à rien, puisqu'au final tu affiche n (et donc n=e-p)
que signifie Un ? en programmation, on ne travail pas comme en math :) on n'affecte qu'une seule variable à la fois (donc dire U * n = 15 par exemple, c'est faux)
Merci à vous deux pour votre aide :)
Sara426, je ne comprends pas vraiment. Pourquoi rajouter "stop" le nombre de calcul que l'algo doit faire, étant donné qu'on ne sait justement pas combien il va devoir en faire ? A moins que je raconte n'importe quoi .. ? J'en sais plus rien là .. ^^
vordano, tu me rassures quand tu dis que tu ne comprends pas vraiment le sujet ;)
Par contre, quand tu dis "ta ligne "Un prend la valeur [1+(1/n)]^n" ne sert strictement à rien, puisqu'au final tu affiches n (et donc n=e-p) ", je ne te suis pas non plus, parce qu'il faut bien que Un prenne cette valeur, alors comment la lui donner si je ne peux pas le faire de cette manière ?
Et merci pour l'info de Un, mais ici, ce n'est pas U*n que je voulais dire, mais plutôt U(n) :)
Sara426, je ne comprends pas vraiment. Pourquoi rajouter "stop" le nombre de calcul que l'algo doit faire, étant donné qu'on ne sait justement pas combien il va devoir en faire ? A moins que je raconte n'importe quoi .. ? J'en sais plus rien là .. ^^
vordano, tu me rassures quand tu dis que tu ne comprends pas vraiment le sujet ;)
Par contre, quand tu dis "ta ligne "Un prend la valeur [1+(1/n)]^n" ne sert strictement à rien, puisqu'au final tu affiches n (et donc n=e-p) ", je ne te suis pas non plus, parce qu'il faut bien que Un prenne cette valeur, alors comment la lui donner si je ne peux pas le faire de cette manière ?
Et merci pour l'info de Un, mais ici, ce n'est pas U*n que je voulais dire, mais plutôt U(n) :)
Merci beaucoup pour ton aide ccm81 ;)
Oui, je me doute que c'est "mal nécessaire" de tout reprendre et de se poser des questions, mais j'avoue que je suis pas trop douée dans tout ce qui est programmation/algorithme, et que je crois que tu m'as permis de comprendre les bases.
Et d'accord, je prends note alors de vos remarques, à toi et à vordano, en ce qui concerne U et Un !
Je me posais quand même encore une petite question..
|Un-e| signifie "valeur absolue" ? Ou est-ce une façon d'écrire l'algo ?
Parce qu'en tant que valeur absolue, je comprends pas trop le sens du calcul, comment est-ce possible que |Un-e| soit inférieur à p, si par exemple p=0,0000001 ? Ca mettrait un temps fou à terminer le "Tant que".
Oui, je me doute que c'est "mal nécessaire" de tout reprendre et de se poser des questions, mais j'avoue que je suis pas trop douée dans tout ce qui est programmation/algorithme, et que je crois que tu m'as permis de comprendre les bases.
Et d'accord, je prends note alors de vos remarques, à toi et à vordano, en ce qui concerne U et Un !
Je me posais quand même encore une petite question..
|Un-e| signifie "valeur absolue" ? Ou est-ce une façon d'écrire l'algo ?
Parce qu'en tant que valeur absolue, je comprends pas trop le sens du calcul, comment est-ce possible que |Un-e| soit inférieur à p, si par exemple p=0,0000001 ? Ca mettrait un temps fou à terminer le "Tant que".
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
1. |Un-e| correspond bien à la valeur absolue (la distance entre Un et e)
2. on utilise la valeur absolue puisque la différence Un-e peut être aussi bien positive que négative (du moins à priori) et comme p est positif une valeur négative de Un-e arrêterait la boucle et renverrait une valeur de Un inadéquate
3. comment est-ce possible que |Un-e| soit inférieur à p, si par exemple p=0,0000001 ? Ca mettrait un temps fou à terminer le "Tant que". bonne question (qui n'a rien à voir avec la valeur absolue)
3.1. comme ta suite converge vers e, il arrivera un moment où toutes les valeurs de |Un-e| seront inférieure à p, et ceci quelque soit p positif (y compris si p=0.00000000000000000000000000000000000000000000000000000000000001)
3.2. Pour ce qui est du temps d'exécution, c'est à l'utilisateur de voir, est ce qu'il choisit une solution rapide ( p "grand" 0.1 par exemple) avec une "mauvaise" approximation de e, ou une meilleure approximation de e (p "petit" 0.0001 par exemple) avec une exécution plus coûteuse en temps (comme dans la vraie vie, c'est une question de rapport qualité/prix)
3.3 MAIS, car il y a un mais, il va y avoir un moment ou la précision sur le calcul de Un par la machine va dépasser ses capacités (de la machine), continuer alors le calcul des termes de Un n'a plus de sens, voire va conduire à des résultats aberrants, mais là, c'est un autre problème ...
RQ. j'avoue que je suis pas trop douée dans tout ce qui est programmation/algorithme
ton jugement me parait sévère au vu de ce que tu as pu tirer du post 6, et des questions pertinentes que tu te poses !!!!
bonne suite
2. on utilise la valeur absolue puisque la différence Un-e peut être aussi bien positive que négative (du moins à priori) et comme p est positif une valeur négative de Un-e arrêterait la boucle et renverrait une valeur de Un inadéquate
3. comment est-ce possible que |Un-e| soit inférieur à p, si par exemple p=0,0000001 ? Ca mettrait un temps fou à terminer le "Tant que". bonne question (qui n'a rien à voir avec la valeur absolue)
3.1. comme ta suite converge vers e, il arrivera un moment où toutes les valeurs de |Un-e| seront inférieure à p, et ceci quelque soit p positif (y compris si p=0.00000000000000000000000000000000000000000000000000000000000001)
3.2. Pour ce qui est du temps d'exécution, c'est à l'utilisateur de voir, est ce qu'il choisit une solution rapide ( p "grand" 0.1 par exemple) avec une "mauvaise" approximation de e, ou une meilleure approximation de e (p "petit" 0.0001 par exemple) avec une exécution plus coûteuse en temps (comme dans la vraie vie, c'est une question de rapport qualité/prix)
3.3 MAIS, car il y a un mais, il va y avoir un moment ou la précision sur le calcul de Un par la machine va dépasser ses capacités (de la machine), continuer alors le calcul des termes de Un n'a plus de sens, voire va conduire à des résultats aberrants, mais là, c'est un autre problème ...
RQ. j'avoue que je suis pas trop douée dans tout ce qui est programmation/algorithme
ton jugement me parait sévère au vu de ce que tu as pu tirer du post 6, et des questions pertinentes que tu te poses !!!!
bonne suite
Ah oui d'accord ..! J'ai un peu confondu les choses alors ^^
Mais c'est bon, j'ai plus de question, je dirais même que tout est clair !
Pour ta remarque, c'est gentil, tu es un des seuls à avoir espoir :p
Bon, et bien, pour une énième fois; Merci beaucoup pour tes explications et tes conseils !!
Bonne suite à toi aussi !
Mais c'est bon, j'ai plus de question, je dirais même que tout est clair !
Pour ta remarque, c'est gentil, tu es un des seuls à avoir espoir :p
Bon, et bien, pour une énième fois; Merci beaucoup pour tes explications et tes conseils !!
Bonne suite à toi aussi !
bonjour voldano
on reprend l'algorithme du post #9
on execute à la main avec tableau de suivi (des variables, tests, ..)
e = 2.718 pour simplifier
p = 0.1 valeur lue
n = 0 initialisation
Un = 0 initialisation
c'est fini
Q. où est l'erreur?
RQ. si |Un-e| est inférieur à p^au premier tour il ne peut plus y avoir d'autre tour
bonne suite
on reprend l'algorithme du post #9
lire p n prend la valeur 0 Un prend la valeur 0 e prend la valeur 2.7182818284590 Tant que |Un-e| > p n prend la valeur n+1 Un prend la valeur [1+(1/n)]^n Fin du Tant que Afficher n Afficher Un
on execute à la main avec tableau de suivi (des variables, tests, ..)
e = 2.718 pour simplifier
p = 0.1 valeur lue
n = 0 initialisation
Un = 0 initialisation
n Un |Un-e| |Un-e|>p 0 0 2.718 vrai 1 2 0.718 vrai 2 2.25 0.468 vrai 3 2.370 0.348 vrai 4 2.441 0.277 vrai . . 12 2.613 0.105 vrai 13 2.621 0.097 faux
c'est fini
Q. où est l'erreur?
RQ. si |Un-e| est inférieur à p^au premier tour il ne peut plus y avoir d'autre tour
bonne suite
il n'y a pas de division par 0, n est incrémenté avant le calcul de Un dans la boucle
une traduction en VBA sous Excel (accepter l'exécution des macros à l'ouverture du fichier) https://www.cjoint.com/?0Eer5Tn87Fw
bonne suite
une traduction en VBA sous Excel (accepter l'exécution des macros à l'ouverture du fichier) https://www.cjoint.com/?0Eer5Tn87Fw
bonne suite
Ces "quelques" points m'ont l'air bien nombreux :)
Mais c'est ok, je crois avoir compris tout ce que tu m'as dis, je vais essayer de me rectifier.
Soit n entier
Un, p et e réels
lire p
n prend la valeur 0
Un prend la valeur 0
e prend la valeur 2.7182818284590
Tant que |Un-e| > p
n prend la valeur n+1
Un prend la valeur [1+(1/n)]^n
Fin du Tant que
Afficher n
Afficher Un