WBA1150_v1.

Lógica de programação
Estruturas de controle
Entrada e saída de dados.
Estruturas sequenciais lineares.

Bloco 1
Fabiano Gonçalves dos Santos
 Entrada e saída de dados

Como escrever algoritmos usando pseudocódigo?

Sugestões:

Figura 1 – Portugol Studio Figura 2 – VisualG

Fonte: https://upload.wikimedia.org/wikipedia/ Fonte: https://visualg3.com.br/wp-

commons/7/7d/Logo_Portugol.jpg. Acesso em: content/uploads/2017/04/cropped-logo-
30 ago. 2022. 1.png. Acesso em: 30 ago. 2022.
Entrada e saída de dados

Entrada Processamento Saída

leia( ) escreva ( )

nome_da_função (lista de parâmetros)

leia(X)
escreva (“Texto.\n”)
leia (x, y) escreva (var, ”\n”)
escreva (var+var, ”\n”)
escreva (“Texto com\n”, “quebra de linha”)
escreva (“Texto com\t tabulação”)
Estruturas sequenciais
Blocos.
• Conjunto de ações com uma função definida.

programa
{
funcao inicio ()
{
Bloco 1

Bloco 2

cadeia nome
escreva("Digite seu nome: ")
leia(nome)
escreva(“Olá “,nome)
}
}
Introdução aos algoritmos
programa
{
funcao inicio()
{
inteiro numero, multiplo
escreva("Digite um número: ")
leia(numero)
/*
* Para verificar se um número é múltiplo de outro utiliza-se a operação
* módulo, representada no Portugol pela operador %.
*
* Se o resultado da operação for 0, então um número é múltiplo do outro.
*/
limpa()
se (numero % 5 == 0)
{
escreva("O número ", numero, " é multiplo de 5")
}
senao
{
escreva("O número ", numero, " não é multiplo de 5")
}
escreva("\n")
}
}
Estruturas de controle
Estruturas de seleção/decisão

Bloco 2
Fabiano Gonçalves dos Santos
Seleção simples e composta
se <condição> {
// início do bloco
verdade programa {
comando 1
funcao inicio() {
comando 2
...
real n1,n2,n3,n4,ma
comando n leia(n1,n2,n3,n4)
// fim do bloco verdade ma = (n1+n2+n3+n4)/4
} escreva(ma)
se (ma>=5) {
se <condição> { escreva("\nAprovado")
//início bloco verdade }
comando 1 senao {
comando n
escreva("\nReprovado")
//fim do bloco verdade
senão {
}
// início do bloco falso }
comando 1 }
comando n
} // fim do bloco falso
Seleção encadeada heterogênea
programa {
funcao inicio() {
inteiro a, b, c
leia (a,b,c)
se (a == b e a == c) {
escreva ("\nEquilátero")
}
senao {
se (a == b ou b == c ou c == a) {
escreva ("\nIsósceles")
}
senao {
escreva ("\nEscaleno")
}
}
}
}
 Seleção encadeada homogênea
se – então – se
se <Cond1> {
se <Cond2> {
se <Cond3> { Cond1 Cond2 Cond3 Cond4 Ação
se <Cond4> { V V V V W
W
}
}
}
}

É equivalente a:
se <Cond1> e <Cond2> e <Cond3> e <Cond4> {
W
}
Seleção encadeada homogênea
se X=V1 {
C1
se – senão – se }
senão {
X=V1 X=V2 X=V3 X=V4 Ação se X=V2 {
V - - - C1 C2
}
F V - - C2
senão {
F F V - C3 se X=V3 {
F F F V C4 C3
}
senão {
se X=V4 {
C4;
}
}
}
} //fim senão
Seleção de múltipla escolha
programa {
funcao inicio() {
inteiro opcao
escreva("1) Elogio \n")
escreva("2) Ofensa \n")
escreva("3) Sair \n\n")
escreva("Escolha uma opção: ")
leia(opcao)
limpa()
escolha (opcao) {
caso 1:
escreva (“Bonito(a)!")
pare // Impede que as instruções do caso 2 sejam executadas
caso 2:
escreva (“Feio(a)!")
pare // Impede que as instruções do caso 2 sejam executadas
caso 3:
escreva ("Tchau!")
pare
caso contrario: // Será executado para qq opção diferente de 1, 2 ou 3
escreva ("Opção Inválida !")
}
escreva("\n")
}
}
Estruturas de controle
Estruturas de repetição

Bloco 3
Fabiano Gonçalves dos Santos
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 à quantidade de repetições, os loopings 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
programa { Loop que verifica a
funcao inicio() {
inteiro contador condição antes da
real n1,n2,n3,n4,ma execução do bloco.
contador = 0
enquanto (contador<3) {
leia(n1,n2,n3,n4) É um loop que fica
ma = (n1+n2+n3+n4)/4
escreva(ma) repetindo enquanto uma
se (ma>=5){ dada condição é
escreva("Aprovado")
} verdadeira.
senao {
escreva("Reprovado")
} Uso de contadores e
contador = contador+1 acumuladores.
}
}
}
Repetição com teste no final
programa {
funcao inicio() {
inteiro contador
real n1,n2,n3,n4,ma Loop que primeiro executa
contador = 1 o bloco e depois verifica a
faca {
leia(n1,n2,n3,n4)
continuação do loop de
ma = (n1+n2+n3+n4)/4 acordo com a condição.
escreva(ma)
se (ma>=5){
escreva("\nAprovado\n")
Trata-se de um laço que se
} mantém repetindo até que
senao { uma dada condição se
escreva("\nReprovado\n")
}
torne verdadeira.
contador = contador+1
} enquanto (contador<3)
}
}
Repetição com variável de controle
programa {
funcao inicio() {
inteiro num, res, con
leia(num)
para (con = 1; con <= 10; con++)
{
res = num * con
escreva (num, " X ", con, " = ", res , "\n")
}
}
}

Loop usado em repetições de quantidade

predeterminada.
Possui internamente o funcionamento de um contador
de repetições.
Comparação
É importante perceber que existem laços mais adequados ou
convenientes para cada situação de repetição.
Figura 3 – Comparação

Fonte: elaborada pelo autor.

Teoria em Prática
Bloco 4
Fabiano Gonçalves dos Santos
Elabore o seguinte algoritmo
Construa um algoritmo para uma adega de vinhos.
Seu objetivo é contar a quantidade de vinhos por tipo.
Os vinhos podem ser tintos (T), brancos (B) ou rosé (R).
O usuário entrará com o tipo e o algoritmo internamente
contará a quantidade e calcular a porcentagem de cada tipo
em relação ao total.
O algoritmo lerá as entradas enquanto o usuário não digitar
“f” (para finalizar).
O algoritmo deve apresentar a % de cada tipo em relação ao
total no final.
Resolução

programa
{
funcao inicio()
{
caracter tipo
inteiro con, con_t, con_b, con_r
real por_t, por_b, por_r

con = 0
con_t= 0
Inicialização do
con_b = 0
algoritmo e declaração
con_r = 0
de variáveis.

continua
Resolução (parte 2)
faca {
leia(tipo)

escolha (tipo) {
caso 't':
con_t++
pare
caso 'b':
con_b++
Entrada de dados.
pare
caso 'r':
con_r++
pare
}
con++
} enquanto (tipo != 'f’)
con = con-1
se (con>0) {
por_t = con_t*100/con
por_b = con_b*100/con
por_r = con_r*100/con
escreva("% de tintos = ", por_t)
escreva("\n% de brancos = ", por_b)
escreva("\n% de rose = ", por_r) Classificação.
}
senao {
escreva("Sem entrada de vinhos")
}
}//fim do bloco inicio
}//fim programa
Dicas do(a) Professor(a)
Bloco 5
Fabiano Gonçalves dos Santos
Leitura Fundamental
Prezado aluno, as indicações a seguir podem estar disponíveis
em algum dos parceiros da nossa Biblioteca Virtual (faça o login
por meio do seu AVA), e outras podem estar disponíveis em sites
acadêmicos (como o SciELO), repositórios de instituições
públicas, órgãos públicos, anais de eventos científicos ou
periódicos científicos, todos acessíveis pela internet.
Isso não significa que o protagonismo da sua jornada de
autodesenvolvimento deva mudar de foco. Reconhecemos que
você é a autoridade máxima da sua própria vida e deve,
portanto, assumir uma postura autônoma nos estudos e na
construção da sua carreira profissional.
Por isso, nós o convidamos a explorar todas as possibilidades da
nossa Biblioteca Virtual e além! Sucesso!
Indicação de leitura 1
Excelente livro para encontrar exemplos dos algoritmos
mostrados na aula.

FORBELLONE, André L. V.; EBERSPACHER; Henri F. Lógica de

programação: a construção de algoritmos e estruturas de
dados. São Paulo: Prentice Hall, 2005.
Indicação de leitura 2
Outro livro para encontrar novos exemplos dos algoritmos
apresentados na aula.

GUEDES, Sérgio (org.). Lógica de programação algorítmica.

São Paulo: Pearson, 2014.
Dica do(a) Professor(a)
Scratch.
É um software desenvolvido pelo MIT (Massachusetts Institute
of Technology) para ajudar as pessoas a aprender
programação.
A versão 2.0 permite que os projetos sejam feitos no
navegador, eliminando a necessidade de baixar e instalar
programas no computador.
Referências
FORBELLONE, André L. V.; EBERSPACHER, Henri F. Lógica de
programação: a construção de algoritmos e estruturas de
dados. São Paulo: Prentice Hall, 2005.

GUEDES, Sérgio (org). Lógica de programação algorítmica.

São Paulo: Pearson, 2014.

MEIO, Ana C. Princípios de linguagem de programação. São

Paulo: Blucher, 2003
Bons estudos!