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") } }
|
Comentários
Postar um comentário