Re: Pour alimenter la discussion ...

Oui, on peut dire pleins de choses sur la non élégance de cet algo, mais c'est vraiment un truc comme ça que j'ai appris.

C'est le bon algo, avec néanmoins une comparaison inutile entre les deux nombres. Le principe est celui-ci :

1. prendre deux nombres a et b
2. calculer le reste r de la division de a par b
3. si r est nul, b est le pgcd recherché
4. sinon recommencer en 1 avec b et r

et c'est ce que fait ma boucle en un one liner. Il n'est pas nécessaire de chercher à savoir lequel des deux nombres est le plus grand. Si b est plus grand que a, le reste est a, et le point 4 remet tout dans le bon ordre au premier tour. Ensuite, le reste, qui servira de diviseur, sera toujours plus petit que le dividende.

De ce que je lis 40% des élèves n'y arrivaient pas.

J'ai eu beau cherché dans ce document, je ne vois pas d'où tu tires ce nombre. De mémoire, on était bien moins de 60% à y arriver. J'ai raconté cette anecdote pour montrer que le changement de base était accessible à certain élèves de primaires (les plus doués en maths d'entre eux) et qu'il devait donc être une formalité pour des étudiants dans le supérieur (ceux qui font des études d'info). Ceci étant, je me demande la part d'enfants qui appliquent sans comprendre et ceux qui comprennent réellement : la raison leur est enseignée (voir par exemple la chaîne lumni lancée pendant le confinement) mais combien la retienne et la comprenne réellement, je ne le sais.

Ceci étant, je maintiens que, comme pour le pgcg, l'alogrithme est hautement récursif et fonctionnel :

let ajouter_chiffre c1 c2 =
 let res = c1 + c2 in
 if res < 10 then (res, 0) else (res - 10 , 1)
let additionner l1 l2 =
 let rec loop (res, retenue) m n =
 match m, n with
 | c1 :: reste1, c2 :: reste2 ->
 let c, retenue = ajouter_chiffre c1 (c2 + retenue) in
 loop (c ::res, retenue) reste1 reste2
 | [], c :: reste | c :: reste, [] ->
 let c, retenue = ajouter_chiffre c (0 + retenue) in
 loop (c :: res, retenue) [] reste
 | [], [] ->
 List.rev (if retenue = 0 then res else retenue :: res)
 in loop ([], 0) l1 l2
(* 1 + 999 = 1000 *)
additionner [1] [9; 9; 9];;
- : int list = [0; 0; 0; 1]
(* 31 + 35 = 66 *)
additionner [1; 3] [5; 3];;
- : int list = [6; 6]

Ici les nombres sont représentés par une liste de chifres en mode "petit boutiste". Le code lui même reproduit parfaitement les différentes étapes d'apprentissage d'un enfant, et les sources d'erreurs potentielles où il faut prendre garde.

L'on apprend d'abord à ajouter des chiffres de petites tailles. Ma nièce en CP est à ce stade là, elle n'a pas encore à gérer le cas de la retenue dans la fonction ajouter_chiffre. Ensuite, lorsque la somme dépasse la dizaine, on leur enseigne que l'on crée un paquet de dix (ou dizaine) et que l'on garde le reste : deuxième branche du if then else de la fonction ajouter_chiffre. C'est là que se situe l'origine et la raison d'être de la retenue.

Ensuite, lorsque l'on pose l'addition, on a deux listes de chiffres puis l'on a va en construire une autre (sans modifier les deux en entrées) en appliquant itérativement (c'est-à-dire récursivement) l'addition de chiffre sur nos deux listes jusqu'à épuisement complet.

De plus, les différentes branches montre bien deux sources d'erreurs ou de confusion qui arrive au cours de l'apprentissage :

• la première étant qu'un enfant peut ne pas savoir quoi faire lorsqu'il a épuisé une liste mais pas l'autre (deuxième branche du code)
• la seconde étant qu'au début ils leur arrivent souvent d'oublier de redescendre la retenue s'il en reste une à la fin (le if then else de la dernière branche).

Enfin, la méthode est facilement généralisable pour un programmeur (ou un enfant dont le niveau d'abstraction est suffisamment développé). Ici la base est codée en dur dans l'addition de chiffres : il suffit d'en faire un paramètre. ;-)

(* le tilde ~ devant le paramètre est là pour avoir
 un paramètre nommé *)
let ajoute_chiffre ~base c1 c2 =
 let res = c1 + c2 in
 if res < base then (res, 0) else (res - base , 1)
let additionner ~base l1 l2 =
 let rec loop (res, retenue) m n =
 match m, n with
 | c1 :: reste1, c2 :: reste2 ->
 let c, retenue = ajoute_chiffre ~base c1 (c2 + retenue) in
 loop (c ::res, retenue) reste1 reste2
 | [], c :: reste | c :: reste, [] ->
 let c, retenue = ajoute_chiffre c ~base (0 + retenue) in
 loop (c :: res, retenue) [] reste
 | [], [] ->
 List.rev (if retenue = 0 then res else retenue :: res)
 in loop ([], 0) l1 l2
(* exemples *)
(* 31 + 35 = 66 en base 10 *)
additionner ~base:10 [1; 3] [5; 3];;
- : int list = [6; 6]
(* la même en base 16 *)
additionner ~base:16 [15; 1] [3; 2];;
- : int list = [2; 4]
(* puis en base 13 *)
additionner ~base:13 [5; 2] [9; 2];;
- : int list = [1; 5]

Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.