EVALUATION EN ALGORITHMIQUE TEST  09/ XX    

Exercice 1 : 5 points

1. Écrire un algorithme qui lit un entier et compte le nombre de 1 dans la représentation binaire de cet entier. (1 pt)
2. Écrire un algorithme qui lit un tableau d’entiers de n éléments et donne la plus grande et la plus petite valeur du tableau. (2 pts)
3. Écrire un algorithme qui permet de déterminer si les éléments d’un tableau d’entiers sont tous consécutifs ou non. (2 pts)
   Exemple :
   • 7, 8, 9, 10 → consécutifs
   • 7, 9, 10, 11 → non consécutifs
   On suppose que le tableau et sa taille sont connus.

Exercice 2 : 5 points

1. Considérons le programme suivant qui classe un tableau Tab de Max entiers :

   Programme Tri(tab, Max)
   Debut
     Pour i de 1 a Max-1 faire
       Pour j de 1 a Max-1-i faire
         Si Tab[j] > Tab[j+1] Alors
           Permutation(Tab, j, j+1)
         FinSi
       FinPour
     FinPour
   Fin

   1. Réécrire ce programme avec des boucles Tantque. (1 pt)
   2. Écrire la procédure Permutation et préciser le passage des paramètres. (1 pt)
2. Écrire un algorithme qui lit une matrice A et vérifie si elle est symétrique. (1 pt)
3. Soit l’algorithme suivant : (2 pts)

   Algorithme
   Var SOMME, NOTE : reels ; REPONSE : texte
   Debut
     SOMME <- 0
     Ecrire("Voulez vous saisir une note O/N")
     Lire(REPONSE)
     Tant que REPONSE = "O" Faire
       Lire(NOTE)
       SOMME <- SOMME + NOTE
       Ecrire("Voulez vous saisir une autre note O/N")
       Lire(REPONSE)
     FinTantQue
     Ecrire("La somme des notes est de ", SOMME)
   Fin

   1. Que fait cet algorithme ? (0,5 pt)
   2. Si l’utilisateur saisit 3 puis 4 puis 12, quelle est la valeur finale de SOMME ? (0,5 pt)
   3. L’utilisateur peut-il ne saisir aucune note ? (0,5 pt)
   4. Comment l’utilisateur peut-il arrêter la saisie ? (0,5 pt)

CORRECTION

Exercice 1 (5 pts)

1) Compter le nombre de 1 dans l’écriture binaire (1 pt)

Idée : Diviser le nombre par 2 et compter les restes égaux à 1.

Algorithme CompterBits1
Var
  n, nb1 : entier
Debut
  Lire(n)
  nb1 <- 0

  Tantque (n > 0) Faire
    Si (n MOD 2 = 1) Alors
      nb1 <- nb1 + 1
    FinSi
    n <- n DIV 2
  FinTantque

  Ecrire("Nombre de 1 =", nb1)
Fin

Remarque : si n = 0, alors nb1 = 0.

2) Minimum et maximum d’un tableau (2 pts)

Algorithme MinMaxTableau
Const NMAX = 100
Var
  T : tableau[1..NMAX] d'entier
  n, i, min, max : entier
Debut
  Lire(n)
  Pour i de 1 a n Faire
    Lire(T[i])
  FinPour

  min <- T[1]
  max <- T[1]

  Pour i de 2 a n Faire
    Si (T[i] < min) Alors min <- T[i] FinSi
    Si (T[i] > max) Alors max <- T[i] FinSi
  FinPour

  Ecrire("Min =", min, " Max =", max)
Fin

3) Tableau consécutif (2 pts)

Algorithme TableauConsecutif
Const NMAX = 100
Var
  T : tableau[1..NMAX] d'entier
  n, i, j, tmp : entier
  ok : booleen
Debut
  Lire(n)
  Pour i de 1 a n Faire
    Lire(T[i])
  FinPour

  Pour i de 1 a n-1 Faire
    Pour j de 1 a n-i Faire
      Si (T[j] > T[j+1]) Alors
        tmp <- T[j]
        T[j] <- T[j+1]
        T[j+1] <- tmp
      FinSi
    FinPour
  FinPour

  ok <- VRAI
  Pour i de 1 a n-1 Faire
    Si (T[i+1] <> T[i] + 1) Alors
      ok <- FAUX
    FinSi
  FinPour

  Si (ok) Alors
    Ecrire("Elements consecutifs")
  Sinon
    Ecrire("Elements non consecutifs")
  FinSi
Fin

Exercice 2 (5 pts)

1.a) Tri avec Tantque (1 pt)

Programme Tri_Tantque(Tab, Max)
Var i, j : entier
Debut
  i <- 1
  Tantque (i <= Max - 1) Faire
    j <- 1
    Tantque (j <= Max - i) Faire
      Si (Tab[j] > Tab[j+1]) Alors
        Permutation(Tab, j, j+1)
      FinSi
      j <- j + 1
    FinTantque
    i <- i + 1
  FinTantque
Fin

1.b) Procédure Permutation (1 pt)

Passage : Tab est passé par Var car il est modifié.

Procedure Permutation(Var Tab : tableau d'entiers, i, j : entier)
Var tmp : entier
Debut
  tmp <- Tab[i]
  Tab[i] <- Tab[j]
  Tab[j] <- tmp
Fin

2) Matrice symétrique (1 pt)

Algorithme MatriceSymetrique
Const NMAX = 50
Var
  A : tableau[1..NMAX,1..NMAX] d'entier
  n, i, j : entier
  sym : booleen
Debut
  Lire(n)
  Pour i de 1 a n Faire
    Pour j de 1 a n Faire
      Lire(A[i,j])
    FinPour
  FinPour

  sym <- VRAI
  Pour i de 1 a n Faire
    Pour j de i+1 a n Faire
      Si (A[i,j] <> A[j,i]) Alors
        sym <- FAUX
      FinSi
    FinPour
  FinPour

  Si (sym) Alors
    Ecrire("Matrice symetrique")
  Sinon
    Ecrire("Matrice non symetrique")
  FinSi
Fin

3) QCM (2 pts)

3.1) Réponse : B) Il calcule la somme des notes.

3.2) 3 + 4 + 12 = 19 → Réponse C

3.3) Oui, si l’utilisateur répond directement N → Réponse A

3.4) En tapant "N" → Réponse A

                                                                                                                                                                                                                                                         Par Mr Joel_Yamkam | Contact :+237652027193

Les étudiants d’Info 1 souhaitent manipuler en mémoire centrale de l’ordinateur du commissariat de Dschang un ensemble de Policiers (400 policiers). Les informations concernant un Policier sont : code (entier), nom (chaine), grade (chaine), salaire (réel), ancienneté (réel), date de recrutement (Date) et statut (Actif (0) / Suspendu (1)).

ÉNONCÉ

1. Proposer une structure de donnée adéquate permettant de représenter un Policier et de manipuler ces 400 policiers en mémoire centrale, puis en mémoire permanente (ROM/disque) via un fichier.
2. Proposer une procédure SauvePolice prenant un tableau et un fichier de policiers en paramètre, permettant de sauvegarder l’ensemble des 400 policiers dans un fichier Fpol.
3. Proposer une fonction CompteStatut qui retourne le nombre de policiers Actifs et le nombre de policiers Suspendus dans le tableau.
4.  Proposer une procédure FiltreActifs qui copie uniquement les policiers Actifs (0) dans un nouveau fichier Factifs.

CORRECTION

1) Structures de données (mémoire centrale + fichier)

Type Date = Enregistrement
    jour  : entier ;
    mois  : entier ;
    annee : entier ;
Fin

Type Policier = Enregistrement
    code       : entier ;
    nom        : chaine ;
    grade      : chaine ;
    salaire    : reel ;
    anciennete : reel ;
    recrut     : Date ;
    statut     : entier ;  // 0 = Actif, 1 = Suspendu
Fin

Const N = 400 ;

Type TabPolice = Tableau[1..N] de Policier ;
Type FichPolice = Fichier de Policier ;

Remarque : Le tableau TabPolice sert pour la mémoire centrale (RAM). Le fichier FichPolice sert pour la sauvegarde permanente (ROM/disque).

2) Procédure de sauvegarde permanente : SauvePolice

Procedure SauvePolice(Var Fpol : FichPolice ; T : TabPolice) ;
Var i : entier ;
Debut
    Ouvrir(Fpol) ;                // ouverture du fichier
    Pour i de 1 a N Faire
        Ecrire(Fpol, T[i]) ;      // écriture d’un enregistrement Policier
    FinPour
    Fermer(Fpol) ;                // fermeture du fichier
    Ecrire("Sauvegarde terminee.") ;
Fin ;

3) Question mixte 1 : Compter Actifs et Suspendus

Procedure CompteStatut(T : TabPolice ; Var nbActifs, nbSuspendus : entier) ;
Var i : entier ;
Debut
    nbActifs <- 0 ;
    nbSuspendus <- 0 ;
    Pour i de 1 a N Faire
        Si (T[i].statut = 0) Alors
            nbActifs <- nbActifs + 1 ;
        Sinon
            nbSuspendus <- nbSuspendus + 1 ;
        FinSi
    FinPour
Fin ;

4) Question mixte 2 : Copier uniquement les Actifs dans un fichier Factifs

Procedure FiltreActifs(T : TabPolice ; Var Factifs : FichPolice) ;
Var i : entier ;
Debut
    Ouvrir(Factifs) ;
    Pour i de 1 a N Faire
        Si (T[i].statut = 0) Alors
            Ecrire(Factifs, T[i]) ;
        FinSi
    FinPour
    Fermer(Factifs) ;
    Ecrire("Fichier des actifs cree.") ;
Fin ;

```