Présentation⚓︎
Sur éduscol, on trouve des documents d'accompagnements
Algorithmique et programmation
Et une liste d'activités possibles.
Nous nous en inspirons ici, pour quelques carnets.
Formation des enseignants⚓︎
Travaux du groupe 1⚓︎
Correction
""" EXERCICES corrigés par Franck CHAMBON """
from math import sqrt
def sont_proches(x, y, précision=10**-12):
"Renvoie un booléen : les nombres x et y sont-ils proches ?"
return abs(x - y) < précision
def symétrie_centrale(point_O, point_M):
"""
Renvoie le symétrique de point_M par rapport à point_O
"""
x_O, y_O = point_O
x_M, y_M = point_M
return (2*x_O - x_M, 2*y_O - y_M)
# Tests
assert symétrie_centrale((0, 0), (4, -6)) == (-4, 6)
assert symétrie_centrale((1, -1), (4, -6)) == (-2, 4)
def max_2(n, m):
"Renvoie le plus grand entier parmi n et m"
if n > m:
return n
else:
return m
# Tests
assert max_2(5, 7) == 7
assert max_2(5, 5) == 5
assert max_2(5, 2) == 5
def max_3(n_1, n_2, n_3):
"Renvoie le nombre le plus grand parmi n_1, n_2 et n_3"
n = max_2(n_1, n_2)
return max_2(n, n_3)
# Tests
assert max_3(1, 5, 7) == 7
assert max_3(5, 8, 5) == 8
assert max_3(9, 5, 2) == 9
def est_triangle_constructible(a, b, c):
"""Renvoie un booléen : le triangle de côtés (a, b, c)
est-il constructible ?
"""
grand_côté = max_3(a, b, c)
périmètre = a + b + c
return 2 * grand_côté < périmètre
# équivalent à : grand_côté < (périmètre - grand_côté)
# Tests
assert est_triangle_constructible(1, 1, 1) == True
assert est_triangle_constructible(6, 9, 2) == False
def est_multiple_3_xor_5_V1(n):
"""Renvoie un booléen : n est-il multiple de 3 ou de 5,
mais pas des deux ?
"""
n_divisible_par_3 = n % 3 == 0
n_divisible_par_5 = n % 5 == 0
if n_divisible_par_3 and n_divisible_par_5:
return False
elif n_divisible_par_3 or n_divisible_par_5:
return True
else:
return False
# Tests
assert est_multiple_3_xor_5_V1(45) == False
assert est_multiple_3_xor_5_V1(35) == True
assert est_multiple_3_xor_5_V1(12) == True
assert est_multiple_3_xor_5_V1(7) == False
def est_multiple_3_xor_5_V2(n):
"""Renvoie un booléen : n est-il multiple de 3 ou de 5,
mais pas des deux ?
# variante avec xor logique : bool_1 != bool_2
"""
n_divisible_par_3 = n % 3 == 0
n_divisible_par_5 = n % 5 == 0
return n_divisible_par_3 != n_divisible_par_5
# Tests
assert est_multiple_3_xor_5_V2(45) == False
assert est_multiple_3_xor_5_V2(35) == True
assert est_multiple_3_xor_5_V2(12) == True
assert est_multiple_3_xor_5_V2(7) == False
def est_multiple_3_xor_5_V3(n):
"""Renvoie un booléen : n est-il multiple de 3 ou de 5,
mais pas des deux ?
# variante avec xor logique : bool_1 != bool_2
"""
if n % 3 == 0:
if n % 5 == 0:
return False
else:
return True
else:
return (n % 5 == 0)
# Tests
assert est_multiple_3_xor_5_V3(45) == False
assert est_multiple_3_xor_5_V3(35) == True
assert est_multiple_3_xor_5_V3(12) == True
assert est_multiple_3_xor_5_V3(7) == False
def est_bissextile(année):
"Renvoie un booléen : année est-elle bissextile ?"
if année % 400 == 0:
return True
elif année % 100 == 0:
return False
elif année % 4 == 0:
return True
else:
return False
# Tests
est_bissextile(2000) == True
est_bissextile(1900) == False
est_bissextile(2020) == True
est_bissextile(2021) == False
def nb_jours_V1(année, mois):
"""Renvoie le nombre de jours de année avec mois.
mois est entier de 0 à 11 :
0 (janvier) |-> 31
1 (février) |-> 28
...
11 (décembre) |-> 31
"""
if mois == 1:
if est_bissextile(année):
return 29
else:
return 28
elif mois in [3, 5, 8, 10]:
return 30
else:
return 31
def nb_jours_V2(année, mois):
"""Renvoie le nombre de jours de année avec mois.
mois est entier de 0 à 11 :
0 (janvier) |-> 31
1 (février) |-> 28
...
11 (décembre) |-> 31
"""
if mois == 1:
if est_bissextile(année):
return 29
else:
return 28
elif mois > 6:
mois = mois - 7
return 31 - mois % 2
# Tests
for mois in range(12):
for année in range(1900, 2022):
assert nb_jours_V1(année, mois) == nb_jours_V2(année, mois)
def est_vecteur_nul(x, y):
"Renvoie un booléen : le vecteur (x, y) est-il nul ?"
return sont_proches(x, 0) and sont_proches(y, 0)
def sont_paralleles(point_A, point_B, point_C, point_D):
"""Renvoie un booléen : les droites (AB) et (CD) sont-elles parallèles ?
si A et B sont confondus, ou C et D, les droites n'existent pas,
on renvoie une erreur.
"""
x_A, y_A = point_A
x_B, y_B = point_B
x_C, y_C = point_C
x_D, y_D = point_D
# vecteurs AB et CD
x_AB = x_B - x_A
y_AB = y_B - y_A
x_CD = x_D - x_C
y_CD = y_D - y_C
if est_vecteur_nul(x_AB, y_AB):
raise ValueError("Les points A et B sont confondus !")
if est_vecteur_nul(x_CD, y_CD):
raise ValueError("Les points C et D sont confondus !")
déterminant = (x_AB * y_CD) - (x_CD * y_AB)
return sont_proches(déterminant, 0)
# Tests
A = (0, 0)
B = (0, 5)
C = (4, 3)
D = (4, -2)
assert sont_paralleles (A, B, C, D) == True
D = (5, -2)
assert sont_paralleles (A, B, C, D) == False
def est_triangle_equilateral(point_A, point_B, point_C):
"Renvoie un booléen : le triangle ABC est-il équilatéral ?"
x_A, y_A = point_A
x_B, y_B = point_B
x_C, y_C = point_C
# vecteurs AB, BC et CA
x_AB = x_B - x_A
y_AB = y_B - y_A
x_BC = x_C - x_B
y_BC = y_C - y_B
x_CA = x_A - x_C
y_CA = y_A - y_C
# carrés des modules
AB2 = (x_AB * x_AB) + (y_AB * y_AB)
BC2 = (x_BC * x_BC) + (y_BC * y_BC)
CA2 = (x_CA * x_CA) + (y_CA * y_CA)
return sont_proches(AB2, BC2) and sont_proches(BC2, CA2)
# Tests
A = (0, 0)
B = (6, 0)
C = (3, 5)
assert est_triangle_equilateral (A, B, C) == False
D = (3, sqrt(27))
assert est_triangle_equilateral (A, B, D) == True
def sont_alignés(point_A, point_B, point_C):
"Renvoie un booléen : les 3 points sont-ils alignés ?"
x_A, y_A = point_A
x_B, y_B = point_B
x_C, y_C = point_C
# vecteurs AB et BC
x_AB = x_B - x_A
y_AB = y_B - y_A
x_BC = x_C - x_B
y_BC = y_C - y_B
déterminant = (x_AB * y_BC) - (x_BC * y_AB)
return sont_proches(déterminant, 0)
# Tests
assert sont_alignés((0, 0), (-1, -1), (2, 2)) == True
assert sont_alignés((3, 0), (1, 1), (6, 1)) == False
r_2 = sqrt(2)
assert sont_alignés((4, 2), (3*r_2, r_2), (1 + 2*r_2, 1 + r_2)) == True
Travaux du groupe 2⚓︎
Alignements de trois points⚓︎
Commentaires et correction basées sur cette proposition
Une solution plus mathématique : utiliser le déterminant
Et avec les élèves comment faire ?
- Réaliser l'approche mathématique en classe, sur papier, pour décrire la méthode. Faire quelques exercices "à la main"
- Introduire le code aux élèves, presque donné
def vecteur(point_A, point_B):
"Renvoie les coordonnées du vecteur AB"
x_A, y_A = point_A
x_B, y_B = point_B
return (x_B - x_A, y_B - y_A)
def déterminant(vecteur_u, vecteur_v):
"Renvoie le déterminant des vecteurs u et v"
x_u, y_u = vecteur_u
x_v, y_v = vecteur_v
return x_u * y_v - x_v * y_u
def sont_alignés(point_A, point_B, point_C):
"""Renvoie un booléen :
les points A, B et C sont-ils alignés ?"""
vecteur_AB = vecteur(..., ...)
vecteur_AC = vecteur(..., ...)
dét = déterminant(..., ...)
return dét == 0
- On travaille la première fonction
vecteuravec les élèves sur une première série de points (à coordonnées entières et non entières). - On demande aux élèves de le faire tout seul avec une seconde série de points (à coordonnées entières et non entières).
- On travaille la seconde fonction
déterminantavec les élèves sur une première série de vecteurs. - On demande aux élèves de le faire tout seul avec une seconde série de vecteurs (à coordonnées entières et non entières).
La notion de valeur approchée est apparue sur les différents exemples : en travaillant avec des fractions ou des racines carrées, les résultats sont arrondis automatiquement par Python
- Compléter avec les élèves la fonction
sont_alignéset expliquer la dernière ligne comprenant==. - On travaille avec les élèves sur quelques exemples à coordonnées entières la fonction
sont_alignés. - On donne un exemple bien choisi à coordonnée non entière sur lequel la fonction
sont_alignésmarche : \(A(-3\,;\, 0,\!5), B(-1\,;\,1), C(2\,;\,1,\!75)\), ou encore \(A(0\,;\,\frac{1}{3}), B(1\,;\,\frac{2}{3}), C(3\,;\,\frac{4}{3})\) - On donne un exemple bien choisi à coordonnée non entière sur lequel la fonction
sont_alignésne marche pas :\(A(0\,;\,\frac{1}{3})\), \(B(1\,;\,\frac{2}{3})\), \(C(2\,;\,1)\) ou encore \(A(4\,;\,2)\), \(B(3\sqrt{2}\,;\,\sqrt{2})\), \(C(1+2\sqrt{2}\,;\,1+\sqrt{2})\)
On fait alors comprendre que le test == 0 doit être rigoureusement exact. Or suivant les arrondis effectués, cela ne l'est pas. On peut faire tester aux élèves en console 0.1 + 0.1 + 0.1 == 0.3
On peut donc maintenant introduire la fonction sont_proches qui permet de résoudre le problème de presque l'égalité entre flottants.
Autour de l'arithmétique en seconde⚓︎
Un carnet Jupyter proposé par Bernard comme point de départ.
La correction du sujet proposée
Avec réponses
Autour de la résolution d'équation⚓︎
On vous propose de travailler sur différentes méthodes au travers d'un carnet Jupyter. Un carnet à compléter pour les enseignants en stage (travail sur les graphiques) et à discuter : c'est ici
et bien sûr (TODO à revoir) le Jupyter avec les graphiques corrigés.
Des exercices rapides à faire avec les élèves⚓︎
Une fonction simple (géométrie) : un exemple en seconde Travailler les conditions : Un exemple simple sur le prix d'un billet de car qui peut aussi devenir un exemple plus complexe Les suites et les algorithmes de seuil : un exemple de coccinelle avec deux fonctions ou un exemple plus classique sur les capitaux
Des questions flash⚓︎
Une banque de questions flash à faire en fin de séance : https://ens-fr.gitlab.io/flash/