Skip to content
Related Articles

Related Articles

Maximum occurred integer in n ranges | Set-3

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 09 Sep, 2021
Improve Article
Save Article

Given N ranges of the form L to R, the task is to find the maximum occurred integer in all the ranges. If more than one such integer exists, print the smallest one.  

Examples: 

Input: points[] = { {1, 6}, {2, 3}, {2, 5}, {3, 8} } 
Output:
Explanation : 
1 occurs in 1 range {1, 6} 
2 occurs 3 in 3 range {1, 6}, {2, 3}, {2, 5} 
3 occurs 4 in 4 range {1, 6}, {2, 3}, {2, 5}, {3, 8} 
4 occurs 3 in 3 range {1, 6}, {2, 5}, {3, 8} 
5 occurs 3 in 3 range {1, 6}, {2, 5}, {3, 8} 
6 occurs 2 in 2 range {1, 6}, {3, 8} 
7 occurs 1 in 1 range {3, 8} 
8 occurs 1 in 1 range {3, 8}
Hence, the most occurred integer is 3.

Input: points[] = { {1, 4}, {1, 9}, {1, 2}}; 
Output: 1

Approach: This is the improvised approach of Maximum occurred integer in n ranges. The main idea is to use coordinate compression using Hashing. So there is no need to create a frequency array that will exceed the memory limit for large ranges. Below is the step by step algorithm to solve this problem: 

  1. Initialize an ordered map name points, to keep track of the starting and ending points of the given ranges. 
  2. Increase the value of the point[L] by 1, for every starting index of the given range.
  3. Decrease the value of the point[R+1] by 1, for every ending index of the given range.
  4. Iterate the map in the increasing order of value of points. Note that the frequency[current point] = frequency[previous point] + points[current point]. Maintain the value of the frequency of the current point in a variable cur_freq.
  5. The point with the maximum value of cur_freq will be the answer.
  6. Store the index and return it.

Below is the implementation of the above approach:  

C++




// C++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the most
// occurred element in given ranges
void maxOccurring(int range[][2], int n)
{
    // STL map for storing start
    // and end points
    map<int, int> points;
 
    for (int i = 0; i < n; i++) {
        int l = range[i][0];
        int r = range[i][1];
 
        // Increment at starting point
        points[l]++;
 
        // Decrement at ending point
        points[r + 1]--;
    }
 
    // Stores current frequency
    int cur_freq = 0;
 
    // Store element with maximum frequency
    int ans = 0;
 
    // Frequency of the current ans
    int freq_ans = 0;
 
    for (auto x : points) {
        // x.first denotes the current
        // point and x.second denotes
        // points[x.first]
        cur_freq += x.second;
 
        // If frequency of x.first is
        // greater that freq_ans
        if (cur_freq > freq_ans) {
            freq_ans = cur_freq;
            ans = x.first;
        }
    }
 
    // Print Answer
    cout << ans;
}
 
// Driver code
int main()
{
    int range[][2]
        = { { 1, 6 }, { 2, 3 }, { 2, 5 }, { 3, 8 } };
    int n = sizeof(range) / sizeof(range[0]);
 
    // Function call
    maxOccurring(range, n);
 
    return 0;
}

Java




// Java program of the above approach
import java.util.*;
 
class GFG{
 
// Function to print the most
// occurred element in given ranges
static void maxOccurring(int range[][], int n)
{
    // STL map for storing start
    // and end points
    HashMap<Integer,Integer> points = new HashMap<Integer,Integer>();
 
    for (int i = 0; i < n; i++) {
        int l = range[i][0];
        int r = range[i][1];
 
        // Increment at starting point
        if(points.containsKey(l)){
            points.put(l, points.get(l)+1);
        }
        else{
            points.put(l, 1);
 
        // Decrement at ending point
            if(points.containsKey(r + 1)){
                points.put(r + 1, points.get(r + 1)-1);
            }
    }
    }
    // Stores current frequency
    int cur_freq = 0;
 
    // Store element with maximum frequency
    int ans = 0;
 
    // Frequency of the current ans
    int freq_ans = 0;
 
    for (Map.Entry<Integer,Integer> entry :points.entrySet()) {
        // x.first denotes the current
        // point and x.second denotes
        // points[x.first]
        cur_freq += entry.getValue();
 
        // If frequency of x.first is
        // greater that freq_ans
        if (cur_freq > freq_ans) {
            freq_ans = cur_freq;
            ans = entry.getKey();
        }
    }
 
    // Print Answer
    System.out.print(ans);
}
 
// Driver code
public static void main(String[] args)
{
    int range[][]
        = { { 1, 6 }, { 2, 3 }, { 2, 5 }, { 3, 8 } };
    int n = range.length;
 
    // Function call
    maxOccurring(range, n);
 
}
}
 
// This code is contributed by Princi Singh

Python3




# Python 3 program of the above approach
 
# Function to print the most
# occurred element in given ranges
def maxOccurring(range1, n):
   
    # STL map for storing start
    # and end points
    points = {}
 
    for i in range(n):
        l = range1[i][0]
        r = range1[i][1]
 
        # Increment at starting point
        if l in points:
            points[l] += 1
        else:
            points[l] = 1
 
        # Decrement at ending point
        if r+1 in points:
            points[r + 1] -= 1
        else:
            points[r+1] = 0
 
    # Stores current frequency
    cur_freq = 0
 
    # Store element with maximum frequency
    ans = 0
 
    # Frequency of the current ans
    freq_ans = 0
 
    for key,value in points.items():
        # x.first denotes the current
        # point and x.second denotes
        # points[x.first]
        cur_freq += value
 
        # If frequency of x.first is
        # greater that freq_ans
        if (cur_freq > freq_ans):
            freq_ans = cur_freq
            ans = key
 
    # Print Answer
    print(ans)
 
# Driver code
if __name__ == '__main__':
    range1 = [[1, 6],[2, 3],[2, 5],[3, 8]]
    n = len(range1)
 
    # Function call
    maxOccurring(range1, n)
     
    # This code is contributed by ipg2016107.

C#




// C# program of the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to print the most
// occurred element in given ranges
static void maxOccurring(int [,]range, int n)
{
    // STL map for storing start
    // and end points
    Dictionary<int, int> points = new Dictionary<int,int>();
 
    for (int i = 0; i < n; i++) {
        int l = range[i,0];
        int r = range[i,1];
 
        // Increment at starting point
      if(points.ContainsKey(l))
        points[l]++;
       
      else
        points.Add(l,1);
 
        // Decrement at ending point
        if(points.ContainsKey(r+1))
          points[r + 1]--;
        else
          points.Add(r+1,0);
    }
 
    // Stores current frequency
    int cur_freq = 0;
 
    // Store element with maximum frequency
    int ans = 0;
 
    // Frequency of the current ans
    int freq_ans = 0;
 
    foreach(KeyValuePair<int,int> entry in points) {
        // x.first denotes the current
        // point and x.second denotes
        // points[x.first]
        cur_freq += entry.Value;
 
        // If frequency of x.first is
        // greater that freq_ans
        if (cur_freq > freq_ans) {
            freq_ans = cur_freq;
            ans = entry.Key;
        }
    }
 
    // Print Answer
    Console.Write(ans);
}
 
// Driver code
public static void Main()
{
    int [,]range = {{1, 6 }, { 2, 3 }, { 2, 5 }, { 3, 8 } };
    int n = 4;
 
    // Function call
    maxOccurring(range, n);
}
}
 
// This code is contributed by ipg2016107.

Javascript




<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to print the most
        // occurred element in given ranges
        function maxOccurring(range, n)
        {
         
            // STL map for storing start
            // and end points
            let points = new Map();
 
            for (let i = 0; i < n; i++) {
                let l = range[i][0];
                let r = range[i][1];
 
                // Increment at starting point
                if (points.has(l))
                    points.set(points.get(l), points.get(l) + 1);
                else
                    points.set(l, 1);
 
                // Decrement at ending point
                if (points.has(r + 1)) {
                    points.set(points.get(r + 1), points.get(r + 1) - 1);
                }
 
            }
 
            // Stores current frequency
            let cur_freq = 0;
 
            // Store element with maximum frequency
            let ans = 0;
 
            // Frequency of the current ans
            let freq_ans = 0;
 
            for (let [key, value] of points)
            {
             
                // x.first denotes the current
                // point and x.second denotes
                // points[x.first]
                cur_freq = cur_freq + value;
 
                // If frequency of x.first is
                // greater that freq_ans
                if (cur_freq > freq_ans) {
                    freq_ans = cur_freq;
                    ans = key;
                }
            }
 
            // Print Answer
            document.write(ans);
        }
 
        // Driver code
        let range
            = [[1, 6], [2, 3], [2, 5], [3, 8]];
        let n = range.length;
 
        // Function call
        maxOccurring(range, n);
 
// This code is contributed by Potta Lokesh
    </script>

Output

3

Time  Complexity: O(n Logn)
Space Complexity: O(n)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!