Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
1 Exercices Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
2 Algorithmes simples avec Calcul de la valeur absolue d'un nombre réel ................................p. 4 Résolution de l'équation du second degré dans R .............................p. 6 Calcul des nombres de Armstrong ...............................................p. 8 Calcul de nombres parfaits ........................................................p. 10 Calcul du pgcd de 2 entiers (méthode Euclide) ................................p. 12 Calcul du pgcd de 2 entiers (méthode Egyptienne) ............................p. 14 Calcul de nombres premiers (boucles while et do...while) ........................p. 16 Calcul de nombres premiers (boucles for) .........................................p. 18 Calcul du nombre d'or ..............................................................p. 20 Conjecture de Goldbach ............................................................p. 22 Méthodes d'opérations sur 8 bits ..................................................p. 24 Chaînes palindromes 2versions
..................................................p. 28 Convertir une date numérique en lettres
......................................p. 31 Convertir un nombre écrit en chiffres romains ................................p. 33 Tri à bulles tableau d'entiers ......................................................p. 34 Tri par insertion tableau d'entiers
.............................................p. 36 Recherche linéaire dans un tableau non trié
..............................p. 39 Recherche linéaire dans un tableau déjà trié
.............................p. 43 Recherche dichotomique dans un tableau déjà trié
.......................p. 46 Dans la majorité des exemples de traduction d'algorithmes simples nous reprenons volontairement des exemples déjà traités dans un autre livre pdf, les fondements de Java, le lecteur remarquera la similarité du code C# et du code Java pour le même exercice. Lorsqu'il y a dissemblance du code C# avec le code Java, nous avons fourni des explications spécifiques au code C#. Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
3 Classes, objets et IHM avec Problème de la référence circulaire.............................................p. 49 Classe de salariés dans une entreprise fictive ................................p. 51 Classe de salariés dans un fichier de l'entreprise ............................p. 62 Construction d'un ensemble de caractères ...................................p. 70 Construction d'un ensemble générique ........................................p. 76 Construction d'une IHM de jeu de puzzle ....................................p. 84
Les exercices utilisent des classes spécifiques au langage C#, si le lecteur veut traduire ces exemples en code Java ou en code Delphi, il doit soit chercher dans les packages Java ou Delphi des classes possédant les mêmes fonctionnalités soit les construire lui-même.
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
4 Algorithme Calcul de la valeur absolue d'un nombre réel Objectif : Ecrire un programme C# servant à calculer la valeur absolue d'un nombre réel x à partir de la définition de la valeur absolue. La valeur absolue du nombre réel x est le nombre réel |x| : |x| = x , si x ≥ 0
|x| = -x si x <- 0 Spécifications de l’algorithme :
lire( x );
si x ≥ 0 alors écrire( '|x| =', x)
sinon écrire( '|x| =', -x)
fsi Implantation en C#
Ecrivez avec les deux instructions différentes "if...else.." et "...?.. : ...", le programme C# complet correspondant à l'affichage ci-dessous : Entrez un nombre x = -45
|x| = 45 Proposition de squelette de classe C# à implanter :
class ApplicationValAbsolue {
static void Main(string[ ] args) {
........} } La méthode Main calcule et affiche la valeur absolue.
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
5 Classe C# solution Une classe C# solution du problème avec un if...else : using System; namespace CsExosAlgo1 { class ApplicationValAbsolue1 {
static void Main(string[ ] args) {
double x;
System.Console.Write("Entrez un nombre x = ");
x = Double.Parse( System.Console.ReadLine( ) ) ;
if (x< ) System.Console.WriteLine("|x| = "+(-x));
else System.Console.WriteLine("|x| = "+x);
} } } Explication sur l'instruction :
x = Double.Parse ( System.Console.ReadLine( ) ) ; Le gestionnaire d'entrée sortie C# à partir de la classe Console renvoie à travers la méthode ReadLine() une valeur saisie au clavier de type string. Il est donc obligatoire si l'on veut récuperer un nombre réel au clavier (ici double x;) de transtyper le réel tapé correctement sous forme de chaîne au clavier, et de le convertir en un réel de type double ici, grâce à la méthode Parse de la classe enveloppe Double du type double. Remarquons que cette version simple ne protège pas des erreurs de saisie. Pour être plus robuste le programme devrait intercepter l'exception levée par une éventuelle erreur de saisie signalée par une exception du type FormatException : try {
x = Double.Parse( System.Console.ReadLine( ) ) ; } catch ( FormatException ) { //...traitement de l'erreur de saisie } Une classe C# solution du problème avec un "... ? ... : ..." : using System; namespace CsExosAlgo1 { class ApplicationValAbsolue2 { static void Main(string[ ] args) {
double x;
System.Console.Write("Entrez un nombre x = ");
x = Double.Parse( System.Console.ReadLine( ) ) ;
System.Console.WriteLine("|x| = "+ (x <- 0 ? -x : x) );
} } } Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
6 Algorithme Algorithme de résolution de l'équation du second degré dans R. Objectif : On souhaite écrire un programme C# de résolution dans R de l'équation du second degré : Ax
2 + Bx +C = 0 Il s'agit ici d'un algorithme très classique provenant du cours de mathématique des classes du secondaire. L'exercice consiste essentiellement en la traduction immédiate Spécifications de l’algorithme :
Algorithme Equation
Entrée: A, B, C ∈ Réels
Sortie: X1 , X2 ∈ Réels
Local: Δ ∈ Réels début
lire(A, B, C);
Si A=0 alors début{A=0}
Si B = 0 alors
Si C = 0 alors
écrire(R est solution)
Sinon{C ≠ 0}
écrire(pas de solution)Fsi Sinon {B ≠ 0}
X1 ← C/B;
écrire (X1)Fsi fin
Sinon {A ≠ 0}début Δ ← B
2 - 4*A*C ;
Si Δ <- 0 alors
écrire(pas de solution)
Sinon {Δ ≥ 0}
Si Δ = 0 alors
X1 ← -B/(2*A);
écrire (X1)
Sinon{Δ ≠ 0}
X1 ← (-B +√Δ )/(2*A);
X2 ← (-B - √Δ)/(2*A);
écrire(X1 , X2 )Fsi Fsifin Fsi FinEquation
Implantation en C#
Ecrivez le programme C# qui est la traduction immédiate de cet algorithme dans le corps de la méthode Main. Proposition de squelette de classe C# à implanter : class ApplicationEqua2 {
static void Main(string[ ] args) {
........} } Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
7 Conseil : On utilisera la méthode static Sqrt(double x) de la classe Math pour calculer la racine carrée d'un nombre réel : √Δ se traduira alors par : Math.Sqrt(delta) Classe C# solution using System; namespace CsExosAlgo1 { class ApplicationEqua2 {
static void Main (string[ ] arg) {
double a, b, c, delta ;
double x, x1, x2 ;
System.Console.Write("Entrer une valeur pour a : ") ;
a = Double.Parse( System.Console.ReadLine( ) ) ;
System.Console.Write("Entrer une valeur pour b : ") ;
b = Double.Parse( System.Console.ReadLine( ) ) ;
System.Console.Write("Entrer une valeur pour c : ") ;
c = Double.Parse( System.Console.ReadLine( ) ) ;
if (a ==0) {
if (b ==0) {
if (c ==0) {
System.Console.WriteLine("tout reel est solution") ;} else {// c ≠ 0
System.Console.WriteLine("il n'y a pas de solution") ;} }
else { // b ≠ 0
x = -c/b ;
System.Console.WriteLine("la solution est " + x) ;} }
else { // a ≠ 0
delta = b*b - 4*a*c ;
if (delta <- 0){ System.Console.WriteLine("il n'y a pas de solution dans les reels") ;} else { // delta ≥ 0
x1 = (-b + Math.Sqrt(delta))/ (2*a) ;
x2 = (-b - Math.Sqrt(delta))/ (2*a) ;
System.Console.WriteLine("il y deux solutions egales a " + x1 + " et " + x2) ;} }
} } } Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
8 Algorithme Calcul des nombres de Armstrong Objectif : On dénomme nombre de Armstrong un entier naturel qui est égal à la somme des cubes des chiffres qui le composent.
Exemple : 153 = 1 + 125 + 27, est un nombre de Armstrong. Spécifications de l’algorithme : On sait qu'il n'existe que 4 nombres de Armstrong, et qu'ils ont tous 3 chiffres (ils sont compris entre 100 et 500). Si l'on suppose qu'un tel nombre est écrit ijk (i chiffre des centaines, j chiffres des dizaines et k chiffres des unités), il suffit simplement d'envisager tous les nombres possibles en faisant varier les chiffres entre 0 et 9 et de tester si le nombre est de Armstrong. Implantation en C#
Ecrivez le programme C# complet qui fournisse les 4 nombres de Armstrong : Nombres de Armstrong:153 370371 407 Proposition de squelette de classe C# à implanter : class ApplicationArmstrong {
static void Main(string[ ] args) {
........} } La méthode Main calcule et affiche les nombres de Armstrong. Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
9 Squelette plus détaillé de la classe C# à implanter : using System; namespace CsExosAlgo1 { class ApplicationArmstrong { static void Main(string[ ] args) {
int i, j, k, n, somcube;
System.Console.WriteLine("Nombres de Armstrong:");
for(i = 1; i<=9; i++)
for(j = 0; j<=9; j++)
for(k = 0; k<=9; k++){ ......} } } } Classe C# solution using System; namespace CsExosAlgo1 {
class ApplicationArmstrong {
static void Main(string[ ] args) {
int i, j, k, n, somcube;
System.Console.WriteLine("Nombres de Armstrong:");
for(i = 1; i<=9; i++)
for(j = 0; j<=9; j++)
for(k = 0; k<=9; k++){ n = 100*i + 10*j + k;
somcube = i*i*i + j*j*j + k*k*k;
if (somcube == n)
System.Console.WriteLine(n);} }
} } Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
10 Algorithme Calcul de nombres parfaits Objectif : On souhaite écrire un programme C# de calcul des n premiers nombres parfaits. Un nombre est dit parfait s’il est égal à la somme de ses diviseurs, 1 compris.
Exemple : 6 = 1+2+3 , est un nombre parfait. Spécifications de l’algorithme : l'algorithme retenu contiendra deux boucles imbriquées. Une boucle de comptage des nombres parfaits qui s'arrêtera lorsque le décompte sera atteint, la boucle interne ayant vocation à calculer tous les diviseurs du nombre examiné d'en faire la somme puis de tester l'égalité entre cette somme et le nombre. Algorithme Parfait
Entrée: n ∈ N
Sortie: nbr ∈ N
Local: somdiv, k, compt ∈ N début
lire(n);
compt ← 0;
nbr ←2;
Tantque(compt <- n) Faire
somdiv ← 1;
Pour k ← 2 jusquà nbr-1 Faire
Si reste(nbr par k) = 0 Alors // k divise nbr
somdiv ← somdiv + kFsi Fpour ;
Si somdiv = nbr Alors
ecrire(nbr) ;
compt ← compt+1;Fsi; nbr ← nbr+1
Ftant FinParfait Implantation en C#
Ecrivez le programme C# complet qui produise le dialogue suivant à l’écran (les caractères gras représentent ce qui est écrit par le programme, les italiques ce qui est entré au clavier) :
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
11 Entrez combien de nombre parfaits : 4
6 est un nombre parfait
28 est un nombre parfait
496 est un nombre parfait
8128 est un nombre parfait Proposition de squelette de classe C# à implanter : class ApplicationParfaits {
static void Main(string[ ] args) {
........} } La méthode Main calcule et affiche les nombres parfaits. Classe C# solution using System; namespace CsExosAlgo1 {
class ApplicationParfaits {
static void Main (string[ ] args) {
int compt = 0, n, k, somdiv, nbr;
System.Console.Write("Entrez combien de nombre parfaits : ");
n = Int32.Parse( System.Console.ReadLine( ) ) ;
nbr = 2;
while (compt != n)
{ somdiv = 1;
k = 2;
while(k <= nbr/2 ){ if (nbr % k == 0) somdiv += k ;k++; }
if (somdiv == nbr)
{ System.Console.WriteLine(nbr+" est un nombre parfait");
compt++;} nbr++;} }
} } La saisie de l'entier int n; s'effectue par transtypage grâce à la méthode Parse de la classe Net Framework Int32 du type int. Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
12 Algorithme Calcul du pgcd de 2 entiers (méthode Euclide) Objectif : On souhaite écrire un programme de calcul du pgcd de deux entiers non nuls, en C# à partir de l’algorithme de la méthode d'Euclide. Voici une spécification de l'algorithme de calcul du PGCD de deux nombres (entiers strictement positifs) a et b, selon cette méthode :
Spécifications de l’algorithme : Algorithme Pgcd
Entrée: a,b ∈ N* x N*
Sortie: pgcd ∈ N
Local: r,t ∈ N x Ndébut lire(a,b);
Si ba Alors
t ← a ;
a ← b ;
b ← tFsi; Répéter
r ← a mod b ;
a ← b ;
b ← r
jusquà r = 0;
pgcd ← a;
ecrire(pgcd) FinPgcd Implantation en C#
Ecrivez le programme C# complet qui produise le dialogue suivant à la console (les caractères gras représentent ce qui est écrit par le programme, les italiques ce qui est entré au clavier) : Entrez le premier nombre : 21 Entrez le deuxième nombre : 45 Le PGCD de 21 et 45 est : 3
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
13 Proposition de squelette de classe C# à implanter : class ApplicationEuclide {
static void Main(string[ ] args) {
........} static int pgcd (int a, int b) {
........} } La méthode pgcd renvoie le pgcd des deux entiers p et q . Classe C# solution using System; namespace CsExosAlgo1 { class ApplicationEuclide {
static void Main (string[ ] args) {
System.Console.Write("Entrez le premier nombre : ");
int p = Int32.Parse( System.Console.ReadLine( ) ) ;
System.Console.Write("Entrez le deuxième nombre : ");
int q = Int32.Parse( System.Console.ReadLine( ) ) ;
if (p*q!=0)
System.Console.WriteLine("Le pgcd de "+p+" et de "+q+" est "+pgcd(p,q));else System.Console.WriteLine("Le pgcd n'existe pas lorsque l'un des deux nombres est nul !");
} static int pgcd (int a , int b) {
int r,t ;
if ( b>a) {
t = a;
a = b;
b = t;} do {
r = a % b;
a = b;
b = r;
} while(r !=0);
return a ;} } } Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
14 Algorithme Calcul du pgcd de 2 entiers (méthode Egyptienne) Objectif : On souhaite écrire un programme de calcul du pgcd de deux entiers non nuls, en C# à partir de l’algorithme de la méthode dite "égyptienne " Voici une spécification de l'algorithme de calcul du PGCD de deux nombres (entiers strictement positifs) p et q, selon cette méthode :
Spécifications de l’algorithme :
Lire (p, q ) ;
Tantque p ≠ q faire
Si p > q alors
p ← p – qsinon q ← q – p
FinSi FinTant; Ecrire( " PGCD = " , p ) Implantation en C#
Ecrivez le programme C# complet qui produise le dialogue suivant à la console (les caractères gras représentent ce qui est écrit par le programme, les italiques ce qui est entré au clavier) : Entrez le premier nombre : 21 Entrez le deuxième nombre : 45 Le PGCD de 21 et 45 est : 3 Proposition de squelette de classe C# à implanter : class ApplicationEgyptien {
static void Main(String[ ] args) {
........} static int pgcd (int p, int q) {
........} } La méthode pgcd renvoie le pgcd des deux entiers p et q . Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
15 Classe C# solution using System; namespace CsExosAlgo1 { class ApplicationEgyptien {
static void Main (string[ ] args) {
System.Console.Write("Entrez le premier nombre : ");
int p = Int32.Parse( System.Console.ReadLine( ) ) ;
System.Console.Write("Entrez le deuxième nombre : ");
int q = Int32.Parse( System.Console.ReadLine( ) ) ;
if ( p*q != 0 )
System.Console.WriteLine("Le pgcd de "+p+" et de "+q+" est "+pgcd(p,q));else System.Console.WriteLine("Le pgcd n'existe pas lorsque l'un des deux nombres est nul !");} static int pgcd (int p, int q) {
while ( p != q){ if (p > q) p -= q;
else q -= p;} return p;
} } } Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
16 Algorithme Calcul de nombres premiers (boucles while et do...while) Objectif : On souhaite écrire un programme C# de calcul et d'affichage des n premiers nombres premiers. Un nombre entier est premier s’il n’est divisible que par 1 et par lui-même On opérera une implantation avec des boucles while et do...while.
Exemple : 31 est un nombre premier
Spécifications de l’algorithme : Algorithme Premier
Entrée: n ∈ N
Sortie: nbr ∈ N
Local: Est_premier ∈ {Vrai , Faux}
divis,compt ∈N2 ; début
lire(n);
compt ← 1;
ecrire(2);
nbr ← 3;
Tantque(compt <- n) Faire
divis ← 3;
Est_premier ← Vrai;Répéter Si reste(nbr par divis) = 0 Alors
Est_premier ← FauxSinon divis ← divis+2Fsi jusquà (divis > nbr / 2)ou (Est_premier=Faux);
Si Est_premier =Vrai Alors
ecrire(nbr);
compt ← compt+1Fsi; nbr ← nbr+1Ftant FinPremier
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
17 Implantation en C# Ecrivez le programme C# complet qui produise le dialogue suivant à la console (les caractères gras représentent ce qui est écrit par le programme, les italiques ce qui est entré au clavier) : Combien de nombres premiers : 52 35 7
11 Classe C# solution Avec une boucle while et une boucle do...while imbriquée : On étudie la primalité de tous les nombres systématiquement using System;
namespace CsExosAlgo1 {
class ApplicationComptPremiers1 {
static void Main(string[ ] args) {
int divis, nbr, n, compt = 0 ;
bool Est_premier;
System.Console.Write("Combien de nombres premiers : ");
n = Int32.Parse( System.Console.ReadLine( ) ) ;
System.Console.WriteLine( 2 );
nbr = 3;
while (compt <- n-1){ divis = 2 ;
Est_premier = true;do {
if (nbr % divis == 0) Est_premier=false;
else divis = divis+1 ;} while ((divis <= nbr/2) && (Est_premier == true));
if (Est_premier){ compt++;
System.Console.WriteLine( nbr );} nbr++ ;} }
} } La méthode Main affiche la liste des nombres premiers demandés.
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
18 Algorithme Calcul de nombres premiers (boucles for) Objectif : On souhaite écrire un programme C# de calcul et d'affichage des n premiers nombres premiers. Un nombre entier est premier s’il n’est divisible que par 1 et par lui-même. On opérera une implantation avec des boucles for imbriquées.
Exemple : 23 est un nombre premier Spécifications de l’algorithme : (on étudie la primalité des nombres uniquement impairs) Algorithme Premier
Entrée: n ∈ N
Sortie: nbr ∈ N
Local: Est_premier ∈ {Vrai , Faux}
divis,compt ∈N2 ; début
lire(n);
compt ← 1;
ecrire(2);
nbr ← 3;
Tantque(compt <- n) Faire
divis ← 3;
Est_premier ← Vrai;Répéter Si reste(nbr par divis) = 0 Alors
Est_premier ← FauxSinon divis ← divis+2Fsi jusquà (divis > nbr / 2)ou (Est_premier=Faux);
Si Est_premier =Vrai Alors
ecrire(nbr);
compt ← compt+1Fsi; nbr ← nbr+2 // nbr impairs Ftant
FinPremier Implantation en C#
Ecrivez le programme C# complet qui produise le dialogue suivant à la console (les caractères gras représentent ce qui est écrit par le programme, les italiques ce qui est entré au clavier) :
Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
19 Combien de nombres premiers : 52 35 7
11 Classe C# solution Avec deux boucles for imbriquées : On étudie la primalité des nombres uniquement impairs
using System;
namespace CsExosAlgo1 {
class ApplicationComptPremiers2 {
static void Main(string[ ] args) {
int divis, nbr, n, compt = 0 ;
bool Est_premier;
System.Console.Write("Combien de nombres premiers : ");
n = Int32.Parse( System.Console.ReadLine( ) ) ;
System.Console.WriteLine( 2 );
//-- primalité uniquement des nombres impairs
for( nbr = 3; compt <- n-1; nbr += 2 )
{ Est_premier = true;
for (divis = 2; divis<= nbr/2; divis++ )
if ( nbr % divis == 0 )
{ Est_premier = false;break; }
if (Est_premier){ compt++;
System.Console.WriteLine( nbr );} }} } } La méthode Main affiche la liste des nombres premiers demandés. Le fait de n'étudier la primalité que des nombres impairs accélère la vitesse d'exécution du programme, il est possible d'améliorer encore cette vitesse en ne cherchant que les diviseurs dont le carré est inférieur au nombre ( test : jusquà (divis
2 > nbr )ou (Est_premier=Faux) ). Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
20 Algorithme Calcul du nombre d'or Objectif : On souhaite écrire un programme C# qui calcule le nombre d'or utilisé par les anciens comme nombre idéal pour la sculpture et l'architecture. Si l'on considère deux suites numériques (U) et (V) telles que pour n strictement supérieur à 2 :
et On montre que la suite (V) tend vers une limite appelée nombre d'or (nbr d'Or = 1,61803398874989484820458683436564).
Spécifications de l’algorithme :n,U n ,U
n1 ,U
n2 : sont des entiers naturels V
n ,V
n1 , ε : sont des nombres réels lire( ε ); // précision demandéeU n2 ← 1;U n1 ← 2;V n1 ← 2;
n ←2; // rang du terme courant Itération
n ← n + 1;U n ←U
n1 + U
n2 ;V n ← U
n / U
n1 ;
si |V
n - Vn1 | ≤ ε alors Arrêt de la boucle ; // la précision est atteintesinon U
n2 ← U
n1 ;U n1 ← U
n ;V n1 ← V
n ;
fsi fin Itération ecrire (V
n , n); Ecrire un programme fondé sur la spécification précédente de l'algorithme du calcul du nombre d'or. Ce programme donnera une valeur approchée avec une précision fixée de ε du nombre d'or. Le programme indiquera en outre le rang du dernier terme de la suite correspondant. Programmer objet .Net avec C# - ( rév. 17.10.2007 )
EXERCICES
page exos -
21 Implantation en C#
On entre au clavier un nombre réel ci-dessous 0,00001, pour la précision choisie (ici 5 chiffres après la virgule), puis le programme calcule et affiche le Nombre d'or (les caractères gras représentent ce qui est écrit par le programme, les italiques ce qui est entré au clavier) : Précision du calcul ? : 0,00001 Nombre d'Or = 1.6180328 // rang=14 Classe C# solution Avec un boucle for :
using System;
namespace CsExosAlgo1 {
class AppliNombredOr {
static void Main(string[ ] args) {
int n, Un, Un1=2, Un2=1 ;
double Vn,Vn1=2, Eps ;
System.Console.Write("Précision du calcul ? : ");
//-- précision demandée (exemple 1e-4 ou 1e-2 ou 0,0001, ...) :
Eps = Double.Parse( System.Console.ReadLine( ) ) ;
for (n=2; ; n++) //n est le rang du terme courant{ Un = Un1 + Un2;
Vn =(double)Un / (double