Ajuda na logica

Programação Java
#1

Bom dia, quero calcular um deposito de R$ 100 em cada mes com juros de 1%, em 35 anos.
Como faço pra colocar isso dentro do laço ?
Abaixo, o codigo o codigo faz o calculo de um mês, como faço pra fazer em 35 anos?
Quem poder ajudar, agradeco.

import java.math.BigDecimal;

public class Calculo {

	
	public static void main(String[] args) {
		BigDecimal juros = new BigDecimal("1.01");
		BigDecimal deposito = new BigDecimal("100");
		int mes = 420;

		for (int i = 0; i < mes; i++) {

			BigDecimal total = deposito.multiply(juros);
			System.out.println(total);
		}
	}

}
#2 
int mes = 420;

420 meses são 35 anos… já está fazendo o que você quer… :lol:

#3

entao fiz isso, mas ele repete 420 vezes 101.00

#4

Ah, claro, nem tinha visto isso… olha só:

[code]import java.math.BigDecimal;

public class Calculo {

public static void main(String[] args) {
	BigDecimal juros = new BigDecimal("1.01");
	BigDecimal deposito = new BigDecimal("100");
	int mes = 420;

	for (int i = 0; i < mes; i++) {

		BigDecimal total = deposito.multiply(juros); // vc inicializa a variavel a cada loop!
		System.out.println(total);
	}
}

}[/code]

Sacou? Tem que inicializar o totalizador fora do loop e depois somar:

[code]import java.math.BigDecimal;

public class Calculo {

public static void main(String[] args) {
	BigDecimal juros = new BigDecimal("1.01");
	BigDecimal deposito = new BigDecimal("100");
	int mes = 420;
	
	BigDecimal total = new BigDecimal(0);
	for (int i = 0; i < mes; i++) {

		total = total + deposito.multiply(juros); // agora sim, soma com o total anterior!
		System.out.println(total);
	}
}

}[/code]

#5

Coloque tambem o println depois do for, senão ele vai imprimir 420 vezes

#6

Você deve multiplicar o total pelos juros várias vezes. Você só está multiplicando o valor do depósito original pelo taxa de juro original várias vezes:

import java.math.BigDecimal;

[code]public class Calculo {

public static void main(String[] args) {
	BigDecimal juros = new BigDecimal("1.01");
	BigDecimal deposito = new BigDecimal("100");
	int mes = 420;
	BigDecimal total = deposito;

	for (int i = 0; i < mes; i++) {
		total = total.multiply(juros);
		System.out.println(total);
	}
}

}
[/code]

Outra possibilidade é usar a fórmula do juro composto e evitar o loop.

Montante = capital * (1+taxa)^tempo.

No seu caso, você já somou 1 à taxa.

#7

[quote=ViniGodoy]Você deve multiplicar o total pelos juros várias vezes. Você só está multiplicando o valor do depósito original pelo taxa de juro original várias vezes:

import java.math.BigDecimal;

[code]public class Calculo {

public static void main(String[] args) {
	BigDecimal juros = new BigDecimal("1.01");
	BigDecimal deposito = new BigDecimal("100");
	int mes = 420;
	BigDecimal total = deposito;

	for (int i = 0; i < mes; i++) {
		total = total.multiply(juros);
		System.out.println(total);
	}
}

}
[/code]

Outra possibilidade é usar a fórmula do juro composto e evitar o loop.

Montante = capital * (1+taxa)^tempo.

No seu caso, você já somou 1 à taxa.
[/quote]

Credo, Vini, você até me fez lembrar das aulas da faculdade… :roll:

#8

É que geralmente fazer com um for essas coisas é o pior meio. Você sai de um tempo de O(1) para um tempo de O(N).
Quanto mais com fórmulas simples, como essa.

#9

É que geralmente fazer com um for essas coisas é o pior meio. Você sai de um tempo de O(1) para um tempo de O(N).
Quanto mais com fórmulas simples, como essa.
[/quote]

Verdade… mas veja só, você só chegou á esse resultado porque voce conhece a área envolvida no problema, no caso cálculos financeiros… eu nunca ia sugerir essa fórmula de juros composto! :shock:

Conhecimento técnico é bom, mas experiência ajuda demais nesse tipo de caso…

#10

Cara desculpa ser chato, mas nao to conseguindo incrementar R$ 100 em cada volta do loop

import java.math.BigDecimal;

public class Calculo {

	
	public static void main(String[] args) {
		BigDecimal juros = new BigDecimal("1.01");
		BigDecimal deposito = new BigDecimal("100");
		int mes = 2;
		
		BigDecimal total = deposito;
		
		for (int i = 0; i < mes; i++) {   
			total = total.multiply(juros);  
            System.out.println(total);  
            
			 
		}
	}

}
#11

[code]import java.math.BigDecimal;

public class Calculo {

public static void main(String[] args) {
    BigDecimal juros = new BigDecimal("1.01");
    BigDecimal deposito = new BigDecimal("100");
    int mes = 35;
    BigDecimal total = new BigDecimal("0");

    for (int i = 0; i < mes; i++) {
        total = deposito.multiply(juros.pow(i+1)).setScale(2, BigDecimal.ROUND_CEILING);
        System.out.println(total);
    }
}

}[/code]

o setScale(2, BigDecimal.ROUND_CEILING) -> serve para arredondar a saída.
o juros.pow(i+1) -> é onde vai incrementar o juros, i+1 pq i começa em 0.

#12

Eu faria assim:

[code]import java.math.BigDecimal;

public class Calculo {
public static void main(String[] args) {
BigDecimal taxa = new BigDecimal(“1.01”);
BigDecimal deposito = new BigDecimal(“100”);
int mes = 420;

	BigDecimal total = new BigDecimal("0");
	BigDecimal jurosAtual = taxa;

	for (int i = 0; i < mes; i++) {

		total = total.add(deposito.multiply(jurosAtual));
		jurosAtual = jurosAtual.multiply(taxa);
		System.out.println(total); // Se quiser apenas o resultado final coloque esta linha fora do for
	}
}

}[/code]

Ou assim, caso queira usar o “i” como referência para o mês:

[code]import java.math.BigDecimal;

public class Calculo {
public static void main(String[] args) {
BigDecimal taxa = new BigDecimal(“1.01”);
BigDecimal deposito = new BigDecimal(“100”);
int mes = 420;

	BigDecimal total = new BigDecimal("0");
	BigDecimal jurosAtual = taxa;

	for (int i = 1; i <= mes; i++) {

		total = total.add(deposito.multiply(jurosAtual));
		jurosAtual = jurosAtual.multiply(taxa);
		System.out.println("O total no mês " + i + " resulta: " + total);
	}
}

}[/code]

Abraço!

#13

Ah, você quer é juros simples?

Veja bem, existem dois tipos de juro. O que inside sobre o montante total, que é o juro composto. Por exemplo, se vc começa com 100 com juro de 1%, essa seria a evolução em 5 meses:

Mês 0: Valor: 100
Mês 1: Valor: 101 Juro: R$1,00 (1% de R$100)
Mês 2: Valor: 102,01 Juro: R$1,01 (1% de R$101)
Mês 3: Valor: 103,03 Juro: R$1,02 (1% de R$102,01)
Mês 4: Valor: 104,06 Juro: R$1,03 (1% de R$103,03)
Mês 5: Valor: 105,10 Juro: R$1,04 (1% de R$104,06)

A fórmula dessa encrenca aí em cima é
Montante = Capital * (1+taxa)^tempo

Ou seja, para um capital de R$100,00 por 5 meses a juro de 1%:
Montante = R$100,00 * (1+0,01)^5
Montante = R$100,00 * 1,0510100501
Montante = R$105,10

E existe o juro simples. Nele, o juro só incide sobre o valor do capital inicial.

Mês 0: Valor: 100
Mês 1: Valor: 101 Juro: R$1,00 (1% de 100)
Mês 2: Valor: 102 Juro: R$1,00 (1% de 100)
Mês 3: Valor: 103 Juro: R$1,00 (1% de 100)
Mês 4: Valor: 104 Juro: R$1,00 (1% de 100)
Mês 5: Valor: 105 Juro: R$1,00 (1% de 100)

A fórmula do juro simples é ainda mais fácil.

Montante = Capital + capitaltaxatempo

Ou seja, para um capital de R$100,00 por 5 meses a juro de 1%:
Montante = R$100,00 + R$100,000,015
Montante = R$100,00 + R$5,0
Montante = R$105,00.

#14

Em Java, fica mais ou menos assim:

[code]public static BigDecimal calcularMontanteJuroComposto(BigDecimal capital, BigDecimal taxa, int tempo) {
return capital.multiply(taxa.add(BigDecimal.ONE).pow(tempo));
}

public static BigDecimal calcularMontanteJuroSimples(BigDecimal capital, BigDecimal taxa, int tempo) {
return capital.add(capital.multiply(taxa).multiply(new BigDecimal(tempo)));
}[/code]

Não tenho java aqui para testar, mas deve ser por aí.

#15

[quote=ViniGodoy]Em Java, fica mais ou menos assim:

[code]public static BigDecimal calcularMontanteJuroComposto(BigDecimal capital, BigDecimal taxa, int tempo) {
return capital.multiply(taxa.add(BigDecimal.ONE).pow(tempo));
}

public static BigDecimal calcularMontanteJuroSimples(BigDecimal capital, BigDecimal taxa, int tempo) {
return capital.add(capital.multiply(taxa).multiply(new BigDecimal(tempo)));
}[/code]

Não tenho java aqui para testar, mas deve ser por aí.[/quote]

Olá BiniGodoy,

Testei seu métodos e estão funcionando perfeitos, porém estão retornando o valor do depósito referente ao último mês. Pelo que entendi ele quer o valor total acumulado após o depósito do mês.

Chequei a essa conclusão por causa das linhas 13 e 14 do código que ele postou na abertura do tópico:

BigDecimal total = deposito.multiply(juros); System.out.println(total);

Outra coisa, não acredito que seja juros simples pois ele disse que quer juros de 1% (0,01) e na linha 7 do código dele ele diz que os “juros” é de 1.01 (1 + taxa). Daí cheguei a conclusão também de ser juros compostos.

Amigo renatorudolf, confirma o que você quer aí para que haja uma solução rápida para você. E caso alguém já tenha resolvido seu problema de um alô.

Grande abraço para todos!

#16

Não, ele calcula o montante final, desde que seja só acrescido os juros.

Essa é outra dúvida que eu tenho. Será feito um depósito todo mês? Pq se for, as fórmulas mudam.

#17

Não, ele calcula o montante final, desde que seja só acrescido os juros.

Essa é outra dúvida que eu tenho. Será feito um depósito todo mês? Pq se for, as fórmulas mudam.[/quote]

Pois então, foi assim que fiz, com um depósito por mes, como se o sujeito tivesse pagando um emprestimo. Baita empréstimo esse de 420 meses, com esses juros. hehhe

Acho que alguma das soluções vai satisfaze-lo.

#18

Na verdade, com juros simples, não sei que tipo de aplicação financeira seria essa.

Mas com juros compostos, seria uma espécie de poupança.
Uma taxa fixa por mês, mas um valor fixo que o cara deposita todo mês.

Aí a formula é essa:

montante = deposito * (1 + juro) * ((1 + juro)^tempo-1) / taxa;

#19

[quote=ViniGodoy]Na verdade, com juros simples, não sei que tipo de aplicação financeira seria essa.

Mas com juros compostos, seria uma espécie de poupança.
Uma taxa fixa por mês, mas um valor fixo que o cara deposita todo mês.

Aí a formula é essa:

montante = deposito * (1 + juro) * ((1 + juro)^tempo-1) / taxa;

[/quote]

Faltou um par de parenteses na sua formula:

montante = deposito * (1 + juro) * (((1 + juro)^tempo)-1) / taxa;

Salvo pela imagem… hehhee

#20

A exponenciação tem precedência sobre a subtração. Portanto, aquele parênteses não é mesmo necessário.
Se o -1 atuasse sobre o tempo, aí sim, seria necessário por o parênteses.

Mas concordo que fica mais claro dessa forma. Não é à toa que coloquei a fórmula, pq o calculo escrito no computador fica osso de ler. hehehe