Algorithme Fermé

Question

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 ? 


Configuration: Windows 7 / Firefox 12.0

Sara426 · Answer

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 ?

ccm81 · Answer

bonjour à tous, bonjour Lolly  

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

ccm81 · Answer

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

Lolly · Answer

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".

ccm81 · Answer

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

Lolly · Answer

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 !

ccm81 · Answer

bonjour voldano 

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

ccm81 · Answer

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

Algorithme

8 réponses

Discussions similaires