O que é algoritmo: a receita que o computador segue

Algoritmo é uma sequência finita de passos definidos para transformar uma entrada em um resultado. A ideia vem antes da linguagem: se outra pessoa não consegue seguir seus passos sem adivinhar, o computador também não conseguirá.

Pense numa receita. A analogia ajuda porque receita tem ingredientes, ordem e resultado esperado. O limite aparece quando a receita diz “coloque o suficiente”: uma pessoa usa experiência; o computador precisa de uma medida ou regra explícita. É por isso que aprender lógica começa por retirar as lacunas da instrução.

Uma receita que dá certo toda vez que alguém segue

O primeiro rascunho do café coado parecia completo. Ele tinha seis verbos e cabia num bilhete:

const passos = [
  'Colocar o filtro',
  'Adicionar o pó',
  'Despejar a água',
  'Esperar coar',
  'Servir',
  'Beber',
];

passos.forEach((passo, indice) => console.log(`${indice + 1}. ${passo}`));

Entreguei essa lista para uma pessoa executar literalmente. Três falhas apareceram: a água nunca foi esquentada, o filtro ficou fora do suporte e não havia xícara sob o coador. A tarefa parecia óbvia apenas para quem já conhecia o resultado. Esse teste separa uma intenção — “faça café” — de um algoritmo executável.

As três exigências: passos definidos, ordem e fim

Um passo definido diz qual ação acontece e sobre qual objeto. A ordem informa o que depende do quê. O fim evita que o processo continue para sempre. Podemos conferir as três propriedades como dados:

const algoritmo = {
  passosDefinidos: true,
  ordemDefinida: true,
  temFim: true,
};

console.log(Object.values(algoritmo).every(Boolean));

“Adicionar o pó” antes de “encaixar o filtro” quebra a ordem. “Mexer até ficar bom” não define o fim. E “usar água” não informa quantidade nem temperatura. A pergunta útil em cada linha é: alguém que não conhece a tarefa saberia exatamente o que fazer agora e quando avançar?

A versão dois do café, agora sem adivinhação

As três falhas viraram três passos explícitos. O segundo algoritmo tem nove passos:

const passos = [
  'Separar coador, filtro, xícara, 20 g de café e 300 ml de água',
  'Aquecer a água até começar a formar bolhas',
  'Encaixar o filtro no coador',
  'Posicionar o coador sobre a xícara',
  'Colocar 20 g de café no filtro',
  'Despejar 50 ml de água e esperar 30 segundos',
  'Despejar os 250 ml restantes devagar',
  'Esperar parar de pingar',
  'Retirar o coador e servir',
];

console.log(`${passos.length} passos; primeiro: ${passos[0]}`);

Os números não servem para deixar a receita sofisticada. Eles fecham decisões que antes estavam escondidas. Em software, limites como “idade maior ou igual a 18” e “até três tentativas” cumprem o mesmo papel.

O passo ambíguo é uma decisão que ficou sem dono

Podemos tornar a ausência visível validando os recursos antes de começar. Aqui o erro é reproduzido e tratado, em vez de aparecer só depois do café derramado:

function validarRecursos(recursos) {
  for (const item of ['agua', 'filtro', 'xicara']) {
    if (!recursos[item]) throw new Error(`Recurso ausente: ${item}`);
  }
}

try {
  validarRecursos({ agua: true, filtro: true, xicara: false });
} catch (erro) {
  console.log(`${erro.name}: ${erro.message}`);
}

O erro não acusa a pessoa. Ele nomeia a pré-condição que o algoritmo precisava declarar. Esse hábito volta em formulários, APIs e bancos: valide a entrada na fronteira, antes do processamento depender dela.

Dois algoritmos podem chegar à mesma saída

Para somar os preços de uma compra, você pode acumular num laço ou usar uma operação pronta. A saída é igual:

const precos = [12, 8, 5];

let totalComLaco = 0;
for (const preco of precos) totalComLaco += preco;

const totalComReduce = precos.reduce((soma, preco) => soma + preco, 0);
console.log(totalComLaco, totalComReduce, totalComLaco === totalComReduce);

O laço expõe cada passo e costuma ser melhor para aprender. reduce concentra a regra e pode ser melhor quando a equipe já domina a operação. “Mais curto” não significa automaticamente “melhor”: escolha pelo custo, pela clareza e pela chance de erro.

Trocar a ordem muda o resultado

Algoritmos não são sacos de instruções. Compare calcular desconto antes e depois do frete:

const subtotal = 100;
const frete = 20;
const desconto = 0.1;

const descontoAntesDoFrete = subtotal * (1 - desconto) + frete;
const descontoDepoisDoFrete = (subtotal + frete) * (1 - desconto);
console.log(descontoAntesDoFrete, descontoDepoisDoFrete);

As duas sequências terminam, mas respondem a regras comerciais diferentes. O requisito precisa decidir se o cupom atinge o frete. O código apenas torna essa decisão literal.

Do papel para o Node, uma linha por passo

JavaScript é linguagem de apoio aqui. O raciocínio já estava resolvido na lista; o Node só executa a ordem:

function executar(passos) {
  for (const passo of passos) console.log(`executando: ${passo}`);
  return 'café pronto';
}

console.log(executar(['aquecer água', 'encaixar filtro', 'coar']));

Essa passagem fica mais fácil quando você escreve primeiro o que entra, o que cada passo muda e qual saída prova o fim. A lição de entrada, processamento e saída desenvolve exatamente esse desenho.

Missão: entregar uma troca de pneu para outra pessoa executar

Escreva o algoritmo sem código. Inclua ferramentas, condição de segurança, ordem das porcas e critério de término. Depois peça para alguém marcar toda linha em que precisou fazer uma pergunta. Cada pergunta revela uma decisão ausente.

Use este verificador simples para conferir a forma da lista, não a qualidade mecânica do procedimento:

function revisar(passos) {
  return {
    quantidade: passos.length,
    todosComAcao: passos.every((passo) => /^[A-ZÁÉÍÓÚ]/.test(passo)),
    termina: passos.at(-1)?.includes('guardar ferramentas') ?? false,
  };
}

console.log(revisar(['Estacionar em local seguro', 'Trocar a roda', 'Abaixar o carro e guardar ferramentas']));

O critério de sucesso é alguém conseguir simular cada passo sem completar uma lacuna. Depois, transforme a lista em fluxograma e pseudocódigo e compare sua sequência com o mapa do guia de lógica de programação. O percurso completo também aparece na trilha de Lógica.

Antes de considerar a missão pronta, faça uma segunda rodada com outra pessoa. Quem participou da primeira conversa pode ter aprendido suas intenções e passar a completar lacunas sem perceber. Na revisão, marque também pré-condições, estados de erro e a evidência de término. “A roda está presa, o carro voltou ao chão e as ferramentas foram guardadas” é verificável; “terminar o serviço” ainda depende de interpretação. Esse vocabulário objetivo será reutilizado em testes: para cada passo, existe um estado anterior, uma ação e um estado posterior que alguém consegue observar.