Exercice 1
==========


Q1. Définition du type Commande

#define LNOM 20

typedef enum {Basque, Bretonne, Corse, Dauphinoise, Savoyarde} natPizza ;

typedef struct {
  char nom[LNOM+1] ; // ajout de 1 pour la marque de fin 
  natPizza nature ;
  unsigned char nombre ; // on pourrait choisir unsigned int, ou int
  char surplace ; // booleen
} Commande ;

Q2.

En considérant que la taille d'un type énuméré est de 4 octets (un entier), la taille en octet d'un élément de type Commande est :
	21 + 4 + 1 + 1 = 31 octets

Q3. Deux commandes sont-elles identiques ?

int main() {
   Commande c1, c2 ; // deux commandes
   // lecture au clavier des commandes c1 et c2 
   int identique ; // booleen valant vrai ssi c1 et c2 sont indentiques

   // A COMPLETER :  affiche vrai ssi c1 et c2 sont identiques 
   identique = !strcmp(c1.nom, c2.nom) && (c1.nature == c2.nature) && (c1.nombre == c2.nombre) && (c1.surplace == c2.surplace) ;
   if (identique) 
      printf("c1 et c2 sont identiques\n") ;
   else
      printf("c1 et c2 ne sont pas identiques\n") ;

   return 0 ;
}

Q4. Prix d'une commande

int main() {
   Commande c ; // une commande
   float p ; // le prix de la commande c

   // A COMPLETER : définition et initalisation du tableau Prix (de la Figure 1)
   float Prix[5] = {7.5, 7, 8, 8, 8.5} ; 
   
   // lecture au clavier de la commandes c

   // A COMPLETER : calcul et affichage de p

   p = c.nombre * Prix[c.nature] ;  // prix de base
   if (c.surplace) { // si consommation sur place 
        p = p + (p*10)/100 ;  // ajout de la majoration de 10%
   } ;
   printf("le prix de la commande c est %f\n", p) ; 
   return 0 ;
}

Q5. Permettre de commande des pizzas de nature différente

Il faut remplacer le champ entier nombre par un tableau indicé par natPizza indiquant 
le nombre de chacune des pizzas :

#define NB_NAT_PIZZAS 5

typedef struct {
  char nom[LNOM+1] ; // ajout de 1 pour la marque de fin 
  natPizza nature ;
  char nombre[NB_NAT_PIZZAS] ; // nbre de chacune des pizzas 
  char surplace ; // booleen
} Commande ;


Exercice 2
===========

Q1.  On choisit le type char pour représenter le champ base qui est un entier sur [0,10] 
     (on pourrait également utiliser unsigned char).

#define L 128
typedef struct { char base; char val[L] ; } intBase ;

Q2. Traduction de l'algo de calcul de la valeur décimale d'un intBase

int main() { 
  intBase x ;
  unsigned int i, resulat ;

  printf("entrez un chiffre entre 2 et 9") ; scanf("%d", &(x.base)) ;
  printf("entrez une chaine de caracteres representant une valeur dans cette base") ; scanf("%s", x.val) ;
  i=0 ; resultat=0 ; 
  while (x.val[i] != '\0') {
      resultat = resultat * x.base + chiffre(x.val[i]) ;
      i=i+1 ;
  } ;
  return resultat ;
}

Q3. Vérification des contraintes pour un élément de type intBase. 

    intBase x ;
    int ok ;
    // A COMPLETER :
    //     ok vaut vrai ssi x respecte les deux contraintes C1 et C2 ci-dessus

    int C1 ; // contrainte C1 ;
    int C2 ; // contrainte C2 ;
    int i ;

    C1 = x.base >= 2 && X.base <= 9 ;

    // vérification de la contrainte C2
    // schéma de recherche en langage C 
    C2 = 1 ; // on initialise C2 à vrai
    for (i=0 ; x.val[i] != '\0' ; i=i+1) {
       // le caractere x.val[i] doit étre compris entre '0' et '0' + x.base-1
       if (x.val[i] < '0' || x.val[i] > '0' + x.base-1) {
            C2=0; break ;  // C2 n'est pas respectée, on peut arreter la recherche ...
       } ;
    } ;

    ok = C1 && C2 ;


Q4. Conversion en base b d'un entier en base 10

int main() { 
  unsigned int n ; // l'entier à convertir
  unsigned char b ; // une base b entre 2 et 9
  intBase x ; // la représentation de n en base b 
  char tmp[L] ; // variable temporaire
  int i, j ;

  printf("entrez un entier positif en base 10") ; scanf("%d", &n) ;
  printf("entrez une base entre 2 et 9") ; scanf("%d", &b) ;
  
  x.base = b ; // on affecte champ base de x 

  // calcul du champ val de x
  // on stocke dans tmp les chiffres de la representation de n en base b "de droite à gauche"
  i=0 ;
  while (n != 0) {
      tmp[i] = '0' + n % b ; // on transforme un chiffre en caractère 
      n = n/b ;
      i=i+1 ;
  } ;
  // on recopie tmp de gauche à droite dans x.val
  i=i-1 ; j=0 ;
  while (i>=0) {
     x.val[j] = x.tmp[i] ;
     j=j+1 ; i=i-1 ;
  } ; 
  x.val[j] = '\0' ; // fin de sequence à l'indice j
 
  return 0 ;
}