Algoritmo para Validar CPF

Quando se está trabalhando em um sistema corporativo, é comum a necessidade de validar CPF. Muita gente não sabe que um CPF para ser válido não basta apenas atender à máscara “###.###.###-##” (o caractere ‘#’ representa um número), existe uma regra matemática que também deve ser verificada para um CPF ser considerado válido. Se você acha que é complicado verificar se um CPF é válido ou não, você vai se surpreender!

exemplo de CPF

Regra para validar CPF

O cálculo para validar um CPF é especificado pelo Ministério da Fazenda, que disponibiliza no próprio site as funções (em javascript) para validação de CPF. Vamos entender como funciona.

O CPF é formado por 11 dígitos numéricos que seguem a máscara “###.###.###-##”, a verificação do CPF acontece utilizando os 9 primeiros dígitos e, com um cálculo simples, verificando se o resultado corresponde aos dois últimos dígitos (depois do sinal “-“).

Vamos usar como exemplo, um CPF fictício “529.982.247-25”.

Validação do primeiro dígito

Primeiramente multiplica-se os 9 primeiros dígitos pela sequência decrescente de números de 10 à 2 e soma os resultados. Assim:

5 * 10 + 2 * 9 + 9 * 8 + 9 * 7 + 8 * 6 + 2 * 5 + 2 * 4 + 4 * 3 + 7 * 2

O resultado do nosso exemplo é:

295

O próximo passo da verificação também é simples, basta multiplicarmos esse resultado por 10 e dividirmos por 11.

295 * 1011

O resultado que nos interessa na verdade é o RESTO da divisão. Se ele for igual ao primeiro dígito verificador (primeiro dígito depois do ‘-‘), a primeira parte da validação está correta.

Observação Importante: Se o resto da divisão for igual a 10, nós o consideramos como 0.

Vamos conferir o primeiro dígito verificador do nosso exemplo:

O resultado da divisão acima é ‘268’ e o RESTO é 2

Isso significa que o nosso CPF exemplo passou na validação do primeiro dígito.

Validação do segundo dígito

A validação do segundo dígito é semelhante à primeira, porém vamos considerar os 9 primeiros dígitos, mais o primeiro dígito verificador, e vamos multiplicar esses 10 números pela sequencia decrescente de 11 a 2. Vejamos:

5 * 11 + 2 * 10 + 9 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 2 * 5 + 4 * 4 + 7 * 3 + 2 * 2

O resultado é:

347

Seguindo o mesmo processo da primeira verificação, multiplicamos por 10 e dividimos por 11.

347 * 10 / 11

Verificando o RESTO, como fizemos anteriormente, temos:

O resultado da divisão é ‘315’ e o RESTO é 5

Verificamos, se o resto corresponde ao segundo dígito verificador.

Com essa verificação, constatamos que o CPF 529.982.247-25 é válido.

CPFs inválidos conhecidos

Existe alguns casos de CPFs que passam nessa validação que expliquei, mas que ainda são inválidos. É os caso dos CPFs com dígitos repetidos (111.111.111-11, 222.222.222-22, …)

Esses CPF atendem à validação, mas ainda são considerados inválidos.

No nosso algoritmo, vamos verificar se todos os dígitos do CPF são iguais e, neste caso, considerar que ele é inválido.

Algoritmo para validar CPF

Agora que já aprendemos como acontece a validação de um CPF, vamos ver como ficaria um algoritmo para validar CPF. Vamos escrever o algoritmo em Portugal utilizando o Visualg.

No algoritmo abaixo, eu criei uma função chamada validaCPF(cpf:CARACTER) que retorna verdadeiro ou falso se o CPF for ou não válido.

Se você não sabe o que é uma função, leia este artigo.

Perceba que testamosa nossa função com três CPFs, um inválido e outro válido e um inválido conhecido. O resultado da execução deste algoritmo é esse.

Também utilizei algumas funções pré-definidas pelo Visualg para extrair cada caracter da variável cpf e para convertê-los em números inteiros. As funções que utilizei foram:

  • Caracpnum (c : caracter): inteiro
    • Esta função serve para converter um valor do tipo texto em um valor do tipo inteiro
  • Copia (c : caracter ; p, n : inteiro): caracter
    • Esta função serve para extrair sub-textos de variáveis texto.
    • Ela recebe três parâmetros, o primeiro é o texto de onde vamos extrair o sub-texto, o segundo é a posição de inicio do sub-texto e o terceiro parâmetro é a quantidade de caracteres que vamos extrair.

No nosso caso, nós extraímos os dígitos do cpf através da função copia e convertemos o resultado desta função em inteiro através da função caracpnum.

Por exemplo, para o cpf “529.982.247-25” a linha abaixo atribui o valor inteiro 8 à variável num5, pois este é o caracter da posição 6 (contando o caracter ponto “.”).

Outro detalhe interessante é o operador mod que retorna o resto da divisão.

Claro que pode-se implementar de outras formas, com Vetores, LOOPs, etc. Entretanto eu tentei implementar de uma forma mais simples de entender a regra.

Se quiser entender cada recurso utilizado neste algoritmo leia os artigos abaixo.

Estrutura de decisão SE-ENTAO-SENAO
O que são Funções e Procedimentos?
Você sabe usar os Operadores Aritméticos em programação?
Conheça os Operadores Relacionais!
O que são tipos de dados primitivos?
Quer aprender programação? Saiba qual a melhor linguagem!

Entendendo como funciona o algoritmo, você torna-se capaz de validar CPF em qualquer linguagem.

Algoritmo para Validar CPF
4.83 (96.67%) 102 votos
  • Join

    Muito interessante. Vou implementar em C.

  • Daniel Gomes

    Muito bom mesmo.Agora é só praticar.

  • Eu não entendi o porque do 5 * 10 + 2 , porque esse + 2 no final ?
    Desde já , agradeço.

    • Marcelo, perceba que a expressão ainda não terminou …
      5 * 10 + 2 * 9 + …
      Ou seja, 2 (o segundo número do CPF) * 9.

      • muitobom@gmail.com

        muito bom

  • Gerson W. Barbosa

    O programa que enviei ontem tinha um erro: quando o primeiro dígito verificador era 10 ( = 0 ), o segundo dígito era calculado erradamente. Agora está correto:

    ————————-

    Program CPF;
    Uses Crt;
    var d1,d2, i: Byte;
    s, t: Integer;
    n: Longint;
    begin
    ClrScr;
    Read(n);
    s:=0;
    t:=0;
    for i:=1 to 9 do
    begin
    s:=s+(10-i)*(n Mod 10);
    t:=t+i*(n Mod 10);
    n:=n div 10
    end;
    if (s Mod 11)=10 then
    t:=t+9;
    d1:=(s Mod 11) Mod 10;
    d2:=(t Mod 11) Mod 10;
    GotoXY(10,1);
    WriteLn(‘-‘,d1:1,d2:1)
    end.

    ————————-

    Run

    123456789

    123456789-09
    Type EXIT to return…

    —————————

    Note-se que o programa não é exatamente um validador de CPF, mas pode ser facilmente modificado para tal. Dados os primeiros nove dígitos do CPF, os dois dígitos verificadores são calculados usando um algoritmo diferente daquele disponível no site da Receita (e mais simples).
    Estou sem o Dev-C++ instalado, mas acho que o código Pascal é suficientemente claro para demonstrar o algoritmo.

  • Estava procurando por este algoritmo Gustavo.
    Obrigado por posta-lo.

  • e como fazer esse algoritmo de validação de cpf sem usar função??

  • CRISTIANO LOPES BORGES

    QUERO UM LINK PARA ACESSA SUA BIBLIOGRAFIA POR QUE ESTOU FAZENDO UM TRABALHO ACADEMICO PRA UNOPAR

  • CRISTIANO LOPES BORGES

    CARO GUSTAVO QUERO UM LINK PARA ACESSA SUA BIBLIOGRAFIA POR QUE ESTOU FAZENDO UM TRABALHO ACADEMICO PRA UNOPAR

  • Paulo Quadros

    Eu fiz exatamente assim, mas achei um “furo” na formula.
    Sempre que o CPF for numeros repetidos (111111111-11, 222222222-22 … 999999999-99) ele passa como valido, mas nos sites de validacao aparecem como invalidos, entao deve ter algum erro na formula, imagino eu. Ja fiz na mao o teste (papel e caneta) e realmente, nesta formula passada no algoritimo, o CPF 111111111-11 seria valido.
    Qual a formula correta? Encontrei algo parecido em outro site.
    Nesse aqui: http://www.geradorcpf.com/algoritmo_do_cpf.htm
    Testem ai, valeu abraco!

    • Paulo, muito obrigado pelo comentário.

      Realmente eu descobri que esses casos são os CPFs inválidos conhecidos.
      Vi o algoritmo de validação do site que você indicou. http://www.geradorcpf.com/scripts.js

      A validação adicional que eles fazem é essa:

      if (cpf.length != 11 || cpf == “00000000000” || cpf == “11111111111” || cpf == “22222222222” || cpf == “33333333333” || cpf == “44444444444” || cpf == “55555555555” || cpf == “66666666666” || cpf == “77777777777” || cpf == “88888888888” || cpf == “99999999999”)
      return false;

      Vou acrescentar essa validação no algoritmo deste post.

      Novamente muito obrigado.

  • gente, pra quem precisar de javascript mando abaixo o código que escrevi. No formulário dê o name=”formulario1″ para as tags form que contem o campo cpf e definam name=cpf_verifica para o input que pega o cpf. Além disso, aconselho deixar o javascript num arquivo separado, e deixar o form com a ação onSubmit=”return validacpf();” para buscar a função corretamente.

    function validacpf () {

    var cpf = document.formulario1.cpf_verifica.value;
    cpf = cpf.replace( “.” , “” );
    cpf = cpf.replace( “-” , “” );
    cpf = cpf.replace( “.” , “” );

    if (cpf.length != 11 ||
    cpf == “00000000000” ||
    cpf == “11111111111” ||
    cpf == “22222222222” ||
    cpf == “33333333333” ||
    cpf == “44444444444” ||
    cpf == “55555555555” ||
    cpf == “66666666666” ||
    cpf == “77777777777” ||
    cpf == “88888888888” ||
    cpf == “99999999999”){
    document.getElementById(“cpf_verifica”).style.backgroundColor = “#faa”; //isso deixa o campo avermelhado
    document.formulario1.cpf_verifica.focus();
    return false;
    } else {
    var soma = 0;
    soma = soma + (parseInt(cpf.substring( 0 , 1))) * 10;
    soma = soma + (parseInt(cpf.substring( 1 , 2))) * 9;
    soma = soma + (parseInt(cpf.substring( 2 , 3))) * 8;
    soma = soma + (parseInt(cpf.substring( 3 , 4))) * 7;
    soma = soma + (parseInt(cpf.substring( 4 , 5))) * 6;
    soma = soma + (parseInt(cpf.substring( 5 , 6))) * 5;
    soma = soma + (parseInt(cpf.substring( 6 , 7))) * 4;
    soma = soma + (parseInt(cpf.substring( 7 , 8))) * 3;
    soma = soma + (parseInt(cpf.substring( 8 , 9))) * 2;
    }

    var resto1 = (soma * 10) % 11;

    if ((resto1 == 10) || (resto1 == 11)) {
    resto1 = 0;
    }

    var soma = 0;
    soma = soma + (parseInt(cpf.substring( 0 , 1))) * 11;
    soma = soma + (parseInt(cpf.substring( 1 , 2))) * 10;
    soma = soma + (parseInt(cpf.substring( 2 , 3))) * 9;
    soma = soma + (parseInt(cpf.substring( 3 , 4))) * 8;
    soma = soma + (parseInt(cpf.substring( 4 , 5))) * 7;
    soma = soma + (parseInt(cpf.substring( 5 , 6))) * 6;
    soma = soma + (parseInt(cpf.substring( 6 , 7))) * 5;
    soma = soma + (parseInt(cpf.substring( 7 , 8))) * 4;
    soma = soma + (parseInt(cpf.substring( 8 , 9))) * 3;
    soma = soma + (parseInt(cpf.substring( 9 , 10))) * 2;

    var resto2 = (soma *10) % 11;
    if ((resto2 == 10) || (resto2 == 11)) {
    resto2 = 0;
    }

    if (
    (resto1 == (parseInt(cpf.substring( 9 , 10)))) &&
    (resto2 == (parseInt(cpf.substring( 10 , 11)))) ) {
    alert(“deuserto”);
    return true;
    } else {
    alert (“CPF inválido”)
    document.getElementById(“cpf_verifica”).style.backgroundColor = “#faa”;
    document.formulario1.cpf_verifica.focus();
    return false;
    }

    }

  • Mateus Gomes

    rapaz tava querendo criar um algoritmo ni visual g pra ler codigos binarios alguem tem alguma informacao ai obrugado!