Estruturas de decisão e repetição para Analista Judiciário - TI: condições, laços e validações

Estruturas de decisão: if/else e switch

Estruturas de decisão controlam o fluxo do algoritmo com base em uma condição (expressão booleana). Em concursos, o foco costuma estar em: precedência de operadores, curto-circuito (&& e ||), comparação correta (== vs !=), e efeitos colaterais em expressões (incrementos dentro de condições).

if/else: leitura e armadilhas comuns

No if, a condição é avaliada como verdadeira ou falsa. Se verdadeira, executa o bloco do if; caso contrário, executa o bloco do else (se existir). Cadeias else if são avaliadas em ordem: a primeira condição verdadeira “ganha” e as demais não são avaliadas.

// Exemplo genérico (pseudocódigo estilo C/Java) if (nota >= 60) { status = "APROVADO"; } else if (nota >= 40) { status = "RECUPERACAO"; } else { status = "REPROVADO"; }

Pegadinhas frequentes:

• Ordem das condições: colocar uma condição mais ampla antes de uma mais específica pode “engolir” casos. Ex.: testar nota >= 40 antes de nota >= 60 torna o segundo teste inútil.
• Chaves omitidas: sem chaves, apenas a próxima instrução pertence ao if. Em prova, isso muda completamente a saída.
• Comparação vs atribuição: em linguagens como C, if (x = 0) atribui e avalia o resultado; em Java/C#, isso é erro. Em questões, identifique a linguagem-alvo.
• Precedência: ! tem precedência alta; && antes de ||. Use parênteses para “enxergar” a intenção.

Curto-circuito (short-circuit) em && e ||

Em A && B, se A for falso, B não é avaliado. Em A || B, se A for verdadeiro, B não é avaliado. Isso impacta tanto desempenho quanto efeitos colaterais (incrementos, chamadas de função, validações).

int x = 0; boolean ok = (x != 0) && (10 / x > 1); // Não divide por zero porque (x != 0) é falso e a segunda parte não roda

Em questões, observe quando a segunda parte teria erro (divisão por zero, acesso a índice inválido) ou alteraria variáveis (ex.: i++ dentro da condiçã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

switch: seleção por casos

switch seleciona um bloco com base no valor de uma expressão (inteiro, caractere, enum e, em algumas linguagens, string). A principal pegadinha é o fall-through (queda para o próximo caso) quando não há break.

int dia = 2; String nome; switch (dia) { case 1: nome = "SEG"; break; case 2: nome = "TER"; // sem break case 3: nome = "QUA"; break; default: nome = "INV"; } // Para dia=2, nome termina como "QUA" por fall-through

Boas práticas para prova:

• Procure break (ou return) em cada caso.
• Verifique se há casos agrupados intencionalmente (vários case antes de um bloco).
• Considere o default como “caso nenhum” e avalie se ele pode ser atingido.

Estruturas de repetição: for, while, do-while

Laços repetem um bloco enquanto uma condição for satisfeita (ou até uma condição de parada). Em concursos, erros típicos envolvem: limites (< vs <=), inicialização, atualização da variável de controle, e alteração da condição dentro do laço.

for: quando há contagem clara

O for costuma ter três partes: inicialização; condição; atualização. A ordem de execução é: inicializa (uma vez) → testa condição → executa bloco → executa atualização → volta a testar condição.

int soma = 0; for (int i = 1; i <= 3; i++) { soma += i; } // soma = 1+2+3 = 6

Pegadinhas frequentes:

• Off-by-one: trocar < por <= muda a quantidade de iterações.
• Atualização não padrão: i += 2, i--, ou atualização no corpo do laço.
• Variável de controle alterada no corpo: pode pular valores ou gerar laço infinito.

while: repetição condicionada (pré-teste)

No while, a condição é testada antes de cada iteração. Se começar falsa, o bloco não executa nenhuma vez.

int i = 0; int cont = 0; while (i < 3) { cont++; i++; } // cont = 3

Use while quando a quantidade de repetições depende de eventos/validações (por exemplo, “enquanto a entrada for inválida”).

do-while: repetição com pós-teste

No do-while, o bloco executa pelo menos uma vez, pois a condição é testada ao final.

int i = 5; int cont = 0; do { cont++; i++; } while (i < 3); // cont = 1 (executa uma vez mesmo com condição falsa)

Em prova, compare while vs do-while quando a condição inicial é falsa: o resultado muda.

Laços aninhados e contagem de iterações

Laços aninhados (um laço dentro de outro) são comuns em varredura de matrizes, tabelas e combinações. A pegadinha típica é confundir o número total de execuções do laço interno: ele roda completamente para cada iteração do laço externo (salvo break/continue).

int c = 0; for (int i = 1; i <= 2; i++) { for (int j = 1; j <= 3; j++) { c++; } } // c = 2*3 = 6

Cuidados em aninhamento:

• Reinicialização do contador interno: j normalmente reinicia a cada novo i.
• Uso incorreto de variáveis: confundir i e j na condição ou atualização.
• Condição dependente: for (j=0; j<i; j++) gera contagem triangular (1+2+...); isso aparece em questões de complexidade e contagem.

Condições de parada: break, continue e sentinelas

Além da condição do laço, a parada pode ocorrer por comandos de controle:

• break: encerra o laço imediatamente.
• continue: pula para a próxima iteração (executa a atualização no for e volta ao teste).

int soma = 0; for (int i = 1; i <= 5; i++) { if (i == 3) continue; if (i == 5) break; soma += i; } // soma = 1 + 2 + 4 = 7

Sentinela é um valor especial que encerra a repetição, muito usado em leitura de entradas:

// Lê números até digitar -1 (sentinela) int x; int soma = 0; while (true) { x = lerInteiro(); if (x == -1) break; soma += x; }

Validação de entrada: padrões recorrentes em prova

Validação de entrada é garantir que um valor esteja dentro de regras (faixa, formato, não nulo). Em concursos, o que cai é a lógica do laço de validação e o uso correto de operadores lógicos.

Padrão 1: repetir enquanto inválido

int idade = lerInteiro(); while (idade < 0 || idade > 120) { idade = lerInteiro(); }

Observe o operador: para “inválido”, usa-se frequentemente || (fora do intervalo). Uma pegadinha comum é trocar por &&, tornando a condição impossível (ninguém é <0 e >120 ao mesmo tempo).

Padrão 2: validar com curto-circuito para evitar erro

// Evita acessar s[0] se string vazia (exemplo conceitual) if (s != null && s.length() > 0 && s.charAt(0) == 'A') { ... }

A ordem importa: primeiro valida nulidade, depois tamanho, depois acesso. Em prova, inverter a ordem pode gerar exceção/erro.

Padrão 3: menu com switch + laço

int op; do { op = lerInteiro(); switch (op) { case 1: executar(); break; case 0: break; default: // opção inválida } } while (op != 0);

O do-while é comum em menus porque garante ao menos uma exibição/entrada.

Depuração mental: como prever saídas sem executar

Depurar mentalmente é simular o algoritmo passo a passo, registrando valores de variáveis e decisões. Em prova, isso reduz erros em questões de “qual a saída?” e “quantas vezes executa?”.

Checklist de simulação

• Liste valores iniciais das variáveis.
• Para cada decisão, avalie a condição com os valores atuais (respeite precedência e parênteses).
• Para cada laço, marque: (1) teste da condição, (2) execução do corpo, (3) atualização da variável de controle.
• Em && e ||, verifique se há curto-circuito (parte direita pode não rodar).
• Em switch, procure break e identifique quedas.
• Em incrementos/decrementos, diferencie i++ (pós) de ++i (pré) quando usados em expressões.

Exemplo guiado 1: limites de loop e off-by-one

int c = 0; for (int i = 0; i <= 2; i++) { c += i; } // i: 0,1,2 => c=3

Passo a passo: inicia i=0 (condição verdadeira) soma 0; atualiza para 1; soma 1; atualiza para 2; soma 2; atualiza para 3; condição 3 <= 2 falsa, para. Trocar para i < 2 faria i=0,1 e c=1.

Exemplo guiado 2: curto-circuito com efeito colateral

int i = 0; boolean r = (i++ > 0) && (i++ > 0); // Avalie i e r ao final

Simulação: começa i=0. Avalia (i++ > 0): compara 0>0 (falso) e depois incrementa i para 1. Como é && e a esquerda é falsa, a direita não avalia. Resultado: r=false, i=1. Se fosse & (operador não curto-circuito em algumas linguagens), a direita avaliaria e i poderia virar 2.

Exemplo guiado 3: switch com fall-through

int x = 1; int y = 0; switch (x) { case 1: y += 10; case 2: y += 20; break; default: y += 99; } // y=?

Simulação: entra no case 1, soma 10. Sem break, cai no case 2, soma 20, encontra break. Logo y=30.

Pegadinhas comuns (lista rápida para revisão)

• Condição impossível: usar && quando deveria ser || (validação fora de faixa).
• Laço infinito: variável de controle não muda na direção da condição (ex.: while (i > 0) i++ começando em 1).
• Atualização duplicada: incrementa no cabeçalho e também no corpo.
• Uso de variável errada em laços aninhados (condição de j usando i sem querer).
• Pré vs pós-incremento dentro de expressões altera resultado.
• switch sem break gera quedas não percebidas.
• Comparação de limites: < vs <= muda contagem e índices válidos.

Exercícios (com níveis) e critérios de correção

Nível 1 (básico)

• 1) Dado int a=5; e int b=7;, escreva uma estrutura if/else que atribua max ao maior valor. Critérios: condição correta (a >= b ou a > b), atribuições coerentes, cobre empate se exigido.
• 2) Preveja a saída: int s=0; for(int i=1;i<=4;i++) s+=i;. Critérios: soma correta (1+2+3+4), entendimento do limite <=4.
• 3) Validação: escreva um while que repita a leitura de nota enquanto nota não estiver entre 0 e 100. Critérios: uso correto de || para “fora do intervalo”, atualização da variável dentro do laço.

Nível 2 (intermediário)

• 4) Preveja o valor final: int i=0; while(i<3){ i++; } e compare com do{ i++; }while(i<3); iniciando em i=3. Critérios: distinguir pré-teste e pós-teste; identificar quando executa 0 ou 1 vez.
• 5) Preveja: int c=0; for(int i=0;i<3;i++){ for(int j=0;j<i;j++){ c++; } }. Critérios: contagem triangular (0+1+2), resultado correto (c=3), reconhecer que j<i depende de i.
• 6) Dado int x=2;, avalie switch(x) com casos 1,2,3 e default, sendo que o case 2 não tem break. Determine a variável acumuladora final. Critérios: identificar fall-through e ponto exato do break.

Nível 3 (avançado)

• 7) Simule: int i=0; boolean r = (i++ == 0) || (i++ == 2); Determine r e i ao final. Critérios: curto-circuito em ||, efeito do pós-incremento, valores comparados vs valor final de i.
• 8) Identifique o erro lógico e corrija: while (n >= 0) { n = lerInteiro(); soma += n; } considerando que -1 é sentinela e não deve entrar na soma. Critérios: evitar somar sentinela; ordem correta (ler, testar, somar) ou uso de break.
• 9) Preveja a saída e justifique: int a=1,b=2; if(a++ > 1 && ++b > 2) { ... } Determine valores finais de a e b e se o bloco executa. Critérios: avaliar esquerda primeiro, curto-circuito no &&, diferença entre a++ e ++b.
• 10) Projete um algoritmo que percorra uma matriz 3x3 e conte quantos elementos são maiores que a soma de seus índices (i+j). Critérios: laços aninhados corretos, inicialização do contador, condição correta, limites de índices (0..2 ou 1..3 conforme padrão adotado) consistentes.