Algoritmo de Luhn: evitar errores de transcripción en identificadores numéricos
El conocido como algoritmo de Luhn es un sencillo algoritmo de checksum desarrollador por el científico de IBM Hans Peter Luhn External link en los años 60. También se le conoce como "módulo 10" o "mod10".
Su objetivo es detectar errores al teclear en la transcripción de dígitos. Muchas entidades han decidido utilizar éste algoritmo para evitar que circulen identificadores numéricos que han sido erróneamente introducidos. Por supuesto, si estamos programando una aplicación que acepta un identificador numérico que utiliza el algoritmo de Luhn para validar, debemos comprobar esos números cuando se introducen por teclado y evitaremos graves errores de transcripción. Aunque se inventó en los 60, el algoritmo se ha popularizado porque algunas entidades emisoras de tarjetas de crédito lo utilizan para que se puedan detectar errores de transcripción en los números de sus tarjetas.
Se utiliza en muchos entornos distintos. Por ejemplo:
* Algunas tarjetas de crédito, como Visa, Master Card o Diner's Club (Descrito como estándar ISO-7812-1)
* El CIF (Código de Identificación Fiscal, en España) Con algunas particularidades
* Los números de la seguridad social canadiense
* El número de socio del IEEE
* etc.
El algoritmo de Luhn es muy sencillo. Dado un número de varias cifras que utilice este algoritmo, el último dígito es un dígito de control. Es decir, si vamos a aplicarlo, por ejemplo a un número de tarjeta de crédito de 16 dígitos, aplicamos el algoritmo de Luhn a los 15 primeros, y comprobamos que el checksum obtenido coincide con la cifra 16. Si no, es que ha habido un error de transcripción.
El algoritmo consiste en ir sumando los dígitos (siempre a excepción del último), pero con una particularidad: los dígitos que ocupen una posición impar se multiplican por dos, y se suman individualmente los dígitos del resultado. Alternativamente, también se puede restar 9 si el resultado de multiplicar un número impar es mayor o igual a 10, que da el mismo resultado.
Cuando se han recorrido todos los dígitos, sumando directamente los de las posiciones pares y con la particularidad descrita arriba los de las posiciones impares habremos obtenido una suma s. El dígito de control se obtiene mediante la operación 10-(s mod 10), siendo el operador mod el resto de la división entera. Si el resultado es 10 se entenderá que el dígito de control es 0.
Por ejemplo, los números de las tarjetas de crédito tipo Visa o Master Card se componen de 16 dígitos, que a menudo se escriben en 4 grupos de 4 dígitos, separados por espacios o guiones, de la forma siguiente:
Código:
ABCD-EFGH-IJKL-MNOP
El primer dígito (el que ocupa la posición "A") debe ser un "4" para las tarjetas Visa, y un "5" para las Master Card.
El último dígito (el que ocupa la posición "P") es un dígito de control, que se obtiene de los 15 anteriores, y que sirve para verificar que no han habido errores al transcribir el número.
Este último dígito se obtiene de esta forma:
Código:
Variable numero:vector[1..16] de enteros; //los 16 dígitos
Variable suma,x,y,ultimoDigito:entero
suma:=0
para x:=1 hasta 15
Si x es impar
y:=numero[x]*2
Si y>=10
y:=y-9; //como sumar sus dos digitos
finSi
si no
y:=numero[x];
finSi
suma:=suma+y
finPara
suma:=10-(suma mod 10)
Si suma=10
suma:=0;
ultimoDigito=suma
Obtenido el último dígito, solamente queda comprobar si
Código:
numero[16]=ultimoDigito
Ejemplo:
Supongamos el siguiente número de tarjeta que utilice el algoritmo de Luhn:
Código:
5432-1234-5678-9876
Hacemos una traza...
Código:
x=1 impar y=5*2-9=1 suma=1
x=2 par y=4 suma=1+4=5
x=3 impar y=3*2=6 suma=5+6=11
x=4 par y=2 suma=11+2=13
x=5 impar y=1*2=2 suma=13+2=15
x=6 par y=2 suma=15+2=17
x=7 impar y=3*2=6 suma=17+6=23
x=8 par y=4 suma=23+4=27
x=9 impar y=5*2-9=1 suma=27+1=28
x=10 par y=6 suma=28+6=34
x=11 impar y=7*2-9=5 suma=34+5=39
x=12 par y=8 suma=39+8=47
x=13 impar y=9*2-9=9 suma=47+9=56
x=14 par y=8 suma=56+8=64
x=15 impar y=7*2-9=5 suma=64+5=69
suma=10-(69 mod 10)=10-9=1
Fuente
|
