Tp1

Ex1:
#include <iostream>
using namespace std;

int main(){
int a = 1;
int b = 2;
string nom;
cout<<"Entrez votre nom : “ ;
cin>>nom ;
cout<<"Bonjour "<<nom<<", a = "<<a<<" et b = "<<b<<endl;
return 0;
}

Ex2:
#include <iostream>
using namespace std;
int main()
{
int a, b;
cout << "Entrez deux nombres entiers: ";
cin >> a;
cin >> b;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}

Ex3:
#include <iostream>
using namespace std;

int main(){
int a, b, somme;
cout<<"Entrez deux nombres entiers: ";
cin>>a;
cin>>b;
somme = a + b;
 cout<<"La somme de "<<a<<" et "<<b<<" est "<<somme<<endl;
return 0;
}

Ex4:
#include <iostream>
using namespace std;

int main(){
string nom;
cout<<"Entrez votre nom : ";
cin>>nom;
cout<<"Bienvenue, "<<nom<<" !"<<endl;
return 0;
}

Ex5:
#include <iostream>
#include <cmath>
using namespace std;

int main(){
float a;
cout<<"Entrez un nombre à virgule flottante : ";
cin>>a;
cout<<"La racine carrée de "<<a<<" est "<<sqrt(a)<<endl;
return 0;
}

Tp2
Ex1:
#include <iostream>
using namespace std;

int main()
{
int N, somme = 0;
do
{
cout << "Entrez la taille du tableau (N <= 10): ";
cin >> N;
 } while (N > 10);

int Tab[10];
for (int i = 0; i < N; i++)
{
cout << "Entrez l'element " << i + 1 << " du tableau: ";
cin >> Tab[i];
somme += Tab[i];
}
cout << "La somme des elements du tableau est: " << somme << endl;
return 0;
}

Ex2:
#include <iostream>
using namespace std;

void permut(int *a, int *b)

{
int temp = *a;
*a = *b;
*b = temp;
}

void permut(int &a, int &b)

{
int temp = a;
a = b;
b = temp;
}

int main()
{
int a, b;
cout << "Entrez la valeur de a: ";
cin >> a;
cout << "Entrez la valeur de b: ";
cin >> b;
cout << "Avant permutation: a = " << a << " et b = " << b << endl;
permut(&a, &b);
cout << "Après permutation: a = " << a << " et b = " << b << endl;
permut(a, b);
cout << "Après permutation: a = " << a << " et b = " << b << endl;
return 0;
}
Ex3:
#include <iostream>
#include <cmath>
using namespace std;

struct Vecteur{
float x;
float y;
};

float prodScal(Vecteur v1, Vecteur v2){

return v1.x*v2.x+v1.y*v2.y;
}

int main(){
Vecteur v1, v2;
cout<<"Entrez les coordonnées du premier vecteur : ";
cin>>v1.x>>v1.y;
cout<<"Entrez les coordonnées du second vecteur : ";
cin>>v2.x>>v2.y;
cout<<"Le produit scalaire de ces deux vecteurs est : "<<prodScal(v1, v2)<<endl;
return 0;
}
Ex4:
#include <iostream>
#include <string>
using namespace std;

struct Personne{
string nom;
string prenom;
};

void lecturePers(Personne &p){

cout<<"Entrez le nom de la personne : ";
cin>>p.nom;
cout<<"Entrez le prénom de la personne : ";
cin>>p.prenom;
}

void affichePers(Personne p){

cout<<"Nom : "<<p.nom<<endl;
 cout<<"Prénom : "<<p.prenom<<endl;
}

int main(){
Personne p;
lecturePers(p);
affichePers(p);
return 0;
}

Tp3
Ex1:
#include <iostream>
using namespace std;
#define MAX_FACTEUR = 100;

void calculerFacteursPremiers(int nombre, int facteurs[], int& nombreDeFacteurs) {

nombreDeFacteurs = 0;
for (int i = 2; i <= nombre; i++) {
while (nombre % i == 0) {
facteurs[nombreDeFacteurs] = i;
nombreDeFacteurs++;
nombre /= i;
}
}
}

bool sontHomogenes(int N, int M) {

int facteursN[MAX_FACTEUR];
int facteursM[MAX_FACTEUR];
int nombreDeFacteursN, nombreDeFacteursM;

calculerFacteursPremiers(N, facteursN, nombreDeFacteursN);

calculerFacteursPremiers(M, facteursM, nombreDeFacteursM);

cout << "Les facteurs premiers de " << N << " sont : [“ ;
for (int i = 0; i < nombreDeFacteursN; i++) {
cout << facteursN[i];
if (i < nombreDeFacteursN - 1) {
cout << ", ";
}
}
 cout << "]\n";

cout << "Les facteurs premiers de " << M << " sont : [";
for (int i = 0; i < nombreDeFacteursM; i++) {
cout << facteursM[i];
if (i < nombreDeFacteursM - 1) {
cout << ", ";
}
}
cout << "]\n";

for (int i = 0; i < nombreDeFacteursN; i++) {

bool facteurTrouve = false;
for (int j = 0; j < nombreDeFacteursM; j++) {
if (facteursN[i] == facteursM[j]) {
facteurTrouve = true;
break;
}
}
if (!facteurTrouve) {
return false;
}
}

for (int i = 0; i < nombreDeFacteursM; i++) {

bool facteurTrouve = false;
for (int j = 0; j < nombreDeFacteursN; j++) {
if (facteursM[i] == facteursN[j]) {
facteurTrouve = true;
break;
}
}
if (!facteurTrouve) {
return false;
}
}
return true;
}

int main() {
int N, M;

cout << "Donner N : ";

cin >> N;
 cout << "Donner M : ";
cin >> M;

if (N <= 5 || M <= N) {
cerr << "Les valeurs saisies ne respectent pas les contraintes.\n";
return 1;
}

if (sontHomogenes(N, M)) {
cout << N << " et " << M << " sont homogènes.\n";
} else {
cout << N << " et " << M << " ne sont pas homogènes.\n";
}

return 0;
}

Ex2:
#include <iostream>
#include <list>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>

using namespace std;

void lire_liste(list<int>& L) {
int N;
cout << "Donner la taille de L : ";
cin >> N;
while (N < 1 || N > 50) {
cout << "La taille doit être comprise entre 1 et 50. Réessayez : ";
cin >> N;
}
L.resize(N);
}

void remplir_liste(list<int>& L) {
cout << "Entrez " << L.size() << " entiers positifs et distincts : ";
for (auto& x : L) {
cin >> x;
}
L.sort();
}

void afficher_sequence(const list<int>& L, int A) {

auto it = find(L.begin(), L.end(), A);
if (it == L.end()) {
cout << "Il n'y a pas de séquence de tête " << A << " dans L." << endl;
return;
}
int start_index = distance(L.begin(), it);
int length = 1;
while (++it != L.end() && *it == A + length) {
++length;
}
cout << "Il existe une séquence de tête " << A << " dans L, indice début = " << start_index <<
" et sa longueur = " << length << endl;
cout << "Le contenu de la séquence : [";
for (int i = 0; i < length; ++i) {
cout << A + i << (i == length - 1 ? "]\n" : ", ");
}
}

bool is_unitary_perfect(int x) {
vector<int> divisors;
for (int i = 1; i <= sqrt(x); ++i) {
if (x % i == 0) {
divisors.push_back(i);
if (i != x / i) {
divisors.push_back(x / i);
}
}
}
int sum = accumulate(divisors.begin(), divisors.end(), 0);
return sum == 2 * x;
}

void unitairement_parfait(const list<int>& L) {

cout << "Les nombres unitairement parfaits de L sont :\n";
for (auto x : L) {
if (is_unitary_perfect(x)) {
cout << x << endl;
}
}
}
int main() {
list<int> L;
lire_liste(L);
remplir_liste(L);
int A;
cout << "Donner un entier A : ";
cin >> A;
afficher_sequence(L, A);
unitairement_parfait(L);
return 0;
}

Tp4
Ex1:
#include <iostream>
using namespace std;
#define PI 3.14
class cercle
{
private:
float rayon, abscisse, ordonnee;
public: cercle(float r, float a, float o)
{
rayon = r;
abscisse = a;
ordonnee = o;
}
friend float perimetre(cercle c);
friend float air(cercle c);
friend void sortie(cercle c);
};
float perimetre(cercle c)
{
return 2*PI*c.rayon;
}

float air(cercle c)
{
return PI*c.rayon*c.rayon;
}

void sortie(cercle c)
{
cout<<"rayon = "<<c.rayon<<endl;
cout<<"abscisse = "<<c.abscisse<<endl;
cout<<"ordonnee = "<<c.ordonnee<<endl;
cout<<"perimetre = "<<perimetre(c)<<endl;
cout<<"air = "<<air(c)<<endl;
}

int main()
{
cercle c(2, 3, 4);
sortie(c);
return 0;
}

Ex2:
#include <iostream>
using namespace std;
#define PI 3.14
class cercle
{
private:
float rayon, abscisse, ordonnee;
public: cercle(float r, float a, float o)
{
rayon = r;
abscisse = a;
ordonnee = o;
}
friend float perimetre(cercle c);
friend float air(cercle c);
friend void sortie(cercle c);
};
float perimetre(cercle c)
{
return 2*PI*c.rayon;
}

float air(cercle c)
{
return PI*c.rayon*c.rayon;
}
void sortie(cercle c)
{
cout<<"rayon = "<<c.rayon<<endl;
cout<<"abscisse = "<<c.abscisse<<endl;
cout<<"ordonnee = "<<c.ordonnee<<endl;
cout<<"perimetre = "<<perimetre(c)<<endl;
cout<<"air = "<<air(c)<<endl;
}

int main()
{
cercle c(2, 3, 4);
sortie(c);
return 0;
}

Ex3:
#include <iostream>
using namespace std;
class Vecteur{
private:
int x, y,z;
public:
void affiche(Vecteur V){
cout<<"x = "<<V.x<<endl;
cout<<"y = "<<V.y<<endl;
cout<<"z = "<<V.z<<endl;
}
Vecteur(int a, int b, int c){
x = a;
y = b;
z = c;
}
Vecteur(){
x=0;
y=0;
z=0;
}
void homothetie(int k){
x = k*x;
y = k*y;
z = k*z;
}
int prod_scalaire(Vecteur V, Vecteur W){
 return V.x*W.x + V.y*W.y + V.z*W.z;
}
Vecteur somme_enligne(Vecteur V, Vecteur W){
return Vecteur(V.x+W.x, V.y+W.y, V.z+W.z);
}
friend Vecteur somme_independante(Vecteur V, Vecteur W);

};

Vecteur somme_independante(Vecteur V, Vecteur W){

return Vecteur(V.x+W.x, V.y+W.y, V.z+W.z);
}

int main(){
Vecteur V(1,2,3);
Vecteur W(4,5,6);
Vecteur X;
V.affiche(V);
W.affiche(W);
X.affiche(somme_independante(V,W));
X.affiche(X.somme_enligne(V,W));
X.affiche(X);
X.homothetie(2);
X.affiche(X);
return 0;
}

Tp6
Ex1:
#include <iostream>

using namespace std;

class PileEntier {
private:
int nelem;
int dim;
int* adr;

public:
PileEntier(int n) : nelem(0), dim(n), adr(new int[n]) {}

PileEntier() : nelem(0), dim(20), adr(new int[20]) {}

 PileEntier(const PileEntier& other) : nelem(other.nelem), dim(other.dim), adr(new
int[other.dim]) {
for (int i = 0; i < nelem; ++i) {
adr[i] = other.adr[i];
}
}

~PileEntier() {
delete[] adr;
}

void empiler(int p) {
if (!pleine()) {
adr[nelem++] = p;
} else {
cerr << "La pile est pleine, impossible d'ajouter un élément." << endl;
}
}

void depiler() {
if (!vide()) {
--nelem;
} else {
cerr << "La pile est vide, impossible de dépiler." << endl;
}
}

bool pleine() const {

return nelem == dim;
}

bool vide() const {

return nelem == 0;
}

int dernier() const {

if (!vide()) {
return adr[nelem - 1];
} else {
cerr << "La pile est vide." << endl;
return -1;
}
}
 void operator>(int& n) {
if (!vide()) {
n = dernier();
depiler();
} else {
cerr << "La pile est vide, impossible de récupérer une valeur." << endl;
}
}

void operator<(int n) {
if (!pleine()) {
empiler(n);
} else {
cerr << "La pile est pleine, impossible d'ajouter un élément." << endl;
}
}

friend void operator>(PileEntier& p, int& n);

friend void operator<(int n, PileEntier& p);
};

void operator>(PileEntier& p, int& n) {

p > n;
}

void operator<(int n, PileEntier& p) {

p < n;
}

int main() {
PileEntier a(10);
PileEntier b = a;

PileEntier* c = new PileEntier(5);

delete c;

return 0;
}

Ex2:
#include <iostream>

using namespace std;

class Compte {
private:
float solde;
static int numero;
const int cle;

public:
Compte(float solde = 0.0) : solde(solde), cle(numero++) {}
Compte(const Compte& other) : solde(other.solde), cle(numero++) {}

Compte& operator<<(float m) {
solde += m;
return *this;
}

Compte& operator>>(float m) {
if (solde >= m) {
solde -= m;
} else {
cerr << "Solde insuffisant pour effectuer le retrait." << endl;
}
return *this;
}

Compte& operator<<(const Compte& other) {

solde += other.solde;
return *this;
}

Compte& operator>>(const Compte& other) {

if (solde >= other.solde) {
solde -= other.solde;
} else {
cerr << "Solde insuffisant pour effectuer le retrait." << endl;
}
return *this;
}

void afficherSolde() const {

cout << "Solde du compte " << cle << " : " << solde << endl;
}
};
int Compte::numero = 1;

int main() {
Compte c1;
Compte c2(1000.0);

c1 << 500 << 200 << 300;

c2 >> 200 >> 400;
c1.afficherSolde();
c2.afficherSolde();

c1 << c2 << 1000;

c1.afficherSolde();
c2.afficherSolde();

return 0;
}

Ex3:
#include <iostream>
#include <cmath>

using namespace std;

class Vecteur {
protected:
double x, y;

public:
Vecteur(double x = 0.0, double y = 0.0) : x(x), y(y) {}

bool memeComposantes(const Vecteur& autre) {

return (x == autre.x) && (y == autre.y);
}

void vecteurNormeMin(const Vecteur& autre, Vecteur& resultat) {

double norme1 = sqrt(x * x + y * y);
double norme2 = sqrt(autre.x * autre.x + autre.y * autre.y);

if (norme1 < norme2) {

resultat = *this;
} else {
resultat = autre;
}
 }

void affiche() {
cout << "(" << x << ", " << y << ")" << endl;
}
};

class Vecteur3D : public Vecteur {

private:
double z;

public:
Vecteur3D(double x = 0.0, double y = 0.0, double z = 0.0) : Vecteur(x, y), z(z) {}

void affiche() {
cout << "(" << x << ", " << y << ", " << z << ")" << endl;
}
};

int main() {
Vecteur v1(1.0, 2.0);
Vecteur v2(3.0, 4.0);

cout << "Vecteur 1 : ";

v1.affiche();

cout << "Vecteur 2 : ";

v2.affiche();

if (v1.memeComposantes(v2)) {
cout << "Les vecteurs ont les mêmes composantes." << endl;
} else {
cout << "Les vecteurs n'ont pas les mêmes composantes." << endl;
}

Vecteur vecteurMin;
v1.vecteurNormeMin(v2, vecteurMin);

cout << "Le vecteur avec la plus petite norme est : ";
vecteurMin.affiche();

Vecteur3D v3d(1.0, 2.0, 3.0);

cout << "Vecteur 3D : ";

 v3d.affiche();

return 0;
}