Quando comecei a estudar programação, percebi que nem sempre a maior dificuldade estava em escrever JavaScript. Muitas vezes, o verdadeiro desafio era descobrir o que o programa precisava fazer e como organizar os passos para chegar ao resultado.
Lembro de uma atividade do freeCodeCamp em que precisava construir uma pirâmide de asteriscos utilizando laços for em JavaScript.
Parecia uma tarefa simples. Afinal, eu só precisava imprimir alguns asteriscos na tela, certo?
Mas não foi tão simples assim. Precisei pensar na quantidade de espaços, no posicionamento dos asteriscos e nas quebras de linha. Levei aproximadamente duas horas para resolver o exercício.
Foi uma experiência que me ajudou a compreender melhor a importância de organizar a lógica antes de escrever o código.
Esse processo está relacionado aos algoritmos, um dos quatro pilares do pensamento computacional.

Foto ilustrativa: Jakub Zerdzicki / Pexels. Não representa o exercício original do freeCodeCamp.
Diagrama reconstruído para explicar a lógica. Não representa o código original da atividade.
O que é um algoritmo?
Um algoritmo é uma sequência finita de instruções bem definidas, organizada para realizar uma tarefa ou resolver um problema.
Imagine que você precisa preparar uma xícara de café utilizando um filtro de papel. Você separa os materiais, aquece a água, coloca o filtro no suporte, adiciona o pó de café e despeja a água cuidadosamente.
Existe uma sequência de ações para chegar ao resultado desejado. Se você esquecer de colocar o filtro, o resultado poderá ser diferente do esperado.
Na computação, o princípio é semelhante: precisamos descrever instruções suficientemente claras para que possam ser executadas corretamente.
Mas existe uma diferença importante: um algoritmo não precisa ser escrito em uma linguagem de programação. Podemos representá-lo utilizando palavras, desenhos, fluxogramas ou pseudocódigo.
Um algoritmo descreve o procedimento; uma linguagem como JavaScript é uma das formas de implementá-lo.
Por que pensar antes de escrever o código?
Durante meus estudos, desenvolvi o hábito de abrir um editor de texto simples e escrever o que chamo de meu próprio Portugol.
Não é necessariamente o Portugol formal, com todas as regras de sintaxe. É uma maneira pessoal de representar aquilo que estou pensando.
Escrevo cada passo como se já estivesse desenvolvendo o programa, mas sem me preocupar imediatamente com a sintaxe do JavaScript. Isso me ajuda a visualizar o que precisa acontecer.
Quando percebo que alguma parte da lógica não faz sentido, procuro corrigir ali mesmo, antes de começar a implementação.
Para mim, a parte mais trabalhosa costuma ser descobrir a solução e compreender seu funcionamento. Depois que tenho clareza sobre o caminho, transformar esse raciocínio em JavaScript se torna mais fácil.
Essa maneira de trabalhar está relacionada ao pseudocódigo, uma representação de algoritmos que utiliza instruções compreensíveis sem exigir a sintaxe exata de uma linguagem.
Imagine que precisamos verificar se alguém tem pelo menos 18 anos. Antes de programar, poderíamos escrever:
- Receber a idade.
- Verificar se a idade é maior ou igual a 18.
- Se for, informar que a entrada é permitida.
- Caso contrário, informar que a entrada não é permitida.
Ainda não escrevemos JavaScript, mas já descrevemos o caminho que o programa deverá seguir. Isso não garante que a implementação estará correta, mas oferece uma estrutura para orientar o desenvolvimento e os testes.
Como organizei a lógica de uma pirâmide de asteriscos
Na atividade do freeCodeCamp, eu precisava construir uma pirâmide utilizando asteriscos e laços de repetição.
Não guardei o código original, mas lembro da maneira como procurei resolver o problema. Comecei pela linha da base e fui pensando nas linhas superiores, uma de cada vez, até chegar ao asterisco central no topo. Se não me engano, eram quatro linhas.
O que realmente me ajudou foi conseguir visualizar cada etapa separadamente.
Para demonstrar o raciocínio, podemos reconstruir uma pirâmide de quatro linhas:
*
***
*****
*******
Esse desenho é um exemplo didático reconstruído, não uma cópia do meu código original.
Observe que a primeira linha possui um asterisco, enquanto a última possui sete. A quantidade de espaços à esquerda diminui conforme descemos pela pirâmide.
Se começarmos pela base, como fiz no meu planejamento, observamos: zero espaços e sete asteriscos; depois um espaço e cinco asteriscos; depois dois espaços e três asteriscos; por fim, três espaços e um asterisco.
Existe um padrão: a cada linha que subimos, acrescentamos um espaço à esquerda e retiramos dois asteriscos.
Foi justamente essa visualização, linha por linha, que me ajudou durante o exercício.
Como transformar esse raciocínio em um algoritmo?
Agora que compreendemos o formato da pirâmide, podemos organizar uma solução.
Vamos escolher construir a pirâmide do topo para a base, embora meu planejamento original tenha começado pela base. Essa escolha facilita demonstrar como um programa pode gerar as linhas na ordem em que aparecem na tela.
Primeiro, definimos que a pirâmide terá quatro linhas. Depois, para cada linha, precisamos descobrir quantos espaços e asteriscos serão necessários.
Contando as linhas a partir de um, a quantidade de espaços é o total de linhas menos a linha atual. A quantidade de asteriscos é duas vezes o número da linha, menos um.
Com isso, conseguimos descrever o algoritmo:
Definir a quantidade de linhas como 4
Para cada linha, começando em 1:
Calcular a quantidade de espaços
Calcular a quantidade de asteriscos
Construir o texto da linha
Exibir a linha
Observe que ainda não precisamos conhecer todos os detalhes do JavaScript. Primeiro compreendemos a solução. Depois escolhemos as instruções da linguagem que permitirão executá-la.
Transformando o algoritmo em JavaScript
Agora podemos implementar o exemplo utilizando um laço for.
const totalLinhas = 4;
for (let linha = 1; linha <= totalLinhas; linha++) {
const espacos = totalLinhas - linha;
const asteriscos = 2 * linha - 1;
const resultado =
" ".repeat(espacos) + "*".repeat(asteriscos);
console.log(resultado);
}
O método repeat() repete espaços e asteriscos de acordo com a quantidade calculada. O laço for controla qual linha está sendo construída.
Na primeira repetição, linha vale 1. O programa calcula três espaços e um asterisco. Na segunda, calcula dois espaços e três asteriscos. O processo continua até a quarta linha.
O resultado esperado é a pirâmide que desenhamos anteriormente.
Esse exemplo foi reconstruído para explicar o conceito. Não é o código que escrevi na atividade original do freeCodeCamp.
O JavaScript não criou a solução por conta própria. Antes de escrever o programa, precisamos definir como calcular os espaços, como calcular os asteriscos e quando encerrar a repetição.
O código implementa o algoritmo que planejamos.
O que acontece quando a lógica está errada?
Imagine que, ao calcular a quantidade de asteriscos, esquecemos de subtrair um. Em vez de utilizar duas vezes o número da linha menos um, utilizamos apenas duas vezes o número da linha.
O programa ainda poderá executar normalmente, mas o desenho terá uma quantidade diferente de asteriscos.
Um programa pode executar sem erros de sintaxe e, mesmo assim, produzir um resultado incorreto.
Por isso, não basta verificar se o JavaScript consegue executar as instruções. Também precisamos observar se o resultado corresponde ao que planejamos.
Durante meu exercício, utilizei meu pseudocódigo pessoal para organizar o raciocínio e corrigir os passos que não faziam sentido.
Na programação, investigar e corrigir erros é uma atividade relacionada à depuração, também chamada de debugging.
Podemos testar um algoritmo com diferentes entradas, comparar os resultados e verificar se suas instruções realmente resolvem o problema.
No exemplo da pirâmide, poderíamos experimentar construir uma, duas ou cinco linhas. Se a solução funcionar apenas para quatro linhas, talvez exista alguma suposição no código que precise ser revista.
Algoritmo, lógica de programação e linguagem são a mesma coisa?
Esses conceitos estão relacionados, mas não são iguais.
O algoritmo descreve o procedimento utilizado para resolver um problema.
A lógica de programação envolve o raciocínio utilizado para construir e organizar esse procedimento, incluindo decisões, condições e repetições.
A linguagem de programação fornece recursos e sintaxe para implementar esse procedimento em um programa.
Na pirâmide, o algoritmo determina como calcular e organizar as linhas. A lógica permite compreender as relações entre espaços, asteriscos e repetições. O JavaScript oferece instruções como for, operadores matemáticos e métodos de texto para implementar a solução.
Uma mesma ideia algorítmica pode ser implementada em diferentes linguagens, embora cada linguagem tenha suas particularidades.
Por isso, aprender JavaScript e aprender a resolver problemas são atividades que se complementam.
O que aprendi com essa experiência?
A atividade da pirâmide me ensinou algo que continuo aplicando durante meus estudos.
Quando encontro um problema de programação, gosto de organizar primeiro o raciocínio. Utilizo um editor de texto, escrevo meu próprio pseudocódigo e procuro compreender cada etapa antes de transformar tudo em JavaScript.
Naquele exercício do freeCodeCamp, levei aproximadamente duas horas para chegar à solução.
Hoje, conhecendo o caminho que utilizei, acredito que conseguiria resolver um exercício semelhante em aproximadamente trinta minutos, mesmo sem consultar o código anterior. Essa é uma estimativa pessoal, não o resultado de um novo teste.
O que mudou foi minha compreensão do problema.
Antes, precisava descobrir como construir cada linha. Depois, já sabia quais relações observar e como organizar as instruções.
Também percebi como os pilares do pensamento computacional podem trabalhar juntos.
Ao separar a pirâmide em linhas, utilizei a ideia de decomposição. Ao observar a mudança na quantidade de espaços e asteriscos, trabalhei com reconhecimento de padrões. Ao focar nas informações necessárias para construir cada linha, apliquei abstração. E, ao organizar as instruções para gerar o desenho, construí um algoritmo.
Essa experiência reforçou algo importante para mim: aprender uma linguagem de programação não significa apenas memorizar comandos.
Também precisamos aprender a pensar sobre o problema, compreender suas partes e organizar uma solução que possamos explicar e verificar.
Porque, quando entendo o caminho que preciso seguir, escrever o código deixa de ser uma tentativa às cegas e passa a ser a implementação de uma ideia que já consigo compreender.
Teste seus conhecimentos
Você acertou 0 de 0 respondidos.