Orléans informatique : exercices algorithmes BTS CG / DCG

Sommaire

Introduction Comment utiliser ces entraînements ?

Objectif

L'objectif des exercices ci-après est de couvrir au maximum tous les concepts de programmation aux programmes du BTS CG/CGO et du DCG.

De ce fait, il s'agit certes de proposer des exercices simples et autres cas d'école. Néanmoins, il s'agit également de proposer des exercices tout à la fois un peu plus compliqués et plus intéressants de par ce qu'ils sont quelque peu plus réalistes au regard du métier comptable et/ou des problématiques professionnelles.

En conséquence, il ne s'agit pas de réaliser tous les exercices :

Piochez et effectuez un, deux voire trois exercices d'affilée.
Vérifiez que votre algorithme fonctionne et/ou prenez le temps de comprendre la correction.
Revenez sur les exercices réalisés ultérieurement ou piochez-en quelques nouveaux.
Si vous êtes à l'aise, attardez-vous éventuellement sur les exercices plus compliqués.

Prérequis

Afin de réaliser les exercices, je vous conseille vivement, au moins tant que les concepts et/ou la syntaxe n'est pas retenue, d'ouvrir le cours d'algorithmique dans un autre onglet :

Cours d'algorithmique : théorie et exemples d'algorithmes pour découvrir les bases de l'algorithmique et de la programmation.

Pensez-y ! Pour naviguer plus facilement sur cette page, pensez à utiliser le sommaire en cliquant sur l'icône "sommaire" en haut à gauche de l'écran.

Pensez-y ! Si vous avez un oubli quant à la syntaxe (javascript), pensez à cliquer sur l'icône "aide" en à gauche de l'écran pour ouvrir le cours sur les algorithmes.

Exercices sur les variables Variables et opérations sur les variables

Récupération et affichage d'un prénom

On souhaite rédiger l'algorithme "Bonjour" qui :

Demande à l'utilisateur son prénom.
Souhaite bonjour à l'utilisateur : "Bonjour [prénom] !".


		// ALGORITHME Bonjour
		// Récupère le prénom de l'utilisateur
		var prenom = read("Saisissez votre prénom :");
		// Souhaite bonjour à l'utilisateur
		writeLine("Bonjour " + prenom + " !");
		// FIN ALGORITHME Bonjour


		// ALGORITHME Bonjour
		// Récupération du prénom de l'utilisateur
		prenom : chaîne := lire("Saisissez votre prénom :")
		// Souhaite bonjour à l'utilisateur
		ecrire("Bonjour " & prenom & " !")
		// FIN ALGORITHME Bonjour

Calcul d'un montant TTC

On souhaite rédiger l'algorithme "Ttc" qui :

Demande à l'utilisateur de saisir un montant HT.
Calcule le montant TTC associé.
Affiche le montant HT saisi et celui TTC calculé.

La TVA est supposée être au taux de 20%.


		// ALGORITHME Ttc
		// Récupération du montant HT
		var montantHt = readNumber("Saisissez un montant HT :");
		writeLine("Montant HT : " + montantHt);
		// Calcul puis affichage du montant TTC
		var montantTtc = montantHt * 1.2;
		writeLine("Montant TTC : " + montantTtc);
		// FIN ALGORITHME Ttc


		// ALGORITHME Ttc
		// Récupération du montant HT
		montantHt : réel := lire("Saisissez un montant HT :")
		ecrire("Montant HT : " & montantHt)
		// Calcul puis affichage du montant TTC
		montantTtc : réel := montantHt x 1.2
		ecrire("Montant TTC : " & montantTtc)
		// FIN ALGORITHME Ttc

Calcul d'un montant HT

On souhaite rédiger l'algorithme "Ht" qui :

Demande à l'utilisateur de saisir un montant TTC.
Calcule la TVA et le montant HT associés.
Affiche le montant HT, la TVA puis le montant TTC.

La TVA est supposée être au taux de 20%.


		// ALGORITHME Ht
		// Récupération du montant TTC
		var montantTtc = readNumber("Saisissez un montant TTC :");
		// Calcul du montant HT et de la TVA
		var montantHt = montantTtc / 1.2;
		var montantTva = montantHt * 0.2;
		// Affichage des montants
		writeLine("Montant HT : " + montantHt);
		writeLine("Montant TVA : " + montantTva);
		writeLine("Montant TTC : " + montantTtc);
		// FIN ALGORITHME Ht


		// ALGORITHME Ht
		// Récupération du montant TTC
		montantTtc : réel := lire("Saisissez un montant TTC :")
		// Calcul du montant HT et de la TVA
		montantHt : réel := montantTtc / 1.2
		montantTva : réel := montantHt x 0.2
		// Affichage des montants
		ecrire("Montant HT : " & montantHt)
		ecrire("Montant TVA : " & montantTva)
		ecrire("Montant TTC : " & montantTtc)
		// FIN ALGORITHME Ht

Résolution d'une équation du premier degré

On souhaite rédiger l'algorithme "EquationDegre1 " qui :

Demande à l'utilisateur de saisir les nombres $a$, $b$ et $c$.
Affiche l'équation $ax+b=c$ dont l'utilisateur a saisi les coefficients.
Calcule puis affiche la solution $s$ de l'équation.

Rappel mathématique : $ax+b=c \implies x = \frac{c-b}{a}$.

Par exemple, avec $a=3$, $b=5$ et $c=17$, on obtient l'équation $3x+5=17$. La solution de l'équation est alors $s=(17-5)/3=4$.


		// ALGORITHME EquationDegre1
		// Récupération des coefficients de l'équation
		var a = readNumber("a = ");
		var b = readNumber("b = ");
		var c = readNumber("c = ");
		// Affichage de l'équation
		writeLine("Soit l'équation " + a + "x + " + b + " = " + c);
		// Calcul de la solution de l'équation
		var s = (c - b) / a;
		// Affichage de la solution
		writeLine("La solution de l'équation est :");
		writeLine("s = " + s);
		// FIN ALGORITHME EquationDegre1


		// ALGORITHME EquationDegre1
		// Récupération des coefficients de l'équation
		a : réel := lire("a = ")
		b : réel := lire("b = ")
		c : réel := lire("c = ")
		// Affichage de l'équation
		ecrire("Soit l'équation " & a & "x + " & b & " = " & c);
		// Calcul de la solution de l'équation
		s : réel := (c - b) / a
		// Affichage de la solution
		ecrire("La solution de l'équation est :")
		ecrire("s = " & s)
		// FIN ALGORITHME EquationDegre1

Division euclidienne

En primaire, on apprend un jour ce qu'est la "division euclidienne". Le temps passe et certains oublient... Rappelons ce que c'est :

Au sens de la division euclidienne :

Comme $15 = 3 \times 5 + 0$, on dit que $15/3=5\:reste\:0$. En l'occurrence, $3$ est qualifié de "diviseur", $5$ de "dividende" et $0$ de "reste".
En revanche $16 = 3 \times 5 + 1$, on dit donc que $16/3=5\:reste\:1$. Cette fois-ci, le diviseur est toujours $3$, le dividende toujours $5$ mais le reste est $1$.

Plus généralement :

Diviser un nombre $a$ par $n$ revient à écrire $a = d \times n + r$ où $d$ (le dividende) est un entier quelconque et $r$ (le reste) est un entier tel que $0 \leq r \le n$.
En mathématique et en algorithmique, on peut utilise l'opérateur $%$ (modulo) qui calcule le reste de la division euclidienne d'un nombre $a$ par un nombre $n$.
Dès lors, si on a $a = d \times n + r$, avec $a$ et $n$ deux entiers (supposés positifs), on a :
$r = a % n$
$d = \frac{a - r}{n}$

En se servant de l'opérateur modulo (%), on souhaite rédiger l'algorithme "DivisionEuclidienne" qui :

Demande à l'utilisateur de saisir un nombre entier positif $a$ (le nombre à diviser).
Demande à l'utilisateur de saisir un nombre entier positif $n$ (le diviseur).
Calcule le dividende $d$ et le reste $r$ de la division euclidienne de $a$ par $n$.
Affiche la division euclidienne sous la forme $a = d \times n + r$.


		// ALGORITHME DivisionEuclidienne
		// Récupération du nombre à diviser et du diviseur
		var a = readInteger("Saisissez le nombre à diviser :");
		var n = readInteger("Saisissez le diviseur :");
		// Calcul du dividende et du reste
		var r = a % n;
		var d = (a - r) / n;
		// Affichage de la division euclidienne
		writeLine(a + " = " + d + " x " + n + " + " + r);
		// FIN ALGORITHME DivisionEuclidienne


		// ALGORITHME DivisionEuclidienne
		// Récupération du nombre à diviser et du diviseur
		a : entier := readInteger("Saisissez le nombre à diviser :")
		n : entier := readInteger("Saisissez le diviseur :")
		// Calcul du dividende et du reste
		r : entier := a % n
		d : entier := (a - r) / n
		// Affichage de la division euclidienne
		ecrire(a & " = " & d & " x " & n & " + " & r);
		// FIN ALGORITHME DivisionEuclidienne

Exercices sur les conditions Utiliser la structure conditionnelle SI

Calcul du maximum de deux nombres

On souhaite rédiger l'algorithme "TrouverMax " qui :

Demande à l'utilisateur de saisir un premier nombre $n_{1}$.
Demande à l'utilisateur de saisir un deuxième nombre $n_{2}$.
Détermine lequel des deux nombres est le maximum (i.e. le plus grand des deux).
Affiche les nombres saisis ainsi que le maximum.


		// ALGORITHME TrouverMax
		// Récupération de deux nombres
		var n1 = readNumber("Saisir le 1er nombre :");
		var n2 = readNumber("Saisir le 2nd nombre :");
		// Détermination du maximum
		var max;
		if(n1 > n2){
			max = n1;
		}else{
			max = n2;
		}
		// Affichage des nombres et du maximum
		writeLine("Nombre 1 : " + n1);
		writeLine("Nombre 2 : " + n2);
		writeLine("Maximum : " + max);
		// FIN ALGORITHME TrouverMax


		// ALGORITHME TrouverMax
		// Récupération de deux nombres
		n1 : réel := lire("Saisir le 1er nombre :")
		n2 : réel := lire("Saisir le 2nd nombre :")
		// Détermination du maximum
		max : réel
		SI n1 > n2 ALORS
			max := n1
		SINON
			max := n2
		FIN SI
		// Affichage des nombres et du maximum
		ecrire("Nombre 1 : " & n1)
		ecrire("Nombre 2 : " & n2)
		ecrire("Maximum : " & max)
		// FIN ALGORITHME TrouverMax

Calcul de la valeur absolue d'un nombre

On souhaite rédiger l'algorithme "ValeurAbsolue" qui :

Demande à l'utilisateur de saisir un nombre $n$.
Calcule la valeur absolue du nombre.
Affiche le nombre $n$ saisi puis sa valeur absolue $|n|$.

Rappel : $ \|n| = \left\{ \begin{array}{ll} n \: si \: n > 0 \\ -n \: sinon \end{array} \right. $

Par exemple, la valeur absolue de 5 est 5 et celle de -7 est 7.


		// ALGORITHME ValeurAbsolue
		// Récupération d'un nombre
		var n = readNumber("Saisir un nombre :");
		// Calcul de la valeur absolue
		var abs;
		if(n > 0){
			abs = n;
		}else{
			abs = -n;
		}
		// Affichage du nombre et de sa valeur absolue
		writeLine("n = " + n);
		writeLine("|n| = " + abs);
		// FIN ALGORITHME ValeurAbsolue


		// ALGORITHME ValeurAbsolue
		// Récupération d'un nombre
		n : réel := lire("Saisir un nombre :")
		// Calcul de la valeur absolue
		abs : réel
		SI n0 > 0 ALORS
			abs := n
		SINON
			abs := -n
		FIN SI
		// Affichage du nombre et de sa valeur absolue
		ecrire("n = " & n)
		ecrire("|n| = " & abs)
		// FIN ALGORITHME ValeurAbsolue

Résolution d'une équation du second degré

On souhaite rédiger l'algorithme "EquationDegre2 " qui :

Demande à l'utilisateur de saisir les nombres $a$, $b$ et $c$.
Affiche l'équation $ax^{2}+bx+c=0$ dont l'utilisateur a saisi les coefficients.
Calcule le discriminant de l'équation et précise (affiche) si celui-ci est positif, négatif ou nul.
S'il n'y a aucune solution, affiche "L'équation n'admet aucune solution".
S'il y a une ou deux solutions, affiche la solution ou les solutions.

Rappel mathématique :

Le discriminant vaut $\Delta = b^{2} - 4ac$.
Si $\Delta < 0$, l'équation n'admet aucune solution réelle.
Si $\Delta = 0$, l'équation admet $\frac{-b}{2a}$ comme unique solution.
Si $\Delta > 0$, l'équation admet $\frac{-b+\sqrt{\Delta}}{2a}$ et $\frac{-b-\sqrt{\Delta}}{2a}$ comme solutions.

Pour calculer la racine carré d'un nombre, vous utiliserez le bout de code suivant :


	// calcule puis affiche la racine carrée de 64
	var racine = Math.sqrt(64);
	writeLine("La racine carrée de 64 vaut " + racine);


		// ALGORITHME EquationDegre2
		// Récupération des coefficients de l'équation
		var a = readNumber("a = ");
		var b = readNumber("b = ");
		var c = readNumber("c = ");
		// Affichage de l'équation
		writeLine("Soit l'équation " + a + "x² + " + b + "x + " + c + " = 0");
		// Calcul du discriminant
		var delta = b * b - 4 * a * c;
		// Selon la valeur du discriminant
		if(delta < 0){
			writeLine("L'équation n'admet aucune solution.")
		}else if(delta == 0){
			var s = -b / (2 * a);
			writeLine("La solution de l'équation est :");
			writeLine("s = " + s);
		}else{
			var s1 = (-b + Math.sqrt(delta)) / (2 * a);
			var s2 = (-b - Math.sqrt(delta)) / (2 * a);
			writeLine("Les solutions de l'équation sont :");
			writeLine("s1 = " + s1);
			writeLine("s2 = " + s2);
		}
		// FIN ALGORITHME EquationDegre2


		// ALGORITHME EquationDegre2
		// Récupération des coefficients de l'équation
		a : réel := readNumber("a = ")
		b : réel := readNumber("b = ")
		c : réel := readNumber("c = ")
		// Affichage de l'équation
		ecrire("Soit l'équation : " & a & "x² + " & b & "x + " & c & " = 0")
		// Calcul du discriminant
		delta = b x b - 4 x a x c;
		// Selon la valeur du discriminant
		SI delta < 0 ALORS
			ecrire("L'équation n'admet aucune solution.")
		SINON SI delta = 0 ALORS
			s : réel := -b / (2 x a)
			ecrire("La solution de l'équation est :")
			ecrire("s = " & s)
		SINON
			s1 : réel := (-b + Math.sqrt(delta)) / (2 x a)
			s2 : réel := (-b - Math.sqrt(delta)) / (2 x a)
			ecrire("Les solutions de l'équation sont :")
			ecrire("s1 = " & s1)
			ecrire("s2 = " & s2)
		FIN SI
		// FIN ALGORITHME EquationDegre2

Calcul de prime

On souhaite rédiger l'algorithme "CalculPrime" permettant de calculer la prime d'un commercial. La prime d'un commercial est calculée à partir du chiffre d'affaires qu'il a réalisé et ce selon le barème suivant :

Chiffre d'affaires (CA)	Prime (%)
≤ 150000	0%
> 150000 et ≤ 500000	1%
>500000	2%

A titre d'exemple, la prime d'un commercial ayant réalisé 75000€ de CA est de 0€, celle d'un commercial ayant réalisé 1000000€ de CA est de 20000€.

L'algorithme fonctionne comme suit :

Il demande à l'utilisateur de saisir le chiffre d'affaires $ca$ réalisé.
Il détermine le (seul) pourcentage $pourcent$ de prime applicable.
Il calcule la prime du commercial.
Il affiche la chiffre d'affaires réalisé, le pourcentage de prime applicable et la prime du commercial.


		// ALGORITHME CalculPrime
		// Récupération du CA réalisé
		var ca = readNumber("Chiffre d'affaires réalisé (en euros) :");
		// Détermination du pourcentage de prime applicable
		var pourcent;
		if(ca <= 150000){
			pourcent = 0;
		}else if(ca <= 500000){
			pourcent = 1;
		}else{
			pourcent = 2;
		}
		// Calcul de la prime
		var prime = ca * pourcent / 100;
		// Affichage du CA, du pourcentage de prime et de la prime
		writeLine("Chiffre d'affaires : " + ca);
		writeLine("Pourcentage prime : " + pourcent + "%");
		writeLine("Montant prime : " + prime + "€");
		// FIN ALGORITHME CalculPrime


		// ALGORITHME CalculPrime
		// Récupération du CA réalisé
		ca : réel := lire("Chiffre d'affaires réalisé (en euros) :")
		// Détermination du pourcentage de prime applicable
		pourcent : réel
		SI ca ≤ 150000 ALORS
			pourcent := 0
		SINON SI ca ≤ 500000 ALORS
			pourcent := 1
		SINON
			pourcent := 2
		FIN SI
		// Calcul de la prime
		prime : réel := ca x pourcent / 100
		// Affichage du CA, du pourcentage de prime et de la prime
		ecrire("Chiffre d'affaires : " & ca)
		ecrire("Pourcentage prime : " & pourcent & "%")
		ecrire("Montant prime : " & prime & "€")
		// FIN ALGORITHME CalculPrime

Calcul de prime progressive

On souhaite rédiger l'algorithme "CalculPrimeProgressive" permettant de calculer la prime d'un commercial. La prime d'un commercial est calculée selon un barème progressif à partir du chiffre d'affaires qu'il a réalisé. Le barème est le suivant :

Chiffre d'affaires (CA)	Prime (%)
≤ 100000	0%
> 100000 et ≤ 250000	2%
> 250000 et ≤ 500000	5%
> 500000	10%

A titre d'exemples :

La prime d'un commercial ayant réalisé $50000€$ de CA est de $0€$.
La prime d'un commercial ayant réalisé $200000€$ de CA est de :
$(200000 - 100000) \times 2\% = 2000€$.
La prime d'un commercial ayant réalisé $400000€$ de CA est de :
$(250000 - 100000) \times 2\% + (400000-250000) \times 5\% = 3000 + (400000-250000) \times 5\% = 10500€$.

L'algorithme fonctionne comme suit :

Il demande à l'utilisateur de saisir le chiffre d'affaires réalisé.
Il calcule la prime du commercial en appliquant le barème progressif.
Il affiche le chiffre d'affaires saisi et le montant de la prime.


		// ALGORITHME CalculPrimeProgressive
		// Récupération du CA réalisé
		var ca = readNumber("Chiffre d'affaires réalisé (en euros) :");
		// Application du barème progressif (plusieurs méthodes possibles)
		var prime;
		if(ca > 500000){
			prime = (ca - 500000) * 0.1 + 15500;			
		}else if(ca > 250000){
			prime = (ca - 250000) * 0.05 + 3000;
		}else if(ca > 100000){
			prime = (ca - 100000) * 0.02;
		}else{
			prime = 0;
		}
		// Affichage du chiffre d'affaires et de la prime du commerciale
		writeLine("Chiffre d'affaires : " + ca);
		writeLine("Prime : " + prime + "€");
		// FIN ALGORITHME CalculPrimeProgressive


		// ALGORITHME CalculPrimeProgressive
		// Récupération du CA réalisé
		ca : réel := lire("Chiffre d'affaires réalisé (en euros) :")
		// Application du barème progressif (plusieurs méthodes possibles)
		prime : réel
		SI ca > 500000 ALORS
			prime := (ca - 500000) x 0.1 + 15500			
		SINON SI ca > 250000 ALORS
			prime := (ca - 250000) x 0.05 + 3000
		SINON SI ca > 100000 ALORS
			prime := (ca - 100000) x 0.02
		SINON
			prime := 0
		FIN SI
		// Affichage du chiffre d'affaires et de la prime du commerciale
		ecrire("Chiffre d'affaires : " & ca)
		ecrire("Prime : " & prime & "€")
		// FIN ALGORITHME CalculPrimeProgressive

Calcul de prime selon localisation

On souhaite rédiger l'algorithme "CalculPrimeLocale" permettant de calculer la prime d'un commercial d'une société ayant deux agences. La prime du commercial est fonction du chiffre d'affaires (CA) qu'il a réalisé. Elle est calculée selon un barème (non progressif) propre à chaque agence. Le barème est globalement le suivant :

Ville	Chiffre d'affaires (CA)	Prime (%)
Orléans	≤ 100000	0%
	> 100000 et ≤ 300000	3%
	> 300000	5%
Paris	≤ 200000	0%
	> 200000 et ≤ 500000	2%
	> 500000	4%

A titre d'exemples, la prime d'un commercial d'Orléans ayant réalisé un CA de 200000€ est de 6000€. Elle serait de 0€ s'il était commercial à Paris.

L'algorithme permet :

De demander à l'utilisateur le chiffre d'affaires réalisé.
De demander à l'utilisateur de choisir l'agence : "ORLEANS" ou "PARIS". L'utilisateur doit impérativement saisir l'une de ces deux valeurs, sinon le logiciel affiche un message d'erreur : "Erreur : nom d'agence saisi incorrect.".
De calculer la prime du commercial.
D'afficher le chiffre d'affaires, la ville et la prime calculée.


		// ALGORITHME CalculPrimeLocale
		var pourcent = -1;
		// Saisie du CA réalisé
		var ca = readNumber("Chiffre d'affaires (en euros) :");
		// Choix de la ville
		var agence = read("Agence (ORLEANS ou PARIS) :");
		if(agence == "ORLEANS"){
			// Pourcentage de prime
			if(ca <= 100000){
				pourcent = 0;
			}else if(ca <= 300000){
				pourcent = 3;
			}else{
				pourcent = 5;
			}
		}else if(agence == "PARIS"){
			// Pourcentage de prime
			if(ca <= 200000){
				pourcent = 0;
			}else if(ca <= 500000){
				pourcent = 2;
			}else{
				pourcent = 4;
			}
		}else{
			writeLine("Erreur : nom d'agence saisi incorrect.");
		}
		// Affichage du CA, de l'agence et de la prime
		if(pourcent != -1){
			var prime = ca * pourcent / 100;
			writeLine("Chiffre d'affaires : " + ca);
			writeLine("Agence : " + agence);
			writeLine("Prime (%) : " + pourcent);
			writeLine("Prime (€) : " + prime);
		}
		// FIN ALGORITHME CalculPrimeLocale


		// ALGORITHME CalculPrimeLocale
		pourcent : réel := -1
		// Saisie du CA réalisé
		ca : réel := lire("Chiffre d'affaires (en euros) :")
		// Choix de la ville
		agence : chaîne := lire("Agence (ORLEANS ou PARIS) :")
		SI agence = "ORLEANS" ALORS
			// Pourcentage de prime
			SI ca ≤ 100000 ALORS
				pourcent := 0
			SINON SI ca ≤ 300000 ALORS
				pourcent := 3
			SINON
				pourcent := 5
			FIN SI
		SINON SI ville = "PARIS" ALORS
			// Pourcentage de prime
			SI ca ≤ 200000 ALORS
				pourcent := 0
			SINON SI ca ≤ 500000 ALORS
				pourcent := 2
			SINON
				pourcent := 4
			FIN SI
		SINON
			ecrire("Erreur : nom d'agence saisi incorrect.")
		FIN SI
		// Affichage du CA, de l'agence et de la prime
		SI pourcent ≠ -1 ALORS
			prime := ca x pourcent / 100
			ecrire("Chiffre d'affaires : " & ca)
			ecrire("Agence : " & agence)
			ecrire("Prime (%) : " & pourcent)
			ecrire("Prime (€) : " & prime)
		FIN SI
		// FIN ALGORITHME CalculPrimeLocale

Résolution d'un système de deux équations à deux inconnues

On souhaite rédiger l'algorithme "SystemeEquation2" qui :

Demande à l'utilisateur de saisir les nombres $a$, $b$, $c$, $d$, $e$ et $f$.
Affiche le système d'équations $ax+by=c$ et $dx+ey=f$ dont l'utilisateur a saisi les coefficients.
Calcule puis affiche les solutions $x$ et $y$ de l'équation.

Informations mathématiques :

Soit le système : $\left\{ \begin{array}{ll} ax+by=c \\ dx+ey=f \end{array} \right.$
Si le déterminant $\Delta = ae - bd \ne 0$, l'unique solution du système est : $\left\{ \begin{array}{ll} x=\frac{ce - bd}{\Delta} \\ y=\frac{af - cd}{\Delta} \end{array} \right.$
Sinon, le système n'a aucune ou a une infinité de solutions.

Par exemple :

$$ \left\{ \begin{array}{ll} x+y=1 \\ x-y=1 \end{array} \right. \implies \left\{ \begin{array}{ll} \Delta = 1 \times (-1) - 1 \times 1 = -1 - 1 = -2 \\ x=\frac{1 \times (-1) - 1 \times 1}{-2} = 1 \\ y=\frac{1 \times 1 - 1 \times 1}{-2} = 0 \end{array} \right. $$


		// ALGORITHME SystemeEquation2
		// Récupération des coefficients de l'équation
		var a = readNumber("a = ");
		var b = readNumber("b = ");
		var c = readNumber("c = ");
		var d = readNumber("d = ");
		var e = readNumber("e = ");
		var f = readNumber("f = ");
		// Affichage du système d'équations
		writeLine("Système d'équations :");
		writeLine(a + "x + " + b + " = " + c);
		writeLine(d + "x + " + e + " = " + f);
		// Calcul du "déterminant"
		var delta = a * e - b * d;
		// Selon le cas 
		if(delta != 0){
			var x = (c * e - b * d) / delta;
			var y = (a * f - c * d) / delta;
			writeLine("Solution :");
			writeLine("x = " + x);
			writeLine("y = " + y);
		}else{
			writeLine("Solution : aucune ou une inifinité.");
		}
		// FIN ALGORITHME SystemeEquation2


		// ALGORITHME SystemeEquation2
		// Récupération des coefficients de l'équation
		a : réel := lire("a = ")
		b : réel := lire("b = ")
		c : réel := lire("c = ")
		d : réel := lire("d = ")
		e : réel := lire("e = ")
		f : réel := lire("f = ")
		// Affichage du système d'équations
		ecrire("Système d'équations :")
		ecrire(a & "x + " & b & " = " & c)
		ecrire(d & "x + " & e & " = " & f)
		// Calcul du "déterminant"
		delta : réel := a x e - b x d
		// Selon le cas 
		SI delta ≠ 0 ALORS
			x : réel := (c x e - b x d) / delta
			y : réel := (a x f - c x d) / delta
			ecrire("Solution :")
			ecrire("x = " & x)
			ecrire("y = " & y)
		SINON
			ecrire("Solution : aucune ou une inifinité.")
		FIN SI
		// FIN ALGORITHME SystemeEquation2

Calcul d'impôt sur le revenu

On souhaite rédiger l'algorithme "CalculIR" permettant de calculer l'impôt sur le revenu (IR)* d'un redevable imposé uniquement au titre des traitements et salaires. Il peut y avoir un ou deux déclarants. Le montant de l'IR est calculé sur la base des informations suivantes :

* Du moins, tel que l'IR était calculé jusqu'au lancement du prélèvement à la source en 2019.

Le redevable précise son nombres de parts (N).
Le redevable précise le montant des revenus imposables (traitements et salaires nets imposables) du déclarant n°1.
Le redevable précise s'il désire que le déclarant n°1 passe aux frais réels.
Si le déclarant n°1 est aux frais rééls, le redevable saisit le montant des frais déductibles du déclarant n°1. On obtient ainsi le revenu net imposable (R1) du déclarant n°1.
Dans le cas contraire, un abattement forfaitaire de 10% est appliqué. On obtient une fois encore le revenu net imposable (R1) du déclarant n°1.
Le redevable précise s'il y a oui ou non un déclarant n°2.
Si oui, le redevable saisit le montant des revenus imposables du déclarant n°2. Le cas échéant, ces revenus sont diminués des frais réels saisis ou de l'abattement forfaitaire de 10%. On obtient le revenu net imposable (R2) du déclarant n°2.

Ceci fait, l'algorithme se poursuit comme suit :

Il détermine la revenu net imposable (R=R1+R2) en additionnant le revenus net imposable des déclarants.
Il calcule le quotient familial (QF=R/N) en divisant la revenu net imposable par le nombre de parts.
Il calcule le montant de l'impôt en appliquant le barème ci-dessous.

Barème progressif :

Quotient familial (QF)	Taux marginal (%)	Formule
En-deçà de 9807 euros	0%	0
9807 à 27086 euros	14%	R x 0.14 - 1372.98 x N
27086 à 72617 euros	30%	R x 0.30 - 5706.74 x N
72617 à 153783 euros	41%	R x 0.41 - 13 694.61 x N
Au-delà de 153783 euros	45%	R x 0.45 - 19845.93 x N

A titre d'exemple :

Avec des revenus imposables de $75000€$, $2\:parts$ et abattement forfaitaire 10%.
On obtient $R = 75000 - 75000 \times 0.1 = 75000 \times 0.9 = 67500€$.
On obtient $QF = 67500€/2 = 33750$ et donc imposition dans la tranche $30\%$
Donc $IR = 67500€ \times 0.30 - 5706.74 \times 2 = 8836.52€$ d'impôt.


		// ALGORITHME CalculIR
		// Nombre de parts
		var n = readNumber("Nombre de parts :");
		// Revenus imposables du déclarant n°1
		var r1 = readNumber("Revenus imposables du déclarant n°1 :");
		// Frais réels ?
		var reel = readBoolean("Le déclarant n°1 est-il aux frais réels ?");
		// Revenus nets imposables du déclarant n°1
		if(reel){
			var frais = readNumber("Montant des frais réels du déclarant n°1 :");
			r1 = r1 - frais;
		}else{
			r1 = 0.9 * r1;
		}
		writeLine("Revenu net imposable déclarant n°1 : " + r1 + "€");
		// Déclarant n°2
		var secondDeclarant = readBoolean("Y a-t-il un déclarant n°2 ?");
		// Revenus imposables du déclarant n°2
		var r2;
		if(secondDeclarant){
			r2 = readNumber("Revenus imposables du déclarant n°2 :");
			reel = readBoolean("Le déclarant n°2 est-il aux frais réels ?");
			// Revenus nets imposables du déclarant n°2
			if(reel){
				frais = readNumber("Montant des frais réels du déclarant n°2 :");
				r2 = r2 - frais;
			}else{
				r2 = 0.9 * r2;
			}
		}else{
			r2 = 0;
		}
		writeLine("Revenu net imposable déclarant n°2 : " + r2 + "€");
		// Revenus nets imposables
		var r = r1 + r2;
		writeLine("Revenus nets imposables : " + r + "€");
		// Quotient familial
		var qf = r / n;
		writeLine("Quotient familial : " + qf + "€");
		// Calcul de l'impôt
		var ir;
		var tranche;
		if(qf <= 9807){
			ir = 0;
			tranche = "0%";
		}else if(qf <= 27086){
			ir = r * 0.14 - 1372.98 * n;
			tranche = "14%";
		}else if(qf <= 72617){
			ir = r * 0.30 - 5706.74 * n;
			tranche = "30%";
		}else if(qf <= 153783){
			ir = r * 0.41 - 13694.61 * n;
			tranche = "41%";
		}else{
			ir = r * 0.45 - 19845.93 * n;
			tranche = "45%";
		}
		writeLine("Tranche : " + tranche);
		writeLine("Impôt sur le revenu : " + ir + "€");
		// FIN ALGORITHME CalculIR


		// ALGORITHME CalculIR
		// Nombre de parts
		n : réel := lire("Nombre de parts :")
		// Revenus imposables du déclarant n°1
		r1 : réel := lire("Revenus imposables du déclarant n°1 :")
		// Frais réels ?
		reel : booléen := lire("Le déclarant n°1 est-il aux frais réels ?")
		// Revenus nets imposables du déclarant n°1
		SI reel ALORS
			frais : réel := lire("Montant des frais réels du déclarant n°1 :")
			r1 := r1 - frais
		SINON
			r1 := 0.9 x r1
		FIN SI
		ecrire("Revenu net imposable déclarant n°1 : " & r1 & "€")
		// Déclarant n°2
		secondDeclarant : booléen := lire("Y a-t-il un déclarant n°2 ?")
		// Revenus imposables du déclarant n°2
		r2 : réel
		SI secondDeclarant ALORS
			r2 := lire("Revenus imposables du déclarant n°2 :")
			reel := lire("Le déclarant n°2 est-il aux frais réels ?")
			// Revenus nets imposables du déclarant n°2
			SI reel ALORS
				frais := lire("Montant des frais réels du déclarant n°2 :")
				r2 := r2 - frais
			SINON
				r2 := 0.9 x r2
			FIN SI
		SINON
			r2 := 0
		FIN SI
		ecrire("Revenu net imposable déclarant n°2 : " & r2 & "€")
		// Revenus nets imposables
		r : réel := r1 + r2
		ecrire("Revenus nets imposables : " & r & "€")
		// Quotient familial
		qf : réel := r / n
		ecrire("Quotient familial : " & qf & "€")
		// Calcul de l'impôt
		ir : réel
		tranche : chaîne
		SI qf ≤ 9807 ALORS
			ir := 0;
			tranche := "0%"
		SINON SI qf ≤ 27086 ALORS
			ir := r x 0.14 - 1372.98 x n
			tranche := "14%"
		SINON SI qf ≤ 72617 ALORS
			ir := r x 0.30 - 5706.74 x n
			tranche := "30%"
		SINON SI qf ≤ 153783 ALORS
			ir := r x 0.41 - 13694.61 x n
			tranche := "41%"
		SINON 
			ir := r x 0.45 - 19845.93 x n
			tranche := "45%"
		FIN SI
		ecrire("Tranche : " & tranche)
		ecrire("Impôt sur le revenu : " & ir & "€")
		// FIN ALGORITHME CalculIR

Exercices sur les boucles Utiliser les structures itératives POUR et TANTQUE

Table de multiplications

On souhaite rédiger l'algorithme "TableMultiplication" permettant d'afficher les 11 premiers multiples (0 à 10) d'une table de multiplications (n) choisie par l'utilisateur. La table de multiplication choisie doit être comprise entre 0 et 10. On demande à l'utilisateur de choisir une table de multiplication jusqu'à ce qu'il ait bien saisi un nombre compris entre 0 et 10 inclus.

On souhaite obtenu un résultat de la forme suivante :

Table des 5 :
0 x 5 = 0
1 x 5 = 5
2 x 5 = 10
...
10 x 5 = 50


		// ALGORITHME TableMultiplication
		// Récupération de la table de multiplication
		var n = -1;
		while(n < 0 || n > 10){
			n = readInteger("Table de multiplication :");
		}
		// Affichage de la table de n
		writeLine("Table des " + n);
		var i;
		for(i=0; i<=10; i=i+1){
			writeLine(i + " x " + n + " = " + (i*n));
		}
		// FIN ALGORITHME TableMultiplication


		// ALGORITHME TableMultiplication
		// Récupération de la table de multiplication
		n : entier := -1;
		TANTQUE n < 0 OU n > 10
			n := lire("Table de multiplication :")
		FIN TANTQUE
		// Affichage de la table de n
		ecrire("Table des " & n)
		i : entier;
		POUR i:=0 JUSQU'A 10 PAS DE 1
			ecrire(i & " x " & n & " = " & (i x n))
		FIN POUR
		// FIN ALGORITHME TableMultiplication

Pyramide croissante

On souhaite rédiger l'algorithme "PyramideAsc" permettant :

De demander à l'utilisateur la hauteur $n>0$ de la pyramide.
D'afficher une pyramide de hauteur $n$ comme dans l'exemple ci-dessous.

Exemple d'une pyramide de taille n=5 :

*
**
***
****
*****


		// ALGORITHME PyramideAsc
		var n = readInteger("Hauteur de la pyramide :");
		var i;
		var etage = "";
		for(i=0; i<n; i=i+1){
			etage = etage + "*";
			writeLine(etage);
		}
		// FIN ALGORITHME PyramideAsc


		// ALGORITHME PyramideAsc
		n : entier := lire("Hauteur de la pyramide :")
		i : entier
		etage : chaîne := ""
		POUR i:=1 JUSQU'A n PAS DE 1
			etage := etage & "*"
			ecrire(etage)
		FIN POUR
		// FIN ALGORITHME PyramideAsc

Pyramide décroissante

On souhaite rédiger l'algorithme "PyramideDesc" permettant :

De demander à l'utilisateur la hauteur $n>0$ de la pyramide.
D'afficher une pyramide inversée de hauteur $n$ comme dans l'exemple ci-dessous.

Exemple d'une pyramide de taille n=5 :

*****
****
***
**
*


		// ALGORITHME PyramideDesc
		var n = readInteger("Hauteur de la pyramide :");
		var i;
		var j;
		for(i=n; i>0; i=i-1){
			var etage = "";
			for(j=0 ; j<i; j=j+1){
				etage = etage + "*";
			}
			writeLine(etage);
		}
		// FIN ALGORITHME PyramideDesc


		// ALGORITHME PyramideDesc
		n : entier := lire("Hauteur de la pyramide :")
		i : entier
		j : entier;
		POUR i:=n JUSQU'A 1 PAS DE -1
			etage : chaîne := ""
			POUR j=1 JUSQU'A i PAS DE 1
				etage := etage & "*"
			FIN POUR
			ecrire(etage)
		FIN POUR
		// FIN ALGORITHME PyramideDesc

Carré plein

On souhaite rédiger l'algorithme "CarrePlein" permettant :

De demander à l'utilisateur la largeur $n>0$ du carré.
D'afficher un carré plein sur le modèle ci-dessous.

Exemple de "carré" de largeur n=5 :

*****
*****
*****
*****
*****


		// ALGORITHME CarrePlein
		var n = readInteger("Largeur du carré :");
		var etage = "";
		var i;
		for(i=0; i<n; i=i+1){
			etage = etage + "*";
		}
		for(i=0; i<n; i=i+1){
			writeLine(etage);
		}
		// FIN ALGORITHME CarrePlein


		// ALGORITHME CarrePlein
		n : entier := lire("Largeur du carré :")
		etage : chaîne := ""
		i : entier
		POUR i:=1 JUSQU'A n PAS DE 1
			etage := etage & "*"
		FIN POUR
		POUR i:=0 JUSQU'A n PAS DE 1
			ecrire(etage)
		FIN POUR
		// FIN ALGORITHME CarrePlein

Moyenne pondérée

On souhaite rédiger l'algorithme "MoyennePonderee" permettant :

De demander à l'utilisateur de saisir un nombre.
De demander à l'utilisateur de saisir un coefficient.
D'afficher le nombre et le coefficient saisis.
De laisser l'utilisateur saisir des nombres et coefficients s'il le souhaite.
De calculer la moyenne pondérée des nombres qu'il a saisis.


		// ALGORITHME MoyennePonderee
		// Pour stopper les saisies de nombres et coefficients
		var continuer = true;
		// Somme des nombres x coefficients
		var somme = 0;
		// Somme des coefficients
		var coefficients = 0;
		while(continuer){
			var nombre = readNumber("Saisir un nombre :");
			var coefficient = readNumber("Saisir son coefficient :");
			somme = somme + nombre * coefficient;
			coefficients = coefficients + coefficient;
			writeLine(nombre + " coef " + coefficient);
			continuer = readBoolean("Ajouter une nouvelle note (oui/non) ?");
		}
		// Affiche la moyenne
		var moyenne = somme / coefficients;
		writeLine("Moyenne : " + moyenne);
		// FIN ALGORITHME MoyennePonderee


		// ALGORITHME MoyennePonderee
		// Pour stopper les saisies de nombres et coefficients
		continuer : booléen := vrai
		// Somme des nombres x coefficients
		somme : réel := 0
		// Somme des coefficients
		coefficients : réel := 0
		TANTQUE continuer
			nombre : réel := lire("Saisir un nombre :")
			coefficient : réel := lire("Saisir son coefficient :")
			somme := somme + nombre x coefficient
			coefficients := coefficients + coefficient
			ecrire(nombre & " coef " & coefficient)
			continuer := lire("Ajouter une nouvelle note (oui/non) ?")
		FIN TANTQUE
		// Affiche la moyenne
		moyenne := somme / coefficients
		ecrire("Moyenne : " & moyenne)
		// FIN ALGORITHME MoyennePonderee

Moyenne des notes d'un élève

On souhaite rédiger l'algorithme "MoyenneEleve". On s'inspirera du précédent algorithme. L'élève saisit ces notes et leur coefficient. Cependant :

L'élève doit impérativement saisir des notes comprises entre 0 et 20 inclus.
L'élève doit impérativement saisir des coefficient entiers compris entre 0 et 12 inclus.
On demande à l'élève de saisir une note ou un coefficient tant que sa saisie est incorrecte.


		// ALGORITHME MoyennePonderee
		// Pour stopper les saisies de nombres et coefficients
		var continuer = true;
		// Somme des nombres x coefficients
		var somme = 0;
		// Somme des coefficients
		var coefficients = 0;
		while(continuer){
			var note = -1;
			while(note < 0 || note > 20){
				note = readNumber("Saisir une note (entre 0 et 20) :");
			}
			var coefficient = -1;
			while(coefficient < 0 || coefficient > 12){
				coefficient = readInteger("Saisir son coefficient :");
			}
			somme = somme + note * coefficient;
			coefficients = coefficients + coefficient;
			writeLine(note + " coef " + coefficient);
			continuer = readBoolean("Ajouter une nouvelle note (oui/non) ?");
		}
		// Affiche la moyenne
		var moyenne = somme / coefficients;
		writeLine("Moyenne : " + moyenne);
		// FIN ALGORITHME MoyennePonderee


		// ALGORITHME MoyennePonderee
		// Pour stopper les saisies de nombres et coefficients
		continuer : booléen := vrai
		// Somme des nombres x coefficients
		somme : réel := 0
		// Somme des coefficients
		coefficients : réel := 0
		TANTQUE continuer
			note : réel := -1
			TANTQUE note < 0 OU note > 20
				note := lire("Saisir une note (entre 0 et 20) :")
			FIN TANTQUE
			coefficient : réel := -1;
			TANTQUE coefficient < 0 OU coefficient > 12
				coefficient := lire("Saisir son coefficient :")
			FIN TANTQUE
			somme := somme + note x coefficient
			coefficients := coefficients + coefficient
			ecrire(note & " coef " & coefficient)
			continuer := lire("Ajouter une nouvelle note (oui/non) ?");
		FIN TANTQUE
		// Affiche la moyenne
		moyenne := somme / coefficients
		ecrire("Moyenne : " & moyenne)
		// FIN ALGORITHME MoyennePonderee

Affichage d'une facture simplifiée

On souhaite rédiger l'algorithme "Facturation" visant à produire une facture. Cet algorithme fonctionne somme suit :

Il demande à l'utilisateur de saisir un libellé de produit, un prix de produit (prix unitaire HT) et une quantité (entier). Puis il affiche les informations saisies.
Il permet à l'utilisateur de saisir autant de produits qu'il le souhaite.
Il calcule et affiche le montant total HT ainsi que le montant de TVA et le montant TTC de la facture.

La TVA est supposée au taux de 20%.


		// ALGORITHME Facturation
		// Pour stopper les saisies de produits
		var continuer = true;
		// Somme des prix x qte
		var montantHt = 0;
		// Liste des produits
		while(continuer){
			var produit = read("Produit :");
			var prix = readNumber("Prix :");
			var qte = readInteger("Quantité :");
			writeLine(produit + " | prix : " + prix + "€ | qté : " + qte);
			montantHt = montantHt + prix * qte;
			continuer = readBoolean("Souhaitez-vous ajouter un nouveau produit ?");
		}
		// Montant HT
		writeLine("Montant HT : " + montantHt + "€");
		// Montant de TVA
		var montantTva = montantHt * 0.2;
		writeLine("Montant TVA : " + montantTva + "€");
		// Montant TTC
		var montantTtc = montantHt + montantTva;
		writeLine("Montant TTC : " + montantTtc + "€");
		// FIN ALGORITHME Facturation


		// ALGORITHME Facturation
		// Pour stopper les saisies de produits
		continuer : booléen := true
		// Somme des prix x qte
		montantHt : réel := 0
		// Liste des produits
		TANTQUE continuer 
			produit : chaîne := lire("Produit :")
			prix : réel := lire("Prix :")
			qte : entier := lire("Quantité :")
			ecrire(produit & " | prix : " & prix & "€ | qté : " & qte)
			montantHt := montantHt + prix x qte
			continuer := lire("Souhaitez-vous ajouter un nouveau produit ?")
		FIN TANTQUE
		// Montant HT
		ecrire("Montant HT : " & montantHt & "€")
		// Montant de TVA
		montantTva : réel := montantHt x 0.2
		ecrire("Montant TVA : " & montantTva & "€")
		// Montant TTC
		var montantTtc : réel := montantHt + montantTva
		ecrire("Montant TTC : " & montantTtc & "€")
		// FIN ALGORITHME Facturation

Affichage d'une facture

On souhaite rédiger l'algorithme "Facturation", plus complet que le précédent, visant à produire une facture. On s'inspirera volontiers de l'exercice précédent. Cet algorithme fonctionne somme suit :

Il demande à l'utilisateur de saisir un libellé de produit, un prix de produit (prix unitaire HT) et une quantité (entier). Puis il affiche les informations saisies.
Il permet à l'utilisateur de saisir autant de produits qu'il le souhaite.
De plus, l'algorithme s'assure que l'utilisateur saisisse bien des prix et quantités positives.
Il calcule et affiche le montant total HT de la facture.
Si l'utilisateur le souhaite, il peut saisir un pourcentage de remise à appliquer au montant total HT de la facture.
Il affiche finalement le montant net HT de la facture (montant HT diminué le cas échéant de la remise) ainsi que le montant de TVA et le montant TTC de la facture.

La TVA est supposée au taux de 20%.


		// ALGORITHME Facturation
		// Pour stopper les saisies de produits
		var continuer = true;
		// Somme des prix x qte
		var montantHt = 0;
		// Liste des produits
		while(continuer){
			var produit = read("Produit :");
			var prix = -1;
			while(prix < 0){
				prix = readNumber("Prix :");
			}
			var qte = -1;
			while(qte < 0){
				qte = readInteger("Quantité :");
			}
			writeLine(produit + " | prix : " + prix + "€ | qté : " + qte);
			montantHt = montantHt + prix * qte;
			continuer = readBoolean("Souhaitez-vous ajouter un nouveau produit ?");
		}
		// Montant HT
		writeLine("Montant HT : " + montantHt + "€");
		// Remise 
		if(readBoolean("Souhaitez-vous appliquer une remise ?")){
			var pourcent = readNumber("Pourcentage de remise :");
			var remise = montantHt * pourcent / 100;
			writeLine("Remise : " + pourcent + "%");
			montantHt = montantHt - remise;
			writeLine("Net HT : " + montantHt + "€");
		}
		// Montant de TVA
		var montantTva = montantHt * 0.2;
		writeLine("Montant TVA : " + montantTva + "€");
		// Montant TTC
		var montantTtc = montantHt + montantTva;
		writeLine("Montant TTC : " + montantTtc + "€");
		// FIN ALGORITHME Facturation


		// ALGORITHME Facturation
		// Pour stopper les saisies de produits
		continuer : booléen := true
		// Somme des prix x qte
		montantHt : réel := 0
		// Liste des produits
		TANTQUE continuer 
			produit : chaîne := lire("Produit :")
			prix : réel := -1
			TANTQUE prix < 0
				prix := lire("Prix :")
			FIN TANTQUE
			qte : entier := -1
			TANTQUE prix < 0
				prix := lire("Quantité :")
			FIN TANTQUE
			ecrire(produit & " | prix : " & prix & "€ | qté : " & qte)
			montantHt := montantHt + prix x qte
			continuer := lire("Souhaitez-vous ajouter un nouveau produit ?")
		FIN TANTQUE
		// Montant HT
		ecrire("Montant HT : " & montantHt & "€")
		// Remise 
		SI lire("Souhaitez-vous appliquer une remise ?") ALORS
			pourcent : réel := lire("Pourcentage de remise :")
			remise : réel := montantHt x pourcent
			ecrire("Remise : " & remise & "%")
			montantHt := montantHt - remise
			ecrire("Net HT : " & montantHt & "€")
		FIN SI
		// Montant de TVA
		montantTva : réel := montantHt x 0.2
		ecrire("Montant TVA : " & montantTva & "€")
		// Montant TTC
		var montantTtc : réel := montantHt + montantTva
		ecrire("Montant TTC : " & montantTtc & "€")
		// FIN ALGORITHME Facturation

Affichage d'un plan d'amortissement

On souhaite rédiger l'algorithme "PlanAmortissement" qui permet d'établir un plan d'amortissement selon la méthode linéaire. Le programme fonctionne de la manière suivante :

L'utilisateur saisit le montant du bien à amortir, la durée de l'amortissement et l'année N de l'acquisition.
L'algorithme affiche le tableau d'amortissement comme dans l'exemple ci-dessous, en suppose le bien acquis le 01/01/N.
Dans un premier temps, l'algorithme ne tient pas compte des dépréciations. Ceci fait, on l'améliore de sorte que, au cours de l'affichage du tableau d'amortissement, l'utilisateur puisse saisir une dépréciation.

Exemple d'une immobilisation de 100000€, amortie sur 5 ans, acquise en 2018 et ayant subi une dépréciation de 10000€ en 2020 :

2018 | VNC Déb : 100000 | AMO : 20000 | VNC Fin : 80000 | Dép. : 0
2019 | VNC Déb : 80000 | AMO : 20000 | VNC Fin : 60000 | Dép. : 0
2020 | VNC Déb : 60000 | AMO : 20000 | VNC Fin : 30000 | Dép. : 10000
2021 | VNC Déb : 30000 | AMO : 15000 | VNC Fin : 15000 | Dép. : 0
2022 | VNC Déb : 15000 | AMO : 15000 | VNC Fin : 0 | Dép. : 0


		// ALGORITHME PlanAmortissement
		var vnc = readNumber("Montant immobilisation (en euros) :");
		var duree = readInteger("Durée d'amortissement (en années) :");
		var n = readInteger("Année d'acquisition :");
		var amo = vnc / duree;
		var i;
		// Affichage du plan d'amortissement
		for(i=0; i<duree; i=i+1){
			// Année suivante
			var annee = n + i;
			// Dépréciation
			var dep = readNumber("Dépréciation en " + annee + " (en euros) :");
			// Montant de l'amortissement
			writeLine(annee + " | VNC Déb : " + vnc + " | AMO : " + amo + " | VNC FIN : " + (vnc-amo-dep) + " | Dép. : " + dep);
			// VNC révisée
			vnc = vnc - amo - dep;
			// Années restantes
			var reste = duree - i - 1;
			// Amortissement révisé (Attention! On ne peut pas diviser par 0)
			if(reste > 0){
				amo = vnc / reste;
			}
		}
		// FIN ALGORITHME PlanAmortissement


		// ALGORITHME PlanAmortissement
		vnc : réel := lire("Montant immobilisation (en euros) :")
		duree : entier := lire("Durée d'amortissement (en années) :")
		n : entier := lire("Année d'acquisition :")
		amo : réel := vnc / duree
		i : entier
		// Affichage du plan d'amortissement
		POUR i:=0 JUSQU'A n-1 PAS DE 1
			// Année courante
			annee : entier := n + i
			// Dépréciation
			dep : réel := lire("Dépréciation " & annee & " (en euros) :")
			// Montant de l'amortissement
			ecrire(annee & " | VNC Déb : " & vnc & " | AMO : " & amo & " | VNC FIN : " & (vnc-amo-dep) & " | Dép. : " & dep)
			// VNC révisée
			vnc := vnc - amo - dep
			// Années restantes
			reste : entier := duree - i - 1
			// Amortissement révisé (Attention! On ne peut pas diviser par 0)
			SI reste > 0 ALORS
				amo := vnc / reste
			FIN SI
		FIN POUR
		// FIN ALGORITHME PlanAmortissement

Exercices sur les tableaux, fonctions et procédures Utiliser et créer des tableaux et des fonctions et procédures

Ligne d'écriture comptable

On souhaite rédiger la procédure "ligneEcriture" qui permet d'afficher (sur une seule ligne) une ligne d'écriture comptable constituée d'un n° de compte, d'un libellé de compte et d'un montant au débit ou au credit. Si la ligne est passée au débit, alors le crédit vaut 0 et inversement.

En utilisant la procédure (pour tester), on passe l'écriture suivante :

607000 | Achats de marchandises. | Débit : 200
624100 | Transports sur achats. | Débit : 10
445660 | TVA sur ABS | Débit : 42
401100 | Fournisseurs | Débit : 252


		// Récupère, affiche éventuellement et retourne une liste de nombres saisis. 
		function ligneEcriture(compteNum, compteLib, debit, credit){
			if(debit > 0){
				writeLine(compteNum + " | " + compteLib + " | Débit : " + debit);
			}else{
				writeLine(compteNum + " | " + compteLib + " | Crédit : " + credit);
			}
		}
		// Test
		ligneEcriture(607000, "Achats de marchandises.", 200, 0);
		ligneEcriture(624100, "Transports sur achats.", 10, 0);
		ligneEcriture(445660, "TVA sur ABS", 42, 0);
		ligneEcriture(401100, "Fournisseurs", 0, 252);


		// Récupère, affiche éventuellement et retourne une liste de nombres saisis. 
		PROCEDURE ligneEcriture(compteNum : entier, compteLib : chaîne, debit : réel, credit : réel)
			SI debit > 0 ALORS
				ecrire(compteNum & " | " & compteLib & " | Débit : " & debit)
			SINON
				ecrire(compteNum & " | " & compteLib & " | Crédit : " & credit)
			FIN SI
		FIN PROCEDURE
		// Test
		ligneEcriture(607000, "Achats de marchandises.", 200, 0)
		ligneEcriture(624100, "Transports sur achats.", 10, 0)
		ligneEcriture(445660, "TVA sur ABS", 42, 0)
		ligneEcriture(401100, "Fournisseurs", 0, 252)

Calcul du minimum de deux nombres

On souhaite rédiger les fonctions "min" et "max" qui retournent respectivement le minimum et le maximum entre deux nombres.


		// Retourne le minimum de "a" et "b".
		function min(a, b){
			if(a < b){
				return a;
			}
			return b;
		}
		// Retourne le maximum de "a" et "b".
		function max(a, b){
			if(a < b){
				return b;
			}
			return a;
		}
		// Test
		var n1 = readNumber("Nombre n°1 :");
		var n2 = readNumber("Nombre n°2 : ");
		writeLine("min(" + n1 + ", " + n2 + ") = " + min(n1, n2));
		writeLine("max(" + n1 + ", " + n2 + ") = " + max(n1, n2));


		// Retourne le minimum de "a" et "b".
		FONCTION min(a : réel, b : réel) : réel
			SI a < b ALORS
				RETOURNER a
			FIN SI
			RETOURNER b
		FIN FONCTION
		// Retourne le maximum de "a" et "b".
		FONCTION max(a : réel, b : réel) : réel
			SI a < b ALORS
				return b
			FIN SI
			RETOURNER a
		FIN FONCTION
		// Test
		n1 : réel := lire("Nombre n°1 :")
		n2 : réel := lire("Nombre n°2 : ")
		ecrire("min(" & n1 & ", " & n2 & ") = " & min(n1, n2))
		ecrire("max(" & n1 & ", " & n2 & ") = " & max(n1, n2))

Calcul de la valeur absolue et de l'opposé d'un nombre

On souhaite rédiger les fonctions "abs" et "opp" qui retournent respectivement la valeur absolue et l'opposé d'un nombre.

Rappel de mathématique :

La valeur absolue de 5 est celle de -5 est 5.
L'opposé de 5 et -5 et celui de -5 est 5.


		// Retourne la valeur absolue de "a".
		function abs(a){
			if(a < 0){
				return -a;
			}
			return a;
		}
		// Retourne l'opposé de "a".
		function opp(a){
			return -a;
		}
		// Test
		var n = readNumber("Nombre :");
		writeLine("Nombre : " + n);
		writeLine("Valeur absolue : " + abs(n));
		writeLine("Opposé : " + opp(n));


		// Retourne la valeur absolue de "a".
		FONCTION abs(a : réel) : réel
			SI a < 0 ALORS
				RETOURNER -a
			FIN SI
			RETOURNER a
		FIN FONCTION
		// Retourne l'opposé de "a".
		FONCTION opp(a : réel) : réel
			RETOURNER -a
		FIN FONCTION
		// Test
		n : réel := lire("Nombre :")
		ecrire("Nombre : " & n);
		ecrire("Valeur absolue : " & abs(n))
		ecrire("Opposé : " & opp(n))

Calcul de la puissance d'un nombre

On souhaite rédiger la fonction "puissance" qui :

Calcule $a$ élevé à la puissance d'exposant $n$, c'est-à-dire : $a^{n}$.
Retourne la valeur $a^{n}$ calculée.
Dans un premier temps, on suppose que $n$ est un entier positif. Dans un second temps, on suppose que $n$ peut être positif ou négatif.

Rappels mathématiques :

$a^{n} = \overbrace{a \times a \times ... \times a}^{n fois}$
$a^{-n} = \frac{1}{a^{n}}$
$a^{0} = 1$


		// Calcule et retourne "a" élevé à la puissance d'exposant "n"
		function puissance(a, n){
			if(n >= 0){
				var resultat = 1;
				var i;
				for(i=0; i<n; i=i+1){
					resultat = resultat * a;
				}
				return resultat;
			}else{
				return 1 / puissance(a, -n);
			}
		}
		// Tests
		writeLine("18^0 = " + puissance(18, 0));
		writeLine("5^2 = " + puissance(5, 2));
		writeLine("3^4 = " + puissance(3, 4));
		writeLine("4^-1 = " + puissance(4, -1));


		// Calcule et retourne "a" élevé à la puissance d'exposant "n"
		FONCTION puissance(a : réel, n : entier) : réel
			SI n ≥ 0 ALORS
				resultat : réel := 1
				i : entier
				POUR i:=1 JUSQU'A n PAS DE 1
					resultat := resultat x a
				FIN POUR
				RETOURNER resultat;
			SINON
				RETOURNER 1 / puissance(a, -n)
			FIN SI
		FIN FONCTION
		// Tests
		ecrire("18^0 = " & puissance(18, 0))
		ecrire("5^2 = " & puissance(5, 2))
		ecrire("3^4 = " & puissance(3, 4))
		ecrire("4^-1 = " & puissance(4, -1))

Récupération d'une liste de nombres

On souhaite rédiger la fonction "nombres() : réel[]" qui :

Demande à l'utilisateur de saisir un nombre.
Demande à l'utilisateur s'il souhaite (oui/non) continuer à ajouter des nombres.
Retourne sous forme de tableau la liste des nombres saisis.


		// Récupère, affiche éventuellement et retourne une liste de nombres saisis. 
		function nombres(){
			var continuer = true;
			var nombres = [];
			while(continuer){
				var nombre = readNumber("Saisir un nombre :");
				nombres.push(nombre);
				continuer = readBoolean("Souhaitez-vous ajouter un autre nombre (oui/non) ?");
			}
			return nombres;
		}
		// Test
		var n = nombres();
		write("Nombres : ");
		writeLine(n);


		// Récupère, affiche éventuellement et retourne une liste de nombres saisis. 
		FONCTION nombres(afficher : booléen) : réel[]
			continuer : booléen := vrai
			nombres : réel[]
			TANTQUE continuer
				nombre : réel := lire("Saisir un nombre :")
				nombres[] = nombre
				continuer = lire("Souhaitez-vous ajouter un autre nombre (oui/non) ?")
			FIN TANTQUE
			RETOURNER nombres
		FIN FONCTION
		// Test
		n : réel[] := nombres()
		ecrire("Nombres :")
		ecrire(n)

Calcul de la moyenne de nombres

On souhaite rédiger la fonction "moyenne" qui calcule la moyenne des nombres (tableau de réels) passés en paramètre.

Pour tester cette fonction, on utilise la fonction "readNumbers" qui demande à l'utilisateur de saisir une liste de nombres puis la retourne sous forme de tableau de réels :


	var nombres;
	nombres = readNumbers("Nombre");


		// Calcule la moyenne des "nombres" (tableau) passés en paramètre
		function moyenne(nombres){
			var i;
			var n = nombres.length;
			var somme = 0;
			for(i=0; i<n; i=i+1){
				somme = somme + nombres[i];
			}
			return somme / n;
		}
		// Test
		var n = readNumbers("Nombre");
		write("Nombres : ");
		writeLine(n);
		var m = moyenne(n);
		writeLine("Moyenne : " + m);


		// Calcule la moyenne des "nombres" (tableau) passés en paramètre
		FONCTION moyenne(nombres : réel[]) : réel
			i : entier
			n : entier := taille(nombres)
			somme : réel := 0
			POUR i:=1 JUSQU'A n PAS DE 1
				somme := somme + nombres[i]
			FIN POUR
			RETOURNER somme / n
		FIN FONCTION
		// Test
		n : réel[] := readNumbers("Nombre")
		ecrire("Nombres : ")
		ecrire(n)
		m : réel := moyenne(n)
		ecrire("Moyenne : " + m)

Calcul d'une moyenne pondérée

On souhaite rédiger la fonction "moyenne" qui calcule la moyenne pondérée des notes et coefficients (tableaux de réels) passés en paramètres. On suppose que l'utilisateur a saisi le même nombre de notes et de coefficients.

Pour tester cette fonction, on utilise la fonction "readNumbers" décrite plus haut.


		// Calcule et retourne la moyenne pondérée des notes
		function moyenne(notes, coefficients){
			var i;
			var n = notes.length;
			var somme = 0;
			var ponderation = 0;
			for(i=0; i<n; i=i+1){
				somme = somme + notes[i] * coefficients[i];
				ponderation = ponderation + coefficients[i];
			}
			return somme / ponderation;
		}
		// Test
		var notes = readNumbers("Note");
		var coefs = readNumbers("Coefficient");
		var m = moyenne(notes, coefs);
		write("Notes : ");
		writeLine(notes);
		write("Coefficients : ");
		writeLine(coefs);
		writeLine("Moyenne : " + m);


		// Calcule et retourne la moyenne pondérée des notes
		FONCTION moyenne(nombres : réel[], coefficients : réel[]) : réel
			i : entier;
			n : entier := taille(notes)
			somme : réel := 0
			ponderation : réel := 0
			POUR i:=1 JUSQU'A n PAS DE 1
				somme := somme + notes[i] x coefficients[i]
				ponderation := ponderation + coefficients[i]
			FIN POUR
			RETOURNER somme / ponderation
		FIN FONCTION
		// Test
		notes : réel[] := lire("Note")
		coefs : réel[] := lire("Coefficient")
		m : réel := moyenne(notes, coefs)
		ecrire("Notes : ")
		ecrire(notes)
		ecrire("Coefficients : ")
		ecrire(coefs)
		ecrire("Moyenne : " & m)