Solucionado (ver solução)
Solucionado
(ver solução)
7
respostas

Continuação do problema do cartão de Crédito: Pagando dívida em um ano

Agora, escreva um programa que calcule o pagamento mensal fixo mínimo necessário para liquidar um saldo de cartão de crédito dentro de 12 meses. Por um pagamento mensal fixo, queremos dizer um único número que não muda a cada mês, mas sim um valor constante que será pago a cada mês.

Neste problema, não estaremos lidando com uma taxa de pagamento mensal mínima.

As seguintes variáveis contêm valores conforme descrito abaixo:

  1. balance - o saldo em dívida no cartão de crédito
  2. annualInterestRate - taxa de juros anual como um decimal

O programa deve imprimir uma linha: o menor pagamento mensal que saldará todas as dívidas em menos de 1 ano, por exemplo:

Lowest Payment: 180

Suponha que os juros sejam compostos mensalmente de acordo com o saldo no final do mês (após o pagamento para esse mês ser feito). O pagamento mensal deve ser um múltiplo de $ 10 e é o mesmo para todos os meses. Observe que é possível que o saldo fique negativo usando este esquema de pagamento, o que é correto. Um resumo da matemática necessária é encontrado abaixo:

Monthly interest rate = (Annual interest rate) / 12.0 Monthly unpaid balance = (Previous balance) - (Minimum fixed monthly payment) Updated balance each month = (Monthly unpaid balance) + (Monthly interest rate x Monthly unpaid balance)

Casos de teste para testar seu código.

Certifique-se de testá-los em sua própria máquina - e obter a mesma saída! - antes de executar o seu código nesta página!

Test Case 1: balance = 3329 annualInterestRate = 0.2

Result Your Code Should Generate:

Lowest Payment: 310

• Test Case 2: balance = 4773 annualInterestRate = 0.2

Result Your Code Should Generate:

Lowest Payment: 440

• Test Case 3: balance = 3926 annualInterestRate = 0.2

Result Your Code Should Generate:

Lowest Payment: 360

Original em inglês: https://files.fm/u/gnyqwzes

Minha tentativa:


balance = 3329
annualInterestRate = 0.2
Lowest_Payment = Monthly_unpaid_balance - balance 
#mes_0

Updated_balance_each_month = 0
Monthly_unpaid_balance =0
mes = 0
while mes < 12:
    Monthly_unpaid_balance = (balance) - ( (monthlyPaymentRate) * (balance))

    balance= (Monthly_unpaid_balance) + ((annualInterestRate/12) * Monthly_unpaid_balance)


    mes += 1

print("Lowest Payment : {0:.2f}".format(Lowest_Payment))

A saída está sempre em zero...

7 respostas

Oi Edson, seu programa sempre retorna zero por conta desta linha:

Lowest_Payment = Monthly_unpaid_balance - balance

que deve atribuir zero a variável Lowest_Payment e ela não é atualizada em nenhum momento depois. Além disso, falta atribuir valor para as variáveis monthlyPaymentRate e balance que imagino que no seu código completo iniciam com algum valor.

Espero ter ajudado e bons estudos!

@Thais Thomazini Andre:

Obrigado!

Tinha esquecido o valor destas duas constantes:

balance = 3329
annualInterestRate = 0.2

Como atualizo o Lowest_Payment ?

Então, você deve seguir a regra pedida no exercício. Precisa iniciar o pagamento mínimo com 10, atualizar o saldo não pago subtraindo o valor do pagamento mínimo e aplicar a taxa de juros mensal, mês a mês para este valor (12 vezes). Se o resultado for positivo, quer dizer que o pagamento mínimo ainda não chegou no saldo inicial e você deve repetir o procedimento para o próximo múltiplo de 10 até chegar no resultado.

Olá, Edson, ainda ficou alguma dúvida?

@Thais Thomazini Andre:

Na verdade, ainda não consegui finalizar. Poderia ajudar?

solução!

Oi Edson, vou escrever as variáveis em português pra ficar mais claro o raciocínio. Para calcular o pagamento mínimo que seja múltiplo de 10, devemos começar com um pagamento_minimo = 10.

#dados de entrada
saldo = 3329
taxa_juros_anual = 0.2

#imprime dados entrada
print('saldo: {}'.format(saldo))
print('taxa juros anual: {}'.format(taxa_juros_anual))
print('*' * 30)

#iniciando variáveis
saldo_inicial = saldo
taxa_juros_mensal = taxa_juros_anual / 12.0
mes = 0
pagamento_minimo = 10

Você pode construir uma função calcula() que vai atualizar o saldo após subtrair o valor do pagamento mínimo e aplicar a taxa de juros mensal.

def calcula(mes, saldo, pagamento_minimo, taxa_juros_mensal):
    while mes <12:
        saldo_nao_pago = saldo - pagamento_minimo
        saldo = saldo_nao_pago + (taxa_juros_mensal * saldo_nao_pago)
        mes += 1
    return saldo

Chamamos a função calcula() verificando se seu retorno é positivo. Caso seja, quer dizer que não conseguimos liquidar o saldo do cartão com o pagamento mínimo inicial (10) e devemos pegar seu próximo múltiplo. Usamos um laço while para repetir este procedimento até que o valor retornado seja quitado (ou seja, o retorno da função calcula seja <= 0):

while calcula(mes, saldo, pagamento_minimo, taxa_juros_mensal) > 0:
    saldo = saldo_inicial
    pagamento_minimo +=10
    mes = 0
    calcula(mes, saldo, pagamento_minimo, taxa_juros_mensal)

Quando não entrar mais no laço while, ou seja, quando quitarmos o saldo, o programa deve imprimir o pagamento mínimo:

#imprime saída:
print('Pagamento mínimo: ' + str(pagamento_minimo))

saída do programa:

saldo: 3329
taxa juros anual: 0.2
******************************
Pagamento mínimo: 310

Espero ter ajudado e bons estudos

@Thais Thomazini Andre: Obrigado! Vou estudar o código e depois marcarei como resolvido!