Pensamento computacional e resolução de problemas

Um computador pode calcular uma rota, reproduzir um som ou organizar uma lista de nomes. A ciência da computação estuda os processos por trás dessas tarefas: como a informação é representada e tratada, quais problemas podem ser resolvidos e como construir sistemas que executam as soluções.

Descreva uma computação

Um modelo inicial útil é entrada → processo → saída. Um planejador de rotas recebe um ponto de partida e um destino. Ele busca informações sobre vias e retorna uma rota, uma distância em quilômetros e um tempo de viagem. As informações sobre as vias também são dados necessários ao processo. O resultado visível é apenas uma parte da computação.

Defina um problema computacional antes de escolher seu método. Por exemplo: “Entrada: uma lista de nomes. Saída: os mesmos nomes em ordem alfabética.” Isso especifica como deve ser um resultado correto. Deixa espaço para diferentes métodos de produzi-lo. Se a saída omitir um nome, ela não resolve o problema, mesmo quando os nomes restantes estão ordenados.

Além de escrever código

Programação é escrever instruções em uma linguagem que um computador possa executar. É uma atividade importante dentro da ciência da computação. A área mais ampla também investiga se uma solução existe, quanto trabalho ela exige e como as pessoas podem usá-la com segurança e facilidade.

As fronteiras se sobrepõem. Projetar um editor de imagens pode envolver computação gráfica, interação com o usuário e engenharia de software ao mesmo tempo. A computação também dá suporte a outras disciplinas: biólogos comparam sequências de DNA, cientistas do clima modelam a atmosfera e artistas usam software para criar imagens e música.

Áreas relacionadas e limites práticos

A engenharia de computação concentra-se em dispositivos físicos, como processadores e placas de circuito. A tecnologia da informação, ou TI, concentra-se em escolher, configurar e operar sistemas para uma organização. A ciência de dados combina estatística e computação para tirar conclusões a partir de dados. Essas áreas compartilham métodos com a ciência da computação, mas dão ênfase a trabalhos diferentes.

Computadores executam instruções precisas rapidamente, muitas vezes bilhões de operações simples por segundo. A velocidade não corrige uma instrução pouco clara. “Adicione um pouco de sal” deixa uma quantidade indefinida; um processo destinado à execução automática precisa de uma ação precisa.

Também há limites além da velocidade. Alguns problemas definidos com precisão não têm solução algorítmica. Outros problemas têm soluções que exigem passos demais para serem viáveis. Perguntar o que um computador pode realizar faz parte da própria ciência da computação.

O pensamento computacional torna um problema claro o suficiente para ser resolvido passo a passo. Uma pessoa pode executar a solução, um computador pode executá-la ou os dois podem dividir o trabalho. O raciocínio inclui decidir o que o problema significa e como um resultado deve ser conferido.

Quatro técnicas que funcionam em conjunto

A decomposição divide um problema em partes menores. O reconhecimento de padrões encontra semelhanças ou trabalho repetido. A abstração mantém os detalhes necessários para um objetivo e deixa outros de fora. A elaboração de algoritmos transforma uma solução em passos precisos e ordenados.

Essas técnicas são ferramentas às quais você pode recorrer conforme necessário. Elas não são quatro etapas que precisam ser concluídas em uma ordem fixa. Um teste malsucedido pode revelar um subproblema ausente. Um subproblema repetido pode sugerir um procedimento reutilizável. Um modelo pode precisar de mais um detalhe antes que o algoritmo funcione.

Jeannette Wing ajudou a divulgar amplamente o termo “pensamento computacional” em um ensaio de 2006. Sua mensagem central era que essa abordagem é útil para todos, além das pessoas que trabalham como programadoras.

Entenda, planeje, execute e confira

O matemático George Pólya descreveu quatro etapas de resolução de problemas em 1945. Na computação, elas levam a ações concretas:

1. Entenda o problema. Identifique entradas, saídas, restrições e critérios de sucesso.
2. Faça um plano. Escolha tarefas menores, padrões úteis e um algoritmo.
3. Execute o plano. Expresse-o e execute-o com pseudocódigo, um fluxograma ou um programa.
4. Reveja. Compare o resultado com os critérios de sucesso e revise a solução quando necessário.

Uma restrição é uma regra que a solução deve respeitar, como um tempo máximo disponível. Um critério de sucesso é uma forma de julgar o resultado. “Produzir uma lista de compras combinada com as quantidades necessárias” pode ser conferido. “Melhorar as compras” deixa o resultado pouco claro.

Resolva um plano de refeições

Suponha que você precise de jantares para uma semana. As entradas incluem as receitas, a quantidade de pessoas e os alimentos já disponíveis. A saída é um plano e uma lista de compras. Necessidades alimentares e tempo disponível para cozinhar são restrições.

Decomponha o trabalho em escolher as refeições, fazer a lista e cozinhar. O reconhecimento de padrões mostra que várias receitas usam arroz e cebola. A abstração representa um ingrediente por seu nome e sua quantidade, como “arroz, 1 kg”, sem manter a marca quando ela não afeta o plano.

O algoritmo de compras pode agora ser ordenado: escolher as refeições, listar seus ingredientes, combinar os ingredientes repetidos, subtrair o que já está na despensa e comprar o que resta. Combinar as quantidades antes de conferir a despensa evita que o mesmo estoque seja subtraído separadamente para cada receita.

Confira o resultado em relação às refeições. Todo ingrediente necessário deve estar disponível em quantidade suficiente. Se um ingrediente estiver faltando, rastreie como a lista foi criada e revise o passo correspondente.

Uma falha comum é começar a programar antes de decidir qual resultado é necessário. Um programa rápido pode resolver fielmente o problema errado. As pessoas continuam escolhendo o modelo, as restrições e os passos; o computador executa as instruções que expressam essas escolhas.

Um problema grande pode ser difícil de manter em mente por inteiro. A decomposição o substitui por subproblemas menores que você pode compreender, resolver e conferir separadamente. As partes ainda precisam se combinar em uma solução para o problema original.

Trabalhe do todo aos detalhes

Comece pela tarefa principal. Divida-a em algumas responsabilidades significativas e depois detalhe cada responsabilidade. Isso é decomposição descendente. Um diagrama de decomposição em forma de árvore coloca o problema completo no topo e as tarefas menores abaixo dele. Os ramos mostram a qual tarefa uma tarefa menor pertence.

Para um aplicativo de perguntas e respostas, as partes principais são armazenar perguntas e respostas, fazer perguntas, verificar respostas e manter e mostrar a pontuação. A parte “fazer uma pergunta” pode ser dividida em mostrar o texto da pergunta, mostrar as opções de resposta e ler a escolha do aluno.

Um diagrama de estrutura textual poderia ser assim:

Run a quiz
    Store questions and answers
    Ask a question
        Show question text
        Show answer options
        Read the choice
    Check the answer
    Keep and show the score

Esses ramos descrevem responsabilidades. Sua posição vertical, por si só, não fornece a ordem completa de execução. Por exemplo, o aplicativo repete as perguntas e verificações enquanto restarem perguntas. Um algoritmo separado descreve esse fluxo.

Decida quando parar de dividir

Uma parte é pequena o suficiente quando você consegue ver como resolvê-la diretamente ou quando um método ou uma ferramenta existente dá conta dela. “Ler a escolha” pode ser uma tarefa utilizável quando você sabe como a interface coleta a entrada. Dividi-la em movimentos individuais das mãos acrescentaria detalhes que não ajudam a projetar o aplicativo.

Faça primeiro a divisão principal. Se você começar descrevendo ações minúsculas, é fácil gastar tempo em uma tela enquanto esquece uma responsabilidade inteira, como decidir quando o jogo termina.

Identifique dependências

Uma dependência significa que uma tarefa precisa do resultado de outra. O aplicativo precisa obter uma escolha antes de verificá-la e verificá-la antes de atualizar a pontuação. Anote o que cada parte recebe e produz. Isso esclarece as passagens de informação.

As partes devem ser tão independentes quanto possível. Se a tela mudar de quatro botões de resposta para outro método de entrada, o cálculo da pontuação ainda deve funcionar com o resultado verificado. Limites claros permitem que as pessoas construam partes separadas ao mesmo tempo e facilitam alterações posteriores.

Independência não significa que as partes nunca troquem informações. Elas precisam de entradas e saídas acordadas. Uma parte que calcula a pontuação e espera TRUE ou FALSE não pode usar diretamente o texto bruto de uma parte que exibe perguntas sem um passo que verifique a resposta.

Procure lacunas e sobreposições

Leia o problema original novamente e pergunte se concluir todas as partes terminaria o trabalho completo. O primeiro diagrama não mostra quando o jogo para. Acrescente essa responsabilidade ao controle geral do jogo. Pergunte também se duas partes alteram a pontuação, o que poderia contar uma resposta correta duas vezes.

Confira cada parte pequena separadamente e depois confira o processo combinado. Uma exibição de pergunta correta e um verificador de resposta correto ainda podem falhar juntos se um enviar um formato de escolha diferente do que o outro espera.

O trabalho repetido muitas vezes esconde um método reutilizável. Reconhecimento de padrões significa buscar semelhanças, repetições ou tendências dentro de um problema e entre problemas diferentes. A pergunta útil é o que permanece igual e o que muda.

Encontre repetições dentro de uma tarefa

Para desenhar um quadrado, uma caneta em movimento pode avançar 100 passos e girar à direita 90 graus, quatro vezes. O par de ações se repete. Um laço expressa esse par uma vez e fornece a quantidade de repetições:

REPEAT 4 TIMES
    Move forward 100 steps
    Turn right 90 degrees

Esse padrão facilita a visualização da estrutura. Também facilita uma mudança: alterar a distância de avanço em um lugar muda todos os lados.

Substitua detalhes variáveis por parâmetros

A generalização faz uma solução funcionar para uma família de casos. Um parâmetro é uma entrada nomeada que representa um detalhe que pode mudar. Para polígonos regulares, a quantidade e o comprimento dos lados podem ser parâmetros.

Uma caneta que percorre um polígono regular gira uma volta completa. O giro em cada vértice é:

Aqui, $n$ é a quantidade de lados. Repita o par de ações avançar e girar $n$ vezes, mantendo o mesmo comprimento de lado e o mesmo giro a cada vez.

O giro é a mudança na direção da caneta, não o ângulo interno do polígono. Para um triângulo, usar um giro de 60 graus não produziria o percurso pretendido de três lados.

Reconheça o mesmo método em problemas diferentes

Encontrar o voo mais barato, a rota mais curta e a nota mais alta em uma prova envolve guardar o melhor candidato visto até então. Comece com um candidato. Examine cada candidato seguinte e substitua o guardado quando o novo for melhor. O sentido da comparação muda entre o menor e o maior, mas o padrão geral continua útil.

Padrões também podem organizar dados. Agrupar despesas em alimentação, transporte e moradia torna características comuns visíveis. Se as vendas de guarda-chuvas aumentam repetidamente quando há previsão de chuva, uma loja pode usar a tendência para ajudar a planejar o estoque. Uma tendência é uma evidência a ser examinada; a razão pela qual ela ocorre importa ao decidir se continuará.

Confira o padrão proposto

Os números 1, 2, 4 não determinam um único próximo número. Dobrar fornece 8. Aumentar as diferenças em uma unidade fornece 7, pois as diferenças até então são 1 e 2. São necessários mais casos ou uma regra que explique a sequência para decidir qual padrão se ajusta ao problema.

Procure diferenças relevantes antes de reutilizar uma solução. Dividir uma conta igualmente e dividi-la conforme o que cada pessoa pediu envolvem um total compartilhado. A divisão igual resolve a primeira tarefa, mas a segunda precisa do pedido de cada pessoa. Reutilize a estrutura comum somente depois de identificar o detalhe que muda o resultado necessário.

Um modelo pode ser mais simples que o objeto real e ainda ser útil. A abstração mantém as informações necessárias para um objetivo específico e deixa outros detalhes de fora. Sua qualidade depende de conseguir responder às perguntas feitas pela tarefa.

Escolha um modelo para a tarefa

Um mapa de metrô mantém as estações, sua ordem ao longo de cada linha e os lugares onde as linhas se conectam. Esses detalhes ajudam um passageiro a planejar uma viagem. Ele pode distorcer distâncias e omitir o traçado das ruas porque seu objetivo principal é mostrar conexões.

Esse mesmo mapa é uma ferramenta ruim para decidir a distância a caminhar entre duas estações. O modelo deixou de fora um detalhe necessário para o novo objetivo. Um detalhe é relevante por causa do problema, não por ser interessante em geral.

Considere dois modelos do mesmo carro:

O jogo de corrida precisa atualizar o movimento. O estacionamento precisa identificar o carro e acompanhar sua permanência. Nenhum dos modelos precisa preservar todas as características físicas do carro.

Oculte passos por trás de um nome claro

A abstração também permite usar o que um componente faz sem pensar em como ele funciona a cada vez. Selecionar um programa de máquina de lavar não exige que você controle seu motor diretamente.

Em um algoritmo, um procedimento é um grupo nomeado de passos. Chamar o nome executa esses passos. Um nome como average(list) comunica uma tarefa enquanto oculta os cálculos repetidos. Um procedimento que envia um resultado de volta a quem o chamou retorna um valor. Quem o chamou pode armazenar esse valor ou usá-lo em outro cálculo.

Um parâmetro dá a um procedimento uma entrada que pode mudar. drawPolygon(sides, length) tem dois parâmetros. A chamada drawPolygon(6, 100) fornece seis lados e um comprimento de 100 passos. Isso combina abstração, que oculta os passos do desenho, com generalização, que permite diferentes formas e tamanhos.

Os limites de um procedimento precisam ser claros: quais entradas ele aceita e qual resultado ou ação produz? Para uma média, uma lista vazia precisa de tratamento especial porque não há quantidade pela qual dividir. Ocultar passos não elimina a necessidade de definir entradas utilizáveis.

Construa camadas de compreensão

Um aplicativo de conversa oferece uma forma de enviar uma mensagem. Abaixo dele, o sistema operacional oferece serviços que o aplicativo pode usar. Abaixo disso, o hardware executa operações. Cada camada depende do comportamento da camada seguinte sem expor todos os detalhes internos ao seu usuário. Uma mudança interna pode ficar restrita à própria camada quando o comportamento prometido permanece igual.

As técnicas se apoiam mutuamente. A decomposição identifica partes. O reconhecimento de padrões encontra partes com uma estrutura comum. A abstração dá nomes e limites claros a essas partes para que possam ser combinadas.

Um erro comum de abstração é excluir um fato que altera a possibilidade de um resultado funcionar. Um planejador de rotas que ignora ruas de mão única pode propor um percurso impossível de fazer. Para conferir um modelo, liste as decisões que ele deve apoiar e confirme se os dados mantidos são suficientes para cada uma.

Um algoritmo é um conjunto finito e ordenado de instruções precisas para resolver um problema ou executar uma tarefa. Para uma entrada válida, ele produz a saída necessária após uma quantidade finita de passos. Uma receita, instruções de montagem e a divisão longa usam essa ideia.

Confira as propriedades do método

Um algoritmo útil tem entradas e saídas definidas. Cada passo deve ser preciso o suficiente para ter um significado e executável o suficiente para ser realizado. Os passos devem terminar, e seu resultado deve estar correto para toda entrada válida.

“Encontre o maior número” indica um objetivo, mas não especifica um método. “Examine cada número e guarde o maior visto até então” fornece um método que pode ser desenvolvido em instruções. Também levanta uma pergunta sobre a entrada: o que deve acontecer se a lista estiver vazia? Definir entradas válidas evita deixar o método incompleto.

Instruções cotidianas podem deixar lacunas que as pessoas preenchem com a experiência. “Coloque a geleia no pão” deixa de fora a abertura do pote e o ato de espalhar uma quantidade em uma superfície. Ao elaborar um método para execução automática, declare as ações necessárias ao sistema que o executa e coloque-as em uma ordem utilizável.

Separe o método de sua expressão

Um algoritmo é o método de solução. Um programa expressa um método em uma linguagem de programação para que um computador possa executá-lo. O mesmo algoritmo pode aparecer em pseudocódigo, em um fluxograma e em programas escritos em linguagens diferentes.

Três estruturas de controle organizam a execução:

Junto com variáveis, essas estruturas são suficientes para expressar qualquer algoritmo. Essa é a ideia por trás de um resultado clássico publicado por Böhm e Jacopini em 1966. Um algoritmo pode combiná-las: percorrer uma lista repetidamente, testar cada valor e atualizar um resultado armazenado em sequência.

Compare métodos corretos

Suponha que uma lista telefônica em ordem alfabética tenha 1.000 páginas. Conferir uma página por vez pode exigir 1.000 verificações. Virar duas páginas por vez e conferir apenas uma página sim e outra não exige até cerca de 500 verificações, mais um passo para trás se o nome tiver sido ultrapassado.

Um método diferente abre a seção restante no meio e mantém a metade que pode conter o nome. No máximo 10 divisões ao meio reduzem 1.000 páginas possíveis a uma:

1000 → 500 → 250 → 125 → 63 → 32
     → 16 → 8 → 4 → 2 → 1

A ordem alfabética torna seguro descartar uma metade. Sem essa ordem, a metade descartada poderia conter o nome. Essa suposição sobre a entrada faz parte do método.

Para 2.000 páginas, conferir todas as páginas pode exigir o dobro de verificações, enquanto o método de divisão ao meio exige apenas mais uma divisão: 11. Comparar como a quantidade de passos cresce explica mais do que medir o tempo de uma execução em uma máquina.

Confira a correção antes de elogiar a velocidade. Um método que examina apenas o primeiro e o último número de uma lista encontra 12 em [7, 3, 12] por acaso. Ele não encontra 12 em [7, 12, 3]. Um exemplo bem-sucedido não pode estabelecer que o método trata toda a faixa de entradas.

O pseudocódigo descreve um algoritmo com instruções estruturadas e legíveis. Ele não está preso a uma linguagem de programação. Permite trabalhar na lógica antes de lidar com a pontuação e outras regras de escrita de uma linguagem.

Leia a notação

As palavras-chave são escritas em maiúsculas: INPUT, OUTPUT, IF, WHILE e FOR. Cada instrução tem sua própria linha. A indentação mostra quais instruções pertencem a um bloco. Um comentário começa com // e explica o código sem acrescentar uma ação.

A seta ← significa atribuição. Alguns outros estilos de pseudocódigo usam = ou SET … TO para atribuição. Aqui, = compara valores. Leia count ← 0 como “count recebe zero”. Uma variável é um local nomeado que armazena um valor que pode mudar. Uma constante tem um nome, mas mantém o mesmo valor, como PASS_MARK ← 50.

O lado direito de uma atribuição é avaliado primeiro. Seu resultado substitui o valor antigo à esquerda. Se count contém 4, count ← count + 1 lê o 4 antigo, soma 1 e armazena 5. É uma instrução para alterar dados armazenados, não uma equação que afirma que um número é igual a si mesmo mais um.

Relacione dados a operações

Somar os números 12 e 3 resulta em 15. Juntar as cadeias “12” e “3” resulta em “123”. Escolha nomes descritivos, como temperature e total, para que a função de um valor continue visível.

Os operadores aritméticos incluem +, −, * e /. DIV fornece o quociente inteiro, enquanto MOD fornece o resto. Assim, 17 DIV 5 é 3 e 17 MOD 5 é 2. O teste n MOD 2 = 0 identifica um número inteiro par. Comparações como =, ≠, <, >, ≤ e ≥ produzem valores booleanos.

Leia, calcule e exiba

INPUT minutes
hours ← minutes DIV 60
rest ← minutes MOD 60
OUTPUT hours, "h", rest, "min"

Para 135 minutos, dois grupos completos de 60 usam 120 minutos, restando 15. A saída é “2 h 15 min”. INPUT recebe dados, as duas atribuições os processam e OUTPUT envia o resultado.

Preserve um valor antes de substituí-lo

Suponha que a contenha 5 e b contenha 8. As instruções a ← b e depois b ← a deixam ambas as variáveis com 8. A primeira instrução sobrescreveu a única cópia armazenada de 5.

Use uma variável temporária:

temp ← a
a ← b
b ← temp

Após a primeira linha, temp contém 5. A segunda linha coloca 8 em a. A terceira coloca o 5 guardado em b. A atribuição copia um valor atual; ela não cria uma ligação permanente entre variáveis.

Dê a cada variável um valor inicial antes de lê-la. Um total acumulado precisa de total ← 0 antes de sua primeira adição. Colocar a atribuição depois da adição deixa o primeiro passo sem um valor inicial definido.

A seleção escolhe quais instruções são executadas. Uma condição é uma expressão com o valor TRUE ou FALSE. A comparação score ≥ 50 pergunta se a pontuação atual é pelo menos 50.

Use IF e ELSE

IF score ≥ 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
END IF

Exatamente um ramo é executado. Com 50, a condição é TRUE e a saída é “Pass”. Com 49, ela é FALSE e a saída é “Fail”. Um IF sem ELSE simplesmente pula seu bloco quando sua condição é FALSE.

A comparação deve corresponder à regra. “Pelo menos 50” inclui 50, portanto precisa de ≥. Usar > rejeitaria essa nota no limite. Testar valores no limite é uma maneira direta de detectar esse erro.

Ordene vários casos

Uma cadeia ELSE IF verifica condições em ordem e executa o primeiro ramo cuja condição é satisfeita:

IF temperature ≥ 30 THEN
    OUTPUT "Hot"
ELSE IF temperature ≥ 20 THEN
    OUTPUT "Warm"
ELSE IF temperature ≥ 10 THEN
    OUTPUT "Mild"
ELSE
    OUTPUT "Cold"
END IF

Para 24 °C, o primeiro teste falha e o segundo é satisfeito. A saída é “Warm”. Para 10 °C, o terceiro ramo é executado. Para −3 °C, o ELSE final é executado.

Uma temperatura de 35 °C satisfaz as três comparações escritas, mas somente o primeiro ramo cuja condição é satisfeita é executado. Se temperature ≥ 10 viesse primeiro, ele incluiria 35 e apresentaria “Mild”. Ao usar limites sobrepostos de “pelo menos”, teste primeiro o maior. Os ramos inferiores tratam então os valores que não satisfizeram os limites superiores.

Combine condições

Para incluir temperaturas de 10 °C até um valor inferior a 20 °C, use temperature ≥ 10 AND temperature < 20. Os dois limites devem ser respeitados. Em 15, ambos são TRUE. Em 20, o segundo é FALSE.

Usar OR para esse intervalo resulta em temperature ≥ 10 OR temperature < 20. Isso aceita qualquer número: um valor abaixo de 10 ainda satisfaz a segunda parte, enquanto qualquer valor de pelo menos 10 satisfaz a primeira. OR é útil quando qualquer um dos caminhos basta, não quando dois limites devem ser respeitados ao mesmo tempo.

Coloque uma decisão dentro de outra

Um IF aninhado coloca uma decisão dentro de um ramo de outra. Você pode primeiro verificar se uma senha é longa o suficiente e depois, dentro do ramo de sucesso, verificar se ela contém um dígito. A decisão interna só é alcançada quando a condição externa permite.

Indente o bloco interno para que os caminhos fiquem visíveis. Se várias decisões aninhadas tornarem uma regra simples difícil de ler, considere combinar condições com AND ou usar uma cadeia ELSE IF. Rastreie um valor pela ordem real antes de supor que todos os testes escritos serão alcançados.

A iteração repete um bloco de instruções. Um laço permite expressar o trabalho repetido uma vez, mas você ainda precisa decidir quando ele começa, quando termina e quais valores mudam em cada passada.

Escolha como a repetição é controlada

Um laço FOR é adequado quando a quantidade de repetições é conhecida. Um laço controlado por condição é adequado para uma tarefa cujo ponto de parada depende de valores ou de uma nova entrada. O corpo de um WHILE pode ser executado zero vezes. O corpo de um REPEAT … UNTIL com teste no final é executado pelo menos uma vez.

Rastreie uma contagem regressiva

n ← 3
WHILE n > 0 DO
    OUTPUT n
    n ← n − 1
END WHILE
OUTPUT "Go!"

No primeiro teste, n é 3. O laço apresenta 3 e muda n para 2. As passadas seguintes apresentam 2 e 1. Após a atualização de 1 para 0, o teste é FALSE. A execução sai do laço e apresenta “Go!”.

Remover a atualização deixa n em 3, de modo que o laço nunca alcança seu estado de parada. Um laço que deve terminar precisa de uma maneira de mudar a condição: uma atualização interna ou uma nova entrada pode fornecê-la.

Acumule um total e conte elementos

Um acumulador constrói um resultado ao longo de várias passadas. Um contador registra quantas vezes algo ocorre. Para encontrar a média das temperaturas diárias 18, 21, 19, 22 e 20 °C:

total ← 0
count ← 0
FOR EACH t IN temperatures
    total ← total + t
    count ← count + 1
END FOR
OUTPUT total / count

Os totais sucessivos são 18, 39, 58, 80 e 100. A contagem termina em 5, portanto a média é 20 °C. Inicialize as duas variáveis antes do laço. Reiniciar total dentro dele apagaria as adições anteriores. Uma lista vazia precisa de uma verificação separada antes da divisão porque sua contagem é zero.

Guarde o melhor valor até então

Para uma lista não vazia, inicialize largest com o primeiro elemento. Depois, examine cada valor e substitua largest sempre que aparecer um valor maior:

largest ← first item of list
FOR EACH value IN list
    IF value > largest THEN
        largest ← value
    END IF
END FOR
OUTPUT largest

Para [7, 3, 12, 5], o melhor valor guardado continua em 7, passa a 12 e permanece em 12. Começar em zero falha para uma lista como [−4, −9, −2], cujo maior valor é −2. Zero nunca foi um candidato.

Confira a primeira e a última passada

Um erro de uma unidade acrescenta ou elimina uma repetição. FOR i ← 0 TO 5 é executado seis vezes. Na contagem regressiva, n ≥ 0 também apresentaria zero. Escreva o primeiro e o último valor da variável de controle para conferir a contagem.

Laços aninhados repetem um laço dentro de outro. Para 3 linhas e 4 colunas, o bloco interno é executado quatro vezes para cada linha, totalizando 12 execuções. O laço interno recomeça a cada passada do laço externo.

Um fluxograma desenha um algoritmo como formas conectadas por setas. As formas identificam tipos de passos, e as setas mostram qual passo é executado em seguida. Um fluxograma curto torna um processo visível para alguém que talvez não leia código.

Escolha uma forma para cada função

Os principais símbolos seguem a ISO 5807. Eles têm funções distintas:

Uma linha de fluxo tem uma seta que mostra a direção. A direção usual de leitura é de cima para baixo e da esquerda para a direita, mas a seta determina o próximo passo real. Uma linha que retorna a um ponto anterior pode mostrar repetição.

Construa uma sequência simples

Para calcular a área de uma sala retangular, use estes cinco símbolos em ordem:

1. Início ou fim: “Início”.
2. Entrada e saída: “Entrada: comprimento, largura”.
3. Processamento: area ← length * width.
4. Entrada e saída: “Saída: área”.
5. Início ou fim: “Fim”.

Conecte cada passo ao seguinte com uma seta. Com comprimento de 4,5 m e largura de 3 m, o cálculo fornece 13,5 metros quadrados. Ler a entrada não calcula a área; isso pertence ao seu próprio retângulo de processamento. Exibir a área pertence ao paralelogramo de saída.

Esse fluxograma não tem escolha nem caminho repetido. É uma sequência pura, e sua forma deixa a ordem clara.

Siga uma decisão usando os valores atuais

Um losango faz uma pergunta ou testa um valor. Para uma pergunta de sim ou não, como score ≥ 50?, identifique as saídas como “Sim” e “Não”. Determine o resultado da condição usando a nota atual e siga exatamente uma seta correspondente.

Uma decisão pode ter mais de duas saídas possíveis quando testa vários valores distintos. Identifique cada saída com o valor ou caso que ela representa. O objetivo das identificações é tornar o próximo passo inequívoco.

Uma ação como count ← count + 1 pertence a um retângulo de processamento. Uma pergunta como count < 5? pertence a um losango de decisão. Misturar essas funções oculta se um valor está sendo alterado ou testado.

Confira as conexões

Um fluxograma claro tem um início e pelo menos um fim. Cada símbolo de processamento e de entrada e saída tem uma linha de fluxo de saída. Cada decisão de sim ou não tem duas saídas identificadas. Siga cada caminho para conferir se ele alcança o próximo passo pretendido ou o fim.

Evite deixar um ramo sem continuação após sua saída. Se ambos os ramos devem continuar no mesmo passo, desenhe-os se unindo antes desse passo. Use conectores identificados quando linhas longas ou cruzadas dificultarem a leitura da página. Um símbolo de processo predefinido permite que um procedimento grande fique em um fluxograma separado enquanto o principal mantém sua estrutura geral.

Pseudocódigo e fluxogramas podem expressar o mesmo algoritmo. Converter entre eles significa preservar a ordem das ações, as condições e todos os caminhos pelo processo. Um diagrama organizado com um teste em outra posição descreve um algoritmo diferente.

Mostre uma escolha e reúna os caminhos

Para uma nota mínima de aprovação de 50, desenhe um losango identificado por score ≥ 50?. Sua saída Sim leva a um paralelogramo de saída identificado como “Aprovado”. Sua saída Não leva a um identificado como “Reprovado”. Reúna os caminhos antes do fim.

Em pseudocódigo, esses caminhos tornam-se os ramos IF e ELSE. O ponto em que se unem novamente corresponde à primeira instrução após END IF. O fluxograma não deve enviar a saída Aprovado para a saída Reprovado; apenas uma delas pertence a cada execução.

Coloque o teste no lugar certo

Um laço tem um caminho de volta a um passo anterior e uma decisão que controla se a repetição continua. Para um laço WHILE, coloque a decisão antes do corpo. A saída FALSE passa ao largo do corpo, portanto zero passadas são possíveis.

Para um REPEAT … UNTIL com teste no final, coloque a decisão depois do corpo. Sua saída FALSE retorna ao corpo e sua saída TRUE sai do laço. O corpo é executado pelo menos uma vez porque a execução o alcança antes do primeiro teste.

Resolva um acesso com três tentativas

attempts ← 0
REPEAT
    INPUT password
    attempts ← attempts + 1
UNTIL password = storedPassword OR attempts = 3
IF password = storedPassword THEN
    OUTPUT "Welcome"
ELSE
    OUTPUT "Account locked"
END IF

Comece o fluxograma com Início e um retângulo de processamento para attempts ← 0. Em seguida, desenhe o paralelogramo de entrada da senha e depois o retângulo de incremento. O losango do laço pergunta “Senha correta OU tentativas = 3?”. Sua saída Não retorna à entrada da senha. Sua saída Sim sai do laço.

A condição de saída dá duas possíveis razões para a parada, portanto não pode, por si só, escolher a mensagem final. Acrescente um segundo losango perguntando se a senha está correta. Sim leva a “Boas-vindas”; Não leva a “Conta bloqueada”. Em uma terceira tentativa correta, o laço para e o ramo de senha correta ainda recebe o usuário com boas-vindas.

Converta seguindo os caminhos

Do pseudocódigo para um fluxograma, transforme cada atribuição em um retângulo e cada entrada ou saída em um paralelogramo. Transforme os testes de ramos e laços em losangos. Conecte o corpo de volta à decisão que o controla, na posição correta.

De um fluxograma para pseudocódigo, examine aonde levam os caminhos de cada losango. Caminhos que executam alternativas e voltam a se unir sugerem seleção. Um caminho que retorna a um trabalho anterior sugere iteração. Indente cada corpo de acordo com seus limites.

Confira o destino de cada seta de retorno. Retornar depois da decisão de controle pularia o próximo teste. Retornar antes de uma inicialização que deve ocorrer uma só vez poderia reiniciar um contador em cada passada e impedir que o laço termine.

Um algoritmo pode parecer razoável enquanto faz algo errado. O rastreamento segue suas instruções exatamente e registra o que acontece. O teste executa o algoritmo com entradas escolhidas e confere os resultados. A depuração encontra e corrige a causa de uma falha.

Torne o estado visível

Uma tabela de rastreamento registra variáveis e saídas durante um teste de mesa. Use os valores atuais, não os valores que você espera que o autor tenha pretendido. Por exemplo:

total ← 0
FOR i ← 1 TO 4
    total ← total + i
END FOR
OUTPUT total

Essa tabela compacta mostra o estado após cada adição. Para um erro difícil, acrescente linhas após instruções individuais e uma coluna para os resultados das condições. Um teste de laço com resultado FALSE também pertence a um rastreamento detalhado: ele explica por que a execução sai do laço.

Escolha testes a partir das regras

Calcule o resultado esperado antes de executar cada teste. Caso contrário, é fácil aceitar a saída do programa simplesmente porque ela apareceu. Alguns testes verificam uma propriedade, como manter a saída em ordem, em vez de um resultado exato.

Para notas válidas de 0 a 100, com nota mínima de aprovação de 50:

As categorias de valores-limite e inválidos podem se sobrepor: −1 está perto de um limite e é inválido. A categoria explica por que o teste é útil. Uma regra que usa score > 50 passa nos testes normais com 73 e 49, mas falha com exatamente 50.

Teste também estruturas incomuns de entrada. Uma lista vazia, um elemento, valores todos iguais e valores negativos expõem suposições diferentes. Um algoritmo de média deve tratar uma lista vazia antes de dividir pela contagem. Um algoritmo de maior valor inicializado com zero pode falhar em uma lista apenas de valores negativos.

Identifique o erro que está corrigindo

Um erro de sintaxe infringe as regras de escrita de uma linguagem, como a falta de um parêntese de fechamento. Um erro em tempo de execução ocorre durante a execução, como uma divisão por zero. Um erro de lógica permite a execução, mas fornece um resultado errado, como excluir o limite de aprovação usando >.

Essas categorias ajudam você a escolher uma verificação. A verificação de sintaxe detecta construções que infringem as regras da linguagem. Um rastreamento pode revelar o primeiro estado incorreto em um erro de lógica. Dados de teste podem provocar uma falha em tempo de execução que uma entrada típica nunca alcança.

Depure a partir da primeira divergência

Reproduza a falha com uma entrada específica. Rastreie ou exiba valores intermediários e encontre o primeiro passo em que o estado real difere do estado esperado. Altere a causa e execute novamente o teste que falhou e os testes anteriores. Um reparo em um ramo pode prejudicar outro.

Passar em testes selecionados fornece evidências sobre essas entradas. A correção ainda exige que o método trate toda entrada válida, portanto combine testes com raciocínio sobre as instruções e suas suposições.

Na programação em blocos, blocos gráficos representam instruções e valores. Você os arrasta para uma área de trabalho e os encaixa. As formas eliminam grande parte do trabalho de memorizar a sintaxe, deixando você livre para se concentrar na lógica do programa.

Conheça as partes de um projeto

O Scratch foi criado no MIT Media Lab. Outros ambientes de blocos incluem o Snap!, desenvolvido na Universidade da Califórnia em Berkeley, o Microsoft MakeCode e o Blockly. O Blockly é uma biblioteca para criar interfaces de blocos; começou no Google e passou para a Raspberry Pi Foundation em 2025.

No Scratch, o palco é a área onde o projeto é executado de forma visível. Atores são personagens ou objetos que atuam nele. Um ator pode ter scripts, fantasias e sons. Um script é uma pilha de blocos; uma fantasia é uma imagem que o ator pode exibir.

O palco mede 480 por 360 unidades do Scratch. Seu centro é o ponto de coordenadas (0, 0). As coordenadas horizontais x vão de −240 a 240, e as coordenadas verticais y, de −180 a 180. Os passos de movimento do Scratch são unidades do palco, não metros.

Deixe a forma do bloco orientar você

Um repórter de valor se encaixa em um espaço de entrada de outro bloco. Um comando se encaixa em uma pilha de ações. Um bloco booleano se encaixa em um espaço de condição. A forma ajuda a distinguir o fornecimento de um valor da execução de um comando.

Encontre blocos por categoria

O Scratch 3 tem nove categorias principais identificadas por cores: Movimento, Aparência, Som, Eventos, Controle, Sensores, Operadores, Variáveis e Meus Blocos. Movimento altera a posição; Aparência lida com a aparência visível e a fala; Sensores recebe informações; Operadores calcula ou compara. A extensão Caneta é adicionada separadamente quando um projeto precisa desenhar linhas enquanto um ator se move.

Execute uma sequência curta

Selecione um ator e coloque estes blocos sob um chapéu “quando bandeira verde for clicado”:

1. “vá para x: 0 y: 0”
2. “diga Olá! por 2 segundos”
3. “mova 100 passos”

Clique na bandeira verde. O ator primeiro vai ao centro, depois exibe “Olá!” por dois segundos e então se move 100 passos em sua direção atual. O bloco de fala temporizado torna a pausa visível. A pilha é executada de cima para baixo.

Uma pilha solta pode ser executada quando clicada diretamente na área de trabalho, mas não começará pela bandeira verde a menos que tenha o chapéu de evento correspondente. Confira tanto a ordem da pilha quanto seu evento inicial quando o projeto parecer não responder.

Blocos encaixados corretamente ainda precisam de um plano correto. Um movimento pode acontecer antes de uma redefinição de posição pretendida, ou uma pergunta pode ser feita depois que o resultado é exibido. As formas ajudam na construção válida; o rastreamento revela se essa construção faz o trabalho pretendido.

O Scratch usa as mesmas ideias do pseudocódigo: armazenar um valor, testar uma condição e repetir passos. Os blocos tornam a estrutura visível, mas sua posição ainda determina quando cada ação acontece.

Escolha um laço adequado à tarefa

“Repita 10” executa seu corpo dez vezes. “Sempre” continua executando até que o programa pare e é adequado para um jogo que verifica entradas continuamente. “Repita até que <condição>” testa antes de cada passada e para quando a condição é verdadeira. Portanto, ele pode ser executado zero vezes, ao contrário do REPEAT … UNTIL do pseudocódigo, que testa no final.

Com a extensão Caneta e a caneta abaixada, “repita 4” contendo “mova 100 passos” e “gire à direita 90 graus” desenha um quadrado. Para um hexágono regular, use seis repetições e um giro de 60 graus. As mudanças de direção somam 360 graus ao redor da forma.

Armazene um valor e escolha um ramo

Crie score em Variáveis. “Mude score para 0” atribui seu valor inicial. “Adicione 1 a score” soma ao seu valor atual. Coloque a reinicialização antes de um laço de pontuação; dentro dele, a reinicialização apagaria a pontuação anterior a cada vez.

O repórter arredondado score fornece o valor atual a outros blocos. Marcar sua caixa mostra um monitor no palco, o que ajuda durante o rastreamento.

Um bloco “se … então … senão” executa um de seus dois corpos. Seu espaço de condição de seis lados aceita um bloco booleano como “(score) > (9)” ou “tocando em ponteiro do mouse?”. Os operadores “e”, “ou” e “não” combinam condições com os mesmos significados do pseudocódigo.

Receba uma entrada, crie texto e mostre-o

O bloco “pergunte [Qual é o seu nome?] e espere” pausa para receber uma entrada e a armazena em “resposta”. O bloco “junte [Olá, ] (resposta)” cria texto. Coloque esse repórter dentro de “diga … por 2 segundos” para exibir a saudação. Se a entrada for “Amara”, a saída será “Olá, Amara”.

As três funções são separadas: pergunte recebe dados, junte processa texto e diga o exibe. Um repórter pode calcular um valor útil sem mostrar nada por conta própria.

Crie um jogo de adivinhação

Use esta ordem de blocos, com cada parte indentada dentro do bloco que a contém:

"when green flag clicked"
"set secret to (pick random 1 to 10)"
"ask [Guess a number from 1 to 10] and wait"
"repeat until <(answer) = (secret)>"
    "if <(answer) > (secret)> then"
        "say [Too high] for 2 seconds"
    "else"
        "say [Too low] for 2 seconds"
    "ask [Guess a number from 1 to 10] and wait"
"say [Correct!] for 2 seconds"

Um acerto na primeira tentativa pula o laço. Para o segredo 6 e as tentativas 3, 8 e 6, o retorno é “Too low”, “Too high” e depois “Correct!”. A nova pergunta dentro do laço fornece um valor que pode tornar sua condição verdadeira.

O retorno temporizado importa. A pergunta de um ator visível usa seu balão de fala, portanto a próxima pergunta substitui imediatamente um balão de fala sem tempo definido. Um bloco de fala de dois segundos permite que o aluno leia o retorno primeiro.

Leia o laço como WHILE answer ≠ secret para conferi-lo em pseudocódigo. Omitir a pergunta repetida prende o jogo à resposta incorreta antiga; mover a mensagem final de sucesso para dentro do laço a coloca no caminho errado.

Um projeto Scratch muitas vezes tem vários scripts esperando por eventos diferentes. A programação orientada a eventos inicia um script quando um evento ocorre. Um bloco personalizado permite então que um script chame um trecho nomeado de trabalho reutilizável.

Inicie o script correto

Os blocos chapéu incluem “quando bandeira verde for clicado”, “quando este ator for clicado”, “quando tecla espaço for pressionada” e “quando eu receber [mensagem]”. Cada um descreve o que inicia a pilha ligada a ele.

Vários scripts podem responder ao mesmo evento. Dois atores podem começar quando a bandeira verde é clicada e depois ser executados ao mesmo tempo. A posição de suas pilhas na área de trabalho não estabelece uma ordem de execução entre elas.

Dentro de um script, as ações permanecem ordenadas de cima para baixo. Entre scripts, o momento de execução pode importar. Se dois scripts moverem o mesmo ator em direções opostas, o resultado combinado dependerá de quando suas ações forem executadas. Dê responsabilidades claras aos scripts e coordene o trabalho quando uma tarefa precisar do resultado de outra.

Envie uma mensagem entre scripts

“Transmita [fim de jogo]” envia uma mensagem a todos os atores e ao palco. Os scripts correspondentes “quando eu receber [fim de jogo]” começam em resposta. O nome da mensagem deve corresponder; ele identifica o evento tratado pelos receptores.

“Transmita e espere” também pausa o emissor até que os scripts receptores terminem. Use-o quando a próxima ação depender da conclusão deles. Por exemplo, um controlador pode transmitir uma mensagem de preparação e esperar enquanto os atores se movem para as posições iniciais e então começar o jogo.

Esperar não ordena os receptores entre si. Se dois receptores de preparação sobrescreverem o mesmo valor, eles ainda precisarão de um plano que evite responsabilidades conflitantes. Um receptor executado para sempre também impede que o emissor em espera continue.

Dê um nome e uma entrada ao trabalho repetido

Em Meus Blocos, crie um bloco personalizado com uma entrada chamada size. Sua definição pode ser descrita assim:

"define square (size)"
    "repeat 4"
        "move (size) steps"
        "turn right 90 degrees"

Com a caneta abaixada, chamar “quadrado (100)” desenha lados de 100 passos. Chamar “quadrado (60)” usa as mesmas instruções com lados menores. O bloco personalizado fornece abstração ao ocultar os passos por trás de um nome e generalização ao permitir que quem o chama forneça o tamanho.

A chamada executa a definição; ela não copia uma segunda versão mantida manualmente para o script. Alterar a definição muda o trabalho executado por chamadas posteriores. Isso facilita a manutenção de um método repetido.

Leve as ideias para o texto

Em uma linguagem textual, você digita as instruções e obedece às regras de pontuação e espaçamento da linguagem. O raciocínio subjacente sobre estado, condições e repetição continua a se aplicar.

Os blocos eliminam muitos erros de sintaxe, mas uma condição errada ainda pode escolher o caminho errado. Rastreamentos e testes continuam úteis. Projetos grandes em blocos também podem se tornar difíceis de navegar e comparar porque seus scripts ocupam muito espaço na tela; o texto é mais fácil de pesquisar e gerenciar em projetos grandes de software.