Universidade Federal do Vale do São Francisco
Curso de Engenharia de Computação
Introdução a Algoritmos – Parte 04
Prof. Jorge Cavalcanti
[email protected]
www.univasf.edu.br/~jorge.cavalcanti
www.twitter.com/jorgecav
1
Introdução a Algoritmos
Estruturas de controle de fluxo
Em alguns algoritmos, é necessário executar uma
mesma tarefa por um número determinado ou
indeterminado de vezes.
Exemplos:
Calcular a raiz quadrada dos números 1 à 100. Observe
que para cada número, o mesmo cálculo será realizado.
Neste caso, o cálculo é repetido 100 vezes.
Calcular a raiz quadrada de um número sempre que este
número for menor que 15.
Este fato gerou a criação das estruturas de repetição
as quais veremos a seguir.
2
Introdução a Algoritmos
Estrutura de Repetição – Enquanto
Neste caso, uma dada tarefa será repetida enquanto
uma determinada condição for verdadeira.
Sintaxe:
enquanto (<expressão lógica ou relacional>)
faca<sequência de comandos>
Fimenquanto
Obs: <expressão lógica ou relacional> é avaliada antes de
cada repetição do laço. Quando seu resultado for
VERDADEIRO, <sequência-de-comandos> é executada.
O fato da avaliação da expressão lógica encontrar-se
no início do laço faz com que a sequência de
comandos só venha a ser executada se ao menos uma
vez a avaliação da expressão resultar em verdadeiro.
3
Introdução a Algoritmos
algoritmo "Exemplo 1 - enquanto"
var
r: real
inicio
escreval ("Digite um numero")
leia (r)
enquanto (r<100) faca
r <- (r^(1/2))
escreval (r)
leia (r)
fimenquanto
fimalgoritmo
4
Introdução a Algoritmos
5
Introdução a Algoritmos
Estrutura ou laço de repetição – enquanto (continuação)
Exemplo 2:
O pseudocódigo e os fluxogramas a
seguir escrevem na saída padrão os
números inteiros contidos no intervalo [1,
10].
6
Introdução a Algoritmos
algoritmo "exemplo 2 laço enquanto"
var
valor: inteiro
inicio
valor <- 1
enquanto (valor <= 10) faca
escreval (valor)
valor <- valor+1
fimenquanto
fimalgoritmo
7
Introdução a Algoritmos
Inicio
Inicio
valor: inteiro
valor: inteiro
Valor <- 1
Valor <- 10
falso
valor<=10
falso
Fim
Valor>0
verdadeiro
verdadeiro
Valor <- valor-1
valor, “ ”
10-valor, “ ”
Valor <- valor+1
8
Fim
Introdução a Algoritmos
E se a condição do exemplo 1 for 50 < r < 100?
algoritmo "Exemplo 1m enquanto"
Var
r: real
Inicio
Escreval (“Digite um número maior que 50 e menor que 100”)
leia (r)
enquanto (r > 50) e (r < 100) faca
r <- r^(1/2)
escreval (r)
leia (r)
fimenquanto
fimalgoritmo
9
Introdução a Algoritmos
10
Introdução a Algoritmos
Estrutura de Repetição – Repita ... Até
<seqüência de comandos> será
executada sempre que o resultado da
<expressão lógica ou relacional>
resultar em FALSO.
Sintaxe:
repita
<seqüência de comandos>
ate (<expressão lógica ou relacional>)
<seqüência de comandos> é executada ao menos uma vez,
visto que a avaliação da <expressão lógica ou
relacional> encontra-se no final da estrutura de repetição.
Obs.: As instruções contidas no repita serão executadas enquanto o
resultado da avaliação da expressão lógica resultar em falso. O
fato da avaliação da expressão lógica encontrar-se no final do laço
faz com que, mesmo no caso da expressão lógica nunca resultar
em falso, a sequência de comandos seja executada ao menos uma
vez.
11
Introdução a Algoritmos
algoritmo "Repita...ate"
var
a: inteiro
inicio
escreval("Digite um numero inteiro menor que
10")
Sempre que a condição a=10 for
leia(a)
FALSA, a seqüência de comandos
repita
será executada.
a<- a+1
escreval (a)
ate (a=10)
fimalgoritmo
12
Estruturas de Controle de Fluxo
Inicio
Inicio
valor: inteiro
valor: inteiro
Valor <- 9
Valor <- 0
Valor <- valor+1
10-valor, “ ”
valor, “ ”
falso
Valor <- valor-1
valor=10
verdadeiro
Fim
falso
13
Valor=-1
verdadeiro
Fim
Estruturas de Controle de Fluxo
Exercício:
Faça um algoritmo que recebe números
naturais fornecidos pelo usuário, quando o usuário
quiser parar a execução do algoritmo, o mesmo
fornecerá um número negativo.
O algoritmo deve retornar, ao final de seu
processamento, a quantidade de números naturais
fornecida pelo usuário. Fazer dois
algoritmos
utilizando em cada um, uma das estruturas de
repetição vistas.
Os
algoritmos
desenvolvidos
devem
ser
representados através de um pseudocódigo e de
um fluxograma.
14
Estruturas de Controle de Fluxo
algoritmo "exercício laço de repetição (a) "
var num, contador: inteiro
inicio
contador <- 0
repita
escreva ("Entre com um número natural (entre
com um inteiro negativo para sair): ")
leia (num)
se (num>=0) entao
contador <- contador + 1
fimse
ate (num<0)
escreva ("Foram fornecidos " ,contador, " números
naturais pelo usuário ")
fimalgoritmo
15
Estruturas de Controle de Fluxo
algoritmo " exercício 15 laço de repetição (b)"
var num, contador: inteiro
inicio
contador <- -1
repita
escreva ("Entre com um número natural (entre
com um inteiro negativo para sair): ")
leia (num)
contador <- contador + 1
ate (num<0)
escreva ("Foram fornecidos " ,contador, " números
naturais pelo usuário ")
fimalgoritmo
16
Estruturas de Controle de Fluxo
Inicio
num, contador: inteiro
contador <- -1
"Entre com um número
natural (entre com
um inteiro
negativo para sair): "
num
contador <- contador+1
falso
num<0
verdadeiro
"Fora fornecidos " ,
contador, " números
naturais pelo usuário "
17
Fim
Estruturas de Controle de Fluxo
algoritmo "exercício 15 laço de repetição enquanto (a)"
var num, contador: inteiro
inicio
contador <- 0
escreva ("Entre com um número natural (entre com
um inteiro negativo para sair): ")
leia (num)
enquanto (num>=0) faca
contador <- contador + 1
escreva ("Entre com um número natural (entre
com um inteiro negativo para sair): ")
leia (num)
fimenquanto
escreva ("Foram fornecidos " ,contador, " números
naturais pelo usuário")
fimalgoritmo
18
Estruturas de Controle de Fluxo
algoritmo " exercício 15 laço de repetição enquanto b"
var num, contador: inteiro
Inicio
num <- 1
contador <- -1
enquanto (num>=0) faca
contador <- contador + 1
escreva ("Entre com um número natural (entre com
um inteiro negativo para sair): ")
leia (num)
fimenquanto
escreva ("Foram fornecidos " ,contador, " números
naturais pelo usuário")
fimalgoritmo
19
Estruturas de Controle de Fluxo
Inicio
num, contador: inteiro
num <- 1
contador <- -1
falso
num>=0
"Fora fornecidos " ,
contador, " números
naturais pelo usuário "
verdadeiro
contador <- contador+1
num
"Entre com um número
natural (entre com
um inteiro
negativo para sair): "
20
Fim
Estruturas de Controle de Fluxo
Fluxograma/Exercício – Construa um fluxograma para
obter o resultado da divisão entre dois números. OBS.: Caso
um dos operandos não seja válido o mesmo deve ser
novamente solicitado até um valor válido ser fornecido, ou
seja, as entradas devem ser validadas.
Inicio
n1, n2, res: real
“Digite o
Dividendo:”
n1, “/”,n2, “=”,res
res <- n1 / n2
verdadeiro
falso
n1
“Digite o
Divisor:”
n2<>0
n2
21
Fim
Estruturas de Controle de Fluxo
Estrutura ou laço de repetição
Ao analisarmos o que ocorre nos laços de repetição
enquanto e repita, perceberemos que,
normalmente, ocorre uma inicialização de uma
variável, envolvida na expressão lógica que controla
o número de repetições.
Dentro do laço ocorre uma atualização no valor da
variável mencionada, fazendo com que esta venha a
tornar o resultado da avaliação da expressão lógica
coerente para a finalização da execução do laço de
repetição.
Com base nesta observação foi criado o laço de
repetição para.
Introdução a Algoritmos
Estrutura de Repetição – Para
Sintaxe:
Conta o número de repetições (deve
ser necessariamente uma variável do
tipo inteiro)
Especifica o valor máximo que
a variável contadora pode
alcançar.
Especifica o valor de inicialização da
variável contadora.
para <variável> de <valor-inicial> ate <valor limite>
passo<incremento> faca
<sequência de comandos>
fimpara
Quando o programa chega neste ponto, a
variável contadora é incrementada e
comparada com o valor limite.
Indica o valor do
incremento que será
acrescentado à variável
contadora
em
cada
repetição do laço.
É
opcional.
23
Estruturas de Controle de Fluxo
<valor-inicial> É uma expressão que especifica o valor
de inicialização da variável contadora.
<valor-limite> É uma expressão que especifica o valor
máximo que a variável contadora pode alcançar.
<incremento> É opcional. Quando presente, é
precedido pela palavra-reservada passo. Constitui-se
de uma expressão que especifica o valor do incremento
que será acrescentado à variável contadora em cada
repetição do laço. O valor padrão, assumido por
omissão de <incremento> é 1.
É possível especificar valores negativos para
<incremento>.
24
Estruturas de Controle de Fluxo
fimpara Indica o fim da sequência de comandos a
serem repetidos. Cada vez que o programa chega neste
ponto, é acrescentado à variável contadora o valor de
<incremento>, e o valor resultante é comparado a
<valor-limite>. Se for menor ou igual (ou maior ou igual,
quando <incremento > for negativo), a sequência de
comandos será executada mais uma vez; caso contrário,
a execução prosseguirá a partir do primeiro comando que
esteja após o fimpara.
<valor-inicial>, <valor-limite> e <incremento> são
avaliados uma única vez antes da execução da primeira
repetição, e não se alteram durante a execução do
laço, mesmo que variáveis eventualmente presentes
nessas expressões tenham seus valores alterados.
25
Introdução a Algoritmos
Exemplo 7:
O pseudocódigo e o fluxograma a seguir escrevem na saída padrão
os números inteiros contidos no intervalo [0, 10].
algoritmo "exemplo para"
var
valor: inteiro
inicio
para valor de 0 ate 10 faca
escreval (valor)
fimpara
fimalgoritmo
Se passo for omitido, o valor default do
incremento é 1.
26
Introdução a Algoritmos
algoritmo "Exemplo Para modificado"
var
n, j:inteiro
No programa foi adicionado uma
variável de incremento, onde o valor
desta é digitada pelo usuário.
Inicio
escreval ("Digite um numero inteiro")
leia(n)
para j de 0 ate 10 passo n faca
escreval (j)
Obs:<valor-inicial>, <valor-limite> e
fimpara
<incremento> são avaliados uma única vez
fimalgoritmo
antes da execução da primeira repetição, e
não se alteram durante a execução do laço,
mesmo que variáveis eventualmente presentes
nessas expressões tenham seus valores alterados.
27
Estruturas de Controle de Fluxo
Inicio
valor: inteiro
Valor <- 0
falso
valor<=10
verdadeiro
valor, “ ”
Valor <- valor+1
Fim
Introdução a Algoritmos
Ex.: Construa um pseudocódigo para um algoritmo que exiba em um
monitor uma contagem decrescente do valor 30 até o valor 1.
algoritmo “decrescendo1"
var
n: inteiro
inicio
para n de 30 ate 1 passo -1 faca
escreval (n)
fimpara
algoritmo “decrescendo2"
var
fimalgoritmo
n: inteiro
inicio
para n de 0 ate 29 faca
escreval (30-n)
fimpara
fimalgoritmo
29
Estruturas de Controle de Fluxo
Para finalizarmos nosso estudo das estruturas de controle
de fluxo, vamos tratar do teorema que as originou: o
Teorema da Programação Estruturada, conhecido como
Teorema de Böhm-Jacopini.
Enunciado em 1966 por Corrado Böhm e Giuseppe
Jacopini, sendo resultado da teoria das linguagens de
programação, O qual define que cada rotina computável
pode ser descrita por um algoritmo que combine as
instruções utilizando apenas três maneiras especificas:
1. Executar uma instrução, depois outra instrução
(sequência);
2. Executar uma ou duas sequências de instruções de
acordo com um valor booleano (condição);
3.Executar uma sequências de instruções até que um
valor booleano seja verdadeiro (iteração).
30
Algoritmos e Programação
1)Receba do usuário um número entre 1 e 7, inclusive 1 e 7.
Se ele digitar o número 1 mostre “Hoje é Domingo”, se ele
digitar o número 2 mostre “Hoje é Segunda”.......
2)Peça uma letra e mostre se ela é vogal ou consoante.
3) Peça três números e mostre o maior entre eles.
31
Algoritmos e Programação
1 - Receba do usuário um número entre 1 e 7,
inclusive 1 e 7. Se ele digitar o número 1 mostre
“Hoje é Domingo”, se ele digitar o número 2 mostre
“Hoje é Segunda”.......
algoritmo "Dias da Semana seleção múltipla“
var
num: inteiro
inicio
// Seção de Comandos
escreval ("Digite um número de 1 a 7:")
leia (num)
escolha (num)
caso 1
escreval ("Hoje é Domingo")
caso 2
escreval ("Hoje é Segunda")
caso 3
escreval ("Hoje é Terça")
caso 4
escreval
caso 5
escreval
caso 6
escreval
caso 7
escreval
outrocaso
escreval
fimescolha
("Hoje é Quarta")
("Hoje é Quinta")
("Hoje é Sexta")
("Hoje pe Sábado")
("Número inválido")
fimalgoritmo
32
Algoritmos e Programação
2 - Peça uma letra e mostre se ela é vogal ou
consoante.
algoritmo "Letras do Alfabeto seleção multipla“
Tudo na mesma
linha do algoritmo
var
let: caracter
caso "b", "c", "d", "f", "g", "h", "j",
inicio
"k", "l", "m", "n", "p", "q", "r",
// Seção de Comandos
"s", "t", "v", "x", "w", "y", "z"
escreval ("Digite uma letra do alfabeto:")
escreval ("É uma consoante")
leia (let)
outrocaso
escolha (let)
escreval ("É outro caractere")
caso "a", "e", "i", "o", "u"
fimescolha
escreval ("É uma vogal")
fimalgoritmo
33
Algoritmos e Programação
3 - Peça três números e mostre o maior entre eles.
algoritmo "MAIOR“
var
n1,n2,n3, maior: inteiro
inicio
// Seção de Comandos
escreval ("Digite três números")
leia (n1,n2,n3)
se (n1>n2) e (n1>n3) entao
maior:= n1
senao
se (n2>n3) entao
maior:= n2
senao
maior:= n3
fimse
fimse
escreva (maior)
fimalgoritmo
34
Algoritmos e Programação
Exercícios
4. Faça um algoritmo para escrever os números pares de 0
a 100.
5. Faça um algoritmo para escrever a série de Fibonacci =
(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...) enquanto o termo a
ser impresso for menor que 300.
6. Construa um algoritmo que receba dois números reais e
um dos seguintes símbolos: +, -, * ou /, o qual designará
qual operação será aplicada considerando os valores
recebidos como seus operandos. O referido algoritmo
deve retornar o resultado da operação selecionada com
uma precisão de dois dígitos (observar a divisão por 0).
35
Algoritmos e Programação
4. Faça um algoritmo para escrever os números pares
de 0 a 100.
algoritmo "par de 0 a 100“
var
par: inteiro
Inicio
para par de 0 ate 100 faca
se(par%2)=0 entao
escreval (par)
fimse
fimpara
fimalgoritmo
36
Algoritmos e Programação
5. Faça um algoritmo para escrever a série de
Fibonacci = (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...)
enquanto o termo a ser impresso for menor que 300.
enquanto (proximo<300)
algoritmo “fibonacci“
faca
var
escreval (proximo)
proximo, atual, anterior: inteiro
proximo:= (atual + anterior)
Inicio
anterior:= atual
proximo:= 0
atual:= proximo
atual:= 0
fimenquanto
anterior:= 1
se proximo = 0 entao
escreval (proximo)
fimse
fimalgoritmo
37
Algoritmos e Programação
6. Construa um algoritmo que receba dois números reais
e um dos seguintes símbolos: +, -, * ou /, o qual
designará qual operação será aplicada considerando os
valores recebidos como seus operandos.
O referido algoritmo deve retornar o resultado da
operação selecionada com uma precisão de dois dígitos.
38
Algoritmos e Programação
Ex. 06 - algoritmo “calculadora"
var op1, op2: real
operador: caractere
inicio
escreva ("Entre com o primeiro operando: ")
leia (op1)
escreva ("Entre com o segundo operando: ")
leia (op2)
escreva ("Entre com um dos operadores (+, -, *, /): ")
leia (operador)
escolha (operador)
caso "+“
escreva (op1," ",operador,op2," =",op1+op2:10:2)
caso "-"
escreva (op1," ",operador,op2," =",op1-op2:10:2)
39
Algoritmos e Programação
Ex 6. Continuação
caso "*"
escreva (op1," ",operador,op2," =", op1*op2:10:2)
caso "/"
se (op2<>0) entao
escreva (op1," ",operador,op2," =")
escreval (op1/op2:10:2)
senao
escreva ("Não é possível efetuar a divisão!")
fimse
Outrocaso
escreva ("Operação inválida! ")
fimescolha
fimalgoritmo
40
Algoritmos e Programação
7. Escreva um programa que requisita dois números e faz a
soma deles e depois pergunta se o usuário quer fazer o cálculo
novamente.
8. Escreva um programa que recebe um número e conta a
partir deste número até 100.
9. Ler 10 números e dizer se cada um é: nulo, positivo ou
negativo.
41
Algoritmos e Programação
7. Escreva um programa que requisita dois números e
faz a soma deles e depois pergunta se o usuário quer
fazer o cálculo novamente.
algoritmo “repete soma“
var
n1, n2, soma: real
resp: caracter
Inicio
repita
escreval ("Digite dois numeros para serem somados:")
leia (n1,n2)
soma:= n1+n2
escreval ("A soma eh:" ,soma)
escreval ("Digite algo p/ fazer novo calculo e fim p/ encerrar")
leia (resp)
ate (resp = “fim")
fimalgoritmo
42
Algoritmos e Programação
8. Escreva um programa que recebe um número e conta
a partir deste número até 100.
algoritmo “Conta ate 100“
var
a: inteiro
inicio
escreval("Digite um numero inteiro menor que 100")
leia(a)
repita
a<-a+1
escreval (a)
ate (a=100)
fimalgoritmo
43
Algoritmos e Programação
9. Ler 10 números e dizer se cada um é: nulo, positivo
ou negativo.
algoritmo “definir numero“
var
n1: inteiro
Inicio
para n1 de 0 ate 10 faca
escreval ("Digite um numero:")
leia (n1)
se (n1=0) entao
escreval ("nulo")
fimse
se (n1<0) entao
escreval ("Numero negativo")
fimse
se (n1>0) entao
escreval ("Numero positivo")
fimse
fimpara
fimalgoritmo
44
Algoritmos e Programação
10. Escreva um programa que calcula o valor do imposto de
renda de uma pessoa física, com as seguintes condições: se o
salário >= 3.000, alíquota será 15%. Se 3.000>salário>=1500,
alíquota será 7%. Se salário < 1500, isento.
11. Escreva um algoritmo que calcule N!, sendo que N é um
inteiro fornecido pelo usuário e que 0! =1, por definição.
12. Elabore um algoritmo para cada estrutura de repetição
(enquanto, repita e para) imprimir a tabuada do número 5.
45
Algoritmos e Programação
10. Escreva um programa que calcula o valor do imposto de renda de
uma pessoa física, com as seguintes condições: se o salário >= 3.000,
alíquota será 15%. Se 3.000>salário>=1500, alíquota será 7%. Se
salário < 1500, isento.
algoritmo "Imposto de Renda"
// Seção de Declarações
var
salario, imposto: real
aliquota: caractere
inicio
// Seção de Comandos
escreva(" Informe o valor do salário: ")
leia(salario)
// definicao da alíquota
se (salario >= 3000) entao
aliquota <- "c"
senao
se (salario < 1500) entao
aliquota <- "a"
senao
aliquota <- "b"
fimse
fimse
escolha aliquota
caso "a"
imposto <- 0
caso "b"
imposto <- salario * 0.07
caso "c"
imposto <- salario * 0.15
fimescolha
escreval(" Valor do imposto de renda:",imposto)
fimalgoritmo
46
Algoritmos e Programação
11. Escreva um algoritmo que calcule N!, sendo que N é um
inteiro fornecido pelo usuário e que 0! =1, por definição.
algoritmo "Fatorial de N"
// Seção de Declarações
var N, F, C: inteiro // entrada, fatorial e controle)
inicio
// Seção de Comandos
Escreva ("Digite um número inteiro: ")
leia(N)
Se (N = 0)entao
escreva ("Fatorial de ", N, " = 1")
senao
F <-1
para c de 1 ate n faca
F <- F*C
fimpara
escreva ("Fatorial de ", N, " = ", F)
Fimse
Fimalgoritmo
47
Algoritmos e Programação
12. Elabore um algoritmo para cada estrutura de repetição
(enquanto, repita e para) imprimir a tabuada do número 5.
algoritmo "Tabuada do 5 usando enquanto"
// Seção de Declarações
var cont: inteiro
inicio
// Seção de Comandos
cont <- 1
enquanto (cont <=10) faca
escreval (cont, " x 5 = " , cont*5)
cont <- cont +1
fimenquanto
fimalgoritmo
algoritmo "Tabuada do 5 usando repita"
// Seção de Declarações
var cont: inteiro
inicio
// Seção de Comandos
cont <- 1
repita escreval (cont, " x 5 = " , cont*5)
cont <- cont +1
ate (cont <10)
fimalgoritmo
algoritmo "Tabuada do 5 usando para“
var cont: inteiro
Inicio
cont <- 1
para cont de 1 ate 10 faca
escreval (cont, " x 5 = " , cont*5)
cont <- cont +1
fimpara
fimalgoritmo
48