Objetivos:
|
Permitir ao leitor desenvolver praticar os conceitos discutidos nas aulas ao longo deste capítulo, em especial, as estruturas de repetição com teste no início, com teste no final e com variável de controle.
|
Recursos e materiais:
|
|
Última atualização:
|
06/07/2020
|
Aulas do capítulo:
|
Algoritmos: 1. O que são algoritmos e porque eles são tão importantes 2. Três formas de representação de um algoritmo 3. Tipos de dados, variáveis e identificadores 4. Operadores aritméticos, relacionais e lógicos 5. Exercícios de lógica de programação para iniciantes 6. Atribuição, entrada e saída de dados em algoritmos 7. Aprendendo como fazer um algoritmo com exercícios 8. As estruturas de decisão: se-então-senão e escolha-caso 9. Exercícios sobre estruturas de decisão em algoritmos 10. Estruturas de repetição com teste no início 11. Estruturas de repetição com teste no final e com variável de controle 12. Exercícios sobre estruturas de repetição |
Elaboramos alguns exercícios sobre estruturas de repetição para que você leitor possa praticar os conceitos abordados nas duas últimas aulas. Algumas dúvidas surgem apenas quando colocamos a mão a massa e tentamos escrever os algoritmos. Por isso, antes de ler as respostas sugeridas, tente fazê-los você mesmo! Em caso de qualquer dúvida, estamos à disposição para ajudá-lo.
1 – Utilizando a estrutura de repetição com teste no início (“enquanto-faça”), elabore um algoritmo para tabelar a função y = x2, com x variando de 0 a 10. O valor do incremento de x (x) deverá ser informado pelo usuário.
1 |
inicio;
|
2 |
real: incremento, x;
|
3 |
x
|
4 |
escreva (“Informe o valor do incremento: “);
|
5 |
leia (incremento);
|
6 |
escreva (“(x, y)”);
|
7 |
enquanto (x <= 10) faça
|
8 |
escreva (“(“, x, pot(x,2), “)”);
|
9 |
x
|
10 |
fimenquanto;
|
11 |
fim.
|
2 – Repita o problema anterior utilizando:
a) estrutura de repetição com teste no final (“repita-enquanto”)
b) estrutura de repetição com variável de controle (“para-faça”)
1 |
inicio;
|
2 |
real: incremento, x;
|
3 |
x
|
4 |
escreva (“Informe o valor do incremento: “);
|
5 |
leia (incremento);
|
6 |
escreva (“(x, y)”);
|
7 |
repita
|
8 |
escreva (“(“, x, pot(x,2), “)”);
|
9 |
x
|
10 |
enquanto (x <= 10);
|
11 |
fim.
|
1 |
inicio;
|
2 |
real: incremento, x;
|
3 |
escreva (“Informe o valor do incremento: “);
|
4 |
leia (incremento);
|
5 |
escreva (“(x, y)”);
|
6 |
para x de 0 até 10 passo incremento faça
|
7 |
escreva (“(“, x, pot(x,2), “)”);
|
8 |
fimpara;
|
9 |
fim.
|
3 – Elabore um pseudocódigo para tabelar a função y = x2 – 4x, com x variando de “a” até “b“. O valor do incremento de x (x) e o intervalo [a,b] deverão ser informados pelo usuário.
1 |
inicio;
|
2 |
real: incremento, a, b, x;
|
3 |
escreva (“Informe os valores de a, b e do incremento: “);
|
4 |
leia (a, b, incremento);
|
5 |
escreva (“(x, y)”);
|
6 |
para x de a até b passo incremento faça
|
7 |
escreva (“(“, x, pot(x,2) – 4*x, “)”);
|
8 |
fimpara;
|
9 |
fim.
|
4 – Apresente um algoritmo para calcular e escrever a soma dos números ímpares compreendidos entre 100 e 200.
Respostas1 |
inicio;
|
2 |
inteiro: num, soma;
|
3 |
soma
|
4 |
para num de 1 até 199 passo 2 faça
|
5 |
soma
|
6 |
fimpara;
|
7 |
escreva (“O valor total da soma de números ímpares é: “, soma);
|
8 |
fim.
|
5 – Desenvolva um pseudocódigo que calcule o valor médio de um conjunto de n números reais. O algoritmo deverá calcular a soma dos números informados e, quando o número fornecido pelo usuário for zero, apresentar o valor da média.
Respostas1 |
inicio;
|
2 |
real: num, soma, media;
|
3 |
inteiro: n;
|
4 |
soma
|
5 |
n
|
6 |
repita
|
7 |
escreva (“Informe o número real a ser somado: “);
|
8 |
leia (num);
|
9 |
soma
|
10 |
n
|
11 |
enquanto (num <> 0);
|
12 |
media
|
13 |
escreva (“O valor da média é: “, media);
|
14 |
fim.
|
6 – Elabore um algoritmo que, dado um conjunto de números inteiros e positivos, determine e imprima o maior e o menor valor do conjunto. O último valor, que não deverá ser considerado, será -1. Assuma que o maior e o menor valor que podem, eventualmente, ser informados pelo usuário, são 100 e 0, respectivamente.
Respostas1 |
inicio;
|
2 |
inteiro: num, max, min;
|
3 |
min
|
4 |
max
|
5 |
escreva (“Informe um número: “);
|
6 |
leia (num);
|
7 |
enquanto (num <> -1)
|
8 |
se (num < min) entao
|
9 |
min
|
10 |
fimse;
|
11 |
se (num > max) entao
|
12 |
max
|
13 |
fimse;
|
14 |
escreva (“Informe um número: “);
|
15 |
leia (num);
|
16 |
fimenquanto;
|
17 |
escreva (“O menor número informado é: “, min);
|
18 |
escreva (“O maior número informado é: “, max);
|
19 |
fim.
|
/
|
|
O que aconteceria se o usuário inserir um valor que não esteja contido entre 0 e 100? Como isso poderia ser resolvido?
|
7 – Crie um pseudocódigo para calcular o volume (V) da esfera em função do raio (R), que deverá variar de 0 a 20cm, de 0.5 em 0.5cm. O volume da esfera pode ser calculado pela equação abaixo.
1 |
inicio;
|
2 |
real: raio, volume;
|
3 |
escreva (“Raio (cm), Volume (cm^3)”);
|
4 |
para raio de 0 até 20 passo 0.5 faça
|
5 |
volume
|
6 |
escreva (raio, “, “, volume);
|
7 |
fimpara;
|
8 |
fim.
|
8 – Elabore um algoritmo que leia um conjunto de 20 números inteiros compreendidos entre 150 e 550, e determine e imprima o maior e o menor número fornecido.
Respostas1 |
inicio;
|
2 |
inteiro: i, num, min, max;
|
3 |
min
|
4 |
max
|
5 |
i
|
6 |
enquanto (i <= 20)
|
7 |
escreva (“Informe um número: “);
|
8 |
leia (num);
|
9 |
se (num < 150 ou num > 550) entao
|
10 |
escreva (O número inserido deve ser entre 150 e 550!”);
|
11 |
senao
|
12 |
i
|
13 |
se (num < min) entao
|
14 |
min
|
15 |
fimse;
|
16 |
se (num > max) entao
|
17 |
max
|
18 |
fimse;
|
19 |
fimse;
|
20 |
fimenquanto;
|
21 |
escreva (“O menor número informado é: “, min);
|
22 |
escreva (“O maior número informado é: “, max);
|
23 |
fim.
|
9 – Apresente um pseudocódigo para ler um conjunto de números inteiros positivos e informar, um a um, se o número é par ou ímpar. Quando o usuário fornecer 0 ou qualquer número negativo como valor de entrada, o algoritmo deverá ser finalizado.
Respostas1 |
inicio;
|
2 |
inteiro: num;
|
3 |
escreva (“Digite um número inteiro: “);
|
4 |
leia (num);
|
5 |
enquanto (num > 0) faça
|
6 |
se (num mod 2 = 1) entao
|
7 |
escreva (“O número digitado é ímpar!”);
|
8 |
senao
|
9 |
escreva (“O número digitado é par!”);
|
10 |
fimse;
|
11 |
escreva (“Digite um número inteiro: “);
|
12 |
leia (num);
|
13 |
fimenquanto;
|
14 |
fim.
|
10 – Desenvolva um algoritmo que leia um conjunto de dados contendo a altura e o sexo (M ou F) de 50 pessoas e que determine a maior e a menor altura do grupo, a média das alturas das mulheres e o número de homens com altura inferior a 1.73m. Imprima os resultados ao final do algoritmo.
Respostas1 |
inicio;
|
2 |
inteiro: cont1, cont2, cont3;
|
3 |
real: altura, max, min, total_alt_m;
|
4 |
char: sexo;
|
5 |
escreva (“Digite a altura e o sexo: “);
|
6 |
leia (altura, sexo);
|
7 |
max
|
8 |
min
|
9 |
cont2
|
10 |
cont3
|
11 |
total_alt_m
|
12 |
para cont1 de 2 até 50 passo 1 faça
|
13 |
se (altura < min) entao
|
14 |
min
|
15 |
senao
|
16 |
se (altura > max) entao
|
17 |
max
|
18 |
fimse;
|
19 |
fimse;
|
20 |
se (sexo = “F”) entao
|
21 |
cont2
|
22 |
total_alt_m
|
23 |
senao
|
24 |
se (sexo = “M” e altura < 1.73) entao
|
25 |
cont3
|
26 |
fimse;
|
27 |
fimse;
|
28 |
se (cont1 <= 49) entao
|
29 |
escreva (“Digite a altura e o sexo: “);
|
30 |
leia (altura, sexo);
|
31 |
fimse;
|
32 |
fimpara;
|
33 |
escreva (“A maior altura é “, max, ” cm!”);
|
34 |
escreva (“A menor altura é “, min, ” cm!”);
|
35 |
escreva (“A média da altura das mulheres é: , total_alt_m/cont2, ” cm!”);
|
36 |
escreva (“O número de homens com menos de 1.73cm é: “, cont3);
|
37 |
fim.
|
Porque foi adicionada uma estrutura de decisão entre as linhas 28 e 31, com condição para cont1 ser menor ou igual a 49?
|
11 – Crie um pseudocódigo para calcular o valor de S de acordo com as equações abaixo.
1 |
inicio;
|
2 |
inteiro: den;
|
3 |
real: S;
|
4 |
den
|
5 |
S
|
6 |
enquanto (den <= 50) faça
|
7 |
S
|
8 |
den
|
9 |
fimenquanto;
|
10 |
escreva (“O valor final de S é: “, S);
|
11 |
fim.
|
1 |
inicio;
|
2 |
inteiro: num;
|
3 |
real: S;
|
4 |
num
|
5 |
S
|
6 |
enquanto (num <= 10) faça
|
7 |
S
|
8 |
num
|
9 |
fimenquanto;
|
10 |
escreva (“O valor final de S é: “, S);
|
11 |
fim.
|
Se você leitor acompanhou todas as aulas deste capítulo e não teve dificuldades para fazer os exercícios sobre estruturas de repetição que apresentamos acima, deve estar agora familiarizado com a lógica de programação e pronto para começar a programar de fato. Embora cada linguagem de programação tenha suas peculiaridades, as estruturas de abordamos aqui estão presentes em todas elas e serão suficientes para resolver a maioria dos problemas que você deve encontrar na engenharia. Caso qualquer dúvida tenha surgido ao longo do capítulo, deixe abaixo nos comentários para que possamos ajudá-lo.
Temos certeza que você quer aprender muito mais sobre programação e se tornar um expert em diferentes linguagens. Por isso, acesse agora esse link e faça parte gratuitamente do nosso time. Além de ser notificado sobre todas as novidades que lançarmos, terá acesso a uma comunidade que compartilha das mesmas paixões e a oportunidade de ajudar outras pessoas ao mesmo tempo em que pratica tudo o que está aprendendo. Quem deixaria uma oportunidade dessas passar?