(Creado por el analista de sistemas y docente Leonel Iván Saafigueroa)

---

ALGORITMO DE LUHN

Creado por un científico de IBM, el algoritmo de Luhn es utilizado en la verificación de números de identificación, como en las tarjetas de crédito o el IMEI de los teléfonos móviles.

Son números que usamos todos los días, muy pocas veces nos preguntamos quién los crea, o los motivos por los cuales se dice que solo deben ser compartidos con personas de confianza. El número de las tarjetas consta de 16 dígitos, están separados en grupos de 4 para poder identificarlos mejor, no es porque cada grupo de 4 dígitos signifique una cosa, aunque todo depende de quien emita la tarjeta.

El ingeniero informático Hans Peter Luhn, diseñó en 1954 un algoritmo basado en el principio del módulo aritmético (suma matemática mod-10), que permite la identificación de posibles errores durante la digitación o transmisión de una cantidad considerable de números, por ejemplo durante la digitación de un número de tarjeta por una persona en un formulario web.
Su algoritmo se conoce como “algoritmo o fórmula de Luhn” o “algoritmo de módulo 10“.

Generación del dígito de verificación a través del algoritmo de Luhn

Para generar el dígito de verificación empleando el algoritmo de Luhn se deben seguir estos pasos:

1. En una secuencia de dígitos dada, el dígito de verificación será el último valor, que en principio se desconoce.
2. Partiendo desde la primera posición, se multiplica cada dígito de posición impar por 2. Si el resultado es un número de dos dígitos, entonces se suman estos dos valores, o también podemos restarle 9, el resultado sería el mismo.
3. Se suman todos los dígitos obtenidos.
4. Calculamos el resto de dividir el resultado por 10 (esto en matemáticas se denomina el MOD 10), luego la diferencia que obtenemos entre 10 y este resto nos dará como resultado el dígito verificador (sería la diferencia que falta para llegar al siguiente múltiplo de 10).

Vamos a crear un programa que permita hacer los cálculos del algoritmo de Luhn de forma automática:

Para esta primera versión de programa usaremos una variable llamada ingreso, donde se guardará el número de tarjeta ingresado. Con un condicional si-entonces se analiza que se ingresen exactamente 16 dígitos, de no ser así mostrará una cadena con el mensaje: “Error. Debe ingresar 16 dígitos.“. En un arreglo de 16 dimensiones llamado tarjeta se volcará cada uno de los dígitos que compone el número de tarjeta almacenado en la variable ingreso (lo hará tomando subcadenas del mismo), convirtiéndolo nuevamente al tipo numérico con la función convertiranumero (así se evita problemas con el tipo de datos). Una vez cargado el arreglo con los 16 dígitos, el programa a través de una estructura PARA asignará a la variable i valores que van de 1 a 15, avanzando de a 2 pasos multiplicará las posiciones impares de cada digito por 2, si el resultado es mayor a 9 se le restará 9, volviendo a asignar el resultado en la misma posición del arreglo. Una segunda estructura PARA asignará a la variable i valores que van de 1 a 15, para realizar la suma de los primeros 15 dígitos de los valores del arreglo tarjeta, luego a través de un condicional si-entonces y utilizando el operador algebraico MOD, se calculará si el resto de dividir esa suma por 10 es igual a 0, de ser así se asigna ese resultado a la variable verificador, de lo contrario se asignará el resultado de restarle a 10 ese valor. Por último con otro condicional si-entonces se analiza si el valor de la variable verificador es igual al último dígito almacenado en el arreglo tarjeta, de ser así significa que el número es correcto y mostrará la cadena con el mensaje : “El número de tarjeta ES CORRECTO.“, si no es igual mostrará la cadena con el mensaje: 
”El número de tarjeta NO ES CORRECTO“, luego de esto y solo para nuestro control, se muestra cuál tendría que ser el digito verificador para los 15 dígitos de la tarjeta ingresada.

Analizamos el código:

Algoritmo LUHN1
	Escribir 'Ingrese los 16 dígitos de su tarjeta:'
	Leer ingreso
	// Dimensionamos un arreglo
	Dimensionar tarjeta(16)
	Si longitud(ingreso)=16 Entonces
		Para i<-1 Hasta 16 Con Paso 1 Hacer
			tarjeta[i] <- convertiranumero(subcadena(ingreso,i,i))
		FinPara
		Para i<-1 Hasta 15 Con Paso 2 Hacer
			tarjeta[i] <- tarjeta[i]*2
			Si tarjeta[i]>9 Entonces
				tarjeta[i] <- tarjeta[i]-9
			FinSi
		FinPara
		Para i<-1 Hasta 15 Con Paso 1 Hacer
			verificador <- verificador+tarjeta[i]
		FinPara
		// Calculamos el resto de dividir el total del verificador por 10
		// Si es igual a 0, asignamos 0 a la variable verificador
		// de lo contrario asignamos la diferencia del resto para llegar a 10.
		Si verificador MOD 10=0 Entonces
			verificador <- 0
		SiNo
			verificador <- 10-(verificador MOD 10)
		FinSi
		// Analizamos si el número verificador obtenido es igual al último digito de la tarjeta.
		Si verificador=tarjeta[16] Entonces
			Escribir 'El número de la tarjeta ES CORRECTO.'
		SiNo
			Escribir 'El número de la tarjeta NO ES CORRECTO.'
		FinSi
	SiNo
		Escribir 'Error. Debe ingresar 16 dígitos.'
	FinSi
FinAlgoritmo

Ejecutamos el programa:

Veamos el código en C++ (comentado línea por línea):

// LUHN1
#include <iostream>
#include <cstdlib>

using namespace std;

int main() {
  // Solicitar al usuario que ingrese los 16 dígitos de la tarjeta.
  string ingreso;
  cout << "Ingrese los 16 dígitos de su tarjeta: ";
  cin >> ingreso;

  // Verificar si la longitud del ingreso es exactamente 16 caracteres.
  if (ingreso.length() == 16) {
    // Declarar un arreglo para almacenar los 16 dígitos como enteros.
    int tarjeta[16];

    // Convertir cada carácter del string a un entero y almacenarlo en el arreglo.
    for (int i = 0; i < 16; ++i) {
      tarjeta[i] = ingreso[i] - '0'; // Restamos '0' para convertir caracteres ASCII a enteros.
    }

    // Calcular la suma verificador siguiendo las reglas del algoritmo Luhn.
    int verificador = 0;
    for (int i = 0; i < 15; i += 2) { // Iterar sobre cada segundo dígito.
      tarjeta[i] *= 2;          // Duplicar el valor del dígito.
      if (tarjeta[i] > 9) {       // Si el resultado es mayor a 9, restarle 9.
        tarjeta[i] -= 9;
      }
    }

    // Sumar todos los valores resultantes del cálculo anterior.
    for (int i = 0; i < 15; ++i) {
      verificador += tarjeta[i];
    }

    // Calcular el dígito verificador final.
    if (verificador % 10 == 0) {
      verificador = 0;
    } else {
      verificador = 10 - (verificador % 10);
    }

    // Validar si el dígito verificador calculado coincide con el último dígito ingresado.
    if (verificador == tarjeta[15]) {
      cout << "El número de la tarjeta ES CORRECTO." << endl;
    } else {
      cout << "El número de la tarjeta NO ES CORRECTO." << endl;
    }

  } else {
    // Mostrar un mensaje de error si la longitud del ingreso no es 16 caracteres.
    cout << "Error. Debe ingresar 16 dígitos." << endl;
  }

  return 0;
}

Ahora el código en PYTHON (comentado línea por línea):

# LUHN1
ingreso = input("Ingrese los 16 dígitos de su tarjeta:")
tarjeta = []
verificador = 0
if len(ingreso) == 16:
    for i in range (0, 16):
        tarjeta.append(int(ingreso[i:i+1]))
    for i in range (0, 15,2):
        tarjeta[i] = tarjeta[i]*2
        if tarjeta[i] > 9:
            tarjeta[i] = tarjeta[i]-9
    for i in range (0, 15):
        verificador = verificador + tarjeta[i]
    # Calculamos el resto de dividir el total del verificador por 10
    # Si es igual a 0, asignamos 0 a la variable verificador
    # de lo contrario asignamos la diferencia del resto para llegar a 10.
    if verificador%10 == 0:
        verificador = 0
    else:
        verificador = 10-(verificador%10)
    # Analizamos si el número verificador obtenido es igual al último digito de la tarjeta.
    if verificador == tarjeta[15]:
        print("El número de la tarjeta ES CORRECTO.")
    else:
        print("El número de la tarjeta NO ES CORRECTO.")
else:
    print("Error. Debe ingresar 16 dígitos.")

Modificamos el programa anterior para que al introducir los primeros 15 dígitos de la tarjeta nos dé como resultado el dígito verificador.

En el siguiente ejemplo nos pondremos en el lugar de la entidad bancaria que emite las tarjetas, y ver cómo calcular directamente el dígito verificador.

Son necesarias solo unas pequeñas modificaciones, eliminamos el último condicional si-entonces, para mostrar directamente como resultado el dígito verificador. Además se debe de ingresar 15 dígitos en vez de 16.

Analizamos el código:

Algoritmo LUHN2
	Escribir "Ingrese 15 números para generar el Dígito verificador:"
	Leer ingreso
	// Dimensionamos un arreglo
	Dimension tarjeta[16]
	Si longitud(ingreso)=15 Entonces
		Para i <- 1 Hasta 15 Con Paso 1 Hacer
			tarjeta[i] <- convertiranumero(subcadena(ingreso,i,i))
		FinPara
		Para i <- 1 Hasta 15 con Paso 2 Hacer
			tarjeta[i] <- tarjeta[i]*2
			Si tarjeta[i]>9 Entonces
				tarjeta[i] <- tarjeta[i]-9
			FinSi
		FinPara
		Para i <- 1 Hasta 15 Con Paso 1 Hacer
			verificador <- verificador+tarjeta[i]
		FinPara
		// Calculamos el resto de dividir el total del verificador por 10
		// Si es igual a 0, asignamos 0 a la variable verificador
		// de lo contrario asignamos la diferencia del resto para llegar a 10.
		Si verificador mod 10 = 0 Entonces
			verificador <- 0
		SiNo
			verificador <- 10-(verificador mod 10)
		FinSi
		// Mostramos el dígito resultante.
		Escribir "El dígito verificador es: ",verificador
	SiNo
		Escribir "Error. Debe ingresar 15 dígitos."
	FinSi
FinAlgoritmo 

Ejecutamos el programa:

Ingresamos los siguiente 15 dígitos: “439818598367000“, luego presionamos la tecla ENTER.

El programa nos responde con la cadena: “El Dígito verificador es: 2“.
Por lo tanto, el número de tarjeta junto a su número verificador seria: “4398185983670002“.

El resultado del programa coincide con nuestros cálculos, todo parece funcionar bien.

Veamos el código en C++ (comentado línea por línea):

// LUHN2
#include <iostream>
#include <cstdlib>

using namespace std;

int main() {
  // Solicitar al usuario que ingrese los 15 dígitos para calcular el verificador.
  string ingreso;
  cout << "Ingrese 15 números para generar el Dígito verificador: ";
  cin >> ingreso;

  // Verificar si la longitud del ingreso es exactamente 15 caracteres.
  if (ingreso.length() == 15) {
    // Declarar un arreglo para almacenar los 15 dígitos como enteros.
    int tarjeta[15];

    // Convertir cada carácter del string a un entero y almacenarlo en el arreglo.
    for (int i = 0; i < 15; ++i) {
      tarjeta[i] = ingreso[i] - '0'; // Restamos '0' para convertir caracteres ASCII a enteros.
    }

    // Calcular la suma verificador siguiendo las reglas del algoritmo Luhn.
    int verificador = 0;
    for (int i = 0; i < 15; i += 2) { // Iterar sobre cada segundo dígito.
      tarjeta[i] *= 2;          // Duplicar el valor del dígito.
      if (tarjeta[i] > 9) {       // Si el resultado es mayor a 9, restarle 9.
        tarjeta[i] -= 9;
      }
    }

    // Sumar todos los valores resultantes del cálculo anterior.
    for (int i = 0; i < 15; ++i) {
      verificador += tarjeta[i];
    }

    // Calcular el dígito verificador final.
    if (verificador % 10 == 0) {
      verificador = 0;
    } else {
      verificador = 10 - (verificador % 10);
    }

    // Mostrar el dígito resultante.
    cout << "El dígito verificador es: " << verificador << endl;

  } else {
    // Mostrar un mensaje de error si la longitud del ingreso no es 15 caracteres.
    cout << "Error. Debe ingresar 15 dígitos." << endl;
  }

  return 0;
}

Ahora el código en PYTHON (comentado línea por línea):

# LUHN2
ingreso = input("Ingrese 15 números para generar el Dígito verificador:")
tarjeta = []
verificador = 0
if len(ingreso) == 15:
    for i in range (0, 15):
        tarjeta.append(int(ingreso[i:i+1]))
    for i in range (0, 15,2):
        tarjeta[i] = tarjeta[i]*2
        if tarjeta[i] > 9:
            tarjeta[i] = tarjeta[i]-9
    for i in range (0, 15):
        verificador = verificador + tarjeta[i]
    # Calculamos el resto de dividir el total del verificador por 10
    # Si es igual a 0, asignamos 0 a la variable verificador
    # de lo contrario asignamos la diferencia del resto para llegar a 10.
    if verificador%10 == 0:
        verificador = 0
    else:
        verificador = 10-(verificador%10)
    # Mostramos el dígito resultante.
    print(f"El dígito verificador es: {verificador}")
else:
    print("Error. Debe ingresar 15 dígitos.")

Modificamos el programa para crear un generador de números de tarjetas al azar.

En esta nueva versión se incorpora un arreglo nuevo de 16 dimensiones llamado t, en el cual se asignará de forma aleatoria números del 0 al 9, estos dígitos representan en conjunto a la tarjeta elegida al azar. Agregamos una estructura mientras, que se ejecutará hasta que la variable llamada ok deje de valer 0, analizando si el número es válido, de no ser así volverá a asignar nuevos números al arreglo t para volver a verificar una y otra vez hasta encontrar uno que si lo sea, una vez encontrado se asigna a la variable ok el valor 1 para poder salir de la estructura mientras y finalizar la ejecución del programa.

Analizamos el código:

Algoritmo LUHN3
	ok <- 0
	// Dimensionamos los arreglos.
	Dimension tarjeta[16]
	Dimension t[16]
	Mientras ok=0 hacer // Buscará números de tarjetas al azar hasta encontrar uno válido.
		Escribir "Generando un nuevo número de tarjeta al azar..."
		verificador <- 0 // Asignamos 0 a la variable.
		Para i <- 1 Con Paso 1 Hasta 16 Hacer
			t[i] <- Aleatorio(0,9)
			tarjeta[i] <- t[i]
		FinPara
		Escribir "Intentando con el número: ",t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8],t[9],t[10],t[11],t[12],t[13],t[14],t[15],t[16]
        Para i <- 1 Hasta 15 con Paso 2 Hacer
            tarjeta[i] <- tarjeta[i]*2
            Si tarjeta[i]>9 Entonces
                tarjeta[i] <- tarjeta[i]-9
            FinSi
        FinPara
        Para i <- 1 Hasta 15 Con Paso 1 Hacer
            verificador <- verificador+tarjeta[i]
        FinPara
        // Calculamos el resto de dividir el total del verificador por 10
        // Si es igual a 0, asignamos 0 a la variable verificador
        // de lo contrario asignamos la diferencia del resto para llegar a 10.
        Si verificador mod 10 = 0 Entonces
            verificador <- 0
        SiNo
            verificador <- 10-(verificador mod 10)
        FinSi
        // Analizamos si el número verificador obtenido es igual al último digito de la tarjeta.
		Si verificador=tarjeta[16] Entonces
			Escribir "El número de tarjeta ES CORRECTO: ",t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8],t[9],t[10],t[11],t[12],t[13],t[14],t[15],t[16]
			ok <- 1
		SiNo
			Escribir "El número de tarjeta NO ES CORRECTO..."
		FinSi
	FinMientras
FinAlgoritmo 

Ejecutamos el programa:

Veamos el código en C++ (comentado línea por línea):

// LUHN3
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main() {
  // Inicializar generador de números aleatorios.
  srand(time(NULL)); // Iniciamos la semilla random con la hora.

  int ok = 0; // Flag para indicar si se encontró un número válido.
  int verificador = 0;

  // Dimensionar los arreglos.
  int t[16];
  int tarjeta[16];

  cout << "Generando un nuevo número de tarjeta al azar..." << endl;

  while (ok == 0) {
    // Generar 16 números aleatorios.
    for (int i = 0; i < 16; ++i) {
      t[i] = rand() % 10; // Genera un valor entre 0 y 9.
      tarjeta[i] = t[i];
    }

    cout << "Intentando con el número:" << endl;
    // Imprimir la tarjeta generada.
    for (int i = 0; i < 16; ++i) {
      cout << t[i];
    }
    cout << endl;

// Calcular la suma verificador siguiendo las reglas del algoritmo Luhn.
    int verificador = 0;
    for (int i = 0; i < 15; i += 2) { // Iterar sobre cada segundo dígito.
      tarjeta[i] *= 2;          // Duplicar el valor del dígito.
      if (tarjeta[i] > 9) {       // Si el resultado es mayor a 9, restarle 9.
        tarjeta[i] -= 9;
      }
    }
    // Sumar todos los valores resultantes del cálculo anterior.
    for (int i = 0; i < 15; ++i) {
      verificador += tarjeta[i];
    }
    // Calcular el dígito verificador final.
    if (verificador % 10 == 0) {
      verificador = 0;
    } else {
      verificador = 10 - (verificador % 10);
    }

    if (verificador == tarjeta[15]) {
      cout << "El número de la tarjeta ES CORRECTO: ";
      for (int i = 0; i < 16; ++i) {
        cout << t[i];
      }
      cout << endl;
      ok = 1; // Se encontró un número válido.
    } else {
      cout << "El número de la tarjeta NO ES CORRECTO." << endl;
    }
  }
  return 0;
}

Ahora el código en PYTHON (comentado línea por línea):

# LUHN3
import random
ok = 0
verificador = 0
# Dimensionamos los arreglos.
t = [0] * 16 
tarjeta = [0] * 16
print("Generando un nuevo número de tarjeta al azar...")
while ok == 0:
    for i in range (0, 16):
        t[i] = random.randint(0,9)
        tarjeta[i] =t[i]
    print("Intentando con el número:")
    print(f"{t[0]}{t[1]}{t[2]}{t[3]}{t[4]}{t[5]}{t[6]}{t[7]}{t[8]}{t[9]}{t[10]}{t[11]}{t[12]}{t[13]}{t[14]}{t[15]}")
    for i in range (0, 15,2):
        tarjeta[i] = tarjeta[i]*2
        if tarjeta[i] > 9:
            tarjeta[i] = tarjeta[i]-9
    for i in range (0, 15):
        verificador = verificador + tarjeta[i]
    # Calculamos el resto de dividir el total del verificador por 10
    # Si es igual a 0, asignamos 0 a la variable verificador
    # de lo contrario asignamos la diferencia del resto para llegar a 10.
    if verificador%10 == 0:
        verificador = 0
    else:
        verificador = 10-(verificador%10)
    # Analizamos si el número verificador obtenido es igual al último digito de la tarjeta.
    if verificador == tarjeta[15]:
        print(f"El número de la tarjeta ES CORRECTO: {t[0]}{t[1]}{t[2]}{t[3]}{t[4]}{t[5]}{t[6]}{t[7]}{t[8]}{t[9]}{t[10]}{t[11]}{t[12]}{t[13]}{t[14]}{t[15]}")
        ok = 1
    else:
        print("El número de la tarjeta NO ES CORRECTO.")

Creamos una versión mejorada del generador de números de tarjetas

Una última versión de nuestro programa podría ser más óptimo, en vez de elegir 16 dígitos y probar una y otra vez, podría elegir solo los primeros 15 dígitos de forma aleatoria y calcular el dígito verificador, para luego mostrar como resultado un número de tarjeta válido creado de un solo intento.

En esta nueva versión reducimos las dimensiones de los arreglos a 15, se genera el número verificador y luego se muestra en pantalla el número resultante de tarjeta.

Analizamos el código:

Algoritmo LUHN4
	Escribir "Generando número de tarjeta al azar..."
	// Dimensionamos los arreglos.
	Dimension tarjeta[15]
	Dimension t[15]
	Para i <- 1 Con Paso 1 Hasta 15 Hacer
		t[i] <- Aleatorio(0,9)
		tarjeta[i] <- t[i]
	FinPara
	Para i <- 1 Hasta 15 Con Paso 2 Hacer
		tarjeta[i] <- tarjeta[i]*2
		Si tarjeta[i] > 9 Entonces
			tarjeta[i] <- tarjeta[i]-9
		FinSi
	FinPara
	Para i <- 1 Con Paso 1 Hasta 15 Hacer
		verificador <- verificador+tarjeta[i]
	FinPara
	// Calculamos el resto de dividir el total del verificador por 10
	// Si es igual a 0, asignamos 0 a la variazble verificador
	// de lo contrario asignamos la diferencia del resto para llegar a 10.
	Si verificador mod 10 = 0 Entonces
		verificador <- 0
	SiNo
		verificador <- 10-(verificador mod 10)
	FinSi
	// Mostramos el número de tarjeta generado.
	Escribir t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8],t[9],t[10],t[11],t[12],t[13],t[14],t[15],verificador
FinAlgoritmo

Ejecutamos el programa:

Veamos el código en C++ (comentado línea por línea):

// LUHN4
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main() {
  // Inicializar generador de números aleatorios.
  srand(time(NULL)); // Iniciamos la semilla random con la hora.

  int verificador = 0;

  // Dimensionar los arreglos.
  int t[15];
  int tarjeta[15];

  cout << "Generando número de tarjeta al azar..." << endl;

  // Generar 15 números aleatorios.
  for (int i = 0; i < 15; ++i) {
    t[i] = rand() % 10; // Genera un valor entre 0 y 9.
    tarjeta[i] = t[i];
  }

// Calcular la suma verificador siguiendo las reglas del algoritmo Luhn.
  for (int i = 0; i < 15; i += 2) { // Iterar sobre cada segundo dígito.
    tarjeta[i] *= 2;                // Duplicar el valor del dígito.
    if (tarjeta[i] > 9) {           // Si el resultado es mayor a 9, restarle 9.
      tarjeta[i] -= 9;
    }
  }
  // Sumar todos los valores resultantes del cálculo anterior.
  for (int i = 0; i < 15; ++i) {
    verificador += tarjeta[i];
  }
  // Calcular el dígito verificador final.
  if (verificador % 10 == 0) {
    verificador = 0;
  } else {
    verificador = 10 - (verificador % 10);
  }

  //Mostramos el número de tarjeta generado.

  for (int i = 0; i < 15; ++i) {
        cout << t[i];
        }
  cout << verificador;

  return 0;
}

Ahora el código en PYTHON (comentado línea por línea):

# LUHN4
import random
verificador = 0
# Dimensionamos los arreglos.
t = [0] * 16 
tarjeta = [0] * 16
print("Generando número de tarjeta al azar...")
for i in range (0, 15):
    t[i] = random.randint(0,9)
    tarjeta[i] =t[i]
for i in range (0, 15,2):
    tarjeta[i] = tarjeta[i]*2
    if tarjeta[i] > 9:
        tarjeta[i] = tarjeta[i]-9
for i in range (0, 15):
    verificador = verificador + tarjeta[i]
# Calculamos el resto de dividir el total del verificador por 10
# Si es igual a 0, asignamos 0 a la variable verificador
# de lo contrario asignamos la diferencia del resto para llegar a 10.
if verificador%10 == 0:
    verificador = 0
else:
    verificador = 10-(verificador%10)
# Mostramos el número de tarjeta generado.
print(f"{t[0]}{t[1]}{t[2]}{t[3]}{t[4]}{t[5]}{t[6]}{t[7]}{t[8]}{t[9]}{t[10]}{t[11]}{t[12]}{t[13]}{t[14]}{verificador}")