Mudanças entre as edições de "Lógica de Programação 1 - Estruturas de Repetição"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
 
(149 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 a somatório de N valores a serem fornecidos pelo teclado.
+
'''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_i /* valor de um dos N números a serem inseridos */
+
* 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:FluxogramaSomatoria.jpg|border|450px]]
+
ATENÇÃO 2: em alguns momentos são OMITIDAS as mensagens para AJUDAR a pessoa (ou sistema) que está entrando com dados.
−
<blockquote style="background: lime; border: 1px solid black; padding: 1em;">
+
</blockquote>
−
NOTAR que usamos a variável '''a_i''' para ler cada valor a ser usado na soma acumulada.  
+
 
−
A medida que a leitura é realizada a soma já é computada. Desta forma podemos REAPROVEITAR a mesma
+
 
−
variável para cada elemento lido. ENTRETANTO, em outros problemas isto poderia ser um problema. Os vetores
+
[[imagem:FluxogramaSomatoriaV1.jpg|border|450px]]
 +
 
 +
<blockquote style="background: pink; border: 1px solid black; padding: 1em;">
 +
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.
 +
</blockquote>
 +
 
 +
<blockquote style="background: pink; border: 1px solid black; padding: 1em;">
 +
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...
 
auxiliarão neste processo...
 
</blockquote>
 
</blockquote>
 +
  
  
 
ou
 
ou
  
−
<code>
+
<syntaxhighlight lang="C">
−
ALGORITMO
+
ALGORITMO soma_n_numeros()
 +
VARIAVEIS
 
   N: inteiro
 
   N: inteiro
−
   A_i: inteiro
+
   parcela: inteiro
−
   I: inteiro
+
   i: inteiro
−
   SOMA: inteiro
+
   S: inteiro
 
INICIO
 
INICIO
 
   LER N
 
   LER N
 
   i = 0
 
   i = 0
−
   SOMA = 0
+
   S = 0
−
   ENQUANTO I<N FAÇA
+
   ENQUANTO i<N FAÇA
−
       LER A_i
+
       LER parcela
−
       SOMA = SOMA + A_i
+
       S <- S + parcela
−
       I=I+1
+
       i <- i+1
 
   FIM_ENQUANTO
 
   FIM_ENQUANTO
−
   IMPRIMIR "SOMATORIA = ", SOMA
+
   IMPRIMIR "SOMATORIA = ", S
 
FIM
 
FIM
 
</syntaxhighlight>
 
</syntaxhighlight>
  
 +
====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:
  
−
NOTA: 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.
+
{| class="wikitable"
 +
! style="text-align: center; background-color:#ffffc7; color:#333333;" | Instrução
 +
executada
 +
! style="text-align: center; background-color:#ffffc7; color:#333333;" | N
 +
! 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;" | parcela
 +
! style="text-align: center; background-color:#ffffc7;" | i<N
 +
|-
 +
| style="text-align: center; background-color:#68cbd0; color:#333333;" | 1
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
|-
 +
| style="text-align: center; background-color:#68cbd0; color:#333333;" | 2
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
|-
 +
| style="text-align: center; background-color:#68cbd0; color:#333333;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
|-
 +
| style="text-align: center; background-color:#68cbd0; color:#333333;" | 4
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#68cbd0; color:#333333;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#68cbd0; color:#333333;" | 6
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | ?
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#68cbd0;" | 7
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#68cbd0;" | 8
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 0
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#68cbd0;" | 9
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 1
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#68cbd0;" | 6
 +
| style="text-align: center; background-color:#96fffb;" | 3
 +
| style="text-align: center; background-color:#96fffb;" | 1
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | 5
 +
| style="text-align: center; background-color:#96fffb;" | V
 +
|-
 +
| style="text-align: center; background-color:#ffffff;" | :
 +
| style="text-align: center;" | :
 +
| style="text-align: center;" | :
 +
| style="text-align: center;" | :
 +
| style="text-align: center;" | :
 +
| style="text-align: center;" | :
 +
|}
  
 
====EXERCÍCIO====
 
====EXERCÍCIO====
Linha 66: Linha 168:
 
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.
 
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.
  
−
==Exemplos Adicionais==
+
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
  
−
===Exemplo 1===
+
==Comando DO-ENQUANTO: repetição com decisão no final do loop==
  
−
Elaborar um fluxograma para imprimir os números pares em ordem decrescente (até atingir 0) a partir de um número N fornecido como entrada.
+
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:
  
−
Dados de Entrada: N (variável inteira)
+
<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]] ||
 +
|-
 +
|}
  
−
Dados de saída: números pares impressos
+
</span>
  
−
[[imagem:FluxogramaRepeticaoImprimePar.jpg|border|450px]]
+
==Comando PARA: organizando a repetição de forma estruturada==
  
−
====Exercício====
+
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:
  
−
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 de N.
+
{| 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>
 +
|-
 +
|}
  
−
===Exemplo 2===
+
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).
  
−
Elaborar um programa para computação do fatorial de um número conforme definição abaixo:
+
Um fluxograma para a versão com comando PARA seria:
  
−
DADOS DE ENTRADA: número N (numero inteiro)
+
[[imagem:FluxogramaComandoPara.png|border|250px]]
  
−
DADO DE SAÌDA: FATORIAL computado
+
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.
  
−
O fatorial é definido por:
+
==Exemplos Adicionais==
  
−
:<math>n!=\prod_{k=1}^n k\qquad\forall n\in\mathbb{N}</math>
+
===Exemplo 1===
  
−
[[imagem:FluxogramaFatorialNum.jpg|border|450px]]
+
'''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.
  
−
====Exercício 1====
+
'''DADOS DE ENTRADA''': N (a ser colocado em uma variável inteira)
  
−
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 se encerrar.
+
'''DADOS DE SAÍDA''': números pares impressos
  
−
====Exercício 2====
+
OBS: Existe uma solução mais eficiente que a mostrada abaixo. Testar se é par ou ímpar antes do loop...
  
−
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.
+
[[imagem:FluxogramaRepeticaoImprimeParV2.jpg|border|450px]]
  
−
DADOS DE ENTRADA: N (inteiro)
+
====Exercício====
  
−
DADOS DE SAÌDA: fatoriais entre 1 e N
+
Elabore um teste de mesa para o problema acima.
  
−
===Exemplo 3===
+
====Exercício====
  
−
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.
+
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.
  
−
*DADOS DE ENTRADA: SENHA /* variável que armazena a senha entrada pelo usuário ou administrador */
+
{{collapse top | solução}}
−
*DADOS DE SAÍDA: mensagem de abertura da porta / usuário bloqueado*/
+
<!--[[Arquivo:paresomaimpar.jpg]]-->
−
*VARIÁVEIS INTERMEDIÁRIAS: CONT_ACESSO /* valor inicial zero - incrementada a cada senha inválida */
+
{{collapse bottom}}
  
−
[[imagem:FluxogramaControleAcessoComContador.jpg|border|850px]]
+
===Exemplo 2===
  
−
Note que a variável CONT_ACESSO é iniciada com zero e
+
'''PROBLEMA''': Elaborar um fluxograma para computação do fatorial de um número conforme definição abaixo:
−
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!)
 
  
−
<!--
+
'''DADOS DE ENTRADA''':número cujo fatorial deve ser computado, a ser armazenado em N (numero inteiro)
−
===Quebrando um problema em subproblemas: SUBPROGRAMAS===
 
  
 +
'''DADOS DE SAÌDA''': FATORIAL computado
  
−
Neste procedimento pode ser observado que:
+
O fatorial é definido por:
−
*começa a aparecer uma certa complexidade no fluxograma;
 
−
*Além disto, não ficou uma abordagem muito interessante, pois se for o administrador que erra a senha, ele pode bloquear o usuário. Mudando a ordem de teste pode-se  contornar este problema.
 
−
*não existe forma de desbloquear a senha (zerar o contador), a não ser mudando a senha.
 
  
−
Em síntese, existem subproblemas adicionais a serem resolvidos que adicionam complexidade ao sistema. Como podemos resolvê-los sem deixar um fluxograma complexo?
+
:<math>n!=\prod_{i=1}^n i\qquad\forall n\in\mathbb{N}</math>
  
−
Usaremos a caixa de processos pré-definidos que usaremos para invocar funções que resolvem determinado subproblema.
+
OBS: Existem OUTRAS soluções possíveis!!!
  
−
Inicialmente, vamos construir três subprogramas:
+
[[imagem:FluxogramaFatorialNum.jpg|border|390px]]
−
* Iniciar_Sistema(): inicia variáveis do sistema, colocando o sistema em um estado inicial conhecido;
 
−
* Tratar_Admin(): é o código que trata a funcionalidade associada ao administrador;
 
−
* Tratar_User(): é a funcionalidade que trata o usuário (procedimento de abrir porta, bloquear etc).
 
  
 +
====Exercício 1====
  
−
[[imagem:FluxogramaControleAcessoComSubprograma.jpg|850px]]
+
Faça uma versão do algoritmo acima na forma de pseudocódigo.
  
−
OBS: Note que foi usada uma variável auxiliar AUX que permite ajustar o valor
+
====Exercício 2====
−
de número de acessos a ser mostrado no display. Note também que na caixa DISPLAY foi usado
 
−
uma string a ser impressa e a variável AUX cujo conteúdo deve ser impresso. Ambos separados
 
−
por vírgula.
 
  
−
* ANINHAMENTO DE DECISÔES
+
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.
  
−
A função Tratar_User() se utiliza de aninhamento de decisões. Em um primeiro momento é testado se a senha confere com a senha do usuário. SE ela conferir ENTÂO é testado se o contador de bloqueios está dentro do aceitável.
+
{{collapse top | Solução Exercício 1}}
 +
[[imagem:FatN1v2.jpg|border|400px]]
 +
{{collapse bottom}}
  
−
-->
+
====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.
  
−
===PARÂMETROS E RETORNO DE VALORES EM SUBPROGRAMAS===
+
'''DADOS DE ENTRADA''': N (inteiro)
  
−
Para tornar ainda mais interessante o uso de subprogramas, vamos ver o conceito de passagem de parâmetros e retorno de valores.
+
'''DADOS DE SAÌDA''': fatoriais entre 1 e N
  
−
Quando chamamos (invocamos) um subprograma podemos passar valores (dados de entrada) para este subprograma.
+
{{collapse top | Solução Exercício 2}}
−
Estes valores são passados através de variáveis especiais que chamamos de parâmetros.
+
[[imagem:FluxogramaFatorialdeNumeros.jpg|border|390px]]
 +
{{collapse bottom}}
  
−
Parâmetros podem ser passados por valor e por referência. Por valor é quando os dados a serem passados na invocação
+
===Exemplo 3===
−
do subprograma são copiados para uma variável do subprograma.
 
  
−
Os parâmetros são passados por referência quando o que é passado para o subprograma é simplesmente o endereço da variável
+
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.
−
repassada na invocação do subprograma.
 
  
−
Não existe uma forma explícita de definir os parâmetros em um fluxograma. Deve-se realizar um comentário antes ou ao lado do mesmo especificando o tipo e como será tratado o parâmetro.
+
*'''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 */
  
−
EXEMPLO: Seja elaborar um fluxograma correspondente a uma subprograma que deve calcular o fatorial de um número inteiro passado como parâmetro. O subprograma deve retornar o valor calculado.
+
[[imagem:FluxogramaControleAcessoComContador.jpg|border|850px]]
  
−
A função fatorial é definida por:
+
<blockquote style="background: pink; border: 1px solid black; padding: 1em;">
 +
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!)
  
−
:<math>n!=\prod_{k=1}^n k\qquad\forall n\in\mathbb{N}</math>
+
Esta solução não é perfeita e poderia ser aprimorada. Se o administrador erra, ele pode vir a bloquear o usuário.
 +
</blockquote>
  
  
−
[[imagem:FluxogramaFatorial.jpg|border|650px]]
+
===EXERCÍCIOS===
  
−
Neste fluxograma, o subprograma denominado ''CalcFatorial'' recebe um valor no parâmetro N (implicitamente inteiro) e retorna o valor calculado do fatorial.
+
==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.
  
−
O fluxograma principal invoca duas vezes o subrograma. O retorno é armazenado nas variáveis NUM1 e NUm3.
+
{{collapse top | Solução Ex. 1}}
 +
[[imagem:media_aprova_reprova.jpg|border|650px]]
 +
{{collapse bottom}}
  
−
Quando um subprograma retorna um valor, ele é chamado de função. Para manter coerência com o C chamaremos
+
'''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.
−
qualquer subrprograma de função (independente de retornar valor).
 
  
−
EXERCÍCIO: Implementar a solução acima usando pseudocódigo.
+
{{collapse top | Solução Ex. 2}}
 +
[[imagem:maior_valor.jpg|border|650px]]
 +
{{collapse bottom}}
  
−
EXERCÍCIO: Implementar uma função (subpŕograma), usando fluxograma, que recebe dois números inteiros como parâmetro. A função retorna 1 se os números forem iguais, 0 se o primeiro número maior que o segundo e -1 se o segundo for maior que o primeiro.
+
'''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}}
  
−
===EXERCÍCIOS===
+
==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 - Exercicio 01}}
+
{{collapse top|Solução - Exercício 01}}
−
<!--
+
[[imagem:Aula03_Exercicio01-BAK.jpg|2500px]]
−
[[imagem:Aula03_Exercicio01.jpg|2500px]]
 
−
-->
 
 
{{collapse bottom}}
 
{{collapse bottom}}
  
Linha 216: Linha 393:
 
:<math>a_n=a_1.q^{n-1}\,\!</math>
 
:<math>a_n=a_1.q^{n-1}\,\!</math>
  
−
<!--
+
 
−
{{collapse top|Solução - Exercicio 02}}
+
{{collapse top|Solução - Exercício 02}}
−
[[imagem:Aula03_Exercicio02_(1).jpg|800px]]
+
<syntaxhighlight>
−
{{collapse bottom}}
 
−
-->
 
−
{{collapse top|Solução - Exercicio 02}}
 
−
<code>
 
 
ALGORITMO
 
ALGORITMO
 
   S: real;
 
   S: real;
Linha 243: 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 - Exercicio 03}}
+
{{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 - Exercicio 04}}
+
[[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.

Falhou ao verificar gramática (MathML com retorno SVG ou PNG (recomendado para navegadores modernos e ferramentas de acessibilidade): Resposta inválida ("Math extension cannot connect to Restbase.") do servidor "https://en.wikipedia.org/api/rest_v1/":): {\displaystyle S = \sum_{i=0}^{N-1} a_i = a_0 + a_1 + .. + a_{N-1}}

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.


FluxogramaSomatoriaV1.jpg

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 DO-ENQUANTO comando ENQUANTO 
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

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
FluxogramaComandoDo-Para.png

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:

FluxogramaComandoPara.png

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...

FluxogramaRepeticaoImprimeParV2.jpg

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:

Falhou ao verificar gramática (MathML com retorno SVG ou PNG (recomendado para navegadores modernos e ferramentas de acessibilidade): Resposta inválida ("Math extension cannot connect to Restbase.") do servidor "https://en.wikipedia.org/api/rest_v1/":): {\displaystyle n!=\prod_{i=1}^n i\qquad\forall n\in\mathbb{N}}

OBS: Existem OUTRAS soluções possíveis!!!

FluxogramaFatorialNum.jpg

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.

Solução Exercício 1

FatN1v2.jpg

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

Solução Exercício 2

FluxogramaFatorialdeNumeros.jpg

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 */

FluxogramaControleAcessoComContador.jpg

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.

Solução Ex. 1

Media aprova reprova.jpg

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.

Solução Ex. 2

Maior valor.jpg

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”.

Solução Ex. 3

Aula03 ExercicioFluxogramaContagemDe0A100.jpg

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

2500px

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:

Falhou ao verificar gramática (MathML com retorno SVG ou PNG (recomendado para navegadores modernos e ferramentas de acessibilidade): Resposta inválida ("Math extension cannot connect to Restbase.") do servidor "https://en.wikipedia.org/api/rest_v1/":): {\displaystyle a_1 = s }
Falhou ao verificar gramática (MathML com retorno SVG ou PNG (recomendado para navegadores modernos e ferramentas de acessibilidade): Resposta inválida ("Math extension cannot connect to Restbase.") do servidor "https://en.wikipedia.org/api/rest_v1/":): {\displaystyle a_n = q\times a_{n-1} } ou
Falhou ao verificar gramática (MathML com retorno SVG ou PNG (recomendado para navegadores modernos e ferramentas de acessibilidade): Resposta inválida ("Math extension cannot connect to Restbase.") do servidor "https://en.wikipedia.org/api/rest_v1/":): {\displaystyle a_n=a_1.q^{n-1}\,\!}


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

800px

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

1200px

EXERCÍCIO 6:: Implementar um algoritmo na forma de fluxograma que permite implementar uma calculadora especial que tem 3 funções:

  1. Calcular o número de Fibonacci Fₙ para um número n ≥ 0 (ver https://en.wikipedia.org/wiki/Fibonacci_number)
  2. Calcular o Fatorial de um número N (ver https://pt.wikipedia.org/wiki/Fatorial)
  3. 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)
  4. 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.

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Lógica_de_Programação_1_-_Estruturas_de_Repetição&oldid=190450”