Algorithmique et Programmation 2

MIP S3 : 2017-2018
Pr. G. Mangoub

Correction de la série d’exercice 4 printf("Voici votre vecteur W \n");

affiche_vect(2*N,W);

EX1 prod_mat_vect(N,W,AW,A);
printf("Voici votre vecteur Aw produit de A avec W\n");

//mainEX1_S4.C affiche_vect(2*N,AW);

#include"M1_EX1_S4.h" system("PAUSE");

#include"M2_EX1_S4.h" return(0);

#include"M3_EX1_S4.h" }

#include"M4_EX1_S4.h" //M1_EX1.h
#include<stdlib.h> void lect_vect(int N,int T[]);

#include<stdio.h> void lect_mat(int N,int A[][2*N]);

int main()
{int N=2; //M1_EX1_S4.c
int T[N],V[N]; #include"M1_EX1_S4.h"

int W[2*N],AW[2*N]; #include<stdlib.h>

int A[2*N][2*N]; #include<stdio.h>

printf("lecture du vecteur T\n"); void lect_vect(int N,int T[])

lect_vect(N,T); {int I;

printf("lecture du vecteur V\n"); for(I=0;I<N;I++)

lect_vect(N,V); {printf("donner l elt %d \n",I);

printf("Voici votre vecteur T que vous avez saisi\n"); scanf("%d",&T[I]);

affiche_vect(N,T); }

printf("Voici votre vecteur V que vous avez saisi\n"); }

affiche_vect(N,V); void lect_mat(int N,int A[][2*N])

printf("lecture de la matrice A\n"); {int I,J;

lect_mat(N,A); for(I=0;I<2*N;I++)

printf("Voici votre matrice A\n"); for(J=0;J<2*N;J++)

affiche_mat(N,A); {printf("donner l elt %d%d \n",I,J);

class_crois(N,T); scanf("%d",&A[I][J]);

printf("Voici votre vecteur T par ordre croissant\n"); }

affiche_vect(N,T); }

class_decrois(N,V); //M4_EX1_S4.h
printf("Voici votre vecteur V par ordre decrois\n"); void affiche_vect(int N,int T[]);

affiche_vect(N,V); void affiche_mat(int N,int A[][2*N]);

regr_vect(N,T,V,W);
// M4_EX1_S4.c
#include"M4_EX1_S4.h"
 Algorithmique et Programmation 2
MIP S3 : 2017-2018
Pr. G. Mangoub

#include<stdlib.h> void regr_vect(int N,int T[],int V[],int W[])

#include<stdio.h> {int I;
void affiche_vect(int N,int T[]) for(I=0;I<N;I++)
{int I; W[I]=T[I];
for(I=0;I<N;I++) for(I=N;I<2*N;I++)
printf("%d |",T[I]); W[I]=V[I-N];
printf("\n"); }
} void prod_mat_vect(int N,int W[],int AW[],int A[][2*N])
void affiche_mat(int N,int A[][2*N]) {int I,J;
{int I,J; for(I=0;I<2*N;I++)
for(I=0;I<2*N;I++) {AW[I]=0;
{ for(J=0;J<2*N;J++)
for(J=0;J<2*N;J++)
printf("%d",A[I][J]); AW[I]=AW[I]+A[I][J]*W[J];
printf("\n"); }
} }
}
//M2_EX1_S4.h
//classement
void class_crois(int N,int T[]); EX2
void class_decrois(int N,int T[]); //mainEX2_S4.C
#include"M1_EX2_S4.h"
// M2_EX1_S4.c #include"M2_EX2_S4.h"
#include"M2_EX1_S4.h" #include<stdlib.h>
#include<stdio.h>
void class_crois(int N,int T[]) int main()
{int I,J,ECH; {
for(I=0;I<N-1;I++) int X,Y,N;
for(J=I+1;J<N;J++) printf("lecture de la dimension N\n");
if(T[I]>T[J]) N=lect_dim();
{ECH=T[I];T[I]=T[J];T[J]=ECH;} int T[N];
} printf("lecture du vecteur T\n");
void class_decrois(int N,int T[]) lect_vect(N,T);
{int I,J,ECH; printf("lecture des deux elements sur lesquels on fait le
for(I=0;I<N-1;I++) tassement\n");
for(J=I+1;J<N;J++) lect_NB(&X,&Y);
if(T[I]<T[J]) printf("Voici votre vecteur T que vous avez saisi\n");
{ECH=T[I];T[I]=T[J];T[J]=ECH;} affiche_vect(N,T);
} //tassement
//M3_EX1_S4.h tass_vect(&X,&Y,N,T);
void regr_vect(int N,int T[],int V[],int W[]); printf("Voici votre vecteur T apres tassement\n");
void prod_mat_vect(int N,int W[],int AW[],int A[][2*N]); affiche_vect(N,T);
system("PAUSE");
//M3_EX1_S4.c return(0);
#include"M3_EX1_S4.h" }
#include<stdlib.h> //M1_EX2_S4.h
#include<stdio.h> int lect_dim();
 Algorithmique et Programmation 2
MIP S3 : 2017-2018
Pr. G. Mangoub

void lect_vect(int N,int T[]); {ECH=T[I];

void lect_NB(int *X,int *Y); for(K=I;K>J;K--)
void affiche_vect(int N,int T[]); T[K]=T[K-1];
T[J]=ECH;
//M2_EX2_S4.h J=J+1;
void tass_vect(int *X,int *Y,int N,int T[]); }
}
//M1_EX2_S4.c }
#include"M1_EX2_S4.h"
#include<stdlib.h> EX3
#include<stdio.h> //mainEX3_S4.C
int lect_dim() #include"M1_EX3_S4.h"
{int N; #include"M2_EX3_S4.h"
printf("donner votre dimension N \n"); #include<stdlib.h>
scanf("%d",&N); #include<stdio.h>
return N; int main()
} {
void lect_vect(int N,int T[]) int X,Y,N,U0,U1;
{int I; printf("lecture de la dimension N\n");
for(I=0;I<N;I++) N=lect_N();
{printf("donner l elt %d \n",I); int U[N];
scanf("%d",&T[I]); printf("lecture des deux premiers termes U0 et U1\n");
} lect_U0_U1(&U0,&U1);
} U[0]=U0; U[1]=U1;
void lect_NB(int *X,int *Y) printf("calcul de tous les termes de U\n");
{ calcul_tab_U(N,U);
printf("donner les deux entiers que voulez mettre a la fin de T printf("Voici tous les termes de votre suite\n");
\n"); affiche_tab_U(N,U);
scanf("%d%d",X,Y); system("PAUSE");
} return(0);
void affiche_vect(int N,int T[]) }
{int I;
for(I=0;I<N;I++) //M1_EX3_S4.h
printf("%d |",T[I]); int lect_N();
printf("\n"); void lect_U0_U1(int *U0, int *U1);
} void affiche_tab_U(int N,int U[]);

//M2_EX2_S4.c //M2_EX3_S4.h
#include"M2_EX2_S4.h" void calcul_tab_U(int N,int U[]);
#include<stdlib.h> //M1_EX3_S4.c
#include<stdio.h> #include"M1_EX3_S4.h"
void tass_vect(int *X,int *Y,int N,int T[]) #include<stdlib.h>
{ #include<stdio.h>
int I,K,L,ECH,J=0; int lect_N()
for(I=0;I<N;I++) {int N;
{ do
if((T[I]!=*X)&&(T[I]!=*Y)) {
 Algorithmique et Programmation 2
MIP S3 : 2017-2018
Pr. G. Mangoub

printf("donner votre dimension N >=2\n"); affiche_vect(N,W);

scanf("%d",&N); system("PAUSE");
}while(N<2); return(0);
return N; }
}
void lect_U0_U1(int *U0, int *U1) //M1_EX4_S4.h
{ int lect_dim();
printf("donner les deux premiers termes U0 et U1\n"); void lect_vect(int N,int T[]);
scanf("%d%d",U0,U1);
} //M2_EX4_S4.h
void affiche_tab_U(int N,int U[]) void prod_vect(int N,int T[],int V[],int W[]);
{int I;
for(I=0;I<N;I++) //M3_EX4_S4.h
printf("%d |",U[I]); void affiche_vect(int N,int T[]);
printf("\n");
} //M1_EX4_S4.c
#include"M1_EX4_S4.h"
//M2_EX3_S4.c #include<stdlib.h>
#include"M2_EX3_S4.h" #include<stdio.h>
#include<stdlib.h> int lect_dim()
#include<stdio.h> {int N;
void calcul_tab_U(int N,int U[]) printf("donner votre dimension N \n");
{int I; scanf("%d",&N);
for(I=2;I<N;I++) return N;
U[I]=U[I-1]+U[I-2]; }
} void lect_vect(int N,int T[])
{int I;
EX4 for(I=0;I<N;I++)
//mainEX4_S4.C {printf("donner l elt %d \n",I);
#include"M1_EX4_S4.h" scanf("%d",&T[I]);
#include"M2_EX4_S4.h" }
#include"M3_EX4_S4.h" }
#include<stdlib.h>
#include<stdio.h> //M2_EX4_S4.c
int main() #include"M2_EX4_S4.h"
{ #include<stdlib.h>
int N; #include<stdio.h>
printf("lecture de la dimension N\n"); void prod_vect(int N,int T[],int V[],int W[])
N=lect_dim(); {
int T[N],V[N],W[N]; int I;
printf("lecture du vecteur T\n"); for(I=0;I<N-2;I++)
lect_vect(N,T); W[I]=T[I+1]*V[I+2]-T[I+2]*V[I+1];
printf("lecture du vecteur V\n"); W[N-2]=T[N-1]*V[0]-T[0]*V[N-1];
lect_vect(N,V); W[N-1]=T[0]*V[1]-T[1]*V[0];
//calcul du produit vectoriel
prod_vect(N,T,V,W); }
printf("Voici votre vecteur W =TxV\n");
 Algorithmique et Programmation 2
MIP S3 : 2017-2018
Pr. G. Mangoub

//M3_EX4_S4.c det2=detB(B2);
#include"M3_EX4_S4.h" det3=detB(B3);
#include<stdlib.h> DET=A[0][0]*det1-A[1][0]*det2+A[2][0]*det3;
#include<stdio.h> printf("determinant de A=%d\n",DET);
}
void affiche_vect(int N,int T[]) void lectureA(int A[N][N])
{int I; {int I,J;
for(I=0;I<N;I++) for( I=0;I<N;I++)
printf("%d |",T[I]); for( J=0;J<N;J++)
printf("\n"); { printf("donner A[%d,%d]\n",I,J);
} scanf("%d",&A[I][J]);
}
//EX5_S4.c }
//Un premier programme qui calcule le déterminent d’une int detB(int B[M][M])
matrice 3*3 {return(B[0][0]*B[1][1]-B[1][0]*B[0][1]);
//d’une façon très élémentaire }

#include<stdlib.h> //EX5_S4.c
#include <stdio.h> //Un deuxième programme qui calcule l’inverse d’une matrice
//calcul du determinant d'une matrice(3,3) en passant avant
const int N=3;const int M=2; //par le calcul du déterminant
void lectureA(int A[N][N]); // valable pour une dimension n quelconque
int detB(int B[M][M]);
int main() #include<stdio.h>
{int I,J,DET=0; #include<stdlib.h>
int det1,det2,det3; const int n=3;
int A[N][N]; void resolution(int A[n][n],int x[n],int b[n],int cst)
int B1[M][M],B2[M][M],B3[M][M]; { int i,j,k,io;
//lecture de A float eps;
lectureA(A); int s,coef,pmax,temp;
// on définit les matrices B1, B2 et B3
//matrice B1 eps=0.001;
B1[0][0]=A[1][1];
B1[0][1]=A[1][2]; for(i=0;i<n;i++)
B1[1][0]=A[2][1]; {
B1[1][1]=A[2][2]; if(i==cst) b[i]=1;
//matrice B2 else b[i]=0;
B2[0][0]=A[0][1]; }
B2[0][1]=A[0][2];
B2[1][0]=A[2][1]; //********Partie traitement*******
B2[1][1]=A[2][2]; for(k=0;k<n;k++)
//matrice B3 {
B3[0][0]=A[0][1]; pmax=abs(A[k][k]);
B3[0][1]=A[0][2]; if(pmax<eps)
B3[1][0]=A[1][1]; {
B3[1][1]=A[1][2]; printf("La matrice est non inversible\n");
det1=detB(B1); break;
 Algorithmique et Programmation 2
MIP S3 : 2017-2018
Pr. G. Mangoub

} { int cst,i,j,k,m;
else //printf("Donner la taille n=");
{ //scanf("%d",&n);
for(i=k+1;i<n;i++) int x[n],b[n];
{ int A[n][n],Ain[n][n];
if(pmax<A[i][k])
{ //La saisie de la matrice A
pmax=A[i][k]; for(i=0;i<n;i++)
io=i; { for(j=0;j<n;j++)
for(j=k;j<n;j++) {printf("donner A[%d][%d] \n",i,j);
{ scanf("%d",&A[i][j]);}
temp=A[k][j]; }
A[k][j]=A[io][j];
A[io][j]=temp; //TRAITEMENT
temp=b[k]; for(j=0;j<n;j++)
b[k]=b[io]; { cst=j;
b[io]=temp; resolution(A,x,b,cst);
} for(i=0;i<n;i++)
} Ain[i][j]=x[i];
} }
} printf("\n");

for(i=k+1;i<n;i++) //Compteur des lignes //Affichage de la matrice inverse

{ printf("La matrice inverse de A est:\n");
coef=A[i][k]/A[k][k]; //Les Gik for(i=0;i<n;i++)
for(j=k;j<n;j++) //Compteur des colonnes { for(j=0;j<n;j++)
{ printf("%d ",Ain[i][j]);
A[i][j]=A[i][j]-(coef*A[k][j]); printf("\n");
} }
b[i]=b[i]-(coef*b[k]); system("PAUSE");
} return 0;
} }
x[n-1]=b[n-1]/A[n-1][n-1];
for(i=n-2;i>=0;i--)
{
s=0;
for(j=i+1;j<n;j++)
{
s=s+(x[j]*A[i][j]);
}
x[i]=(b[i]-s)/A[i][i];
}
printf("\n");
printf("colonne %d de inv(A) :\n",cst);
for(i=0;i<n;i++) printf("%d |",x[i]);
}
int main()