为什么我的代码输出比数学多一个？

Question

Okay, so I'm writing a loan calculator where 10% of the remaining amount of the loan is subtracted from the previous amount over the course of six months. The problem isn't difficult, it's that the code I wrote seems to be... uhm... retarded.

import java.util.Scanner;

public class Program
{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int amount = scanner.nextInt();
        
        int payment;

        for (int month = 0; month < 6; month++)
        {
            payment = amount / 10;
            
            amount -= payment;
        }

        System.out.println(amount);
        
    }
}

The code sorta works, but I did the math and the output of amount is exactly 1 more than it should be. Is there some kind of Java rule that I just haven't learned yet or what?

Answer 1

When you work on integers it might happens because the part after '.' is lost. Lets make an example of your problem: Assume that you have amount 100 so the payments are:

100 / 10 = 10

90 / 10 = 9

81 / 10 = 8

73 / 10 = 7

66 / 10 = 6

60 / 10 = 6 - (this is where you expect that the number will be 5 but it is not because you lose decimal part in all previous calculations)

Output: 54

Personally I think that for such calculation you should use double instead of integer

Answer 2

Solution

The following code will give you the result rounded on two decimal places.

As in the commentarys already mentioned when you do 76 / 10 on an integer the result will be 7 so the decimal part will be lost.

So in the solution below I used double instead of integer and I rounded up the result on two decimal places as you expect from currencys.

import java.util.Scanner;

public class Programm
{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double amount = scanner.nextDouble();
        
        double payment;
        try {
        for (int month = 0; month < 6; month++)
        {
            
            payment = amount / 10;
            
            amount -= payment;
            amount = Math.round(100.0 * amount) / 100.0;
            }
        }catch(Exception e) {
            System.out.println("Zero Divivided");
        }

        System.out.println(amount);
        
    }
}

For the input of 100 the code produces the result 53.15

Answer 3

Use Double instead of int, and always use 2 decimal points since this is the currency

public class Program {
  public static void main(String[] args) {
     Scanner scanner = new Scanner(System.in);
     double  amount = scanner.nextDouble();
     double payment;

     for (int month = 0; month < 6; month++) {
            payment = amount / 10;
            BigDecimal bd = new BigDecimal(payment).setScale(2, RoundingMode.HALF_UP);
            amount -= bd.doubleValue();
     }

     System.out.println(amount);
}

}

Answer 4

One of the hallmarks of a good question is to include your inputs and your outputs. In your case, each line of input results in a single line of output. You should put in your question a 3-column table. The first column should be the input integer, the second column should be the expected output value (your definition), and the third column should be what the code produced for that input. Once you get to the point where you can produce this table, you can construct your tests.

As your code stands, you can test it with something like this, without having to learn anything about JUnit. The script below is quite simple and utilizes tools that you should be learning anyway. Well, that is, if you plan to use a real operating system for the rest of your career. You can use these tools to test much code regardless of its language.

Here is a test shell script for your particular program:

javac Program.java
if [ $? -ne 0 ]; then
   exit 1;
fi

while read line; do
    echo $line > tmp
    java Program < tmp
done < test.dat > test.out

diff test.out test.spec

Here is one way you execute it:

$ sh test.sh

Here is what your code produces by running the script:

$ cat test.out
54
533
5315
53145
268
2658
26573
265721

If all tests pass, then the script produces no output. Here is the test data used by that script.

$ cat test.dat
100
1000
10000
100000
500
5000
50000
500000

Here is a specification for the outputs of those data given the fact that you said your code produces output that is exactly one more than what you expect.

cat test.spec
53
532
5314
53144
267
2657
26572
265720

This is what the script produces, since the code isn't satisfying your specification:

$ sh test.sh
1,8c1,8
< 54
< 533
< 5315
< 53145
< 268
< 2658
< 26573
< 265721
---
> 53
> 532
> 5314
> 53144
> 267
> 2657
> 26572
> 265720

If you change int to double in two places in your program, then this is what the script produces:

$ sh test.sh
1,8c1,8
< 53.1441
< 531.441
< 5314.41
< 53144.1
< 265.7205
< 2657.205
< 26572.05
< 265720.5
---
> 53
> 532
> 5314
> 53144
> 267
> 2657
> 26572
> 265720

If you want to floor the output values then you can use String.format and perhaps it would match the spec. It won't in this case because I'm blindly following your definition (1 more than desired). But you'll go far if you embrace Test Driven Development.