Algorithme

Bonjour !

Je voulais savoir si vous pouviez m'aider un peu avec mon Algorithme ; voici le sujet :

On définit les deux suites (u_n) et (v_n) par u₀=2 et v₀=10 et les relations :

u_n+1 = (3u_n+v_n)/4 et v_n+1 = (u_n +3v_n)/4

Ecrire un algorithme permettant de calculer et d'afficher les 15 premiers termes de chaque suite.

Alors pour cela, j'ai commencé mon algorithme :

J'ai d'abord afficher u₀ et v₀ (puisqu'il faut afficher chacun des 15 termes de chaque suite)

Puis j'ai enchaîné avec une boucle "Tant que" en fesant bien attention à ce que n prenne la valeur n+1 à chaque tour de boucle.

Par contre, je me trouve coincé quand je met la valeur de u_n et de v_n car la suite qui sera définie en deuxième prendra la nouvelle valeur de la première suite et donc non la bonne valeur (Je ne sais pas si j'arrive vraiment à faire comprendre mon problème)

Si quelqu'un peut m'aider !

Merciii

Déclaration des variables:

n entier

u réel

v réel

Début

Initialisation:

u=2

v=10

Pour n=1 à 14

u=(3u+v)/4

v=(u +3v)/4

Afficher "au rang" n "u vaut" Afficher u

Afficher "au rang" n "v vaut" Afficher v

n=n+1

Fin

Ca doit etre ça et si c'est pas ça, t'as matière à réfléchir

Salut,

Je ne suis pas sur de bien cerner ton problème. Il faut faire une boucle en effet. et calculer simultanément U_n+1 et V_n+1.

Une solution pour le faire aisément, est de stocker les valeurs de U_n et de V_n dans une variable temporaire. Tu as donc 4 variables U_n, U_n+1, V_n et V_n+1, dans lesquelles tu stockes les valeurs dont tu as besoin pour calculer ta suite.

Ce n'est pas optimisé pour la mémoire, on peut travailler avec une seule variable temporaire, mais à mon avis, c'est plus facile à comprendre de cette façon là.

Cordialement, Arahan.

u=(3u+v)/4 // U_n+1=(3U_n+V_n)/4

v=(u +3v)/4 // V_n+1 =(U_n+1 +3 V_n) /4

Salut,

Cet algorythme ne marchera pas, puisque tu incrémentes le u, et réutilises le u incrémenté pour calculer le v, alors qu'il te faut le u précédent. J'ai détaillé le calcul en copiant ce que tu as écrit. C'est la raison pour laquelle il faut stocker les valeurs U_net V_n dans une variable temporaire.

Cdt, Arahan.

Salut,

Pourquoi faire une boucle "tant que" ? Ça marche mais ce n'est pas nécessaire étant donné que tu sais à l'avance combien de fois tu dois faire tourner la boucle.

Tu peux créer deux vecteurs dans lesquels tu stockes les valeurs des deux suites : tu stockes u₀ et v₀, tu commences la boucle en calculant u₁ et v₁ en faisant appel à u₀ et v₀ que tu as stockés, tu stockes u₁ et v₁, et ainsi de suite. Ensuite, tu affiches les deux vecteurs.

Sinon, tu peux ne stocker que le dernier terme calculé pour chacune des suites : au i-ème tour de boucle, tu poses par exemple a = u et b = v avec u et v respectivement les (i-1)-èmes termes des suites (u_n) et (v_n), tu recalcules u et v, mais pour le i-ème terme cette fois, à l'aide de a et b, puis tu affiches u et v.

salut Arahan,

ok tu as raison

ptet que comme ça c mieux?

le problème avec les indices, c'est qu'en programmation faut déclarer la variable sous forme de tableau, alors j'ai utilisé les variables temporaires que tu conseilles mais en les appelant a et b pour n'utiliser que des réels

Déclaration des variables:

n entier

u réel

v réel

a réel

b réel

Début

Initialisation:

u=2

v=10

Pour n=0 à 14

a=(3u+v)/4

b=(u +3v)/4

n=n+1

u=a

v=b

afficher n afficher u

afficher n afficher v

Fin

salut konvicted,

heureusement que vous êtes là :D

Oui j'ai fais comme ça mais ce que je ne comprend pas, c'est que cela ne me donne pas des valeurs rondes, mais des valeurs approchées. Alors quand on calcul les premiers termes à la main, ce sont des chiffres ronds.

Merci en tout cas !

Tu as des valeurs approchées à partir de quel terme ?

Tu as peut-être une erreur dans ton algorithme ; est-ce que tu peux nous le montrer ?

En python tu pourrait te passer de variable temporaire en utilisant un tuple. Les valeurs du tuple étant calculées et affectées en simultanée: (en fait, l'interpréteur utilise des variables que tu ne voit pas)

u,v = 2,10 
for i in range(15):
   print ("u%d=%f; v%d=%f"%(i,u,i,v))
   u,v = (3*u+v)/4,(u+3*v)/4

dans les autres langages que je connais il faut passer par 2 variables temporaires, mais certainement pas besoin de tableaux tant qu'on ne te demande pas de conserver les valeurs intermédiaires. Le dernier code proposé par pere_vert est alors bon.

Dans tous les cas, inverser l'ordre de l'affichage et du calcul des valeurs au rang suivant dans la boucle permettrait d'éviter de calculer le 16ème terme pour rien (lors de la dernière itération), mais nécessiterait de rajouter une ligne avant le for pour afficher les valeurs de U0 et V0. (ce qui n'est pas fait par le code de pere_vert).

le résultat est :

u0=2.000000; v0=10.000000
u1=4.000000; v1=8.000000
u2=5.000000; v2=7.000000
u3=5.500000; v3=6.500000
u4=5.750000; v4=6.250000
u5=5.875000; v5=6.125000
u6=5.937500; v6=6.062500
u7=5.968750; v7=6.031250
u8=5.984375; v8=6.015625
u9=5.992188; v9=6.007812
u10=5.996094; v10=6.003906
u11=5.998047; v11=6.001953
u12=5.999023; v12=6.000977
u13=5.999512; v13=6.000488
u14=5.999756; v14=6.000244

Comme tu peut le voir, les résultats ne sont plus des entiers à partir du rang 3.

Enfin, que ce soit un UNTIL, un WHILE ou un FOR, c'est strictement équivalent pour l'usage qui en est fait ici, c'est une boucle. Le choix du type de boucle n'est que du sucre pour le programmeur.

Mon Algo ne doit pas être bon puisque j'ai 8.5 pour v₁ alors que je devrais avoir 8.

Quand je rentre l'équation de v_n dans ma boucle, je pense qu'elle doit prendre dans son équation la nouvelle valeur de u_n dont j'ai rentré l'équation juste au dessus. Ce qui me décale tous mes résultats.

(Je ne sais pas si mon explication est bien clair, je n'arrive pas à exprimer mon idée)

Merci en tout cas !