Este artigo tem por objetivo demonstrar o uso do Algoritmo de Lunh aplicado ao cálculo do digito verificador do número IMEI de um celular, porém antes de iniciarmos a explicação em si do algoritmo, vamos primeiro entender o que vem a ser o número de IMEI.
IMEI é um acrônimo para International Mobile Equipment Identity, e este é uma identificação global e única para cada telefone celular. O IMEI está para o celular assim como o MAC Address está para a Placa de Rede.
E qual o principal objetivo deste número? Há um Banco de Dados de Registro de Identidade de equipamentos (EIR) responsável por armazenar todos os IMEIs de todos os equipamentos móveis válidos no mundo, com isso você pode ligar a qualquer momento para a ANATEL e pedir o bloqueio de determinado aparelho pelo seu número de IMEI.
Assim como o CPF, o número de IMEI também possui digito verificador, que tem por função validar se aquele IMEI é válido. O algoritmo de Lunh faz essa validação que veremos mais a seguir.
Algoritmo de Lunh para Validar IMEI
A validação do número de IMEI é baseada em três passos:
- Começando da direita para esquerda, de dois em dois dígitos o valor deste deve ser dobrado. Por exemplo: Aplicando a primeira regra ao número 345672, ficaria da seguinte maneira:
3(mantido) 8(dobrado) 5(mantido) 12(dobrado) 7(mantido) 4(dobrado) - O segundo passo é somar todos os dígitos, porém os valores de foram “dobrados” devem ser somados se este possuírem mais de um dígito, ou seja, se dobramos de “6” para “12”, deve-se somar “1+2=3” antes de somar este com os outros dígitos.
Por exemplo, dado o número 345672, que possui o resultado 3 8 5 12 7 4 após aplicado o primeiro passo, vamos aplicar agora o segundo passo:
3 + 8 + 5 + (1+2) + 7 + 4 = 30 - Enfim o último passo é verificar se o resultado da soma é divisível por 10, e o dígito verificador são os números que devemos adicionar ao resultado para torná-lo divisível por 10, caso não haja necessidade de adicionar nenhum número, significa que o digito verificador é 0.
Mas é óbvio que antes de iniciar os 3 passos acima você deve certificar-se que há 15 dígitos no número, pois este é o tamanho fixo do número do IMEI. No exemplo acima usamos apenas 6 dígitos para não estender muito a explicação de cada passo, porém você não deve começar a verificar o IMEI se ele não possuir 15 dígitos exatos.
Exemplo prático
Para exemplificar o uso real deste algoritmo, vamos pegar um exemplo real e realizar o passo 1, 2 e 3, além de mostrar a implementação em Java do algoritmo completo.
Suponha que tenhamos que validar o IMEI de número 35 780502 398494 9. Vamos seguir o passo a passo abaixo para validar este IMEI.
- Retire o digito verificar do IMEI e dobre os valores de duas em duas casas decimais. Veja como fazer abaixo:
3 5 7 8 0 5 0 2 3 9 8 4 9 4
3 10 7 16 0 10 0 4 3 18 8 8 9 8
- Vamos realizar a somatória de todos os dígitos, lembrando de somar antes os números com dois dígitos:
3 + (1+0) + 7 + (1+6) + 0 + (1+0) + 0 + 4 + 3 + (1+8) + 8 + 8 + 9 + 8 = 68
- Enfim temos o resultado 68 que não é divisível por 10 (sabemos disso por seu resultado divido por 10 não é zero). Vamos acrescentar quanto for necessário para torná-lo divisível por 10, neste caso vamos acrescer o número de 2, que nos dá o resultado final de 70, que agora é divisível por 10.
O valor acrescido (2) é o nosso dígito verificador, agora só precisamos conferir se esse dígito verificador gerado pelo algoritmo é igual ao dígito verificador que nos foi passado com o número. Como o dígito verificador passado foi 9, sabemos então que este IMEI é inválido.
Para complementar o aprendizado vamos usar o algoritmo de lunh em uma aplicação Java mostrada na Listagem 1.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class AlgoritmoLuhn {
private static boolean validar(String numero) {
try {
int soma = 0;
for (int i = 0; i < 15; i++) {
soma = soma
+ calculoDoDigito((Integer.parseInt(String.valueOf(numero
.charAt(i)))), (i + 1) % 2 == 0);
}
if (soma % 10 == 0)
return true;
else
return false;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
private static int calculoDoDigito(int valorSemDigito, boolean indexKey) {
if (indexKey) {
int number = valorSemDigito * 2;
while (number > 9) {
number = Integer.parseInt(String.valueOf(String.valueOf(number)
.charAt(0)))
+ Integer.parseInt(String.valueOf(String
.valueOf(number).charAt(1)));
}
return number;
} else {
return valorSemDigito;
}
}
/**
* @param args
*/
public static void main(String[] args) {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
System.in));
boolean isValid = false;
while (!isValid) {
System.out.println();
System.out.println("--------------------------------------");
System.out
.println("Digite o número do IMEI: [Digite 'exit' para sair]");
String numero = in.readLine();
if (numero.equals("exit")) {
System.out.println("Aplicação finalizada");
return;
}
if (validar(numero)) {
System.out.println("O IMEI " + numero + " é válido.");
isValid = true;
} else
System.out.println("O IMEI " + numero + " é inválido.");
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}O código apresentado em Java foi apenas para simplificar o uso do algoritmo de Lunh, porém o mesmo pode ser aplicado a qualquer linguagem. Basta que o desenvolvedor tenha a habilidade de “traduzi-lo” para a respectiva linguagem.
