Check for Integer Overflow

Given two integers a and b. The task is to design a function that adds two integers and detects overflow during the addition. If the sum does not cause an overflow, return their sum. Otherwise, return -1 to indicate an overflow.
Note: You cannot use type casting to a larger data type to check for overflow. Also, the function must handle both positive and negative integers correctly.

Examples:

Input: a = 1000000000, b = 1000000000
Output: 2000000000
Explanation: The sum 1000000000 + 1000000000 = 2000000000 is within the valid integer range, so no overflow occurs, and the function stores the result successfully.

Input: a = -2000000000, b = -500000000
Output: -1
Explanation: The sum -2000000000 + (-5000000000) = -7000000000 exceeds the maximum limit of an integer (assuming 32 bit representation), causing an overflow.

Input: a = -100, b = 100
Output: 0
Explanation: The sum -100 + 100 = 0 is within the valid integer range, so no overflow occurs, and the function stores the result successfully.

[Expected Approach] Observation on Signs of the Integers - O(1) Time and O(1) Space

The idea is to detect overflow by observing how the sum behaves relative to the input values. The thought process is that overflow can only occur if both numbers have the same sign, but the sum has the opposite sign. The key observation is that in a typical integer representation, exceeding the maximum or minimum limit causes a wraparound effect, flipping the sign unexpectedly. By checking if this sign reversal happens, we can accurately determine overflow and return an error indicator.

• Calculate sum
• If both numbers are positive and sum is negative then return -1
• OR If both numbers are negative and sum is positive then return -1
• Else return sum.

// C++ program to add two integers and detect overflow #include <bits/stdc++.h> using namespace std; // Function to add two numbers and check for overflow int addOvf(int a, int b) {    // Calculate sum  int sum = a + b;    // Check for overflow conditions  if ((a > 0 && b > 0 && sum < 0)   || (a < 0 && b < 0 && sum > 0)) {    return -1;   }    return sum; } int main() {    int a = 1000000000, b = 1000000000;    cout << addOvf(a, b) << endl;    return 0; } 

// Java program to add two integers and detect overflow class GfG {  // Function to add two numbers and check for overflow  static int addOvf(int a, int b) {    // Calculate sum  int sum = a + b;    // Check for overflow conditions  if ((a > 0 && b > 0 && sum < 0)   || (a < 0 && b < 0 && sum > 0)) {    return -1;   }    return sum;  }  public static void main(String[] args) {    int a = 1000000000, b = 1000000000;    System.out.println(addOvf(a, b));  } } 

# Python program to add two integers and detect overflow # Function to add two numbers and check for overflow def addOvf(a, b): # Calculate sum sum = a + b # Check for overflow conditions if (a > 0 and b > 0 and sum < 0) or (a < 0 and b < 0 and sum > 0): return -1 return sum if __name__ == "__main__": a, b = 1000000000, 1000000000 print(addOvf(a, b)) 

// C# program to add two integers and detect overflow using System; class GfG {  // Function to add two numbers and check for overflow  static int addOvf(int a, int b) {    // Calculate sum  int sum = a + b;    // Check for overflow conditions  if ((a > 0 && b > 0 && sum < 0)   || (a < 0 && b < 0 && sum > 0)) {    return -1;   }    return sum;  }  public static void Main() {    int a = 1000000000, b = 1000000000;    Console.WriteLine(addOvf(a, b));  } } 

// JavaScript program to add two integers and detect overflow // Function to add two numbers and check for overflow function addOvf(a, b) {    // Calculate sum  let sum = a + b;    // Check for overflow conditions  if ((a > 0 && b > 0 && sum < 0)   || (a < 0 && b < 0 && sum > 0)) {    return -1;   }    return sum; } let a = 1000000000, b = 1000000000; console.log(addOvf(a, b)); 

2000000000 

Time Complexity: O(1), due to constant number of operations (addition and comparisons).
Space Complexity: O(1), as only a few integer variables are used.

[Alternate Approach] Checking the Sum - O(1) Time and O(1) Space

The idea remains the same as in the previous approach, checking for integer overflow while performing addition. Instead of relying on post-addition checks, we now prevent overflow before it happens by ensuring that the sum does not exceed Max Integer Value for positive numbers or go below Min Integer Value for negative numbers.

// C++ program to add two integers and detect overflow #include <bits/stdc++.h> using namespace std; // Function to add two numbers and check  // for overflow int addOvf(int a, int b) {    // Check for positive overflow  if (a >= 0 && b >= 0 && (a > INT_MAX - b)) {  return -1;  }  // Check for negative overflow  else if (a < 0 && b < 0 && (a < INT_MIN - b)) {  return -1;  }  // No overflow, compute sum  int result = a + b;    return result; } int main() {    int a = 1000000000, b = 1000000000;    cout << addOvf(a, b) << endl;    return 0; } 

// Java program to add two integers and detect overflow class GfG {  // Function to add two numbers and check   // for overflow  static int addOvf(int a, int b) {    // Check for positive overflow  if (a >= 0 && b >= 0 && (a > Integer.MAX_VALUE - b)) {  return -1;  }  // Check for negative overflow  else if (a < 0 && b < 0 && (a < Integer.MIN_VALUE - b)) {  return -1;  }  // No overflow, compute sum  int result = a + b;    return result;  }  public static void main(String[] args) {    int a = 1000000000, b = 1000000000;    System.out.println(addOvf(a, b));  } } 

# Python program to add two integers and detect overflow # Function to add two numbers and check  # for overflow def addOvf(a, b): # Check for positive overflow if a >= 0 and b >= 0 and (a > (2**31 - 1) - b): return -1 # Check for negative overflow elif a < 0 and b < 0 and (a < (-2**31) - b): return -1 # No overflow, compute sum result = a + b return result if __name__ == "__main__": a, b = 1000000000, 1000000000 print(addOvf(a, b)) 

// C# program to add two integers and detect overflow using System; class GfG {  // Function to add two numbers and check   // for overflow  public static int addOvf(int a, int b) {    // Check for positive overflow  if (a >= 0 && b >= 0 && (a > int.MaxValue - b)) {  return -1;  }  // Check for negative overflow  else if (a < 0 && b < 0 && (a < int.MinValue - b)) {  return -1;  }  // No overflow, compute sum  int result = a + b;    return result;  }  public static void Main() {    int a = 1000000000, b = 1000000000;    Console.WriteLine(addOvf(a, b));  } } 

// JavaScript program to add two integers and detect overflow // Function to add two numbers and check  // for overflow function addOvf(a, b) {    // Check for positive overflow  if (a >= 0 && b >= 0 && (a > Number.MAX_SAFE_INTEGER - b)) {  return -1;  }  // Check for negative overflow  else if (a < 0 && b < 0 && (a < Number.MIN_SAFE_INTEGER - b)) {  return -1;  }  // No overflow, compute sum  let result = a + b;    return result; } // Driver Code let a = 1000000000, b = 1000000000; console.log(addOvf(a, b)); 

2000000000 

Time Complexity: O(1), due to constant number of operations (addition and comparisons).
Space Complexity: O(1), as only a few integer variables are used.