Vfrdtyky

I have the following program
The sum of squares 1^2 + 2^2 + … + N^2 is calculated as:
Example output:

java SumSquares 2 = 5

java SumSquares 3 = 14

java SumSquares 1000000 = 333333833333500000

Here's what I have so far:

        int N = Integer.parseInt(args[0]);

        int sum = 0;

        long R;



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

            R = i * i;

            if (i != R / i) {

                System.err.println("Overflow at i = " + i);

                System.exit(1);

            }

            sum += R;

        }

        System.out.println(sum);

My output is java SumSquares 100000000
Overflow at i = 46341

As 46341^2 passes MAX INT.

I just can't get the program to out put the below instructions, any ideas on how to get

java SumSquares 100000000
Overflow at i = 3024616

I could change the ints to longs but that would negate the need for the overflow checking.

From specification:

The computation will overflow. I need to exactly determine the point in the summation where the overflow happens, via checking whether the new sum is (strictly) less than the old sum.

java SumSquares 100000000
Overflow at i = 3024616

Note that the above must be achieved by a general overflow-handling in the loop, not by some pre-determined input-testing. So that when the integer-type used for the summation is replaced by some bigger type, your program will fully use the new extended range.

Just to clarify:
Is it possible to get the output

java SumSquares 100000000
Overflow at i = 3024616

As per the specification.

You have 2 errors:

• 
  

  R = i * i still performs the multiplication using int math, and doesn't widen the value to long until after multiplication has already overflowed to a negative value.

  
  
  

  You need to cast at least one of them to long, e.g. R = i * (long) i.

  
  



• if (i != R / i) is not the right test for overflow. Simply check if the long value exceeds the range of int: if (r > Integer.MAX_VALUE)

static int sumOfSquares(int n) {

    int sum = 0;

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

        long r = i * (long) i;

        if (r > Integer.MAX_VALUE) {

            System.err.println("Overflow at i = " + i);

            System.exit(1);

        }

        sum += r;

    }

    return sum;

}

Test

System.out.println(sumOfSquares(2));

System.out.println(sumOfSquares(3));

System.out.println(sumOfSquares(1000000));

Output

5

14

Overflow at i = 46341

Another way to guard against overflow is to use the Math.multiplyExact() and Math.addExact() methods.

static int sumOfSquares(int n) {

    int sum = 0;

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

        int r = Math.multiplyExact(i, i);

        sum = Math.addExact(sum, r);

    }

    return sum;

}

Output

5

14

Exception in thread "main" java.lang.ArithmeticException: integer overflow

    at java.base/java.lang.Math.addExact(Math.java:825)

    at Test.sumOfSquares(Test.java:12)

    at Test.main(Test.java:6)

Or catch the exception if you want a better error message:

static int sumOfSquares(int n) {

    int sum = 0;

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

        try {

            int r = Math.multiplyExact(i, i);

            sum = Math.addExact(sum, r);

        } catch (@SuppressWarnings("unused") ArithmeticException ignored) {

            System.err.println("Overflow at i = " + i);

            System.exit(1);

        }

    }

    return sum;

}

Output

5

14

Overflow at i = 1861

Without having to use longs, you can check if the multiplication of two integers will overflow before actually doing the operation:

int a = 500000; //or -500000

int b = 900000; //or -900000



System.out.println(isOverflowOrUnderflow(a, b));



//Returns true if multiplication of a, b results in an overflow or underflow..

public static boolean isOverflowOrUnderflow(int a, int b) {

    return ((a > Integer.MAX_VALUE / b) || (a < Integer.MIN_VALUE / b) || ((a == -1) && (b == Integer.MIN_VALUE)) || ((b == -1) && (a == Integer.MIN_VALUE)));

}

Example using your code:

public class Main {

    public static void main (String args) {

        int N = Integer.parseInt(args[0]); //Where args[0] = "1000000"..

        int sum = 0;

        long R;



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

            if (Main.isOverflowOrUnderflow(i, i)) {

                System.err.println("Overflow at i = " + i);

                System.exit(1);

            }



            R = i * i;

            sum += R;

        }



        System.out.println(sum);

    }



    public static boolean isOverflowOrUnderflow(int a, int b) {

        return ((a > Integer.MAX_VALUE / b) || (a < Integer.MIN_VALUE / b) || ((a == -1) && (b == Integer.MIN_VALUE)) || ((b == -1) && (a == Integer.MIN_VALUE)));

    }

}

Outputs:

Overflow at i = 46341

Command exited with non-zero status 1