Java variables exercises — BMI, seconds and the print shop inventory (and the percentage that got stuck at 100)

In the Java variables practice we triggered the three traps of the topic on purpose: integer division, overflow and == with texts. Now it’s your turn, with a twist: here they won’t be the stars. They show up as tools (or as obstacles) inside ordinary problems, which is how they show up in exams.

What happened to me with exercise 2 the first time I did it: the breakdown into days, hours and minutes came out perfect, and the percentage of the day got stuck at 100 %, whatever number of seconds over a day I tried. You’ll find it in «What’s wrong here?».

The output is real, from Java 21 on a computer set to English, apart from the javac messages, which are the same in any language.

How to use this article

There are three exercises of rising difficulty. Each one has its task, the output your program should give (it’s the real output of the solution) and a box with hints. Try each one for at least ten minutes before opening the hint, and the hint before the solution. After that come «What’s wrong here?» with three very common mistakes, the commented solutions, an exam-style quiz and the topic’s cheat sheet.

As in the practice, the data is written in the program: we don’t use Scanner, if or loops yet (they arrive in flow control and in loops). That forces you to solve everything with variables, operators and types, which is exactly what you need to master right now.

Basic level

Exercise 1: BMI calculator

Write a program that, for a weight of 70 kg and a height of 1.75 m, works out the Body Mass Index, the healthy weight range for that height and which category it belongs to. As we don’t have if yet, each category is shown as a boolean (true for the right one).

• BMI = weight / (height × height).
• Healthy range: BMI between 18.5 and 24.9. The minimum weight is 18.5 × height² and the maximum, 24.9 × height².
• Categories: underweight (< 18.5), normal weight (from 18.5 to under 25), overweight (from 25 to under 30) and obesity (30 or more).

Expected output:

=== BMI CALCULATOR ===
Weight (kg): 70.0
Height (m):  1.75
BMI:             22.86
Healthy weight:  between 56.7 kg and 76.3 kg
Underweight:   false
Normal weight: true
Overweight:    false
Obesity:       false

Intermediate level

Exercise 2: time converter

Write a program that breaks 90061 seconds down into days, hours, minutes and seconds, also shows it in clock format (1 d 01:01:01), works out what percentage of a full day it is and, as a check, rebuilds the total from the four pieces.

Expected output:

=== TIME CONVERTER ===
Total seconds: 90061
1 d, 1 h, 1 min and 1 s
Clock format: 1 d 01:01:01
Percentage of a day: 104.24 %
Check: 90061 seconds

Final challenge

Exercise 3: the print shop inventory

The faculty print shop has three products (made-up prices):

Write a program that shows a table with the base price, the price with IGIC (the Canary Islands sales tax, 7 % at the general rate) and the units; the total number of units; the inventory value (price × units of each product, added up) worked out in two ways, with double and with cents in a long; the most expensive and the cheapest product, and the average price per unit. No arrays and no if: three sets of variables.

Expected output:

PRINT SHOP INVENTORY
Product         Base     +IGIC  Stock
Laptop        899.99    962.99      5
Mouse          29.99     32.09     23
Keyboard       79.99     85.59     12
Units: 40
Value as double (println):  6149.599999999999
Value as double (printf):   6149.60 €
Value in cents: 614960 → 6149.60 €
Most expensive: 899.99 € | cheapest: 29.99 €
Average price per unit: 153.74 €

What’s wrong here?

Three fragments with very common mistakes. Before reading the explanation, decide what each one prints (or whether it compiles).

Fragment 1: the percentage stuck at 100

public class Percentage {
    public static void main(String[] args) {
        int seconds = 90061;
        double percentage = seconds / 86400 * 100;
        System.out.printf("%.2f %%%n", percentage);
    }
}

What it prints:

100.00 %

seconds / 86400 are two int values: 90061 / 86400 = 1. Then 1 × 100 = 100, which is stored in the double as 100.0. The variable being double doesn’t help, because the division has already been done as integers. The fix is to convert before dividing: (double) seconds / 86400 * 100, which gives 104.24. That was my stubborn 100 % from the start.

Fragment 2: the stock value

public class StockValue {
    public static void main(String[] args) {
        double price = 29.99;
        int stock = 23;
        int value = price * stock;
        System.out.println(value);
    }
}

What javac says:

StockValue.java:5: error: incompatible types: possible lossy conversion from double to int
        int value = price * stock;
                          ^
1 error

price * stock is double × int, and the result is double (689.77). Storing it in an int would lose the cents, and Java won’t do that without permission. There are two fixes, depending on what you want: double value = price * stock; if you want the amount, or working in cents (long cent = Math.round(price * 100) * stock;) if you want an exact whole number. The cast (int) (price * stock) would compile, but it would throw away the 77 cents.

Fragment 3: the username that doesn’t match

public class Username {
    public static void main(String[] args) {
        String name = "laura";
        String username = name.substring(0, 1) + "santana";
        System.out.println(username);
        System.out.println(username == "lsantana");
    }
}

What it prints:

lsantana
false

The first line shows the text is lsantana. And still == gives false: username was built at run time with substring and +, so it’s a new object, different from the literal "lsantana". == compares the arrows, not the letters. Fix: username.equals("lsantana").

Commented solutions

Solution to exercise 1

/** Exercise 1: BMI with fixed data and the classification with booleans (no if, which arrives in the next topic). */
public class BMICalculator {
    public static void main(String[] args) {
        final double BMI_MIN = 18.5;              // limits of the healthy range
        final double BMI_MAX = 24.9;
        double weight = 70;                       // the int 70 turns into 70.0 by itself
        double height = 1.75;

        double bmi = weight / (height * height);  // height^2 in Java would be something else (XOR)
        double weightMin = BMI_MIN * height * height;
        double weightMax = BMI_MAX * height * height;
        boolean underweight = bmi < BMI_MIN;
        boolean normalWeight = bmi >= BMI_MIN && bmi < 25;
        boolean overweight = bmi >= 25 && bmi < 30;
        boolean obesity = bmi >= 30;

        System.out.println("=== BMI CALCULATOR ===");
        System.out.println("Weight (kg): " + weight);
        System.out.println("Height (m):  " + height);
        System.out.printf("BMI:             %.2f%n", bmi);
        System.out.printf("Healthy weight:  between %.1f kg and %.1f kg%n", weightMin, weightMax);
        System.out.println("Underweight:   " + underweight);
        System.out.println("Normal weight: " + normalWeight);
        System.out.println("Overweight:    " + overweight);
        System.out.println("Obesity:       " + obesity);
    }
}

Why it’s written like this:

• double weight = 70;: the 70 is an int, but it fits in a double and Java converts it on its own (widening). That’s why the output says 70.0.
• The constants BMI_MIN and BMI_MAX avoid writing 18.5 and 24.9 in several places: if the criterion changed, you’d change one line.
• bmi >= BMI_MIN && bmi < 25: for normal weight we use < 25 and not <= 24.9. Why? Because a BMI of 24.95 is neither normal weight (it’s over 24.9) nor overweight (it doesn’t reach 25): it would end up with no category. With < 25 there are no gaps between the categories.

Sums by hand: 1.75 × 1.75 = 3.0625; 70 / 3.0625 = 22.857… → 22.86. Minimum weight: 18.5 × 3.0625 = 56.66 → 56.7; maximum: 24.9 × 3.0625 = 76.26 → 76.3. (The previous version of this article said 80.1 kg: it was wrong, it didn’t follow from its own formula.)

Solution to exercise 2

/** Exercise 2: breaking down 90061 seconds with / and %, and the percentage of a day with the cast in the right place. */
public class TimeConverter {
    public static void main(String[] args) {
        final int SEC_DAY = 24 * 60 * 60;          // 86400: let Java work it out
        final int SEC_HOUR = 60 * 60;              // 3600
        int totalSeconds = 90061;

        int days = totalSeconds / SEC_DAY;         // whole days
        int remainder = totalSeconds % SEC_DAY;    // what is left after taking out the days
        int hours = remainder / SEC_HOUR;
        remainder = remainder % SEC_HOUR;          // we reuse remainder
        int minutes = remainder / 60;
        int seconds = remainder % 60;

        double percentage = (double) totalSeconds / SEC_DAY * 100;   // cast BEFORE dividing
        int back = days * SEC_DAY + hours * SEC_HOUR + minutes * 60 + seconds;

        System.out.println("=== TIME CONVERTER ===");
        System.out.println("Total seconds: " + totalSeconds);
        System.out.printf("%d d, %d h, %d min and %d s%n", days, hours, minutes, seconds);
        System.out.printf("Clock format: %d d %02d:%02d:%02d%n", days, hours, minutes, seconds);
        System.out.printf("Percentage of a day: %.2f %%%n", percentage);
        System.out.println("Check: " + back + " seconds");
    }
}

The trace of the breakdown, step by step:

Design decisions:

• SEC_DAY = 24 * 60 * 60 instead of writing 86400: Java does the sum (you can’t get it wrong) and the name explains what it is. There’s no risk of overflow here: 86400 fits easily in an int.
• remainder is reused: first it keeps what’s left after the days and then what’s left after the hours. It saves variables, but don’t do it if it makes the code harder to read.
• The percentage: (double) 90061 / 86400 = 1.04237… × 100 = 104.24 %.
• The check line rebuilds the total: 1 × 86400 + 1 × 3600 + 1 × 60 + 1 = 90061. If it ever doesn’t match, the bug is in the breakdown.

Solution to exercise 3

/**
 * Challenge: inventory of three products at the faculty print shop (made-up prices, 7 % IGIC).
 * No arrays and no if: three sets of variables, Math.max/Math.min and the sums in cents.
 */
public class Shop {
    public static void main(String[] args) {
        final double IGIC = 0.07;                   // Canary Islands tax, general rate

        String name1 = "Laptop";    double price1 = 899.99;  int stock1 = 5;
        String name2 = "Mouse";     double price2 = 29.99;   int stock2 = 23;
        String name3 = "Keyboard";  double price3 = 79.99;   int stock3 = 12;

        // Inventory value with double: price * stock and add up
        double valueDouble = price1 * stock1 + price2 * stock2 + price3 * stock3;

        // The same in cents (long): exact whole numbers
        long cent1 = Math.round(price1 * 100);      // 89999
        long cent2 = Math.round(price2 * 100);      // 2999
        long cent3 = Math.round(price3 * 100);      // 7999
        long valueCents = cent1 * stock1 + cent2 * stock2 + cent3 * stock3;

        double mostExpensive = Math.max(price1, Math.max(price2, price3));
        double cheapest = Math.min(price1, Math.min(price2, price3));
        int units = stock1 + stock2 + stock3;

        System.out.println("PRINT SHOP INVENTORY");
        System.out.printf("%-10s %9s %9s %6s%n", "Product", "Base", "+IGIC", "Stock");
        System.out.printf("%-10s %9.2f %9.2f %6d%n", name1, price1, price1 * (1 + IGIC), stock1);
        System.out.printf("%-10s %9.2f %9.2f %6d%n", name2, price2, price2 * (1 + IGIC), stock2);
        System.out.printf("%-10s %9.2f %9.2f %6d%n", name3, price3, price3 * (1 + IGIC), stock3);
        System.out.println("Units: " + units);
        System.out.println("Value as double (println):  " + valueDouble);
        System.out.printf("Value as double (printf):   %.2f €%n", valueDouble);
        System.out.println("Value in cents: " + valueCents + " → " + valueCents / 100 + "." + valueCents % 100 + " €");
        System.out.println("Most expensive: " + mostExpensive + " € | cheapest: " + cheapest + " €");
        System.out.printf("Average price per unit: %.2f €%n", (double) valueCents / units / 100);
    }
}

What to look at in the output:

• The println of the double says 6149.599999999999. The sums are 899.99 × 5 = 4499.95; 29.99 × 23 = 689.77; 79.99 × 12 = 959.88; total, 6149.60. But 899.99 can’t be stored exactly in binary (just as 1/3 can’t be written exactly in decimal), and the small errors add up. printf with %.2f rounds and hides it, but the stored number is the other one.
• In cents, the result is exact: 89999 × 5 + 2999 × 23 + 7999 × 12 = 449995 + 68977 + 95988 = 614960. To write it in euros, valueCents / 100 gives 6149 (integer division) and valueCents % 100 gives 60.
• Math.max(price1, Math.max(price2, price3)): the inner one picks the larger of 2 and 3; the outer one, the larger of that and 1. The same with Math.min. Without if, we can only know the price, not the product’s name; with if (next topic) you can keep the name too.
• The average price per unit: (double) valueCents / units / 100 = 614960 / 40 / 100 = 153.74 €. The cast goes in front so that the first division already has decimals.
• Prices with IGIC: 899.99 × 1.07 = 962.99; 29.99 × 1.07 = 32.09; 79.99 × 1.07 = 85.59 (rounded by printf).

Exam-style quiz

Now test yourself as in the exam. The FP2 Java quiz works like this: 15 questions in 15 minutes about the whole Java syllabus, with single answer, multiple answer (wrong answers subtract), true or false, fill in the gaps, matching, short answer and «what does this code print?». Here are 11 original questions about variables and types in Java. Answer without running anything, press Check and read the explanation for each one. These questions are also the bank of the FP2 theory mock exam, which will mix them with those from the other Java topics.

int a = 7, b = 2;
double c = a / b;
double d = (double) a / b;
System.out.println(c + " " + d);

System.out.print('A' + 1);
System.out.print(" ");
System.out.println("" + 'A' + 1);

int x = Integer.MAX_VALUE;
x = x + 1;
System.out.println(x == Integer.MIN_VALUE);

String s = "12";
int n = Integer.parseInt(s) + 3;
System.out.println(s + 3 + " " + n);

System.out.println((int) 9.99 + (int) -2.7);

Watch it step by step in Python Tutor

pythontutor.com runs the code line by line and shows the value of every variable. Choose Java and paste this version of exercise 2 with fragment 1 inside:

public class TimeTutor {
    public static void main(String[] args) {
        int total = 90061;
        int days = total / 86400;
        int remainder = total % 86400;
        int hours = remainder / 3600;
        remainder = remainder % 3600;
        int minutes = remainder / 60;
        int seconds = remainder % 60;
        double wrong = total / 86400 * 100;
        double right = (double) total / 86400 * 100;
        System.out.println(days + " " + hours + " " + minutes + " " + seconds);
        System.out.println(wrong + " " + right);
    }
}

Output:

1 1 1 1
100.0 104.2372685185185

What to watch:

1. See how remainder changes value: first 3661 and, after remainder = remainder % 3600;, 61. It’s the trace table of the solution.
2. In double wrong = total / 86400 * 100; the value shows as 100.0: integer division had already left a 1.
3. In double right = … you get 104.2372685185185, with all its decimals. printf would round it to 104.24.
4. Notice that days, hours, minutes and seconds are int the whole time: the breakdown doesn’t need a single decimal.

Cheat sheet: Java variables

The essentials in 30 seconds: every variable has a fixed type (int, double, char, boolean, String…). Java calculates with the type of the operands, so int / int truncates and an int that goes past 2,147,483,647 wraps round. Going up a type is automatic; going down needs a cast and truncates. Texts are compared with equals().

Templates from the exercises:

// Breakdown with / and %
int days = total / 86400;   int remainder = total % 86400;
int hours = remainder / 3600;   remainder = remainder % 3600;
int minutes = remainder / 60;   int seconds = remainder % 60;

// Money in cents
long cent = Math.round(price * 100);
long value = cent * units;
System.out.printf("%d.%02d €%n", value / 100, value % 100);

// Classify without if: one boolean per category
boolean normalWeight = bmi >= 18.5 && bmi < 25;

Before handing in, ask yourself:

1. Is there a division where both sides are integers? Do I want decimals there?
2. Can any sum go past 2 billion?
3. Have I used (int) where I wanted to round?
4. Have I compared any String with ==?

If you want to keep going, the next topic is Java flow control: with if and switch, the BMI will be able to say «Normal weight» directly and the print shop, which product is the most expensive.

Did this article help you? Here is how you can support SergioLearns →