________________________________________________________________

REMERCIEMENTS
Nous tenons à exprimer notre sincère gratitude à toutes les personnes qui
ont contribué à la réalisation de ce projet.

Tout d’abord, nous remercions le Dieu tout puissant, ainsi que le

professeur Cédric KABEYA TSHISEBA, et notre encadreuse MWIKA
BANZA pour leurs soutiens, leurs conseils précieux et leurs encadrements
tout au long de ce travail. Leurs disponibilités et leurs expertises ont été
déterminantes pour mener à bien notre projet.

Nous souhaitons également remercier nos camarades de classe pour leur

collaboration et les échanges enrichissants qui ont facilité notre réflexion.
Leur enthousiasme et leur esprit d’équipe ont grandement contribué à
l’avancement de notre travail.

Enfin, nous exprimons notre reconnaissance envers nos familles et amis

pour leur encouragement et leur compréhension durant cette période de
travail intense.

Merci à tous !

____________________________________________________

1
 INTRODUCTION GENERAL

Dans ce projet nous allons explorer la résolution d’un système d’équation

à trois inconnus en utilisant l’algorithme et le langage de programmation
en c.

Dans le domaine des mathématiques, les équations à trois inconnus

représentent un sujet fondamental qui trouve des applications variées dans
des domaines tels que l’ingénierie, l’économie et les sciences sociales.
Comprendre comment résoudre ces équations est essentiel pour modéliser
des situations complexes où plusieurs variables interagissent
simultanément.
Ce projet tutoré se propose d’explorer les différentes méthodes de
résolution des systèmes d’équations à trois inconnus, en mettant l’accent
sur les approches algébriques et graphiques. Nous aborderons les
techniques classiques telles que la substitution, l’élimination et
l’utilisation de matrices, tout en illustrant leur pertinence à travers des
exemples concrets.
L’objectif de notre étude est non seulement de maîtriser les outils
mathématiques nécessaires pour résoudre ces systèmes, mais aussi de
développer une compréhension approfondie de leur signification et de leur
utilisation dans des contextes réels. En fin de compte, nous espérons
démontrer que la résolution d’équations à trois inconnus est non
seulement une compétence mathématique essentielle, mais aussi une clé
pour comprendre et analyser des problèmes complexes du monde qui nous
entoure.

2
 CHAPITRE I. GENERALITE SUR LE SYSTÈME DE TROIS ÉQUATIONS A
TROIS INCONNUES

Le principe de résolution d’un système de trois équations à trois inconnues consiste à

former un système équivalent de trois équations dont deux ne contiennent que deux
inconnues. Exemple 1.
Résoudre :

2x − y − 3z = 1,
3x + 2y − 2z = − 4
− x − 4y + 6z = 22.

1.1. Méthode d’élimination par substitution.

Nous commençons par cette méthode parce qu’elle nous semble plus naturelle pour les
débutants. Mais nous conseillons d’utiliser, de préférence, la méthode d’élimination
par addition.
De la première équation, tirons l’expression de y en fonction de x et de z :

2x − 3z − 1 = y ou y = 2x − 3z − 1, et remplaçons y par cette

expression dans les deux autres équations. On obtient :

3x + 2(2x − 3z − 1) − 2z = − 4,
− x − 4(2x − 3z − 1) + 6z = 22 ;

Ou :

3x + 4x − 6z − 2 − 2z = − 4,
− x − 8x + 12z + 4 + 6z = 22 ;

Soit :

7x − 8z = − 4 + 2 = − 2,
− 9x + 18z = 22 − 4 = 18.

Cette dernière équation peut être simplifiée en divisant ses deux membres par 9. On est
donc ramené à résoudre le système :

2x − y − 3z = 1, 7x − 8z = − 2
− x + 2z = 2.

3
Entre les deux dernières équations, éliminons z par addition :

1 7x − 8z = − 2, 7x − 8z = −2
4 − x + 2z = 2 − 4x + 8z = 8
3x = 6

On en tire : x = 2.
L’équation : − x + 2z = 2 donne alors :
2z = 2 + x = 2 + 2 = 4, soit : z = 2.

L’équation :
2x − y − 3z = 1 ou y = 2x − 3z −
1, donne enfin : y = 4 − 6 − 1 = − 3.
Ne pas oublier de remplacer x, y, z, par : 2, − 3, 2 dans le système (I), pour vérifier.

1.2. Méthode d’élimination par addition.

Eliminons z par addition entre les deux dernières équations

3 3x + 2y − 2z = − 4, 9x + 6y − 6z = −12
1 − x − 4y + 6z = 22 − x − 4y + 6z = 22
8x + 2y = 10

Eliminons z par addition entre la première et la dernière équation.

2 2x − y − 3z = 1, 4x − 2y − 6z = 2
1 -x − 4y + 6z = 22 − x − 4y + 6z = 22
3x − 6y = 24
ou : x − 2y = 8

Résolvons le système :

8x + 2y = 10
+ x − 2y = 8.

En additionnant membre à membre, ces deux équations, on obtient : 9x = 18 ou x = 2.

L’équation : x − 2y = 8 donne alors :

1− 2y = 8 ou y = − 3.

Enfin une des équations du système (I), la première par exemple, donne la valeur de z :

4 + 3 − 3z = 1, z = 2.

4
Exemple 2. Résoudre :

3x − z + 2y= 4
3x + z− y= 9
2x − 3y = 2.

La dernière équation de ce système ne contenant pas x, le plus simple est d’éliminer x,

le plus simple est d’éliminer x par addition entre les deux premières équations :

− 3x + z − 2y = − 4
−1 3x − z + 2y = 4,
1 3x + z − y = 9 3x + z − y = 9
2z − 3y = 5

Cette équation est incompatible avec la troisième équation du système : 2z − 3y = 2.

Le système proposé est donc impossible.
On remarquera que, si la troisième équation du système était 2z − 3y = 5, le système
serait indéterminé.

1.3. Méthodes particulières.

Il existe d’autres méthodes pour résoudre un système d’équations. Un système peut

présenter des particularités qui permettent de le résoudre plus rapidement en
employant une méthode adaptée à ces particularités.
Dans l’un des exemples qui suivent, nous exposerons aussi une méthode générale, dite
de Bézout, qu’il peut être utile de connaître mais que nous ne conseillons pas
d’employer couramment. EXEMPLE 1. Résoudre :

𝑥 𝑦 𝑧
= =
3 4 5

− 2x − y + 3z = 3

On pourrait mettre un tel système sous la forme :

4x = 3y 4x − 3y = 0
5y = 4z ou 5y − 4z = 0
− 2x − y + 3z = 3 − 2x − y + 3z = 3.

Et le résoudre par la méthode générale.

Il est plus simple d’utiliser ce qu’on appelle une inconnue auxiliaire. Posons :

5
 3x =4y =5z =t.
On en tire : x = 3t, y = 4t,
z = 5t.
Reportons dans la dernière équation du système :
− 2. 3t − 4t + 3. 5t = 3,
Ou :
− 6t − 4t + 15t = 3,
soit :
5t = 3 et t= .
On en déduit les solutions du système :
x=3t , y=4t , z = 5t =3.

Une méthode plus élégante consisterait à utiliser une propriété des suites de rapports
égaux. On écrirait :

𝑥 𝑦 𝑧 −2𝑥−𝑦+3𝑧 3
= = = =
3 4 5 −2.3−4+3.5 5
EXEMPLE 2. Résoudre :

x + y = m,
y + z = p,
z + x = q.

Additionnons membre à membre les trois équations de ce système.

On obtient :

2(x + y + z) = m + p + q,

𝑚+𝑝+𝑞
Ou : x+ y+z = .
2

Remplaçant successivement dans cette équation : x + y par m, y + z par p z + x par q,

on obtient :
𝑚+𝑝+𝑞 𝑚+𝑝+𝑞 𝑝+𝑞−𝑚
m+ z = ou z= −m = ,
2 2 2

𝑚+𝑝+𝑞 𝑚+𝑝+𝑞 𝑚+𝑞−𝑝

x+p= ou x= −p = ,
2 2 2

𝑚+𝑝+𝑞 𝑚+𝑝+𝑞 𝑚+𝑝−𝑞

x+q= ou y= −q = .
2 2 2

6
 EXEMPLE 3.
1.4. Méthode de Bézout ou méthode des coefficients indéterminés.

Pour résoudre un système de trois équations à trois inconnues au lieu d’éliminer

d’abord une inconnue, pourquoi ne pas essayer d’en éliminer deux à la fois ? Telle est
l’idée de Bézout.
Prenons un système quelconque :

2x − y + 3z = − 2, (1)
x +2y − 4z = 4,
4x − 3y − 2z = 3.

Multiplions les deux membres de la première équation par un coefficient indéterminé

u, les deux membres de la deuxième par v, les deux membres de la troisième par w,
puis additionnons, membre à membre, les équations obtenues :

u 2x − y + 3z = − 2 2ux − uy + 3uz = − 2u,

v x + 2y − 4z = 4 vx + 2vy − 4uz = 4v, w 4x − 3y −
2z = 3 4wx − 3wy − 2wz = 3w.

(2u + v + 4w) x + (− u + 2v − 3w) y + (3u − 4v − 2w) z = − 2u + 4v + 3w. (II)

Cherchons à déterminer u, v, et w pour que cette équation ne contienne plus qu’une
inconnue, x par exemple, en posant :

− u + 2v − 3w = 0,
3u − 4v − 2w = 0.

On obtient un système de deux équations homogènes.

Un tel système, nous l’avons vu, possède une infinité de solutions. Une seule nous
suffit. Eliminons v entre ces deux équations :

2 − u + 2v − 3w = 0 − 2u + 4v − 6w = 0,
1 3u − 4v − 2w = 0 3u − 4v − 2w = 0,
u − 8w = 0.

On obtient : u = 8w, qui porté dans l’équation :

− u + 2v − 3w = 0,
Par exemple, donne :

7
 − 8w + 2v − 3w = 0,
soit :
2v = 11w.

Donnons à w une valeur arbitraire. Nous prendrons w = 2, pour avoir une solution en
nombres entiers, sous la forme la plus simple possible. On obtient :

v = 11 et u = 16.

Portons ces valeurs dans l’équation (II), on obtient :

(32 + 11 + 8) x = − 32 + 44 + 6,
ou :
51x = 18,
soit :
x= = ,

Pour éliminer x et y, de l’équation (II), il faut poser de même :

2u + v + 4w = 0,
− u + 2v − 3w = 0.

Eliminons u :
1 2u + v + 4w = 0 2u + v + 4w = 0,
2 − u + 2v − 3w = 0 − 2u + 4v − 6w = 0
5v − 2w = 0.

Eliminons v :
+2 2u + v + 4w = 0 4u + 2v + 8w = 0,
−1 − u + 2v − 3w = 0 u − 2v + 3w = 0
5u + 11w = 0.

On a donc : 5v = 2w et 5u = − 11w.
Prenons : w = 5, on aura :
v = 2, u = − 11, et
l’équation (II) donne :
(−33 − 8 − 10) z = + 22 + 8 + 15,
ou :
− 51z = 45, soit
: x=− =− .

On pourrait calculer de même y. Contentons-nous de remplacer x par et z par −

dans les équations du système (I), pour obtenir la valeur de y et vérifier. On obtient :
y= .

8
 CHAPITRE II : ALGORITHME

1.1. Définitions :
Un algorithme est une suite ordonnée d’instructions qui indique la démarche à suivre
pour résoudre une série de problèmes équivalents.
Algorithme : Description en langage naturel de la suite des actions effectuées par un
programme structuré. Un algorithme est écrit en utilisant un langage de description
d’algorithme (LDA). L’algorithme ne doit pas être confondu avec le programme
proprement dit (tel que Pascal, C, ..)
L’algorithmique s’intéresse à l’art de construire des algorithmes ainsi qu’à caractériser
leur validité, leur robustesse, leur réutilisabilité, leur complexité ou leur efficacité.
La validité d’un algorithme est son aptitude à réaliser exactement la tâche pour
laquelle il a été conçu.
La réutilisabilité d’un algorithme est son aptitude à être réutilisé pour résoudre des
taches équivalentes à celle pour laquelle il a été conçu.
La complexité d’un algorithme est le nombre d’instructions élémentaires à exécuter
pour réaliser la tâche pour laquelle il a été conçu.
L’efficacité d’un algorithme est son aptitude à utiliser de manière optimale les
ressources du matériel qui l’exécute.

1.2. Objectifs d’algorithme

Un algorithme sert à transmettre un savoir faire. Il décrit les étapes à suivre pour
réaliser un travail.
Il permet d’expliciter clairement les idées de solution d’un problème indépendamment
d’un langage de programmation.
L’utilisateur d’un algorithme n’aura qu’à suivre toutes les instructions, dans l’ordre
pour arriver au résultat que doit donner l’algorithme.

1.3. Les variables

Une variable est une entité qui contient une information, elle possède :
- Un nom, on parle d’identifiant,
- Une valeur,
- Un type qui caractérise l’ensemble des valeurs que peut prendre la variable.

L’ensemble des variables est stocké dans la mémoire de l’ordinateur.

●Type de variable

Entier : Il s’agit des variables destinées à contenir un nombre entier positif ou négatif.
Réel : Il s’agit des variables numériques qui ne sont pas des entiers, c’est-à-dire qui
comportent des décimales. Généralement un nombre réel est codé sur 4 octets.

9
 Booléen : Il est souvent nécessaire lorsque l’on écrit un programme d’introduire des
variables qui prennent les valeurs VRAI ou FAUX ou les valeurs OUI ou NON.
Caractère : Les variables de type caractères contiennent des caractères
alphanumériques ou numériques.
Chaîne : Pour manipuler des chaînes de caractères permettant de représenter des mots
ou des phrases.

1.4. Opérateur

Un opérateur est un symbole d’opération qui permet d’agir sur des variables ou de
faire des “calculs”.
Un opérateur peut être unaire ou binaire :

- Unaire s’il n’admet qu’un seul opérande, par exemple l’opérateur non.
- Binaire s’il admet deux opérandes, par exemple l’opérateur +
Un opérateur est associé à un type de donnée et ne peut être utilisé qu’avec des
variables, des constantes, ou des expressions de ce type ; Par exemple l’opérateur + ne
peut être utilisé qu’avec les types arithmétiques (naturel, entier et réel) ou (exclusif) le
type chaîne de caractères.
Un opérande est une entité (variable, constante ou expression) utilisée par un
opérateur.
Une expression est une combinaison d’opérateur(s) et d’opérande(s), elle est évaluée
durant l’exécution de l’algorithme, et possède une valeur (son interprétation) et un
type.

1.5. La structure répétitive

Un programme a presque toujours pour rôle de répéter une même action un certain
nombre de fois. Pour ce faire on utilise une structure permettant de dire « Exécute
telles actions jusqu’à ce que telle condition soit remplie ».

1.6. Algo : Résolution du système d’équation à trois inconnues

VARIABLE
. a1, b1, c1, d1
.a2, b2, c2, d2
.a3, b3, c3, d3
Chaine de caractère x, y, z réel
DEBUT
Ecrire (‘’Entrez les coefficients 1 (a1, b1, c1, d1)’’)
Lire (a1, b1, c1, d1)
Ecrire (‘’ Entrez les coefficients 2 (a2, b2, c2, d2)’’)
Lire (a2, b2, c2, d2)
Ecrire (‘’ Entrez les coefficients 3 (a3, b3, c3, d3)’’)
Lire (a3, b3, c3, d3)
Si D == 0
Ecrire (‘’ce système n’é pas de solution unique ‘’)
Sinon

10
 Calculons x, y, z
X=
Y=
Z=
Ecrire (‘’que le résultat de x, y, z est : résultat’’)
Finsi
Fin

11
 CHAPITRE III : LA PROGRAMMATION EN LANGAGE C

2.1. Introduction au langage C.

2.1.1. Historique et origines du langage C.

Le langage C a été développé au début des années 1970 par Dennis Ritchie aux
laboratoires Bell. Il est basé sur le langage B, qui était lui-même dérivé du langage
BCPL. C a été conçu pour écrire des systèmes d’exploitation, et il a été utilisé pour
développer UNIX, ce qui a grandement contribué à sa popularité.

2.1.2. Importance et utilisation du C dans le développement logiciel.

Le C est considéré comme un langage de « bas niveau » en raison de sa proximité avec
le matériel, tout en ayant des fonctionnalités de haut niveau. Il est largement utilisé
dans le développement de systèmes d’exploitation, de compilateurs et d’autres
logiciels critiques. De nombreux autres langages modernes, comme C++, Java et
Python, s’inspirent de la syntaxe et des concepts du C.

2.1.3. Comparaison avec d’autres langages.

- C vs C++ : Le C++ est une extension orientée objet du C. Alors que le C se concentre
sur la programmation procédurale, le C++ permet également la programmation
orientée objet.
- C vs Python : Python est souvent considéré comme plus facile à apprendre et à
utiliser grâce à sa syntaxe claire et ses bibliothèques riches. Cependant, le C offre une
meilleure performance et un contrôle plus fin sur les ressources système.
- C vs Java : Java est un langage orienté objet qui fonctionne sur une machine virtuelle
(JVM), ce qui le rend indépendant de la plateforme. En revanche, les programmes en
C sont compilés en code machine spécifique à l’architecture.

2.1.4. Exemples pratiques.

Pour rendre cette section plus interactive, tu pourrais inclure un petit exemple de
programme en C qui illustre la syntaxe basique :
#include <stdio.h>

Int main () {
Printf(« Bonjour, monde !\n ») ;
Return 0 ;
}

2. Installation et configuration de l’environnement de développement

2.1.5. Choix d’un compilateur

Pour programmer en C, tu auras besoin d’un compilateur. Voici quelques options
populaires :

- GCC (GNU Compiler Collection) : C’est l’un des compilateurs les plus utilisés pour
le langage C. Il est open source et disponible sur plusieurs plateformes.

12
- Clang : Un autre compilateur open source, connu pour sa rapidité et ses messages
d’erreur clairs. Il est souvent utilisé dans les projets de développement sur macOS.
- MinGW : Pour les utilisateurs de Windows, MinGW (Minimalist GNU for
Windows) fournit un environnement de compilation basé sur GCC.

2.1.6. Installation du compilateur

1. Sur Windows avec MinGW:

- Télécharge l’installateur MinGW depuis le site officiel.

- Pendant l’installation, sélectionne le composant « mingw32-base » pour installer le
compilateur de base.
- Ajoute le chemin `C:\MinGW\bin` à la variable d’environnement `PATH` pour
pouvoir utiliser GCC dans la ligne de commande.

2. Sur macOS avec Xcode :

- Installe Xcode depuis l’App Store.

- Une fois installé, ouvre le terminal et exécute la commande `xcode-select –install`
pour installer les outils en ligne de commande, y compris Clang.

3. Sur Linux :

- Ouvre un terminal et utilise la commande suivante selon ta distribution :

- Pour Ubuntu/Debian: `sudo apt install build-essential`
- Pour Fedora : `sudo dnf install gcc gcc-c++`
- Pour Arch Linux : `sudo pacman -S base-devel`

2.1.7. Choix d’un éditeur de code

Une fois ton compilateur installé, tu as besoin d’un éditeur de code pour écrire tes
programmes. Voici quelques options :

- Visual Studio Code : Un éditeur léger et extensible qui prend en charge une
multitude de langages et dispose de nombreux plugins utiles pour C.
- Code : Blocks : Un IDE simple et facile à utiliser spécifiquement conçu pour la
programmation en C/C++.
- Dev-C++ : Un autre IDE populaire qui est léger et facile à configurer pour les projets
C.

2.1.8. Configuration de l’environnement

Après avoir installé ton compilateur et ton éditeur :

2.1.8.1. Crée un nouveau projet ou fichier source dans ton éditeur.

2.1.8.2. Assure-toi que ton éditeur est configuré pour utiliser le bon
compilateur.

Par exemple, dans Visual Studio Code, tu peux installer l’extension « C/C++ »
pour bénéficier de fonctionnalités avancées comme l’auto complétion.

13
 2.1.8.3. Écris ton premier programme en C, par exemple :

#include <stdio.h>
Int main () {
Printf (« Bienvenue dans la programmation en C !\n ») ;
Return 0 ;
}

a. Syntaxe de base

La syntaxe du C est relativement simple, mais il y a quelques règles importantes à

connaître :
- Les lignes de code se terminent par un point-virgule (` ;`).
- Les commentaires : Utilise `//` pour un commentaire sur une seule ligne ou `/* … */`
pour un commentaire sur plusieurs lignes.
Exemple :
// Ceci est un commentaire
/*
Ceci est un commentaire
Sur plusieurs lignes
*/
b. Types de données

Le C propose plusieurs types de données de base :

- int : Pour les entiers (ex. : `int age = 25 ;`)
- float : Pour les nombres à virgule flottante (ex. : `float prix = 19.99 ;`)
- double : Pour des nombres à virgule flottante avec double précision (ex. : `double pi
= 3.14159 ;`)
- char : Pour les caractères uniques (ex. : `char lettre = ‘A’ ;`)

b. Variables

Les variables sont utilisées pour stocker des valeurs. Tu dois déclarer une variable
avant de l’utiliser :
Int nombre ; // Déclaration d’une variable
Nombre = 10 ; // Initialisation de la variable

c. Opérateurs

Le C propose plusieurs types d’opérateurs :

- Opérateurs arithmétiques : `+`, `-`, `*`, `/`, `%`
- Opérateurs relationnels : `==`, ` !=`, `<`, `>`, `<=`, `>=`
- Opérateurs logiques : `&&` (ET), `||` (OU), ` !` (NON)
Exemple d’utilisation :
If (nombre > 5) {
Printf (« Le nombre est supérieur à 5.\n ») ;
}
d. Structures de contrôle

Le langage C utilise des structures de contrôle pour gérer le flux du programme :

14
 1. Conditions (`if`, `else`):

If (age >= 18) {

Printf (« Vous êtes majeur.\n ») ;
} else {
Printf (« Vous êtes mineur.\n ») ;
}

2. Boucles (`for`, `while`):

- Boucle for
For (int i = 0; i < 10; i++) {
Printf (« %d\n », i) ;
}
- Boucle while :
Int i = 0;
While (i < 10) {
Printf(« %d\n », i) ;
I++ ;
}
e. Fonctions

Les fonctions permettent de structurer ton code et de le rendre réutilisable :

#include <stdio.h>
// Déclaration de la fonction
Void saluer () {
Printf (« Bonjour, monde !\n ») ;
}
Int main () {
Saluer () ; // Appel de la fonction
Return 0 ;
}

2.1.8.4. Gestion des tableaux et des chaînes de caractères

a. Tableaux

Les tableaux sont des structures de données qui te permettent de stocker plusieurs
valeurs du même type sous un seul nom. Voici comment les déclarer et les utiliser :
Déclaration d’un tableau :
Int nombres [5] ; // Déclare un tableau de 5 entiers
Initialisation d’un tableau :
Int nombres [5] = {1, 2, 3, 4, 5} ; // Initialisation avec des valeurs

Accès aux éléments :

Les éléments d’un tableau sont indexés à partir de 0. Pour accéder à un élément :
Printf (« %d\n », nombres [0]) ; // Affiche le premier élément (1)
Boucle sur un tableau :

15
 Tu peux utiliser une boucle pour parcourir tous les éléments d’un tableau :
For (int i = 0 ; i < 5 ; i++) {
Printf(« %d\n », nombres[i]) ;
}

b. Chaînes de caractères

Les chaînes de caractères en C sont des tableaux de caractères terminés par un

caractère nul (`’\0’`). Voici comment les utiliser :

Déclaration d’une chaîne :

Char nom [20] ; // Déclare un tableau pour une chaîne de 19 caractères + ‘\0’
Initialisation d’une chaîne :
Char nom [] = « Luzia » ; // Le compilateur détermine la taille automatiquement
Affichage d’une chaîne :
Pour afficher une chaîne, utilise `printf` avec le format `%s` :
Printf (« Bonjour, %s !\n », nom) ; // Affiche « Bonjour, Luzia ! »
Copie d’une chaîne :
Utilise la fonction `strcpy` pour copier une chaîne dans une autre :
#include <string.h>
Char source [] = « Bonjour »;
Char destination [20] ;
Strcpy (destination, source) ; // Copie « Bonjour » dans destination
Longueur d’une chaîne :
Pour obtenir la longueur d’une chaîne, utilise `strlen` :
Int longueur = strlen(nom) ; // Calcule la longueur de la chaîne nom
Printf(« La longueur du nom est : %d\n », longueur) ;

c. Manipulation avancée des chaînes

Il existe plusieurs fonctions utiles dans `<string.h>` pour manipuler les chaînes :
- Concaténation (`strcat`) :
Char nom1 [20] = « Junior » ;

2.1.8.5. Gestion de la mémoire et pointeurs

a. Pointeurs

Les pointeurs sont des variables qui stockent l’adresse mémoire d’une autre variable.
Ils te permettent d’accéder directement à la mémoire, ce qui est très puissant en C.
Déclaration d’un pointeur :
Int p ; // Déclare un pointeur vers un entier
Initialisation d’un pointeur :
Pour initialiser un pointeur, tu dois lui assigner l’adresse d’une variable :
Int a = 10 ;
P = &a ; // p pointe vers a
Accès à la valeur pointée :
Pour accéder à la valeur stockée à l’adresse pointée par le pointeur, utilise l’opérateur
de déréférencement `` :
Printf (« %d\n », p) ; // Affiche 10

16
b. Allocation dynamique de mémoire

En C, tu peux allouer de la mémoire dynamiquement à l’aide des fonctions `malloc`,

`calloc`, `realloc` et `free`.
Allocation avec `malloc` :
Int tab = (int ) malloc(5 sizeof(int)) ; // Alloue un tableau de 5 entiers
If (tab == NULL) {
Printf (« Erreur d’allocation mémoire\n ») ;
}
Initialisation avec `calloc` :
`calloc` initialise la mémoire allouée à zéro :
Int tab = (int) calloc (5, sizeof (int)) ; // Alloue et initialise à zéro
Redimensionnement avec `realloc` :
Si tu veux redimensionner un bloc de mémoire déjà alloué :
Tab = (int) realloc (tab, 10 sizeof (int)) ; // Redimensionne le tableau à 10 entiers
Libération de la mémoire avec `free` :
N’oublie pas de libérer la mémoire lorsque tu n’en as plus besoin pour éviter les fuites
de mémoire :
Free (tab) ; // Libère la mémoire allouée pour tab

c. Pointeurs et tableaux

Les tableaux et les pointeurs sont étroitement liés en C. En fait, le nom d’un tableau est
considéré comme un pointeur vers le premier élément du tableau.
Accès aux éléments du tableau via un pointeur :
Int nombres [5] = {1, 2, 3, 4, 5} ;
Strcpy (p1.nom, « Alice ») ; // Assigne « Alice » au membre nom
P1.age = 30 ; // Assigne 30 au membre âge
Printf (« Nom : %s, Age : %d\n », p1.nom, p1.age) ; // Affiche les informations

d. Pointeurs vers des structures

Tu peux également utiliser des pointeurs pour accéder aux membres d’une structure.
Utilise l’opérateur `->` :

e. Lecture à partir d’un fichier

Pour lire à partir d’un fichier, utilise `fscanf` ou `fgets` :

Char buffer [100] ;
Fgets (buffer, sizeof (buffer), fichier) ; // Lit une ligne depuis le fichier
Printf (« %s », buffer) ; // Affiche la ligne lue

Int nombre ;
Fscanf (fichier, « %d », &nombre) ;
// Lit un entier depuis le fichier
Printf (« %d\n », nombre) ;
// Affiche l’entier l

17
f. Fermeture d’un fichier

N’oublie pas de fermer le fichier lorsque tu as terminé avec lui :

Fclose (fichier) ;
// Ferme le fichier ouvert

Les pointeurs sont des variables qui stockent l’adresse d’une autre variable. Ils sont
puissants et permettent une manipulation efficace de la mémoire.

a. Déclaration et initialisation d’un pointeur

Pour déclarer un pointeur, utilise l’astérisque (``) :

Int a = 10 ;
// Une variable entière
Int p ;
// Déclaration d’un pointeur vers une int
P = &a ;
// Initialisation du pointeur avec l’adresse de a

b. Accès à la valeur pointée

Pour accéder à la valeur pointée par un pointeur, utilise l’opérateur de déréférencement

(``) :
Printf(« La valeur de a est : %d\n », p) ;
// Affiche 10

c. Pointeurs et tableaux

Les pointeurs sont étroitement liés aux tableaux. Le nom d’un tableau est en fait un
pointeur vers son premier élément.
Int tab [3] = {1, 2, 3} ;
Int ptr = tab ;
// ptr pointe vers le premier élément du tableau
Printf (« %d\n », (ptr + 1)) ;
// Affiche 2 (deuxième élément)

2.1.8.6. Mémoire dynamique

La mémoire dynamique te permet d’allouer et de libérer de la mémoire à la volée

pendant l’exécution de ton programme.

c. Libération de la mémoire

N’oublie pas de libérer la mémoire que tu as allouée pour éviter les fuites mémoires :
Free (tableau) ;
// Libère la mémoire allouée

18
 2.1.8.7. Fonctions

Les fonctions te permettent d’organiser ton code en blocs réutilisables.

a. Déclaration et définition d’une fonction

Voici comment déclarer une fonction :

Int addition (int x, int y) ;
// Déclaration
Et voici sa définition :
Int addition (int x, int y) {
Return x + y ;
}

b. Appel d’une fonction

Pour appeler une fonction, fais simplement :

Int résultat = addition (5, 3) ;
// Appelle la fonction addition avec 5 et 3
Printf (« Le résultat est : %d\n », résultat) ;
// Affiche le résultat

c. Fonctions avec des pointeurs

Tu peux également passer des pointeurs à des fonctions pour modifier des variables :
Void incrémenter (int n) {
(n)++ ;
// Incrémente la valeur pointée par n
}
Int main () {
Int nombre = 5 ;
Incrementer(&nombre) ;
// Passe l’adresse de nombre à la fonction
Printf (« Nombre après incrémentation : %d\n », nombre) ; // Affiche 6
}
Les pointeurs te donnent un contrôle fin sur la mémoire, ce qui est crucial pour écrire
des programmes efficaces en C. La gestion dynamique de la mémoire te permet de
gérer des structures de données flexibles, tandis que les fonctions facilitent
l’organisation et la réutilisation du code.

La gestion des fichiers en C te permet de lire et d’écrire des données sur le disque.

Utilise `fopen` pour ouvrir un fichier :

FILE fichier = fopen (« mon_fichier.txt », « w ») ;
// Ouvre un fichier en écriture
If (fichier == NULL) {
Printf (« Erreur à l’ouverture du fichier\n ») ;

19
}

While (fgets (ligne, sizeof(ligne), fichierLecture)) {

Printf (« %s », ligne) ; // Affiche chaque ligne lue
}
Fclose (fichierLecture) ;
} else {
Printf (« Erreur à l’ouverture du fichier pour lecture\n ») ;
}

2.1.8.8. Gestion des erreurs

La gestion des erreurs est cruciale pour écrire des programmes fiables.

a. Vérification des erreurs

Il est important de vérifier si les opérations réussissent, par exemple lors de

l’allocation mémoire ou de l’ouverture de fichiers.
Int tableau = (int) malloc (5 sizeof(int)) ;
If (tableau == NULL) {
Fprintf (stderr, « Échec de l’allocation mémoire\n ») ;
Return 1 ; // Sortie du programme avec un code d’erreur
}

b. Utilisation d’errno

La variable `errno` peut être utilisée pour obtenir plus d’informations sur les erreurs
système.
#include <errno.h>
#include <string.h>
FILE fichier = fopen (« inexistant.txt », « r ») ;
If (fichier == NULL) {
Printf (« Erreur : %s\n », strerror (errno)) ; // Affiche le message d’erreur
correspondant
}
Conclusion sur les structures, les fichiers et la gestion des erreurs
Les structures te permettent de gérer des données complexes de manière organisée,
tandis que la gestion des fichiers facilite la persistance des données. La gestion
appropriée des erreurs est essentielle pour garantir que ton programme fonctionne
correctement dans différents scénarios.

2.1.8.9. Préprocesseurs

Les préprocesseurs sont des directives qui sont traitées avant la compilation du code
source.

a. Inclusion de fichiers

Utilise `#include` pour inclure des bibliothèques standard ou des fichiers que tu as
créés :
#include <stdio.h>

20
#include <stdlib.h>
#include « mon_fichier.h »

b. Définitions de macros

Les macros te permettent de définir des constantes ou des fonctions simples :

#define PI 3.14
#define CARRE(x) ((x) (x))
Int main () {
Printf (« La valeur de PI est : %.2f\n », PI) ;
Printf (« Le carré de 5 est : %d\n », CARRE(5)) ; // Affiche 25
}

c. Directives conditionnelles

Tu peux utiliser des directives conditionnelles pour inclure ou exclure du code en

fonction de certaines conditions :
#ifdef DEBUG
Printf(« Mode débogage activé\n ») ;
#endif
Les structures sont essentielles pour organiser les données complexes, tandis que la
gestion des fichiers te permet de sauvegarder et de récupérer des informations. Les
préprocesseurs offrent une flexibilité supplémentaire dans ton code.

2.1.9. Le code du projet en langage c qui traite le système de trois équations a

trois inconnues

EXPLICATION DU PROGRAMME

1. Saisie des coefficients :

Le programme demande à l’utilisateur d’entrer les coefficients des trois équations.
2. Calcul de déterminant :
Le déterminant est calculé à l’aide des formules standards pour un système de trois
équations.
3. Vérification du déterminant :
Si le déterminant est égale à zéro, le programme indique qu’il n’y pas de solution
unique et termine.
4. Calcul des solutions :
Si le déterminant est non nul, le programme calcule les valeurs de x, y, et z à l’aide des
formules dérivées.
5. Affichage des résultats :
Les solutions sont affichées avec une précision de deux décimales.

#include <stdio.h>

int main() {
// Coefficients des équations
double a1, b1, c1, d1;

21
 double a2, b2, c2, d2;
double a3, b3, c3, d3;

// Variables pour les solutions

double x, y, z;

// Lecture des coefficients

printf("Entrez les coefficients de la première équation (a1, b1, c1,
d1) : ");
scanf("%lf %lf %lf %lf", &a1, &b1, &c1, &d1);

printf("Entrez les coefficients de la deuxième équation (a2, b2, c2,

d2) : ");
scanf("%lf %lf %lf %lf", &a2, &b2, &c2, &d2);

printf("Entrez les coefficients de la troisième équation (a3, b3,

c3, d3) : ");
scanf("%lf %lf %lf %lf", &a3, &b3, &c3, &d3);

// Méthode d'élimination pour résoudre les équations

// On élimine z de la première et deuxième équation

double det = a1 * (b2 * c3 - b3 * c2) - b1 * (a2 * c3 - a3 * c2) +

c1 * (a2 * b3 - a3 * b2);

if (det == 0) {
printf("Le système n'a pas de solution unique (il pourrait être
incompatible ou avoir une infinité de solutions).\n");
return 1;
}

// Calcul de x, y, z
x = (d1 * (b2 * c3 - b3 * c2) - b1 * (d2 * c3 - d3 * c2) + c1 * (d2
* b3 - d3 * b2)) / det;
y = (a1 * (d2 * c3 - d3 * c2) - d1 * (a2 * c3 - a3 * c2) + c1 * (a2
* d3 - a3 * d2)) / det;
z = (a1 * (b2 * d3 - b3 * d2) - b1 * (a2 * d3 - a3 * d2) + d1 * (a2
* b3 - a3 * b2)) / det;

// Affichage des résultats

printf("Les solutions du système d'équations sont :\n");
printf("x = %.2lf\n", x);
printf("y = %.2lf\n", y);
printf("z = %.2lf\n", z);

return 0;
}

22
 CONCLUSION

En conclusion, ce travail tutoré sur le développement d’un programme

algorithmique en langage C qui un problème d’équation a trois inconnues
nous a permis d’approfondir nos connaissances dans l’un des langages les
plus fondamentaux et influents du domaine de l’informatique. Nous avons
exploré les concepts clés tels que les structures de contrôle, les fonctions,
les tableaux et la gestion de la mémoire, qui sont essentiels pour écrire des
programmes efficaces et performants.
Au cours de notre étude, nous avons également mis en lumière
l’importance de la syntaxe et des conventions du langage C, ainsi que son
rôle dans le développement de systèmes d’exploitation, de logiciels
embarqués et d’applications à hautes performances. Grâce à des exercices
pratiques et à des projets concrets, nous avons pu développer des
compétences en débogage et en optimisation de code, renforçant ainsi
notre capacité à résoudre des problèmes complexes.
Enfin, ce travail souligne que la maîtrise du langage C est non seulement
un atout pour les développeurs, mais aussi une base solide pour apprendre
d’autres langages de programmation. Nous espérons que nos conclusions
pourront encourager d’autres étudiants à s’engager dans l’apprentissage
du C et à apprécier ses applications variées dans le monde moderne.

23
 SUGGESTION

Résoudre un Système d’Équations à Trois Inconnues :

Approche et Méthodes
Lorsqu’on aborde les systèmes d’équations à trois inconnues, on se retrouve
face à un défi passionnant qui requiert une bonne compréhension des concepts
algébriques. Un système d’équations de ce type peut être représenté sous la
forme :
𝑎1 𝑥 + 𝑏1 𝑦 + 𝑐1 𝑧 = 𝑑1
𝑎2 𝑥 + 𝑏2 𝑦 + 𝑐2 𝑧 = 𝑑2
𝑎3 𝑥 + 𝑏3 𝑦 + 𝑐3 𝑧 = 𝑑3
Où 𝑥, 𝑦 et 𝑧 sont les inconnues que nous souhaitons déterminer, tandis que
𝑎𝑖 , 𝑏𝑖 , 𝑐𝑖 et 𝑑𝑖 sont des coefficients constants.
Méthodes de Résolution
1. Méthode de substitution :
- Choisissez une des équations et exprimez une inconnue en fonction des
autres.
- Substituez cette expression dans les deux autres équations.
- Répétez le processus jusqu’à ce que toutes les inconnues soient déterminées.
2. Méthode d’élimination :
- Additionnez ou soustrayez les équations pour éliminer une des inconnues.
- Cela donne un nouveau système de deux équations avec deux inconnues.
- Résolvez ce système et remontez pour trouver les autres inconnues.
3. Méthode matricielle :
- Représentez le système sous forme matricielle :
AX = B, où A est la matrice des coefficients, X est le vecteur des inconnues, et
B est le vecteur constant.
- Utilisez l’inverse de la matrice ou appliquez la méthode de Gauss pour
trouver la solution.
Applications
Les systèmes d’équations à trois inconnues sont largement utilisés dans divers
domaines comme l’économie, l’ingénierie et les sciences sociales, où plusieurs
facteurs interagissent simultanément. Par exemple, ils peuvent modéliser des
situations où trois produits doivent être fabriqués avec des ressources limitées.

24
 DIFFICULTES RENCONTREE

En travaillant sur un projet tutoré concernant les systèmes d’équations à trois

inconnues, voici quelques difficultés rencontrée des plus courantes :
1. Compréhension des Concepts de Base
- Notions d’algèbre : Entant qu’étudiants on avait des lacunes dans les concepts
fondamentaux d’algèbre, ce qui rend difficile la formulation et la résolution des
équations.
- Terminologie : La terminologie mathématique pouvait être déroutante pour
certains, en particulier pour ceux qui ne sont pas familiers avec les systèmes
d’équations.
2. Choix de la Méthode de Résolution
- Méthodes variées : Il existe plusieurs méthodes pour résoudre des systèmes
d’équations (substitution, élimination, méthode matricielle). Choisir la méthode la plus
appropriée c’était un défi.
- Complexité accrue : La difficulté à appliquer ces méthodes, surtout si le système
est mal conditionné ou si les coefficients sont complexes.
3. Gestion des Erreurs
- Erreurs de calcul : Les erreurs arithmétiques peuvent facilement se glisser dans les
calculs, surtout lorsqu’il s’agit de manipulations complexes.
- Interprétation des résultats : Une mauvaise interprétation des solutions obtenues
peut mener à des conclusions erronées.
4. Application Pratique
- Modélisation du problème : Traduire une situation réelle en un système d’équations
peut être difficile. Alors entant qu’étudiants nous devenons être capables d’identifier
les variables et de formuler correctement les équations.
- Contexte multidisciplinaire : Si le projet implique des applications dans des
domaines comme l’économie ou l’ingénierie, les étudiants peuvent rencontrer des
difficultés à relier les mathématiques à ces contextes pratiques.
5. Collaboration et Communication
- Travail en groupe : Travailler en équipe peut entraîner des désaccords sur la
manière d’aborder le projet ou sur les méthodes à utiliser.
- Présentation des résultats : Expliquer clairement les résultats et les méthodes
utilisées à un public non spécialisé c’était un défi.
6. Compréhension de la Syntaxe
- Syntaxe stricte : Le langage C a une syntaxe rigoureuse, et même une petite erreur
(comme un point-virgule manquant) peut entraîner des messages d’erreur déroutants.
- Déclaration des variables : La nécessité de déclarer les types de variables avant leur
utilisation peut être source de confusion pour ceux qui viennent d’un langage plus
flexible.
7. Débogage
- Difficulté à identifier les erreurs : Les erreurs en C peuvent être difficiles à déboguer,
surtout celles liées aux pointeurs ou à la gestion de la mémoire.
- Outils de débogage : L’utilisation d’outils comme `gdb` pour déboguer le code peut être
intimidante pour ceux qui ne sont pas familiers avec ces outils.
8. Contrôle des Flux
- Structures conditionnelles et boucles : La logique derrière les structures conditionnelles
(`if`, `switch`) et les boucles (`for`, `while`) doit être bien comprise pour éviter les
comportements inattendus.

25
- Gestion des erreurs : Savoir comment gérer les erreurs et les exceptions dans le code
peut être un défi, car le C n’offre pas de mécanisme intégré pour cela.
9. Portabilité du Code
- Différences entre compilateurs : Les différences entre divers compilateurs peuvent
entraîner des problèmes de portabilité du code, ce qui nécessite une attention particulière
lors du développement.
- Normes du langage : S’assurer que le code respecte les normes ANSI C ou ISO C peut
également poser problème si les étudiants ne sont pas conscients des différences.

Pour surmonter ces difficultés, il est essentiel que les étudiants bénéficient d’un
accompagnement adéquat, tant sur le plan théorique que pratique. Des séances de
tutorat, des exercices pratiques et une bonne communication au sein du groupe
peuvent grandement faciliter la compréhension et la résolution des systèmes
d’équations à trois inconnues ainsi que du langage C dans le cadre d’un projet tutoré.

26
 TABLE DES MATIERES

Remerciement …………………………………………………………………………… 1
Introduction Générale …………………………………………………………………………. 2

Chapitre 1 : Généralité sur Système de trois équations a trois inconnues ……...………… 3

1.1. Méthode d’élimination par substitution. ……………………………………. 3

1.2. Méthode d’élimination par addition. ………………………………………... 4
1.3. Méthodes particulières. ……………………………………………………… 5
1.4. Méthode de Bézout ou méthode des coefficients indéterminés. …………………………….. 7

Chapitre 2 : Algorithme ……………………………………………………………………... 9

2.1. Définition.……………………………………………………………………….... 9
2.2. Objectifs d’algorithme …………………………………………………………... 9
2.3. Les variables .......................................................................................................... 9
2.4. Opérateur ………………………………………………………………………… 10
2.5. La structure répétitive ……………………………………………………………. 10
2.6. Algo : résolution du système d’équation à trois inconnues ……………………… 10

Chapitre 3 : La programmation en langage c ………………………………............................ 11

3.1. Introduction au langage C. ………………….…………………………………… 11

3.1.1. Historique et origines du langage C. ……………………………………………… 11
3.1.2. Importance et utilisation du C dans le développement logiciel. ………………….. 11
3.1.3. Comparaison avec d’autres langages. …………………………………………….. 11
3.1.4. Exemples pratiques……………………………………………………………....... 11
3.1.5. Choix d’un compilateur …………………………………………………………… 11
3.1.6. Installation du compilateur ……………………………………………………....... 12
3.1.7. Choix d’un éditeur de code ……………………………………………………...... 12
3.1.8. Configuration de l’environnement ………………………………………………… 12

3.1.8.1. Crée un nouveau projet ou fichier source dans ton éditeur. ……………….. 12
3.1.8.2. Assure-toi que ton éditeur est configuré pour utiliser le bon compilateur…. 12
3.1.8.3. Écris ton premier programme en C, par exemple ………………………….. 12
3.1.8.4. Gestion des tableaux et des chaînes de caractères …………………………. 14
3.1.8.5. Gestion de la mémoire et pointeurs ………………………………………... 15
3.1.8.6. Mémoire dynamique ……………………………………………………….. 17
3.1.8.7. Fonctions…………………………………………………………………… 18
3.1.8.8. Gestion des erreurs…………………………………………………...... 19
3.1.8.9. Préprocesseurs……………………………………………………………… 19

3.1.9. Le code du projet en langage c qui traite le système de trois équations a trois
inconnues. ………………………………………………………………………. 20

CONCLUSION …………………………………………………………………... 22
SUGGESTION ………………………………………………………………….... 24
DIFFICULTES RENCONTREE …………………………………………………. 25

27