CORRECTION DES EXERCICES
#include <stdio.h>;
void main(void)
{
float puiss,x,result;
printf("entrez x ");
scanf("%f",&x);
result=2 -5*x +(puiss=x*x) -3*(puiss*=x) +2*puiss*x;
printf("resultat : %f\n",result);
}
#include <stdio.h>
#include "base_tus.inc"
#define dim 10
void main(void)
{
int i,nb;
composante v,t[dim],moy=0;
init_tus(t,&nb,dim);
do
{
printf("entrez la %dieme note (fin si <0 ou >20) :",nb+1);
scanf("%f",&v);
if(v<0||v>20) break; /* on aurait pu le mettre dans la condition du while */
moy+=v;
}
while (!ajoute_val_tus(t,&nb,dim,v));
if(nb) moy/=nb;
printf("moyenne des %d notes : %5.2f\n",nb,moy);
for(i=0;i<nb;i++) printf("%2dieme valeur : %5.2f (ecart/moyenne %+5.2f)\n",i+1,t[i],t[i]-moy);
}
#include <stdio.h>
#include <conio.h>
#include "base_tus.inc"
#include "mani_tus.inc"
#define dim 10
void lecture(type_tus t,int *nb)
{
composante v;
do
{
printf("entrez la %dieme note (fin si <0 ou >20) :",(*nb)+1);
scanf("%f",&v);
if(v<0||v>20) break; /* on aurait pu le mettre dans la condition du while */
}
while (!ajoute_val_tus(t,nb,dim,v));
}
void main(void)
{
int nb;
composante t[dim];
char rep;
init_tus(t,&nb,dim);
lecture(t,&nb);
do
{
printf("0 fin, 1 affiche, 2 rot gauche, 3 rot droite, 4 suppr, 5 ins :");
rep=getche()-'0';
printf("\n");
switch (rep)
{
case 0:puts("au revoir");break;
case 1:affiche_tus(t,nb);break;
case 2:rot_gauche_tus(t,nb);break;
case 3:rot_droite_tus(t,nb);break;
case 4:{int pos;
printf("position de l'element a supprimer ? ");
scanf("%d",&pos);
suppr_tus(t,&nb,pos);
break;}
case 5:{int pos;composante v;
printf("position de l'element a inserer ? ");
scanf("%d",&pos);
printf("valeur a inserer ? ");
scanf("%f",&v);
insert_tus(t,&nb,dim,pos,v);
break;}
default:puts("code errone !");
}
}
while (rep);
}
#include <stdio.h>
#include <alloc.h>
#include <math.h> /* pour fabs */
#define composante float
typedef composante *mat_dyn;
#define adr_mrd(l,c,nbc) ((l)*(nbc)+(c))
mat_dyn alloc_mrd(int nbl,int nbc)
{return((mat_dyn)malloc(nbl*nbc*sizeof(composante)));}
void affiche_mrd(mat_dyn tab,int nblig, int nbcol)
{
int l,c;
printf("\n");
for(l=0;l<nblig;l++)
{
printf("|");
for(c=0;c<nbcol;c++)printf("%5.1f ",tab[adr_mrd(l,c,nbcol)]);
printf(" |\n");
}
}
void autom_3_3(mat_dyn *t,int*nblig, int *nbcol)
{
composante ex[][3]={{1,1,-2},{1,3,-4},{-1,-2,6}};
int l,c;
*nblig=*nbcol=3;
*t=alloc_mrd(*nblig,*nbcol);
for(l=0;l<*nblig;l++) for(c=0;c<*nbcol;c++)
(*t)[adr_mrd(l,c,*nbcol)]=ex[l][c];
}
void autom_3_1(mat_dyn *t,int*nblig, int *nbcol)
{
composante ex[]={2,6,-1};
int l,c;
*nblig=3;*nbcol=1;
*t=alloc_mrd(*nblig,*nbcol);
for(l=0;l<*nblig;l++) for(c=0;c<*nbcol;c++)
(*t)[adr_mrd(l,c,*nbcol)]=ex[l];
}
void gauss_triangulation(mat_dyn A,mat_dyn B, int N)
{
int ce,l,c,lpivot;
composante coef;
for(ce=0;ce<N-1;ce++) /* ce=colonne a effacer */
{
/* recherche du pivot le plus grand possible (dans les lignes qui restent)
*/
lpivot=ce;
for(l=ce+1;l<N;l++)
if(fabs(A[adr_mrd(l,ce,N)])>fabs(A[adr_mrd(lpivot,ce,N)])) lpivot=l;
/* echange de la ligne du pivot et de la ligne ce (ne pas oublier B)*/
for(c=ce;c<N;c++) /* tous les termes devant ce sont nuls */
{
coef=A[adr_mrd(ce,c,N)];
A[adr_mrd(ce,c,N)]=A[adr_mrd(lpivot,c,N)];
A[adr_mrd(lpivot,c,N)]=coef;
}
coef=B[ce];B[ce]=B[lpivot];B[lpivot]=coef;
for(l=ce+1;l<N;l++) /* pour chaque ligne au dessous */
{
coef=A[adr_mrd(l,ce,N)]/A[adr_mrd(ce,ce,N)];
A[adr_mrd(l,ce,N)]=0; /* normalement pas besoin de le calculer*/
for(c=ce+1;c<N;c++)
A[adr_mrd(l,c,N)]-=coef*A[adr_mrd(ce,c,N)];
B[l]-=coef*B[ce];
}
}
}
void gauss_resolution(mat_dyn A,mat_dyn B,mat_dyn X,int N)
/* on pourait rendre le resultat dans B (si l'utilisateur
desirait le garder, il lui suffit de le copier avant). Ceci
economise le tableau X et le tampon */
{
int l,c;
composante tampon;
for(l=N-1;l>=0;l--)
{
tampon=B[l];
for(c=l+1;c<N;c++) tampon-=A[adr_mrd(l,c,N)]*X[c];
X[l]=tampon/A[adr_mrd(l,l,N)];
}
}
void main(void)
{
int nblA,nblB,nbcA,nbcB;
mat_dyn A,B,X;
autom_3_3(&A,&nblA,&nbcA);
affiche_mrd(A,nblA,nbcA);
autom_3_1(&B,&nblB,&nbcB);
affiche_mrd(B,nblB,nbcB);
if(nblA!=nbcA){puts("erreur fatale : matrice A non carree");return;}
if(nblB!=nblB){puts("erreur fatale : nb lignes du second membre incompatibles"); return;}
if(nbcB!=1){puts("erreur fatale : le second membre doit avoir une seule colonne"); return;}
gauss_triangulation(A,B,nblA); /*nblA=nbcA=nblB*/
puts("resultat apres triangulation : ");
affiche_mrd(A,nblA,nbcA);
affiche_mrd(B,nblB,nbcB);
X=alloc_mrd(nblB,nbcB);
gauss_resolution(A,B,X,nblA);
puts("solution :");
affiche_mrd(X,nblB,1);
}
#include <stdio.h>
#include <alloc.h>
#include <string.h>
typedef char composante;
typedef composante *ligne;
/* ou composante ligne []*/
typedef ligne *mat_ttd;
/* ou ligne mat_ttd[] */
void affiche(mat_ttd tab,int nblig)
{
int l;
for(l=0;l<nblig;l++)printf("%s\n",tab[l]);
}
void lecture(mat_ttd *tdl,int *nblig)
{
/* on se limite a 100 lignes de 1000 caracteres, mais une
fois sorti de la fonction, seule la place necessaire est
reservee (variables locales). On supprime ces limites par
utilisation (toujours temporaire) de listes chaînees */
composante txt[1000];
ligne tab_de_lignes[100];
int longueur;
*nblig=0;
printf("entrez vos lignes (fin du texte par '@@@' en deb de ligne):\n");
do
{
gets(txt);
longueur=strlen(txt); /* \0 non compris */
if(!strcmp(txt,"@@@"))break;
tab_de_lignes[*nblig]=(ligne)malloc(longueur+1);
strcpy(tab_de_lignes[*nblig],txt);
(*nblig)++;
}
while (1);
*tdl=(mat_ttd)malloc((*nblig)*sizeof(ligne));
memcpy(*tdl,tab_de_lignes,(*nblig)*sizeof(ligne));
}
void tri_insertion(mat_ttd tab, int N)
{
int pt,dpg; /* position testee,dernier plus grand */
ligne tampon;
for(pt=1;pt<N;pt++)
{
dpg=pt-1;
tampon=tab[pt];
while(strcmp(tab[dpg],tampon)>0 && dpg>=0)
{tab[dpg+1]=tab[dpg];dpg--;}
tab[dpg+1]=tampon;
}
}
void main(void)
{
int nbl;
mat_ttd txt;
lecture(&txt,&nbl);
puts("avant tri :");
affiche(txt,nbl);
tri_insertion(txt,nbl);
puts("apres tri :");
affiche(txt,nbl);
}