Lógica de Programação
Estruturas de Controle
Estruturas de Controle
Nesta aula
Estrutura Sequencial
Estrutura de Seleção
Estrutura de Repetição
Objetivos
Apresentar o conceito de estrutura sequencial de fluxo de
execução
Explicar a aplicabilidade das estruturas de seleção, suas
variações, combinações e equivalências
Apresentar as estruturas de repetição, suas
particularidades e equivalências
Estrutura Sequencial
O Fluxo de Controle segue a mesma sequência linear da
nossa escrita, ou seja:
De cima para baixo;
Da esquerda para direita
Cada ação é seguida de um ;
Objetiva separar uma ação da outra
Indica que a próxima ação da sequência deve ser executada
Estrutura sequencial
Algoritmo 3.1 – Modelo geral
início
// declaração de variáveis
// corpo do algoritmo
ação 1;
ação 2;
ação 3;
.
.
.
ação n;
fim. // fim do algoritmo
Estrutura sequencial
Algoritmo 3.2 - Média Aritmética
início
// declaração de variáveis
real: N1, N2, N3, N4, // notas bimestrais
MA; // média anual
// entrada de dados
leia (N1, N2, N3, N4);
// processamento
MA  (N1 + N2 + N3 + N4) / 4;
// saída de dados
escreva (MA);
fim.
Estruturas de Seleção
São aquelas que permitem alterar o Fluxo de Execução, de
forma a selecionar qual parte deve ser executada
Essa “decisão” de execução é tomada a partir de uma
condição, que pode resultar apenas em Verdade ou
Falsidade
Uma condição é representada por expressões relacionais ou
lógicas
As estruturas de seleção podem ser classificadas em
simples, compostas ou encadeadas
Seleção Simples
se <condição> então
início // início do bloco verdade
comando 1;
comando 2;
...
comando n;
fim; // fim do bloco verdade
fimse;
Quando a <condição> for verdadeira o “bloco verdade” é
executado
Quando a <condição> for falsa o “bloco verdade” não é
executado
Seleção Simples
Algoritmo 3.3 - Média Aritmética com Aprovação
início
// declaração de variáveis
real: N1, N2, N3, N4, // notas bimestrais
MA; // média anual
// entrada de dados
leia (N1, N2, N3, N4);
// processamento
MA  (N1 + N2 + N3 + N4) / 4;
// saída de dados
escreva (MA);
se (MA >= 7) então
escreva (“Aluno Aprovado !”);
fimse;
fim.
Seleção Composta
se <condição> então
início // início do bloco verdade
comando 1;
comando n;
fim; // fim do bloco verdade
senão
início // início do bloco falsidade
comando 1;
comando n;
fim; // fim do bloco falsidade
fimse;
Quando a <condição> for verdadeira o “bloco verdade” é
executado
Quando a <condição> for falsa o “bloco falsidade” é
executado
Seleção Composta
Algoritmo 3.4 - Média Aritmética com aprovação e reprovação
início
// declaração de variáveis
real: N1, N2, N3, N4, // notas bimestrais
MA; // média anual
leia (N1, N2, N3, N4);
MA  (N1 + N2 + N3 + N4) / 4;
escreva (MA);
se (MA >= 7) então
início
escreva (“Aluno Aprovado !”);
escreva (“Parabéns !”);
fim;
senão
início
escreva (“Aluno Reprovado !”);
escreva (“Estude mais !”);
fim;
fimse;
fim.
Seleção Encadeada
Ocorre quando uma seleção tem como ação uma
outra seleção
Uma seleção encadeada pode ser:
Heterogênea: Quando não é possível identificar padrão
de comportamento
Homogênea: Quando é possível identificar padrão de
comportamento
se – então – se: quando depois de cada então ocorre outro se
se – senão – se: quando depois de cada senão ocorre outro se
Seleção Encadeada
Dados três valores A, B, C, verificar se eles podem
ser os comprimentos dos lados de um triângulo
Caso positivo, verificar se compõem
Triângulo equilátero
Triângulo isósceles
Triângulo escaleno
A
B
C
Seleção Encadeada
Dados três valores A, B, C, verificar se eles podem
ser os comprimentos dos lados de um triângulo
Caso positivo, verificar se compõem
Triângulo equilátero – três lados iguais
Triângulo isósceles – dois lados iguais
Triângulo escaleno – todos os lados diferentes
A
B
C
Seleção Encadeada
É triângulo? É equilátero? É isósceles? É escaleno?
Ações
V
V
F
F
“Equilátero”
V
F
V
-
“Isósceles”
V
F
F
V
“Escaleno”
F
-
-
-
“Não é triângulo”
Triângulo: (A<B+C) e (B<A+C) e (C<A+B)
Equilátero: (A=B) e (B=C)
Isósceles: (A=B) ou (B=C) ou (A=C)
Escaleno: (A<>B) e (B<>C) e (A<>C)
Seleção Encadeada Heterogênea
Algoritmo 3.5 – Tipos de Triângulo
início
inteiro: A, B, C; // tamanho dos lados
leia (A, B, C);
se (A<B+C) e (B<A+C) e (C<A+B) então
se (A=B) e (B=C) então
escreva (“Triangulo Equilátero”);
senão
se (A=B) ou (B=C) ou (A=C) então
escreva (“Triângulo Isósceles”);
senão
escreva (“Triangulo Escaleno”);
fimse;
fimse;
senão
escreva (“Estes valores não formam um triângulo”);
fimse;
fim.
Seleção Encadeada Homogênea
se – então – se
se <Cond1> então
se <Cond2> então
se <Cond3> então
se <Cond4> então W;
fimse;
fimse;
fimse;
fimse;
Cond1
Cond2
Cond3
Cond4
Ação
V
V
V
V
W
É equivalente a:
se <Cond1> e <Cond2> e <Cond3> e <Cond4> então W;
fimse;
Seleção Encadeada Homogênea
se X=V1 então
C1;
fimse;
se X=V2 então
C2;
fimse;
se X=V3 então
C3;
fimse;
se X=V4 então
C4;
fimse;
se X=V1
então C1;
senão se X=V2
então C2;
senão se X=V3
então C3;
senão se X=V4
se – senão – se
então C4;
fimse;
fimse;
fimse;
fimse;
X=V1 X=V2 X=V3 X=V4 Ação
X=V1 X=V2 X=V3 X=V4 Ação
V
F
F
F
C1
V
-
-
-
C1
F
V
F
F
C2
F
V
-
-
C2
F
F
V
F
C3
F
F
V
-
C3
F
F
F
V
C4
F
F
F
V
C4
Seleção de Múltipla Escolha
Seleções encadeadas homogêneas se-senão-se são
bastante frequentes para o tratamento de listas de valor
Para simplificar a escrita, pode-se utilizar o comando
escolha.
Adaptando o algoritmo anterior:
escolha X
caso V1: C1;
caso V2: C2;
caso V3: C3;
caso V4: C4;
fimescolha;
Seleção de Múltipla Escolha
Construa um algoritmo que, tendo como dados de entrada o preço de um
produto e seu código de origem, mostre o preço junto de sua procedência
Caso o código não seja nenhum dos especificados, o produto deve ser
encarado como importado
Siga a tabela de códigos abaixo
Código de origem
Procedência
1
Sul
2
Norte
3
Leste
4
Oeste
5 ou 6
Nordeste
7, 8 ou 9
Sudeste
10 até 20
Centro-oeste
25 até 30
Nordeste
Seleção de Múltipla Escolha
Algoritmo 3.6 – Múltipla Escolha
início
real: Preço;
inteiro: Origem;
leia (Preço, Origem);
escolha Origem
caso 1: escreva (Preço, “ – produto do Sul”);
caso 2: escreva (Preço, “ – produto do Norte”);
caso 3: escreva (Preço, “ – produto do Leste”);
caso 4: escreva (Preço, “ – produto do Oeste”);
caso 7, 8, 9: escreva (Preço, “ – produto do Sudeste”);
caso 10..20: escreva (Preço, “ – produto do Centro-Oeste”);
caso 5, 6, 25..50: escreva (Preço, “ – produto do Nordeste”);
caso contrário: escreva (Preço, “ – produto importado”);
fimescolha;
fim.
Estruturas de Repetição
São aquelas que permitem executar mais de uma vez
(repetir) um determinado trecho do algoritmo
O trecho do algoritmo em repetição é também chamado de
laço (ou “loop”)
As repetições devem ser sempre finitas
Quanto a quantidade de repetições, os laços podem ser
Pré-determinados: Sabe-se antes a quantidade de execuções
Indeterminados: Não se conhece a quantidade de execuções
Quanto ao critério de parada, os laços podem utilizar
Teste no início
Teste no final
Variável de controle
Repetição com Teste no Início
Laço que verifica antes de cada execução, se é “permitido”
executar o trecho do algoritmo
Trata-se de um laço que se mantém repetindo enquanto uma
dada condição permanecer verdadeira
enquanto <condição> faça
comando 1;
comando 2;
...
comando n;
fimenquanto;
Repetição com Teste no Início
Contador: Variável que reproduz o processo de
contagem
início
inteiro: CON;
CON  0;
enquanto CON < 3 faça
CON  CON + 1;
fimenquanto;
fim.
CON
3
2
1
0
Repetição com Teste no Início
Algoritmo 3.7 - Média Aritmética para 50 alunos
início
// declaração de variáveis
real: N1, N2, N3, N4, // notas bimestrais
MA; // média anual
inteiro: CON; // contador
CON  0; // inicialização do contador
enquanto (CON < 50) faça // teste da condição de parada
leia (N1, N2, N3, N4);
MA  (N1 + N2 + N3 + N4) / 4;
escreva (MA);
se (MA >= 7) então
escreva (“Aluno Aprovado. Parabéns !”);
senão
escreva (“Aluno Reprovado. Estude mais !”);
fimse;
CON  CON + 1; // incremento do contador
fimenquanto;
fim.
Repetição com Teste no Início
Acumulador: Variável que reproduz o processo de
acumulação
início
inteiro: CON, X, ACM;
CON  0;
ACM  0;
enquanto CON < 3 faça
CON  CON + 1;
leia (X);
ACM  ACM + X;
fimenquanto;
fim.
CON
ACM
X
3
2
1
0
11
7
5
0
4
2
5
Repetição com Teste no Início
Algoritmo 3.8 - Média Aritmética da turma de 50 alunos
início
// declaração de variáveis
real: MA, // média anual de dado aluno
ACM, // Acumulador
MAT; // Média Anual da Turma
inteiro: CON; // contador
CON  0; // inicialização do contador
ACM  0; // inicialização do acumulador
enquanto (CON < 50) faça // teste da condição de parada
leia (MA);
ACM  ACM + MA; // soma em ACM os valores lidos em MA
CON  CON + 1; // incremento do contador
fimenquanto;
MAT  ACM / 50; // calculo da média anual da turma
escreva (“média anual da turma = “, MAT);
fim.
Repetição com Teste no Final
Laço que verifica depois de cada execução, se é “permitido”
continuar executando o trecho do algoritmo
Trata-se de um laço que se mantém repetindo até que uma
dada condição se torne verdadeira
repita
comando 1;
comando 2;
...
comando n;
até <condição>;
Repetição com Teste no Final
Algoritmo 3.9 - Média Aritmética da turma com Repita
início
// declaração de variáveis
real: MA, // média anual de dado aluno
ACM, // Acumulador
MAT; // Média Anual da Turma
inteiro: CON; // contador
CON  0; // inicialização do contador
ACM  0; // inicialização do acumulador
repita
leia (MA);
ACM  ACM + MA; // soma em ACM os valores lidos em MA
CON  CON + 1; // incremento do contador
até (CON >= 50); // teste da condição de parada
MAT  ACM / 50; // calculo da média anual da turma
escreva (“média anual da turma = “, MAT);
fim.
Repetição com Variável de
Controle
Laço simplificado para utilização em repetições de
quantidade predeterminada
Incorpora internamente o funcionamento de um contador de
repetições
para V de vi até vf passo p faça
comando 1;
comando 2;
...
comando n;
fimpara;
Repetição com Teste no Final
Algoritmo 3.10 - Média Aritmética da turma com Para
início
// declaração de variáveis
real: MA, // média anual de dado aluno
ACM, // Acumulador
MAT; // Média Anual da Turma
inteiro: V; // contador
ACM  0; // inicialização do acumulador
para V de 1 até 50 passo 1 faça
leia (MA);
ACM  ACM + MA; // soma em ACM os valores lidos em MA
fimpara;
MAT  ACM / 50; // calculo da média anual da turma
escreva (“média anual da turma = “, MAT);
fim.
Comparação entre Estruturas de
Repetição
Aprendemos 3 maneiras de construir laços de repetição
É importante perceber que existem laços mais adequados ou
convenientes para cada situação
Estrutura
Condição
Quantidade de
Execuções
Condição de
Existência
Enquanto
Início
zero ou muitas
Condição verdadeira
Repita
Final
uma ou muitas
Condição falsa
Para
Não tem
((vf - vi) div p) + 1
v <= vf
Exercício
Construa um algoritmo que permita fazer um levantamento
do estoque de vinhos de uma adega, tendo como dados de
entrada tipos de vinho, sendo
T – vinho tinto
B – vinho branco
R – vinho rosê
Especifique a porcentagem de cada tipo sobre o total geral
de vinhos
A quantidade de vinhos é desconhecida
Utilize como finalizador
F – fim
Lógica de Programação
Estruturas de Dados
Estruturas de Dados
Tópicos
Vetores
Matrizes
Registros
Registro de Conjuntos
Conjuntos de Registros
Estruturas de Dados
Os tipos primitivos (inteiro, real, caracter e lógico) não são
suficientes para representar todos os tipos de informação.
Particularmente quando temos mais de uma informação
relacionada. Ex: Lista dos nomes dos alunos de uma sala,
endereço de alguém etc.
Utilizaremos os tipos primitivos para construir outras
estruturas de dados mais complexas.
Vetores
Também denominados Estruturas compostas homogêneas
unidimensionais
Permitem a manipulação de um conjunto de informações de
um mesmo tipo primitivo
Declaração :
tipo CLASSE = vetor [1 .. 40] de reais;
CLASSE: VCLASSE;
Onde:
CLASSE: Nome do tipo que está sendo construído
1: Limite inicial do vetor
40: Limite final do vetor
reais: Tipo primitivo base do vetor
VCLASSE: Nome da variável criada cf o tipo construído
Vetores
Manipulação:
inteiro: A;
VCLASSE [ 7 ]  6,5;
VCLASSE [ 2 ]  7,8;
VCLASSE [ 4 ]  5,3;
leia (A); // supondo que foi informado 6
VCLASSE [ A ]  9,8;
VCLASSE [ A-1 ]  9,1;
leia ( VCLASSE [ A+3 ] ); // supondo que foi informado 4,7
VCLASSE
7,8
1
2
5,3
3
4
9,1
5
9,8
6,5
6
7
4,7
8
9
38
39
40
Vetores
Algoritmo 4.1 – Notas acima da média usando variáveis simples
início
inteiro: NotaAcima;
real: A, B, C, D, E, F, G, H, I, J, Média;
NotaAcima  0;
leia (A,B,C,D,E,F,G,H,I,J);
Média  (A + B + C + D + E + F + G + H + I + J)/10;
se (A > Média)
então NotaAcima  NotaAcima + 1;
fimse;
se (B > Média)
então NotaAcima  NotaAcima + 1;
fimse;
...
se (J > Média)
então NotaAcima  NotaAcima + 1;
fimse;
escreva (NotaAcima);
fim.
Vetores
Algoritmo 4.2 – Notas acima da média usando vetor
início
tipo Classe = vetor [1 .. 10] de reais;
Classe: VClasse;
inteiro: NotaAcima, X;
real: Soma, Média;
Soma  0;
NotaAcima  0;
para X de 1 até 10 passo 1 faça
leia ( VClasse[X] );
Soma  Soma + VClasse[X];
fimpara;
Média  Soma / 10;
para X de 1 até 10 passo 1 faça
se ( VClasse[X] > Média )
então NotaAcima  NotaAcima + 1;
fimse;
fimpara;
escreva (NotaAcima);
fim.
Matrizes
Também denominadas Estruturas compostas homogêneas
multidimensionais
Permitem a manipulação de um conjunto de informações de
um mesmo tipo primitivo
Declaração:
tipo SALA = matriz [1 .. 4, 1 .. 4] de inteiros;
SALA: MSALA;
Onde:
SALA: Nome do tipo que está sendo construído
1: Limite inicial da primeira e da segunda dimensão
4: Limite final da primeira e da segunda dimensão
inteiros: Tipo primitivo base da matriz
MSALA: Nome da variável criada cf o tipo construído
Matrizes
MSALA
Manipulação:
inteiro : A, B;
MSALA [ 2, 3 ]  5;
MSALA [ 3, 2 ]  6;
MSALA [ 1, 2 ]  7;
A  4;
B  3;
MSALA [ A, B ]  8;
MSALA [ A, B-2 ]  9;
MSALA [ A-2, B-2 ]  10;
MSALA [ B, A ]  11;
MSALA [ B-2, A ]  12;
1
1
2
7
2 10
3
4 9
3
4
12
5
6
11
8
Matrizes
Exemplo: Cartão da Loteria Esportiva
Jg
Coluna 1
Ept
Coluna 2
1
Santos
Corinthians
2
Flamengo
Fluminense
3
Palmeiras
São Paulo
4
Vasco
Botafogo
5
Portuguesa
XV de jaú
6
São Caetano
XV de Piracicaba
7
Grêmio
Internacional
8
Havaí
Figueirense
9
Coritiba
Atlético-PR
10
Paysandú
Juventude
11
Atlético-MG
Cruzeiro
12
Brasiliense
Ponte Preta
13
Fortaleza
Goiás
14
Esportivo
Londrina
Matrizes
Algoritmo 4.3 – Loteria Esportiva, jogo mais marcado
início
tipo Loteria = vetor [1 .. 14, 1 .. 3] de caracteres;
Loteria: mLoteria;
inteiro: I, J, maisMar, nJogo, marLin;
maisMar  0;
para I de 1 até 14 faça
marLin  0;
para J de 1 até 3 faça
se mLoteria[ I, J] =‘x’;
então marLin  marLin + 1;
fimse;
fimpara;
se marLin > maisMar então
maisMar  marLin;
nJogo  I;
fimse;
fimpara;
escreva (“Jogo mais marcado: “, nJogo, “com “, maisMar);
fim.
Matrizes
Algoritmo 4.4 – Loteria Esportiva, coluna mais marcada
início
tipo Loteria = vetor [1 .. 14, 1 .. 3] de caracteres;
Loteria: mLoteria;
inteiro: I, J, maisMar, nColuna, marCol;
maisMar  0;
para J de 1 até 3 faça
marCol  0;
para I de 1 até 14 faça
se mLoteria[ I, J] =‘x’;
então marCol  marCol + 1;
fimse;
fimpara;
se marCol > maisMar então
maisMar  marCol;
nColuna  J;
fimse;
fimpara;
escreva (“Coluna mais marcada: “, nColuna, “com “, maisMar);
fim.
Registros
Também denominadas Estruturas compostas heterogêneas
Permitem a manipulação de um conjunto de informações de
tipos primitivos diferentes
Exemplo: Passagem de ônibus
Número: 0001
De: ____________________ Para: _______________________
Data: ____ / ____ / _______ Horário: ________ : _________
Poltrona: ____________
Distância: ____________ km
Registros
Declaração:
tipo regPassagem = registro
inteiro: Número;
caracter: Origem, Destino, Data, Horário;
inteiro: Poltrona;
real: Distância;
fimregistro;
regPassagem: Passagem;
Manipulação:
leia (Passagem);
escreva (Passagem);
leia (Passagem.Origem);
escreva (Passagem.Destino);
Passagem.Distância  500;
Registro de Conjuntos
Combinação de estruturas heterogêneas com homogêneas
Podem ser obtidas ao incluir num registro outro tipo de
dados construído
Exemplo: Registro de Estoque com Baixa semanal
Nome: _____________________________________________
Código: ___________________ Preço: __________________
Baixa
1
2
3
4
5
6
Registro de Conjuntos
Declaração:
tipo vDias = vetor [ 1 .. 6 ] de inteiros;
tipo regProd = registro
caracter: Nome;
inteiro: Código;
real: Preço;
vDias: Baixa;
fimregistro;
regProduto: Produto;
Manipulação:
escreva (Produto.Nome);
escreva (Produto.Código);
escreva (Produto.Preço);
escreva (Produto.Baixa [ 1 ]);
Produto.Baixa [ 4 ]  500;
Conjunto de Registros
Combinação de estruturas homogêneas com heterogêneas
Podem ser obtidas ao formar um conjunto com outro tipo de
dados construído
Exemplo: Ônibus formado por Passagem
1
Número: 0001
2
De: ____________________ Para: _______________________
3
Data: ____ / ____ / _______ Horário: ________ : _________
4
Poltrona: ____________
44
Distância: ____________ km
Conjunto de Registros
Declaração:
tipo regPassagem = registro
inteiro: Número;
caracter: Origem, Destino, Data, Horário;
inteiro: Poltrona;
real: Distância;
fimregistro;
Tipo vetPassagem = vetor [ 1 .. 44 ] de regPassagem;
vetPassagem: Ônibus;
Manipulação:
leia (Passagem [ 7 ]);
escreva (Passagem [ 4 ]);
leia (Passagem [12].Origem);
escreva (Passagem [21].Destino);
Passagem [34].Distância  500;