Luhn-algorithme-wikipedia

Numéro de locomotif avec un montant de test selon l’algorithme Luhn à Deutsche Bahn

Le Algorithme de Luhn ou la Formule de Luhn , également connu sous le nom d’algorithme “modulo 10” ou “mod 10” et en tant que À double-méthode est une méthode simple pour calculer une somme d’essai. Il est devenu dans les années 1950 ^[d’abord] Développé par l’informaticien allemando-américain Hans Peter Luhn et est maintenant sans communauté et très répandu. Entre autres choses, l’algorithme Luhn sert à vérifier les numéros de carte de crédit et les numéros de sécurité sociale canadiens, ISINS et les numéros de compte à sept chiffres de Deutsche Bank et Commerzbank ainsi que de nombreuses banques d’épargne. Il est également utilisé dans le nombre de locomotives et de voitures ferroviaires selon le programme d’étiquetage de l’UIC, comme cela l’a été dans la série Federal Railway.

L’algorithme Luhn reconnaît chaque erreur sur les chiffres individuels, ainsi que dans la plupart des cas d’échanges à partir de chiffres voisins.

L’algorithme Luhn crée un numéro de test, qui est généralement attaché au numéro d’identification incomplet à l’arrière. Il en résulte le nombre complet. Ceci est considéré comme valide s’il existe l’algorithme de test suivant:

1. Parcourez le nombre de droite à gauche et formez la somme des chiffres, mais: double chaque deuxième chiffre, et si une valeur est supérieure à 9, soustrayez 9
2. Si la somme a un 0, reconnaissez le nombre comme valide et autrement pas

Par exemple, le numéro 18937 Pour vérifier, les chiffres sont exécutés et bouleversés de droite à gauche, c’est-à-dire à partir de 7. Chaque deuxième chiffre est doublé, dans cet exemple, les 3 et 8. Étant donné qu’une valeur est supérieure à 9 lorsque le 8 est double, 9 est soustrait, de sorte que 16 – 9 = 7 résultats.

Ainsi, la somme est calculée comme 7 + (2 × 3 ) + 9 + (2 × 8 – 9) + d’abord = 7 + 6 + 9 + 7 + 1 = 30. Étant donné que les 30 se terminent à 0, le nombre est valide.

Techniquement parlant, une sorte de somme croisée du nombre est calculée avec le traitement spécial de chaque deuxième place. Le résultat est réduit le modulo 10; Cela signifie que cela n’a pas d’importance le résultat lui-même, mais uniquement sur le reste qui sort par 10 avec une division entière. Ce repos est la dernière place du résultat.

Si ce repos est 0, qui est synonyme du fait que le résultat est divisible par 10, le nombre est considéré comme valide, sinon non.

L’algorithme Luhn le reconnaît lorsqu’un nombre est accidentellement entré lors de la saisie d’un nombre. Cela modifie la somme d’un montant entre 1 et 9 et n’est donc plus divisible par 10. Si un 4 est entré dans l’exemple ci-dessus au lieu du 1, le résultat 33 et donc non divisible par 10. Si un 6 est entré au lieu du 8, le résultat 26 et donc non divisible par 10.

Une entrée en faux chiffres serait également reconnue en cas de formation de suce transversale normale – pas l’un des «turners nombres» fréquemment qui se présentent, c’est-à-dire l’échange de deux chiffres successifs. Cela ne changerait pas la somme croisée normale.

L’algorithme Luhn reconnaît un tel tour de nombre par le fait qu’un nombre différent est désormais doublé qu’auparavant et que le montant croisé change. Par exemple, le numéro 190 est valide (Luhn Testing Montant 10), 910 Not (Luhn Test Sum 11), c’est-à-dire H. Le numéro Turner 19 à 91 est reconnu. Seuls le nombre de tariveurs des chiffres 0 et 9 sont exclus, car leurs sommes croisées sont les mêmes avec et sans doubler. Par exemple, 190 et 109 sont tous deux valides (Luhn Test Sum 10), c’est-à-dire H. Le numéro Turner 90 à 09 n’est pas reconnu.

Pas L’échange de chiffres est reconnu, dont les positions diffèrent en une quantité droite – par exemple, si, par exemple, les 3e et 5e chiffres ou les 2e et 6e chiffres sont échangés. De même, il peut ne pas être reconnu si deux chiffres ou plus sont incorrectement saisis.

Dans les implémentations suivantes de l’algorithme, le nombre est une chaîne, c’est-à-dire comme une chaîne nombre à la fonction Checkluhn remettre. Dans la fonction, cette chaîne est de gauche à droite d’une manière naturelle – donc vice versa que dans la définition de l’algorithme. Cependant, en déterminant si la longueur de la chaîne est droite ou étrange, il réussit toujours à doubler les chiffres dans les positions correctes.

Pseudo-code [ Modifier | Modifier le texte source ]]

fonction Checkluhn ( chaîne nombre)
{ int somme: = 0 int lng: = longueur (nombre) int parité: = modulo lng 2 pour je depuis 0 pour lng - 1
    { int Chiffre: = Toleger (nombre [i]) si i modulo 2 = parité
        {
            chiffre: = chiffre × 2 si chiffre> 9
                chiffre: = chiffre - 9
        }
        somme: = somme + chiffre
    } retour (Je suis un module 10) = 0
} 

Java [ Modifier | Modifier le texte source ]]

public  statique  booléen  vérifier ( int []  chiffres )  {  int  somme  =  0 ;  int  longueur  =  chiffres . longueur ;  pour  ( int  je  =  0 ;  je  <  longueur ;  je ++ )  {  // Obtenez des chiffres dans l'ordre inverse  int  chiffre  =  chiffres [ longueur  -  je  -  d'abord ]] ;  // chaque 2ème nombre multipliez avec 2  si  ( je  %  2  ==  d'abord )  {  chiffre  * =  2 ;  }  somme  + =  chiffre  >  9  ?  chiffre  -  9  :  chiffre ;  }  retour  somme  %  dix  ==  0 ;  }  

Javascrip [ Modifier | Modifier le texte source ]]

fonction  vérifier ( code )  {  si  ( Nombre . Isnan ( code ))  retour  '' ;  était  seul  =  code . longueur ;  était  parité  =  seul  %  2 ;  était  somme  =  0 ;  pour  ( était  je  =  seul - d'abord ;  je  > =  0 ;  je - )  {  était  d  =  pardent ( code . charat ( je ));  si  ( je  %  2  ==  parité )  {  d  * =  2  }  si  ( d  >  9 )  {  d  - =  9  }  somme  + =  d ;  }  retour  ( somme  %  dix ). tostring ();  }  

Python [ Modifier | Modifier le texte source ]]

def  Checkluhn ( nombre ):  somme  =  0  parité  =  seul ( nombre )  %  2  pour  je ,  chiffre  dans  énumérer ( int ( X )  pour  X  dans  nombre ):  si  je  %  2  ==  parité :  chiffre  * =  2  si  chiffre  >  9 :  chiffre  - =  9  somme  + =  chiffre  retour  somme  %  dix  ==  0  

Ou:

def  Checkluhn ( nombre ):  chiffres  =  liste ( carte ( int ,  nombre ))  retour  0  ==  somme ( chiffres  +  [  d  +  ( d  >  4 )  pour  d  dans  chiffres [ - 2 :: - 2 ]]  ])  %  dix  

VB / VBA [ Modifier | Modifier le texte source ]]

Public  Fonction  Checkluhn ( nombre  Comme  Chaîne )  Comme  Long     Faible  Longueur de chaine  Comme  Long ,  parité  Comme  Long ,  somme  Comme  Long ,  je  Comme  Long ,  chiffre  Comme  Long     Longueur de chaine  =  Seul ( nombre )   parité  =  Longueur de chaine  Contre  2   somme  =  0     Pour  je  =  Longueur de chaine  Pour  d'abord  Marcher  - d'abord   chiffre  =  CLNG ( Milieu ( nombre ,  je ,  d'abord ))                   If (i Mod 2) <> parity Then
            digit = digit * 2
            If digit > 9 Then
                digit = digit - 9
            End If
        End If
        
        sum = sum + digit
    Next i
    checkLuhn = sum Mod 10
End Function

Tsql [ Modifier | Modifier le texte source ]]

CRÉER  FONCTION  FN_CHECKLUHN (   @ Saisir  Nvarchar ( Max )  )   RETOUR  BIT  COMMENCER   DÉCLARER  @ Actuel  Int ;   DÉCLARER  @ Cnt  Int  =  0 ;    DECLARE @Checksum BIGINT = 0;

  -- check if input is numeric, else return null
  IF ISNUMERIC(@Input) = 0
    RETURN NULL

  WHILE @Cnt < LEN(@Input)
    BEGIN
      -- get next rightmost digit
      SET @CurrentDigit = CAST(SUBSTRING(@Input, LEN(@Input) - @Cnt, 1) AS INT);

      -- "add double" every second digit
      SET @CurrentDigit = @CurrentDigit + @CurrentDigit * (@Cnt % 2);

      IF @CurrentDigit > 9
        SET @CurrentDigit = @CurrentDigit - 9;

      SET @Checksum = @Checksum + @CurrentDigit;

      SET @Cnt = @Cnt + 1;
    END

  RETURN IIF(@Checksum % 10 = 0, 1, 0);
END
GO

Le numéro d’identification de l’échantillon 446-667-651 est donné.

La somme 40 est divisée par 10; Le reste est 0 – donc le nombre est valide.

Avec le girocard, le calcul du nombre diffère légèrement. Chaque deuxième chiffre est doublé de la droite (au lieu de la seconde de droite).

1. ↑ Brevet américain n ° 2 950 048 , Inscription soumise le 6 janvier 1954, brevet accordé le 23 août 1960.