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. 

kartik

Follow

Improve

Article Tags :

• Bit Magic
• DSA
• integer-overflow

Practice Tags :

• Bit Magic