Ficha 05 · Pseudocódigo, fluxograma e depuração · Ficha de trabalho

Aluno(a)

Turma

Nº

Data

Objectivos da ficha

Converter entre pseudocódigo e fluxograma
Construir trace tables
Identificar e corrigir erros típicos
Aplicar programação defensiva

Parte I · Pseudocódigo ↔ Fluxograma

Exercício 1 · Identificar símbolos

Indique o nome (e símbolo) que representa cada um destes elementos do fluxograma:

a) Início ou fim do algoritmo. ___

b) Cálculo ou atribuição. ___

c) Decisão (pergunta com resposta V/F). ___

d) Entrada ou saída de dados. ___

e) Direcção do fluxo entre símbolos. ___

a) Terminal — elipse / stadium. b) Processo — rectângulo. c) Decisão — losango. d) Entrada/Saída — paralelogramo. e) Fluxo — seta.

Norma de referência: ISO 5807 (1985).

Exercício 2 · Converter pseudocódigo em fluxograma

Considere o seguinte algoritmo. Desenhe o fluxograma correspondente no espaço abaixo:

INICIO
   LER nota
   SE nota >= 10 ENTÃO
      ESCREVER "Aprovado"
   SENÃO
      ESCREVER "Reprovado"
   FIM SE
FIM

Fluxograma equivalente (descrição textual da estrutura):

Terminal «INÍCIO» (elipse, no topo).
Seta para baixo.
Paralelogramo «LER nota».
Seta para baixo.
Losango «nota ≥ 10 ?» com duas saídas: V (à direita) e F (à esquerda).
Saída V → Paralelogramo «ESCREVER 'Aprovado'».
Saída F → Paralelogramo «ESCREVER 'Reprovado'».
Ambas as saídas convergem para uma seta única.
Terminal «FIM».

Exercício 3 · Converter fluxograma em pseudocódigo

Considere um fluxograma com: - Terminal «INÍCIO»; - Paralelogramo «LER n»; - Processo «soma ← 0», «i ← 1»; - Losango «i ≤ n ?»; - Saída V → Processo «soma ← soma + i», «i ← i + 1», volta ao losango. - Saída F → Paralelogramo «ESCREVER soma». - Terminal «FIM».

Escreva o pseudocódigo equivalente.

INICIO
   LER n
   soma ← 0
   i ← 1
   ENQUANTO i <= n FAÇA
      soma ← soma + i
      i ← i + 1
   FIM ENQUANTO
   ESCREVER soma
FIM

(Calcula a soma dos primeiros n inteiros positivos: 1 + 2 + … + n.)

Versão equivalente com PARA:

INICIO
   LER n
   soma ← 0
   PARA i DE 1 ATÉ n FAÇA
      soma ← soma + i
   FIM PARA
   ESCREVER soma
FIM

Parte II · Trace Table

Exercício 4 · Trace table simples

Complete a trace table para o algoritmo abaixo, com entrada n = 6:

LER n
fact ← 1
i ← 1
ENQUANTO i <= n FAÇA
   fact ← fact * i
   i ← i + 1
FIM ENQUANTO
ESCREVER fact

Iteração	`n`	`i` (antes do teste)	Condição `i ≤ n`	`fact` (após operação)	`i` (após incremento)
Inicial	6	1	V	1 (1×1)	2
2	6	2	V
3	6
4	6
5	6
6	6
7	6		F	—	—

Saída: ____

Iteração	`n`	`i` antes	Cond	`fact` após	`i` após
Inicial	6	1	V	1	2
2	6	2	V	2	3
3	6	3	V	6	4
4	6	4	V	24	5
5	6	5	V	120	6
6	6	6	V	720	7
7	6	7	F	—	—

Saída: 720 (6! = 720).

Parte III · Identificar e corrigir erros

Exercício 5 · Encontrar o erro

O algoritmo seguinte é suposto somar os primeiros n números pares. Identifique o(s) erro(s) e corrija:

LER n
soma ← 1                  // (a)
PARA i DE 1 ATÉ n FAÇA    // (b)
   soma ← soma + i        // (c)
FIM PARA
ESCREVER soma

Erros identificados:

(a) Inicialização errada. soma ← 1 deveria ser soma ← 0 — caso contrário a soma final fica sempre 1 a mais do que devia.
(c) Lógica errada. Soma todos os números (1, 2, 3, …, n), não apenas os pares. Para somar apenas os pares, há duas abordagens:

Solução A — testar paridade dentro do ciclo:

LER n
soma ← 0
PARA i DE 1 ATÉ n FAÇA
   SE i MOD 2 = 0 ENTÃO
      soma ← soma + i
   FIM SE
FIM PARA
ESCREVER soma

Solução B — gerar directamente os pares (mais elegante):

LER n
soma ← 0
PARA i DE 2 ATÉ 2*n PASSO 2 FAÇA
   soma ← soma + i
FIM PARA
ESCREVER soma

Nota: o enunciado diz «primeiros n pares» — se n=3, queremos 2+4+6 = 12. A solução A com i de 1 a n=3 daria 2 (só o número 2). A solução B é a correcta.

Exercício 6 · Detectar ciclo infinito

Indique se cada algoritmo termina. Se não terminar, explique porquê.

(a)

i ← 0
ENQUANTO i < 10 FAÇA
   i ← i + 2
FIM ENQUANTO

(b)

i ← 0
ENQUANTO i ≠ 10 FAÇA
   i ← i + 3
FIM ENQUANTO

(c)

n ← 100
ENQUANTO n > 0 FAÇA
   n ← n - 1
FIM ENQUANTO

(a) Termina. i vai a 0, 2, 4, 6, 8, 10. Quando i = 10, a condição i < 10 falha. Sai após 5 iterações.

(b) NÃO TERMINA. i vai a 0, 3, 6, 9, 12, 15, … nunca toma o valor exacto 10. A condição i ≠ 10 mantém-se sempre verdadeira. Ciclo infinito.

Lição: evitar condições de igualdade quando o incremento pode «saltar» por cima do valor procurado. Usar <, ≤ ou >, ≥ em vez de =.

(c) Termina. Decremento garante que n chega a 0 e o ciclo sai. Executa 100 vezes.

Exercício 7 · Programação defensiva

O seguinte algoritmo calcula a média de notas, mas tem várias vulnerabilidades. Identifique-as e proponha melhorias.

LER n
soma ← 0
PARA i DE 1 ATÉ n FAÇA
   LER nota
   soma ← soma + nota
FIM PARA
media ← soma / n
ESCREVER media

Vulnerabilidades identificadas:

n = 0: divisão por zero na linha media ← soma / n.
n < 0: o ciclo não executa e ainda assim tentamos dividir.
Notas fora do intervalo [0, 20]: o algoritmo aceita qualquer valor sem validação, falseando a média.

Versão defensiva:

INICIO
   REPETIR
      ESCREVER "Quantas notas?"
      LER n
   ATÉ n > 0

   soma ← 0

   PARA i DE 1 ATÉ n FAÇA
      REPETIR
         ESCREVER "Nota ", i, " (0-20):"
         LER nota
      ATÉ nota >= 0 E nota <= 20

      soma ← soma + nota
   FIM PARA

   media ← soma / n
   ESCREVER "Média: ", media
FIM

Observação: validar a entrada na origem é geralmente preferível a tratar valores inválidos depois. Cada validação é uma «fronteira de confiança» — dentro do ciclo já podemos assumir que os valores são válidos.

Exercício 8 · Refactoring (legibilidade)

Reescreva o seguinte algoritmo de forma mais legível, mantendo o mesmo comportamento. Justifique pelo menos duas alterações.

INICIO
   LER x
   LER y
   z ← x + y
   IF z > 100 THEN
      a ← z * 0.1
      ESCREVER z - a
   ELSE
      ESCREVER z
   FIM SE
FIM

Versão melhorada:

INICIO
   CONSTANTE LIMITE_DESCONTO = 100
   CONSTANTE TAXA_DESCONTO = 0.1

   LER preco
   LER taxa
   total ← preco + taxa

   SE total > LIMITE_DESCONTO ENTÃO
      desconto ← total * TAXA_DESCONTO
      total ← total - desconto
   FIM SE

   ESCREVER total
FIM

Alterações justificadas:

Nomes descritivos: x, y, z, a foram substituídos por preco, taxa, total, desconto. O leitor entende imediatamente o propósito do algoritmo.
Constantes nomeadas: 100 e 0.1 foram extraídos para constantes. Se a regra de desconto mudar, altera-se num único ponto, e o nome torna explícito o significado.
Eliminação da duplicação: o ESCREVER aparecia em ambos os ramos do SE. Refactorámos para escrever uma única vez no fim, depois de aplicar o desconto (se aplicável).
IF/THEN → SE/ENTÃO: o pseudocódigo deve ser consistentemente em português.