Vovô João tem uma banca de jornais; ele tem muitos clientes, e diariamente recebe muito dinheiro, mas também faz muitos pagamentos para manter o seu estoque de jornais e revistas. Todo dia ele vai ao banco realizar um depósito ou uma retirada de dinheiro. Em alguns dias, o saldo de sua conta no banco pode ficar negativo, mas Vovô João não é penalizado por isso. Dada a movimentação diária da conta do banco do Vovô João, você deve escrever um programa que calcule o menor saldo da conta, no período dado. O Saldo inicial também deve ser levado em consideração.
Escreva um subprograma principal que recebe na primeira linha da entrada dois números inteiros N e S que indicam respectivamente o número de dias do período de interesse e o saldo da conta no início do período. Cada uma das N linhas seguintes contém um número inteiro indicando a movimentação de um dia (valor positivo no caso de depósito, valor negativo no caso de retirada). A movimentação é dada para um período de N dias consecutivos: a primeira das N linhas corresponde ao primeiro dia do período de interesse, a segunda linha corresponde ao segundo dia, e assim por diante. As N movimentações devem ser armazenadas em um vetor.
Seu programa deverá ter uma função que retorna o menor saldo da conta do vovô. A saída será dada em uma linha, contendo um número inteiro que corresponde ao menor valor de saldo da conta no período dado.
Obs.: Vetores em Python são implementados como listas cujos elementos são todos homogêneos.
Entradas:
  1. Dois números inteiros que indicam o número de dias no período de interesse e o saldo da conta no início do periodo.
  2. N linhas seguintes contendo um número inteiro indicando a movimentação de um dia (valor positivo no caso de depósito, valor negativo no caso de retirada). Esses valores deverão ser armazenados em um vetor.
Saídas:
  1. Um número inteiro que corresponde ao menor valor de saldo da conta no período dado.
Exemplo de Entrada:
31000
100
-800
50
Exemplo de Saída:
300

Passo 1

O que o enunciado pede e o que é dado.
  • Dados:
    • Um inteiro N: número de dias do período de interesse.
    • Um inteiro S: saldo da conta no início do período (saldo inicial).
    • Uma sequência de N inteiros m_1,m_2,\dots,m_N: cada m_i é a movimentação do dia i (depósito se positivo, retirada se negativo). Essas N movimentações devem ser armazenadas em um vetor (lista).
  • Pedido:
    • Escrever um subprograma (função) que receba os valores acima e retorne o menor saldo da conta observado durante o período, levando em conta o saldo inicial.
  • Observação: a cada dia o saldo é atualizado somando a movimentação daquele dia ao saldo do dia anterior; o saldo pode ficar negativo e isso não gera penalidade. Queremos o menor valor (mínimo) entre todos os saldos do período, incluindo o saldo inicial.

Passo 2

Ideia matemática/algorítmica que resolve o problema (explicação didática e fórmula).
  • Definição de saldos por dia:
    • Saldo inicial: B_0 = S.
    • Para cada dia i=1,2,\dots,N, o saldo ao final do dia i é
    B_i = B_{i-1} + m_i.Aqui B_i representa o saldo depois de aplicar a movimentação do dia i, e m_i é a movimentação do dia i.
  • Objetivo: calcular \min\{B_0, B_1, B_2,\dots,B_N\}.Ou seja, o menor saldo entre o saldo inicial e todos os saldos após cada movimentação.
  • Intuição simples: começamos com B_0=S. Vamos percorrer as movimentações m_1 até m_N, atualizando um acumulador B com B \leftarrow B + m_i e mantendo outro valor M que guarda o menor saldo encontrado até o momento. No final M é a resposta.

Passo 3

Passo a passo do algoritmo em palavras (como montar o programa na prova, sem pular etapas).
  1. Ler os inteiros N e S.
  2. Criar um vetor (lista) para armazenar as N movimentações: [m_1,m_2,\dots,m_N].
  3. Inicializar duas variáveis:
    • B \leftarrow S (saldo corrente).
    • M \leftarrow S (menor saldo observado até agora).
  4. Para cada i de 1 até N:
    • Ler m_i e armazenar no vetor.
    • Atualizar o saldo corrente: B \leftarrow B + m_i.
    • Se B < M, então M \leftarrow B.
  5. Ao final do loop, M contém o menor saldo de todo o período. Imprimir M.
Observações práticas:
  • Mesmo que tecnicamente dê para não guardar todas as movimentações (processar em streaming), o enunciado exige que as N movimentações sejam armazenadas em um vetor. Então armazene-as — mas ainda assim use o laço para calcular os saldos.
  • Variáveis explicadas:
    • N: número de dias (inteiro).
    • S: saldo inicial (inteiro).
    • m_i: movimentação do dia i (inteiro).
    • B: saldo corrente ao processar as movimentações.
    • M: menor saldo encontrado.

Passo 4

Complexidade e cuidados (o que observar na prova e no código).
  • Complexidade de tempo: o algoritmo percorre as N movimentações uma vez, logo tem custo O(N).
  • Complexidade de memória: armazena N inteiros no vetor, então O(N) de memória — isto respeita a exigência do enunciado.
  • Casos limites a checar:
    • N=0: não há movimentações; o menor saldo é simplesmente S.
    • Movimentações que levam a valores muito negativos: usar tipo inteiro que suporte o range do problema (em Python int é ilimitado).
  • Erros comuns na prova: esquecer de comparar o saldo inicial B_0=S com os saldos posteriores; inicializar M indevidamente.

Passo 5

Exemplo de implementação em Python (função pedida + programa principal). Este é o jeito que eu implementaria na prova/parte prática.
def menor_saldo(movimentos, S):
“”"
Recebe:
- movimentos: lista com N inteiros [m_1, …, m_N]
- S: saldo inicial (inteiro)
Retorna:
- menor saldo observado (inteiro)
“”"
B = S # saldo corrente
M = S # menor saldo observado
for m in movimentos:
B += m
if B < M:
M = B
return M

Programa principal (leitura e escrita)

Ler N e S na mesma linha ou em linhas separadas conforme a entrada

entrada = input().strip().split()
if len(entrada) == 2:
N = int(entrada[0])
S = int(entrada[1])
else:
# se vierem em linhas diferentes
N = int(entrada[0])
S = int(input().strip())
movimentos = []
for _ in range(N):
m = int(input().strip())
movimentos.append(m)
resultado = menor_saldo(movimentos, S)
print(resultado)
Explicação do código:
  • A função \text{menor\_saldo} reproduce exatamente a ideia dos passos anteriores: começa com B=S e M=S, itera pelas movimentações atualizando B e M.
  • O programa principal lê N e S, depois lê N linhas com as movimentações e as armazena no vetor movimentos. Em seguida chama a função e imprime o resultado.

Passo 6

Aplicando ao exemplo fornecido (mostrando passo a passo dos saldos).
  • Interpretação da entrada de exemplo (peguei esses números do enunciado de exemplo):
    • Primeira linha: N=3 e S=1000.
    • Movimentações (próximas N linhas): m_1 = 100, m_2 = -800, m_3 = 50.
  • Vamos calcular B_i e acompanhar o mínimo M:
    • Inicialmente: B_0 = S = 1000. Então M = 1000.
    • Dia 1: B_1 = B_0 + m_1 = 1000 + 100 = 1100. Atualiza M = \min(1000,1100) = 1000.
    • Dia 2: B_2 = B_1 + m_2 = 1100 + (-800) = 300. Atualiza M = \min(1000,300) = 300.
    • Dia 3: B_3 = B_2 + m_3 = 300 + 50 = 350. Atualiza M = \min(300,350) = 300.
  • Resultado final: menor saldo M = 300.

Passo 7

Dicas rápidas para a prova (como garantir que não dá zebra)
  • Sempre inicialize o menor saldo M com o saldo inicial S, não com zero.
  • Se a entrada puder ter N e S em linhas separadas, trate ambos os casos (uma linha com dois inteiros ou duas linhas).
  • Teste mentalmente com N=0 e com movimentos todos positivos / todos negativos.
  • Evite arredondamentos: estamos trabalhando com inteiros.

Resposta

300

Exercícios relacionados