Lógica de Programação

Cartões · 50

Algoritmo

Sequência finita e ordenada de passos para resolver um problema. Ex: inicio escreva("Passo 1") fim. Usado como receita para guiar a execução de programas.

Pseudocódigo (Portugol)

Forma genérica de escrever algoritmos em linguagem próxima ao português humano. Ex: algoritmo "OlaMundo" inicio fim. Usado para planejar código antes de programar.

Variável

Espaço reservado na memória para armazenar dados mutáveis. Ex: var idade: inteiro. Usado para guardar informações temporárias como nome de usuário ou saldo.

Constante

Espaço reservado na memória com valor fixo que nunca se altera. Ex: constante PI <- 3.1415. Usado para taxas fixas e valores matemáticos imutáveis.

Tipo Inteiro

Dado numérico sem casas decimais, positivo ou negativo. Ex: var qtd: inteiro; qtd <- 10. Usado para contadores, idades e itens inteiros.

Tipo Real

Dado numérico com ponto flutuante (casas decimais). Ex: var preco: real; preco <- 19.90. Usado para valores monetários, médias e medidas.

Tipo Caractere (String)

Dado textual delimitado por aspas duplas. Ex: var nome: caractere; nome <- "Ana". Usado para nomes, mensagens e identificadores alfanuméricos.

Tipo Lógico (Booleano)

Dado binário que assume apenas Verdadeiro ou Falso. Ex: var ativo: logico; ativo <- VERDADEIRO. Usado para checar permissões e estados de controle.

Comando de Saída: escreva / escreval

Exibe dados ou mensagens na tela do usuário. Ex: escreval("Bom dia!"). Usado para mostrar resultados e interagir com quem usa o programa.

Comando de Entrada: leia

Captura dados digitados pelo usuário e guarda em uma variável. Ex: leia(idade). Usado para receber dados via teclado em formulários e menus.

Operador de Atribuição (<-)

Armazena um valor ou resultado em uma variável específica. Ex: soma <- a + b. Usado para inicializar ou atualizar valores no programa.

Operadores Aritméticos Básicos

Símbolos para soma (+), subtração (-), multiplicação (*) e divisão (/). Ex: total <- valor * 2. Usado em qualquer cálculo financeiro ou matemático.

Divisão Inteira (\)

Retorna apenas o quociente inteiro descartando decimais. Ex: resultado <- 7 \ 2 (dá 3). Usado para dividir itens que não aceitam fração.

Resto da Divisão (% ou MOD)

Retorna o resto de uma divisão inteira. Ex: resto <- 7 % 2 (dá 1). Usado para verificar paridade (par/ímpar) e múltiplos de números.

Operador de Potenciação (^)

Eleva uma base a um expoente. Ex: pot <- 2 ^ 3 (dá 8). Usado para cálculos de juros compostos e fórmulas geométricas.

Operadores Relacionais: Igualdade e Diferença

Comparam valores retornando lógico: igual (=) e diferente (<>). Ex: se (senha = "123") entao. Usado para checar credenciais em logins.

Operadores Relacionais: Maior e Menor

Comparam grandeza entre valores: >, <, >= e <=. Ex: se (idade >= 18) entao. Usado para validar maioridade e limites numéricos.

Operador Lógico E (AND)

Retorna verdadeiro somente se todas as condições forem verdadeiras. Ex: se (idade >= 18) e (temCnh) entao. Usado para validações compostas e restritas.

Operador Lógico OU (OR)

Retorna verdadeiro se pelo menos uma condição for verdadeira. Ex: se (estudante) ou (idoso) entao. Usado para regras de meia-entrada e acessos especiais.

Operador Lógico NÃO (NOT)

Inverte o valor lógico de uma expressão. Ex: se nao (chovendo) entao. Usado para inverter verificações de status e flags binárias.

Estrutura Condicional Simples

Executa um bloco de código se a condição for verdadeira. Ex: se (nota >= 7) entao escreva("Aprovado") fimse. Usado para ações opcionais baseadas em teste.

Estrutura Condicional Composta

Oferece caminhos alternativos para verdadeiro e falso. Ex: se (media >= 7) entao ... senao ... fimse. Usado para fluxos mutuamente exclusivos.

Estruturas Condicionais Aninhadas

Condicionais inseridas dentro de outras para múltiplos testes. Ex: se (nota >= 7) entao ... senao se (nota >= 5) ... fimse. Usado para faixas de descontos.

Estrutura Escolha-Caso (Switch Case)

Avalia o valor exato de uma variável entre múltiplos casos. Ex: escolha(opcao) caso 1 ... outrocaso ... fimescolha. Usado para criação de menus interativos.

Estrutura de Repetição: Enquanto (While)

Repete um bloco enquanto o teste lógico no início for verdadeiro. Ex: enquanto (c <= 10) faca c <- c + 1 fimenquanto. Usado quando não sabemos o fim exato.

Estrutura de Repetição: Repita-Até (Do While)

Executa o bloco e testa no final, repetindo até o teste ser verdadeiro. Ex: repita c <- c + 1 ate (c > 10). Usado para menus que devem rodar ao menos uma vez.

Estrutura de Repetição: Para (For)

Repete um bloco com controle automático de contagem fixa. Ex: para c de 1 ate 10 faca ... fimpara. Usado quando o número exato de repetições é conhecido.

Passo no laço Para

Define o incremento ou decremento do laço. Ex: para c de 10 ate 0 passo -2 faca ... fimpara. Usado para contagens regressivas e saltos específicos.

Variável Contadora

Variável somada a um valor constante para rastrear iterações. Ex: cont <- cont + 1. Usado para contar usuários cadastrados ou voltas em laços.

Variável Acumuladora (Somador)

Variável que acumula a soma de valores variáveis. Ex: total <- total + preco. Usado para somar totais de carrinhos de compras e médias.

Interrupção de Laço (Interrompa / Break)

Força a saída imediata de uma estrutura de repetição. Ex: se (sair = "S") entao interrompa fimse. Usado para abortar execuções após erro ou comando de saída.

Vetor (Array Unidimensional)

Estrutura de dados homogênea indexada de tamanho fixo. Ex: var notas: vetor[1..4] de real. Usado para armazenar conjuntos de dados de mesmo tipo.

Acesso a Posição do Vetor

Uso de índice numérico para ler ou escrever no elemento. Ex: notas[1] <- 8.5. Usado para manipular um dado individual dentro de uma lista indexada.

Varredura de Vetor

Uso do laço Para para percorrer todas as posições do vetor. Ex: para i de 1 ate 4 faca leia(v[i]) fimpara. Usado para processar listas inteiras de itens.

Busca Simples em Vetor

Percorrer o vetor para verificar se um dado existe nele. Ex: se (v[i] = busca) entao achei <- VERDADEIRO fimse. Usado para localizar nomes e códigos cadastrados.

Ordenação de Vetor

Algoritmo para ordenar elementos em ordem crescente ou decrescente. Ex: laços aninhados trocando v[i] e v[j] se v[i] > v[j]. Usado em rankings e relatórios.

Matriz (Array Bidimensional)

Estrutura de dados em grade composta por linhas e colunas. Ex: var mat: vetor[1..3, 1..3] de inteiro. Usado em jogos como jogo da velha e tabelas.

Varredura de Matriz

Uso de laços aninhados (um para linha e outro para coluna). Ex: para l de 1 ate 3 faca para c de 1 ate 3 faca ... Usado para preencher e imprimir matrizes.

Diagonal Principal de Matriz

Elementos da matriz onde o índice da linha é igual ao da coluna (l = c). Ex: se (l = c) entao escreva(m[l,c]) fimse. Usado em operações de álgebra linear.

Modularização

Divisão de um programa grande em blocos menores e independentes. Ex: separação em procedimentos e funções. Usado para organização e reuso de código.

Procedimento (Procedure)

Sub-rotina que executa uma tarefa sem retornar valor. Ex: procedimento Topo() inicio escreval("--") fimprocedimento. Usado para cabeçalhos e rotinas.

Função (Function)

Sub-rotina que calcula e devolve obrigatoriamente um valor ao chamador. Ex: funcao Somar(a, b: inteiro): inteiro. Usado para operações que geram respostas.

Passagem de Parâmetro por Valor

Envia uma cópia do dado para a sub-rotina sem alterar a variável original. Ex: procedimento Teste(x: inteiro). Usado para processar dados de forma segura.

Passagem de Parâmetro por Referência

Envia o endereço da variável original, alterando-a diretamente fora. Ex: procedimento Soma(var x: inteiro). Usado para atualizar variáveis externas.

Escopo de Variável Local

Variável declarada dentro de uma sub-rotina, existindo apenas nela. Ex: var n: inteiro dentro de um procedimento. Usado para evitar conflito de nomes.

Escopo de Variável Global

Variável declarada no algoritmo principal, acessível em qualquer parte. Ex: var total: real no bloco principal. Usado para estados globais do sistema.

Retorno de Função (retorne)

Instrução que encerra a função entregando o resultado produzido. Ex: retorne a + b. Usado para repassar resultados a cálculos subsequentes.

Recursividade

Técnica onde uma função chama a si mesma até um caso base. Ex: funcao Fat(n: inteiro): inteiro ... retorne n * Fat(n-1). Usado em fatoriais e buscas em árvores.

Depuração (Debug)

Executar o código passo a passo para rastrear valores e falhas. Ex: monitorar a variável cont a cada linha no Visualg. Usado para encontrar bugs de lógica.

Loop Infinito

Falha em que o laço nunca atinge o critério de parada, travando o sistema. Ex: enquanto (cont <= 5) faca (sem cont <- cont + 1). Evitado com incrementos.