Lógica de Programação aplicada ao Agente de Tecnologia do Banco do Brasil

Sequência de raciocínio lógico para resolver problemas

Em provas e no dia a dia de TI bancária, “lógica de programação” é a habilidade de transformar uma regra de negócio em passos executáveis, verificáveis e sem ambiguidades. A sequência mais segura para resolver problemas é: (1) entender entradas e saídas, (2) definir variáveis e tipos, (3) escrever expressões com operadores e precedência, (4) estruturar decisões e repetições, (5) modularizar em funções/procedimentos, (6) rastrear a execução para validar o resultado.

Entradas, saídas e definição do problema

Antes de codificar, descreva: quais dados chegam (entrada), quais resultados devem sair (saída) e quais regras precisam ser respeitadas (restrições). Em contexto bancário, isso inclui validação de dados (ex.: CPF, agência/conta, valores monetários), elegibilidade (ex.: idade mínima, score, renda) e limites (ex.: valor máximo por transação).

• Entrada: dados fornecidos por usuário/sistema (ex.: valor, taxa, prazo, saldo, perfil).
• Saída: informação calculada/decisão (ex.: juros, parcela, “aprovado/reprovado”, mensagem de erro).
• Regra: condição que governa o resultado (ex.: “se saldo < valor, negar”).

Variáveis e tipos de dados

Variável é um “nome” para armazenar um valor que pode mudar durante a execução. Em pseudocódigo, declare com um tipo coerente para evitar erros lógicos (ex.: comparar texto com número, truncar decimais em dinheiro).

Tipos mais comuns em questões

• Inteiro: contagens, idades, quantidade de parcelas.
• Real/Decimal: valores monetários, taxas, juros (atenção a casas decimais).
• Lógico/Booleano: verdadeiro/falso (ex.: elegível, autenticado).
• Caractere/String: CPF, nome, código de agência (podem ter zeros à esquerda).

Exemplo prático (declaração e atribuição)

inteiro idade, parcelas
real valor, taxa, juros
logico elegivel
cadeia cpf

idade <- 21
valor <- 1000.00
taxa <- 0.02

Dica de prova: CPF, agência e conta frequentemente devem ser tratados como texto para não perder zeros à esquerda.

Operadores, precedência e expressões

Operadores combinam valores para formar expressões. A prova costuma cobrar resultado de expressões e armadilhas de precedência.

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

• Aritméticos: +, -, *, /, % (resto).
• Relacionais: >, <, >=, <=, =, ≠.
• Lógicos: E (AND), OU (OR), NÃO (NOT).

Precedência (ordem típica)

• Parênteses
• Multiplicação e divisão
• Adição e subtração
• Relacionais
• NÃO
• E
• OU

Exemplo de expressão com armadilha

// Considere: a=10, b=5, c=2
resultado1 <- a + b * c        // 10 + (5*2) = 20
resultado2 <- (a + b) * c      // (10+5)*2 = 30

Em condições, use parênteses para deixar a intenção explícita e evitar ambiguidades.

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

Entrada/saída é o “contrato” do algoritmo com o mundo externo. Em TI bancária, é comum validar: campos obrigatórios, faixas de valores, formato e consistência.

Passo a passo: validação de valor de transação

Objetivo: aceitar uma transferência apenas se o valor for positivo e não exceder o saldo.

real saldo, valor

leia(saldo)
leia(valor)

se valor <= 0 entao
    escreva("Valor invalido")
senao se valor > saldo entao
    escreva("Saldo insuficiente")
senao
    saldo <- saldo - valor
    escreva("Transferencia realizada")
    escreva("Novo saldo: ", saldo)
fimse

Tratamento de exceções lógicas: note que não é “erro de sistema”, mas regra de negócio impedindo a operação.

Rastreamento de execução (dry run) e tabela de variáveis

Rastrear execução é simular passo a passo, atualizando valores das variáveis. Em concurso, isso resolve questões de “qual será a saída?” e ajuda a encontrar bugs lógicos.

Exemplo com tabela de rastreamento

inteiro i
inteiro soma

soma <- 0
para i de 1 ate 4 faca
    soma <- soma + i
fimpara
escreva(soma)

• Início: soma=0
• i=1: soma=1
• i=2: soma=3
• i=3: soma=6
• i=4: soma=10
• Saída: 10

Estruturas condicionais

Condicionais implementam regras: se uma condição for verdadeira, execute um bloco; caso contrário, execute outro. Em provas, atenção a condições compostas e encadeamento (senão se).

Regras de elegibilidade (modelo de concurso)

Cenário: pré-aprovação de crédito didática. Regras: renda ≥ 2000, idade ≥ 18 e sem restrição cadastral.

inteiro idade
real renda
logico semRestricao

leia(idade)
leia(renda)
leia(semRestricao)

se (idade >= 18) E (renda >= 2000) E (semRestricao = verdadeiro) entao
    escreva("Elegivel")
senao
    escreva("Nao elegivel")
fimse

Boa prática: quebre condições longas em variáveis booleanas nomeadas para legibilidade.

logico maiorDeIdade, rendaMinima
maiorDeIdade <- (idade >= 18)
rendaMinima <- (renda >= 2000)

se maiorDeIdade E rendaMinima E semRestricao entao
    escreva("Elegivel")
senao
    escreva("Nao elegivel")
fimse

Fluxograma (condicional de saldo)

[Inicio]
   |
[Leia saldo, valor]
   |
{valor <= 0?}---sim-->[Escreva "Valor invalido"]-->[Fim]
   |
  nao
   |
{valor > saldo?}--sim-->[Escreva "Saldo insuficiente"]-->[Fim]
   |
  nao
   |
[saldo <- saldo - valor]
   |
[Escreva "OK" e novo saldo]
   |
 [Fim]

Laços de repetição (para, enquanto, repita-até)

Laços repetem um bloco enquanto uma condição for atendida. Em TI bancária, aparecem em validação (repetir até entrada válida), processamento de listas (transações) e acumulações (totais).

Passo a passo: repetir até digitar um valor válido

real valor

repita
    leia(valor)
    se valor <= 0 entao
        escreva("Digite um valor positivo")
    fimse
ate (valor > 0)

Somatório de transações do dia (acumulação)

Cenário: somar N lançamentos (valores positivos e negativos) para obter o total do dia.

inteiro n, i
real lancamento, total

leia(n)
total <- 0

para i de 1 ate n faca
    leia(lancamento)
    total <- total + lancamento
fimpara

escreva("Total do dia: ", total)

Armadilhas comuns em laços

• Condição de parada errada (loop infinito).
• Inicialização esquecida (ex.: total não começa em 0).
• Atualização ausente (ex.: i não incrementa no enquanto).

Funções e procedimentos: modularização e reuso

Modularizar é dividir o problema em partes menores. Funções retornam um valor; procedimentos executam ações (podem alterar variáveis por referência, dependendo da notação).

Exemplo: função para validar faixa de valor

funcao logico valorValido(real v)
    retorne (v > 0)
fimfuncao

real valor
leia(valor)
se valorValido(valor) entao
    escreva("OK")
senao
    escreva("Invalido")
fimse

Exemplo: procedimento para aplicar débito com checagens

procedimento debitar(real saldo, real valor)
    se valor <= 0 entao
        escreva("Valor invalido")
    senao se valor > saldo entao
        escreva("Saldo insuficiente")
    senao
        saldo <- saldo - valor
        escreva("Debito realizado. Novo saldo: ", saldo)
    fimse
fimprocedimento

Observação de prova: algumas notações de pseudocódigo não deixam claro se o parâmetro é por valor ou referência. Quando houver dúvida, a questão geralmente indica “retorne o novo saldo” (função) ou “atualize o saldo” (referência).

Escopo de variáveis

Escopo é onde a variável “existe” e pode ser usada. Variáveis locais (dentro de função/bloco) não devem ser acessadas fora; variáveis globais (quando existem) podem causar efeitos colaterais e confusão.

Exemplo de escopo (local vs. global)

real taxaGlobal

taxaGlobal <- 0.02

funcao real calcularJurosSimples(real principal, inteiro meses)
    real juros
    juros <- principal * taxaGlobal * meses
    retorne juros
fimfuncao

Boa prática: prefira passar a taxa como parâmetro para reduzir dependência de variável global.

Exemplos bancários: juros simples e composto

Juros simples (didático)

Fórmula: J = P × i × t, onde P é principal, i é taxa por período e t é número de períodos.

real P, i, J
inteiro t

leia(P)
leia(i)   // ex.: 0.02 para 2%
leia(t)

J <- P * i * t
escreva("Juros: ", J)
escreva("Montante: ", P + J)

Juros composto (didático)

Fórmula: M = P × (1 + i)^t. Em pseudocódigo, pode-se usar potência ou um laço multiplicando (1+i) t vezes.

real P, i, M
inteiro t, k

leia(P)
leia(i)
leia(t)

M <- P
para k de 1 ate t faca
    M <- M * (1 + i)
fimpara

escreva("Montante: ", M)
escreva("Juros: ", M - P)

Ponto de atenção: se a taxa for informada como “2” (em vez de 0.02), normalize: i <- i/100.

Boas práticas de legibilidade (cobrança indireta em prova e útil no trabalho)

• Nomes claros: use “saldoDisponivel” em vez de “x”.
• Evite números mágicos: declare constantes (ex.: LIMITE_PIX).
• Indentação: facilita identificar blocos de se/para/enquanto.
• Uma responsabilidade por função: validação separada de cálculo.
• Mensagens e retornos consistentes: padronize “OK/ERRO” ou códigos.

Exercícios progressivos (pseudocódigo e fluxogramas)

Exercício 1 (variáveis, operadores e precedência)

Enunciado: Dados a=8, b=3, c=2, calcule x = a + b * c e y = (a + b) * c. Mostre x e y.

inteiro a, b, c, x, y

a <- 8
b <- 3
c <- 2

x <- a + b * c
y <- (a + b) * c

escreva(x)
escreva(y)

Exercício 2 (entrada/saída e validação)

Enunciado: Leia um valor de depósito. Se for menor ou igual a zero, informe “depósito inválido”. Caso contrário, some ao saldo e mostre o novo saldo.

real saldo, deposito

leia(saldo)
leia(deposito)

se deposito <= 0 entao
    escreva("Deposito invalido")
senao
    saldo <- saldo + deposito
    escreva("Novo saldo: ", saldo)
fimse

Exercício 3 (condicional composta: elegibilidade)

Enunciado: Um cliente é elegível a um produto se: (idade ≥ 21 OU é emancipado) E renda ≥ 3000 E não possui restrição. Leia os dados e imprima “Elegível” ou “Não elegível”.

inteiro idade
logico emancipado, semRestricao
real renda

leia(idade)
leia(emancipado)
leia(renda)
leia(semRestricao)

se ((idade >= 21) OU (emancipado = verdadeiro)) E (renda >= 3000) E semRestricao entao
    escreva("Elegivel")
senao
    escreva("Nao elegivel")
fimse

Exercício 4 (laço: validação repetida)

Enunciado: Leia uma taxa de juros em porcentagem (0 a 100). Enquanto estiver fora do intervalo, peça novamente. Ao final, converta para decimal (divida por 100) e mostre.

real taxaPercent, taxa

leia(taxaPercent)
enquanto (taxaPercent < 0) OU (taxaPercent > 100) faca
    escreva("Taxa invalida. Digite entre 0 e 100")
    leia(taxaPercent)
fimenquanto

taxa <- taxaPercent / 100
escreva(taxa)

Exercício 5 (juros simples e composto: escolha por menu)

Enunciado: Leia P, i (em %), t e um tipo (1=simple, 2=composto). Calcule e mostre montante e juros.

real P, iPercent, i, M, J
inteiro t, tipo, k

leia(P)
leia(iPercent)
leia(t)
leia(tipo)

i <- iPercent / 100

se tipo = 1 entao
    J <- P * i * t
    M <- P + J
senao se tipo = 2 entao
    M <- P
    para k de 1 ate t faca
        M <- M * (1 + i)
    fimpara
    J <- M - P
senao
    escreva("Tipo invalido")
fimse

se (tipo = 1) OU (tipo = 2) entao
    escreva("Montante: ", M)
    escreva("Juros: ", J)
fimse

Exercício 6 (funções: validação e cálculo modularizados)

Enunciado: Crie: (a) função taxaDecimal que converte percentual para decimal validando 0..100; (b) função montanteComposto que calcula M por laço; (c) programa principal que usa as funções.

funcao real taxaDecimal(real p)
    se (p < 0) OU (p > 100) entao
        retorne -1
    senao
        retorne p / 100
    fimse
fimfuncao

funcao real montanteComposto(real P, real i, inteiro t)
    real M
    inteiro k
    M <- P
    para k de 1 ate t faca
        M <- M * (1 + i)
    fimpara
    retorne M
fimfuncao

real P, iPercent, i, M
inteiro t

leia(P)
leia(iPercent)
leia(t)

i <- taxaDecimal(iPercent)
se i = -1 entao
    escreva("Taxa invalida")
senao
    M <- montanteComposto(P, i, t)
    escreva("Montante: ", M)
    escreva("Juros: ", M - P)
fimse

Exercício 7 (fluxograma: autenticação com tentativas)

Enunciado: Um usuário tem 3 tentativas para informar uma senha correta. Se acertar, “Acesso liberado”. Se errar 3 vezes, “Acesso bloqueado”.

[Inicio]
   |
[tentativas <- 0]
   |
{tentativas < 3?}---nao-->[Escreva "Acesso bloqueado"]-->[Fim]
   |
  sim
   |
[Leia senha]
   |
{senha correta?}---sim-->[Escreva "Acesso liberado"]-->[Fim]
   |
  nao
   |
[tentativas <- tentativas + 1]
   |
(Volta para: tentativas < 3?)

Exercício 8 (questão-modelo: rastreamento de laço com condição)

Enunciado: Considere o algoritmo abaixo. Qual o valor final de cont se n=10?

inteiro n, i, cont
n <- 10
cont <- 0
para i de 1 ate n faca
    se (i % 2 = 0) E (i % 3 <> 0) entao
        cont <- cont + 1
    fimse
fimpara
escreva(cont)

Orientação: conte os i pares de 1..10 que não são múltiplos de 3: 2, 4, 8, 10. Logo, cont=4.