Vous êtes sur la page 1sur 16

Réalisé par : TAHRI ILIAS

* Intelligence artificielle et Génie informatique *

I – Complexité Algorithmique :
 Méthode de dichotomie :
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main()
{
int i, debut=0 ,fin,n,milieu;
float v,A[50];
char* trouve;
printf("donnez le rang du tableau n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("donnez l'element A[%d]",i);
scanf("%f",&A[i]);
}
printf("donnez un nombre v ");
scanf("%f",&v);
fin=n-1;
trouve="false";
while ((trouve="false") && (debut<fin))
{
milieu=floor(debut+(fin-debut)/2);
if (A[milieu]==v)
{
trouve="true";
printf("votre nombre se trouve dans le tableau et a comme
indice %d",milieu);
}
else
{
if (v>=A[milieu])
{
debut=milieu+1;
if (A[debut]==v)
{
milieu=debut;
trouve="true";
printf("votre nombre se trouve dans le tableau et a
comme indice %d",milieu);
}
else
{
fin=milieu-1;
if (A[fin]==v)
{
milieu=fin;
trouve="true";
printf("votre nombre se trouve dans le tableau et
a comme indice %d",milieu);
}
}
}
}
if(debut>=fin)
printf("votre element ne se trouve pas dans le tableau ");

return 0;
}

 Tri a bulles :
#include <stdio.h>
#include <stdlib.h>

int main()
{
float A[100] ,c;
int n , i ,j;
printf("inserer la taille du tableau à trier :\n");
scanf("%d", &n);
printf("veuiller inserer les elements du tableau ");
for (i=0;i<n;i++)
{
scanf("%f",&A[i]);
}
for (i=0;i<n;i++)
{
printf("A[%d]=%f \n",i,A[i]);
}
for (i=0;i<n;i++)
{
for(j=n-1;j>i;j--)
{
if(A[j]<A[j-1])
{
c=A[j];
A[j]=A[j-1];
A[j-1]=c;
}

}
}
printf("le tableau apres le tri est : ");
for (i=0;i<n;i++)
{
printf("A[%d]=%f",i,A[i]);
printf("\n");
}

 Multiplication des matrices :


return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
int A[100][100] , B[100][100] , C[100][100] , n , i , j , k;
printf("inserez la taille de la matrice :");
scanf("%d" ,&n);
printf("remplissez la premiere matrice carree A et la ligne par ligne :
\n");
for(i=0 ;i<n ; i++)
for(j=0 ; j<n ; j++)
{
printf("A[%d][%d]=" , i , j);
scanf("%d" , &A[i][j]);
}
printf("remplissez la deuxieme matrice carree B ligne par ligne \n");
for(i=0 ;i<n ; i++)
for(j=0 ; j<n ; j++)
{
printf("B[%d][%d]=" , i , j);
scanf("%d" , &B[i][j]);
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
C[i][j]=0;
for(k=0;k<n;k++)
{
C[i][j]=C[i][j]+A[i][k]*B[k][j];
}
}
}
printf("le matrice C est :\n");
for(i=0;i<n;i++)
{
for (j=0;j<n;j++)
{
printf("C[%d][%d]=%d \n",i,j,C[i][j]);
}
}
return 0;

 Addition des matrices :


}
#include <stdio.h>
#include <stdlib.h>

int main()
{
int i,j,n;
float a[50][50],b[50][50],c[50][50];
printf("donnez le rang des matrices n ");
scanf("%d",&n);
for (i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("donnnez l'element a[%d][%d]",i,j);
scanf("%f",&a[i][j]);
printf("donnnez l'element b[%d][%d]",i,j);
scanf("%f",&b[i][j]);
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
c[i][j]= a[i][j]+b[i][j];
}

}
printf("la matrice somme c :");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("c[%d][%d] = %f",i,j,c[i][j] );
}

}
return 0;
}

 Le Factoriel :
#include <stdio.h>
#include <stdlib.h>

int main()
{
int i,j,n;
float a[50][50],b[50][50],c[50][50];
printf("donnez le rang des matrices n ");
scanf("%d",&n);
for (i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("donnnez l'element a[%d][%d]",i,j);
scanf("%f",&a[i][j]);
printf("donnnez l'element b[%d][%d]",i,j);
scanf("%f",&b[i][j]);
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
c[i][j]= a[i][j]+b[i][j];
}

}
printf("la matrice somme c :");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("c[%d][%d] = %f",i,j,c[i][j] );
}

}
return 0;
}

II – Structures :
 Structure de Fiche :
#include <stdio.h>
#include <stdlib.h>

typedef struct D
{
int day;
int month;
int year;
}Date;

typedef struct Fiche


{
char nom[20];
char Prenom[20];
char formation[20];
Date d;
int TD;
int N[50];
char v[3];
int max;
int nbnotes;
}Fiche;

int main()
{
Date a;
Fiche m;
Date saisie();
void affichage(Date m);
Fiche EcrireFiche();
void LireFiche(Fiche f);

a=saisie();
affichage(a);
m=EcrireFiche();
LireFiche(m);

return 0;
}
Date saisie()
{
Date D;
printf("Donnez le jour \n");
scanf("%d",&D.day);
printf("Donnez le mois\n");
scanf("%d",&D.month);
printf("Donnez l'annee\n");
scanf("%d",&D.year);
return D;

}
void affichage(Date m)
{
printf("%d -%d -%d",m.day,m.month,m.year);
}

Fiche EcrireFiche()
{
Fiche F;
int i;
printf("\nSaisir le nom\n");
scanf("%s",F.nom);
printf("Saisir le prénom\n");
scanf("%s",F.Prenom);
printf("Saisir la date de naissance\n");
scanf("%d %d %d",&F.d.day,&F.d.month,&F.d.year);
printf("Saisir la formation\n");
scanf("%s",F.formation);
printf("Saisir le groupe de TD\n");
scanf("%d",&F.TD);
printf("Saisir le maximum\n");
scanf("%d",&F.max);
for (i=0;i<F.max;i++)
{
printf("Saisir les notes\n");
scanf("%d",&F.N[i]);
}
printf("Saisir le nombre de notes valides\n");
scanf("%d",&F.nbnotes);
printf("Saisir s'il est redoublant ou non\n");
scanf("%s",F.v);
return F;

}
void LireFiche(Fiche f)
{

int i;
printf("Le nom est:%s\n",f.nom);
printf("Le prenom est: %s\n",f.Prenom);
printf("La date de naissance est %d %d %d
\n",f.d.day,f.d.month,f.d.year);
printf("La formation est %s\n",f.formation);
printf("Le grp de TD est %d \n",f.TD);
printf("Le max de notes est %d\n",f.max);
for (i=0;i<f.max;i++)
{
printf("%d\n",f.N[i]);
}
printf("Le nombre des note valides est %d\n",f.nbnotes);
printf("Redoublant: %s",f.v);

 Structure de Polynome :

#include <stdio.h>
#include <stdlib.h>
#include<math.h>
#define DGMAX 100
#define max 10
#define MAX(x, y) (x > y ? x : y)

typedef struct {
int degree ;
float coef[100];
} poly;
int main()
{
poly p,q,x;

poly lire_poly();
poly sommepoly(poly p ,poly q);
void afficher (poly p);
poly multiply(poly f,poly g);

p=lire_poly();
q=lire_poly();
x=multiply(p,q);

afficher(x);

return 0;
}
poly lire_poly()
{
poly p;
int i;
do {
printf("entrer le degre du polynome ");
scanf("%d", &p.degree);
if (p.degree+1<= 0)
printf("Invalide value assigend to n, try one more time");
} while (p.degree<= 0);

for(i=0;i<=p.degree;i++)
{
printf("entrer le coefficient de degre %d :",i);
scanf("%f",&p.coef[i]);

}
return p;

}
void afficher (poly p)
{
int i;
printf("le polynome est p(x)=");
for(i=p.degree;i>0;i--)
{
if(p.coef[i]==0)
continue;
printf("%2.1fx^%d ",p.coef[i],i);

printf("+");
}
printf("%2.1f",p.coef[0]);

}
poly sommepoly(poly p ,poly q)
{
poly x;
int i;

x.degree=MAX(p.degree,q.degree);
for(i=0;i<=x.degree;i++)

x.coef[i]=p.coef[i]+q.coef[i];

return x;
}
poly multiply(poly p1, poly p2)
{
poly p3;
p3.degree=p1.degree+p2.degree;
void init(poly p);

int i,j;
init(p3);
for(i=0;i<p3.degree;i++)
{
for(j=0;j<=i;j++)
p3.coef[i]=p3.coef[i]+p1.coef[j]*p2.coef[j-i];

}
return p3;
}
void init(poly p)
{
int i;
for(i=0;i<max;i++)
p.coef[i]=0;
}

 Structure du Rationnel :
#include <stdio.h>
typedef struct {
int num;
int denom;
} Rationnel;

Rationnel LireRationnel(char *str);


Rationnel Simplifie(Rationnel);
Rationnel SommeRationnel(Rationnel, Rationnel);
void AfficheRationnel(Rationnel);
int main(void) {
Rationnel a = LireRationnel("1ere"), b = LireRationnel("2eme");
Rationnel c = SommeRationnel(a, b);

printf("\nLa somme des deux rationnels est:\n\t\t");


AfficheRationnel(a);
printf("+ ");
AfficheRationnel(b);
printf("= ");
AfficheRationnel(c);

printf("\n\n");
return 0;
}
Rationnel SommeRationnel(Rationnel x, Rationnel y) {
Rationnel z = {x.num * y.denom + x.denom * y.num, x.denom * y.denom};
return Simplifie(z);
}
void AfficheRationnel(Rationnel x) {
printf("%d/%d ", x.num, x.denom);
}
Rationnel LireRationnel(char *str) {
Rationnel x;

printf("\nLire le %s rationnel :\n", str);

printf("\tEntrez le numerateur (une entier) :");


scanf("%d", &x.num);

do {
printf("\tEntrez le denominateur (une entier != 0) :");
scanf("%d", &x.denom);
if (x.denom == 0)
printf("\t\t <---- Le denominateur ( = %d) n'est pas valide ----> \n",
x.denom);
} while(x.denom == 0);

return Simplifie(x);
}
Rationnel Simplifie(Rationnel x) {
int diviseur=2;

while ((x.num >= diviseur) && (x.denom >= diviseur)) {


if ((x.num % diviseur == 0) && (x.denom % diviseur == 0)) {
x.num /= diviseur;
x.denom /= diviseur;
}
else
diviseur++;
}
return x;
}
III - Série de TD n˚8 : Listes chainées
Solution
Rappel sur les listes chainées :

1. Écrire une structure de données qui permet de représenter une liste chainée d’entiers
(Cette structure sera utilisée dans la suite de la série).
struct element {
int val;
element * suiv;
}
2. De quel autre manière plus lisible on pourrait écrire (*p).val ?
p->val
3. Quel valeur constante indique qu’un pointeur est vide (ou ne pointe vers aucune
adresse) ?
NULL ou 0
4. Comment s’appelle le premier élément d’une liste chainée ?
La tête
5. Comment s’appelle le dernier élément d’une liste chainée ?
La queue
6. Sachant qu’une liste chainée est identifiée par un pointeur tete qui contient l’adresse
de son premier élément, comment indiquer que cette liste est vide ?
tete = NULL //Affecter NULL à la tête de la liste.
7. Le dernier élément d’une liste chainée a une particularité, laquelle ?
Il pointe toujours sur NULL
8. Le parcours d’une liste chainée se fait-t-il généralement en utilisant une boucle
while ou une boucle for ? pourquoi ?
Une boucle while car on ignore combien d’éléments la liste contient.
9. Remplir ce tableau de comparaison entre les listes chainées et les tableaux.
Tableaux Listes chainées

Accès aux éléments (direct ou


direct séquentiel
séquentiel)

Taille constante variable

Insertion (par décalage ou par


décalage chainage
chainage)
Exercice 1
1. Écrire un programme qui créé la liste chainée representée dans la figure suivante :

#include <stdio.h>
#include <stdlib.h>
typedef struct tete tete;
struct tete{
element*first;
};
typedef struct element element;
struct element{
int nbr;
element*next;

};
void ajouterfin(tete*t,int n)
{
element*new=malloc(sizeof(*new));
element*actuel=t->first;
new->nbr=n;
new->next=NULL;
while(actuel->next!=NULL)
{
actuel=actuel->next;
}
actuel->next=new
}
int main()
{
tete*t=NULL;
ajouterfin(t,12);
ajouterfin(t,7);
ajouterfin(t,3);
ajouterfin(t,9) ;
return 0;
}

2. Ajouter au programme précédent les instructions qui permettent de créér et d’insé-


rer l’élément pointé par d, entre les éléments a et b comme representé dans la figure
suivante :

void ajoutermilieu(tete*t,element*a)
{
element*new=malloc(sizeof(*new));
new=t->first;
new->next=a->next;
a->next=new;
}

Exercice 2
4. Écrire une version récursive de la fonction afficher
void afficherREC(element*premier)
{
if(premier!=NULL)
{
printf("%d",premier->nbr);
afficherREC(premier->next);
}
}
5. Écrire une fonction compter qui retourne le nombre d’éléments d’une liste chainée
d’entiers.
int compter(tete*t)
{
int cp=0;
element*actuel=t->first;
if(actuel!=NULL)
{
while(actuel->next!=NULL)
{
cp++;
actuel=actuel->next;
}
}
return cp;
}
6. Écrire une fonction somme qui retourne la somme des éléments d’une liste chainée
d’entiers non vide.
int somme(tete*t)
{
int s=0;
element*actuel=t->first;
if(actuel!=NULL)
{
while(actuel->next!=NULL)
{
s+=actuel->nbr;
actuel=actuel->next;
}
return s;
}
}7. Écrire une fonction min qui retourne la valeur du plus petit élément d’une liste
chainée d’entiers non vide.
int min(tete*t)
{
element*actuel=t->first;
if(actuel!=NULL)
{
int min=t->first->nbr;
while(actuel->next!=NULL)
{
if(actuel->nbr<min)
{
min=actuel->nbr;
}
actuel=actuel->next;
}
return min;
}
}
8. Écrire une fonction existe qui teste si un élémént donné existe dans une liste
chainée d’entiers. La fonction doit retourner true si l’élément existe et false sinon.
bool exister(tete*t,int n)
{
element*actuel=t->first;
if(actuel!=NULL)
{
while(actuel->next!=NULL)
{
if(actuel->nbr==n)
break;
actuel=actuel->next;
}
if(actuel->next==NULL)
return false;
else
return true;
}
}

Vous aimerez peut-être aussi