Algorithmique et programmation

1. a)$47=6\times 7+5$ : $47//6$ vaut le quotient, 7. (0,5)
2. b)Avec la même division, $47$ vaut le reste, 5. (0,5)
3. c)$float$ : la division $/$ donne toujours un flottant (ici $2.0$). (0,5)
4. d)4, 9, 14 et 19 : on part de 4 avec un pas de 5, et la borne 20 est exclue. (0,5)
5. e)Les entiers 0, 1, 2, 3, 4 et 5 : les deux bornes sont comprises. (0,5)
6. f)x = x + 2 (le membre de droite est calculé, puis rangé dans x). (0,5)
7. g)$3>2$ vaut True, donc $not(3>2)$ vaut False. (0,5)
8. h)La puissance passe avant l’addition : $3^2$ vaut 9, puis on ajoute 1 : le résultat est 10. (0,5)

Repère — // donne le quotient, % le reste, / un flottant ; range exclut sa borne de droite, randint inclut les deux.

1. a)

   Ligne	x	y
   x = 4	4	—
   y = 9	4	9
   x = y - x	$9-4=5$	9
   y = y + x	5	$9+5=14$

   (1)
2. b)Au moment du print, x vaut 5 et y vaut 14 : le script affiche $514$. (1)
3. c)y = y + x donne $y=9+4=13$, puis x = y - x donne $x=13-4=9$. L’affichage devient $913$. (1)
4. d)Chaque affectation utilise les valeurs des variables au moment où elle est exécutée : modifier y avant de calculer x change la donnée utilisée dans le calcul de x. (1)

Méthode — Une colonne par variable, une ligne par instruction : le membre de droite se calcule avec la ligne précédente.

1. a)On teste d’abord le cas du forfait :

   def prix(h):
       if h > 8:
           return 14
       else:
           return 2.4 + 1.6 * (h - 1)

   (1)
2. b)$prix(1)$ $=2,4+1,6\times 0=2,40$ € ; $prix(5)$ $=2,4+1,6\times 4=2,4+6,4=8,80$ € ; $prix(9)$ $=14$ € (forfait, car $9>8$). (1)
3. c)Pour 8 heures, on n’est pas au-delà de 8 heures : $2,4+1,6\times 7=2,4+11,2=13,60$ €, moins que le forfait. Le forfait ne s’applique qu’à partir de 9 heures, et coûte alors moins que le tarif horaire ($2,4+1,6\times 8=15,20$ €). (1)
4. d)Le test $h>=1$ est vrai pour toutes les durées autorisées : son bloc est exécuté et le elif n’est jamais examiné. Le forfait n’est jamais appliqué. Il faut tester d’abord le cas le plus restrictif, $h>8$. (1)

Piège — Dans un if / elif, seul le premier test vrai compte : le cas le plus restrictif se teste en premier.

1. a)Le pas 2 ne parcourt que les impairs 1, 3, 5, …, 99 :

   S = 0
   for k in range(1, 100, 2):
       S = S + k
   print(S)

   (1)
2. b)Les termes sont $2k-1$ pour $k$ de 1 à 50 : il y en a 50. On les regroupe par paires : $1+99=3+97=\dots =49+51=100$, soit 25 paires de somme 100. La somme vaut $25\times 100=2500$. (1)
3. c)Le nombre de termes n’est pas connu d’avance : boucle while, avec la condition contraire de l’arrêt ($S>1000$).

   S = 0
   n = 0
   while S <= 1000:
       n = n + 1
       S = S + n
   print(n)

   (1)
4. d)Pour $n=44$ : ${\displaystyle \frac{44\times 45}{2}}=990$, qui n’est pas supérieur à 1 000. Pour $n=45$ : ${\displaystyle \frac{45\times 46}{2}}=1035>1000$. Comme la somme augmente avec n, le plus petit entier cherché est $n=45$. (1)

Choisir la boucle — Nombre de tours connu : for. Nombre de tours cherché : while, avec le contraire de la condition d’arrêt.

1. a)Un secteur au hasard parmi 12 se simule par $randint(1,12)$ (bornes comprises) ; la comparaison est un booléen, que l’on peut renvoyer directement :

   from random import randint
   
   def gagne():
       return randint(1, 12) <= 3

   (1)
2. b)On compte les gains, puis on divise par le nombre de tours :

   def frequence(n):
       c = 0
       for i in range(n):
           if gagne():
               c = c + 1
       return c / n

   (1)
3. c)Les 12 secteurs étant identiques, la situation est équiprobable : la probabilité de gagner vaut ${\displaystyle \frac{3}{12}}=0,25$. Pour 10 000 tours, on attend une fréquence proche de 0,25, mais pas exactement égale. (1)
4. d)Une fréquence observée fluctue d’une simulation à l’autre autour de la probabilité. Les écarts, $0,25-0,2457=0,0043$ et $0,2546-0,25=0,0046$, sont faibles et compatibles avec le hasard. De plus, ces résultats viennent d’une simulation, pas de la roue réelle : ils ne peuvent rien prouver sur elle. (1)

Fréquence et probabilité — La fréquence simulée approche la probabilité sans l’atteindre : elle fluctue d’une exécution à l’autre.