Dígito verificador

Origem: Wikipédia, a enciclopédia livre.
Saltar para a navegação Saltar para a pesquisa
Question book.svg
Esta página ou secção não cita fontes confiáveis e independentes, o que compromete sua credibilidade (desde Dezembro de 2008). Por favor, adicione referências e insira-as corretamente no texto ou no rodapé. Conteúdo sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)

Dígito verificador ou algarismo de controle é um mecanismo de autenticação utilizado para verificar a validade e a autenticidade de um valor numérico, evitando dessa forma fraudes ou erros de transmissão ou digitação.

Consiste em um ou mais algarismos acrescentados ao valor original e calculados a partir deste através de um determinado algoritmo. Números de documentos de identificação, de matrícula, cartões de crédito e quaisquer outros códigos numéricos que necessitem de maior segurança utilizam dígitos verificadores.

Utilização[editar | editar código-fonte]

Código de identidade do Deutsche Post / DHL

É usado normalmente em representações numéricas que exijam integridade, como por exemplo:

Exemplos[editar | editar código-fonte]

O método de cálculo desses dígitos varia conforme o caso, porém muitos deles se baseiam em duas rotinas tradicionais: Módulo 11 e Módulo 10.

Abaixo temos uma explicação do cálculo dessas duas rotinas:

Módulo 11[editar | editar código-fonte]

Conforme o esquema abaixo, para calcular o primeiro dígito verificador, cada dígito do número, começando da direita para a esquerda (do dígito menos significativo para o dígito mais significativo) é multiplicado, na ordem, por 2, depois 3, depois 4 e assim sucessivamente, até o primeiro dígito do número. O somatório dessas multiplicações dividido por 11. O resto desta divisão (módulo 11) é subtraido da base (11), o resultado é o dígito verificador. Para calcular o próximo dígito, considera-se o dígito anterior como parte do número e efetua-se o mesmo processo. No exemplo, foi considerado o número 261533:

  +---+---+---+---+---+---+   +---+
  | 2 | 6 | 1 | 5 | 3 | 3 | - | 9 |
  +---+---+---+---+---+---+   +---+
    |   |   |   |   |   |
   x7  x6  x5  x4  x3  x2
    |   |   |   |   |   |
   =14 =36  =5 =20  =9  =6 soma = 90
    +---+---+---+---+---+-> = (90 / 11) = 8, resto 2 => DV = (11 - 2) = 9

Considerando o número 2615336, onde o 6 é o dígito verificador e a validação é através do "módulo 11". Não seria considerado um número válido, pois o número correto é 2615339, onde 9 é o dígito verificador gerado pelo módulo 11.

O CPF utiliza o módulo 11 duas vezes seguidas (conforme o exemplo), obtendo dois dígitos verificadores.

Observações:

  • Para calculo de CPF, CNPJ e similares, sempre que o resto da divisão for 0 ou 1, o dígito será 0.
  • Para o código de barras, sempre que o resto for 0, 1 ou 10, deverá ser utilizado o dígito 1.

Cálculos variantes poderiam ocorrer, tal como substituir por uma letra, quando o cálculo do dígito final der 10 ou outro número escolhido. Exemplos são os casos da utilização do dígito verificador pelo Banco do Brasil, quando o cálculo resulta em 10, o dígito verificador utilizado é o X, e quando resulta em 11, o dígito verificador utilizado é 0, e da Caixa Econômica Federal e Bradesco, que quando o cálculo resulta em 10, o digito verificador utilizado é o 0 (no caso do Bradesco também pode ser P para poupanças).

Módulo 10[editar | editar código-fonte]

Conforme o esquema abaixo, cada dígito do número, começando da direita para a esquerda (menos significativo para o mais significativo) é multiplicado, na ordem, por 2, depois 1, depois 2, depois 1 e assim sucessivamente.

Número exemplo: 261533-4

  +---+---+---+---+---+---+   +---+
  | 2 | 6 | 1 | 5 | 3 | 3 | - | 4 |
  +---+---+---+---+---+---+   +---+
    |   |   |   |   |   |
   x1  x2  x1  x2  x1  x2
    |   |   |   |   |   |
   =2 =12  =1 =10  =3  =6
    +---+---+---+---+---+-> = (16 / 10) = 1, resto 6 => DV = (10 - 6) = 4

Em vez de ser feito o somatório das multiplicações, será feito o somatório dos dígitos das multiplicações (para o exemplo proposto, o resultado da multiplicação 6x2 = 12, resultará na soma dos seus dígitos 1 + 2 = 3; para 5x2 = 10, será 1 + 0 = 1).

O somatório será dividido por 10 e se o resto (módulo 10) for diferente de zero, o dígito será 10 menos este valor. Se o resto (módulo 10) for zero (0) o DV também será zero (0).

Algoritmos[editar | editar código-fonte]

Entre os algoritmos notáveis para o cálculo de dígitos verificadores estão os seguintes:

Realização dos cálculos em C++[editar | editar código-fonte]

O código é bastante simples, consiste em receber uma string representando os números do CPF sem os dígitos verificadores, e um array do tipo short, que será preenchido com os valores da string mais os dígitos verificadores, sendo devolvida tanto a string como o array contendo os dígitos já calculados.

Há também um função que identifica os estados com base no antepenúltimo dígito (quando contado com os verificadores).

#include <iostream>
#include <string.h>

using namespace std;

char* check_cpf(char cpf[], short* nums)
{
	short nums_multiplicados[11];
	short nums_originais[11];
	int numeros = 0;
	int multiplicador = 10;
	int soma = 0;
	int resto = 0;
	int digito = 0;
	for(int i = 0; i < 9; i++)
	{
		numeros = 0;
		if(cpf[i] >= '0' && cpf[i] <= '9')
		{
			nums_originais[i] = cpf[i] - '0';
			nums_multiplicados[i] = nums_originais[i];
			nums_multiplicados[i] = nums_multiplicados[i] * multiplicador--;
		}
		soma += nums_multiplicados[i];
	}
	resto = soma % 11;
	if(resto != 0 && resto != 1)
	{
		digito = 11 - resto;
	}

	nums_originais[9] = digito;
	cpf[9] = '0' + digito;
	multiplicador = 11;
	soma = 0;
	resto = 0;
	digito = 0;
	for(int i = 0; i < 10; i++)
	{

		nums_multiplicados[i] = nums_originais[i];
		nums_multiplicados[i] = nums_multiplicados[i] * multiplicador--;
		soma += nums_multiplicados[i];
	}
	resto = soma % 11;
	if(resto != 0 && resto != 1)
	{
		digito = 11 - resto;
	}
	nums_originais[10] = digito;
	cpf[10] = '0' + digito;
	for(int i = 0; i < 11; i++)
	{
		nums[i] = nums_originais[i];
	}
	return cpf;
}

void cpf_lugar(char cpf[])
{
	switch(cpf[8])
	{
	case '0':
		cout << "Rio Grande do Sul" << endl;
		break;
	case '1':
		cout << "Distrito Federal, Goi s, Mato Grosso, Mato Grosso do Sul e Tocantins" << endl;
		break;
	case '2':
		cout << "Amazonas, Par , Roraima, Amap , Acre e Rond“nia" << endl;
		break;
	case '3':
		cout << "Cear , MaranhÆo e Piau¡" << endl;
		break;
	case '4':
		cout << "Para¡ba, Pernambuco, Alagoas e Rio Grande do Norte" << endl;
		break;
	case '5':
		cout << "Bahia e Sergipe" << endl;
		break;
	case '6':
		cout << "Minas Gerais" << endl;
		break;
	case '7':
		cout << "Rio de Janeiro e Esp¡rito Santo" << endl;
		break;
	case '8':
		cout << "SÆo Paulo" << endl;
		break;
	case '9':
		cout << "Paran  e Santa Catarina" << endl;
		break;
	}
}

//078539806-63 cpf falso para testes

int main(int argc, char *argv[])
{
	short num_cpf[11];
	char cpf[11];
	strcpy(cpf, "078539806");
	cout << check_cpf(cpf, num_cpf) << endl;
	return 0;
}

Ver também[editar | editar código-fonte]

Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.