# Maximum occurred integer in n ranges | Set-3

• Difficulty Level : Medium
• Last Updated : 09 Sep, 2021

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 ` `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 points = ``new` `HashMap();`   `    ``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 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

 ``

Output

`3`

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

My Personal Notes arrow_drop_up
Related Articles