bonjour

tu peux écrire ton algorithme en français. l'éssentiel est que tu aies compris.

Il s'agit surement du rapport (F(i+1)/F(i))  car diviser par F(1)=1 n'a aucun intérêt.

Fonction(N;R)    ; ici RN=rapport de rang N
début
N entier;
I entier;
F0 réel;
F1 réel;
F2 réel;
R array[50] réel;
lire N;
initialisation;
F0:=1
F1:=1
R[1]:=(F1)/F0;
faire de I=3 à 50;
F2:=F1 + F0;
F0:=F1;
F1:=F2;
I:=I+1.
R[I]:=(F1/F0);
fin faire
Faire de I=1 à 50
afficher R[I];
fin faire;
fin

Merci beaucoup mais, je n'arrive pas à le "traduire en langage" algorithmique, afin de l'utiliser sur Algobox, pourait-tu m'expliquer s'il te plait ?

Bonjour Dimitri,

Pour écrire un algorithme, il faut analyser le problème:
une variable devra représenter le numéro de l'itération i (varie de 0 à 50): un nombre.

Une variable pour représenter le 1er terme de la suite de Fibonacci :A (un nombre)
Une variable pour représenter le 2è terme  de la suite de Fibonacci :B (un nombre)
Une variable pour représenter le 3è terme de la suite de Fibonacci  :C (un nombre)
(qui est la somme de A et de B)
Une variable pour représenter le quotient de B par C (un nombre que l'on devra afficher).


fibo  -  20.04.2012

******************************************
A représente Fi
B représente Fi+1
C représente Fi+2
******************************************

1   VARIABLES
2     i EST_DU_TYPE NOMBRE
3     A EST_DU_TYPE NOMBRE
4     B EST_DU_TYPE NOMBRE
5     C EST_DU_TYPE NOMBRE
6     Q EST_DU_TYPE NOMBRE
7   DEBUT_ALGORITHME
8     A PREND_LA_VALEUR 1
9     B PREND_LA_VALEUR 1
10    POUR i ALLANT_DE 0 A 50
11      DEBUT_POUR
12      Q PREND_LA_VALEUR B/A
13      AFFICHER Q
14      C PREND_LA_VALEUR A+B
15      A PREND_LA_VALEUR B
16      B PREND_LA_VALEUR C
17      FIN_POUR
18  FIN_ALGORITHME



@+

Bonjour Caylus,
Peut être que tu te complique un petit peu la vie avec toutes ces variable car tu peux t'épargner les diverses opérations telles que "c prend la valeur a+b etc " en utilisant tout simplement une variable par exemple F du type LISTE ... C'est comme ca que je le vois..

Bonjour Mangakid,

Poste ton programme que l'on compare.

ok j'y travail dans la soirée >

Je suis d'accord avec Mangakid une variables du type liste faciliterait surement les choses, mais ce que tu as fait m'aide beaucoup à comprendre.
Merci beaucoup pour ton aide Caylus.

j'ai trouvé la solution a ton problème mek
désolé pr caylus :p

VARIABLES
  F EST_DU_TYPE LISTE
  i EST_DU_TYPE NOMBRE
  n EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  POUR n ALLANT_DE 0 A 100
    DEBUT_POUR
    F[0] PREND_LA_VALEUR 1
    F[1] PREND_LA_VALEUR 1
    F[n+2] PREND_LA_VALEUR F[n+1]+F[n]
    F[i] PREND_LA_VALEUR F[n+2]/F[n+1]
    AFFICHER "F"
    AFFICHER n
    AFFICHER "="
    AFFICHER* F[i]
    FIN_POUR
FIN_ALGORITHME


Et soit honnête avec ton prof de maths, dis lui que Dieu t'as aidé
Peace  

Bonjour Mangakid,

En temps que bon belge, je vous invite à boire une bonne ADA (abbaye d'Aulne) que l'on trouve en vente
ici

Pourquoi une boucle jusque 100?
Que vaut une variable en AlgoBox qui n'a pas été initialisée (i) ?
Pourquoi utiliser 101 composantes d'une variable LISTE alors que l'on ne demande pas de les stocker? (cela revient à utiliser 101 variables NOMBRE!)
Pourquoi placer la valeur 1 dans F[0] et F[1] 101 fois?
@+

Pourquoi ? Parceque même dieu semble avoir un supérieur et tout ce que j'ai fais en va de la volontée du prof de math de notre cher dimitri qui est également le mien

Nan pour parler sérieusement le professeur veut que l'on affiche chacun des résultats de chacun des termes pour n allant de 0 a 100.
je crois que ca répond a ta question de la boucle jusqu'a 100 et le pb de "stockage" des variables et donc l'utilisation d'une variable LISTE.
On place la valeur 1 dans F(0) et dans F(1) car selon la suite de fibonacci il serait impossible de calculer quelque termes que ce soit si on ne comprend pas cela. heu.. c'est pas très clair je reformule peut etre:
Suite de fibonacci : F(n+2)= F(n+1) + F(n)
Maintenant comment veux tu calculer F(n+2) pr (n+2)=0 si on a pas deja F(0) ?
( je rappel que le premier terme d'une suite en classe de 1ère ou term S est au minimum 0 )
Donc comme dirait mon prof "celui qui cherche peut se lever très très tôt" ... je kiffe ce mek
D'après ce raisonnement tu comprend également qu'il nous faut F(1).
Par contre peux tu répéter ta deuxième question dans une autre langue ou en francais ?

Sauf que Mangakid la Caylus à raison, tu peu placer 1 dans F[1] avant ta boucle, bien que cela ne change rien ce n'est pas très utile de le faire dans la boucle.
Et je te rappelle que F[0] prend la valeur 0, du moins c'est ce que j'ais noté.

en fait pardon tu peux meme pas calculer F(0) enfin je veux dire le veritable F(0) pour lequel (n+2)=0 pke il y a pas de termes avant 0.
Donc tu remarque que dans l'execution de cette suit (si tu prend uniquement la suite de fibonacci) le F(0) apparaissant comme égale a 2 est en réalité F(2) impliquant que F(0)=1 et F(1)=1
Capito ?

t'as mal noté man regarde ton livre

mais on s'en fou de les placer avant ou après me pète pas un cable pour ca

Oui, mais c'était juste pour dire que Caylus avait raison, les mettres dedans n'as aucun intérêt et fait faire des opérations en plus à l'algo