Sum of all integers in given N ranges

0 0 7 minutes read

Given N ranges of the form [L, R], the task is to find the sum of all integers that lie in any of the given ranges.

Examples:

Input: arr[] = {{1, 5}, {3, 7}}, N = 2
Output: 28
Explanation: The set of integers that exist in one or more ranges is {1, 2, 3, 4, 5 , 6, 7}. Hence their sum is 28.

Input: ranges[] = {{-12, 15}, {3, 9}, {-5, -2}, {20, 25}, {16, 20}}
Output: 247

Approach: The given problem can be solved by an approach similar to the Merge Overlapping Intervals problem. Below are the steps to follow:

Sort the intervals based on increasing order of L.
Push the first interval onto a stack and for each interval do the following:
- If the current interval does not overlap with the stack top, push it.
- If the current interval overlaps with stack top and right end of the current interval is more than that of stack top, update stack top with the value of right end of current interval.
After traversing through all intervals, the remaining stack contains the merged intervals. The sum of the merged intervals can be calculated using formula for the sum of an Arithmetic Progression as the range [L, R] forms an AP with a common difference as 1 and the number of elements as R – L + 1. The sum is ((L + R)*(R-L+1))/2.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
#define ll long long
using namespace std;
 
// Function to find the sum of all
// integers numbers in range [L, R]
ll sumInRange(long L, long R)
{
    ll Sum = ((R - L + 1) / 2) 
      * (2 * L + (R - L));
    return Sum;
}
 
// Function to find sum of all integers
// that lie in any of the given ranges
ll calcSum(vector<pair<long, long> > data, 
           int n)
{
 
    // Sort intervals in increasing order
    // according to their first element
    sort(data.begin(), data.end());
 
    // Merging the overlapping intervals
    int i, idx = 0;
 
    // Loop to iterate through the array
    for (i = 1; i < n; i++) {
 
        // If current interval overlaps
        // with the previous intervals
        if ((data[idx].second >= 
             data[i].first)
            || (data[i].first == 
                data[idx].second + 1)) {
 
            // Merge the previous and the
            // current interval
            data[idx].second
                = max(data[idx].second, 
                      data[i].second);
        }
        else {
            idx++;
            data[idx].second = data[i].second;
            data[idx].first = data[i].first;
        }
    }
 
    // Stores the required sum
    ll Sum = 0;
 
    // Loop to calculate the sum of all
    // the remaining merged intervals
    for (i = 0; i <= idx; i++) {
 
        // Add sum of integers
        // in current range
        Sum += sumInRange(data[i].first, 
                          data[i].second);
    }
 
    // Return the total Sum
    return Sum;
}
 
// Driver Code
int main()
{
    vector<pair<long, long> > vec 
      = { { -12, 15 }, 
         { 3, 9 }, 
         { -5, -2 }, 
         { 20, 25 }, 
         { 16, 20 } };
 
    cout << calcSum(vec, vec.size());
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG
{
 
// Function to find the sum of all
// integers numbers in range [L, R]
static int sumInRange(int L, int R)
{
    int Sum = ((R - L + 1) / 2) 
      * (2 * L + (R - L));
    return Sum;
}
 
// Function to find sum of all integers
// that lie in any of the given ranges
static int calcSum(int [][]data, 
           int n)
{
 
    // Sort intervals in increasing order
    // according to their first element
    Arrays.sort(data,(a,b)->{
        return a[0]-b[0];
    });
 
    // Merging the overlapping intervals
    int i, idx = 0;
 
    // Loop to iterate through the array
    for (i = 1; i < n; i++) {
 
        // If current interval overlaps
        // with the previous intervals
        if ((data[idx][1] >= 
             data[i][0])
            || (data[i][0] == 
                data[idx][1] + 1)) {
 
            // Merge the previous and the
            // current interval
            data[idx][1]
                = Math.max(data[idx][1], 
                      data[i][1]);
        }
        else {
            idx++;
            data[idx][1] = data[i][1];
            data[idx][0] = data[i][0];
        }
    }
 
    // Stores the required sum
    int Sum = 0;
 
    // Loop to calculate the sum of all
    // the remaining merged intervals
    for (i = 0; i <= idx; i++) {
 
        // Add sum of integers
        // in current range
        Sum += sumInRange(data[i][0], 
                          data[i][1]);
    }
 
    // Return the total Sum
    return Sum;
}
 
// Driver Code
public static void main(String[] args)
{
    int [][]vec 
      = { { -12, 15 }, 
         { 3, 9 }, 
         { -5, -2 }, 
         { 20, 25 }, 
         { 16, 20 } };
 
    System.out.print(calcSum(vec, vec.length));
 
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python 3 program for the above approach
 
# Function to find the sum of all
# integers numbers in range [L, R]
def sumInRange(L, R):
 
    Sum = ((R - L + 1) // 2) * (2 * L + (R - L))
    return Sum
 
# Function to find sum of all integers
# that lie in any of the given ranges
def calcSum(data,
            n):
 
    # Sort intervals in increasing order
    # according to their first element
    data.sort()
 
    # Merging the overlapping intervals
    idx = 0
 
    # Loop to iterate through the array
    for i in range(1, n):
 
        # If current interval overlaps
        # with the previous intervals
        if ((data[idx][1] >=
             data[i][0])
            or (data[i][0] ==
                data[idx][1] + 1)):
 
            # Merge the previous and the
            # current interval
            data[idx][1] = max(data[idx][1],
                               data[i][1])
 
        else:
            idx += 1
            data[idx][1] = data[i][1]
            data[idx][0] = data[i][0]
    # Stores the required sum
    Sum = 0
 
    # Loop to calculate the sum of all
    # the remaining merged intervals
    for i in range(idx+1):
 
        # Add sum of integers
        # in current range
        Sum += sumInRange(data[i][0],
                          data[i][1])
 
    # Return the total Sum
    return Sum
 
# Driver Code
if __name__ == "__main__":
 
    vec = [[-12, 15],
           [3, 9],
           [-5, -2],
           [20, 25],
           [16, 20]]
 
    print(calcSum(vec, len(vec)))
 
    # This code is contributed by ukasp.

C#

// C# implementation of the approach
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
class GFG {
 
  // Custom function for sort 
  public static void Sort<T>(T[][] data, int col) 
  { 
    Comparer<T> comparer = Comparer<T>.Default;
    Array.Sort<T[]>(data, (x,y) => comparer.Compare(x[col],y[col])); 
  } 
 
 
 
  // Function to find the sum of all
  // integers numbers in range [L, R]
  public static int sumInRange(int L, int R)
  {
    int Sum = ((R - L + 1) / 2)  * (2 * L + (R - L));
    return Sum;
  }
 
  // Function to find sum of all integers
  // that lie in any of the given ranges
  public static int calcSum(int[][] data, int n)
  {
 
    // Sort intervals in increasing order
    // according to their first element   
    Sort<int>(data, 0); 
 
    // Merging the overlapping intervals
    int i = 0;
    int idx = 0;
 
    // Loop to iterate through the array
    for (i = 1; i < n; i++) {
 
      // If current interval overlaps
      // with the previous intervals
      if ((data[idx][1] >= data[i][0]) || (data[i][0] == data[idx][1] + 1)) {
 
        // Merge the previous and the
        // current interval
        data[idx][1] = Math.Max(data[idx][1], data[i][1]);
      }
      else {
        idx++;
        data[idx][1] = data[i][1];
        data[idx][0] = data[i][0];
      }
    }
 
    // Stores the required sum
    int Sum = 0;
 
    // Loop to calculate the sum of all
    // the remaining merged intervals
    for (i = 0; i <= idx; i++) {
 
      // Add sum of integers
      // in current range
      Sum += sumInRange(data[i][0], data[i][1]);
    }
 
    // Return the total Sum
    return Sum;
  }
 
  static void Main() {
 
    int[][] vec = new int[][] { 
      new int[] {-12, 15}, 
      new int[] {3, 9 }, 
      new int[] {-5, -2 },
      new int[] {20, 25},
      new int[] {16, 20}
    }; 
    Console.WriteLine(calcSum(vec, vec.Length));
  }
}
 
// The code is contributed by Nidhi goel.

Javascript

<script>
       // JavaScript code for the above approach
 
       // Function to find the sum of all
       // integers numbers in range [L, R]
       function sumInRange(L, R) {
           let Sum = ((R - L + 1) / 2)
               * (2 * L + (R - L));
           return Sum;
       }
 
       // Function to find sum of all integers
       // that lie in any of the given ranges
       function calcSum(data, n) {
 
           // Sort intervals in increasing order
           // according to their first element
           data.sort(function (a, b) { return a.first - b.first })
 
           // Merging the overlapping intervals
           let i, idx = 0;
 
           // Loop to iterate through the array
           for (i = 1; i < n; i++) {
 
               // If current interval overlaps
               // with the previous intervals
               if ((data[idx].second >=
                   data[i].first)
                   || (data[i].first ==
                       data[idx].second + 1)) {
 
                   // Merge the previous and the
                   // current interval
                   data[idx].second
                       = Math.max(data[idx].second,
                           data[i].second);
               }
               else {
                   idx++;
                   data[idx].second = data[i].second;
                   data[idx].first = data[i].first;
               }
           }
 
           // Stores the required sum
           let Sum = 0;
 
           // Loop to calculate the sum of all
           // the remaining merged intervals
           for (i = 0; i <= idx; i++) {
 
               // Add sum of integers
               // in current range
               Sum += sumInRange(data[i].first,
                   data[i].second);
           }
 
           // Return the total Sum
           return Sum;
       }
 
       // Driver Code
 
       let vec
           = [{ first: -12, second: 15 },
           { first: 3, second: 9 },
           { first: -5, second: -2 },
           { first: 20, second: 25 },
           { first: 16, second: 20 }];
 
       document.write(calcSum(vec, vec.length));
        
 // This code is contributed by Potta Lokesh
   </script>

Output

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

Recommended

Solve DSA problems on GfG Practice.

Solve Problems

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!