Pseudocódigo essencial: propósito, clareza e regras mínimas

O que se espera de um pseudocódigo útil

Pseudocódigo é uma forma padronizada de descrever um algoritmo com foco em legibilidade e traduzibilidade para uma linguagem de programação. Ele não existe para “parecer código”, e sim para registrar decisões, passos e regras de forma que outra pessoa (ou você no futuro) consiga implementar sem precisar adivinhar intenções.

Um pseudocódigo útil deve permitir que alguém transforme o texto em programa respondendo, sem suposições, perguntas como: quais são as entradas, quais são as saídas, quais passos são executados, em que ordem, sob quais condições e com quais repetições.

Critérios objetivos de qualidade

1) Clareza (legibilidade operacional)

Clareza significa que cada linha descreve uma ação ou decisão de forma direta, com termos consistentes. Um leitor deve conseguir “simular” o algoritmo mentalmente.

• Use verbos de ação: LER, CALCULAR, SE, ENQUANTO, IMPRIMIR.
• Nomeie variáveis pelo papel: total, media, idade, quantidade.
• Evite frases vagas: “faz o cálculo”, “verifica se dá”, “trata o caso”.

2) Completude (não deixar lacunas)

Completude é o algoritmo conter todos os passos necessários para sair das entradas e chegar às saídas, incluindo casos alternativos e validações essenciais quando elas afetam o fluxo.

• Declare entradas e saídas esperadas (mesmo que informalmente).
• Inclua inicializações: contadores começam em quanto? acumuladores começam em quanto?
• Inclua o que acontece em casos-limite relevantes (ex.: lista vazia, divisão por zero, valor inválido).

3) Determinismo (mesmas entradas, mesmo resultado)

Determinismo significa que, dadas as mesmas entradas, o algoritmo executa os mesmos passos e produz o mesmo resultado (a menos que você declare explicitamente uma fonte de aleatoriedade).

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

• Evite instruções como “escolha um valor bom” ou “tente até dar certo”.
• Se houver empate ou múltiplas opções, defina regra de desempate (ex.: “em caso de empate, escolha o menor índice”).

4) Ausência de ambiguidade (uma interpretação possível)

Ambiguidade ocorre quando uma frase pode ser implementada de mais de um jeito plausível. Pseudocódigo deve reduzir interpretações alternativas.

• Especifique condições com precisão: SE idade >= 18 em vez de “se for maior”.
• Defina claramente limites de laços: “para i de 1 até n (inclusive)” ou “enquanto i < n”.
• Defina formato de dados quando necessário: “lista de inteiros”, “texto”, “registro com campos”.

O que não pode ocorrer (erros que impedem virar programa)

Misturar linguagem natural solta com trechos de código

O problema não é usar português; é alternar entre frases vagas e código “meio pronto”, criando buracos lógicos. Exemplo de mistura problemática: “aí você faz um loop e dá um break se precisar”. Isso não define condição de parada nem o que é “precisar”.

Pular etapas lógicas

Se um resultado depende de uma decisão intermediária, essa decisão precisa aparecer. Ex.: dizer “calcule a média” sem dizer “some os valores” e “divida pela quantidade” pode ser aceitável em contextos simples, mas se houver lista vazia, arredondamento, ou filtragem, o pseudocódigo precisa explicitar.

Depender da sintaxe de uma linguagem específica

Pseudocódigo deve ser traduzível para várias linguagens. Evite detalhes como {}, ;, compreensão de listas, métodos específicos (.map(), .push()) ou bibliotecas. Use estruturas genéricas: SE, ENQUANTO, PARA CADA, ADICIONAR, REMOVER.

Regras mínimas (um padrão simples)

Use este conjunto mínimo de convenções para manter consistência:

• Blocos explícitos: toda estrutura (SE, ENQUANTO, PARA) deve ter início e fim claros (por indentação e/ou palavras como FIMSE, FIMENQUANTO).
• Uma ação por linha: facilita leitura e implementação.
• Variáveis definidas antes do uso: inicialize contadores e acumuladores.
• Condições completas: use comparações explícitas e operadores lógicos quando necessário.
• Entradas e saídas nomeadas: deixe claro o que entra e o que sai.

Passo a passo prático: como escrever um pseudocódigo “traduzível”

Passo 1 — Declare entradas, saídas e objetivo

Escreva uma linha curta com o que o algoritmo recebe e o que devolve. Isso reduz lacunas.

ENTRADA: lista de números (valores) e um número (limite)  SAÍDA: quantidade de valores maiores que limite

Passo 2 — Liste as variáveis necessárias e inicialize

Se você vai contar, acumular ou guardar “o melhor até agora”, inicialize explicitamente.

contador <- 0

Passo 3 — Descreva o fluxo principal com estruturas genéricas

Use PARA CADA, SE, ENQUANTO e mantenha as condições explícitas.

PARA CADA valor EM valores FAÇA  SE valor > limite ENTÃO    contador <- contador + 1  FIMSE FIMPARA

Passo 4 — Especifique casos-limite quando mudam o comportamento

Se a entrada pode ser vazia e isso altera o resultado, declare. Se não altera, ainda pode ser útil deixar claro.

SE valores está vazia ENTÃO  RETORNAR 0 FIMSE

Passo 5 — Finalize com a saída

O algoritmo deve terminar com uma saída inequívoca.

RETORNAR contador

Comparação prática: pseudocódigo “bom” vs “confuso”

Exemplo 1 — Calcular média de notas válidas

Problema: receber uma lista de notas (0 a 10) e retornar a média apenas das notas válidas. Se não houver nenhuma nota válida, retornar 0.

Pseudocódigo bom

ENTRADA: lista de números (notas)  SAÍDA: número (media) soma <- 0 quantidade <- 0 PARA CADA nota EM notas FAÇA  SE nota >= 0 E nota <= 10 ENTÃO    soma <- soma + nota    quantidade <- quantidade + 1  FIMSE FIMPARA SE quantidade = 0 ENTÃO  RETORNAR 0 SENÃO  media <- soma / quantidade  RETORNAR media FIMSE

Por que este vira programa sem adivinhação:

• Completude: define filtragem (0..10), soma, contagem e caso de lista sem válidas.
• Determinismo: não há escolhas subjetivas; a regra de validade é objetiva.
• Sem ambiguidade: o que é “válida” está formalizado; divisão por zero é evitada.
• Independente de linguagem: usa estruturas genéricas e operadores comuns.

Pseudocódigo confuso

pega as notas boas calcula a média se não tiver nota retorna algo faz um for e ignora as ruins media = soma/qtde

Por que falha ao virar programa:

• Ambiguidade: “notas boas” significa >= 7? entre 0 e 10? não negativas? não está definido.
• Incompleto: não diz como identificar “ruins”, nem inicializa soma e qtde.
• Indeterminado: “retorna algo” não especifica qual valor.
• Mistura solta: alterna frase informal com uma expressão de código sem contexto.

Exemplo 2 — Encontrar o maior valor e sua posição

Problema: receber uma lista de inteiros e retornar o maior valor e o índice (posição) da primeira ocorrência. Se a lista estiver vazia, retornar nulo para ambos.

Pseudocódigo bom

ENTRADA: lista de inteiros (valores) SAÍDA: (maior, indice) SE valores está vazia ENTÃO  RETORNAR (nulo, nulo) FIMSE maior <- valores[0] indice <- 0 PARA i DE 1 ATÉ tamanho(valores)-1 FAÇA  SE valores[i] > maior ENTÃO    maior <- valores[i]    indice <- i  FIMSE FIMPARA RETORNAR (maior, indice)

Por que este vira programa sem adivinhação:

• Critério de desempate implícito e correto: usa > (não >=), então mantém a primeira ocorrência.
• Casos-limite: lista vazia tratada antes de acessar valores[0].
• Passos explícitos: inicialização e atualização do “melhor até agora”.

Pseudocódigo confuso

maior = 0 pos = 0 para cada item na lista se for maior atualiza no final devolve

Por que falha ao virar programa:

• Erro lógico por inicialização inadequada: se todos os valores forem negativos, maior = 0 está errado.
• Ambiguidade: “se for maior” maior do que o quê? não está explícito.
• Incompleto: não define o que acontece com lista vazia; “devolve” não diz o formato da saída.

Checklist rápido de revisão (antes de implementar)