Validando CPF: Do algorítmo ao código (PHP, Python, JS)

Com uma busca rápido, você encontra na internet vários algorítmos para validar um CPF (Cadastro de Pessoa Física) de forma eficiente. Porém, você já pensou como é o cálculo por trás?

Hoje, vamos juntos descobrir como funciona o cálculo do CPF, construir um algorítmo para fazer esse cálculo e adapatar para algumas linguagens de programação (PHP, JS e Python)

Obs.: Se você não tiver paciência para ver como é feito o cálculo e a forma que eu pensei para chegar no algorítmo pode ir para o final desse artigo que tem todos os códigos prontos para copiar e colar 😀 Mas, se você fizer isso não estará evoluindo como um programador, apenas como um copiador :O

Entendo o cálculo de validação do CPF

O CPF assim como outros documentos oficiais, possuem alguns números que são considerados DV (Dígitos Verificadores). São os números utilizados para verificar se o documento é valido ou não.

Esse cálculo é implementado no próprio software, sem a necessidade de qualquer conexão com a receita federal. Assim, evita erros de digitação ou algum tipo de golpe. Após, essa primeira validação, alguns sistemas fazem uma conexão com a Receita Federal para validar se aquele pessoa pertence aquele CPF.

No CPF existem dois (02) DV para validação, que são os dois (02) últimos números depois do traço (-).

Vamos utilizar o seguinte CPF (Fictício) como exemplo: 111.222.333-96

Calculando o primeiro DV

Para realizar o cálculo do primeiro DV, tempos que que fazer um cálculo com os primeiros nove (09) números. Temos que múltiplicar esses nove (09) números por dez (10) até dois (02) e depois somar os resultados … O que!?!?!?
Deixa eu mostrar abaixo 😀

[

Com o resultado final de noventa (90), vamos dividí-lo por onze (11). Porém, não vamos utilizar o resultado da divisão e sim o resto:

90 % 11 = 2

Caso o resto seja dez (10) ou maior, então o DV será zero (0). Como não é nenhum desses números, vamos pegar o resto e subtrair por onze (11):

11 – 2 = 9

Então, o primeiro DV é nove (09) e o décimo digito do CPF de exemplo é nove (09), significando que esse número é valido.

Calculando o segundo DV

Para realizar o cálculo do segundo DV é quase o mesmo processo que o primeiro DV. Porém, vamos utilizar os dez (10) primeiro números, multiplicar por 11 e ir caindo e somar os resultado … Agora entendi 😀

O resultado foi cento e vinte e seis (126), vamos dividir esse resultado por onze (11) e vamos utilizar o resto da divisão:

126 % 11 = 5

Caso, o resto da divisão seja dez (10) ou número maior, então, o DV será zero (0).
Então, vamos pegar o resto da divisão e subtrair por onze (11)

11 – 5 = 6

Então, como podemos ver o nosso CPF (fictício) 111.222.333-96 é válido, pois, o primeiro DV (9) está igual ao décimo digito e o segundo DV (6) é igual ao décimo primeiro dígito.

Criando o algorítimo

Agora, que já sabemos como funciona o cálculo do CPF, vamos implementar isso em um algorítmo para ser utilizado em qualquer linguagem. Iremos fazer isso em apenas cinco (05) passos:

Passo 1: Extrair os primeiros nove (09) dígitos do CPF
Passo 2: Fazer as multiplicações e somas com os nove (09) dígitos
Passo 3: Descobrir o primeiro DV (Dígito Verificador)
Passo 4: Descobrir o segundo DV (Dígito Verificador)
Passo 5: Validando o número digitado

Vamos utilizar a seguinte estrutura básica para montar o nosso algorítmo:

algoritmo "validorCPF"
var
inicio

fimalgoritmo

Passo 1: Extrair os primeiros nove (09) dígitos do CPF

O primeiro passo é extrair os primeiros nove (09) dígitos e colocar em um variável.
Então, vamos fazer o seguinte, criar uma variável para comportar o CPF recebido (Espero que você já tenha bloqueado letras e caracteres especiais nesse campo anteriormente :O) e inicializar ela com o valor do CPF (Utilizarei o valor do primeiro exemplo):

algoritmo "validorCPF"
var
cpfRecebido: Caractere
inicio
cpfRecebido <- “11122233396”

fimalgoritmo

Obs.: Criei essa variável do tipo caractere, pois, se o CPF iniciar com zero (0) ela será considerado no resto do programa. Caso, a variável fosse do tipo inteiro, ele seria ignorado.

Para ficar mais fácil, vamos pegar esse CPF recebido e colocar em uma variável do tipo Matriz. Assim, vamos pode extrair quantos números do CPF for necessário facilmente.

algoritmo "validorCPF"
var
cpfRecebido: Caractere
cpf: Matriz
inicio
cpfRecebido <- “11122233396”
cpf <- funcaoSeparadora (cpfRecebido)

fimalgoritmo

Obs.: “funcaoSeparadora” será a função utilizada na linguagem de programação para transformar a variável “cpfRecebido” em Matriz.

Como o CPF está dentro de uma Matriz, podemos utilizar uma repetição para listar todos os nove (09) primeiros dígitos do CPF. Iremos, utilizar a repetição “Para”.

Na maioria das linguagens de programação (Falo maioria, pois, pode ter alguma linguagem que seja diferente :O), o primeiro elemento da Matriz tem o índice zero (0), então, vamos listar tudo de zero (0) até oito (08);

algoritmo "validorCPF"
var
cpfRecebido: Caractere
cpf: Matriz
inicio
cpfRecebido <- “11122233396”
cpf <- funcaoSeparadora (cpfRecebido)

Para i <- 0 ate 8 passo 1 faca
    Escreva (cpf[i])
FimPara

fimalgoritmo

O resultado do programa será:

[1, 1, 1, 2, 2, 2, 3, 3, 3,]

Passo 2: Fazer as multiplicações e somas com os nove (09) dígitos

Agora temos que fazer aquelas multiplicações e somas que está explicado na primeira parte de artigo (O que?!?! Não acredito que você está começando essa artigo por aqui ? :O)

Então, vamos fazer o seguinte, dentro da repetição “Para”, vamos fazer com os primeiros nove (09) dígitos do CPF, sejam multiplicados pelos números corretos (10, 9, 8, 7, 6, 5, 4, 3, 2).

Como a variável temporária “i” está indo de zero (0) até oito (08), podemos ir subtraindo cada repetição para chegar ao número correto:

i = 0, então, 0 – 10 = 10
i = 1, então, 1 – 10 = 9
i = 2, então, 2 – 10 = 8

E assim por diante …
Vamos multiplicar e colocar dentro de uma variável chamada “resultadoMultiplicacaoPDV” (Esse PDV do final significa “Primeiro Dígito Verificador”), essa variável será do tipo “inteiro”;

algoritmo "validorCPF"
var
cpfRecebido: Caractere
resultadoMultiplicacaoPDV: inteiro
cpf: Matriz
inicio
cpfRecebido <- “11122233396”
cpf <- funcaoSeparadora (cpfRecebido)
resultadoMultiplicacaoPDV = 0

Para i <- 0 ate 8 passo 1 faca
    resultadoMultiplicacaoPDV <- cpf[i] * (10 – i)
    Escreva (resultadoMultiplicacaoPDV)
FimPara

fimalgoritmo

Resultado do programa será:

Maravilha, está funcionando do jeito que precisamos 😀
Obs.: É muito melhor ir fazendo, testando, fazendo testando, do que digitar tudo e deixar para testar no final. Pois, se tiver algum problema já corrimos agora, depois com várias linhas de código será muito difícil localizar o erro :O

Como o nosso programa já está fazendo a multiplicação dos números, temos que fazer o somatórios deles também. Porém, não podemos colocar a soma do lado de fora do “Para” pois, iria somar somente o resultado final e o que queremos, é a soma de cada operação.

Então, criaremos uma variável chamada “resultadoSomaPDV” (Que também será do tipo “inteiro”) para guardar o resultado da soma de operação.

Utilizaremos a seguinte estrutura:
resultadoSomaPDV = resultadoSomaPDV + resultadoMultiplicacaoPDV
Talvez, vendo no linha a linha vai ficar mais fácil de entender:
resultadoSomaPDV = 0 + 10
resultadoSomaPDV = 10 + 9
resultadoSomaPDV = 19 + 8
E assim, por diante …
No programa vai ficar da seguinte forma:

algoritmo "validorCPF"
var
cpfRecebido: Caractere
resultadoMultiplicacaoPDV, resultadoSomaPDV: inteiro
cpf: Matriz
inicio
cpfRecebido <- “11122233396”
cpf <- funcaoSeparadora (cpfRecebido)
resultadoMultiplicacaoPDV <-  0
resultadoSomaPDV <-  0

Para i <- 0 ate 8 passo 1 faca
    resultadoMultiplicacaoPDV <- cpf[i] * (10 – i)
    resultadoSomaPDV <- resultadoSomaPDV + resultadoMultiplicacaoPDV
    Escreva (resultadoSomaPDV)
FimPara

fimalgoritmo

Resultado do programa será:

Que alegria saber que está tudo funcionando corretamente, vamos para o próximo passo 😀

Passo 3: Descobrir o primeiro DV (Dígito Verificador)

Como vimos anteriormente, depois de fazer as multiplicações e somas, temos que pegar esse resultado dividir por onze (11), com o resto da divisão subtrair de onze (11), assim chegaremos no primeiro DV.

Criarei uma variável chamada “restoSomaPDV” e vamos atribuir o resto da divisão de onze (11):

algoritmo "validorCPF"
var
…...
resultadoMultiplicacaoPDV, resultadoSomaPDV, restoSomaPDV: inteiro
…...
inicio
…...
restoSomaPDV <- 0

…...
restoSomaPDV = resultadoSomaPDV % 11
Escreva (restoSomaPDV)

fimalgoritmo

Resultado do programa será:
Resultado do programa será:

Conforme visto acima, se o resto for maior do que dez (10), então, o dígito verificador será zero (0), caso contrário será o dígito verificador menos onze (11).
Então, vamos fazer uma estrutura “Se” para validar essa parte e colocar o resultado do primeiro DV em uma variável chamada “pdv”;

algoritmo "validorCPF"
var
…...
pdv: inteiro
…...

inicio
…...
pdv <- 0
……

Se (resultadoRestoPDV >= 10) então
   pdv <- 0
senao
   pdv <- (11 – resultadoRestoPDV)
FimSe

Escreva (pdv)

fimalgoritmo

Resultado do programa será:
9

Agora, que já temos a estrutura para chegar no primeiro dígito verificador, podemos prosseguir 😀

Passo 4: Descobrir o segundo DV (Dígito Verificador)

Como assim ?!?! Cadê os outros passos ?!?!?
Isso mesmo que você leu, já podemos ir direto calculando o segundo DV. Pois, o cálculo é muito parecido com o primeiro.
Porém, no primeiro é feito a multiplicação de dez (10) até dois (2) no segundo é feito de onze (11) até dois (2) e utiliza os primeiro dez (10) dígitos.

Vamos copiar e colar o código, porém, vamos criar novas variáveis para o segundo DV.
Novas variáveis equivalentes:

“resultadoSomaPDV” é o mesmo que “resultadoSomaSDV”
“resultadoMultiplicacaoPDV” é o mesmo que “resultadoMultiplicacaoSDV”
“restoSomaPDV” é o mesmo que “restoSomaSDV”
“pdv” é o mesmo que “sdv”

algoritmo "validorCPF"
var
…...
resultadoMultiplicacaoSDV, resultadoSomaSDV, restoSomaSDV: inteiro
pdv, sdv: inteiro
…...

inicio
…...
resultadoMultiplicacaoSDV <- 0
resultadoSomaSDV <- 0
restoSomaSDV <- 0
sdv <- 0

…...

Para i <- 0 ate 9 passo 1 faca
    resultadoMultiplicacaoSDV <- cpf[i] * (11 – i)
    resultadoSomaSDV <- resultadoSomaSDV + resultadoMultiplicacaoSDV
FimPara

restoSomaSDV = resultadoSomaSDV % 11
Se (resultadoRestoSDV >= 10) então
   sdv <- 0
senao
   sdv <- (11 – resultadoRestoSDV)
FimSe

Escreva (pdv)
Escreva(sdv)

fimalgoritmo

Resultado do programa será:

9
6

Maravilha, temos o primeiro e segundo DV, então, acabou o programa, certo? 😀
Errado ! 🙁

Vamos para o próximo passo.

Passo 5: Validando o número digitado

Agora que já temos o cálculo que chega nos dois (02) DV, temos que validar se o número digitado no CPF é realmente um CPF válido.

Então, é muito simples, vamos adicionar uma estrutura “Se” e comparar a variável “pdv” com o décimo dígito do CPF (cpf[9]) e a variável “sdv” com o décimo primeiro dígito do CPF (cpf[10)

algoritmo "validorCPF"
var
…...

inicio

…...

Se (cpf[9] = pdv) e (cpf[10] = sdv) entao
   Escreva (“CPF valido”)
senao
   Escreva (“CPF invalido”)
FimSe

fimalgoritmo

Resultado do programa será:
CPF valido

Como pensamos em um CPF (FICTÍCIO) válido, o resultado foi “CPF válido”. Porém, temos que validar uma última coisa em nosso sistema.
Se a pessoa digitar todos os números iguais (2222222, 33333, …) vai dar no final “CPF válido”. Então, temos que prevenir isso também.

Vamos criar uma variável chamada “cpfInvalido” e vamos colocar toda listagem de números repetidos: 111111111111, 222222222222, 33333333333, 44444444444, 5555555555, 66666666666, 77777777777, 88888888888, 9999999999, 0000000000

algoritmo "validorCPF"
var
…...
cpf, cpfInvalido: Matriz

inicio
…...
cpfInvalido <- [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999]

……

fimalgoritmo

Agora, vamos fazer um “Para” para comparar todos os valores que estão na variável “cpfInvalido” com o valor recebido no CPF.
E criaremos uma variável chamada “situacao”, caso a situacao em alguma dessas repetições for “Verdadeira”, então, ele vai guardar essa valor para ser validado no “Se” final

algoritmo "validorCPF"
var
……
situacao: boleano

inicio
……
Para i <- 0 ate 9 passo 1 faca
    Se (cpfRecebido = cpfInvalido[i]) entao
        situacao <- "Verdadeiro"
        Parar
    senao
        situacao = "Falso"
    FimSe
FimPara

…...

fimalgoritmo

E agora vamos incrementar o último “Se” com essa nova condição, se o valor de “situacao” for igual a “Verdadeiro”, então, o CPF é inválido.

algoritmo "validorCPF"
var
……
situacao: boleano

inicio
……
Para i <- 0 ate 9 passo 1 faca
    Se (cpfRecebido = cpfInvalido[i]) entao
        situacao <- "Verdadeiro"
        Parar
    senao
        situacao = "Falso"
    FimSe
FimPara

Se (situacao = "Verdadeiro") entao
    Escreva ("CPF invalido")
senao  
    Se (cpf[9] = pdv) e (cpf[10] = sdv) entao
        Escreva ("CPF valido")
    senao
        Escreva ("CPF invalido")
    FimSe
FimSe

…...

fimalgoritmo

O algorítmo completo fica da seguinte forma:

algoritmo "validorCPF"
var
cpfRecebido: Caractere
resultadoSomaPDV, resultadoMultiplicacaoPDV: Inteiro
resultadoSomaSDV, resultadoMultiplicacaoSDV: Inteiro
situacao: Logico
cpf, cpfInvalido: Matriz

inicio
cpfRecebido <- "11122233396"
cpf <- funcaoSeparadora (cpfRecebido)
resulatdoSomaPDV <- 0
resultadoMultiplicacaoPDV <- 0
resultadoSomaSDV <- 0
resultadoMultiplicacaoSDV <- 0
cpfInvalido <- [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999]

Para i <- 0 ate 8 passo 1 faca
    resultadoMultiplicacaoPDV <- cpf[i] * (10 - i)
    resultadoSomaPDV <- resultadoSomaPDV + resultadoMultiplicacaoPDV
FimPara

resultadoRestoPDV <- resultadoSomaPDV % 11
Se (resultadoRestoPDV >= 10) entao
    pdv <- 0
Senao
    pdv <- (11 - resultadoRestoPDV)
FimSe

Para i <- 0 ate 9 passo 1 faca
    resultadoMultiplicacaoSDV <- cpf[i] * (11 - i)
    resultadoSomaSDV <- resultadoSomaSDV + resultadoMultiplicacaoSDV
FimPara

resultadoRestoSDV <- resultadoSomaSDV % 11
Se (resultadoRestoSDV  >= 10) 
    sdv <- 0
senao
    sdv <- (11 - resultadoRestoSDV)
FimSe

Para i <- 0 ate 9 passo 1 faca
    Se (cpfRecebido = cpfInvalido[i]) entao
        situacao <- "Verdadeiro"
        Parar
    senao
        situacao = "Falso"
    FimSe
FimPara

Se (situacao = "Verdadeiro") entao
    Escreva ("CPF invalido")
senao  
    Se (cpf[9] = pdv) e (cpf[10] = sdv) entao
        Escreva ("CPF valido")
    senao
        Escreva ("CPF invalido")
    FimSe
FimSe

fimalgoritmo

Transcrição para outras linguagens

Como temos o algorítmo pronto, podemos recriá-lo em qualquer liguagem de programação. Nesse artigo vamos utilizar três (03) linguagens, PHP, Python e JavaScript.

Começaremos com a transcrição das variáveis.

Em algorítmo

algoritmo "validadorCPF"
var
cpfRecebido: Caractere
resultadoSomaPDV, resultadoMultiplicacaoPDV: Inteiro
resultadoSomaSDV, resultadoMultiplicacaoSDV: Inteiro
situacao: Logico
cpf, cpfInvalido: Matriz

inicio
cpfRecebido <- "11122233396"
cpf <- funcaoSeparadora (cpfRecebido)
resulatdoSomaPDV <- 0
resultadoMultiplicacaoPDV <- 0
resultadoSomaSDV <- 0
resultadoMultiplicacaoSDV <- 0
cpfInvalido <- [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999]

Em PHP

No PHP não é necessário informar qual é o seu tipo e tem que inciada com o símbolo ($).
Lembrando que no PHP é obrigatório o uso do ponto e vírgula (;) no final de cada inscrição :O

$cpfRecebido = "11122233396";
$cpf = str_split($cpfRecebido);
$cpfInvalido = array(00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999);
$resultadoSomaPDV = 0;
$resultadoMultiplicacaoPDV = 0;
$resultadoSomaSDV = 0;
$resultadoMultiplicacaoSDV = 0;
$situacao = 0;

Em Python

Assim, como no PHP não é necessário informar o tipo da variável e não é obrigatório utilização do ponto e vírgula 😀
Porém, tive que utilizar um “for” para converter a variável que recebe o número do CPF em caractere, para matriz com inteiros;

cpfRecebido = str(11122233396)
cpf = []
for i in cpfRecebido:
    cpf.append(int(i))
cpfInvalido = [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999]
resultadoSomaPDV = 0
resultadoMultiplicacaoPDV = 0
resultadoSomaSDV = 0
resultadoMultiplicacaoSDV = 0
situacao = False

Em JavaScript

Assim como no PHP e Python, no JavaScript não é necessário informar o tipo da variável e o código é bem parecido com o algorítmo

    let cpfRecebido = "11122233396"
    let cpf = cpfRecebido.split("")
    let cpfInvalido = [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 999999999]
    let resultadoSomaPDV = 0
    let resultadoMultiplicacaoPDV = 0
    let resultadoSomaSDV = 0
    let resultadoMultiplicacaoSDV = 0
    let situacao = 0

Agora, podemos fazer a podemos transcrever a parte que calcula o primeiro DV. Nas três (03) linguagens de programação (PHP, Python e JavaScript) temos o operador ternário, com isso é possível resumir a estrutura do “Se” em apenas uma (01) linha.

Em algorítmo

Para i <- 0 ate 8 passo 1 faca
    resultadoMultiplicacaoPDV <- cpf[i] * (10 - i)
    resultadoSomaPDV <- resultadoSomaPDV + resultadoMultiplicacaoPDV
FimPara

resultadoRestoPDV <- resultadoSomaPDV % 11
Se (resultadoRestoPDV >= 10) entao
    pdv <- 0
Senao
    pdv <- (11 - resultadoRestoPDV)
FimSe

Em PHP

for ($i = 0; $i <= 8; $i++){
    $resultadoMultiplicacaoPDV = $cpf[$i] * (10 - $i);
    $resultadoSomaPDV = $resultadoSomaPDV + $resultadoMultiplicacaoPDV;
}
$resultadoRestoPDV = $resultadoSomaPDV % 11;
$pdv = ($resultadoRestoPDV >= 10) ? 0 : (11 - $resultadoRestoPDV);

Em Python

for i in range(0, 9):
    resultadoMultiplicacaoPDV = cpf[i] * (10 - i)
    resultadoSomaPDV = resultadoSomaPDV + resultadoMultiplicacaoPDV

resultadoRestoPDV = resultadoSomaPDV % 11
pdv = 0 if resultadoRestoPDV >= 10 else (11 - resultadoRestoPDV)

Em JavaScript

        for (i = 0; i <= 8; i++)
        { 
            resultadoMultiplicacaoPDV = cpf[i] * (10 - i)
            resultadoSomaPDV = resultadoSomaPDV + resultadoMultiplicacaoPDV
        }
        resultadoRestoPDV = resultadoSomaPDV % 11
        pdv = (resultadoRestoPDV >= 10) ? 0 : (11 - resultadoRestoPDV)

Continuando nossa transcrição, podemos ir para o cálculo do segundo DV, que é bem parecido com o cálculo do primeiro, porém, são utilizado os dez (10) primeiros números.

Em Algorítmo

Para i <- 0 ate 9 passo 1 faca
    resultadoMultiplicacaoSDV <- cpf[i] * (11 - i)
    resultadoSomaSDV <- resultadoSomaSDV + resultadoMultiplicacaoSDV
FimPara

resultadoRestoSDV <- resultadoSomaSDV % 11
Se (resultadoRestoSDV  >= 10) 
    sdv <- 0
senao
    sdv <- (11 - resultadoRestoSDV)
FimSe

Em PHP

for ($i = 0; $i <= 9; $i++) {
    $resultadoMultiplicacaoSDV = $cpf[$i] * (11 - $i);
    $resultadoSomaSDV = $resultadoSomaSDV + $resultadoMultiplicacaoSDV;
}
$resultadoRestoSDV = $resultadoSomaSDV % 11;
$sdv = ($resultadoRestoSDV >= 10) ? 0 : (11 - $resultadoRestoSDV);

Em Python

for i in range(0, 10):
    resultadoMultiplicacaoSDV = cpf[i] * (11 - i)
    resultadoSomaSDV = resultadoSomaSDV + resultadoMultiplicacaoSDV

resultadoRestoSDV = resultadoSomaSDV % 11
sdv = 0 if resultadoRestoSDV >= 10 else (11 - resultadoRestoSDV)

Em JavaScript

    for (i = 0; i <= 9; i++)
        { 
            resultadoMultiplicacaoSDV = cpf[i] * (11 - i)
            resultadoSomaSDV = resultadoSomaSDV + resultadoMultiplicacaoSDV
        }
        resultadoRestoSDV = resultadoSomaSDV % 11
        sdv = (resultadoRestoSDV >= 10) ? 0 : (11 - resultadoRestoSDV)

Vamos para a parte que verifica se o número digitado no CPF são aqueles casos de todos os números repetidos

Em Algorítimo

Para i <- 0 ate 9 passo 1 faca
    Se (cpfRecebido = cpfInvalido[i]) entao
        situacao <- "Verdadeiro"
        Parar
    senao
        situacao = "Falso"
    FimSe
FimPara

Em PHP

for ($i = 0; $i <= 9; $i++) {
    if($cpfRecebido == $cpfInvalido[$i]) {
        $situacao = true;
        break;
    } else {
        $situacao = false;
    }
}

Em Python

for i in range(0, 10):
    if cpfRecebido == cpfInvalido[i]:
        situacao = True
        break
    else:
        situacao = False

Em JavaScript

        for (i = 0; i<= 9; i++){
            if(cpfRecebido == cpfInvalido[i]) {
                situacao = true
                break
            } else {
                situacao = false
            }
        }

E finalmente a última parte (Minha cabeça já estava dando um nó, por ficar trocando tanto de lingaugem kkkk)
Nessa parte que é feita a validação final verificando se tem algum número repetido no código e se, o primeiro DV é igual ao décimo número do CPF, e o segundo DV é igual ao décimo primeiro número do CPF

Em Algorítimo

Se (situacao = "Verdadeiro") entao
    Escreva ("CPF invalido")
senao  
    Se (cpf[9] = pdv) e (cpf[10] = sdv) entao
        Escreva ("CPF valido")
    senao
        Escreva ("CPF invalido")
    FimSe
FimSe

Em PHP

if ($situacao) {
    echo("CPF inválido");
} else if(($cpf[9] == $pdv) and ($cpf[10] == $sdv)) {
        echo ("CPF válido");
} else {
    echo("CPF inválido");
}

Em Python

if(situacao):
    print('CPF invalido')
elif (cpf[9] == pdv) and (cpf[10] == sdv):
    print('CPF valido')
else:
    print('CPF invalido')

Em JavaScript

    if (situacao) {
        console.log('CPF inválido')
    } else {
        if (cpf[9] == pdv && cpf[10] == sdv) {
        console.log("CPF válido")
    } else {
        console.log("CPF inválido")
    }
    }

Então é isso, espero que a forma que cheguei na resolução desse problema tenha agregado em algo na sua construção de raciocínio na lógida de programação. Porém, existem várias formas de fazer a mesma coisa na programação. Eu quero lhe convidar a utilizar a caixa de comentários abaixo para colocar a sua solução, ou mesmo alguma coisa que poderia ser melhorado nesse algorítmo.
Abaixo, estarei colocando o código completo de cada linguagem para os seus testes.

Muito obrigado por sua atenção, até a próxima 😀

Algorítimo completo

algoritmo "validadorCPF"
var
cpfRecebido: Caractere
resultadoSomaPDV, resultadoMultiplicacaoPDV: Inteiro
resultadoSomaSDV, resultadoMultiplicacaoSDV: Inteiro
situacao: Logico
cpf, cpfInvalido: Matriz

inicio
cpfRecebido <- "11122233396"
cpf <- funcaoSeparadora (cpfRecebido)
resulatdoSomaPDV <- 0
resultadoMultiplicacaoPDV <- 0
resultadoSomaSDV <- 0
resultadoMultiplicacaoSDV <- 0
cpfInvalido <- [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999]

Para i <- 0 ate 8 passo 1 faca
    resultadoMultiplicacaoPDV <- cpf[i] * (10 - i)
    resultadoSomaPDV <- resultadoSomaPDV + resultadoMultiplicacaoPDV
FimPara

resultadoRestoPDV <- resultadoSomaPDV % 11
Se (resultadoRestoPDV >= 10) entao
    pdv <- 0
Senao
    pdv <- (11 - resultadoRestoPDV)
FimSe

Para i <- 0 ate 9 passo 1 faca
    resultadoMultiplicacaoSDV <- cpf[i] * (11 - i)
    resultadoSomaSDV <- resultadoSomaSDV + resultadoMultiplicacaoSDV
FimPara

resultadoRestoSDV <- resultadoSomaSDV % 11
Se (resultadoRestoSDV  >= 10) 
    sdv <- 0
senao
    sdv <- (11 - resultadoRestoSDV)
FimSe

Para i <- 0 ate 9 passo 1 faca
    Se (cpfRecebido = cpfInvalido[i]) entao
        situacao <- "Verdadeiro"
        Parar
    senao
        situacao = "Falso"
    FimSe
FimPara

Se (situacao = "Verdadeiro") entao
    Escreva ("CPF invalido")
senao  
    Se (cpf[9] = pdv) e (cpf[10] = sdv) entao
        Escreva ("CPF valido")
    senao
        Escreva ("CPF invalido")
    FimSe
FimSe
fimalgoritmo

Código PHP completo

<?php
$cpfRecebido = "11122233396";
$cpf = str_split($cpfRecebido);
$cpfInvalido = array(00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999);
$resultadoSomaPDV = 0;
$resultadoMultiplicacaoPDV = 0;
$resultadoSomaSDV = 0;
$resultadoMultiplicacaoSDV = 0;
$situacao = 0;

for ($i = 0; $i <= 8; $i++){
    $resultadoMultiplicacaoPDV = $cpf[$i] * (10 - $i);
    $resultadoSomaPDV = $resultadoSomaPDV + $resultadoMultiplicacaoPDV;
}
$resultadoRestoPDV = $resultadoSomaPDV % 11;
$pdv = ($resultadoRestoPDV >= 10) ? 0 : (11 - $resultadoRestoPDV);

for ($i = 0; $i <= 9; $i++) {
    $resultadoMultiplicacaoSDV = $cpf[$i] * (11 - $i);
    $resultadoSomaSDV = $resultadoSomaSDV + $resultadoMultiplicacaoSDV;
}
$resultadoRestoSDV = $resultadoSomaSDV % 11;
$sdv = ($resultadoRestoSDV >= 10) ? 0 : (11 - $resultadoRestoSDV);

for ($i = 0; $i <= 9; $i++) {
    if($cpfRecebido == $cpfInvalido[$i]) {
        $situacao = true;
        break;
    } else {
        $situacao = false;
    }
}

if ($situacao) {
    echo("CPF inválido");
} else if(($cpf[9] == $pdv) and ($cpf[10] == $sdv)) {
        echo ("CPF válido");
} else {
    echo("CPF inválido");
}

?>

Código Python completo

cpfRecebido = str(11122233396)
cpf = []
for i in cpfRecebido:
    cpf.append(int(i))
cpfInvalido = [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 99999999999]
resultadoSomaPDV = 0
resultadoMultiplicacaoPDV = 0
resultadoSomaSDV = 0
resultadoMultiplicacaoSDV = 0
situacao = False

for i in range(0, 9):
    resultadoMultiplicacaoPDV = cpf[i] * (10 - i)
    resultadoSomaPDV = resultadoSomaPDV + resultadoMultiplicacaoPDV

resultadoRestoPDV = resultadoSomaPDV % 11
pdv = 0 if resultadoRestoPDV >= 10 else (11 - resultadoRestoPDV)

for i in range(0, 10):
    resultadoMultiplicacaoSDV = cpf[i] * (11 - i)
    resultadoSomaSDV = resultadoSomaSDV + resultadoMultiplicacaoSDV

resultadoRestoSDV = resultadoSomaSDV % 11
sdv = 0 if resultadoRestoSDV >= 10 else (11 - resultadoRestoSDV)

for i in range(0, 10):
    if cpfRecebido == cpfInvalido[i]:
        situacao = True
        break
    else:
        situacao = False

if(situacao):
    print('CPF invalido')
elif (cpf[9] == pdv) and (cpf[10] == sdv):
    print('CPF valido')
else:
    print('CPF invalido')

Código JavaScript completo

    let cpfRecebido = "11122233396"
    let cpf = cpfRecebido.split("")
    let cpfInvalido = [00000000000, 11111111111, 22222222222, 33333333333, 44444444444, 55555555555, 66666666666, 77777777777, 88888888888, 999999999]
    let resultadoSomaPDV = 0
    let resultadoMultiplicacaoPDV = 0
    let resultadoSomaSDV = 0
    let resultadoMultiplicacaoSDV = 0
    let situacao = 0
        for (i = 0; i <= 8; i++)
        { 
            resultadoMultiplicacaoPDV = cpf[i] * (10 - i)
            resultadoSomaPDV = resultadoSomaPDV + resultadoMultiplicacaoPDV
        }
        resultadoRestoPDV = resultadoSomaPDV % 11
        pdv = (resultadoRestoPDV >= 10) ? 0 : (11 - resultadoRestoPDV)

    for (i = 0; i <= 9; i++)
        { 
            resultadoMultiplicacaoSDV = cpf[i] * (11 - i)
            resultadoSomaSDV = resultadoSomaSDV + resultadoMultiplicacaoSDV
        }
        resultadoRestoSDV = resultadoSomaSDV % 11
        sdv = (resultadoRestoSDV >= 10) ? 0 : (11 - resultadoRestoSDV)

        for (i = 0; i<= 9; i++){
            if(cpfRecebido == cpfInvalido[i]) {
                situacao = true
                break
            } else {
                situacao = false
            }
        }

    if (situacao) {
        console.log('CPF inválido')
    } else {
        if (cpf[9] == pdv && cpf[10] == sdv) {
        console.log("CPF válido")
    } else {
        console.log("CPF inválido")
    }
    }

Categories:Programação

Tags:algoritmo cpf javascript js php python

Diego Peres Marques

Patricia disse:

novembro 22, 2021 às 23:16

Eu só queria saber como podemos identificar um CPF falso

Responder

DEBXP COMUNIDADE

Validando CPF: Do algorítmo ao código (PHP, Python, JS)

Entendo o cálculo de validação do CPF

Calculando o primeiro DV

Calculando o segundo DV

Criando o algorítimo

Passo 1: Extrair os primeiros nove (09) dígitos do CPF

Passo 2: Fazer as multiplicações e somas com os nove (09) dígitos

Passo 3: Descobrir o primeiro DV (Dígito Verificador)

Passo 4: Descobrir o segundo DV (Dígito Verificador)

Passo 5: Validando o número digitado

Transcrição para outras linguagens

Em algorítmo

Em PHP

Em Python

Em JavaScript

Em algorítmo

Em PHP

Em Python

Em JavaScript

Em Algorítmo

Em PHP

Em Python

Em JavaScript

Em Algorítimo

Em PHP

Em Python

Em JavaScript

Em Algorítimo

Em PHP

Em Python

Em JavaScript

Algorítimo completo

Código PHP completo

Código Python completo

Código JavaScript completo

1 Response

Deixe um comentário Cancelar resposta

Entendo o cálculo de validação do CPF

Calculando o primeiro DV

Calculando o segundo DV

Criando o algorítimo

Passo 1: Extrair os primeiros nove (09) dígitos do CPF

Passo 2: Fazer as multiplicações e somas com os nove (09) dígitos

Passo 3: Descobrir o primeiro DV (Dígito Verificador)

Passo 4: Descobrir o segundo DV (Dígito Verificador)

Passo 5: Validando o número digitado

Transcrição para outras linguagens

Em algorítmo

Em PHP

Em Python

Em JavaScript

Em algorítmo

Em PHP

Em Python

Em JavaScript

Em Algorítmo

Em PHP

Em Python

Em JavaScript

Em Algorítimo

Em PHP

Em Python

Em JavaScript

Em Algorítimo

Em PHP

Em Python

Em JavaScript

Algorítimo completo

Código PHP completo

Código Python completo

Código JavaScript completo

Related Posts

Curso: interfaces para scripts em shell – Aula 2

Você não entende o shell se não sabe como ele processa os comandos

Curso: interfaces para scripts em shell – Aula 3

Repositórios git ‘bare’

tmux – Guia básico de sobrevivência – parte 1

Funções no Bash

1 Response

Deixe um comentário Cancelar resposta