Java Methods Challenge: A Price Calculator

Start with rules that two implementations can agree on

This challenge is a fictional console price calculator. It does not charge a card, reserve stock, calculate real taxes, or use SovranCode's product catalog. The purpose is to combine the methods, arrays, validation, conversions, and scope lessons into one understandable program.

The policy is precise: multiply each unit price by its quantity, add line totals, apply one whole-percent discount to the entire subtotal, round the discount down to whole cents, and subtract it. Then shipping is zero for a zero merchandise amount or an after-discount amount of at least 5000 cents; otherwise it is 300 cents. The final amount is discounted merchandise plus shipping.

Input uses at most 100 paired lines, unit prices from 0 through 1,000,000 cents, quantities from 0 through 1000, and a discount from 0 through 100 percent. Empty carts and zero quantities are valid. These are exercise limits and policy choices, not universal commerce rules. Write them down before coding so boundary tests have a definite expected answer.

Keep values in cents and give units meaningful names

A unit price of 1299 means 1299 cents, displayed later as $12.99. Two units therefore contribute 2598 cents. Keeping this fixed-two-decimal exercise in integer minor units avoids using a floating-point approximation as the working price representation.

lineTotalCents has one calculation and returns its result without printing. The cast to long happens before multiplication. A long return type alone would not make an overflowing int multiplication safe if both operands were still ints during that multiplication.

The stated unit and quantity limits make one line at most 1,000,000,000 cents. This one-line maximum already fits int, but many lines together need more range. Use the long return consistently so the subtotal and discount pipeline does not accidentally narrow that larger amount later.

public class Main {
    public static void main(String[] args) {
        int unitCents = 1299;
        int quantity = 2;
        System.out.println("Line cents: " + lineTotalCents(unitCents, quantity));
    }

    // Preconditions: 0 <= unitCents <= 1_000_000 and 0 <= quantity <= 1000.
    static long lineTotalCents(int unitCents, int quantity) {
        return (long) unitCents * quantity;
    }
}

Select Run code to compile and execute this program.

Line cents: 2598

Validate the relationship between arrays, not just each number

The price at index i pairs with the quantity at index i. If the two arrays have different lengths, that relationship is incomplete and a loop could read beyond one array. Check null references and matching lengths before any corresponding element access.

isValidCart also checks the line budget, discount range, and every price/quantity pair. It answers a boolean question without editing the arrays. main will return an invalid-cart message before invoking calculation helpers when that question is false. Those helpers can then rely on an explicitly stated precondition.

A valid empty cart has two existing arrays of length zero. It is different from null or mismatched input. Negative values are rejected, not silently skipped: dropping a bad cart line would create a plausible receipt for data the caller never actually submitted as a valid order.

public class Main {
    public static void main(String[] args) {
        System.out.println("Normal cart: " + isValidCart(new int[] {1299}, new int[] {2}, 10));
        System.out.println("Mismatched arrays: " + isValidCart(new int[] {1299}, new int[] {}, 10));
        System.out.println("Invalid discount: " + isValidCart(new int[] {1299}, new int[] {2}, 101));
        System.out.println("Empty cart: " + isValidCart(new int[] {}, new int[] {}, 0));
    }

    static boolean isValidCart(int[] unitCents, int[] quantities, int discountPercent) {
        if (unitCents == null || quantities == null) {
            return false;
        }
        if (unitCents.length != quantities.length || unitCents.length > 100) {
            return false;
        }
        if (discountPercent < 0 || discountPercent > 100) {
            return false;
        }
        for (int index = 0; index < unitCents.length; index++) {
            if (unitCents[index] < 0 || unitCents[index] > 1_000_000
                    || quantities[index] < 0 || quantities[index] > 1000) {
                return false;
            }
        }
        return true;
    }
}

Select Run code to compile and execute this program.

Normal cart: true
Mismatched arrays: false
Invalid discount: false
Empty cart: true

One helper handles a line; another handles the collection

The sample has two units at 1299 cents and one unit at 2499 cents. The line totals are 2598 and 2499, so their subtotal is 5097. A paired indexed loop is appropriate because the same position selects both the unit price and its quantity.

subtotalCents starts a local long total at zero and adds each lineTotalCents result. It does not print, alter quantities, apply discounts, or decide shipping. Keeping its contract that narrow makes it possible to test a wrong subtotal without investigating unrelated formatting or shipping logic.

At the maximum validated inputs, 100 lines each contribute at most 1,000,000,000 cents, giving a subtotal no larger than 100,000,000,000 cents. That bound also makes the later multiplication by a percent at most 10,000,000,000,000, within long range. Integer cents still need range reasoning; they are not automatically immune to overflow.

public class Main {
    public static void main(String[] args) {
        int[] prices = {1299, 2499};
        int[] quantities = {2, 1};
        System.out.println("Subtotal cents: " + subtotalCents(prices, quantities));
    }

    // Preconditions: 0 <= unitCents <= 1_000_000 and 0 <= quantity <= 1000.
    static long lineTotalCents(int unitCents, int quantity) {
        return (long) unitCents * quantity;
    }

    // Precondition: the cart has passed isValidCart.
    static long subtotalCents(int[] unitCents, int[] quantities) {
        long total = 0;
        for (int index = 0; index < unitCents.length; index++) {
            total += lineTotalCents(unitCents[index], quantities[index]);
        }
        return total;
    }
}

Select Run code to compile and execute this program.

Subtotal cents: 5097

Make the discount's rounding rule part of its contract

Ten percent of 5097 cents is 509.7 cents. This exercise deliberately rounds that discount down to 509 whole cents, leaving 4588 cents of merchandise. A nearest-cent policy would give a different result, so rounding cannot be an unstated implementation detail.

For validated nonnegative operands, subtotal * percent / 100 performs a long multiplication followed by integer division. Truncation toward zero is rounding down in this nonnegative domain. Dividing percent by 100 first would turn most percentages into zero and lose the discount entirely.

Apply this rule once to the whole subtotal, not independently to each line. Rounding separate line discounts can produce a different total. Percent zero must leave the subtotal unchanged; percent 100 must discount all of it. None of these rules are a claim about the rounding policy used by a real shop or payment provider.

public class Main {
    public static void main(String[] args) {
        long subtotal = 5097;
        long discount = discountCents(subtotal, 10);
        System.out.println("Discount cents: " + discount);
        System.out.println("After discount cents: " + (subtotal - discount));
    }

    // Preconditions: 0 <= subtotal <= 100_000_000_000 and 0 <= percent <= 100.
    static long discountCents(long subtotal, int percent) {
        return subtotal * percent / 100;
    }
}

Select Run code to compile and execute this program.

Discount cents: 509
After discount cents: 4588

Use the discounted merchandise amount to decide shipping

shippingCents receives the merchandise amount after discount, not the original subtotal. The boundary is inclusive: 5000 cents qualifies for zero shipping, while 4999 cents incurs 300. Zero merchandise also has zero shipping under this challenge's explicit policy.

In the main sample, the original 5097 cents would pass the threshold, but the discounted 4588 does not. Passing subtotal instead of net would therefore produce an incorrect free-shipping receipt even if all the discount arithmetic were correct.

Keep the zero-amount rule visible instead of letting an empty cart fall into the ordinary under-threshold branch. A fully discounted nonempty cart also has zero merchandise and therefore zero shipping here. Test those cases directly rather than assuming empty and 100-percent-discount examples will behave correctly by accident.

public class Main {
    public static void main(String[] args) {
        System.out.println("At 4999: " + shippingCents(4999));
        System.out.println("At 5000: " + shippingCents(5000));
        System.out.println("At zero: " + shippingCents(0));
    }

    // Precondition: netCents is a valid nonnegative discounted merchandise total.
    static long shippingCents(long netCents) {
        if (netCents == 0 || netCents >= 5000) {
            return 0;
        }
        return 300;
    }
}

Select Run code to compile and execute this program.

At 4999: 300
At 5000: 0
At zero: 0

Format only after calculations are complete

formatCents splits a nonnegative amount into whole units with division by 100 and fractional cents with remainder by 100. The fractional portion needs a leading zero when it is below ten; otherwise five cents would incorrectly display as $0.5 rather than $0.05.

The helper returns text instead of printing. Calculation helpers continue returning numbers that main can subtract, compare, and add. Do not format an amount into a String and then try to use that display text as the input to the next arithmetic step.

This formatter deliberately uses a dollar symbol, two decimal places, and no grouping separators. It is not a universal currency formatter, and currencies and locale requirements can differ. For this bounded exercise, integer formatting makes every expected receipt line deterministic without an extra floating-point conversion.

public class Main {
    public static void main(String[] args) {
        System.out.println(formatCents(0));
        System.out.println(formatCents(5));
        System.out.println(formatCents(105));
        System.out.println(formatCents(5097));
    }

    // Precondition: cents is nonnegative. This exercise uses two decimal places.
    static String formatCents(long cents) {
        long whole = cents / 100;
        long fraction = cents % 100;
        return "$" + whole + "." + (fraction < 10 ? "0" : "") + fraction;
    }
}

Select Run code to compile and execute this program.

$0.00
$0.05
$1.05
$50.97

Let main show the sequence without owning every formula

The composition example begins with a validated subtotal of 6000, calculates a 600-cent discount, and obtains 5400 cents of merchandise. Shipping is then zero, so the final amount is also 5400. Each returned value becomes an input to the next meaningful operation.

main is the coordinator: validate, calculate subtotal, calculate discount, subtract discount, choose shipping, add shipping, format, print. It should be easy to read that order without opening every helper. The helpers still own their small formulas and state their required input domains.

Do not add recursion or overloading merely because the preceding lessons covered them. This linear cart traversal is clear as a loop, and the operations have distinct useful names. A challenge demonstrates judgment about which tools fit, not a requirement to use every syntax feature in one program.

public class Main {
    public static void main(String[] args) {
        long subtotal = 6000;
        long discount = discountCents(subtotal, 10);
        long net = subtotal - discount;
        long shipping = shippingCents(net);
        long total = net + shipping;
        System.out.println("Net cents: " + net);
        System.out.println("Shipping cents: " + shipping);
        System.out.println("Total cents: " + total);
    }

    // Preconditions: 0 <= subtotal <= 100_000_000_000 and 0 <= percent <= 100.
    static long discountCents(long subtotal, int percent) {
        return subtotal * percent / 100;
    }

    // Precondition: netCents is a valid nonnegative discounted merchandise total.
    static long shippingCents(long netCents) {
        if (netCents == 0 || netCents >= 5000) {
            return 0;
        }
        return 300;
    }
}

Select Run code to compile and execute this program.

Net cents: 5400
Shipping cents: 0
Total cents: 5400

Independent calls and unchanged inputs are part of correctness

A subtotal belongs to one calculation, so its accumulator is local to that invocation. Calling another cart in between two calls for the first must not change either answer. The repeat example gives 5097, then 500, then 5097 again, and zero for an empty cart.

All price-calculation methods read arrays without assigning to their elements. The final lab saves snapshots to verify that the source prices and quantities remain unchanged. A method returning a plausible total while reducing quantities or changing prices would violate the read-only contract.

Avoid hidden static fields for subtotal, discount, or shipping. They make one receipt depend on earlier calls and force callers to remember cleanup. Returning numeric results and keeping local report variables makes the sequence testable without shared working state.

public class Main {
    public static void main(String[] args) {
        int[] prices = {1299, 2499};
        int[] quantities = {2, 1};
        System.out.println("First: " + subtotalCents(prices, quantities));
        System.out.println("Other cart: " + subtotalCents(new int[] {500}, new int[] {1}));
        System.out.println("First again: " + subtotalCents(prices, quantities));
        System.out.println("Empty: " + subtotalCents(new int[] {}, new int[] {}));
    }

    // Preconditions: 0 <= unitCents <= 1_000_000 and 0 <= quantity <= 1000.
    static long lineTotalCents(int unitCents, int quantity) {
        return (long) unitCents * quantity;
    }

    // Precondition: the cart has passed isValidCart.
    static long subtotalCents(int[] unitCents, int[] quantities) {
        long total = 0;
        for (int index = 0; index < unitCents.length; index++) {
            total += lineTotalCents(unitCents[index], quantities[index]);
        }
        return total;
    }
}

Select Run code to compile and execute this program.

First: 5097
Other cart: 500
First again: 5097
Empty: 0

Turn each rule into a test before revealing the solution

First compute one normal receipt by hand. Then test empty arrays, zero quantity, zero price, no discount, full discount, and the smallest nonzero amount. Test invalid references, mismatched arrays, negative values, and each maximum plus one separately from accepted input.

For shipping, use after-discount amounts just below, exactly at, and just above 5000. Include a subtotal that crosses below the threshold after discount so a wrong argument cannot hide. For rounding, use an amount that produces a fractional cent discount rather than only multiples of 100.

Finally check identities: discount must be between zero and subtotal, net must equal subtotal minus discount, and total must equal net plus shipping. Repeat calls in different orders and compare input snapshots. These checks locate a broken contract more effectively than one final output assertion alone.

A nonzero percentage produces zero discount

The percent may have been divided by 100 using integer arithmetic before multiplication. Multiply the validated long subtotal first, then divide once to implement the chosen round-down rule.

A discounted order receives the wrong shipping fee

Check the argument to shippingCents: the contract needs net merchandise after discount. Test a subtotal just at or above the threshold that becomes lower after discount.

An empty cart is charged shipping

The zero-net rule may be missing. Under this fictional policy, zero merchandise has zero shipping. Make that rule explicit before the ordinary positive-under-threshold branch.

Paired indexing fails or a bad line is silently omitted

Validate both references, equal lengths, and all values before calculating. Invalid input should reject this cart, not be silently skipped into a different receipt.

Large totals overflow despite a long result variable

Check the type used during each operation and the accumulator's type, not just its final destination. Widen before multiplication and retain the validated line-count and numeric bounds through the discount intermediate.

The receipt has five cents displayed as $0.5

The remainder must be padded to two decimal digits. Keep formatting separate from arithmetic and test 0, 1, 5, 10, and 105 cents rather than only whole-dollar amounts.

References and related learning

The policy, scenarios, explanations, examples, and exercises are original SovranCode teaching material. Official references support the Java 21 arithmetic and method rules, not the fictional commerce policy.

• Java 21 specification: integer division
• Java 21 specification: numeric contexts and promotion
• Java 21 specification: method declarations

Review returned results · Review numeric conversions · Review independent local state · Java course roadmap.

Last updated: 21 October 2026