Lógica de Programação para Analista Judiciário - TI: fundamentos e resolução de problemas

Fundamentos de raciocínio lógico aplicado à programação

Em concursos para Analista Judiciário – TI, “lógica de programação” costuma ser cobrada como a capacidade de ler, prever e corrigir o comportamento de algoritmos. O foco não é uma linguagem específica, e sim o entendimento de: tipos de dados, variáveis, operadores, expressões e sua precedência, entrada/saída e controle de fluxo (decisão e repetição). Também são frequentes questões de rastreio de execução (dry run), identificação de erros e análise informal de complexidade (quantas operações crescem com o tamanho da entrada).

Tipos de dados (noções essenciais)

Tipos de dados definem o “formato” e as operações válidas sobre um valor. Em provas, é comum confundir conversões, comparações e operações entre tipos.

• Inteiro (int): números sem parte decimal (ex.: -2, 0, 15). Operações: +, -, *, divisão inteira (dependendo do pseudocódigo), resto (mod).
• Real (float/double): números com parte decimal (ex.: 3,14). Atenção a divisões: 5/2 pode ser 2 (inteiro) ou 2,5 (real) conforme o tipo/regra.
• Booleano (bool): verdadeiro/falso. Usado em condições e expressões lógicas.
• Caractere (char): um símbolo (ex.: 'A', '7').
• String: sequência de caracteres (ex.: "TJ", "123").

Padrão de prova: comparar string com número, ou somar string com número, costuma exigir conversão explícita (ex.: "10" → 10).

Variáveis e atribuição

Variável é um “nome” associado a um valor armazenado. A atribuição altera o valor da variável.

• Declaração (em pseudocódigo): define nome e tipo (quando aplicável).
• Atribuição: geralmente representada por “←” ou “:=”.

inteiro x, y
x ← 10
y ← x + 5   // y = 15
x ← y - 3   // x = 12

Armadilha comum: confundir “=” como atribuição vs. comparação. Em muitos pseudocódigos, “=” aparece como comparação e “←” como atribuição.

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

Operadores: aritméticos, relacionais e lógicos

Operadores formam expressões. Em concursos, a cobrança recai em: precedência, curto-circuito e diferenças entre divisão e resto.

• Aritméticos: +, -, *, /, div (divisão inteira), mod (resto).
• Relacionais: >, <, >=, <=, =, ≠ (resultam em booleano).
• Lógicos: e (AND), ou (OR), não (NOT).

// Exemplo de mod e div
inteiro a, b
a ← 17 div 5   // a = 3
b ← 17 mod 5   // b = 2

Curto-circuito (quando aplicável): em “A e B”, se A for falso, B pode nem ser avaliado; em “A ou B”, se A for verdadeiro, B pode nem ser avaliado. Provas exploram isso para evitar divisão por zero.

// Se houver curto-circuito, evita erro quando x = 0
se (x ≠ 0) e (10 / x > 2) entao
   escreva("ok")
fimse

Expressões e precedência

Precedência define a ordem de avaliação. Quando houver dúvida, use parênteses. Questões de rastreio frequentemente dependem de uma precedência “clássica”.

• 1) Parênteses
• 2) Não (NOT)
• 3) Multiplicação/divisão/mod
• 4) Soma/subtração
• 5) Relacionais
• 6) E (AND)
• 7) Ou (OR)

// Avalie com cuidado
inteiro x
x ← 2 + 3 * 4      // x = 14
x ← (2 + 3) * 4    // x = 20

// Mistura de relacionais e lógicos
booleano r
r ← (3 > 2) e (2 > 5) ou (1 = 1)
// Com precedência: e antes de ou
// (verdadeiro e falso) ou verdadeiro => falso ou verdadeiro => verdadeiro

Entrada e saída (I/O) e validação simples

Entrada/saída aparece em algoritmos de prova para simular leitura de dados e impressão de resultados. O ponto crítico é entender o estado das variáveis após cada leitura.

inteiro idade
leia(idade)
se idade >= 18 entao
   escreva("maior")
senao
   escreva("menor")
fimse

Padrão de prova: leitura em sequência e reuso de variável.

inteiro x
leia(x)        // x recebe o primeiro valor
x ← x + 1
leia(x)        // x é sobrescrito pelo segundo valor (perde o anterior)
escreva(x)

Controle de fluxo: decisão e repetição

Decisão (se/senão e encadeamentos)

Estruturas condicionais escolhem caminhos. Em provas, é comum pedir o valor final de uma variável após múltiplos “se”.

inteiro x
x ← 7
se x > 10 entao
   x ← x - 2
senao se x > 5 entao
   x ← x + 3
senao
   x ← x * 2
fimse
// x = 10

Passo a passo prático (rastreio):

• Comece com os valores iniciais.
• Avalie a condição do primeiro “se”.
• Se for falso, vá para o próximo “senao se”.
• Execute apenas o bloco do primeiro teste verdadeiro (em encadeamento).
• Atualize o valor das variáveis e siga.

Repetição: enquanto, para, repita-até

Laços repetem um bloco enquanto uma condição for satisfeita. A cobrança mais comum é: quantas vezes executa, qual o valor final e se há risco de loop infinito.

Enquanto (while)

inteiro i, soma
i ← 1
soma ← 0
enquanto i <= 5 faca
   soma ← soma + i
   i ← i + 1
fimenquanto
// soma = 15

Passo a passo prático (contagem de iterações):

• Verifique a condição antes de entrar no laço.
• Conte uma iteração a cada execução do bloco.
• Garanta que alguma variável do teste seja atualizada (senão, pode virar infinito).

Para (for)

inteiro i, p
p ← 1
para i de 1 ate 4 faca
   p ← p * 2
fimpara
// p = 16

Padrão de prova: limites inclusivos ("de 1 até 4" executa 4 vezes) e passo (incremento/decremento).

Repita-até (do-while)

Executa ao menos uma vez e só depois testa a condição de parada.

inteiro x
x ← 0
repita
   x ← x + 1
ate x = 3
// x = 3

Algoritmos com pseudocódigo e fluxogramas

Pseudocódigo: padrões de escrita e leitura

Pseudocódigo é uma forma padronizada de descrever algoritmos. Em provas, o essencial é interpretar corretamente atribuições, condições e laços, independentemente da sintaxe exata.

Modelo de pseudocódigo (estrutura típica):

algoritmo Nome
   // declarações
   // entradas
   // processamento
   // saídas
fimalgoritmo

Fluxogramas: como “traduzir” para execução

Fluxogramas representam o fluxo com símbolos. Mesmo sem desenhar, você deve saber ler a lógica:

• Início/Fim: terminal.
• Processo: atribuições e cálculos.
• Entrada/Saída: leia/escreva.
• Decisão: losango com ramificações (sim/não).

Passo a passo prático (fluxograma → rastreio):

• Comece no “Início”.
• Siga as setas, executando cada bloco.
• Em decisões, escolha o ramo conforme a condição.
• Em laços, observe a seta de retorno e o ponto de teste.

Padrões de concurso: rastreio, erros e complexidade informal

Rastreio de execução (dry run) com tabela

Uma técnica segura é montar uma tabela com as variáveis relevantes e atualizar a cada passo/iteração.

inteiro i, x
x ← 0
para i de 1 ate 3 faca
   x ← x + i
fimpara
escreva(x)

Tabela de rastreio:

Iteração   i   x (antes)   x (depois)
Inicial    -      0           0
1          1      0           1
2          2      1           3
3          3      3           6

Saída: 6.

Identificação de erros comuns

• Erro de inicialização: usar variável sem valor definido.
• Erro de atualização: esquecer i ← i + 1 no enquanto.
• Condição invertida: usar < quando deveria ser <=.
• Off-by-one: laço executa uma vez a mais/menos por causa dos limites.
• Divisão por zero: condição não protege o denominador.
• Sombreamento/reuso: ler novamente em variável e perder valor anterior.

// Exemplo de loop infinito (erro): i nunca muda
inteiro i
i ← 1
enquanto i <= 3 faca
   escreva(i)
   // faltou: i ← i + 1
fimenquanto

Análise de complexidade informal (sem formalismo pesado)

Em concursos, pode aparecer como “ordem de crescimento” ou “quantidade de operações” conforme n aumenta. A ideia é estimar quantas vezes um bloco executa.

• O(1): constante (não depende de n). Ex.: atribuições simples.
• O(n): um laço que vai de 1 até n.
• O(n²): dois laços aninhados até n.

// O(n): executa n vezes
para i de 1 ate n faca
   x ← x + 1
fimpara

// O(n^2): executa n*n vezes
para i de 1 ate n faca
   para j de 1 ate n faca
      x ← x + 1
   fimpara
fimpara

Padrão de prova: laços com passo diferente (ex.: i dobra) sugerem crescimento logarítmico.

// Aproximadamente O(log n): i assume 1,2,4,8,...
i ← 1
enquanto i <= n faca
   i ← i * 2
fimenquanto

Exercícios estilo prova (simulação objetiva)

Questão 1 (precedência e tipos)

Considere o pseudocódigo:

inteiro x
booleano b
x ← 10
b ← (x / 4 >= 2) e (x mod 3 = 1)
escreva(b)

Assumindo que “/” é divisão real e o resultado de (x / 4) é 2,5, o valor impresso é:

• A) verdadeiro
• B) falso

Questão 2 (rastreio de laço enquanto)

Considere:

inteiro i, s
i ← 1
s ← 0
enquanto i < 5 faca
   s ← s + (i * 2)
   i ← i + 2
fimenquanto
escreva(s)

O valor impresso é:

• A) 6
• B) 8
• C) 12
• D) 16

Questão 3 (off-by-one em para)

Considere:

inteiro i, c
c ← 0
para i de 0 ate 4 faca
   c ← c + 1
fimpara
escreva(c)

Quantas vezes o corpo do laço executa?

• A) 4
• B) 5
• C) 6
• D) Depende do compilador

Questão 4 (curto-circuito e divisão por zero)

Considere:

inteiro x
x ← 0
se (x ≠ 0) e (10 / x > 1) entao
   escreva("A")
senao
   escreva("B")
fimse

Assumindo avaliação com curto-circuito, a saída é:

• A) A
• B) B
• C) Erro de divisão por zero

Questão 5 (identificação de erro lógico)

Um algoritmo deveria somar os números de 1 a n (n >= 1), mas está incorreto:

inteiro n, i, soma
leia(n)
soma ← 0
para i de 1 ate n faca
   soma ← soma + 1
fimpara
escreva(soma)

Qual é o erro?

• A) O laço deveria começar em 0
• B) Deveria somar i, não 1
• C) soma deveria iniciar com 1
• D) n deveria ser real

Questão 6 (complexidade informal)

Considere o algoritmo:

inteiro i, j, x
x ← 0
para i de 1 ate n faca
   j ← 1
   enquanto j <= n faca
      x ← x + 1
      j ← j * 2
   fimenquanto
fimpara

A ordem de crescimento mais adequada é:

• A) O(1)
• B) O(n)
• C) O(n log n)
• D) O(n^2)

Questão 7 (interpretação de trecho e valor final)

Considere:

inteiro a, b, t
a ← 3
b ← 5
se a > b entao
   t ← a
   a ← b
   b ← t
fimse
escreva(a, b)

O que é impresso?

• A) 3 5
• B) 5 3
• C) 3 3
• D) 5 5

Questão 8 (simulação com entrada)

Considere que a entrada lida é: x = 2 e depois y = 3. Analise:

inteiro x, y, z
leia(x)
leia(y)
z ← x
x ← y
y ← z
escreva(x, y)

A saída é:

• A) 2 3
• B) 3 2
• C) 2 2
• D) 3 3