Saad Dahlab University - Blida1 Module : Algorithmic 2

Faculty des Sciences May 2024

Computer Science Departement 2nd Test
1st Engineer Duration : 1h30 mn

EXERCISE 1 (6
(6 POINTS). We want to represent a binary number using a Doubly Linked List
(DLL) where each element contains a bit (either 0 or 1).

Using the Model of DLL, write the following iterative modules:

1. bool Odd(DLL L): tests if the binary number is odd or not.
2. bool Palindrome(DLL L): tests if the number is a palindrome or not.
3. void Divide2(DLL* L): performs binary division by 2 = (10)₂. For example:
Divide2(1↔0↔1↔0↔1↔1) returns 1↔0↔1↔0↔1.
4. DLL CreateDLL(unsigned int x): converts a decimal number to a binary number and constructs
the list DLL. The conversion can be done by successive divisions: Divide the number "x" and each
of the successive quotients by 2 until obtaining a null quotient. The sequence of remainders, in
reverse order of their obtention, gives the representation of the decimal number in binary.
5. int number(DLL L) returns the decimal number represented by the list L.
6. DLL Sum(DLL L1, DLL L2): receives two binary numbers n1, n2 represented by two lists L1 and
L2, respectively, and performs the sum n1+n2. For example: Sum(1↔0↔1↔0↔1↔1, 1↔1↔1)
returns 1↔1↔0↔0↔1↔0. You cannot use the CreateDLL and number modules.
EXERCISE 2 (5 POINTS).Consider the following algorithms:
bool Number_X(int n, int dv) { int Numbers_X_interval(int debut, int fin) {
if (n <= 1) return false; if (debut > fin) return 0;
else if (n<dv * dv) return true; else
else if (n % dv == 0) return false; if (Number_X (debut, 2)) { printf("%d ", debut);
else return Number_X(n, dv + 1); return (1+Numbers_X_interval (debut + 1, fin));}
} else
return(Numbers_X_interval(debut + 1, fin);
}
1. Provide the step-by-step execution of the this instruction Numbers_X_interval (1, 10) and give
the final result returned.
2. Deduce the role of each function.
3. What is the type of recursion for each function?
4. Perform the conversion to an iterative algorithm (Unrol recursion) for each function.

1/2
EXERCISE 3 (4 POINTS).
Let F be a dynamic queue representing a text, where each node contains a text fragment and its type as
follows:

type Fragment Déclaration

0 A word (a string of alphabetical letters) typedef struct typeqcq {
1 A number (a string of digits) int type;
2 One of the empty characters: null ('\0'), space (' '), or tabulation ('\t') char fragment[50];
3 One of the punctuation characters: (. , : ; ! ?) } typeqcq;
4 One of the delimiter characters: () [] {}

Assuming that the queue F exists (already created), write the following iterative modules using the
dynamic queue (MQueue.h) and static stack (MStack.h) model:

1. void CleanUp(Queue* F): Cleans up the queue F from empty characters and punctuation
characters. You can only use one additional queue.
2. bool CheckDelimiter(Queue* F): Checks if the text is correctly delimited, meaning if all
parentheses, brackets, and braces are properly closed by a character of the same type (example of
correct closure: {([])[{}()]}), and if the parentheses, brackets, and braces are correctly nested
(example of incorrect nesting: ({)}). You can only use one stack and one additional queue.
queue.

2/2
Université Saad Dahlab de Blida 1 Module : Algorithmique 2
Faculté des Sciences Mai 2024
Département d’Informatique Interrogation 2
1ère Ingénieur Durée : 1h30 mn
EXERCICE 1 (6 POINTS).
POINTS) On convient de représenter un nombre binaire par une Liste Linéaire
Chaînée bidirectionnelle (Doubly Linked List, DLL) où chaque élément contient un bit (soit 0 ou 1).

En utilisant le modèle de DLL (MDLL.h), écrire les modules itératifs suivants :

1. bool Odd(DLL L) permet de tester si le nombre binaire est impair ou non.
2. bool Palindrome (DLL L ) permet de tester si le nombre est palindrome ou non
3. void Divide2(DLL* L) réalise la division binaire par 2 = (10)2. Par exemple :
Divide2(1↔0↔1↔0↔1↔1) renvoie 1↔0↔1↔0↔1.
4. DLL CreateDLL(unsigned int x) permet de convertir un nombre décimal en un nombre binaire et
construire la liste DLL. Rappelons que la conversion peut se faire avec des divisions successives :
Diviser le nombre entier « x » et chacun des quotients successifs par 2 jusqu'à obtenir un quotient
nul. La suite des restes, dans l'ordre inverse de leur obtention, donne la représentation du nombre
décimal en binaire.
5. int number(DLL L) renvoie le nombre décimal représenté par la liste L.
6. DLL Sum(DLL L1, DLL L2) reçoit deux nombres binaires n1,n2 représentés par deux listes L1 et
L2, respectivement, et effectue la somme n1+n2 ; Par exemple : Somme(1↔0↔1↔0↔1↔1,
1↔1↔1) renvoie 1↔1↔0↔0↔1↔0. Vous ne pouvez pas utiliser les modules CreateDLL et
number.
EXERCICE 2 (5 POINTS).
POINTS) Soit les algorithmes suivants :
bool Number_X(int n, int dv) { int Numbers_X_interval(int debut, int fin) {
if (n <= 1) return false; if (debut > fin) return 0;
else if (n<dv * dv) return true; else
else if (n % dv == 0) return false; if (Number_X (debut, 2)) { printf("%d ", debut);
else return Number_X(n, dv + 1); return (1+Numbers_X_interval (debut + 1, fin));}
} else
return(Numbers_X_interval(debut + 1, fin);
}
1. Dérouler cette instruction Numbers_X_interval(1, 10) et donner le résultat final retourné.
2. Déduire le rôle de chaque fonction.
3. Quel est le type de récursivité de chaque fonction ?
4. Faire le passage vers un algorithme itératif (Dérécursiver) pour chaque fonction.

1/2
EXERCICE 3 (4 POINTS).
POINTS)
Soit F une File dynamique représentant un texte où chaque maillon contient un fragment du texte et son
type comme suit :

type Fragment Déclaration

0 Un mot (une chaîne des lettres alphabétique) typedef struct typeqcq {
1 Un nombre (une chaîne des lettres) int type;
2 Un des caractères vides : nul ('\0'), espace (' ') ou tabulation ('\t') char fragment[50];
3 Un des caractères de ponctuations (. , : ; ! ?) } typeqcq;
4 Un des caractères de délimitation : () [] {}

Supposant que la file F est déjà créée, écrire les modules itératifs suivants en utilisant le modèle des files
dynamique (MQueue.h) et des piles statiques (MStack.h):

7. void CleanUp(Queue* F) : permet de nettoyer la file F des caractères vides et des caractères de
ponctuation. Vous ne pouvez utiliser qu’une seule autre file.
8. bool CheckDelimiter(Queue*F): de vérifier si le texte (qui est dans F) est correctement délimité,
c’est-à-dire si toutes les parenthèses, crochets et accolades sont bien refermés par un caractère du
même type (exemple d’une fermeture correcte : {([])[{}()]}), et si les parenthèses, crochets et
accolades sont correctement imbriqués (exemple d’une imbrication incorrecte : ({)}. Vous ne
pouvez utiliser qu’une seule pile et une autre file.

2/2