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("résultat : %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 %dième 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("%2dième valeur : %5.2f (écart/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 %dième 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'élément à supprimer ? ");
scanf("%d",&pos);
suppr_tus(t,&nb,pos);
break;}
case 5:{int pos;composante v;
printf("position de l'élément à insérer ? ");
scanf("%d",&pos);
printf("valeur à insérer ? ");
scanf("%f",&v);
insert_tus(t,&nb,dim,pos,v);
break;}
default:puts("code erroné !");
}
}
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 à 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 résultat dans B (si l'utilisateur
désirait le garder, il lui suffit de le copier avant). Ceci
économise 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 carrée");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("résultat après 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 à 100 lignes de 1000 caractères, mais une
fois sorti de la fonction, seule la place nécessaire est
réservée (variables locales). On supprime ces limites par
utilisation (toujours temporaire) de listes chaînées */
composante txt[1000];
ligne tab_de_lignes[100];
int longueur;
*nblig=0;
printf("entrez vos lignes (fin du texte par '@@@' en déb 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 testée,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("après tri :");
affiche(txt,nbl);
}