Accéder au contenu principal

cour et solution sériel 1 pile file et liste

Représentation chainée d’une pile en C :
Cpile.h :
typedef int Element;
typedef struct cellule {Element valeur;
                                           struct cellule *suivant;
                                         } cellule;
typedef cellule *pile;
pile vide_pile ();
int pile_est_vide (pile p);
pile empiler (pile p, Element e);
pile depiler (pile p);
void afficher (pile p);
void menu ();

Cpile.cpp :
#include <stdio.h>
#include <stdlib.h>
#include "Cpile.h"

int main()
{             menu();
                 system("pause");
                 return 0;
}

pile vide_pile(){ return NULL;}

int pile_est_vide (pile p) {if (p==NULL) return 1;//1vide
                                                else return 0;//0non vide
                                                }

pile empiler (pile p, Element e) {cellule *q= (cellule *) malloc (sizeof (cellule));
                                                            q->valeur= e;
                                                            q->suivant= p;p=q;
                                                            return p; }

pile depiler (pile p) {if (p==NULL) printf ("erreur pile est deja vide");
                                      else {cellule *tempo=p;
                                                 p=p->suivant;
                                                 free(tempo);
                                                 return p; }
                                   }





void afficher (pile p) {cellule * tempo=p;
                                         if (p==NULL) {printf ("la pile est deja vide\n");exit (-1) ;}
                                         else {
                                           while (tempo!=NULL) {
                                           printf ("%d\n", tempo->valeur);
                                           tempo=tempo->suivant;
                                                                                        }
                                                 }
                                       }
void menu () {
                                pile p;//=NULL;
                               p=vide_pile ();
                                int i=1;
                                int choix;
                                Element e;
                                printf ("\tmenu\n");
                                printf ("1 empiler\n");
                                printf ("2 depiler\n");
                                printf ("3 afficher\n");
                                do
                             {printf ("votre choix\n");
                                 scanf ("%d", &choix);
                                  printf ("\n");
                              switch(choix){
                                                                               case 1: printf("entrez l'element\n");
                                                                              scanf("%d",&e);
                                                                              p=empiler(p,e);
                                                                               break;
                                                                              case 2: p=depiler(p);break;
                                                                              case 3: afficher(p);break;
                                                                              default : printf ("erreur choix introvable\n");break;
                                                          }
                               } while (choix!=0) ;
                             }







·    pour mieux comprendre  voir les exemple


Capture d’écran :
empiler:
depiler:









Représentation chainée d’une file en C :
Cfile.h :
typedef int elt_file;
typedef struct cellule{ elt_file valeur;
                                           struct cellule *nxt;
                                         } cellule;
typedef cellule *file;
file vide_file ();
int file_est_vide (file f);
file enfiler (file f, elt_file e);
file defiler (file f);
void afficher_file (file f);
void menu ();

Cfile.cpp :
#include <stdio.h>
#include <stdlib.h>
#include "Cfile.h"

int main()
                           {menu();
                               system("pause");
                               return 0;
                               }

file vide_file(){return NULL;}

int file_est_vide (file f) {if (f==NULL) return 1;//file vide
                                             else return 0;//file non vide
                                             }

file enfiler (file f, elt_file e) {
                                                               cellule *nf=(cellule *)malloc(sizeof(cellule));
                                                               nf->valeur= e;
                                                               nf->nxt= NULL;
                                                               if(file_est_vide(f)) return nf;
                                                               else{cellule *tempo=f;
                                                                        while(tempo->nxt!=NULL)
                                                                         {tempo=tempo->nxt;}
                                                                           tempo->nxt= nf;
                                                               return f;
                                                                 }
                                                 }






file defiler (file f) {if (file_est_vide(f)) {printf ("erreur file vide\n");exit (-1) ;}
                                 else{cellule *tempo=f;
                               f=f->nxt;
                               free(tempo);
                                return f;
                                 }
                               }


void afficher_file(file f)
                                   {if (file_est_vide(f)) {printf ("erreur file vide\n");}
                                      else{cellule *tempo=f;
                                      while (tempo!=NULL) {printf ("%d\n", tempo->valeur);
                                                                                   tempo=tempo->nxt;
                                                                                    }
                                               }
                                    }

void menu ()
{
                               file f;
                               f=vide_file ();
                               int i=1;
                               int choix;
                               elt_file e;
                               do
                               {printf("\tmenu\n");
                                printf("1 enfiler\n");
                                printf ("2 defiler\n");
                                printf ("3 afficher\n");
                                printf ("votre choix\n");
                                scanf ("%d", &choix);
                               printf ("\n");
                              switch(choix){ case 1: printf("entrez l'element\n");
                                                           scanf("%d",&e);
                                                           f=enfiler(f,e);
                                                           break;
                                                           case 2: f=defiler(f);break;
                                                           case 3: afficher_file(f);break;
                                                          }
                           }
                           while(choix!=0);                                 
                           }





Capture d’écran :
                                   presenter par etudiant smi4



exercice 2:
#include <stdio.h>

#include <stdlib.h>
#ifndef _file_chaine
#define _file_chaine
typedef int element;
typedef struct cellule 
{
        element valeur;
        struct cellule *suivant;
}cellule ;
typedef struct
{
        struct cellule *tete;
        struct cellule *queue;
} file;
file file_vide();
int file_est_vide(file f);
file enfiler(file f,element e);
file defiler(file f);
element tete(file f);
void menu();
#endif

file file_vide()
{
     file f;
     f.tete = f.queue = NULL ;
     return f;
}

int file_est_vide(file f)
{
    if (f.tete == f.queue && f.queue == NULL ) return 1;
    else return 0;
}

file enfiler(file f,element e)
{
     cellule *c = malloc(sizeof(cellule));
     c->valeur = e;
     c->suivant = NULL;
     if (file_est_vide(f)) f.tete = f.queue = c;
     else 
         {
                           f.queue->suivant = c;
                           f.queue = f.queue->suivant;
         }
         return f;
}
         
file defiler(file f)
{
     if(file_est_vide(f))
     {
                         printf("la file est vide");
     }
     else
     {
         if(f.tete == f.queue) 
         f = file_vide();
         else
             {
                   cellule *p;
                   p = f.tete;
                   f.tete = f.tete->suivant;
                   free(p);
             }
         }
         return f;
}

element tete(file f)
{
        if(file_est_vide(f))
     {
                         printf("la file est vide");
     }
     else return f.tete->valeur;
}

file permuter(file f)
{ 
  element va ;
  file q ;
  if (!file_est_vide(f))
     { va= tete(f);
       f=defiler(f);
       if(file_est_vide(f))
       { 
         f=enfiler(f,va); 
         return f;
         }
         q=file_vide();
       while(f.tete!=f.queue)
       {
        q=enfiler(q,tete(f)) ;
        f=defiler(f);
        }
       while (! file_est_vide(q))
       {
        f=enfiler(f,tete(q));
        q=defiler(q);
        }
      f=enfiler(f,va); 
      return f;
      } 
}

void afficher(file f)
{
    while((f.tete!=NULL) && (f.queue!=NULL))
     {printf("%d\n",f.tete->valeur);
      f.tete=f.tete->suivant;
      }
}

void menu(file f)
{
     int choix,x;
     do
     {    printf("----------------------\n");
          printf("1-File vide\n");
          printf("2-Enfiler\n");
          printf("3-Defiler\n");
          printf("4-Tete file\n");
          printf("5-Afficher les elements de la file\n");
           printf("6-Permuter les elements de la file\n");
          printf("0-Terminer\n");
          printf("Entrer votre choix :");
          scanf("%d",&choix);
          printf("\n\n");
          switch(choix)
          {
                       case 1: f=file_vide();
                       break;
                       case 2 : printf("donner element a enfiler:");
                                scanf("%d",&x);
                                f = enfiler(f,x);
                                break;
                       case 3 : if (!file_est_vide(f))f = defiler(f); break;
                       case 4: if (!file_est_vide(f)) printf("tete = %d \n",tete(f));break;
                       case 5: afficher(f);break;
                       case 6: f=permuter(f); break; 
          }
          }while (choix !=0);
}  
         
int main(int argc, char *argv[])
{ file f;
  f.tete = malloc (sizeof(cellule));
  f.queue = malloc (sizeof(cellule));
  f=file_vide();
  menu(f);
  system("PAUSE");
  return 0;
}

permuter pile 



#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#ifndef _pile_chaine
#define _pile_chaine
typedef int element;
typedef struct cellule
{
        element valeur;
        struct cellule *suivant;
} cellule;
typedef struct cellule *pile ;
pile pile_vide();
int pile_est_vide(pile p);
pile empiler(pile p,element e);
pile depiler(pile p);
element sommet(pile p);
void menu();
#endif


pile pile_vide()
   {return NULL;
    }
int pile_est_vide(pile p)
    {if(p==NULL) return 1;
    else return 0;
    }
pile Empiler(pile p, element e)
    {cellule *q=(cellule *)malloc(sizeof(cellule));
    q->valeur=e;
    q->suivant=p;
    return q;
    }
pile Depiler(pile p)
    {cellule *q=p;
     if (pile_est_vide(p)==1)
                         {printf("Erreur!!la pile est deja vide!!\n");
                         exit(-1);
                          }
     p=p->suivant;     
     free(q);
     return p;                     
     }
element Sommet(pile p)
     {if (pile_est_vide(p)==1)
              {printf(" erreur pile est vide\n");
               exit(-1);
                }
      return p->valeur;
      }

pile Permuter (pile p)
{
     element Va, Vb;
     cellule *Pt=(cellule *)malloc(sizeof(cellule)); //pile Pt;
     if(p==NULL)
     {
     printf("Pile déja vide !!! \n");
     }
     else{
     Va=Sommet(p);
     p=Depiler(p);
     Pt=NULL;
     while (p!=NULL)
        {
                    Pt=Empiler(Pt,Sommet (p));
                    p=Depiler(p);
         }
     p=NULL;     
     Vb=Sommet(Pt);
     Pt=Depiler(Pt);
     p=Empiler(p,Va);
     while (Pt!=NULL)
             {
                     p=Empiler(p,Sommet(Pt));
                     Pt=Depiler(Pt);
               }
     p=Empiler(p,Vb);
     return p;
     }
}
void Afficher(pile p)
    { cellule *Pt=p;
     /* while (Pile_est_Vide(P)!=0)
             {printf(" %d \n",Sommet(Pt));
              Pt=Depiler(Pt);
               }*/
       while(Pt!=NULL)
       {              printf("%d \n",Pt->valeur);
                      Pt=Pt->suivant;
                      }     
       }                                   
void menu (pile p)
{
 int choix ,e;
                                  
 do{
       printf("---------------------- \n");
         printf("\n");
       printf("1: Permuter la pile \n");
       printf("2: Afficher la pile \n");
       printf("3: Empiler la pile \n");
       printf("4: Depiler la pile \n");
       printf("5: Afficher sommet\n");
       printf("0: Quitter \n");
       printf("Entrer votre choix svp :");
       scanf("%d",&choix);
        printf("\n");                           
 
  switch (choix)
       {
         case 1 : p=Permuter(p);
         break;
         case 2: Afficher (p);
         break;
         case 3:do{
              printf("Donner element a empiler (-1 pour sortir):");
              scanf("%d",&e);
              p= Empiler(p,e);}
              while(e!=-1);
              p=Depiler(p);
         break;
         case 4 : p=Depiler(p);
         break;
         case 5: printf("sommet= %d \n",Sommet(p));
         break;
         
         }
         }while (choix!=0);
  }        
 int main(int argc,char *argv[])
 {
     pile p=(cellule *)malloc(sizeof(cellule));
     p=pile_vide();
     menu(p);
     
     
     system ("PAUSE");
     return 0;
 }   

exercice3;





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

typedef struct empl {
        int  val;
        struct empl *suivant;
        struct empl *precedant;
        char *nom;
        int sal;
        char *prenom;
        int code;
        }empl ;
typedef struct empl *liste;


liste liste_vide()
{
      return NULL;
}
     
int liste_est_vide(liste l)

{  
   if(l==NULL)
   return 1;
   else
   return 0;
}

int longueur (liste l)
{
    int taille=0;

    while (l!=NULL)
    {
      taille++;
      l=l->suivant;
      }
    return taille ;
} 
liste ajouter_debut(liste l,empl e)
{
      liste c;
      c=(liste)malloc(sizeof(empl));
      c->code=e.code;
      c->sal=e.sal;
      strcpy(e.nom,c->nom);
      strcpy(e.prenom,c->prenom);
      c->suivant=l;
      l=c;
      
return c;
}
liste ajouter_fin(liste l,int i,empl e)
{
       if (i<0||i>longueur(l))
      {
                            printf("Erreur :rang non valide !\n");
                            exit(-1) ;
      }
      liste pc=(liste)malloc(sizeof(empl));
      pc->code=e.code;
      pc->nom=e.nom;
      pc->prenom=e.prenom;
      pc->sal=e.sal;
      pc->suivant=NULL;
      if(i==0){
               pc->suivant=l;
               l=pc;
               }
      else {
           int j;
           liste pt=(liste)malloc(sizeof(empl));
           pt=l;
           for(j=0;j<i-1;j++){
               pt=pt->suivant;
              }
           pt->suivant=pc;
              } 
      return l;
      /*liste c;
      c=(liste)malloc(sizeof(empl));
      c->code=e.code;
      c->sal=e.sal;
      strcpy(e.nom, c->nom);
      strcpy(e.prenom, c->prenom);
      c->suivant=NULL;
      liste temp=l;
      while(temp->suivant!=NULL)
      {
       temp=temp->suivant;
      }
      temp->suivant=c;
      return l;*/
}

liste cree_liste(liste l)
{
        empl v;
     int i=0;     
     do{
         printf("Donner le code   : ");
         scanf("%d",&v.code);
         printf("Donner le nom    : ");
         v.nom=(char *)malloc(25*sizeof(char));
         scanf("%s",v.nom);
         if(strcmp(v.nom,"FIN")!=0)
              {printf("Donner le prenom : ");
               v.prenom=(char *)malloc(25*sizeof(char));
               scanf("%s",v.prenom);
               printf("Donner salaire   : ");
                scanf("%f",&v.sal);
               l=ajouter_fin(l,i,v);
               i++ ;
               }
        }while(strcmp(v.nom,"FIN")!=0);
        return l;
     
      
      /*empl e;      
      l=liste_vide();
      do
      { printf("Donner code employe :");
        scanf("%d",&e.code);
        printf("Donner le salaire de l'employe :");
        scanf("%f",&e.sal);
        
        e.nom=(char *)malloc(20*sizeof(char));
        e.prenom=(char *)malloc(50*sizeof(char));
        printf("Nom de l'employe :");
        scanf("%s",e.nom);
        printf("Prenom de l'employe :");
        scanf("%s",e.prenom);

        if(strcmp(e.nom,"FIN")!=0)
        { l=ajouter_fin(l,e);        
       
       }}while(strcmp(e.nom,"FIN")!=0);
return l;*/
}

int rechercher(liste l,int c)
{
    int a=0;
    liste lis=l;
    while((a==0)&&(!liste_est_vide(lis)))
    {
      
        if(lis->code==c)
        a=1;
        else
        lis=lis->suivant;
      }
      return a;
    }

liste supprimer(liste l,int c)
{
            int a;
            a=rechercher(l,c);
            liste q=l;
            if(a==1)
            {
                    
                    if(q->code==c)
                    {
                     l=q->suivant;
                     free(q);
                    }
            }
            else
            {
                while(!liste_est_vide(q->suivant)&&q->suivant->code!=c)
                { q=q->suivant; }
                 liste p=q->suivant;
                 
                 if(!liste_est_vide(p->suivant))
                 {
                   q->suivant=p->suivant;
                   free(p);
                 }
                
                 else
                 { q->suivant=NULL;
                  free(p);
                 }
                }
             return l;
}

float moyenne(liste l)
{
      float s=0;
      int m=0;
      
      liste lis=l;
      
      while(!liste_est_vide(lis))
         {
           s+=lis->suivant->sal;
           m++;
           lis=lis->suivant;
         }
         return (s/(float)(m));
}     
             
void afficher(liste l)
{
     liste lis=l;
     float m=moyenne(l);
     while(!liste_est_vide(lis))
     {
         if(lis->sal >m)
         {
            printf(" nom: %s \n ",lis->nom);
            printf("prenom : %s \n",lis->prenom);
            printf("code: %d \n", lis->code);
            printf("salaire : %f \n",lis->sal);
         }
         lis=lis->suivant;
         }
}

int verifie(liste l)
{int j=1;
liste q=l;
while (!liste_est_vide(q->suivant)&&j==1)
{
      if (q->sal > q->suivant->sal)
      j=0;
      else
      q=q->suivant;
      }
      return j;
      }
liste tri_liste(liste l)
{
      int ech;
      empl E;
      liste q;
      if(liste_est_vide(l))
      {printf("Liste vide");}
      else
      {
          do
          {
                     ech=0;
                     for(q=l;q->suivant!=NULL;q=q->suivant)
                     {
                             if(q->sal > q->suivant->sal)
                             {E.code=q->code;
                             E.sal=q->sal;
                             strcpy(E.nom,q->nom);
                             strcpy(E.prenom,q->prenom);
                             q->code=q->suivant->code;
                             q->sal=q->suivant->sal;
                             strcpy(q->nom,q->suivant->nom);
                             strcpy(q->prenom,q->suivant->prenom);
                             q->suivant->code=E.code;
                             q->suivant->sal=E.sal;
                             strcpy(q->suivant->nom,E.nom);
                             strcpy(q->suivant->prenom,E.prenom);
                             ech=1;
                             }}}
                              while (ech==1);}
                              return l;
                              }             
void menu(liste l)
{ int choix,co,k;
     do{
     printf("   .:  M E N U  :.   \n");
     printf("1. Creer une liste d'employes \n"); 
     printf("2. Rechercher un employe selon son code \n");
     printf("3. Supprimer un employe un employe selon son code \n");
     printf("4. Afficher le nom des employés qui ont un salaire superieur à la moyenne\n");
     printf("5. Verifier si la liste est triee \n"); 
     printf("6. Trier la liste selon l'ordre croissant des salaires \n");  
     printf("7. Quitter \n");
 printf("Donner votre choix : ");
     scanf("%d",&choix);
     switch(choix)
             {
                      case 1:cree_liste(l);
                       break;
                      case 2:printf("code employe recherche :");
                             scanf("%d",&co);
                             if(rechercher(l,co)==1)
                             printf("employe est dans la liste \n");
                             else printf("employe absent \n");
                             break;
                      case 3:printf("code employe recherche :");
                             scanf("%d",&co);
                             l=supprimer(l,co);
                             break;
                  case 4:afficher(l);
                         break;
                  case 5: if(verifie(l)==1)
                                           printf("la liste est triee\n");
                          else 
                               printf("la liste n'est pas triee \n");
                          break;
                  case 6: l=tri_liste(l);break;
                  }}while (choix!=0);
}
main()
{
      liste l=(liste)malloc(sizeof(empl));
      l=liste_vide();
      menu(l);
      system("Pause");
      return 0;
}
                  
                  
exercice supplimentaire liste d'entiers:






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

typedef struct cellule {
        int  val;
        struct cellule *suivant;
        struct cellule *precedant;
        }Cellule ;
typedef struct cellule *liste2C;


liste2C liste_vide()
{
      return NULL;
}

int longueur (liste2C l)
{int taille=0;

while (l!=NULL)
{
      taille++;
      l=l->suivant;
}

return taille ;
}      
liste2C inserer(liste2C l,int i,int e)
{
      if (i<0||i>longueur(l))
      {
                            printf("Erreur :rang non valide !\n");
                            exit(-1) ;
      }
      liste2C pc=(liste2C)malloc(sizeof(Cellule));
      pc->val=e;
      pc->suivant=NULL;
      pc->precedant=NULL;
      if(i==0){pc->suivant=l;
               l=pc;
               pc->precedant=l;}
      else {int j;
            liste2C pt=(liste2C)malloc(sizeof(Cellule));
            pt=l;
            for(j=0;j<i-1;j++)
              {pt=pt->suivant;
              }
              pt->suivant=pc;
              pc->precedant=pt;
              } 
      return l;
}
liste2C ajout_liste(liste2C l)
{
     int ve;
     int i=0;     
     do{
         printf("donner la valeur à ajouter (0 pour terminer)  ");
         scanf("%d",&ve);
         if(ve!=0)
              {
               l=inserer(l,i,ve);
               i++ ;
               }
        }while(ve!=0);
        
        return l;
     }
      

liste2C vider(liste2C l)
       {
             while(l!=NULL)
               {liste2C q;//=(liste2C)malloc(sizeof(Cellule));
               q=l;
               l=l->suivant;
               free(q);
               }
       return l;
       }


void affiche(liste2C l)
{
     while(l!=NULL)
     {printf("valeur=%d\n",l->val);
      l=l->suivant;
      }
}                                                                  

void menu(liste2C l)
{ int choix,i,e;
     do{
     printf("   .:  M E N U  :.   \n");
     printf("1. creer une liste d'entier (terminer par 0) \n");
     printf("2. Vider la liste \n");
     printf("3. Afficher la liste \n");
     printf("4. Quitter \n");
     printf("Donner votre choix: ");
     scanf("%d",&choix);
     switch(choix)
             {
                  case 1: l=liste_vide();
                          l=ajout_liste(l);
                    break;
                  case 2:   l=vider(l);
                            break;
                  case 3: 
                            affiche(l);
                    break;
             }  
               }while (choix!=4);
}                  
                            
int main(int argc, char *argv[])
{
  liste2C   l=(liste2C)malloc(sizeof(Cellule));
  
  menu(l);
 
  system("PAUSE");
  return 0;
}

Commentaires

Enregistrer un commentaire

Posts les plus consultés de ce blog

Exercice1 : Calcul des impôts locaux Dans le cadre de l’informatisation d’une mairie, on veut automatiser le calcul des impôts locaux. On distingue deux catégories d’habitation : les habitations à usage professionnel et les maisons individuelles, l’impôt se calculant différemment selon le type d’habitation.Pour cela ,on définit les classes HabitationProfessionnelle et HabitationIndividuelle et les caractéristiques communes à ces deux classes sont regroupées dans la classe Habitation. L’objectif du problème est d’implémenter ce schéma d’héritage et de mettre en œuvre le mécanisme de liaison dynamique. A) Définition de la classe Habitation : La classe Habitation comprend les attributs : -propriétaire du type chaine de caractères et qui correspond au nom de propriétaire, -adresse du type chaine de caractères et qui correspond à l’adresse de l’habitation, -surface du double et qui correspond à la surface de l’habitation, Les méthodes : -Impot ( ) qui permet de calculer le montant de l
Enregistrer un commentaire
rien
 Dans le cadre de l’informatisation d’une entreprise, un directeur souhaite automatiser la gestion des salaires de ses employés pour cela on aura : -Une classe Employe : Un employé est caractérisé par : +ces attributs : nom(chaine de caractères), son prénom(chaine de caractères) et son âge(entier),son année de recrutement(entier) +Ces méthodes : -Un constructeur a quatre paramètres permettant d’initialiser une instance de la classe Employe. +Affiche() :qui permet d’afficher les quatre attributs de la classe Employe. +CalculSalaire() :permet de renvoyer le salaire mensuel d’un employé mais ce calcul dépend du type de l'employé. On distingue les types d'employés suivants qui seront définie dans les classes suivantes: -Producteur : Leur salaire vaut le nombre d'unités produites mensuellement multipliées par 5 : Ajouter l’attribut NbUnités de type entier ;Définir la méthode CalculSalaire() ;Redéfinir la méthode Affiche( ) -Commercial : Leur salaire mensuel se calcule en fon
Enregistrer un commentaire
rien

Les exceptions:Saisie d'un mot de passe

Exercice 3- Saisie d'un mot de passe Dans les failles de sécurité réseau, on trouve très souvent les problèmes de dépassement. Par exemple, sur certaines anciennes versions de telnet, un login ou un mot de passe de plus d'un mega-octet faisait "planter" le programme et on obtenait alors un accès root au système. Ce programme va gérer ce type de problème en séparant les exceptions pour une meilleure gestion. 1- Écrire un programme stand-alone qui demande en boucle un nom d'utilisateur (login) et un mot de passe (pwd) jusqu'à recevoir un login/pwd correct. Le seul utilisateur référencé sera scott / tiger ( à mettre en constante dans la classe principale ). 2- Implémenter les exceptions suivantes: * WrongLoginException qui se produit lorsque l'utilisateur saisit un login inexistant * WrongPwdException lorsque le mot de passe est erroné * WrongInputLength lorsque le login où le pwd saisi dépasse 10 caractères. 3- Implémenter de façon à utiliser
rien

Exception:L'âge du capitaine

Exercice 2- L'âge du capitaine 1- Écrire une méthode getAgeCap() qui demande l'âge du capitaine. Cet âge doit être compris entre 18 et 65 ans et doit être un entier sous peine de lever une AgeCapException. Vous implementerez cette exception pour qu'elle renvoie une description explicite du type "[proposition] ans n'est pas un âge valide". Le programme devra également être en mesure de capturer tout type d'exception autre queAgeCapException. 2- Dans un premier temps, la méthode getAgeCap() propagera l'exception à la méthode appelante qui la traitera. 3- Modifier le programme pour que ce soit la méthode getAgeCap() qui traite l'exception. 4- Modifier encore le programme pour que getAgeCap() traite l'exception mais lève une seconde exception de type Exception pour signaler à la méthode appelante qu'une erreur s'est produite et que cette dernière comptabilise le nombre d'essais infructueux et l'affiche. Le programme d
rien
Exercice2 : Ecrivez une interface Forme avec les méthodes abstraites suivantes: - perimetre(): renvoie le périmètre de la forme, - aire(): renvoie l'aire de la forme. Ecrivez une classe Carre et Rectangle implémentant l'interface Forme avec les attributs suivants:carre(cote:le coté du carré) et Rectangle ( longueur et largeur) Ces deux classes doivent disposer les constructeurs suivants: -Carre( ),Carre(cot). -Rectangle( ),Rectangle( largeur,longueur). Elles doivent contenir des accesseurs et mutateurs pour leurs différents attributs,et les méthodes suivantes: - perimetre( ): Donne le périmètre de la forme, - aire( ): Donne l'aire de la forme, - toString( ): Donne une représentation de la forme Ecrivez aussi une classe de testForme afin de tester les classes.                                                       TELECHARGER ICI package exo2; public interface Forme {      public double perimetre();    public double aire(); } package
Enregistrer un commentaire
rien

Il s'agit de modéliser un segment de droite dont les valeurs des deux extrémités sont entières. Si on échange les deux extrémités, on considère qu'il s'agit encore du même segment. La classe Segment comporte les méthodes suivantes un constructeur de ce segment recevant en argument les deux valeurs entières des extrémités du segment que l'on veut construire une méthode retournant la longueur du segment une méthode nommée ordonne échangeant éventuellement les valeurs des extrémités du segment de telle sorte que la valeur de extr1 soit au plus égale à la valeur de extr2 une méthode testant si un entier donné se trouve sur le segment (c'est dire s'il est compris entre la plus petite et la plus grande valeur des extrémités du segment). public String toString() :Celle ci décrira une instance de Segment sous la forme d'une chaîne de caractères (par exemple, le segment d'extrémités 35 et 44 pourra être transformé en la chaîne de caractères : "segment [ 35, 44]") (la plus petite extrémité est toujours indiquée à gauche). Ecrivez aussi une autre classe EssaiSegment comportant la méthode main et permettant de tester les méthodes de la classe Segment

package tp2; public class exo1Segment { int extr1 , extr2; public int getExtr1() { return extr1; } public void setExtr1(int extr1) { this.extr1 = extr1; } public int getExtr2() { return extr2; } public void setExtr2(int extr2) { this.extr2 = extr2; } public exo1Segment(int extr1, int extr2) { super(); this.extr1 = extr1; this.extr2 = extr2; } public exo1Segment() { this.extr1 = 0; this.extr2 = 0; } public int  longueur(){ return (int) Math.sqrt(Math.abs(Math.pow(extr1, 2)+Math.pow(extr2, 2))); } public void  ordone(){ int ech; if(extr1>extr2){ ech=extr1;     extr1=extr2;     extr2=ech;} } public boolean isIn(int x){ if(x>Math.min(extr1, extr2) && x<Math.max(extr1, extr2) ) return true; return false; } public String toString(){ return  "segment ["+Math.min(extr1, extr2)+","+ Math.max(extr1, extr2)+"]"; } }
Enregistrer un commentaire
rien

Exercice2 : Ecrivez une classe Complexe représentant des nombres complexes. Un nombre complexe comporte une partie réelle et une partie imaginaire (partieReelle + partieImaginaire * i . -La classe Complexe doit disposer des constructeurs suivants: Complexe(): constructeur par défaut, Complexe(partieReelle, partieImaginaire),Complexe(Complexe). -Elle doit contenir des accesseurs et mutateurs pour les différents attributs. -additionner au nombre complexe concerné un autre complexe ; on écrira pour cela une méthode d'instance nommée addition qui recevra en paramètre l'autre complexe et qui ne retournera rien. - additionner deux complexes donnés ; on écrira pour cela une méthode statique nommée aussi addition (en utilisant ainsi la possibilité de la surcharge) qui recevra en paramètres les deux nombres complexes à additionner et qui retournera le résultat sous forme d'un objet de type Complexe. -une méthode toString() donnant une représentation d'un nombre complexe (a+b*i). -Ecrivez aussi une classe testComplexe afin de tester la classe Complexe.

package tp2; class Complex {   static float partieReelle ;   static float  partieImaginaire;         public float getPartieReelle() { return partieReelle; } public void setPartieReelle(float partieReelle) { Complex.partieReelle = partieReelle; } public float getPartieImaginaire() { return partieImaginaire; } public void setPartieImaginaire(float partieImaginaire) { Complex.partieImaginaire = partieImaginaire; } Complex(float r, float i) {     partieReelle  = r;      partieImaginaire = i;   } static void additionner(Complex c2) {   partieReelle=partieReelle+Complex.partieReelle;   partieImaginaire=partieImaginaire+Complex. partieImaginaire;   }   static boolean equals(Complex c1, Complex c2) {     return (Math.abs(Complex.partieReelle -Complex.partieReelle ) ==0 &&         Math.abs(Complex. partieImaginaire-Complex.partieReelle )  == 0);   }     static Complex additionner(Complex c
Enregistrer un commentaire
rien

Exercice3: Ecrivez un programme Geometrie qui permet à l'utilisateur d'entrer les coordonnées (x, y) des sommets d'un triangle. Le programme affiche ensuite le périmètre du triangle ainsi qu'un message indiquant s'il s'agit d'un triangle isocèle. Votre programme doit être orienté objet.

/**  *  */ package tp2; /**  * @author pirate  *  */ public class Point { float x; float y; public Point(float x, float y) { super(); this.x = x; this.y = y; } public float getX() { return x; } public void setX(float x) { this.x = x; } public float getY() { return y; } public void setY(float y) { this.y = y; } public Point() { this.x=0; this.y=0; } public double distance(Point point1,Point point2){ double n=Math.sqrt(Math.pow(Math.abs(point1.x-point2.x),2)+Math.pow(Math.abs(point1.y-point2.y),2)); return n; } } package tp2; import java.util.Scanner; import tp2.Point; public class triangle {   Point p1,p2,p3; public Point getP1() { return p1; } public void setP1(Point p1) { this.p1 = p1; } public Point getP2() { return p2; } public void setP2(Point p2) { this.p2 = p2; } pu
Enregistrer un commentaire
rien

Exercice2: En mathématiques, le triangle de Pascal, est un arrangement géométrique des coefficients binomiaux dans un triangle. À la ligne i et à la colonne j (0 <= j <= i) est placé le coefficient binomial 2 Le but de ce projet est d'écrire un programme qui demande à l'utilisateur de saisir un entier naturel n, non nul. Puis le programme affiche les n premières lignes du triangle de Pascal.

import java.util.Scanner; class Pascal {     private static Scanner scanner = new Scanner(System.in);     public static void main(String[] args) {         int size;         // On demande la taille         System.out.println("Taille du triangle de Pascal : ");         size = scanner.nextInt();         // Ici on déclare le tableau, mais on ne construit que la première         // dimension         int [][] triangle = new int[size][];         // On construit et initialise la 1ère ligne         triangle[0] = new int[1];         triangle[0][0] = 1;         for (int row = 1; row < size; row++) {             // Chaque ligne du triangle est un tableau à une dimension             // dont la taille est celle de la ligne précédente + 1:             // on construit ces lignes (new) au fur et à mesure que l'on             // progresse dans le tableau             triangle[row] = new int [triangle [row - 1].length + 1];             // Remplissage du tableau:
Enregistrer un commentaire
rien