Algorithme de Luhn

---
De nombreux identifiants numériques (numéros de carte bancaire, IMEI de téléphones, numéros de client, etc.) intègrent un mécanisme de contrôle destiné à détecter les erreurs courantes de saisie (inversion de deux chiffres, oubli d’un chiffre, faute de frappe).
L’[algorithme de Luhn](https://fr.wikipedia.org/wiki/Formule_de_Luhn) (1954) est une méthode simple qui permet de vérifier rapidement si une suite de chiffres est cohérente. Attention : cela ne prouve pas qu’une carte existe ou qu’elle soit utilisable ; cela vérifie seulement que le numéro respecte une règle arithmétique.
Le but de cette activité est d'implémenter cet algorithme.
Objectifs : manipuler des chaînes et des listes, parcourir des données, raisonner sur les indices (positions paires/impaires) et structurer une solution en fonctions réutilisables.
Éthique & sécurité : ce travail est un exercice pédagogique. Ne saisissez jamais de vrais numéros personnels. Utilisez uniquement les exemples fournis ou des numéros de test.
\
**FONCTION 1**
Écrire une fonction `somme(liste_entiers)` qui prend en paramètre une liste d'entiers et qui renvoie la somme des éléments de la liste. Ne pas utiliser la fonction `sum()`. Renvoyer `0` si la liste est vide.
Exemple : `somme([1, 1, 3, 8])` renvoie `13`
\
**FONCTION 2**
Écrire une fonction `valide(entier)` qui prend en paramètre un entier et qui renvoie `True` si l'entier est un multiple de `10`, `False` sinon.
Exemples : `valide(237)` renvoie `False` et `valide(5150)` renvoie `True`
**Méthode 1** : utiliser `if` et `else`.
**Méthode 2** : écrire le corps de la fonction en une ligne.
\
**FONCTION 3**
Écrire une fonction `en_liste(entier)` qui prend en paramètre un entier et renvoie une liste de ses chiffres.
Exemple : `en_liste(4815162342)` renvoie `[4, 8, 1, 5, 1, 6, 2, 3, 4, 2]`
**Méthode 1** : utiliser `str()`, `int()` et une boucle.
**Méthode 2** : méthode 1 en une ligne avec une compréhension de liste.
**Méthode 3** : utiliser le quotient et le reste de la division entière et `insert()`.
\
**FONCTION 4**
Écrire une fonction `double_un_sur_deux(liste_chiffres)` qui prend en paramètre une liste de chiffres et renvoie une liste où l’on a doublé les chiffres dont les indices sont pairs (0, 2, 4, …). Si le résultat de la multiplication par deux dépasse 9, on lui retire 9.
Exemple : `double_un_sur_deux([2, 4, 6, 0, 1])` renvoie `[4, 4, 3, 0, 2]`
\
**FONCTION 5**
Écrire une fonction `luhn(entier)` qui prend en paramètre un entier et qui renvoie `True` si l'entier correspond à un numéro de carte valide, `False` sinon. Cette fonction doit utiliser les quatre fonctions précédentes.
PORTÉE D'EXÉCUTION DU CODE :
exécution partagée (toutes les cellules partagent le même environnement)
PROGRAMME 1
CODE ÉLÈVE
# somme(liste_entiers)
CODE ENSEIGNANT
assert somme([1, 2, 3]) == 6
assert somme([0]) == 0
assert somme([7]) == 7
assert somme([]) == 0
assert somme([0, 0, 0]) == 0
assert somme([10, -3, -7]) == 0
assert somme([-1, -2, -3]) == -6
assert somme([5, 0, 5, 0, 5]) == 15
print('OK')
SOLUTION POSSIBLE
PROGRAMME 2
CODE ÉLÈVE
# valide(entier)
CODE ENSEIGNANT
assert valide(10) is True
assert valide(20) is True
assert valide(30) is True
assert valide(1) is False
assert valide(237) is False
assert valide(9999) is False
print('OK')
SOLUTION POSSIBLE
PROGRAMME 3
CODE ÉLÈVE
# en_liste(entier)
CODE ENSEIGNANT
assert en_liste(4815162342) == [4,8,1,5,1,6,2,3,4,2]
assert en_liste(0) == [0]
assert en_liste(7) == [7]
assert en_liste(12) == [1,2]
print('OK')
SOLUTION POSSIBLE
PROGRAMME 4
CODE ÉLÈVE
# double_un_sur_deux(liste_chiffres)
CODE ENSEIGNANT
assert double_un_sur_deux([2, 4, 6, 0, 1]) == [4, 4, 3, 0, 2]
assert double_un_sur_deux([0]) == [0]
assert double_un_sur_deux([1]) == [2]
assert double_un_sur_deux([9]) == [9]
print('OK')
SOLUTION POSSIBLE
PROGRAMME 5
CODE ÉLÈVE
# luhn(entier)
CODE ENSEIGNANT
assert luhn(8812110905111955) == False
assert luhn(4137894711755904) == True
assert luhn(4111111111111111) == True
assert luhn(5555555555554444) == True
print('OK')
SOLUTION POSSIBLE