Algoritmos e Estruturas de Decisão

Prévia do material em texto

1
Algoritmos e 
Técnicas de 
Programação
Estruturas de Decisão e de Repetição
Profa. Dra. Jenai Oliveira Cazetta
Contextualização
REFLITA
• Quando você liga um computador, tablet ou smartphone
centenas de processos são inicializados e passam a
competir o processador para que possam ser
executados.
• Resultados obtidos por meio do processamento de
dados são necessários recursos que permitam
implementar soluções otimizadas para o processamento.
Fonte: https://cutt.ly/WESKxi0
Otimização
É o emprego de técnicas para seleção das 
melhores alternativas, com o propósito de alcançar 
os objetivos.
Fonte: https://cutt.ly/lfXXis4
Instruções
• Comandam o funcionamento da máquina e determinam
a maneira como devem ser tratados os dados;
• Específicas para cada modelo de computador tipo de
processador;
• Conjunto de valores, operações, relações.
Estruturas de 
decisão
Estruturas 
condicional 
encadeada
Estruturas de 
repetição
Nossa teleaula
Estrutura de decisão 
condicional simples
2
Estrutura de decisão
• Condicionais estão por toda parte, seja nos fornecendo uma solução ou 
várias possibilidades de solução. 
Se você decidiu estudar Matemática, 
então é porque, de alguma forma, isso vai 
contribuir para sua formação profissional, 
senão faria outro curso ou seguiria outros rumos.
Operadores relacionais e operadores lógicos
Operador C
maior >
menor <
maior ou igual >=
menor ou igual <=
igual ==
diferente !=
Operador C
Conjunção && binário
Disjunção  binário 
Negação ! unário
Estrutura de decisão simples
Condição
Comandos
Início
Fim
V
F
Condições && e ∥
Teste lógico!!!
Fonte: https://cutt.ly/EfFOiyK
if <(condição)>
{
<conjunto de comandos>;
}
se (condição) então
<conjunto de comandos>;
Exemplo
Antônio comprou o seu
primeiro carro. Mas será
que ele já pode dirigí-lo?
Idade >= 18 e 
com carteira de 
habilitação
Você pode 
dirigir!!!
V
F
int main() 
{
//declarando variáveis
int idade;
int carteira;
//lendo dados e armazenando
printf(" \nDigite sua idade: ");
scanf("%d",&idade);
printf(" \nDigite 1 caso tenha carteira: ");
scanf("%d",&carteira);
3
//verificando condições necessárias para dirigir
if (idade>=18 && carteira=1)
{ 
printf(“ \nVoce pode dirigir!");
}
//encerrando o programa
printf(“ \n Pressione a tecla enter para encerrar!");
return 0;
}
Estrutura de decisão 
condicional composta
Estrutura de decisão condicional composta
Comandos 2
Início
Fim
F V
Comandos 1
Condição
if <(condição)>
{
<1º conjunto comandos>;
}
else
{
<2º conjunto comandos>;
}
se (condição) então
<1º conjunto comandos>;
senão
<2º conjunto comandos>;
Exemplo
Maria e João estão se preparando para uma viagem,
porém, se o orçamento final deles for igual ou maior que
R$ 10.000,00 eles farão uma viagem internacional, senão
deverão fazer uma viagem nacional.
Viagem 
nacional
Início
Fim
F V
Viagem 
internacional
orcamento
>= 10000
4
#include <stdio.h>
int main() 
{
//declarando variáveis
float orcamento;
//armazenando dados
printf("Digite o valor do seu orcamento: \n");
scanf("%f", &orcamento);
//verificando condições para a viagem
if (orcamento >=10000)
{
printf(“ \nViagem internacional. Orcamento é de R$ 
%f”,orcamento);
}
else
{
printf(“ \nViagem nacional. Orcamento é de R$ 
%f",orcamento);
}
//encerrando o programa
printf(“ \nPressione a tecla enter para encerrar!);
return 0; 
} Estrutura condicional 
encadeada
Estrutura condicional encadeada – ifs aninhados
• Ifs aninhados comando if é o objeto de outros ifs e
elses;
• Um comando else sempre estará ligado ao comando if
de seu nível de aninhamento.
if (condição)
comandos1;
else
if (condição) 
comandos2;
else
if (condição) 
comandos3;
...
F
F
Comandos 3
V
Comandos 2
V
Comandos 1
Caso 1
Caso 2
Pode ser preciso colocar { e } entre os blocos, caso haja mais 
de um comando a ser realizado!
5
Estrutura condicional de seleção de casos
switch-case;
Comando break é utilizado para 
forçar a saída do laço de decisão 
ele sai do comando sem 
executar as próximas instruções. 
• Testa, sucessivamente, o valor de uma 
expressão contra uma lista de constantes
(inteiras ou caracteres); 
• Os comandos são executados até o ponto 
em que o comando break seja localizado;
• Caso nenhum dos valores seja encontrado 
comando default será executado.
switch (variável)
{
case constante1:
<comandos>;
break;
case constante2:
<comandos>;
break;
//...
default: <comandos>
}
Comandos NV
F
F
F
V Comandos 1
V Comandos 2
Caso1
Caso2
CasoN
Comando
Condição
Exemplo
Descobrir o desconto
que o cliente terá de 
acordo com a cor da 
etiqueta do produto.
#include <stdlib.h>
int main() 
{
//declarando variáveis
char x;
float valor,desc,total;
//armazenando o valor da compra
printf(“ \nDigite o valor da compra: ");
scanf("%f",&valor);
//mostrando as opções e armazenando a escolha
printf(“ \nMenu: Desconto de acordo com a cor");
printf(“ \nA: azul");
printf(“ \nV: vermelho");
printf(“ \nDigite sua opcao: ");
scanf("%s",&x);
//estrutura de condição
switch(x)
{
case ‘A':
printf(“ \nAzul: desconto de 30%.");
desc = valor*0.30;
total = valor – desc;
printf(“ \nValor a pagar: %.2f", total);
break;
case ‘V’:
printf(“ \nVermelho: desconto de 20%. ");
desc = valor*0.20;
total = valor – desc;
printf(“ \nValor a pagar: %.2f",total);
break;
default:
printf(“ \nOpcao invalida.");
}
//encerrando o programa
printf(“ \nPressione a tecla enter para sair!");
return 0;
}
Cálculo do salário de 
um funcionário
6
Atividade
• Programa que calcule o valor do salário líquido de um
funcionário, levando em consideração os descontos de
INSS e Imposto de Renda.
• Faça dois grupos de ifs aninhados:
(1) para o cálculo do inss;
(2) para o cálculo do imposto de renda.
Salário de contribuição (R$) Alíquota/INSS
Até 1.693,72 8,0%
De 1.693,73 até 2.822,90 9,0%
De 2.822,91 até 5.646,80 11,0%
Acima de 5.646,80 R$ 621,04 (invariavelmente)
Salário de contribuição (R$) Alíquota/IR
Até 1.903,98 -
De 1.903,99 até 2.826,65 7,5%
De 2.826,66 até 3.751,05 15,0%
De 3.751,06 até 4.664,68 22,5%
Acima de 4.664,68 27,5%
#include <stdio.h>
#include <stdlib.h>
int main()
{
//declarando variáveis
float salario,inss,ir,liquido;
//entrando e armazenando dados
printf(" \nDigite o Salario Bruto: ");
scanf("%f",salario);
//cálculo do desconto do INSS
if (salario <= 1693.72)
inss = salario*0.08;
else
if (salario >= 1693.73 && salario <= 2822.90)
inss = salario*0.09;
else
if (salario >= 2822.91 && salario <= 5645.80)
inss = salario*0.11;
else
inss = 621.04;
//cálculo do desconto do IR
if (salario <= 1903.98)
ir = salario*0;
else
if (salario >= 1903.99 && salario <= 2826.65)
ir = salario*0.075;
else
if (salario >= 2826.66 && salario <= 3751.05)
ir = salario*0.15;
else
if (salario >= 3751.06 && salario <= 4664.68)
ir = salario*0.225;
else
if (salario > 4664.69 )
ir = salario*0.275;
//cálculo do Salario Liquido
liquido = (salario – inss) – ir;
//imprimindo resultados
printf(" \nSalaria Bruto: %.2f",salario);
printf(" \nDesconto do INSS: %.2f",inss);
printf(" \nDesconto do Imposto de Renda: %.2f",ir);
printf(" \nSalario Liquido: %.2f",liquido);
//encerrando o programa
printf(" \nPressione a tecla enter para sair!”);
return 0;
} 
7
Comando if
Comando de decisão condicional
Se você decidiu estudar Matemática, 
então é porque, de alguma forma, isso vai contribuir 
para sua formação profissional, 
senão faria outro curso ou seguiria outros rumos.
Se ... então ... senão ...
Não deveria ser?
if... then... else...
Fonte: https://bit.ly/3aLma1D
Estruturas de 
repetição condicional 
(1)
Estruturas de repetição
• Laços, looping, malha ou ciclo;
• Capacidade de trechos de programas poderem ser
repetidos de forma iterativa quando uma sequência
de comandos deve ser executada repetidas vezes;
• A estrutura de repetição, assim como a de decisão,
envolve sempre a avaliação de uma condição;
• Objetivo otimizar as soluções de problemas!
• Exemplos:
• cadastrar 100 clientes;
• ordenar um vetor de caracteres;• calcular a média de 𝑛 números;
• entrar com os dados de uma matriz para o cálculo de seu 
determinante... 
• Laços determinísticos quando se sabe o número de
vezes que o laço será executado;
• Laços indeterminados quando não se sabe quantas
vezes o laço será executado depende de uma
resposta do usuário para fazê-lo laço pré-teste e laço
pós-teste.
8
Laço (loop) pré-teste – enquanto – while
• Algo será repetidamente executado enquanto uma condição verdadeira
for verificada somente após a sua negativa, essa condição será 
interrompida.
O programa não executará 
nenhuma repetição (ações 
que ali dentro estiverem 
programadas) sem antes 
testar uma condição.
Fonte: https://cutt.ly/EfFOiyK
V
F
Condição
Comandos a 
serem 
repetidos
enquanto <condição> faça
//conjunto de comandos
fim_enquanto;
while (<condição>)
{
//comando 1
//comando 2
//...
//comando n
}
Exemplo
Imprimir números inteiros de 1 até 10.
V
F
numero 
<= 10 numero
numero = numero +1
//iniciando o contador
numero=1;
//iniciando o loop
while (numero<=10)
{
printf(“%d”,numero);
//incrementando o contador
numero=numero+1;
}
//...
Estruturas de 
repetição condicional 
(2)
Laço pós-teste – faça_enquanto – do-while
• Analisa a condição ao final do laço os comandos são
executados antes do teste de condição;
• Condição condição de interrupção do laço;
• As ações serão executadas pelo menos uma vez antes
do teste condicional.
V
F
Condição 
fim da repetição
Comandos a 
serem repetidos
Início da repetição repita
//grupo de comandos
até_que <condição>;
do
{
//grupo de comandos
}
while (<condição>);
9
Exemplo
Imprimir números inteiros de 1 a 10.
V
F
numero 
<=10 
fim da repetição
numero = numero + 1
Início da repetição
numero
//iniciando o contador
numero=1;
//iniciando o loop
do
{
printf(“%d”,numero);
//incrementando o contador
numero=numero+1;
}
while (numero<=10);
Loop infinito
• Para que isso não aconteça, pode-se utilizar os seguintes recursos:
• Contador utilizado para controlar as repetições quando são 
determinadas;
• Incremento e decremento trabalham o número do contador, 
seja aumentando-o ou diminuindo-o;
• Acumulador irá somar as entradas de dados de cada iteração da repetição, 
gerando um somatório a ser utilizado quando da saída da 
repetição;
• Condição de parada utilizada para determinar o 
momento de parar quando não se tem um valor exato
desta repetição.
Incremento e decremento
Descrição Exemplo Resultado Obs.
+ +
pós incremento 𝑥 + +
𝑥 + 1
após 1ª execução
pré incremento + +𝑥 antes da 1ª execução
− −
pós incremento 𝑦 − −
𝑦 − 1
após 1ª execução
pré incremento − −𝑦 antes da 1ª execução
Estruturas de 
repetição 
determinísticas
Repetição com variáveis de controle – loop for
• Geralmente usado para repetir uma informação por um
número fixo de vezes podemos determinar quantas
vezes acontecerá a repetição;
• Baseia-se estritamente em numa variável de controle
(contador), a qual pode ser aumentada ou diminuída cada
vez que o looping for executado;
• Entre as diversas aplicações, o comando é muito utilizado
em programas para cálculos de séries matemáticas
acumulativas.
V
F
Inicializando a variável
Condição Comandos Incrementa a 
variável
Condição
10
variável  valor_inicial, valor_final, incremento
comandos
V
F
para <variável>  <valor inicial> até <valor final> passo <incremento> faça
//bloco de comandos
fim_para;
for (inicialização; condição final; incremento)
{
//bloco de comandos
}
• Inicialização executada uma única vez antes de começar o laço.
• Condição final teste que determina se a condição é verdadeira ou
falsa: 
• Verdadeira permanece no laço; 
• Falsa encerra o laço e passa para a próxima instrução.
• Incremento é possível incrementar uma repetição de acordo com um 
contador específico o incremento é executado depois 
dos comandos.
Cálculo do fatorial de um número
𝑁! = 𝑁 𝑁 − 1 𝑁 − 2 … 3 2 1
5! = 5 . 4 . 3 . 2 . 1 = 120
0! = 1
j  N, 1, -1
fat fat*j
𝑁! = 𝑁 𝑁 − 1 𝑁 − 2 … 3 2 1
//inicializando variáveis
fat=1;
j=N;
//iniciando o loop
for (fat=1; j>0; j--)
{
fat=fat*j;
}
//...
𝑓𝑎𝑡 = 1
𝑗 = 2
𝑓𝑎𝑡 = 1 ∗ 2 = 2
𝑗 = 2– 1 = 1
𝑓𝑎𝑡 = 2 ∗ 1 = 2
𝑗 = 1– 1 = 0
2!
Convertendo números 
da base 10 para a 
base 2
11
Atividade
• Programa Conversão de um número inteiro 
decimal para um número binário utilizando 
estruturas de repetição.
255 2
2
2
2
2
2
2
1271
631
311
151
71
31
11
A divisão chega ao final quando o resto da 
divisão é menor que o valor da base!
Exemplo: 255
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(void)
{
//declarando variáveis
int i=0;
int N,bin,bits;
printf(“ \nConversao de um decimal para um binario.");
//lendo e armazenando variáveis
printf(" \nDigite um numero inteiro diferente de zero: ");
scanf("%d",&N);
//perguntando sobre a representação binária
printf(" \nVoce quer a representacao em quantos bits? ");
scanf("%d",&bits);
//iniciando o loop
while(i<bits)
{
//armazenando/imprimindo o resto da divisão do número
bin=N%2;
printf(" \n%d",bin);
N=N/2;
i=i+1;
}
//informando ao usuário o resutado
if (N!=1) 
{
printf(" \n\nO numero nao pode ser representado em 
%d",bits);
printf(" bits");
}
else
{
printf(" \n\nRepresentacao bem sucedida.");
printf(" \n\nO numero deve ser lido de baixo para cima!");
}
//encerrando o programa
printf(" \nPressione a tecla enter para sair!”);
return (0);
} Término de um 
programa
12
Término de um programa
• É considerada uma boa técnica de
programação que o código interaja
bastante com o usuário seja dizendo o que
o usuário deva fazer, como também,
mostrando os resultados detalhados;
• Um opção muito interessante é perguntar
ao usuário, no final do programa, se ele
quer finalizar o programa ou inserir novos
dados para obter novos resultados.
Qual a estrutura 
que você usaria?
Fonte: https://bit.ly/3aLma1D
Fonte: https://cutt.ly/EfFOiyK
Recapitulando
Estrutura de decisão condicional
if <(condição)>
{
//comandos1
}
else
{
//comandos2
}
Condições && e ∥
Estrutura condicional encadeada
if (condição1) 
//comandos1
else
if (condição2)
//comandos2
else
//comandos3
Estrutura condicional de seleção de casos
switch (variável)
{
case constante1:
//comandos1
break;
case constante2:
//comandos1 
break;
default: 
//comandos1
}
Estrutura de repetição condicional – enquanto
while (<condição>)
{
//comando 1
//comando 2
//...
//comando n
}
13
Estrutura de repetição condicional – faça_enquanto
do
{
//comando 1
//comando 2
//...
//comando n
}
while(<condição>);
Estrutura de repetição determinística – para
for (inicialização; condição final; incremento)
{
//comando 1
//...
//comando n
}