Devoir de Synthèse n°3 Matière : Informatique - Classe : 2e INFO - Durée : 2h

Année Scolaire : 2023-2024 Enseignants : K. Bejaoui – N. Achour – H. Kassas – M.A. MANI

Nom & Prénom : ..............................................................................................................................................................................

Exercice 1 – Jeu des trois Gobelets (3 points)

Le jeu des Trois-Gobelets consiste à repérer le gobelet où
se cache la balle après un certain nombre de
permutations. Pour simuler ce jeu, on propose, ci-dessous,
l’algorithme du programme principal qui utilise un
tableau nommé g, et fait appel aux procédures Exchange
et Switch.
Algorithme JEUX Procédure Exchange(X, Y: booléen)
Début Début
g[0]  Faux AUX  X
g[1]  Vrai X  Y
g[2]  Faux Y  AUX
Lire(n) Fin
Pour i de 1 à n faire
Switch(g[0], g[1]) Procédure Switch(@X, @Y: booléen)
Exchange(g[1], g[2]) Début
Switch(g[2], g[0]) AUX  X
Fin Pour X  Y
Pour i de 0 à 2 Faire Y  AUX
Si g[i] Alors Fin
Écrire("Balle sous le gobelet", chr(65+i))
Fin Si Table ASCII des lettres majuscules
Fin Pour c 65 66 67 … 90
Fin chr(c) "A" "B" "C" … "Z"

Pour chacune des propositions ci-dessous, une seule réponse est correcte. Mettre une croix (X) dans la
case correspondante à la bonne réponse.
1) Les objets X et Y utilisés dans les entêtes des procédures Exchange et Switch sont des :
Paramètres effectifs
Paramètres formels
Variables locales

2) Le mode de passage des paramètres dans ces modules est respectivement :

Par valeur pour les deux modules
Par valeur pour le module Exchange et par adresse pour Switch
Par adresse pour le module Exchange et par valeur pour Switch

3) La balle est initialement placée sous le gobelet :

A B C

4) Les lettres affichées par le programme pour n=1, puis pour n=2, et enfin pour n=3 sont :
A, B, C
B, C, A
C, A, B
5) Pour générer aléatoirement une valeur de n comprise entre 1 et 5, l’instruction Lire(n) peut être
remplacée par l’instruction :
n  Aléa(0, 1) * 4 + 1
n  Aléa(0, 100) mod 5 + 1
n  Aléa(0, 20) div 4

Page 1 sur 5
Devoir de synthèse n°3 – Commun 2e Info
6) Pour placer aléatoirement la balle, on peut utiliser cet algorithme :
p  Aléa(0, 2) Pour i de 0 à 2 Faire
Pour i de 0 à 2 Faire Pour i de 0 à 2 Faire p  Aléa(0,2)
g[i]  Aléa(0, 1) = 0 g[i]  i = p g[p]  Vrai
Fin Pour Fin Pour Fin Pour

Exercice 2 – Fêtes nationales (7 points)

En Tunisie, les fêtes nationales officielles sont :
• La fête de l'indépendance, le 20 mars (20/3)
• La fête des martyrs, le 9 avril (9/4)
• La fête de la république, le 25 juillet (25/7)
• La fête de l'évacuation, le 15 octobre (15/10)
À l'occasion des fêtes nationales, un opérateur téléphonique fait
gagner à ses abonnés des recharges gratuites.
Pour déterminer les numéros gagnants, l'opérateur utilise la
fonction suivante qui accepte un numéro de téléphone (numtel) de 8 chiffres ainsi que la date d'une fête
nationale (fete) composée de 2 à 4 chiffres aux formats "jm", "jjm", "jmm" ou "jjmm".
Exemple : fête de l'indépendance, le 20 mars : fete  "203", fête des travailleurs, le 1e mai: fete  "15"
Fonction EstGagnant(numtel : ……………………………, fete : ……………………………):……………………………
Début
gagne ← Vrai
Pour i de 0 à Long(fete)-1 Faire
Si Pos(fete[i], numtel) = -1 alors
gagne ← Faux
Fin Si
Fin Pour
Retourner gagne
Fin

1. Compléter la définition de la fonction EstGagnant.

2. Dans le tableau suivant, indiquer si l'appel de la fonction est correct ou incorrect. S'il est correct,
mentionner son résultat.
Données
1/7 ≈ 0.142857142857
a ← "52743694" Table ASCII des chiffres
b ← "94543693" c 48 49 50 51 52 53 54 55 56
c ← "203" chr(c) "0" "1" "2" "3" "4" "5" "6" "7" "8"
d ← 93504687
e ← 74

Appel Correct/Incorrect Résultat (Vrai/Faux)

g ← EstGagnant(a, "257")

g ← EstGagnant("94543693", c)

g ← EstGagnant(Valeur(b), Valeur(c))

g ← EstGagnant(ConvCh(d), ConvCh(e))

g ← EstGagnant(ConvCh(1/7), chr(49)+chr(53))

g ← EstGagnant(Effacer(b,4,8)+sous_chaine(a,4,8),"74")

Page 2 sur 5
Devoir de synthèse n°3 – Commun 2e Info
3. Récrire la fonction EstGagnant tout en remplaçant la boucle (Pour) par une autre plus adéquate
(Répéter ou TantQue).
La boucle devra s'arrêter lorsque l'un des chiffres de fete est introuvable dans numtel.
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
4. En supposant que un tableau (ta) soit déjà rempli par des numéros de téléphones des (n) abonnés,
écrire une procédure nommée Aff_Gagnants qui affiche la liste des numéros d'abonnés gagnants à
la fête de l'indépendance (fete ← "203"). Utiliser la fonction EstGagnant.
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................

Exercice 3 – Tirs au but (10 points)

Dhia est un informaticien passionné de football. Il décide de créer un
programme pour simuler des tirs au but (‫ )ركالت ترجيحية‬entre un joueur
humain et l'ordinateur. Le programme fonctionne comme suit :
Étape 1 : Le joueur effectue un tir au but. Dans ce cas :
o Le joueur saisit la direction du tir du ballon : 0 à droite ou 1 à
gauche.
o L'ordinateur choisit aléatoirement la direction dans laquelle son
gardien de buts va se jeter : 0 à droite ou 1 à gauche.

o Si le gardien du but se jette dans la mauvaise direction, le joueur marque un but.

Étape 2 : De même, l'ordinateur effectue son tir. Pour ce faire :
Page 3 sur 5
Devoir de synthèse n°3 – Commun 2e Info
o Il choisit aléatoirement la direction du tir du ballon : 0 à droite ou 1 à gauche.
o Le joueur saisit dans quelle direction se dirige son gardien de but : 0 à droite ou 1 à gauche.
o Si le joueur ne devine pas la direction du ballon, l'ordinateur marque un but.
Étape 3 : À la fin des tirs, le programme affiche le score final ainsi que le gagnant de la partie, ou "Partie
nulle" en fonction du score.
Le joueur et l'ordinateur effectuent 5 tirs à tour de rôle et les résultats des tirs sont enregistrés dans des
tableaux (tj) pour le joueur et (to) pour l'ordinateur.

Soit l’algorithme du programme principal suivant : TDNT

Algorithme Tir_au_but
Début T.D.O.G
Pour i de 0 à 4 faire
Tir_Joueur(tj, i) // Etape 1 Objet Type
Tir_Ordi(to, i) // Etape 2
Fin Pour
Afficher_Gagnant(tj, to) // Etape 3
Fin

Travail demandé
1) Compléter les tableaux TDNT et le TDOG précédents.
2) On donne l’algorithme, de l'étape 2, du module Tir_Ordi :
Procédure Tir_Ordi(@t:tab, indice: entier)
Début
dt  aléa(0,1) // dt : direction de tir de l'ordinateur
Répéter
// cj : choix du joueur, direction du gardien de buts
Ecrire("Prédisez le côté (0: Droite, 1: Gauche) : ") ; Lire(cj)
Jusqu’à (Verif(cj))
t[indice]  (1 - dt) * cj + (1 - cj) * dt Instruction 1
Fin

A. Évaluer la valeur de t[indice], instruction 1, dans les cas suivants :

dt 0 0 1 1
cj 0 1 0 1
t[indice] (1-0)*0+(1-0)*0 = 0 (1-1)*0+(1-0)*1 = 1
B. Remplacer l'instruction 1 par une structure conditionnelle (Si … Alors … Sinon …) afin
d'attribuer les mêmes valeurs à t[indice] en fonction des variables dt et cj.
..........................................................................................................................................................................................................
..........................................................................................................................................................................................................
..........................................................................................................................................................................................................
..........................................................................................................................................................................................................
..........................................................................................................................................................................................................

3) Écrire le module Tir_Joueur, étape 1.

.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
4) Dans le contexte du programme, choisir parmi les propositions suivantes les modules adéquats
permettant de vérifier la saisie de l’utilisateur. Cocher (X) toutes les bonnes réponses.
Page 4 sur 5
Devoir de synthèse n°3 – Commun 2e Info
 
Fonction Verif(n: Entier):Booléen Fonction Verif(n: Entier):Booléen
Début Début
ch  ConvCh(n) Test  Faux
Test  48 ≤ ord(ch) ≤ 49 Si (n=0) ou (n=1) Alors Test  vrai Fin Si
Retourner Test Retourner (Test)
Fin Fin

 
Fonction Verif(n: Entier):Booléen Procédure Verif(n: Entier, @ok: Booléen)
Début Début
Retourner 0 ≤ n < 2 ok  n ∈ [0, 1]
Fin Fin

5) Dans les cas suivants, trouver le score et le gagnant de la partie :

Tableau (tj) Tableau (to) Score Gagnant
tj 1 1 0 1 1 to 1 0 0 1 0 4-2 Joueur Gagne
tj 1 0 0 1 1 to 0 1 1 1 0
tj 0 1 1 0 1 to 1 1 1 0 1
6) Écrire l'algorithme du module Afficher_Gagnant qui:
• Calcule le score du joueur et celui de l'ordinateur à partir des tableaux tj et to.
• Affiche le gagnant de la partie ou "Partie Nulle" selon le score obtenu.
Pour le premier exemple de la question n°5, le programme affiche :
Le score est : 4 - 2
Joueur gagne.
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................
.....................................................................................................................................................................................................................

Page 5 sur 5