Vous êtes sur la page 1sur 11

21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

éparation à l'entretien Pratique par sujet C++ Java Python Programmation compétitive Apprent

Algorithme de Luhn
Niveau de difficulté : Moyen ● Dernière mise à jour : 26 mai 2021

L'algorithme de Luhn, également connu sous le nom d'algorithme module 10 ou mod 10 ,

est une formule de somme de contrôle simple utilisée pour valider une variété de numéros

d'identification, tels que les numéros de car te de crédit, les numéros IMEI, les numéros

d'assurance sociale du Canada. L a formule LUHN a été créée à la fin des années 1960 par

un groupe de mathématiciens. Peu de temps après, les sociétés émettrices de car tes de

crédit l'ont adopté. Parce que l'algorithme est dans le domaine public, il peut être utilisé

par n'impor te qui. L a plupar t des car tes de crédit et de nombreux numéros d'identification

gouvernementaux utilisent l'algorithme comme méthode simple pour distinguer les

numéros valides des numéros mal saisis ou incorrects. Il a été conçu pour protéger contre

les erreurs accidentelles, et non contre les attaques malveillantes.

Étapes impliquées dans l'algorithme de Luhn

Comprenons l'algorithme avec un exemple : 

Prenons l'exemple d'un numéro de compte « 79927398713 ». 

Étape 1 - En par tant du chiffre le plus à droite, doublez la valeur de chaque deuxième

chiffre, 

Attention lecteur ! N'arrêtez pas d'apprendre maintenant. Obtenez tous les concepts

impor tants de DS A avec le cours DSA à un r ythme adapté aux étudiants et devenez

prêt pour l'industrie. Pour compléter votre préparation de l'apprentissage d'une

langue à DS Algo et bien d'autres, veuillez vous référer au cours complet de

préparation aux entretiens .

Si vous souhaitez assister à des cours en direct avec des exper ts, veuillez vous référer

aux cours en direct DSA pour les professionnels et à la programmation compétitive

en direct pour les étudiants .

https://www.geeksforgeeks.org/luhn-algorithm/ 1/11
21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

Global Trade Starts Here

Étape 2 – Si le doublement d'un nombre donne un nombre à deux chiffres, c'est-à-dire

supérieur à 9 (par exemple, 6 × 2 = 12), alors ajoutez les chiffres du produit (par exemple,

12 : 1 + 2 = 3, 15 : 1 + 5 = 6), pour obtenir un numéro à un chiffre. 

https://www.geeksforgeeks.org/luhn-algorithm/ 2/11
21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

Étape 3 – Prenez maintenant la somme de tous les chiffres.

Étape 4 – Si le total modulo 10 est égal à 0 (si le total se termine par zéro) alors le nombre

est valide selon la formule de Luhn ; sinon ce n'est pas valable.

Comme la somme est de 70 qui est un multiple de 10, le numéro de compte est peut-être

valide. 

Recommandé : veuillez d'abord essayer votre approche sur {IDE} , avant de passer à la

solution.

L'idée est simple ; nous traversons depuis la fin. Pour chaque deuxième chiffre, nous le

doublons avant de l'ajouter. On additionne deux chiffres du nombre obtenu après

doublement.  

https://www.geeksforgeeks.org/luhn-algorithm/ 3/11
21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

C++

// C++ program to implement Luhn algorithm


#include <bits/stdc++.h>
using namespace std;
 
// Returns true if given card number is valid
bool checkLuhn(const string& cardNo)
{
    int nDigits = cardNo.length();
 
    int nSum = 0, isSecond = false;
    for (int i = nDigits - 1; i >= 0; i--) {
 
        int d = cardNo[i] - '0';
 
        if (isSecond == true)
            d = d * 2;
 
        // We add two digits to handle
        // cases that make two digits after
        // doubling
        nSum += d / 10;
        nSum += d % 10;
 
        isSecond = !isSecond;
    }
    return (nSum % 10 == 0);
}
 
// Driver code
int main()
{
    string cardNo = "79927398713";
    if (checkLuhn(cardNo))
        printf("This is a valid card");
    else
        printf("This is not a valid card");
    return 0;
}

Java

// Java program to implement


// Luhn algorithm
import java.io.*;
 
class GFG {
     
// Returns true if given
// card number is valid
static boolean checkLuhn(String cardNo)

https://www.geeksforgeeks.org/luhn-algorithm/ 4/11
21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

{
    int nDigits = cardNo.length();
 
    int nSum = 0;
    boolean isSecond = false;
    for (int i = nDigits - 1; i >= 0; i--)
    {
 
        int d = cardNo.charAt(i) - '0';
 
        if (isSecond == true)
            d = d * 2;
 
        // We add two digits to handle
        // cases that make two digits
        // after doubling
        nSum += d / 10;
        nSum += d % 10;
 
        isSecond = !isSecond;
    }
    return (nSum % 10 == 0);
}
 
    // Driver code
    static public void main (String[] args)
    {
        String cardNo = "79927398713";
        if (checkLuhn(cardNo))
            System.out.println("This is a valid card");
        else
            System.out.println("This is not a valid card");
     
    }
}
 
// This Code is contributed by vt_m.

P ython3

# Python3 program to implement


# Luhn algorithm
 
# Returns true if given card
# number is valid
def checkLuhn(cardNo):
     
    nDigits = len(cardNo)
    nSum = 0
    isSecond = False
     
    for i in range(nDigits - 1, -1, -1):
        d = ord(cardNo[i]) - ord('0')
     
https://www.geeksforgeeks.org/luhn-algorithm/ 5/11
21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

        if (isSecond == True):


            d = d * 2
  
        # We add two digits to handle
        # cases that make two digits after
        # doubling
        nSum += d // 10
        nSum += d % 10
  
        isSecond = not isSecond
     
    if (nSum % 10 == 0):
        return True
    else:
        return False
 
# Driver code  
if __name__=="__main__":
     
    cardNo = "79927398713"
     
    if (checkLuhn(cardNo)):
        print("This is a valid card")
    else:
        print("This is not a valid card")
 
# This code is contributed by rutvik_56

C#

// C# program to implement
// Luhn algorithm
using System;
 
class GFG {
     
// Returns true if given
// card number is valid
static bool checkLuhn(String cardNo)
{
    int nDigits = cardNo.Length;
 
    int nSum = 0;
    bool isSecond = false;
    for (int i = nDigits - 1; i >= 0; i--)
    {
 
         int d = cardNo[i] - '0';
 
        if (isSecond == true)
            d = d * 2;
 
        // We add two digits to handle
        // cases that make two digits
https://www.geeksforgeeks.org/luhn-algorithm/ 6/11
21/11/2021 17:24 Algorithme de Luhn - GeeksforGeeks

        // after doubling


        nSum += d / 10;
        nSum += d % 10;
 
        isSecond = !isSecond;
    }
    return (nSum % 10 == 0);
}
 
    // Driver code
    static public void Main()
    {
        String cardNo = "79927398713";
        if (checkLuhn(cardNo))
            Console.WriteLine("This is a valid card");
        else
            Console.WriteLine("This is not a valid card");
     
    }
}
 
// This Code is contributed by vt_m.

Javascript

<script>
    // Javascript program to implement Luhn algorithm
     
    // Returns true if given
    // card number is valid
    function checkLuhn(cardNo)
    {
        let nDigits = cardNo.length;
 
        let nSum = 0;
        let isSecond = false;
        for (let i = nDigits - 1; i >= 0; i--)
        {
 
            let d = cardNo[i].charCodeAt() - '0'.charCodeAt();
 
            if (isSecond == true)
                d = d * 2;
 
            // We add two digits to handle
            // cases that make two digits
            // after doubling
            nSum += parseInt(d / 10, 10);
            nSum += d % 10;
 
            isSecond = !isSecond;
        }
        return (nSum % 10 == 0);
    }
https://www.geeksforgeeks.org/luhn-algorithm/ 7/11
21/11/2021 17:25 Algorithme de Luhn - GeeksforGeeks

     
    let cardNo = "79927398713";
    if (checkLuhn(cardNo))
      document.write("This is a valid card");
    else
      document.write("This is not a valid card");
     
</script>

Sor tir: 

Ceci est une carte valide

L'algorithme de Luhn détecte toute erreur à un seul chiffre, ainsi que presque toutes les

transpositions de chiffres adjacents. 

Cet ar ticle est une contribution de Vishal Kumar Gupta . Si vous aimez GeeksforGeeks et

que vous souhaitez contribuer, vous pouvez également écrire un ar ticle en utilisant

write.geeksforgeeks.org ou envoyer votre ar ticle à contribute@geeksforgeeks.org.

Consultez votre ar ticle apparaissant sur la page principale de GeeksforGeeks et aidez les

autres Geeks.

Veuillez écrire des commentaires si vous trouvez quelque chose d'incorrect ou si vous

souhaitez par tager plus d'informations sur le sujet abordé ci-dessus.

Global Trade Starts Here

Comme 0
https://www.geeksforgeeks.org/luhn-algorithm/ 8/11
21/11/2021 17:25 Algorithme de Luhn - GeeksforGeeks
Comme 0

Précédent Prochain

ARTICLES RECOMMANDÉS Rubrique : 1 2 3

Algorithme Karatsuba pour une Un algorithme sur place pour la


01 05
multiplication rapide à l'aide de transformation de chaîne
l'algorithme Divide and Conquer 15, 12 octobre

18, 13 avr.

Algorithme de Manacher - Sous-


06
chaîne palindromique la plus longue
Algorithme naïf pour la recherche de en temps linéaire - Partie 1
02
motifs 16, 14 déc.

01, 11 avr.

Algorithme de Manacher - Sous-


07
Algorithme KMP pour la recherche chaîne palindromique la plus longue
03
de modèles en temps linéaire - Partie 2
16, 14 déc.
03, 11 avr.

Algorithme de Manacher - Sous-


08
Algorithme de Boyer Moore pour la chaîne palindromique la plus longue
04
recherche de modèles en temps linéaire - Partie 3
26, 12 mai 17, 14 déc.

Ar ticle contribué par :

GeekspourGeeks

Votez pour la difficulté

Difficulté actuelle :
Moyenne

F il N l M
https://www.geeksforgeeks.org/luhn-algorithm/
D E 9/11
21/11/2021 17:25 Algorithme de Luhn - GeeksforGeeks
Facile Normal Moyen Dur Expert

Amélioré par : vt_m, Shubham Bansal 13, networkofp, rutvik_56, suresh07

Mots clés de l'article : cryptographie, Cordes


Mots-clés de pratique : Cordes, cryptographie

Améliorer l'article Signaler un problème

Ecrire du code en commentaire ? Veuillez utiliser ide.geeksforgeeks.org , générer un lien et partager le lien ici.

Charger les commentaires

5e étage, A-118,

secteur-136, Noida, Uttar Pradesh - 201305


feedback@geeksforgeeks.org

Société Apprendre
À propos de nous Algorithmes
Carrières Structures de données
Politique de confidentialité Langues
Nous contacter Sujets CS
Politique de droit d'auteur Tutoriels vidéos

Développement web Contribuer


Tutoriels Web Ecrire un article
HTML Rédiger une expérience d'entrevue
CSS Des stages
JavaScript Vidéos
https://www.geeksforgeeks.org/luhn-algorithm/ 10/11
21/11/2021 17:25 Algorithme de Luhn - GeeksforGeeks

Amorcer

@geeksforgeeks , Certains droits réservés

https://www.geeksforgeeks.org/luhn-algorithm/ 11/11

Vous aimerez peut-être aussi