Preparatório Caixa TI: Lógica de Programação aplicada à prova

Conceitos essenciais: variáveis, tipos e atribuição

Em provas, “lógica de programação” costuma ser cobrada com pseudocódigo (Portugol) e exige atenção a detalhes: o que é armazenado, quando é calculado e como é comparado.

Variáveis e atribuição

Variável é um espaço de memória identificado por um nome, que guarda um valor. Atribuição é o comando que coloca um valor na variável. Em pseudocódigo, é comum usar <- para atribuir.

// Atribuição (o lado direito é avaliado antes de guardar no lado esquerdo)\nidade <- 18\nidade <- idade + 1  // agora idade vale 19

Pegadinha comum: x <- x + 1 é válido (incremento), mas x = x + 1 pode significar comparação em algumas linguagens; na prova, veja a notação adotada.

Tipos de dados mais cobrados

• Inteiro: números sem parte decimal (ex.: -2, 0, 10).
• Real: números com parte decimal (ex.: 2,5; 3.14).
• Lógico/Booleano: verdadeiro ou falso.
• Caractere/Texto: letras e cadeias (ex.: 'A', "Caixa").

Pegadinha comum: divisão entre inteiros pode gerar resultado inteiro (truncado) em alguns pseudocódigos. Se o enunciado não for explícito, observe exemplos do próprio padrão da banca.

Entrada, saída e conversões

Entrada lê valores (ex.: leia), saída exibe (ex.: escreva). Conversão transforma o tipo do dado (ex.: texto para inteiro).

Continue em nosso aplicativo

Você poderá ouvir o audiobook com a tela desligada, ganhar gratuitamente o certificado deste curso e ainda ter acesso a outros 5.000 cursos online gratuitos.

ou continue lendo abaixo...

Baixar o aplicativo

// Exemplo de leitura e conversão\nleia(s)              // s é texto, por exemplo "20"\nidade <- inteiro(s)   // converte para 20\nescreva(idade + 1)   // 21

Pegadinhas: concatenar texto vs somar números. Se s for texto, s + 1 pode ser inválido ou virar concatenação dependendo da convenção; por isso a conversão é cobrada.

Operadores, expressões e precedência

Operadores aritméticos

• + soma
• - subtração
• * multiplicação
• / divisão
• % ou mod resto da divisão

// Resto (muito cobrado)\n7 mod 3 = 1\n10 mod 5 = 0

Operadores relacionais

• >, <, >=, <=
• = ou == (igualdade, depende do padrão)
• != ou <> (diferente)

Resultado de uma comparação é lógico: verdadeiro/falso.

Operadores lógicos

• e (AND)
• ou (OR)
• nao (NOT)

Precedência (ordem de avaliação)

Uma ordem típica cobrada: parênteses > nao > * / mod > + - > relacionais > e > ou. Se houver dúvida, use parênteses para forçar a ordem.

// Exemplo de precedência\nresultado <- 2 + 3 * 4      // 14, não 20\nresultado <- (2 + 3) * 4    // 20

Tabelas-verdade e avaliação de expressões lógicas

Tabela-verdade de AND, OR e NOT

AND (e): só é verdadeiro se ambos forem verdadeiros.

V e V = V\nV e F = F\nF e V = F\nF e F = F

OR (ou): é verdadeiro se pelo menos um for verdadeiro.

V ou V = V\nV ou F = V\nF ou V = V\nF ou F = F

NOT (nao): inverte o valor lógico.

nao V = F\nnao F = V

Avaliação passo a passo (pegadinha de precedência)

Considere: nao A ou B e C. Pela precedência típica: primeiro nao, depois e, por fim ou. Então equivale a: (nao A) ou (B e C).

// Exemplo com valores\nA = V, B = V, C = F\nnao A = F\nB e C = V e F = F\n(F) ou (F) = F

Curto-circuito (quando a banca mencionar)

Em algumas linguagens, A ou B não avalia B se A já for verdadeiro; e A e B não avalia B se A já for falso. Se o pseudocódigo da questão sugerir esse comportamento, isso pode afetar expressões com funções que têm efeitos colaterais (ex.: incrementos).

Estruturas de controle: condicionais

Se / Senão (if/else)

Executa um bloco quando a condição é verdadeira; caso contrário, executa o bloco alternativo (se existir).

se (nota >= 7) entao\n  escreva("Aprovado")\nsenao\n  escreva("Reprovado")\nfimse

Encadeamento e “senão se”

Usado para múltiplas faixas. Pegadinha: a primeira condição verdadeira “captura” o fluxo; a ordem importa.

se (x > 0) entao\n  escreva("positivo")\nsenao se (x = 0) entao\n  escreva("zero")\nsenao\n  escreva("negativo")\nfimse

Passo a passo prático: classificação com faixas

Objetivo: dado salario, classificar em A/B/C.

• Passo 1: ler salario.
• Passo 2: testar a faixa mais restritiva primeiro (por exemplo, maior salário primeiro ou menor primeiro, mas sem sobreposição).
• Passo 3: imprimir a classe.

leia(salario)\nse (salario >= 10000) entao\n  classe <- "A"\nsenao se (salario >= 5000) entao\n  classe <- "B"\nsenao\n  classe <- "C"\nfimse\nescreva(classe)

Estruturas de controle: laços (repetição)

Para (for)

Usado quando se sabe a quantidade de repetições. Pegadinha: limites inclusivos e passo (incremento).

// i vai de 1 até 5 (inclusivo)\npara i de 1 ate 5 faca\n  escreva(i)\nfimpara

Enquanto (while)

Repete enquanto a condição for verdadeira. Pegadinha: se a condição começar falsa, o bloco não executa nenhuma vez.

leia(x)\nenquanto (x > 0) faca\n  escreva(x)\n  x <- x - 1\nfimenquanto

Repita...até (do-while)

Executa pelo menos uma vez e só para quando a condição do ate for verdadeira.

repita\n  leia(x)\nate (x >= 0)

Passo a passo prático: somatório com sentinela

Objetivo: ler números até digitar 0; somar os positivos.

• Passo 1: iniciar soma <- 0.
• Passo 2: ler n.
• Passo 3: enquanto n != 0, se n > 0 somar; ler próximo.

soma <- 0\nleia(n)\nenquanto (n != 0) faca\n  se (n > 0) entao\n    soma <- soma + n\n  fimse\n  leia(n)\nfimenquanto\nescreva(soma)

Pegadinha: esquecer de ler novamente dentro do laço causa loop infinito.

Modularização: procedimentos, funções, parâmetros e escopo

Procedimentos vs funções

• Procedimento: executa ações; pode ou não alterar variáveis; normalmente não “retorna” valor.
• Função: calcula e retorna um valor.

// Função: retorna o maior de dois inteiros\nfuncao maior(a, b): inteiro\n  se (a > b) entao\n    retorne a\n  senao\n    retorne b\n  fimse\nfimfuncao

// Procedimento: imprime uma linha\nprocedimento imprimeLinha(msg)\n  escreva(msg)\nfimprocedimento

Passagem de parâmetros: por valor e por referência

Em provas, pode aparecer a distinção:

• Por valor: a função recebe uma cópia; alterar o parâmetro não altera a variável original.
• Por referência: a função recebe “acesso” à variável original; alterar o parâmetro altera a variável original.

// Exemplo conceitual (pseudocódigo pode indicar 'ref')\nprocedimento incrementa(ref x)\n  x <- x + 1\nfimprocedimento\n\na <- 10\nincrementa(a)\n// a vira 11 se for por referência

Pegadinha: quando não está explícito, muitas bancas assumem passagem por valor em funções e por referência apenas quando indicado.

Escopo: variável local vs global

Escopo define onde a variável “existe” e pode ser usada.

• Local: declarada dentro de função/procedimento; não é acessível fora.
• Global: declarada fora; acessível em vários pontos (dependendo do pseudocódigo).

contador <- 0  // global\n\nprocedimento somaUm()\n  contador <- contador + 1\nfimprocedimento

Pegadinha: se houver uma variável local com o mesmo nome da global, a local pode “sombrar” a global (shadowing), e a global não muda.

Estruturas de dados básicas: vetores, matrizes e registros

Vetores (arrays 1D)

Um vetor armazena vários valores do mesmo tipo, acessados por índice. Pegadinhas: índice começando em 0 ou 1; limites do vetor.

// Vetor de 5 posições (exemplo com índices 1..5)\npara i de 1 ate 5 faca\n  leia(v[i])\nfimpara\n\nmaior <- v[1]\npara i de 2 ate 5 faca\n  se (v[i] > maior) entao\n    maior <- v[i]\n  fimse\nfimpara\nescreva(maior)

Matrizes (arrays 2D)

Uma matriz é um “vetor de vetores”, acessado por linha e coluna.

// Soma de uma matriz 2x3\nsoma <- 0\npara i de 1 ate 2 faca\n  para j de 1 ate 3 faca\n    leia(m[i][j])\n    soma <- soma + m[i][j]\n  fimpara\nfimpara\nescreva(soma)

Pegadinha: confundir ordem dos índices (linha/coluna) e errar limites do laço.

Registros (struct)

Registro agrupa campos de tipos possivelmente diferentes (ex.: nome, idade, saldo).

// Registro cliente\nregistro Cliente\n  nome: texto\n  idade: inteiro\n  saldo: real\nfimregistro\n\ncliente1.nome <- "Ana"\ncliente1.idade <- 30\ncliente1.saldo <- 150.75

Pegadinha: acessar campo errado ou confundir atribuição do registro inteiro com atribuição de campos.

Noções de complexidade (nível edital): tempo e memória

Tempo: contagem de operações por laços

Em geral, a banca cobra a ideia de crescimento:

• O(1): constante (ex.: acessar v[i]).
• O(n): um laço simples até n.
• O(n²): laços aninhados (ex.: matriz n x n).

// O(n)\npara i de 1 ate n faca\n  x <- x + 1\nfimpara\n\n// O(n^2)\npara i de 1 ate n faca\n  para j de 1 ate n faca\n    x <- x + 1\n  fimpara\nfimpara

Memória: tamanho de estruturas

Vetores e matrizes consomem memória proporcional ao número de elementos. Registros consomem a soma dos campos. Pegadinha: criar uma matriz grande pode ser inviável; a banca pode perguntar qual estrutura usa mais memória.

Questões-modelo comentadas (pseudocódigo e pegadinhas)

Questão 1 (precedência aritmética)

Considere x <- 10. Qual o valor de y após executar y <- x + 2 * 3?

Comentário: multiplicação tem precedência sobre soma. Primeiro 2*3=6, depois 10+6=16. Logo, y=16.

Questão 2 (mod e paridade)

Um número é par quando n mod 2 = 0. Se n = 15, a condição (n mod 2 = 0) é verdadeira ou falsa?

Comentário: 15 mod 2 = 1. Então 1 = 0 é falso. Pegadinha: confundir “resto” com “quociente”.

Questão 3 (divisão inteira vs real)

Considere a <- 5 e b <- 2. Avalie c <- a / b em um pseudocódigo que define divisão inteira quando ambos são inteiros.

Comentário: 5/2 vira 2 (truncamento). Se a questão quiser 2,5, normalmente indicará tipo real ou conversão: c <- real(a) / b.

Questão 4 (tabela-verdade e precedência lógica)

Se A = verdadeiro, B = falso, C = verdadeiro, qual o valor de nao A ou B e C?

Comentário: Pela precedência: nao primeiro, depois e, depois ou. Então: nao A = falso. B e C = falso e verdadeiro = falso. Por fim: falso ou falso = falso.

Questão 5 (condicional com faixas e ordem)

Dado o código:

se (x >= 0) entao\n  escreva("N")\nsenao se (x >= 10) entao\n  escreva("M")\nsenao\n  escreva("P")\nfimse

Para x = 12, o que é impresso?

Comentário: A primeira condição x >= 0 já é verdadeira para 12, então imprime "N" e não testa o resto. Pegadinha: a faixa x >= 10 ficou “inacessível” porque está depois de uma condição mais ampla.

Questão 6 (laço: enquanto e atualização)

Considere:

x <- 3\nenquanto (x > 0) faca\n  escreva(x)\n  x <- x - 2\nfimenquanto

O que é impresso?

Comentário: Iteração 1: imprime 3, x vira 1. Iteração 2: imprime 1, x vira -1. Para porque x > 0 é falso. Saída: 3 e 1 (nessa ordem). Pegadinha: achar que imprime 3,2,1 (isso seria outro decremento).

Questão 7 (vetor e índice)

Um vetor v tem 3 posições e contém: v[1]=2, v[2]=4, v[3]=6. Qual o valor de s após:

s <- 0\npara i de 1 ate 3 faca\n  s <- s + v[i]\nfimpara

Comentário: Soma: 0+2=2, 2+4=6, 6+6=12. Logo s=12. Pegadinha: errar o limite e somar só até 2 ou tentar acessar v[0].

Questão 8 (função e passagem por valor)

Considere:

funcao f(x): inteiro\n  x <- x + 10\n  retorne x\nfimfuncao\n\na <- 5\nb <- f(a)

Quais são os valores finais de a e b?

Comentário: Em passagem por valor, a não muda. A função retorna 15. Então a=5 e b=15. Pegadinha: achar que a vira 15 sem referência explícita.

Questão 9 (matriz e laços aninhados)

Considere uma matriz 2x2 com valores:

m[1][1]=1, m[1][2]=2\nm[2][1]=3, m[2][2]=4

Qual o valor de s após:

s <- 0\npara i de 1 ate 2 faca\n  para j de 1 ate 2 faca\n    se (i = j) entao\n      s <- s + m[i][j]\n    fimse\n  fimpara\nfimpara

Comentário: Soma da diagonal principal: m[1][1]=1 e m[2][2]=4. Logo s=5. Pegadinha: somar a diagonal secundária por engano (condição seria i + j = 3 em 2x2 com índices 1..2).

Questão 10 (complexidade: identificar crescimento)

Qual a ordem de tempo do trecho abaixo em função de n?

para i de 1 ate n faca\n  para j de 1 ate n faca\n    para k de 1 ate 5 faca\n      x <- x + 1\n    fimpara\n  fimpara\nfimpara

Comentário: O laço de k é constante (5). Então o total cresce como n * n * 5, isto é, O(n²). Pegadinha: marcar O(n³) só por ver três laços, ignorando que um deles é constante.