Validando CPF: Do algorítmo até o código (PHP, Python, JavaScript)

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? :O

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 :D
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 :D

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 :D

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á:

10
9
8
14
12
10
12
9
6

Maravilha, está funcionando do jeito que precisamos :D

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á:

10
19
27
41
53
63
75
84
90

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

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á:

2

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 :D

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? :D
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 :D
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 :D

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”)
}
}