UC00245

Desenvolver algoritmos

Pensamento computacional, pseudocódigo, fluxograma, técnicas de construção e depuração

Curso profissional · 25h · Técnico de Desenvolvimento de Software

Plano

  1. Pensamento computacional e definição do problema
  2. Planear as etapas: decomposição
  3. O que é um algoritmo
  4. Tipos de dados: constantes, variáveis e vetores
  5. Entrada e saída de dados
  6. Estrutura sequencial
  7. Estrutura alternativa
  8. Estrutura repetitiva: PARA
  9. Estrutura repetitiva: ENQUANTO e REPETIR ATÉ
  10. Pseudocódigo
  11. Fluxograma
  12. Contadores e totalizadores
  13. Expressões e funções predefinidas
  14. Validação de dados
  15. Testar, depurar e otimizar algoritmos
  16. Problemas integrados e escolha da estrutura

Bloco 1 · Pensamento computacional

O que é o pensamento computacional

O pensamento computacional é a forma de raciocinar sobre um problema de modo a que a sua solução possa ser executada, passo a passo, por uma pessoa ou por uma máquina. Assenta em quatro princípios:

  • Decomposição: dividir um problema grande em partes mais pequenas.
  • Reconhecimento de padrões: identificar semelhanças entre problemas já resolvidos.
  • Abstração: guardar só o que é essencial, ignorar o detalhe irrelevante.
  • Algoritmia: desenhar uma sequência de passos que resolve o problema.

Não é "pensar como um computador", é pensar de forma estruturada antes de programar.

Definir o problema

Antes de desenhar qualquer algoritmo, o problema tem de estar claramente definido. É a primeira realização desta UC.

  • Identificar os dados de entrada disponíveis (inputs).
  • Identificar o resultado esperado (outputs).
  • Identificar restrições e condições que a solução tem de cumprir.
  • Reformular o problema por palavras próprias, para confirmar que foi compreendido.

Um problema mal definido dá sempre origem a um algoritmo errado, por muito bem escrito que esteja.

Bloco 2 · Planear as etapas

Decompor um problema em subproblemas

Decompor é dividir um problema em partes menores e mais simples de resolver. É uma aptidão central desta UC.

  • Cada subproblema deve ser mais pequeno e mais fácil do que o original.
  • Resolver os subproblemas um a um e depois combinar as soluções.
  • Ajuda a identificar passos repetidos, que podem ser tratados com o mesmo trecho de algoritmo.

Exemplo: "organizar um evento" decompõe-se em: convidar, reservar espaço, preparar material, confirmar presenças.

Planear a solução

Depois de decompor, planeia-se a ordem e a forma de cada etapa antes de escrever o algoritmo final.

  1. Listar as etapas identificadas na decomposição.
  2. Ordená-las de forma lógica (o que tem de acontecer antes de quê).
  3. Escolher, para cada etapa, a estrutura lógica mais adequada (sequência, alternativa ou repetição).
  4. Rever o plano com um caso de teste simples, ainda em papel.

Planear é mais barato do que corrigir um algoritmo já escrito.

Bloco 3 · O que é um algoritmo

Algoritmo: conceito, ação e estado

Um algoritmo é uma sequência finita, ordenada e não ambígua de ações que resolve um problema ou executa uma tarefa.

  • Cada ação transforma o estado do sistema: muda o valor de uma variável, lê um dado, escreve um resultado.
  • O estado da ação é a "fotografia" dos valores das variáveis num dado momento da execução.
  • O algoritmo avança de estado em estado até chegar ao resultado final.
Propriedade Significa
Finito tem de terminar ao fim de um número finito de passos
Definido cada passo é claro e não ambíguo
Determinístico a mesma entrada produz sempre a mesma saída
Eficaz cada passo é executável

Etapas de desenvolvimento de um algoritmo

O desenvolvimento de um algoritmo segue sempre o mesmo ciclo, do problema ao teste:

Definir o problema → Planear as etapas → Estruturar em pseudocódigo
→ Desenhar em fluxograma → Testar e depurar
  • Cada etapa valida a anterior: o fluxograma confirma o pseudocódigo, o teste confirma o fluxograma.
  • Um erro descoberto cedo (na definição do problema) é muito mais barato de corrigir do que um erro descoberto no fim (a testar).

Este ciclo é exatamente a estrutura das cinco realizações desta UC.

Exemplo resolvido · trocar duas variáveis

Com a = 5 e b = 8, queremos a = 8 e b = 5.

aux ← a
a ← b
b ← aux
Ação a b aux
Início 5 8 (nenhuma)
aux ← a 5 8 5
a ← b 8 8 5
b ← aux 8 5 5

Sem a variável auxiliar, a ← b apaga o valor original de a.

Bloco 4 · Tipos de dados

Constantes e variáveis

Um algoritmo manipula dados, guardados em constantes e variáveis.

  • Variável: um espaço com nome que guarda um valor que pode mudar durante a execução. Ex.: idade, total, nome.
  • Constante: um espaço com nome que guarda um valor que não muda. Ex.: IVA ← 0.23, PI ← 3.14159.
  • Toda a variável deve ser inicializada antes de ser usada; usar uma variável sem valor é um erro clássico.
  • Nomes descritivos (preco_total, não x) tornam o algoritmo legível.

Regra de escrita: nome ← valor atribui o valor à variável ou constante.

Tipos de dados básicos

Cada variável guarda dados de um tipo, que determina que operações são válidas:

Tipo Exemplos Operações típicas
Inteiro 5, -3, 120 + - * DIV MOD
Real 3.14, -0.5 + - * /
Texto (cadeia) "Aulify" concatenação
Lógico (booleano) Verdadeiro, Falso E, OU, NÃO

Escolher o tipo certo evita erros: somar dois valores de texto não é o mesmo que concatená-los, e dividir dois inteiros pode exigir DIV (parte inteira) em vez de / (resultado real).

Estruturas de dados: o vetor

Um vetor é uma estrutura de dados que guarda vários valores do mesmo tipo sob um só nome. Cada valor tem um índice, a começar em 1: notas[1] é a primeira nota, notas[5] a quinta.

notas: vetor de 5 reais
total ← 0
PARA i DE 1 ATÉ 5 FAÇA
   LER notas[i]
   total ← total + notas[i]
FIM PARA
ESCREVER "Média: ", total / 5

Notas 12, 8, 15, 10 e 18: vetor [12, 8, 15, 10, 18], total 63, média 12.6. Depois da leitura, notas[3] continua a valer 15.

Bloco 5 · Entrada e saída de dados

LER e ESCREVER

Todo o algoritmo interage com o exterior através de duas operações elementares:

  • LER (input): recolhe um valor do utilizador ou de outra fonte e guarda-o numa variável. Ex.: LER idade.
  • ESCREVER (output): mostra um valor ou uma mensagem. Ex.: ESCREVER "Idade: ", idade.
INICIO
   ESCREVER "Introduza o seu nome:"
   LER nome
   ESCREVER "Olá, ", nome
FIM

A ordem importa: pedir (ESCREVER a mensagem) antes de ler evita que o utilizador não saiba o que introduzir.

Boas práticas de entrada e saída

  • Mensagens claras, que dizem exatamente o que se espera (ex.: "Introduza a nota (0 a 20):").
  • Separar entrada de dados de cálculo: primeiro ler tudo o que é preciso, depois processar.
  • A saída deve ser legível: usar texto explicativo, não só o número ("Total: 45.50 €", não só 45.50).
  • Sempre que possível, validar o que foi lido antes de o usar (bloco 14).

Um algoritmo tecnicamente correto mas com entradas e saídas confusas é, na prática, mau algoritmo.

Bloco 6 · Estrutura sequencial

A estrutura sequencial

A estrutura sequencial é a mais simples das três estruturas lógicas: as ações executam-se uma a seguir à outra, pela ordem em que estão escritas.

INICIO
   LER base
   LER altura
   area ← base * altura
   ESCREVER "Área: ", area
FIM
  • Não há decisões nem repetições, só uma linha reta de execução.
  • É a base sobre a qual se constroem as estruturas alternativa e repetitiva.
  • A ordem das instruções não é arbitrária: uma variável só pode ser usada depois de ter sido definida.

Bloco 7 · Estrutura alternativa

SE simples e SE composto

A estrutura alternativa permite escolher entre caminhos diferentes, consoante uma condição.

SE nota >= 10 ENTÃO
   ESCREVER "Aprovado"
FIM SE

Com SE composto (SENÃO), define-se também o que fazer quando a condição é falsa:

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

A condição é sempre uma expressão lógica, que só pode dar Verdadeiro ou Falso.

SE encadeado e alternativas aninhadas

Quando há mais de duas hipóteses, usa-se SENÃO SE para as encadear:

SE nota >= 18 ENTÃO
   ESCREVER "Excelente"
SENÃO SE nota >= 10 ENTÃO
   ESCREVER "Aprovado"
SENÃO
   ESCREVER "Reprovado"
FIM SE
  • As condições são testadas por ordem, de cima para baixo; assim que uma é verdadeira, as restantes não se testam.
  • Estruturas alternativas podem também ser aninhadas (uma dentro de outra), quando a segunda decisão só faz sentido depois da primeira.

Regra prática: nunca mais do que 2 ou 3 níveis de aninhamento, ou o algoritmo torna-se ilegível.

Exemplo resolvido · a ordem das condições

Escalões: 0 a 9 Insuficiente, 10 a 13 Suficiente, 14 a 17 Bom, 18 a 20 Excelente.

Versão errada: testar nota >= 10 primeiro. Com nota = 19, escreve «Suficiente», porque as restantes condições nunca são testadas.

Versão correta: do mais exigente para o menos exigente.

SE nota >= 18 ENTÃO ESCREVER "Excelente"
SENÃO SE nota >= 14 ENTÃO ESCREVER "Bom"
SENÃO SE nota >= 10 ENTÃO ESCREVER "Suficiente"
SENÃO ESCREVER "Insuficiente"
FIM SE

Testar as fronteiras: 9, 10, 13, 14, 17, 18, 20.

Exemplo resolvido · ano bissexto

Regra: divisível por 4, exceto se for por 100, a não ser que também seja por 400.

SE (ano MOD 4 = 0 E ano MOD 100 <> 0) OU ano MOD 400 = 0 ENTÃO
   ESCREVER "bissexto"
SENÃO
   ESCREVER "não bissexto"
FIM SE
ano MOD 4 = 0 MOD 100 <> 0 MOD 400 = 0 Resultado
2024 Verdadeiro Verdadeiro Falso bissexto
1900 Verdadeiro Falso Falso não bissexto
2000 Verdadeiro Falso Verdadeiro bissexto
2023 Falso Verdadeiro Falso não bissexto

Bloco 8 · Estrutura repetitiva: PARA

O ciclo PARA

A estrutura repetitiva (ciclo) executa um bloco de instruções várias vezes. O ciclo PARA usa-se quando o número de repetições é conhecido.

PARA i DE 1 ATÉ 10 FAÇA
   ESCREVER i
FIM PARA
  • i é a variável de controlo, atualizada automaticamente em cada iteração.
  • DE ... ATÉ ... define o intervalo; PASSO (opcional) define o incremento.
  • Cada volta ao ciclo chama-se iteração.

Regra de ouro: se conseguires dizer de antemão quantas vezes o ciclo repete, é um PARA.

Exemplo resolvido · tabuada com PARA

Problema: ler um número n e escrever a sua tabuada de 1 a 10.

INICIO
   LER n
   PARA i DE 1 ATÉ 10 FAÇA
      ESCREVER n, " x ", i, " = ", n * i
   FIM PARA
FIM

Trace para n = 3: em cada iteração, i toma os valores 1, 2, 3, …, 10, e a expressão n * i calcula 3, 6, 9, …, 30. O ciclo termina sozinho quando i ultrapassa 10.

Bloco 9 · ENQUANTO e REPETIR ATÉ

ENQUANTO: pré-teste

O ciclo ENQUANTO usa-se quando o número de repetições não é conhecido à partida; a condição é testada antes de cada iteração (pré-teste).

LER num
ENQUANTO num <> 0 FAÇA
   ESCREVER "Recebi: ", num
   LER num
FIM ENQUANTO
  • Se a condição for logo falsa, o corpo do ciclo nunca executa.
  • A variável da condição tem de mudar dentro do ciclo, senão o ciclo nunca termina (ciclo infinito).
  • Padrão típico: ler antes do ciclo, e voltar a ler dentro dele.

REPETIR ATÉ: pós-teste

O ciclo REPETIR ATÉ executa o corpo pelo menos uma vez, e só depois testa a condição de paragem (pós-teste).

REPETIR
   ESCREVER "Introduza a nota (0-20):"
   LER nota
ATÉ nota >= 0 E nota <= 20
ENQUANTO REPETIR ATÉ
Teste antes (pré-teste) depois (pós-teste)
Executa pelo menos uma vez não garante sim, sempre
Uso típico leitura com sentinela validação de entrada

Escolher entre os dois depende de uma pergunta: "este bloco tem sempre de correr pelo menos uma vez?"

Exemplo resolvido · soma dos algarismos

Não sabemos quantos algarismos tem o número, logo usa-se ENQUANTO.

soma ← 0
ENQUANTO n > 0 FAÇA
   soma ← soma + n MOD 10
   n ← n DIV 10
FIM ENQUANTO
Iteração n último algarismo soma n depois
1 1234 4 4 123
2 123 3 7 12
3 12 2 9 1
4 1 1 10 0

O ciclo termina porque n diminui sempre. Resultado: 10.

Ciclos aninhados e número primo

Ciclos aninhados: o interior corre por completo a cada iteração do exterior. Com i e j de 1 a 3, o corpo executa 9 vezes.

Primo: maior do que 1 e sem divisores entre 2 e n - 1. Usa-se uma bandeira lógica que baixa a Falso quando se encontra um divisor.

primo ← Verdadeiro
SE n < 2 ENTÃO
   primo ← Falso
FIM SE
d ← 2
ENQUANTO d < n E primo FAÇA
   SE n MOD d = 0 ENTÃO primo ← Falso FIM SE
   d ← d + 1
FIM ENQUANTO

Com n = 9: d = 2 não divide, d = 3 divide, a bandeira baixa e o ciclo para.

Bloco 10 · Pseudocódigo

Convenções do pseudocódigo

O pseudocódigo é uma notação intermédia entre a linguagem natural e uma linguagem de programação: estruturada, mas sem a sintaxe rígida de nenhuma linguagem em concreto.

  • Blocos delimitados por INICIO/FIM e por FIM SE, FIM PARA, FIM ENQUANTO.
  • Atribuição com ←; comparação de igualdade com =.
  • Indentação consistente para mostrar o aninhamento das estruturas.
  • Vocabulário em português: LER, ESCREVER, SE, ENTÃO, SENÃO, PARA, ENQUANTO, REPETIR.

É transferível para qualquer linguagem: quem sabe pensar em pseudocódigo, aprende Python, Java ou C em poucas semanas.

Boas práticas de escrita

  • Nomes descritivos: preco_total, não x.
  • Comentar apenas o que não é óbvio; código bem escrito explica-se sozinho.
  • Indentar cada nível de estrutura (SE dentro de PARA, por exemplo) com um recuo consistente.
  • Evitar duplicar código: se o mesmo bloco aparece duas vezes, é sinal de que falta reorganizar o algoritmo.
  • Testar mentalmente com um exemplo pequeno antes de considerar o pseudocódigo terminado.

Um bom pseudocódigo lê-se de cima para baixo sem surpresas.

Bloco 11 · Fluxograma

Símbolos do fluxograma (ISO 5807:1985)

O fluxograma representa o algoritmo com símbolos gráficos normalizados (norma ISO 5807:1985), ligados por setas que indicam o fluxo de execução.

Símbolo Nome Representa
Retângulo de cantos arredondados (ou elipse) Terminal início ou fim
Paralelogramo Entrada/Saída LER, ESCREVER
Retângulo Processo cálculo, atribuição
Losango Decisão condição (SE)
Seta Fluxo ordem de execução

O fluxograma e o pseudocódigo são duas representações do mesmo algoritmo: o que se pode escrever num, pode desenhar-se no outro.

Regras de boa prática no desenho de um fluxograma

  • Um único símbolo terminal de início e, normalmente, um de fim.
  • Todo o losango tem exatamente duas saídas: Verdadeiro e Falso.
  • As setas nunca se cruzam sem necessidade; o fluxo lê-se de cima para baixo.
  • Todos os caminhos convergem antes do terminal final.
  • Aplicações de desenho de algoritmos (draw.io, Lucidchart, Flowgorithm) ajudam a manter a norma.

Um fluxograma bem desenhado é lido por qualquer colega sem explicações adicionais.

Bloco 12 · Contadores e totalizadores

O contador

Um contador é uma variável que regista quantas vezes algo acontece. Incrementa (ou decrementa) sempre da mesma quantidade fixa, tipicamente 1.

contador ← 0
PARA i DE 1 ATÉ n FAÇA
   LER nota
   SE nota >= 10 ENTÃO
      contador ← contador + 1
   FIM SE
FIM PARA
ESCREVER "Positivas: ", contador
  • Inicializa-se sempre a 0, antes do ciclo.
  • Distingue-se do totalizador porque soma sempre a mesma quantidade fixa (1, ou -1), nunca um valor lido.

O totalizador (acumulador)

Um totalizador (ou acumulador) soma valores variáveis, lidos ou calculados, ao longo do ciclo.

total ← 0
PARA i DE 1 ATÉ n FAÇA
   LER preco
   total ← total + preco
FIM PARA
ESCREVER "Total: ", total
  • Inicializa-se a 0 para uma soma, ou a 1 para um produto (acumulador-produto, como no fatorial).
  • Cada iteração acrescenta um valor diferente, ao contrário do contador que soma sempre 1.

Contador e totalizador aparecem quase sempre juntos, por exemplo para calcular uma média.

Padrões: máximo, mínimo, média e sentinela

Padrão Inicialização
Máximo primeiro valor lido, nunca 0
Mínimo primeiro valor lido
Média total / contador, no fim do ciclo
Sentinela ler antes do ciclo e no fim do corpo

Notas 12, 8, 15, 10, 18: total 63, média 12,6, maior 18, menor 8, aprovados 4.

Com sentinela, testar contador = 0 antes de dividir, para evitar a divisão por zero.

Exemplo resolvido · distância entre dois pontos

Distância entre (x1, y1) e (x2, y2):

dx ← x2 - x1
dy ← y2 - y1
distancia ← RAIZ(dx * dx + dy * dy)

Para (0, 0) e (3, 4): dx = 3, dy = 4, 9 + 16 = 25, RAIZ(25) = 5.

Arredondar a duas casas: ARREDONDAR(valor * 100) / 100. Com 3.14159 obtém-se 3.14.

Precedência: parênteses, depois * / DIV MOD, depois + -.

Bloco 13 · Expressões e funções predefinidas

Expressões aritméticas, relacionais e lógicas

Um algoritmo combina três tipos de expressões:

Tipo Operadores Resultado
Aritmética + - * / DIV MOD ^ um número
Relacional = <> < > <= >= Verdadeiro/Falso
Lógica E, OU, NÃO Verdadeiro/Falso
  • DIV devolve a parte inteira da divisão; MOD devolve o resto. 7 DIV 2 = 3, 7 MOD 2 = 1.
  • As expressões lógicas combinam várias condições: SE idade >= 18 E temCartao ENTÃO.
  • Respeitar a precedência: multiplicação antes de adição, comparações antes de E/OU.

Funções predefinidas

As funções predefinidas poupam trabalho: resolvem operações comuns sem ser preciso escrever o algoritmo de raiz.

Função Faz
RAIZ(x) raiz quadrada de x
ABS(x) valor absoluto de x
ARREDONDAR(x) arredonda x ao inteiro mais próximo
MAIOR(a, b) / MENOR(a, b) maior ou menor de dois valores
COMPRIMENTO(cadeia) número de carateres de uma cadeia de texto

Usar uma função predefinida é preferível a reescrever a mesma lógica: menos código, menos oportunidade de erro.

Bloco 14 · Validação de dados

Porque validar dados de entrada

Validar é confirmar que um valor lido está dentro do intervalo ou formato esperado, antes de o usar nos cálculos.

  • Sem validação, dados absurdos (uma nota de 250, uma idade negativa) contaminam todo o resultado.
  • A validação é uma das técnicas de construção de algoritmos do referencial desta UC.
  • Regra prática: nunca confiar num valor lido do exterior sem o confirmar primeiro.
REPETIR
   ESCREVER "Nota (0-20):"
   LER nota
ATÉ nota >= 0 E nota <= 20

Como estruturar a validação

O padrão de validação combina sempre um REPETIR ATÉ com uma condição de validade:

  1. Pedir e ler o valor.
  2. Se for inválido, mostrar uma mensagem de erro clara.
  3. Repetir até o valor ser válido.
REPETIR
   ESCREVER "Idade (0-120):"
   LER idade
   SE idade < 0 OU idade > 120 ENTÃO
      ESCREVER "Valor fora do intervalo. Tente outra vez."
   FIM SE
ATÉ idade >= 0 E idade <= 120

Cada validação é uma fronteira de confiança: depois dela, o resto do algoritmo pode assumir que o valor está correto.

Validação com limite de tentativas

Em situações reais, não se prende o utilizador para sempre.

tentativas ← 0
valida ← Falso
ENQUANTO tentativas < 3 E NÃO valida FAÇA
   ESCREVER "Nota (0 a 20):"
   LER nota
   tentativas ← tentativas + 1
   SE nota >= 0 E nota <= 20 ENTÃO valida ← Verdadeiro
   SENÃO ESCREVER "Valor inválido." FIM SE
FIM ENQUANTO
Tentativa nota valida
1 25 Falso
2 -3 Falso
3 14 Verdadeiro

Combina bandeira, contador e validação.

Desenhar casos de teste

Família Objetivo Para uma nota de 0 a 20
Típicos funcionamento normal 7, 12, 16
Limite fronteiras 0, 9, 10, 19, 20
Inválidos têm de ser recusados -1, 21, 250

O resultado esperado calcula-se antes de executar o algoritmo.

Se o calculas depois de ver o resultado, confirmas o que já lá estava, não testas.

Exemplo resolvido · depurar uma média

Código do aluno: media ← a + b + c / 3.

Para 10, 12 e 14, esperado (10 + 12 + 14) / 3 = 12. Obtido: cerca de 26,67, porque 14 / 3 é calculado primeiro.

Correção: media ← (a + b + c) / 3.

Método: calcular o esperado, comparar com o obtido, seguir a execução até ao ponto em que divergem, corrigir a causa.

Bloco 15 · Testar, depurar e otimizar

Testar com trace tables

Testar um algoritmo é executá-lo, à mão ou no computador, com dados concretos, e confirmar que o resultado está certo. A ferramenta principal é a trace table: uma tabela que regista o valor de cada variável a cada iteração.

Iteração i soma
Inicial (nenhuma) 0
1 1 1
2 2 3
  • Escolher casos de teste variados: valores típicos, valores-limite (0, negativos) e valores inválidos.
  • Um algoritmo só está pronto depois de passar em todos os casos de teste relevantes.

Depurar: erros comuns e como os corrigir

Depurar (debug) é encontrar e corrigir os erros detetados no teste.

Erro típico Causa Correção
Ciclo infinito variável de controlo não muda garantir incremento/decremento no corpo
Resultado sempre 0 acumulador-produto (multiplicação) inicializado a 0 em vez de 1 inicializar a 1 antes do ciclo
Totalizador nunca aumenta (fica sempre 0) falta a instrução de acumulação (totalizador ← totalizador + valor) dentro do ciclo garantir que a acumulação está dentro do corpo do ciclo
Off-by-one (falta ou sobra uma iteração) limites do PARA mal definidos rever DE/ATÉ

Cada erro corrigido é conhecimento para não o repetir no próximo algoritmo.

Otimizar e ferramentas de apoio

Depois de correto, um algoritmo pode ser otimizado: mais simples, mais rápido, mais legível, sem mudar o resultado.

  • Combinar cálculos que percorrem os dados numa só passagem, em vez de várias.
  • Eliminar código repetido ou desnecessário.
  • Escolher a estrutura mais direta (por exemplo, PARA em vez de ENQUANTO quando o número de iterações é conhecido).
  • Apoiar todo o processo em IDEs, compiladores e aplicações de desenho de algoritmos e fluxogramas.

Um algoritmo correto, testado e otimizado está pronto para se tornar um programa.

Bloco 16 · Problemas integrados

Problema integrado · caixa de loja

Ler preços até 0. Recusar preços negativos. No fim, mostrar artigos, total e desconto de 5% se o total ultrapassar 50 € (valores fictícios).

Entrada 20, -5, 30, 10, 0:

Processado total artigos
20 20 1
-5 20 1
30 50 2
10 60 3

60 > 50, desconto 3.00, a pagar 57. Com total exatamente 50, não há desconto.

Escolher a estrutura certa

O problema pede... Usa...
Ações por ordem sequencial
Dois caminhos SE ... SENÃO
Vários escalões SE encadeado
Número conhecido de repetições PARA
Repetir até um valor especial ENQUANTO com sentinela
Repetir até o dado ser aceitável REPETIR ATÉ
Contar / somar contador / totalizador
Memorizar um acontecimento bandeira lógica

Recapitulando

  • Pensamento computacional: decomposição, reconhecimento de padrões, abstração e algoritmia.
  • Dados: constantes e variáveis, tipos básicos, entrada e saída.
  • Estruturas lógicas: sequencial, alternativa (SE), repetitiva (PARA, ENQUANTO, REPETIR ATÉ).
  • Representações: pseudocódigo e fluxograma (ISO 5807), o mesmo algoritmo em duas linguagens.
  • Técnicas de construção: contadores, totalizadores, expressões, funções predefinidas, validação.
  • Testar e depurar com trace tables, casos-limite e otimização final.

Próximo: fichas e projeto, construir algoritmos completos de raiz.

NOTAS DO PROFESSOR - Enfatizar: o pensamento computacional existe antes e sem qualquer linguagem de programação. É um raciocínio, não uma sintaxe. - Erro comum: os alunos associam logo pensamento computacional a "saber código". Desfazer esta ideia já na primeira aula. - Analogia: uma receita de cozinha bem escrita já é pensamento computacional aplicado, sem uma única linha de código.

NOTAS DO PROFESSOR - Enfatizar: definir inputs, outputs e restrições é um passo formal, não uma perda de tempo. Fazer os alunos escrevê-lo sempre antes de codificar. - Erro comum: saltar direto para o pseudocódigo sem perceber o que é pedido. Corrigir pedindo sempre "o que entra, o que sai, que regras tens de respeitar?" - Exemplo: "calcular a média de um aluno" está mal definido; "ler 3 notas entre 0 e 20 e calcular a média aritmética" já está bem definido.

NOTAS DO PROFESSOR - Enfatizar: quase nenhum problema real se resolve de um só passo. Decompor é sempre o primeiro movimento. - Erro comum: tentar escrever o algoritmo completo de uma vez. Ensinar a parar e a listar os subproblemas primeiro, no papel. - Exercício rápido: pedir à turma que decomponha "preparar o pequeno-almoço" em pelo menos 4 subproblemas.

NOTAS DO PROFESSOR - Enfatizar: o planeamento é uma etapa registada, com valor próprio, e não um "rascunho que se deita fora". - Erro comum: inverter a ordem das etapas (por exemplo, validar dados depois de os usar). Rever sempre a ordem lógica. - Analogia: o plano é a lista de compras antes de ir ao supermercado; sem ela, esquece-se sempre alguma coisa.

NOTAS DO PROFESSOR - Enfatizar as quatro propriedades: finito, definido, determinístico, eficaz. Vão voltar na ficha de avaliação integrada. - Erro comum: confundir "algoritmo" com "programa". O algoritmo é a ideia; o programa é a sua tradução para uma linguagem. - Exemplo: uma receita de bolo é um algoritmo: ações ordenadas, cada uma muda o "estado" da massa.

NOTAS DO PROFESSOR - Enfatizar: este ciclo é o "mapa" de toda a UC. Voltar a ele no início de cada aula para situar a matéria. - Erro comum: tratar o teste como um extra opcional no fim. Reforçar que testar faz parte do desenvolvimento, não é um bónus. - Pergunta à turma: porque é mais barato corrigir um erro na definição do problema do que já no teste final?

NOTAS DO PROFESSOR - Enfatizar: a atribuição substitui o valor anterior de forma irreversível, e a ordem das ações faz parte do significado do algoritmo. - Erro comum: escrever `a ← b` e `b ← a` e achar que trocou. Pedir aos alunos para fazerem a tabela de estado desta versão errada. - Analogia: trocar o conteúdo de dois copos exige um terceiro copo vazio.

NOTAS DO PROFESSOR - Enfatizar: a diferença entre constante e variável é se o valor muda ao longo da execução, não se "parece" fixo. - Erro comum: usar uma variável não inicializada (ex.: um acumulador sem `← 0` antes do ciclo). Vai reaparecer nos contadores e totalizadores. - Exemplo: numa fatura, `IVA` é constante durante o cálculo; `total` é variável, muda a cada artigo.

NOTAS DO PROFESSOR - Enfatizar a diferença entre `DIV` (divisão inteira) e `/` (divisão real): é fonte de muitos erros mais à frente. - Erro comum: tentar somar texto com número sem conversão explícita. Reforçar que o tipo importa. - Exemplo: `7 DIV 2 = 3` mas `7 / 2 = 3.5`. Pedir à turma para calcular os dois à mão.

NOTAS DO PROFESSOR - Enfatizar: um vetor guarda os valores para os consultar mais tarde; cinco variáveis soltas não se percorrem com um ciclo. - Erro comum: usar um índice fora do vetor (`notas[6]`) ou esquecer que aqui o primeiro índice é 1. - O ciclo PARA só é estudado no bloco 8; neste ponto, ler «repete para i de 1 a 5».

NOTAS DO PROFESSOR - Enfatizar: pedir sempre uma mensagem antes de LER. Um algoritmo que só faz "LER x" sem explicação confunde quem o usa. - Erro comum: esquecer a mensagem de pedido, ou trocar a ordem de LER e ESCREVER. - Exemplo/analogia: é como perguntar antes de esperar resposta; ninguém responde a uma pergunta que não ouviu.

NOTAS DO PROFESSOR - Enfatizar que a comunicação com o utilizador faz parte da qualidade do algoritmo, não é um "extra". - Erro comum: misturar leitura e processamento numa única linha confusa. Separar sempre em passos. - Pergunta à turma: porque é que "45.50" sozinho é pior saída do que "Total: 45.50 €"?

NOTAS DO PROFESSOR - Enfatizar: mesmo os algoritmos mais complexos são, no fundo, sequências, com alternativas e repetições encaixadas lá dentro. - Erro comum: usar `area` antes de `base` e `altura` estarem lidas. Reforçar a ordem lógica das dependências. - Exercício: pedir à turma que escreva a sequência de um algoritmo simples (ex.: calcular o perímetro de um retângulo).

NOTAS DO PROFESSOR - Enfatizar que a condição é binária: ou é verdadeira, ou é falsa, nunca "mais ou menos". - Erro comum: esquecer o `FIM SE`, ou escrever a condição ao contrário (ex.: `nota <= 10` em vez de `>= 10`). - Exemplo: perguntar à turma o que aconteceria se a condição fosse `nota > 10` em vez de `nota >= 10` (a nota 10 seria mal classificada).

NOTAS DO PROFESSOR - Enfatizar a ordem de avaliação: a primeira condição verdadeira "ganha", as seguintes nem chegam a ser testadas. - Erro comum: pôr as condições pela ordem errada (ex.: testar `>= 10` antes de `>= 18` nunca deixaria "Excelente" aparecer). - Analogia: é como um funil de perguntas de triagem, a primeira resposta que encaixa decide o caminho.

NOTAS DO PROFESSOR - Enfatizar: num SE encadeado, a primeira condição verdadeira decide tudo e as restantes deixam de ser testadas. - Erro comum: ordenar as condições pela ordem em que o enunciado as menciona, sem pensar no que cada uma apanha. - Pedir aos alunos que prevejam o resultado para 19 antes de revelar a versão correta.

NOTAS DO PROFESSOR - Enfatizar: uma tabela com uma coluna por cada parte da condição é a melhor forma de testar condições compostas. - Erro comum: esquecer os parênteses à volta do E, o que muda o significado da condição. - Exemplo: perguntar porque é que 1900 não foi bissexto e 2000 foi.

NOTAS DO PROFESSOR - Enfatizar a condição de escolha: número de iterações conhecido de antemão implica ciclo `PARA`. - Erro comum: alterar manualmente a variável de controlo dentro do ciclo `PARA`, o que confunde a contagem. Não é boa prática. - Exemplo: imprimir a tabuada de um número é o exemplo clássico de `PARA`, porque são sempre 10 linhas.

NOTAS DO PROFESSOR - Fazer o trace no quadro com a turma, iteração a iteração, para fixar o comportamento da variável de controlo. - Erro comum: confundir `n` (o número escolhido) com `i` (o contador do ciclo). São papéis diferentes. - Pergunta: o que mudaria no código se a tabuada fosse só até 5? (mudar o `ATÉ 10` para `ATÉ 5`).

NOTAS DO PROFESSOR - Enfatizar o pré-teste: se a condição já começa falsa, o corpo nunca corre, ao contrário do REPETIR-ATÉ. - Erro comum clássico: esquecer de atualizar a variável testada dentro do ciclo, criando um ciclo infinito. - Exemplo: ler números até aparecer o 0 (sentinela) é o caso típico de `ENQUANTO`; um menu que tem de aparecer pelo menos uma vez usa `REPETIR ATÉ`.

NOTAS DO PROFESSOR - Enfatizar a tabela comparativa: é a pergunta mais recorrente na avaliação sobre ciclos. - Erro comum: usar `ENQUANTO` para validação de entrada, o que obriga a duplicar a leitura antes e dentro do ciclo. - Exercício: pedir para reescrever o exemplo de validação com `ENQUANTO` e comparar o número de linhas com o `REPETIR ATÉ`.

NOTAS DO PROFESSOR - Enfatizar: `MOD 10` isola o último algarismo e `DIV 10` retira-o. - Erro comum: esquecer a instrução `n ← n DIV 10`, que provoca um ciclo infinito. - Pedir aos alunos que façam a trace table para 507.

NOTAS DO PROFESSOR - Enfatizar: a bandeira lógica memoriza um acontecimento e permite sair do ciclo mais cedo. - Erro comum: tratar 1 como número primo; o algoritmo tem de prever `n < 2` antes do ciclo. - Perguntar quantas vezes corre o corpo interior se o exterior repetir 4 vezes e o interior 5.

NOTAS DO PROFESSOR - Enfatizar que o pseudocódigo não tem uma norma única; o importante é a consistência dentro da turma e do exercício. - Erro comum: misturar sintaxe de uma linguagem real (`if`, `for`, `;`) com pseudocódigo em português. Manter a coerência. - Exemplo: mostrar o mesmo algoritmo em pseudocódigo e depois em Python, lado a lado, para mostrar a tradução direta.

NOTAS DO PROFESSOR - Ligar a este slide as atitudes do referencial: rigor e sentido de organização. - Erro comum: pseudocódigo sem indentação, onde não se percebe o que está dentro de quê. - Exercício: dar um pseudocódigo mal indentado e pedir à turma para o reescrever corretamente.

NOTAS DO PROFESSOR - Enfatizar que fluxograma e pseudocódigo são equivalentes, não é preciso escolher só um: usam-se conforme o contexto. - Erro comum: usar o losango para um cálculo, ou o retângulo para uma decisão. Rever os símbolos até serem automáticos. - Exercício: mostrar 5 símbolos soltos e pedir à turma para os nomear de memória.

NOTAS DO PROFESSOR - Demonstrar, numa aplicação de desenho de fluxogramas, como inserir e ligar os símbolos. - Erro comum: losangos com só uma saída, ou setas que "morrem" sem chegar a lado nenhum. - Ligar ao critério de desempenho: "utilizando aplicações de representação diagramática".

NOTAS DO PROFESSOR - Enfatizar a inicialização a 0 antes do ciclo: esquecê-la é o erro mais comum deste padrão. - Erro comum: incrementar o contador fora da condição, contando tudo em vez de só o que interessa. - Exemplo/pergunta: o que aconteceria se `contador` começasse a 1 em vez de 0? (o resultado final estaria sempre errado por excesso).

NOTAS DO PROFESSOR - Enfatizar a diferença entre contador (soma fixa) e totalizador (soma variável): é a confusão mais frequente nesta matéria. - Erro comum: inicializar um acumulador-produto a 0 em vez de 1, o que faz o resultado ser sempre 0. - Exemplo: para calcular uma média, é preciso um totalizador (soma das notas) e um contador (quantas notas), a dividir no fim.

NOTAS DO PROFESSOR - Enfatizar: inicializar o máximo e o mínimo com o primeiro valor lido, não com 0. - Erro comum: ler o sentinela no início do corpo do ciclo, o que o processa como se fosse um dado. - Fazer a trace table com as cinco notas em conjunto, linha a linha.

NOTAS DO PROFESSOR - Enfatizar: funções simples combinam-se para dar funções mais úteis. - Erro comum: esquecer os parênteses, como em `a + b + c / 3` para a média. - Perguntar quanto vale `2 + 3 * 4` e quanto vale `(2 + 3) * 4`.

NOTAS DO PROFESSOR - Enfatizar `DIV` versus `MOD`: são a base do teste de paridade (`n MOD 2 = 0`) usado em vários exercícios. - Erro comum: esquecer parêntesis em expressões compostas, alterando a ordem de avaliação pretendida. - Exercício rápido: calcular `10 DIV 3` e `10 MOD 3` à mão com a turma.

NOTAS DO PROFESSOR - Enfatizar que reinventar uma função já existente é desperdício de esforço e fonte de erros. - Erro comum: escrever manualmente uma raiz quadrada por tentativa e erro, quando existe `RAIZ()`. - Pergunta: que função usarias para saber quantos carateres tem uma palavra lida? (COMPRIMENTO).

NOTAS DO PROFESSOR - Enfatizar a atitude de rigor: validar não é excesso de zelo, é parte do algoritmo correto. - Erro comum: validar só "porque sim" sem escolher o intervalo certo para o problema em causa. - Exemplo: pedir à turma um caso em que a falta de validação causaria um problema real (idade negativa numa inscrição).

NOTAS DO PROFESSOR - Enfatizar o conceito de "fronteira de confiança": depois de validado, o valor pode ser usado sem mais verificações. - Erro comum: validar dentro do `PARA`/`ENQUANTO` principal em vez de isolar a validação no seu próprio ciclo. - Ligar às atitudes do referencial: rigor e sentido analítico ao definir os limites válidos.

NOTAS DO PROFESSOR - Enfatizar: um algoritmo robusto prevê o que fazer quando o utilizador insiste em dados inválidos. - Erro comum: validar com `OU` onde devia ser `E`, ou vice-versa, nas condições de intervalo. - Pedir o resultado para as leituras 25, -3 e 40.

NOTAS DO PROFESSOR - Enfatizar: o esperado calcula-se antes, e a fronteira é onde os erros se escondem. - Erro comum: testar só com um caso típico e dar o algoritmo por correto. - Pedir à turma que proponha os casos de teste para o algoritmo do ano bissexto.

NOTAS DO PROFESSOR - Enfatizar: corrigir a causa, não o sintoma, e voltar a testar depois da correção. - Erro comum: ajustar o resultado final com um número em vez de corrigir a expressão. - Ligar às atitudes do referencial: rigor e sentido analítico.

NOTAS DO PROFESSOR - Enfatizar os casos-limite: são os que mais frequentemente revelam erros escondidos (n=0, listas vazias, valores negativos). - Erro comum: testar só com um caso "que corre bem" e nunca com casos-limite. - Exercício: construir a trace table de um ciclo simples em conjunto, linha a linha, no quadro.

NOTAS DO PROFESSOR - Enfatizar: estes quatro erros cobrem a maioria dos casos que os alunos vão encontrar nas fichas e no projeto. - Erro comum: corrigir "por tentativa" sem perceber a causa. Insistir em identificar a causa antes de mudar o código. - Ligar às atitudes do referencial: empenho e persistência na resolução de problemas.

NOTAS DO PROFESSOR - Enfatizar que otimizar vem sempre depois de correto: nunca otimizar um algoritmo que ainda não funciona. - Erro comum: otimizar prematuramente e introduzir um novo erro no processo. - Anunciar as fichas e o projeto: construir, testar e depurar algoritmos de raiz.

NOTAS DO PROFESSOR - Enfatizar: o ciclo completo definir, planear, estruturar e testar está presente neste exemplo. - Erro comum: usar `>=` quando o enunciado diz «ultrapassar». - Pedir aos alunos que escrevam o pseudocódigo antes de o mostrar.

NOTAS DO PROFESSOR - Enfatizar: a escolha da estrutura deriva da pergunta que o problema faz, não da preferência de cada um. - Erro comum: usar sempre o mesmo ciclo para tudo. - Dar três enunciados curtos e pedir à turma que escolha a estrutura de cada um.