Introdução aos Computadores e
Programação
Engenharia Civil
Instituto Politécnico de Viseu
Escola Superior de Tecnologia
Departamento de Informática
1º Ano - 2º Semestre
Ficha de Trabalho n.º 2 – Soluções propostas
“Estudo prático de algoritmos”
1. Dado o preço de um determinado artigo e a quantidade de dinheiro disponível, determinar quantas
unidades se podem comprar e quanto dinheiro sobra.
Análise do problema:
Entradas: preço_artigo, dinheiro
Saídas: unidades, troco
Descrição do problema: unidades ← dinheiro / preço_artigo (divisão inteira)
troco ← dinheiro – preço_artigo * unidades
Algoritmo:
Parte declarativa:
Variáveis:
Preço_artigo, dinheiro, unidades, troco: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o preço do artigo?’)
LER(preço_artigo)
ESCREVER(‘Qual o dinheiro disponível?’)
LER(dinheiro)
SE preço_artigo = 0 ENTÃO
ESCREVER(“ERRO: Preço não válido”)
SENÃO
unidades ← dinheiro DIVISÃO_INTEIRA preço_artigo
troco ← dinheiro – unidades*preço_artigo
ESCREVER(‘Com ‘, dinheiro, ‘ é possível comprar ‘, unidades, ‘ e receber de troco ‘ troco)
FIM SE
FIM
2. Determinar o maior de três números.
Análise do problema:
Entradas: valor1, valor2, valor3
Saídas: maior
Descrição do problema: maior ← valor1 se maior que valor2 e valor3
maior ← valor2 se maior que valor1 e valor3
maior ← valor3 se maior que valor1 e valor2
Algoritmo:
Parte declarativa:
Variáveis: maior, valor1, valor2, valor3: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Indique o valor 1, valor 2 e valor 3?’)
LER(valor1, valor2, valor3)
SE valor1 > valor2 ENTÃO
maior ← valor1
SENÃO
maior ← valor2
FIM SE
SE valor3 > maior ENTÃO
maior ← valor3
FIM SE
ESCREVER(‘O maior valor encontrado é: ‘, maior)
FIM
1/9
3. Calcular a área e o perímetro das seguintes figuras: Rectângulo, Triângulo rectângulo e Círculo.
Análise do problema:
Entradas: opção, (ladoA, ladoB) ou (base, altura) ou (raio)
Saídas: area, perimetro
Descrição do problema: Para o rectângulo: area ← ladoA * ladoB; perimetro ← (ladoA+ladoB)*2
Para o triângulo rect.: area ← base*altura/2; perimetro ← base+altura+raizq(base^2+altura^2)
Para o círculo: area ← pi*raio^2; perimetro ← 2*pi*raio
Algoritmo:
Parte declarativa:
Constantes: Pi = 3,1415
Variáveis:
area, perimetro, ladoA, ladoB, base, altura, raio: tipo REAL
opção: tipo CARACTER
Parte operativa:
INICIO
ESCREVER(‘Calcular a área e perímetro do (R)ectângulo, (T)riângulo rectângulo ou (C)írculo? ’)
LER(opção)
CASO opção SEJA
‘R’ ou ‘r’ FAZ: ESCREVER(‘Quais as dimensões do lado A e lado B do rectângulo? ‘)
LER(ladoA, ladoB)
area ← ladoA*ladoB
perimetro ← (ladoA + ladoB)*2
ESCREVER(‘A área do Rectângulo é ‘, area, ‘ e o perímetro é ‘, perimetro)
‘T’ ou ‘t’ FAZ: ESCREVER(‘Quais as dimensões da Base e Altura do Triângulo rectângulo? ‘)
LER(base, altura)
area ← base*altura/2
perimetro ← base + altura + raizq(base^2+altura^2)
ESCREVER(‘A área do Triângulo rectângulo é ‘, area, ‘ e o perímetro é ‘, perimetro)
‘C’ ou ‘c’ FAZ: ESCREVER(‘Qual o raio do Círculo? ‘)
LER(raio)
area ← pi*raio*raio
perimetro ← 2*pi*raio
ESCREVER(‘A área do Círculo é ‘, area, ‘ e o perímetro é ‘, perimetro)
SENÃO FAZ: ESCREVER(‘Opção não válida!’)
FIM CASO
FIM
4. Calcule a soma dos primeiros N números inteiros positivos.
Análise do problema:
Entradas: N
Saídas: soma
Descrição do problema: soma ← 1+2+3+...+N
Algoritmo:
Parte declarativa:
Variáveis:
soma, N, contador: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número de elementos a determinar a soma?’)
LER(N)
soma ← 0
DE contador ← 1 ATÉ N FAZ
Soma ← soma + contador
FIM DE
ESCREVER(‘O resultado da soma é ‘, soma)
FIM
2/9
Outra versão
Estratégia: calcular a soma de N termos de uma progressão aritmética: u1+ u2 + … + uN = (u1+uN)/2*N
Análise do problema:
Entradas: N
Saídas: soma
Descrição do problema: soma ← (u1+uN)/2*N
Algoritmo:
Parte declarativa:
Variáveis:
soma, N: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número de elementos a determinar a soma?’)
LER(N)
soma ← (u1+uN)/2*N
ESCREVER(‘O resultado da soma é ‘, soma)
FIM
5. Simular uma máquina de calcular que só efectua as operações básicas de adição, subtracção,
multiplicação e divisão, entre dois números. (Nota: atenção á divisão por zero).
Análise do problema:
Entradas: operador, operando1, operando2
Saídas: resultado
Descrição do problema: resultado ← operando1 (operador) operando2
Algoritmo:
Parte declarativa:
Variáveis:
operando1, operando2, resultado: tipo REAL
operador: tipo CARACTER
Parte operativa:
INICIO
ESCREVER(‘Qual o valor do Operando 1 e do Operando 2? ‘)
LER(operando1, operando2)
ESCREVER(‘Qual a operação a realizar (+, -, *, /)? ‘)
LER(operador)
CASO operador SEJA
‘+’ FAZ: resultado ← operando1 + operando2
ESCREVER(‘O resultado da Adição é ‘, resultado)
‘-’ FAZ: resultado ← operando1 - operando2
ESCREVER(‘O resultado da Subtracção é ‘, resultado)
‘*’ FAZ: resultado ← operando1 * operando2
ESCREVER(‘O resultado da Multiplicação é ‘, resultado)
‘/’ FAZ: SE operando2 = 0 ENTÃO
ESCREVER(‘Erro: divisão por zero!’)
SENÃO
resultado ← operando1 / operando2
ESCREVER(‘O resultado da Divisão é ‘, resultado)
FIM SE
SENÃO FAZ: ESCREVER(‘Operador não válido!’)
FIM CASO
FIM
3/9
6. Calcular o quadrado de todos os números compreendidos entre x1 e x2.
Análise do problema:
Entradas: x1, x2
Saídas: quadrado
Descrição do problema: quadrado ← x*x com x a variar entre x1 e x2
Algoritmo:
Parte declarativa:
Variáveis:
quadrado, x1, x2, x, temp: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o valor de x1 e x2?’)
LER(x1, x2)
SE x1 > x2 ENTÃO
temp ← x1
x1 ← x2
x2 ← temp
FIM SE
DE x ← x1 ATÉ x2 FAZ
quadrado ← x*x
ESCREVER(‘O quadrado de ‘, x, ‘ é ‘, quadrado)
FIM DE
FIM
7. Para uma sequência de N elementos, determine a soma dos elementos ímpares.
Análise do problema:
Entradas: N
Saídas: soma
Descrição do problema: soma ← 1+3+5+7+9+...+N se N for ímpar
Algoritmo:
Parte declarativa:
Variáveis: N, soma, contador: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número de elementos a determinar a soma?’)
LER(N)
soma ← 0
DE contador ← 1 ATÉ N FAZ
soma ← soma + contador
contador ← contador + 1
FIM DE
ESCREVER(‘O resultado da soma é ‘, soma)
FIM
ou
INICIO
...
soma ← 0
contador ← 1
ENQUANTO contador <= N FAZ
soma ← soma + contador
contador ← contador + 2
FIM ENQUANTO
...
FIM
4/9
Outra versão
Estratégia: calcular a soma dos termos de ordem ímpar numa progressão aritmética: u1+ u3 + … + um = (u1+um)/2*x
Cálculo do número de termos (x) e do índice (m) do último termo, dados os N elementos da sucessão:
x← (N+1) DIVISÃO INTEIRA 2
SE N ímpar ENTÃO m←N SENÃO m←N-1
Caso de soma dos pares
u2+ u4 + … + u2k = (u1+u2k)/2*k
Cálculo de k, dados os N elementos da sucessão: k← N DIVISÃO INTEIRA 2
8. Escrever a tabuada (multiplicação) de um número entre 1 e 10.
Análise do problema:
Entradas: numero
Saídas: resultado
Descrição do problema: resultado ← numero * i com i de 1 a 10
Algoritmo:
Parte declarativa:
Variáveis: resultado, numero, i: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número (1 a 10) da Tabuada?’)
LER(numero)
SE numero >= 1 E numero <= 10 ENTÃO
ESCREVER(‘Tabuada do ‘, numero)
DE i ← 1 ATÉ 10 FAZ
resultado ← numero * i
ESCREVER(numero, ‘ x ‘, i, ‘ = ‘, resultado)
FIM DE
SENÃO
ESCREVER(‘Número inválido!’)
FIM SE
FIM
9. Calcular a soma de uma sequência de números inteiros terminada por 0.
Análise do problema:
Entradas: numero
Saídas: soma
Descrição do problema: soma ← numero (1) + numero (2) + ... até numero ser 0
Algoritmo:
Parte declarativa:
Variáveis: numero, soma: tipo INTEIRO
Parte operativa:
INICIO
Soma ← 0
REPETIR
ESCREVER(‘Qual o número? ‘)
LER(numero)
SE numero <> 0 ENTÃO
soma ← soma + numero
FIM SE
ATÉ numero = 0
ESCREVER(‘O resultado da soma é ‘, soma)
FIM
5/9
10. Calcular os divisores de um número N.
Análise do problema:
Entradas: N
Saídas: divisor
Descrição do problema: é divisor se N for divisível por divisor
Algoritmo:
Parte declarativa:
Variáveis: N, divisor: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número N? ‘)
LER(N)
DE divisor ← 1 ATÉ N FAZ
SE N (Resto_Divisão_Inteira) divisor = 0 ENTÃO
ESCREVER(divisor, ‘ é divisor de ‘, N)
FIM SE
FIM DE
FIM
Melhor: efectuar apenas metade das divisões (N não é divisível por nenhum inteiro superior a N/2):
11. Determinar se um número N é primo.
Análise do problema:
Entradas: N
Saídas: VERDADEIRO ou FALSO
Descrição do problema: Se N só for divisível pelo próprio e pela unidade então é número primo
Algoritmo:
Parte declarativa:
Variáveis: N, contador, resto: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número N? ‘)
LER(N)
contador ← N
REPETIR
contador ← contador - 1
resto ← N (Resto_Divisão_Inteira) contador
ATÉ resto = 0
SE contador = 1 ENTÃO
ESCREVER(N, ‘ é número primo.’)
SENÃO
ESCREVER(N, ‘ não é número primo.’)
FIM SE
FIM
Melhor: efectuar apenas metade das verificações (N não é divisível por nenhum inteiro superior a N/2):
contador ← N DIVISÃO INTEIRA 2
REPETIR
resto ← N (Resto_Divisão_Inteira) contador
contador ← contador - 1
ATÉ resto = 0
6/9
12. Cálculo da média de uma sequência de valores.
Análise do problema:
Entradas: valor, N
Saídas: media
Descrição do problema: media ← (valor (1) + valor (2) + ... + valor (N))/ N
Algoritmo:
Parte declarativa:
Variáveis: valor, media, soma: tipo REAL
N, contador: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número N? ‘)
LER(N)
soma ← 0
DE contador ← 1 ATÉ N FAZ
ESCREVER(‘Qual o ‘, contador, ‘º valor? ’)
Ler(valor)
soma ← soma + valor
FIM DE
SE N <> 0 ENTÃO
media ← soma/N
ESCREVER(‘Média = ‘, media)
SENÃO
ESCREVER(‘Média = 0’)
FIM SE
FIM
13. Determinar o número de ocorrências de um dado número inteiro numa sequência de números
terminada por 0.
Análise do problema:
Entradas: numero, valor
Saídas: contador
Descrição do problema: se valor = numero então incrementa o contador, até valor ser 0
Algoritmo:
Parte declarativa:
Variáveis: numero, valor, contador: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o número a comparar? ‘)
LER(numero)
contador ← 0
REPETIR
ESCREVER(‘Qual o valor? ‘)
LER(valor)
SE valor = numero ENTÃO
contador ← contador + 1
FIM SE
ATÉ valor = 0
ESCREVER(‘O número ‘, numero, ‘ está repetido ‘, contador, ‘ vezes’)
FIM
7/9
14. Jogo do palpite: encontrar um número entre 0 e 100 introduzido por outro utilizador.
Análise do problema:
Entradas: numero, palpite
Saídas: tentativa
Descrição do problema: repetir o palpite ate numero ser igual ao palpite
Algoritmo:
Parte declarativa:
Variáveis: numero, palpite, tentativa: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Jogador 1: Qual o número a encontrar? ‘)
LER(número)
tentativa ← 0
REPETIR
ESCREVER(‘Jogador 2: Qual o seu palpite? ‘)
LER(palpite)
SE palpite > numero ENTÃO
ESCREVER(‘O seu palpite é maior que o número a encontrar.’)
SENÃO
SE palpite < numero ENTÃO
ESCREVER(‘O seu palpite é menor que o número a encontrar.’)
SENÃO
ESCREVER(‘Parabéns, acertou!’)
FIM SE
FIM SE
tentativa ← tentativa +1
ATÉ numero = palpite
ESCREVER(‘Necessitou de ‘, tentativa, ‘ tentativas.’)
FIM
15. Calcular o número de dias que falta para o fim do mês, sendo pedidos o dia, o mês e o ano.
Análise do problema:
Entradas: dia, mês, ano
Saídas: dias
Descrição do problema: Janeiro, Março, Maio, Julho, Agosto, Outubro, Dezembro: dias ← 31 – dia
Abril, Junho, Setembro, Novembro: dias ← 30 – dia
Fevereiro → ano bissexto ⇒ dias ← 29 – dia; ano não bissexto ⇒ dias ← 28 – dia
Algoritmo:
Parte declarativa:
Variáveis: dia, mês, ano, dias, dias_mes: tipo INTEIRO
Parte operativa:
INICIO
ESCREVER(‘Qual o dia, mês e ano? ‘)
LER(dia, mês, ano)
CASO mês SEJA
1, 3, 5, 7, 8, 10, 12 FAZ: dias_mês ← 31
4, 6, 9, 11 FAZ: dias_mês ← 30
2 FAZ: SE ano (Resto_Divisão_Inteira) 4 = 0 ENTÃO
dias_mês ← 29
SENÃO
dias_mês ← 28
FIM SE
SENÃO FAZ: dias_mês ← 0
FIM CASO
SE dias_mês = 0 OU dia > dias_mês OU dia <= 0 ENTÃO
ESCREVER(‘Data errada!’)
SENÃO
dias ← dias_mês – dia
ESCREVER(‘O número de dias até final do mês é ‘, dias)
FIM SE
FIM
8/9
16. Calcular o produto de sucessivos grupos de dois números inteiros, até que o utilizador introduza a
letra “N” quando o programa pergunta se quer continuar.
Análise do problema:
Entradas: numero1, numero2, opção
Saídas: produto
Descrição do problema: se opção diferente de N: produto ← numero1 * numero2
Algoritmo:
Parte declarativa:
Variáveis: numero1, numero2, produto: tipo INTEIRO
opção: tipo CARACTER
Parte operativa:
INICIO
REPETIR
ESCREVER(‘Quais os valores 1 e 2?’)
LER(numero1, numero2)
produto ← numero1 * numero2
ESCREVER(‘O produto de ‘, numero1, ‘ por ‘, numero2, ‘ é ‘, produto)
ESCREVER(‘Deseja continuar (S/N)?’)
LER(opção)
ATÉ opção = ‘N’ OU opção = ‘n’
FIM
17. Dado um valor inicial entre 10 e 20 e um incremento entre 5 e 10 introduzidos pelo utilizador,
determine os números entre o valor inicial e 100 que se obtêm adicionando, sucessivamente a
partir do valor inicial, o incremento ao valor anterior.
Análise do problema:
Entradas: valor_inicial, incremento
Saídas: contador
Descrição do problema: mostrar os valores até 100, inicio entre 10 e 20 e incrementos entre 5 e 10
Algoritmo:
Parte declarativa:
Constantes: valor_final = 100
Variáveis: valor_inicial, incremento, contador
Parte operativa:
INICIO
REPETIR
ESCREVER(‘Qual o valor inicial (entre 10 e 20)?’)
LER(valor_inicial)
ATÉ valor_inicial >= 10 E valor_inicial <= 20
REPETIR
ESCREVER(‘Qual o incremento (entre 5 e 10)?’)
LER(incremento)
ATÉ incremento >= 5 E incremento <= 10
contador ← valor_inicial
ENQUANTO contador <= valor_final FAZ
ESCREVER(‘O valor é ‘, contador)
contador ← contador + incremento
FIM ENQUANTO
FIM
9/9