Glossário do Curso de Lógica de Programação

Todos os termos do curso em um só lugar, com definições simples. Use a busca para achar rápido.

Acumulador: Variável que acumula valores ao longo das voltas de um laço, em geral somando: total <- total + preco. A cada volta, o valor da vez entra no bolo. No fim do laço, o acumulador guarda o resultado agregado.
Acumulador por categoria: Uma variável que começa em zero e recebe somas ao longo do programa, uma para cada categoria de despesa. No fim, cada acumulador guarda o total gasto naquela categoria, pronto para o relatório.
Algoritmo: Uma sequência finita de passos claros e ordenados que resolve um problema ou realiza uma tarefa. É a ideia central de toda a computação: receita que qualquer executor, humano ou máquina, consegue seguir.
Alucinação de IA: Quando a IA inventa uma resposta com aparência de certa: um comando que não existe, uma conta errada, uma regra imaginária. Ela não avisa que inventou; quem detecta é a pessoa que confere, com teste de mesa e casos de borda.
Ambiguidade: A possibilidade de um mesmo passo ser entendido de mais de um jeito. Num algoritmo, ambiguidade é defeito: duas pessoas seguindo o mesmo passo precisam fazer exatamente a mesma coisa.
Argumento: O valor concreto enviado na chamada da função, como “Ana” em saudacao(“Ana”). O argumento é o ingrediente de verdade; o parâmetro é o espaço que o recebe. Cada chamada pode levar argumentos diferentes.
Atribuição: A instrução que guarda um valor numa variável, escrita com a seta <- no pseudocódigo. O lado direito é calculado primeiro; o resultado entra na caixa do lado esquerdo, substituindo o que estava lá.
Atuador: A peça que AGE sobre o mundo quando o programa manda: liga o ar-condicionado, acende a lâmpada, dispara a notificação. É o par do sensor: um lê, o outro executa.
Atualização do laço: A instrução dentro do laço que altera a variável usada na condição, aproximando o teste do falso (ex.: contador <- contador + 1). É a peça cuja falta ou erro cria o laço infinito.
Aviso de leitura: A mensagem mostrada com ESCREVA imediatamente antes de um LEIA, dizendo o que o programa espera receber. Sem o aviso, a tela fica parada em silêncio e a pessoa não sabe o que digitar.
Bloco: Um grupo de instruções tratado como unidade dentro de uma estrutura, como o trecho entre então e senão ou entre senão e fim. O bloco inteiro executa ou o bloco inteiro é pulado; não existe meio termo.
Bug: Um comportamento errado do programa causado por instrução incorreta, incompleta ou fora de ordem. O nome vem de inseto em inglês; o computador seguiu ordens, só que as ordens estavam erradas.
Busca linear (ou sequencial): O algoritmo que procura um valor visitando a lista caixa por caixa, do índice 0 em diante, comparando cada elemento com o procurado. É a busca mais simples que existe e funciona em qualquer lista, ordenada ou não.
Caminho feliz: A execução do algoritmo com entradas comuns e bem comportadas, em que tudo dá certo. Testar só o caminho feliz cria uma falsa sensação de segurança: o programa parece pronto, mas nunca visitou as próprias fronteiras.
Campeão provisório: O apelido didático da variável maior no algoritmo de achar o maior valor: ela guarda o melhor candidato visto ATÉ AGORA e é desafiada por cada nova caixa da lista. Ao fim do percurso, o provisório vira definitivo.
Caso contrário: O caso especial do ESCOLHA CASO que executa quando o valor não bate com nenhum dos casos listados. Funciona como o SENÃO final da escada: a rede de segurança que impede opção inválida de passar em silêncio.
Caso de borda: Uma entrada válida porém extrema, situada na fronteira do que o algoritmo aceita: o zero, a lista vazia, o valor exatamente igual ao limite. É onde a maioria dos bugs se esconde, porque o autor testa apenas os casos comuns.
Caso de teste: Um conjunto de valores de entrada com o resultado esperado já conhecido, usado para conferir se o algoritmo funciona. Exemplo: compra de 25, pagamento de 50, troco esperado de 25.
Certificado verificável: O documento de conclusão emitido após a aprovação no exame, com código único e página pública de conferência. Atesta que você concluiu as aulas e foi aprovado; quem quiser confere a autenticidade pelo código.
Chamada de função: O ato de usar uma função pelo nome, como em escreva(“Olá”). Chamar é apertar o botão de ligar da máquina: o algoritmo pula para dentro da função, executa os passos dela e volta para onde estava.
Ciclo: Uma sequência que se repete do início ao chegar no fim: as horas do relógio, os dias da semana, os finais de placa do rodízio. O mod é o operador dos ciclos, porque o resto de uma divisão por N gira sempre entre 0 e N menos 1.
Ciclo de monitoramento: O laço proposital sem fim que sustenta uma automação: medir, comparar, agir, esperar um pouco e recomeçar. Diferente do laço infinito acidental, ele é projetado para nunca parar enquanto o aparelho estiver ligado.
Circuito em série: Ligação elétrica em que os componentes ficam um atrás do outro no mesmo fio: a corrente precisa atravessar todos para chegar ao destino. É o desenho perfeito do operador E.
Código-fonte: O texto que o programador escreve numa linguagem de programação, antes de a máquina executar. O pseudocódigo deste curso é um rascunho de código-fonte em português, feito para humanos lerem.
Comando escreva: O comando de saída do pseudocódigo: mostra na tela o que estiver entre parênteses, como escreva(“Bom dia”). É como o algoritmo conversa com quem o usa.
Comando leia: O comando de entrada do pseudocódigo: pausa a execução, espera a pessoa digitar algo e guarda a resposta para os próximos passos, como leia(nome).
Comando SE: Estrutura de decisão do pseudocódigo: se a condição vale V, o bloco entre então e fim executa; se vale F, o bloco inteiro é pulado e o programa segue na linha depois do fim.
Combinação de entrada: Uma configuração possível dos valores das condições: com duas condições existem 4 combinações (VV, VF, FV, FF); com três, 8. Cada linha da tabela-verdade é uma combinação.
Comentário: Linha iniciada por // que o executor ignora por completo. Serve para deixar recados a quem lê o algoritmo: explicar uma escolha, anotar a saída esperada, marcar um pedaço para revisar.
Comparação: Uma pergunta de sim ou não que o algoritmo faz sobre valores: este número é igual àquele? É maior? A resposta é sempre um valor lógico, verdadeiro (V) ou falso (F), nunca um talvez.
Comparação de textos: A conferência caractere por caractere que a máquina faz entre dois textos. Basta UM caractere diferente (uma maiúscula, um acento, um espaço) para a igualdade responder F. Não existe “parecido” para o computador; existe igual ou diferente.
Condição: A pergunta de sim ou não que o SE avalia, escrita como comparação (idade >= 18) ou combinação lógica (chovendo E sem guarda-chuva). Sempre resulta em um único valor: V ou F.
Condição de parada: A situação que faz a condição do laço virar falsa e encerra a repetição. Todo ENQUANTO bem escrito tem uma: sem ela, o laço roda para sempre.
Contador: Variável usada para contar quantas vezes algo aconteceu dentro de um laço. Nasce com 0 (ou 1, conforme o caso) antes do laço e recebe mais um a cada ocorrência do evento contado.
Contagem decrescente: Um laço PARA que começa no valor maior e termina no menor, usando passo negativo: para i de 10 até 1 passo -1. É a contagem regressiva do foguete, do micro-ondas e do cronômetro de prova.
Controle de saldo: O conjunto de regras que protege o dinheiro da conta: o saque precisa de valor positivo E de saldo suficiente antes de subtrair; o depósito só soma valores válidos. A conferência SEMPRE vem antes da alteração do saldo, nunca depois.
Corpo do laço: O bloco de comandos entre o FAÇA e o FIM, executado uma vez por volta. Na tabuada, o corpo tem duas linhas: calcular o resultado da vez e escrever a linha formatada.
Decisão: O momento em que um algoritmo escolhe entre caminhos conforme uma condição: se está chovendo, leve o guarda-chuva. Nos módulos 6 a 8 ela vira o comando SE.
Decisão aninhada: Um comando SE escrito dentro do bloco de outro SE. A decisão interna só chega a ser avaliada quando o caminho externo que a contém executa; caso contrário, ela é pulada junto com o bloco inteiro.
Decomposição: A técnica de dividir um problema grande em partes menores e independentes, cada uma resolvida por uma função. É o passo de projeto que vem antes de escrever código: primeiro as máquinas, depois a linha de montagem.
Depuração: O processo de investigar um comportamento errado do programa até achar a causa e corrigi-la. Em inglês, debugging. Não é chute organizado: é método, com reprodução do erro, hipótese, verificação e correção pontual.
Divisão inteira (div): A divisão que responde “quantos cabem por inteiro” e descarta a sobra: 17 div 5 dá 3. É a conta certa quando a resposta não pode ser quebrada, como número de vans, caixas ou pessoas.
Divisão por zero: O erro clássico de borda: uma divisão cujo divisor vale zero, operação sem resultado definido que trava o programa. Aparece quando o algoritmo divide por uma quantidade que pode ser zero, como a média de uma lista vazia.
Documentação oficial: O manual mantido por quem desenvolve a linguagem, com a descrição correta de cada comando. Python e JavaScript têm documentação oficial com versão em português, o que pesa na escolha da primeira linguagem de quem estuda em pt-BR.
Eco da entrada: A prática de mostrar de volta, com ESCREVA, o valor que o programa acabou de ler, para a pessoa conferir se digitou certo. É o “você pediu 6 pães, correto?” dos atendentes bons de balcão.
Ecossistema: Tudo o que vive ao redor de uma linguagem: bibliotecas prontas, ferramentas, cursos, fóruns e vagas. Duas linguagens parecidas podem ter ecossistemas muito diferentes, e é o ecossistema que define o que é fácil de construir com cada uma.
Elemento: Cada valor guardado dentro de uma lista. Na lista de compras [“pão”, “leite”, “café”], cada produto é um elemento, e cada um mora numa posição numerada.
Entrada: Tudo o que o algoritmo recebe de fora para trabalhar: números digitados, o valor pago pelo cliente, o CEP informado. Sem entrada certa, nem o melhor processamento salva o resultado.
Entrada de dados: Toda informação que entra no programa vinda de fora: o que a pessoa digita, o toque na tela, o valor lido de um sensor. É a matéria-prima que o processamento transforma em resultado.
Entrada e saída: A entrada é o que o algoritmo recebe para trabalhar (os ingredientes); a saída é o que ele produz no final (o prato pronto). Todo algoritmo útil transforma entradas em saídas.
Erro de fronteira: Bug causado pela escolha errada entre > e >= (ou < e <=): o algoritmo funciona para quase todos os valores e falha exatamente no limite. É um dos bugs mais comuns da programação e o teste que o pega é sempre o mesmo: experimentar o valor exato da fronteira.
Erro de limite: O bug de dar uma volta a mais ou a menos por errar o início ou o fim do intervalo, conhecido em inglês como off-by-one. É um dos erros mais comuns da programação em qualquer linguagem, e a defesa é conferir os dois extremos no papel.
Erro de sintaxe: Erro que acontece quando o texto do programa quebra as regras de escrita da linguagem: dois-pontos esquecidos, parêntese sem par, palavra digitada errada. A máquina nem começa a executar; ela aponta a linha e reclama.
Escada de SENÃO SE: Uma sequência de decisões encadeadas em que só um degrau executa: se categoria = 1 soma em moradia, senão se categoria = 2 soma em alimentação, e assim por diante. O SENÃO final captura o que sobrou.
Escada SENÃO SE: Encadeamento de decisões em que cada senão se só é avaliado quando todas as condições anteriores deram F. O primeiro degrau que der V executa seu bloco e encerra a escada inteira: no máximo um bloco roda por passagem.
ESCOLHA CASO: Estrutura de decisão que compara UM valor contra vários casos de igualdade exata e executa o bloco do caso que bater. É a forma natural de menus de opções e classificações por código. Em linguagens reais aparece como switch ou match.
Estado do programa: A fotografia de todos os valores das variáveis em um instante da execução. Cada linha executada pode mudar o estado; rastrear o programa é acompanhar essa sequência de fotografias até o fim.
Estratégia do meio: Chutar sempre o meio do intervalo possível: cada dica de maior ou menor descarta metade dos números restantes. De 1 a 100, essa estratégia acerta em no máximo 7 palpites. É a intuição por trás da busca binária, uma das técnicas mais famosas da computação.
Exame final: A prova cumulativa do curso: cada tentativa sorteia 20 questões de um banco de 32, cobrindo todos os módulos, e a aprovação exige 70% de acerto. Pode ser refeito; o sorteio muda as questões a cada tentativa.
Execução literal: O jeito de o computador trabalhar: cumprir cada instrução exatamente como foi escrita, na ordem em que aparece, sem interpretar intenção nem corrigir esquecimentos.
Expressão: Qualquer pedaço de código que produz um valor: o número 25, a conta preco * 2, a soma pontos + 5. A atribuição sempre resolve a expressão do lado direito antes de guardar o resultado na variável.
Faixa de classificação: Um intervalo de valores que recebe um rótulo: média 7 ou mais é aprovado, de 5 a 6,9 é recuperação, abaixo de 5 é reprovado. As faixas se testam em escada, da mais alta para a mais baixa, com SENÃO SE.
Faixa de valores: Um intervalo tratado com a mesma resposta, como nota de 7 a 8,9 valendo “aprovado” ou compra acima de 200 reais com frete grátis. A escada SENÃO SE é a ferramenta clássica para separar faixas.
Fluxograma: A representação desenhada de um algoritmo: cada passo vira uma forma geométrica e as setas mostram a ordem do fluxo. Diz o mesmo que o pseudocódigo, só que para os olhos.
Função: Um bloco de instruções com nome próprio que realiza uma tarefa específica: recebe entradas, faz um trabalho e devolve uma saída. Depois de definida, pode ser usada quantas vezes você quiser, só chamando o nome.
Granularidade: O tamanho de cada passo de um algoritmo. Um passo com granularidade certa descreve uma ação única, que o executor cumpre sem precisar decidir nada por conta própria.
Hipótese de bug: Um palpite específico e testável sobre a causa do erro, do tipo “a média está sendo calculada antes da soma terminar”. Boa hipótese aponta para uma linha ou trecho; “o programa está todo errado” não é hipótese, é desespero.
Identificador: O nome oficial que você dá a uma variável (e, mais adiante, a funções). Segue regras de formação: letras, dígitos e underline, sem espaços, sem acentos e sem começar por dígito. “preco_do_pao” é um identificador; “preço do pão” não é.
Incremento: A operação de aumentar o valor de uma variável, em geral somando 1: contador <- contador + 1. O computador lê o valor atual, soma, e guarda o resultado de volta na mesma caixa.
Índice: O número da posição de uma caixa dentro da lista. A contagem começa em 0: numa lista de 4 elementos, os índices válidos são 0, 1, 2 e 3. É o endereço que você usa entre colchetes: notas[2].
Índice fora da lista: O erro de pedir uma caixa que não existe, como notas[4] numa lista de 4 elementos (cujo último índice é 3). Nas linguagens reais isso derruba o programa ou devolve vazio; é um dos bugs mais comuns da programação.
Inicialização: Dar o primeiro valor a uma variável antes de usá-la. Contadores e acumuladores de soma inicializam com 0, uma única vez, ANTES do laço. Inicializar dentro do laço rezera o valor a cada volta e destrói o acúmulo.
Instrução: Uma ordem única e específica dada ao computador, como somar dois números ou mostrar uma mensagem. Programas são feitos de milhares de instruções executadas em sequência.
Intervalo: A faixa de valores que a variável de controle percorre, do valor inicial ao valor final, ambos incluídos no pseudocódigo do curso. O intervalo de 5 até 9 contém 5 valores: 5, 6, 7, 8 e 9.
Iteração: Cada volta completa de um laço. Um laço que dobra 30 peças de roupa executa 30 iterações do mesmo bloco: pegar a peça, dobrar, empilhar.
Junção de textos: A montagem de uma mensagem a partir de várias partes, misturando textos fixos e valores de variáveis. No pseudocódigo do curso, as partes vão separadas por vírgula dentro do ESCREVA e aparecem emendadas na mesma linha.
Laço (loop): Estrutura que executa o mesmo bloco de passos várias vezes sem reescrevê-lo. Você escreve o bloco uma vez e define até quando repetir; o computador cuida das voltas.
Laço aninhado: Um laço escrito dentro do corpo de outro. A cada volta do laço externo, o interno executa do início ao fim, completo. O total de execuções do bloco mais interno é a multiplicação das voltas: 3 voltas fora e 5 dentro dão 15 execuções.
Laço de tentativas: O padrão de jogo em que um bloco (ler palpite, comparar, dar dica) se repete ENQUANTO a resposta estiver errada. A condição de parada é o acerto; o contador dentro do laço registra quantas voltas foram necessárias.
Laço de validação: O padrão ENQUANTO o dado estiver inválido FAÇA: explique o erro e leia de novo. Diferente de um SE, que confere uma única vez, o laço insiste quantas vezes for preciso até receber um valor aceitável.
Laço ENQUANTO: Estrutura de repetição que testa uma condição antes de cada volta: se a condição for verdadeira, executa o bloco e testa de novo; quando fica falsa, o programa segue para depois do fim. Nas linguagens reais aparece como while.
Laço externo: O laço de fora, que anda devagar: só avança uma volta quando o interno termina todas as dele. No relógio, é o ponteiro das horas; numa tabela, é a linha.
Laço infinito: Laço cuja condição nunca fica falsa, fazendo o bloco se repetir para sempre. O programa não quebra nem avisa: fica preso dando voltas, sem responder, consumindo o processador.
Laço interno: O laço de dentro, que anda rápido: recomeça do valor inicial a cada volta do externo. No relógio, é o ponteiro dos minutos; numa tabela, é a coluna que percorre a linha inteira.
Laço PARA: Estrutura de repetição com contagem embutida: você informa de onde até onde contar (para i de 1 até 10 faça) e o próprio laço cria o contador, testa o limite e avança a cada volta. É a escolha natural quando o número de repetições é conhecido de antemão.
Lista: Uma variável que guarda vários valores em caixas numeradas, todas sob o mesmo nome. Também aparece com os nomes vetor e array nas linguagens reais. É a estrutura que permite tratar 30 notas como um conjunto, e não como 30 variáveis soltas.
Lógica de programação: A habilidade de transformar um problema em uma sequência de passos claros, ordenados e sem ambiguidade, que um computador consegue executar. É a base de qualquer linguagem de programação.
Losango de decisão: A forma do fluxograma que carrega uma pergunta de sim ou não. É a única forma com duas saídas: uma seta para o caminho do sim e outra para o caminho do não.
Maior ou igual (>=): Pergunta se o valor da esquerda é maior OU igual ao da direita: “18 >= 18” responde V. É o operador das regras que incluem o limite, como “a partir de 18 anos” e “no mínimo 7 pontos”.
Média aritmética: A soma de todos os valores dividida pela quantidade deles. Quatro notas 8, 6, 7 e 9 somam 30; divididas por 4, dão média 7,5. Em pseudocódigo, o acumulador soma nota a nota e a divisão acontece uma vez, depois do laço.
Menu de operações: A lista de opções numeradas que o programa mostra em laço até a pessoa escolher sair: consultar saldo, sacar, depositar, encerrar. Cada opção dispara um bloco (ou uma função) diferente, e o laço garante que o programa volta ao menu após cada operação.
Não se repita (DRY): Princípio clássico da programação (em inglês, Don't Repeat Yourself): cada regra do programa deve morar em UM único lugar. Quando um trecho se repete, o sinal é claro: extraia uma função e chame-a onde precisar.
Negação dupla: Aplicar o NÃO duas vezes, voltando ao valor original: NÃO (NÃO V) = V. Em código, quase sempre é sinal de condição mal escrita que merece ser simplificada.
Nome descritivo: Um identificador que anuncia o conteúdo da caixa sem exigir adivinhação: total_da_compra em vez de t, idade_do_cliente em vez de x. É a prática que mais barateia a manutenção de um algoritmo.
Operador aritmético: O símbolo que pede uma conta dentro do algoritmo: + para somar, - para subtrair, * para multiplicar e / para dividir. Ele age sobre valores e variáveis e devolve um resultado, que quase sempre é guardado em outra variável.
Operador de igualdade: O símbolo que pergunta se dois valores são iguais. No pseudocódigo do curso é o = (e o <> pergunta se são diferentes). Não confunda com a atribuição <-, que guarda um valor na variável em vez de perguntar algo.
Operador E (conjunção): Operador lógico que combina duas condições e só devolve verdadeiro quando AS DUAS são verdadeiras. Uma única condição falsa derruba o resultado inteiro, como uma chave aberta corta o circuito em série.
Operador maior que (>): Pergunta se o valor da esquerda é maior que o da direita: “52 > 50” responde V. No empate, responde F: “50 > 50” é falso, porque 50 não é maior que 50, é igual.
Operador menor que (<): Pergunta se o valor da esquerda é menor que o da direita: “3 < 10” responde V. Assim como o >, responde F no empate. A boca aberta do símbolo sempre aponta para o lado maior.
Operador NÃO (negação): Operador lógico que atua sobre UMA condição e devolve o valor oposto: NÃO V = F e NÃO F = V. É o único dos três operadores que trabalha sozinho, sem precisar de segunda condição.
Operador OU (disjunção): Operador lógico que combina duas condições e devolve verdadeiro quando PELO MENOS UMA é verdadeira. Só devolve falso quando as duas falham, como um circuito em paralelo que só apaga com os dois caminhos abertos.
Operando: Cada valor que participa da conta. Em preco * quantidade, os operandos são preco e quantidade. Um operando pode ser um número escrito na hora (como 30) ou uma variável que guarda um número.
Ordem alfabética (na comparação): O critério que dá sentido a “maior” e “menor” entre textos: “abacaxi” < “banana” porque a vem antes de b, como no dicionário. É o que permite ordenar listas de nomes, e tem as próprias pegadinhas com maiúsculas e acentos.
OU inclusivo: O OU da lógica aceita “uma, outra OU AS DUAS”: V OU V continua sendo V. Diferente do “ou” exclusivo da conversa (“ou praia ou cinema”), que sugere escolher só um.
Palavra reservada: Palavra que a linguagem guarda para si, com significado fixo: if, else, while, for, return. Você não pode usá-la como nome de variável, e é ela que dá o esqueleto do programa em qualquer código que você abrir.
Parâmetro: A variável de entrada declarada na definição da função, como o nome em função saudacao(nome). É o espaço reservado que recebe um valor novo a cada chamada, como o copo do liquidificador que aceita frutas diferentes.
Parênteses: O recurso que impõe a sua ordem à expressão: o que está entre parênteses calcula primeiro, sempre. Em (nota1 + nota2) / 2, a soma acontece antes da divisão, mesmo a divisão tendo prioridade natural maior.
Paridade: A propriedade de um número ser par ou ímpar. No algoritmo, ela é o resto da divisão por 2: numero mod 2 dá 0 para os pares e 1 para os ímpares. É o teste de divisibilidade mais usado da programação.
Passo: O tamanho do salto da variável de controle a cada volta do PARA. Quando não se escreve nada, o passo é 1; com passo 2, a contagem visita um valor sim, outro não; com passo negativo, a contagem anda de trás para frente.
Percentual sobre o total: A fatia que uma parte representa do todo: (parte / total) * 100. No projeto, (totalMoradia / totalGeral) * 100 diz quantos por cento do orçamento foram para moradia.
Percorrer (ou varrer) uma lista: Visitar todas as caixas da lista, uma por uma, em ordem, normalmente com um laço PARA que faz o índice ir de 0 até o tamanho menos 1. É a operação mais comum da programação com listas.
Playground: Ambiente de prática que roda código dentro do navegador, sem instalar nada. O curso de lógica tem o Playground de pseudocódigo; os cursos da trilha Python executam Python de verdade na página, inclusive no celular.
Porcentagem: Uma fração de 100 escrita com o símbolo %. Nos algoritmos, ela vira multiplicação e divisão: 10% de um valor é valor * 10 / 100. Não existe operador de porcentagem no pseudocódigo; existe a conta que a representa.
Precedência: A ordem de prioridade que a máquina segue quando uma expressão mistura operadores: primeiro o que está entre parênteses, depois multiplicação, divisão, div e mod, e por último soma e subtração. Operadores de mesma prioridade resolvem da esquerda para a direita.
Prioridade de operadores: A ordem fixa em que o computador avalia operadores misturados sem parênteses: primeiro NÃO, depois E, por último OU. Igual à matemática, onde a multiplicação vence a soma.
Procedimento: Uma função que faz um trabalho (mostrar um menu, imprimir um recibo) mas não devolve valor nenhum. É a campainha da casa: você aperta, algo acontece, e não sobra nada para guardar numa variável.
Processamento: O miolo do algoritmo: os passos que transformam a entrada no resultado. É onde moram as contas, as comparações e as decisões. É a parte que você projeta.
Programa: Um algoritmo escrito por completo, pronto para executar do início ao fim: abertura, leituras, processamento e saída. É a unidade que você entrega para alguém usar, e não apenas um trecho solto de linhas.
Programa principal: O trecho do algoritmo que coordena o trabalho chamando as funções na ordem certa, como o chef que comanda as praças da cozinha. Bem escrito, ele se lê como um resumo do problema em português.
Prompt: O pedido em texto que você escreve para uma IA. Prompt vago gera código vago: os melhores prompts de programação descrevem entrada, processamento, saída e casos de borda, exatamente as peças que este curso ensinou.
Pseudocódigo: Escrita de algoritmos em português estruturado, com comandos como leia, escreva e se. Não roda em computador de verdade; roda no Playground do curso e, principalmente, na sua cabeça. É a língua oficial das aulas.
Rastreio de variáveis: A prática de anotar, linha a linha (e volta a volta nos laços), o valor de cada variável que muda. É o teste de mesa focado em VER a evolução dos valores, e não apenas na saída final.
Recuo (indentação): O deslocamento das linhas para a direita que mostra a que bloco cada instrução pertence. Quanto mais fundo o recuo, mais interna a estrutura. É o mapa visual que impede você de se perder em decisões aninhadas.
Recuperação ativa: Técnica de estudo em que você tenta LEMBRAR e USAR o conteúdo (respondendo, jogando, resolvendo) em vez de só reler. É o motivo de cada aula deste curso ter jogo e teste rápido: buscar a informação na memória fixa mais que revisitar o texto.
Refatoração: Melhorar a estrutura interna de um algoritmo (nomes, organização, clareza) SEM mudar o que ele faz. As mesmas entradas continuam produzindo as mesmas saídas; o que muda é a facilidade de ler, entender e modificar o código no futuro.
Refinamento: A prática de melhorar um algoritmo em versões: a primeira resolve o caso comum; as seguintes tratam os casos que o teste revelou. Ninguém escreve a versão final de primeira, nem os profissionais.
Regressão: Um comportamento que funcionava e quebrou depois de uma mudança. É o risco número um de qualquer melhoria, e o motivo de todo bom refatorador testar as mesmas entradas antes e depois de mexer.
Relatório: A saída organizada do programa: os resultados apresentados de um jeito que uma pessoa entende e usa para decidir. No organizador, são os totais, os percentuais, a categoria campeã e o alerta de concentração de gastos.
Repetição: O momento em que um algoritmo refaz um conjunto de passos várias vezes: uma dobra por peça de roupa até o cesto esvaziar. Nos módulos 9 e 10 ela vira os laços ENQUANTO e PARA.
Requisito: Uma frase que descreve algo que o programa PRECISA fazer, na visão de quem vai usar. Exemplo: o organizador deve recusar despesas com valor zero ou negativo. A lista de requisitos é o contrato do projeto.
Resto (mod): O que sobra da divisão inteira: 17 mod 5 dá 2, porque 3 vans de 5 levam 15 e sobram 2. O resto é sempre um inteiro entre 0 e o divisor menos 1, e essa propriedade o torna perfeito para detectar pares, montar ciclos e conferir sobras.
Retorno: O valor que a função devolve para quem a chamou, através do comando retorne. É a saída da máquina: a vitamina servida no copo de quem pediu. Ao executar o retorne, a função encerra na hora, mesmo que existam linhas depois.
Reuso de código: Aproveitar a mesma função em vários pontos do programa (ou em programas diferentes) em vez de reescrever a lógica. É o retorno do investimento das funções: a máquina construída uma vez trabalha em todas as receitas.
Saída: O que o algoritmo entrega no final: o troco na tela, a rota no mapa, a média no boletim. É a razão de o algoritmo existir; todo o resto trabalha para ela.
Saída de dados: Toda informação que o programa entrega para o mundo exterior: uma mensagem na tela, um comprovante impresso, um alerta sonoro. Sem saída, o resultado do processamento morre dentro da máquina.
Saída esperada: O resultado que o algoritmo DEVERIA produzir para uma entrada conhecida, calculado antes da execução. É a régua do teste de mesa: se a saída obtida for diferente da esperada, existe um erro entre as linhas.
Saída formatada: A montagem da mensagem juntando textos fixos e variáveis, como escreva(numero, ' x ', i, ' = ', resultado). É o que transforma números soltos numa linha legível de tabuada: 7 x 3 = 21.
SENÃO: A segunda metade da decisão: o bloco que executa quando a condição do SE vale F. Com ele, a bifurcação sempre percorre exatamente um dos dois caminhos, sem hipótese de pular os dois ou executar os dois.
Sensor: A peça que MEDE alguma coisa do mundo e entrega o valor para o programa: temperatura, luminosidade, presença, horário. No pseudocódigo, aparece como uma função de leitura, como lerSensorDeTemperatura().
Sintaxe: O conjunto de regras de escrita de uma linguagem de programação: quais palavras usar, onde vão parênteses, dois-pontos e chaves. A sintaxe muda de linguagem para linguagem; a lógica por baixo dela, não.
Tabela-verdade: Tabela que lista TODAS as combinações possíveis dos valores de entrada de uma expressão lógica e o resultado de cada combinação. É o retrato completo do comportamento da expressão, sem exceções escondidas.
tamanho(lista): A função do pseudocódigo que devolve quantas caixas a lista tem. Alimenta o limite do laço: para i de 0 até tamanho(lista) - 1. Nas linguagens reais aparece como len() no Python e .length no JavaScript.
Teste de mesa: Técnica de executar um algoritmo manualmente, linha por linha, anotando o valor de cada variável e o que aparece na tela. Você faz o papel do computador para conferir se os passos produzem o resultado certo.
Texto (string): Uma sequência de caracteres entre aspas: “Maria”, “Rua das Flores, 100”, “01310-100”. Mesmo quando contém dígitos, o texto não entra em contas; ele é tratado como escrita, caractere por caractere.
Texto literal: O trecho entre aspas de um comando, reproduzido na tela exatamente como foi escrito, espaços incluídos. É a parte fixa da mensagem, que não muda entre uma execução e outra.
Tipo de dado: A categoria da informação guardada numa variável: número, texto ou lógico, nos fundamentos. O tipo define o que o algoritmo pode fazer com o valor: números entram em contas, textos se juntam em mensagens, lógicos decidem caminhos.
Trilha de aprendizagem: Uma sequência planejada de cursos em que cada um assume o anterior como base. A trilha Python do ValorFinal tem três degraus (Básico, Intermediário e Avançado) e foi desenhada para receber quem termina este curso de lógica.
Troca (swap): A operação que faz duas variáveis trocarem de valor entre si: o que estava em A vai para B e o que estava em B vai para A. Exige três passos e uma variável auxiliar; em inglês, o nome consagrado é swap.
Validação de entrada: A conferência que um programa faz em todo dado recebido de fora antes de usá-lo: tipo certo, faixa permitida, campo preenchido. Dado que reprova na validação não entra no cálculo; o programa explica o problema e pede de novo.
Valor: O conteúdo guardado dentro de uma variável num dado momento: um número como 37, um texto como “Maria” ou um resultado lógico como verdadeiro. Uma variável guarda exatamente um valor por vez.
Valor lógico (booleano): O tipo que só aceita dois valores: verdadeiro ou falso. É o resultado de perguntas como “a senha confere?” e o combustível das decisões SE, que chegam no módulo 8. O nome booleano homenageia o matemático George Boole.
Valor sentinela: Um valor especial usado para representar uma situação, e não um dado comum. Na busca, a posição -1 é sentinela de “não encontrei”: como nenhum índice real é negativo, não há risco de confusão com um resultado verdadeiro.
Variável: Um espaço na memória do computador com um nome (a etiqueta) e um valor guardado dentro (o conteúdo). O valor pode mudar durante o programa; o nome, não. É a peça que permite ao algoritmo lembrar de informações.
Variável auxiliar: Uma variável criada só para dar apoio temporário a uma operação, como guardar um valor que seria destruído numa substituição. Na troca de valores, ela é o terceiro copo que recebe um dos sucos enquanto os outros dois se reorganizam.
Variável de controle: A variável que o laço PARA cria e atualiza sozinho (o famoso i). Ela guarda o número da volta atual e pode ser usada dentro do laço, em contas e mensagens, mas quem cuida do avanço dela é o laço, não você.
Variável lógica: Uma variável que guarda V ou F, como “maior_de_idade <- idade >= 18”. Dar nome ao resultado de uma comparação deixa o algoritmo legível: a linha “se maior_de_idade então” se lê como português puro.