Mudanças entre as edições de "Lógica de Programação 1 - Estruturas de Repetição"
(126 revisões intermediárias por 4 usuários não estão sendo mostradas) | |||
Linha 2: | Linha 2: | ||
O aluno deverá ser capaz de: | O aluno deverá ser capaz de: | ||
− | *construir fluxogramas usando estruturas de repetição; | + | *construir fluxogramas e pseudocódigo usando estruturas de repetição; |
*compreender o aninhamento de estruturas de controle de fluxo | *compreender o aninhamento de estruturas de controle de fluxo | ||
<!-- *dividir problemas em subproblemas e utilizar subrotinas para organizar a solução. --> | <!-- *dividir problemas em subproblemas e utilizar subrotinas para organizar a solução. --> | ||
− | ===Estruturas de repetição=== | + | ===Estruturas de repetição com decisão no início=== |
No exemplo de controle de acesso da aula passada já construímos uma estrutura de repetição (um ''loop'' infinito). Vamos elaborar um pouco mais estas estruturas de repetição. | No exemplo de controle de acesso da aula passada já construímos uma estrutura de repetição (um ''loop'' infinito). Vamos elaborar um pouco mais estas estruturas de repetição. | ||
Linha 17: | Linha 17: | ||
====Exemplo de Problema com Repetição==== | ====Exemplo de Problema com Repetição==== | ||
− | '''PROBLEMA''': Calcular | + | '''PROBLEMA''': Calcular o somatório de N valores a serem fornecidos pelo teclado. |
:<math> S = \sum_{i=0}^{N-1} a_i = a_0 + a_1 + .. + a_{N-1}</math> | :<math> S = \sum_{i=0}^{N-1} a_i = a_0 + a_1 + .. + a_{N-1}</math> | ||
'''DADOS DE ENTRADA''': | '''DADOS DE ENTRADA''': | ||
− | * N /* número de valores */, | + | * a ser armazenado em N /* número de valores */, |
− | * | + | * a ser armazenado em parcela /* valor de um dos N números a serem inseridos - é o termo a_i da fórmula*/ |
'''DADOS DE SAÌDA''': | '''DADOS DE SAÌDA''': | ||
*S /* somatório */ | *S /* somatório */ | ||
+ | <blockquote style="background: pink; border: 1px solid black; padding: 1em;"> | ||
+ | ATENÇÃO 1: parcela é o nome de uma variável. | ||
− | [[imagem: | + | ATENÇÃO 2: em alguns momentos são OMITIDAS as mensagens para AJUDAR a pessoa (ou sistema) que está entrando com dados. |
+ | </blockquote> | ||
+ | |||
+ | |||
+ | [[imagem:FluxogramaSomatoriaV1.jpg|border|450px]] | ||
<blockquote style="background: pink; border: 1px solid black; padding: 1em;"> | <blockquote style="background: pink; border: 1px solid black; padding: 1em;"> | ||
Linha 36: | Linha 42: | ||
<blockquote style="background: pink; border: 1px solid black; padding: 1em;"> | <blockquote style="background: pink; border: 1px solid black; padding: 1em;"> | ||
− | NOTAR que usamos a variável ''' | + | NOTAR que usamos a variável '''parcela''' para ler cada valor a ser usado na soma acumulada. A medida que a leitura é realizada, a soma já é computada e ARMAZENADA em '''S'''. |
Desta forma podemos REAPROVEITAR a mesma | Desta forma podemos REAPROVEITAR a mesma | ||
variável para cada elemento lido. | variável para cada elemento lido. | ||
Linha 47: | Linha 53: | ||
ou | ou | ||
− | < | + | <syntaxhighlight lang="C"> |
− | ALGORITMO | + | ALGORITMO soma_n_numeros() |
+ | VARIAVEIS | ||
N: inteiro | N: inteiro | ||
− | + | parcela: inteiro | |
− | + | i: inteiro | |
− | + | S: inteiro | |
INICIO | INICIO | ||
LER N | LER N | ||
i = 0 | i = 0 | ||
− | + | S = 0 | |
− | ENQUANTO | + | ENQUANTO i<N FAÇA |
− | LER | + | LER parcela |
− | + | S <- S + parcela | |
− | + | i <- i+1 | |
FIM_ENQUANTO | FIM_ENQUANTO | ||
− | IMPRIMIR "SOMATORIA = ", | + | IMPRIMIR "SOMATORIA = ", S |
FIM | FIM | ||
</syntaxhighlight> | </syntaxhighlight> | ||
Linha 68: | Linha 75: | ||
====EXERCÍCIO==== | ====EXERCÍCIO==== | ||
− | Considere o exercício do somatório acima. Fazer um teste de mesa (realização) para N=3 e os valores | + | Considere o exercício do somatório acima usando FLUXOGRAMA. Fazer um teste de mesa (realização) para N=3 e os valores 5, 3 e 7. Na tabela do teste de mesa considere sempre os valores das variáveis (ou expressões) APÓS a execução da instrução. Segue tabela de apoio: |
{| class="wikitable" | {| class="wikitable" | ||
Linha 76: | Linha 83: | ||
! style="text-align: center; background-color:#ffffc7; color:#333333;" | i | ! style="text-align: center; background-color:#ffffc7; color:#333333;" | i | ||
! style="text-align: center; background-color:#ffffc7; color:#333333;" | S | ! style="text-align: center; background-color:#ffffc7; color:#333333;" | S | ||
− | ! style="text-align: center; background-color:#ffffc7;" | | + | ! style="text-align: center; background-color:#ffffc7;" | parcela |
! style="text-align: center; background-color:#ffffc7;" | i<N | ! style="text-align: center; background-color:#ffffc7;" | i<N | ||
|- | |- | ||
Linha 165: | Linha 172: | ||
*identifique claramente O QUE será entrada de dados e O QUE será saída | *identifique claramente O QUE será entrada de dados e O QUE será saída | ||
*antes de começar, "projete" quais variáveis serão necessárias | *antes de começar, "projete" quais variáveis serão necessárias | ||
+ | |||
+ | ==Comando DO-ENQUANTO: repetição com decisão no final do loop== | ||
+ | |||
+ | Em várias situações pode ser mais conveniente construir um "loop" com teste no final. Por exemplo, uma possível validação de dados de entrada: | ||
+ | |||
+ | <span style="font-size:70%"> | ||
+ | {| class="wikitable" | ||
+ | ! comando DO-ENQUANTO!! comando ENQUANTO | ||
+ | |- | ||
+ | |<syntaxhighlight lang="C"> | ||
+ | ALGORITMO rejeita_entrada() | ||
+ | VARIAVEIS | ||
+ | X: inteiro; | ||
+ | INICIO | ||
+ | mostrar "Entre com o valor de X. Deve ser maior que zero!" | ||
+ | FAÇA | ||
+ | mostrar "Entre com o valor de X. Deve ser maior que zero!" | ||
+ | LER X | ||
+ | ENQUANTO x <= 0; | ||
+ | mostrar X; | ||
+ | FIM </syntaxhighlight> || <syntaxhighlight lang="C"> | ||
+ | ALGORITMO rejeita_entrada() | ||
+ | VARIAVEIS | ||
+ | X: inteiro; | ||
+ | INICIO | ||
+ | mostrar "Entre com o valor de X. Deve ser maior que zero!" | ||
+ | LER X; | ||
+ | ENQUANTO X <= 0 FAÇA | ||
+ | mostrar "Entre com o valor de X. Deve ser maior que zero!" | ||
+ | LER X | ||
+ | FIM_ENQUANTO; | ||
+ | mostrar X; | ||
+ | FIM </syntaxhighlight> | ||
+ | |- | ||
+ | |[[imagem:FluxogramaComandoDo-Para.png|border|250px]] || | ||
+ | |- | ||
+ | |} | ||
+ | |||
+ | </span> | ||
+ | |||
+ | ==Comando PARA: organizando a repetição de forma estruturada== | ||
+ | |||
+ | Uma forma de organizar a execução de um "loop" de maneira clara é usando um comando | ||
+ | que mostra claramente as condições iniciais de execução do loop, a condição de execução (ou parada) e a expressão de modificação da condição de parada. Trata-se do comando PARA-FIM_PARA. Este comando permite colocar claramente a situação de repetição. Vamos ver como ficaria o algoritmo de soma acumulada com este comando: | ||
+ | |||
+ | {| class="wikitable" | ||
+ | ! Pseudocódigo com comando PARA!! Pseudocódigo com ENQUANTO | ||
+ | |- | ||
+ | |<syntaxhighlight lang="C"> | ||
+ | ALGORITMO soma_n_numeros() | ||
+ | VARIAVEIS | ||
+ | N: inteiro; | ||
+ | parcela: inteiro; | ||
+ | i: inteiro; | ||
+ | S: inteiro; | ||
+ | INICIO | ||
+ | LER N; | ||
+ | S ← 0; | ||
+ | PARA i DE 0 ATÉ N-1 PASSO 1 FAÇA | ||
+ | LER parcela; | ||
+ | S ← S + parcela; | ||
+ | FIM_PARA | ||
+ | IMPRIMIR "SOMATORIA = ", S; | ||
+ | FIM | ||
+ | </syntaxhighlight> || <syntaxhighlight lang="C"> | ||
+ | ALGORITMO soma_n_numeros() | ||
+ | VARIAVEIS | ||
+ | N: inteiro; | ||
+ | parcela: inteiro; | ||
+ | i: inteiro; | ||
+ | S: inteiro; | ||
+ | INICIO | ||
+ | LER N; | ||
+ | i ← 0; | ||
+ | S ← 0; | ||
+ | ENQUANTO i<N FAÇA | ||
+ | LER parcela; | ||
+ | S ← S + parcela; | ||
+ | i ← i+1; | ||
+ | FIM_ENQUANTO | ||
+ | IMPRIMIR "SOMATORIA = ", S; | ||
+ | FIM </syntaxhighlight> | ||
+ | |- | ||
+ | |} | ||
+ | |||
+ | Observe que na versão do comando PARA, a variável i assume valores de 0 a N-1, sendo a cada laço incrementada conforme o PASSO, neste caso 1. È desnecessário inicializar o i antes do comando (ver a versão com o comando ENQUANTO). | ||
+ | |||
+ | Um fluxograma para a versão com comando PARA seria: | ||
+ | |||
+ | [[imagem:FluxogramaComandoPara.png|border|250px]] | ||
+ | |||
+ | Observe a caixa utilizada para a repetição estruturada. Não existe rótulos de verdadeiro ou falso pois o número de repetições já está explicitado. | ||
==Exemplos Adicionais== | ==Exemplos Adicionais== | ||
Linha 172: | Linha 271: | ||
'''PROBLEMA''': Elaborar um fluxograma para imprimir os números pares em ordem decrescente (até atingir 0 inclusive) a partir de um número N fornecido como entrada. | '''PROBLEMA''': Elaborar um fluxograma para imprimir os números pares em ordem decrescente (até atingir 0 inclusive) a partir de um número N fornecido como entrada. | ||
− | '''DADOS DE ENTRADA''': N (variável inteira) | + | '''DADOS DE ENTRADA''': N (a ser colocado em uma variável inteira) |
− | '''DADOS DE | + | '''DADOS DE SAÍDA''': números pares impressos |
− | [[imagem: | + | OBS: Existe uma solução mais eficiente que a mostrada abaixo. Testar se é par ou ímpar antes do loop... |
+ | |||
+ | [[imagem:FluxogramaRepeticaoImprimeParV2.jpg|border|450px]] | ||
====Exercício==== | ====Exercício==== | ||
Linha 184: | Linha 285: | ||
====Exercício==== | ====Exercício==== | ||
− | Modificar o exercício anterior para que | + | Modificar o exercício anterior para que ALÉM de imprimir os números pares, também seja impresso no FINAL do algoritmo a SOMA de todos os números ímpares abaixo ou iguais a N. |
+ | Faça na forma de FLUXOGRAMA e em PSEUDOCÓDIGO. | ||
+ | |||
+ | {{collapse top | solução}} | ||
+ | <!--[[Arquivo:paresomaimpar.jpg]]--> | ||
+ | {{collapse bottom}} | ||
===Exemplo 2=== | ===Exemplo 2=== | ||
− | '''PROBLEMA''': Elaborar um | + | '''PROBLEMA''': Elaborar um fluxograma para computação do fatorial de um número conforme definição abaixo: |
− | '''DADOS DE ENTRADA''':número N (numero inteiro) | + | '''DADOS DE ENTRADA''':número cujo fatorial deve ser computado, a ser armazenado em N (numero inteiro) |
'''DADOS DE SAÌDA''': FATORIAL computado | '''DADOS DE SAÌDA''': FATORIAL computado | ||
Linha 196: | Linha 302: | ||
O fatorial é definido por: | O fatorial é definido por: | ||
− | :<math>n!=\prod_{ | + | :<math>n!=\prod_{i=1}^n i\qquad\forall n\in\mathbb{N}</math> |
+ | |||
+ | OBS: Existem OUTRAS soluções possíveis!!! | ||
[[imagem:FluxogramaFatorialNum.jpg|border|390px]] | [[imagem:FluxogramaFatorialNum.jpg|border|390px]] | ||
Linha 202: | Linha 310: | ||
====Exercício 1==== | ====Exercício 1==== | ||
− | Faça uma versão do Fluxograma do Fatorial em que a variável i começa com o valor 1. Teste também se o número N fornecido é maior ou igual a ZERO. Caso não seja (caso seja negativo) o algoritmo deve emitir uma mensagem e | + | Faça uma versão do algoritmo acima na forma de pseudocódigo. |
+ | |||
+ | ====Exercício 2==== | ||
+ | |||
+ | Faça uma versão do Fluxograma do Fatorial em que a variável i começa com o valor 1. Teste também se o número N fornecido é maior ou igual a ZERO. Caso não seja (caso seja negativo) o algoritmo deve emitir uma mensagem e voltar a perguntar por N. FAÇA um teste de mesa considerando N=4. | ||
+ | |||
+ | {{collapse top | Solução Exercício 1}} | ||
+ | [[imagem:FatN1v2.jpg|border|400px]] | ||
+ | {{collapse bottom}} | ||
====Exercício 2==== | ====Exercício 2==== | ||
Linha 208: | Linha 324: | ||
Observe os exemplos acima e elabore um algoritmo que computa todos os fatoriais de números entre 1 e N, onde N é um número fornecido. | Observe os exemplos acima e elabore um algoritmo que computa todos os fatoriais de números entre 1 e N, onde N é um número fornecido. | ||
− | DADOS DE ENTRADA: N (inteiro) | + | '''DADOS DE ENTRADA''': N (inteiro) |
− | DADOS DE SAÌDA: fatoriais entre 1 e N | + | '''DADOS DE SAÌDA''': fatoriais entre 1 e N |
+ | |||
+ | {{collapse top | Solução Exercício 2}} | ||
+ | [[imagem:FluxogramaFatorialdeNumeros.jpg|border|390px]] | ||
+ | {{collapse bottom}} | ||
===Exemplo 3=== | ===Exemplo 3=== | ||
− | PROBLEMA: Aprimorar o exemplo do controle de acesso para que, no caso de 3 tentativas de acesso seguidas, com senha errada, o sistema seja bloqueado. | + | PROBLEMA: Aprimorar o exemplo do controle de acesso para que, no caso de 3 tentativas de acesso seguidas, com senha errada, o sistema seja bloqueado. O administrador desbloqueia redefinindo a senha. |
− | *DADOS DE ENTRADA: SENHA /* variável que armazena a senha entrada pelo usuário ou administrador */ | + | *'''DADOS DE ENTRADA''': senha inserida pelo usuário na variável SENHA /* variável que armazena a senha entrada pelo usuário ou administrador */ |
− | *DADOS DE SAÍDA: mensagem de abertura da porta / usuário bloqueado*/ | + | *'''DADOS DE SAÍDA''': mensagem de abertura da porta / usuário bloqueado*/ |
− | *VARIÁVEIS INTERMEDIÁRIAS: CONT_ACESSO /* valor inicial zero - incrementada a cada senha inválida */ | + | *'''VARIÁVEIS INTERMEDIÁRIAS''': CONT_ACESSO /* valor inicial zero - incrementada a cada senha inválida */ |
[[imagem:FluxogramaControleAcessoComContador.jpg|border|850px]] | [[imagem:FluxogramaControleAcessoComContador.jpg|border|850px]] | ||
+ | <blockquote style="background: pink; border: 1px solid black; padding: 1em;"> | ||
Note que a variável CONT_ACESSO é iniciada com zero e | Note que a variável CONT_ACESSO é iniciada com zero e | ||
incrementada a cada erro no fornecimento da senha. A | incrementada a cada erro no fornecimento da senha. A | ||
Linha 229: | Linha 350: | ||
(o conteúdo anterior é sobrescrito!) | (o conteúdo anterior é sobrescrito!) | ||
− | < | + | Esta solução não é perfeita e poderia ser aprimorada. Se o administrador erra, ele pode vir a bloquear o usuário. |
− | + | </blockquote> | |
− | + | ===EXERCÍCIOS=== | |
− | |||
− | |||
− | |||
− | + | ==Para Praticar== | |
+ | '''EXERCÍCIO 1:''' Fazer um algoritmo (em fluxograma) que receba a nota de 4 avaliações (usar uma única variável) e calcule a média. Usar um '''loop''' controlado pela quantidade 4 (de avaliações). Imprimir aprovado, caso a média seja superior ou igual a 6.0, reprovado caso contrário. | ||
− | + | {{collapse top | Solução Ex. 1}} | |
+ | [[imagem:media_aprova_reprova.jpg|border|650px]] | ||
+ | {{collapse bottom}} | ||
− | + | '''EXERCÍCIO 2:''' Faça um algoritmo que determine o maior entre N números. A condição de parada é a entrada de um valor 0, ou seja, o algoritmo deve ficar calculando o maior até que a entrada seja igual a 0 (ZERO). Supor que pelo menos um número é sempre fornecido. Supor que NUNCA será fornecido número negativo. | |
− | |||
− | |||
− | |||
+ | {{collapse top | Solução Ex. 2}} | ||
+ | [[imagem:maior_valor.jpg|border|650px]] | ||
+ | {{collapse bottom}} | ||
− | + | '''EXERCÍCIO 3:''' Faça um algoritmo que conte de 1 a 100 e a cada múltiplo de 10 emita uma mensagem: “Múltiplo de 10”. | |
− | + | {{collapse top | Solução Ex. 3}} | |
− | + | [[imagem:Aula03_ExercicioFluxogramaContagemDe0A100.jpg|350px]] | |
− | + | {{collapse bottom}} | |
− | |||
− | + | ==Desafios== | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | == | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
'''EXERCÍCIO 1:''' Modificar o sistema de controle de acesso para incluir dois usuários com user_id e senha. Prever a existência de dois usuários (armazenados nas variáveis USERID_1, USERID_2, SENHA_1, SENHA_2 com valores iniciais user "alfa", senha "alfa" e user "beta" com senha "beta"). O admin poderá ser identificado por "admin" e senha fixa "admin123". Prever bloqueio por usuário (duas variáveis contadores). | '''EXERCÍCIO 1:''' Modificar o sistema de controle de acesso para incluir dois usuários com user_id e senha. Prever a existência de dois usuários (armazenados nas variáveis USERID_1, USERID_2, SENHA_1, SENHA_2 com valores iniciais user "alfa", senha "alfa" e user "beta" com senha "beta"). O admin poderá ser identificado por "admin" e senha fixa "admin123". Prever bloqueio por usuário (duas variáveis contadores). | ||
Sugestão: criar funcões separadas para tratamento de cada usuário. Em breve veremos como podemos contornar esta duplicação através da parametrização de funções/subprogramas. | Sugestão: criar funcões separadas para tratamento de cada usuário. Em breve veremos como podemos contornar esta duplicação através da parametrização de funções/subprogramas. | ||
− | {{collapse top|Solução - | + | {{collapse top|Solução - Exercício 01}} |
− | + | [[imagem:Aula03_Exercicio01-BAK.jpg|2500px]] | |
− | [[imagem:Aula03_Exercicio01.jpg|2500px]] | ||
− | |||
{{collapse bottom}} | {{collapse bottom}} | ||
Linha 320: | Linha 393: | ||
:<math>a_n=a_1.q^{n-1}\,\!</math> | :<math>a_n=a_1.q^{n-1}\,\!</math> | ||
− | + | ||
− | + | {{collapse top|Solução - Exercício 02}} | |
− | + | <syntaxhighlight> | |
− | |||
− | |||
− | {{collapse top|Solução - | ||
− | < | ||
ALGORITMO | ALGORITMO | ||
S: real; | S: real; | ||
Linha 347: | Linha 416: | ||
'''EXERCÍCIO 3:''' Implementar um algoritmo que permita computar a somatória dos N primeiros termos de uma PG, cujos valores de "s" e "q" são também fornecidos como dados de entrada. | '''EXERCÍCIO 3:''' Implementar um algoritmo que permita computar a somatória dos N primeiros termos de uma PG, cujos valores de "s" e "q" são também fornecidos como dados de entrada. | ||
− | {{collapse top|Solução - | + | {{collapse top|Solução - Exercício 03}} |
− | + | [[imagem:Aula03_Exercicio03-BAK.jpg|800px]] | |
− | [[imagem:Aula03_Exercicio03.jpg|800px]] | ||
− | |||
{{collapse bottom}} | {{collapse bottom}} | ||
− | '''EXERCÍCIO 4:''' Implementar uma função (subprograma), usando fluxograma, para computar o valor da PG, dados como parâmetros ''s'' e ''q''. | + | '''EXERCÍCIO 4:''': Implementar um algoritmo através de um fluxograma que permita ler N números inteiros. O algoritmo deve computar o fatorial da SOMATÓRIA destes números. |
+ | Exemplo: O usuário fornece 5 números: 2,9,13,21 e 55. O algoritmo computará o fatorial de 2+9+13+21+55, ou seja, o fatorial de 100. | ||
+ | |||
+ | '''EXERCÍCIO 5:''' Implementar uma função (subprograma), usando fluxograma, para computar o valor da PG, dados como parâmetros ''s'' e ''q''. | ||
− | + | {{collapse top|Solução - Exercício 04}} | |
− | {{collapse top|Solução - | + | [[imagem:Aula03_Exercicio04-BAK.jpg|1200px]] |
− | [[imagem:Aula03_Exercicio04.jpg|1200px]] | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | + | ||
+ | '''EXERCÍCIO 6:''': Implementar um algoritmo na forma de fluxograma que permite implementar uma calculadora especial que tem 3 funções: | ||
+ | #Calcular o número de Fibonacci ''Fₙ'' para um número ''n'' ≥ 0 (ver https://en.wikipedia.org/wiki/Fibonacci_number) | ||
+ | #Calcular o Fatorial de um número N (ver https://pt.wikipedia.org/wiki/Fatorial) | ||
+ | #Calcular a combinação simples de N elementos organizados 'r' a 'r' (ver https://pt.wikipedia.org/wiki/Combinat%C3%B3ria#Combina%C3%A7%C3%A3o_simples) | ||
+ | #Uma opção da sua escolha que envolva repetição, tal como nos problemas acima. | ||
+ | Para cada um destes itens deixar claro o que é entrada e o que é saída de dados. |
Edição atual tal como às 09h13min de 17 de agosto de 2023
Objetivos
O aluno deverá ser capaz de:
- construir fluxogramas e pseudocódigo usando estruturas de repetição;
- compreender o aninhamento de estruturas de controle de fluxo
Estruturas de repetição com decisão no início
No exemplo de controle de acesso da aula passada já construímos uma estrutura de repetição (um loop infinito). Vamos elaborar um pouco mais estas estruturas de repetição.
Uma das grandes vantagens de um sistema computacional é a capacidade de repetir um conjunto de instruções possivelmente sobre dados diferentes, a uma velocidade muito grande.
Exemplo de Problema com Repetição
PROBLEMA: Calcular o somatório de N valores a serem fornecidos pelo teclado.
DADOS DE ENTRADA:
- a ser armazenado em N /* número de valores */,
- a ser armazenado em parcela /* valor de um dos N números a serem inseridos - é o termo a_i da fórmula*/
DADOS DE SAÌDA:
- S /* somatório */
ATENÇÃO 1: parcela é o nome de uma variável.
ATENÇÃO 2: em alguns momentos são OMITIDAS as mensagens para AJUDAR a pessoa (ou sistema) que está entrando com dados.
Observe que a estrutura de repetição utilizada é caracterizada por um teste (decisão) de uma expressão que deverá resultar em verdadeiro enquanto houver número a ser lido (dentro da quantidade N de números), um contador de itens lidos "i" e um bloco de repeticão terminado em um arco que conduz o fluxo de execução ao início da decisão.
NOTAR que usamos a variável parcela para ler cada valor a ser usado na soma acumulada. A medida que a leitura é realizada, a soma já é computada e ARMAZENADA em S. Desta forma podemos REAPROVEITAR a mesma variável para cada elemento lido. ENTRETANTO, em outros problemas isto poderia ser um problema. Os vetores auxiliarão neste processo...
ou
ALGORITMO soma_n_numeros()
VARIAVEIS
N: inteiro
parcela: inteiro
i: inteiro
S: inteiro
INICIO
LER N
i = 0
S = 0
ENQUANTO i<N FAÇA
LER parcela
S <- S + parcela
i <- i+1
FIM_ENQUANTO
IMPRIMIR "SOMATORIA = ", S
FIM
EXERCÍCIO
Considere o exercício do somatório acima usando FLUXOGRAMA. Fazer um teste de mesa (realização) para N=3 e os valores 5, 3 e 7. Na tabela do teste de mesa considere sempre os valores das variáveis (ou expressões) APÓS a execução da instrução. Segue tabela de apoio:
Instrução
executada |
N | i | S | parcela | i<N |
---|---|---|---|---|---|
1 | ? | ? | ? | ? | ? |
2 | ? | ? | ? | ? | ? |
3 | 3 | ? | ? | ? | ? |
4 | 3 | 0 | ? | ? | V |
5 | 3 | 0 | 0 | ? | V |
6 | 3 | 0 | 0 | ? | V |
7 | 3 | 0 | 0 | 5 | V |
8 | 3 | 0 | 5 | 5 | V |
9 | 3 | 1 | 5 | 5 | V |
6 | 3 | 1 | 5 | 5 | V |
: | : | : | : | : | : |
EXERCÍCIO
Construir um fluxograma para ler um número inteiro de referência para uma variável denominada REF. Na sequência devem ser lidos N números inteiros e o programa deve contar a quantidade de números maior que REF. Não usar vetores.
SUGESTÕES:
- tente usar o mesmo padrão de leitura do exercício anterior
- identifique claramente O QUE será entrada de dados e O QUE será saída
- antes de começar, "projete" quais variáveis serão necessárias
Comando DO-ENQUANTO: repetição com decisão no final do loop
Em várias situações pode ser mais conveniente construir um "loop" com teste no final. Por exemplo, uma possível validação de dados de entrada:
Comando PARA: organizando a repetição de forma estruturada
Uma forma de organizar a execução de um "loop" de maneira clara é usando um comando que mostra claramente as condições iniciais de execução do loop, a condição de execução (ou parada) e a expressão de modificação da condição de parada. Trata-se do comando PARA-FIM_PARA. Este comando permite colocar claramente a situação de repetição. Vamos ver como ficaria o algoritmo de soma acumulada com este comando:
Pseudocódigo com comando PARA | Pseudocódigo com ENQUANTO |
---|---|
ALGORITMO soma_n_numeros()
VARIAVEIS
N: inteiro;
parcela: inteiro;
i: inteiro;
S: inteiro;
INICIO
LER N;
S ← 0;
PARA i DE 0 ATÉ N-1 PASSO 1 FAÇA
LER parcela;
S ← S + parcela;
FIM_PARA
IMPRIMIR "SOMATORIA = ", S;
FIM
|
ALGORITMO soma_n_numeros()
VARIAVEIS
N: inteiro;
parcela: inteiro;
i: inteiro;
S: inteiro;
INICIO
LER N;
i ← 0;
S ← 0;
ENQUANTO i<N FAÇA
LER parcela;
S ← S + parcela;
i ← i+1;
FIM_ENQUANTO
IMPRIMIR "SOMATORIA = ", S;
FIM
|
Observe que na versão do comando PARA, a variável i assume valores de 0 a N-1, sendo a cada laço incrementada conforme o PASSO, neste caso 1. È desnecessário inicializar o i antes do comando (ver a versão com o comando ENQUANTO).
Um fluxograma para a versão com comando PARA seria:
Observe a caixa utilizada para a repetição estruturada. Não existe rótulos de verdadeiro ou falso pois o número de repetições já está explicitado.
Exemplos Adicionais
Exemplo 1
PROBLEMA: Elaborar um fluxograma para imprimir os números pares em ordem decrescente (até atingir 0 inclusive) a partir de um número N fornecido como entrada.
DADOS DE ENTRADA: N (a ser colocado em uma variável inteira)
DADOS DE SAÍDA: números pares impressos
OBS: Existe uma solução mais eficiente que a mostrada abaixo. Testar se é par ou ímpar antes do loop...
Exercício
Elabore um teste de mesa para o problema acima.
Exercício
Modificar o exercício anterior para que ALÉM de imprimir os números pares, também seja impresso no FINAL do algoritmo a SOMA de todos os números ímpares abaixo ou iguais a N. Faça na forma de FLUXOGRAMA e em PSEUDOCÓDIGO.
solução |
---|
Exemplo 2
PROBLEMA: Elaborar um fluxograma para computação do fatorial de um número conforme definição abaixo:
DADOS DE ENTRADA:número cujo fatorial deve ser computado, a ser armazenado em N (numero inteiro)
DADOS DE SAÌDA: FATORIAL computado
O fatorial é definido por:
OBS: Existem OUTRAS soluções possíveis!!!
Exercício 1
Faça uma versão do algoritmo acima na forma de pseudocódigo.
Exercício 2
Faça uma versão do Fluxograma do Fatorial em que a variável i começa com o valor 1. Teste também se o número N fornecido é maior ou igual a ZERO. Caso não seja (caso seja negativo) o algoritmo deve emitir uma mensagem e voltar a perguntar por N. FAÇA um teste de mesa considerando N=4.
Exercício 2
Observe os exemplos acima e elabore um algoritmo que computa todos os fatoriais de números entre 1 e N, onde N é um número fornecido.
DADOS DE ENTRADA: N (inteiro)
DADOS DE SAÌDA: fatoriais entre 1 e N
Exemplo 3
PROBLEMA: Aprimorar o exemplo do controle de acesso para que, no caso de 3 tentativas de acesso seguidas, com senha errada, o sistema seja bloqueado. O administrador desbloqueia redefinindo a senha.
- DADOS DE ENTRADA: senha inserida pelo usuário na variável SENHA /* variável que armazena a senha entrada pelo usuário ou administrador */
- DADOS DE SAÍDA: mensagem de abertura da porta / usuário bloqueado*/
- VARIÁVEIS INTERMEDIÁRIAS: CONT_ACESSO /* valor inicial zero - incrementada a cada senha inválida */
Note que a variável CONT_ACESSO é iniciada com zero e incrementada a cada erro no fornecimento da senha. A atribuição CONT_ACESSO = CONT_+ACESSO + 1 deve ser interpretada da forma: acesse o valor de CONT_ACESSO e some 1 a este valor. Coloque o resultado novamente em CONT_ACESSO (o conteúdo anterior é sobrescrito!)
Esta solução não é perfeita e poderia ser aprimorada. Se o administrador erra, ele pode vir a bloquear o usuário.
EXERCÍCIOS
Para Praticar
EXERCÍCIO 1: Fazer um algoritmo (em fluxograma) que receba a nota de 4 avaliações (usar uma única variável) e calcule a média. Usar um loop controlado pela quantidade 4 (de avaliações). Imprimir aprovado, caso a média seja superior ou igual a 6.0, reprovado caso contrário.
EXERCÍCIO 2: Faça um algoritmo que determine o maior entre N números. A condição de parada é a entrada de um valor 0, ou seja, o algoritmo deve ficar calculando o maior até que a entrada seja igual a 0 (ZERO). Supor que pelo menos um número é sempre fornecido. Supor que NUNCA será fornecido número negativo.
EXERCÍCIO 3: Faça um algoritmo que conte de 1 a 100 e a cada múltiplo de 10 emita uma mensagem: “Múltiplo de 10”.
Desafios
EXERCÍCIO 1: Modificar o sistema de controle de acesso para incluir dois usuários com user_id e senha. Prever a existência de dois usuários (armazenados nas variáveis USERID_1, USERID_2, SENHA_1, SENHA_2 com valores iniciais user "alfa", senha "alfa" e user "beta" com senha "beta"). O admin poderá ser identificado por "admin" e senha fixa "admin123". Prever bloqueio por usuário (duas variáveis contadores). Sugestão: criar funcões separadas para tratamento de cada usuário. Em breve veremos como podemos contornar esta duplicação através da parametrização de funções/subprogramas.
Solução - Exercício 01 |
---|
EXERCÍCIO 2: Escrever um algoritmo que leia como dados de entrada dois números inteiros positivos para as variáveis S e Q. O programa deve computar os N primeiros números da PG (progressão geométrica), onde o valor inicial de S é o número inicial e o valor em Q a razão de uma progressão geométrica. O número N também será fornecido como entrada.
Obs: Para PG tem-se:
- ou
Solução - Exercício 02 |
---|
ALGORITMO
S: real;
Q: real
N: inteiro
I: inteiro
INICIO
I=1;
LER N //número de repetições
LER Q //Ler a razão
LER S //valor de a_1
ENQUANTO i<=N FAÇA
IMPRIMIR "TERMO" I "TEM VALOR" S
S=S*Q
I=I+1
FIM_ENQUANTO
FIM |
EXERCÍCIO 3: Implementar um algoritmo que permita computar a somatória dos N primeiros termos de uma PG, cujos valores de "s" e "q" são também fornecidos como dados de entrada.
Solução - Exercício 03 |
---|
EXERCÍCIO 4:: Implementar um algoritmo através de um fluxograma que permita ler N números inteiros. O algoritmo deve computar o fatorial da SOMATÓRIA destes números. Exemplo: O usuário fornece 5 números: 2,9,13,21 e 55. O algoritmo computará o fatorial de 2+9+13+21+55, ou seja, o fatorial de 100.
EXERCÍCIO 5: Implementar uma função (subprograma), usando fluxograma, para computar o valor da PG, dados como parâmetros s e q.
Solução - Exercício 04 |
---|
EXERCÍCIO 6:: Implementar um algoritmo na forma de fluxograma que permite implementar uma calculadora especial que tem 3 funções:
- Calcular o número de Fibonacci Fₙ para um número n ≥ 0 (ver https://en.wikipedia.org/wiki/Fibonacci_number)
- Calcular o Fatorial de um número N (ver https://pt.wikipedia.org/wiki/Fatorial)
- Calcular a combinação simples de N elementos organizados 'r' a 'r' (ver https://pt.wikipedia.org/wiki/Combinat%C3%B3ria#Combina%C3%A7%C3%A3o_simples)
- Uma opção da sua escolha que envolva repetição, tal como nos problemas acima.
Para cada um destes itens deixar claro o que é entrada e o que é saída de dados.