Math Operations — Find the Bug¶

public class Main {
    public static void main(String[] args) {
        long days = 50;
        long hoursPerDay = 24;
        long minutesPerHour = 60;
        long secondsPerMinute = 60;
        long millisecondsPerSecond = 1000;

        long totalMillis = days * hoursPerDay * minutesPerHour
                         * secondsPerMinute * millisecondsPerSecond;

        System.out.println("Milliseconds in " + days + " days: " + totalMillis);
        // Output: Milliseconds in 50 days: 4320000000
    }
}

public class Main {
    private static final double EPSILON = 1e-9;

    public static void main(String[] args) {
        double cartTotal = 0.0;
        for (int i = 0; i < 10; i++) {
            cartTotal += 0.1;
        }

        // Option 1: Epsilon comparison
        if (Math.abs(cartTotal - 1.0) < EPSILON) {
            System.out.println("Cart total is $1.00 — proceed to checkout");
        }

        // Option 2: Use BigDecimal for exact decimal arithmetic
        // BigDecimal total = BigDecimal.ZERO;
        // BigDecimal increment = new BigDecimal("0.1");
        // for (int i = 0; i < 10; i++) total = total.add(increment);
        // if (total.compareTo(BigDecimal.ONE) == 0) { ... }
    }
}

public class Main {
    public static void main(String[] args) {
        int correct = 17;
        int total = 20;
        // Cast one operand to double BEFORE the division
        double percentage = (double) correct / total * 100;
        System.out.println("Score: " + percentage + "%");
        // Output: Score: 85.0%
    }
}

public class Main {
    public static void main(String[] args) {
        double distance = 0.0;
        double time = 0.0;

        double speed = distance / time;

        // Always check for NaN before using the result
        if (Double.isNaN(speed)) {
            System.out.println("Invalid speed calculation (0/0)");
            speed = 0.0; // use a safe default
        } else if (Double.isInfinite(speed)) {
            System.out.println("Invalid speed calculation (division by zero)");
            speed = 0.0;
        }

        double bonus = speed + 50;
        if (bonus > 100) {
            System.out.println("High bonus!");
        } else {
            System.out.println("Normal bonus");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        String[] days = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

        int[] offsets = {0, 3, 7, -1, -8, 14, -14};
        for (int offset : offsets) {
            // Option 1: Manual fix — always non-negative
            int index = ((offset % 7) + 7) % 7;

            // Option 2: Math.floorMod (Java 8+)
            // int index = Math.floorMod(offset, 7);

            System.out.println("Offset " + offset + " -> " + days[index]);
        }
    }
}

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        // Use String constructor for exact decimal values
        BigDecimal price = new BigDecimal("19.99");
        BigDecimal quantity = new BigDecimal("3");
        BigDecimal total = price.multiply(quantity);

        System.out.println("Unit price: $" + price);  // $19.99
        System.out.println("Total:      $" + total);   // $59.97

        // Alternative: BigDecimal.valueOf(19.99) also works
        // because it uses Double.toString(19.99) internally
    }
}

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        BigDecimal total = new BigDecimal("100.00");
        BigDecimal people = new BigDecimal("3");

        // Specify scale (decimal places) and rounding mode
        BigDecimal share = total.divide(people, 2, RoundingMode.HALF_UP);
        System.out.println("Each person pays: $" + share); // $33.33

        // Verify: 33.33 * 3 = 99.99 — one cent short!
        BigDecimal remainder = total.subtract(share.multiply(people));
        System.out.println("Remainder: $" + remainder); // $0.01
        System.out.println("Last person pays: $" + share.add(remainder)); // $33.34
    }
}

public class Main {
    public static void main(String[] args) {
        // Fix 1: Use double instead of float for large values
        double value = 16777217.0;
        long rounded = Math.round(value);
        System.out.println("round(16777217.0) = " + rounded); // 16777217

        // Fix 2: Use double for int-to-floating-point conversion
        int bigNumber = 123456789;
        double asDouble = bigNumber; // double has 52-bit mantissa — safe for all int values
        System.out.println("Original int:    " + bigNumber);
        System.out.println("As double:       " + asDouble);
        System.out.println("Back to int:     " + (int) asDouble); // 123456789

        // Fix 3: Be aware of Math.round asymmetry at -0.5
        // For symmetric rounding, use custom logic
        System.out.println("custom(-0.5) = " + roundAwayFromZero(-0.5)); // -1
        System.out.println("custom(0.5)  = " + roundAwayFromZero(0.5));  // 1
    }

    static long roundAwayFromZero(double value) {
        return (long) (value >= 0 ? Math.floor(value + 0.5) : Math.ceil(value - 0.5));
    }
}

public class Main {
    public static int binarySearch(int[] sorted, int target) {
        int low = 0;
        int high = sorted.length - 1;

        while (low <= high) {
            // Fix: overflow-safe midpoint calculation
            int mid = low + (high - low) / 2;
            // Alternative: int mid = (low + high) >>> 1; // unsigned right shift
            if (sorted[mid] == target) return mid;
            else if (sorted[mid] < target) low = mid + 1;
            else high = mid - 1;
        }
        return -1;
    }

    public static void main(String[] args) {
        int low = Integer.MAX_VALUE - 2;
        int high = Integer.MAX_VALUE;

        int mid = low + (high - low) / 2;
        System.out.println("Midpoint: " + mid); // 2147483646
    }
}

public class Main {
    public static long absoluteDifference(int a, int b) {
        // Widen to long BEFORE subtraction to avoid overflow
        return Math.abs((long) a - (long) b);
    }

    public static void main(String[] args) {
        System.out.println(absoluteDifference(10, 5));                  // 5
        System.out.println(absoluteDifference(-5, 10));                 // 15
        System.out.println(absoluteDifference(Integer.MIN_VALUE, 0));   // 2147483648
        System.out.println(absoluteDifference(Integer.MIN_VALUE, 1));   // 2147483649

        // Java 15+: Math.absExact throws ArithmeticException on overflow
        // Math.absExact(Integer.MIN_VALUE) -> ArithmeticException
    }
}