 Open in App
Not now

# Minimize removals required to make given Array consecutive in any order

• Difficulty Level : Medium
• Last Updated : 24 Jan, 2022

Given an array arr[]. The task is to minimize the number of removals to make all the elements in arr[] consecutive.

Examples

Input: arr[] = {45, 42, 46, 48, 47}
Output: 1
Explanation: After removing 42 we see that there is a consecutive elements present in the array(45-48).

Input: arr[] = {7, 4, 8, 5, 9 }
Output: 2
Explanation: After removing 4 and 5 we see that there is a consecutive elements present in the array(7-9).

Approach: This problem can be solved by using Hashmaps. Follow the steps below to solve the given problem.

• Firstly create a map and at every element i.e at every key put its value true.
• So each element/key has true value. Now move through the keyset of the map and see if it contains (key-1) in the map.
• If it is then put false at that key.
• Now in another loop, work for that keys whose value is true and go till its longest sequence and find the length of the longest consecutive sequence.
• So the minimum number of removals will be the difference in length of array and length of the longest consecutive sequence.

Follow the steps below to solve the given problem.

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `void` `minRemovalsConsecutive(vector<``int``>& a, ``int` `n)` `{`   `  ``// Hashmap to store the elements` `  ``// in key-value pairs` `  ``map<``int``, ``bool``> map;`   `  ``for` `(``int` `val : a) {` `    ``map[val] = ``true``;` `  ``}` `  ``for` `(``auto` `it = map.begin(); it != map.end(); ++it) {` `    ``if` `(map.count(it->first - 1)) {` `      ``map[it->first] = ``false``;` `    ``}` `  ``}` `  ``int` `max = 0;`   `  ``// Iterating for all keys in map` `  ``for` `(``auto` `it = map.begin(); it != map.end(); ++it) {` `    ``if` `(map.count(it->first)) {` `      ``int` `t1 = 1;` `      ``while` `(map.count(it->first + t1)) {` `        ``t1++;` `      ``}` `      ``if` `(t1 > max) {` `        ``max = t1;` `      ``}` `    ``}` `  ``}`   `  ``// Printing the final answer` `  ``cout << (n - max);` `}`   `// Driver Code` `int` `main()` `{` `  ``int` `N = 5;` `  ``vector<``int``> arr = { 45, 42, 46, 48, 47 };`   `  ``// Function Call` `  ``minRemovalsConsecutive(arr, N);`   `  ``return` `0;` `}`   `// This code is contributed by rakeshsahni`

## Java

 `// Java program for above approach` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG {`   `    ``public` `static` `void` `    ``minRemovalsConsecutive(``int` `a[], ``int` `n)` `    ``{` `        ``// Hashmap to store the elements` `        ``// in key-value pairs` `        ``HashMap map` `            ``= ``new` `HashMap<>();` `        ``for` `(``int` `val : a) {` `            ``map.put(val, ``true``);` `        ``}` `        ``for` `(``int` `val : map.keySet()) {` `            ``if` `(map.containsKey(val - ``1``)) {` `                ``map.put(val, ``false``);` `            ``}` `        ``}` `        ``int` `max = ``0``;`   `        ``// Iterating for all keys in map` `        ``for` `(``int` `val : map.keySet()) {` `            ``if` `(map.get(val)) {` `                ``int` `t1 = ``1``;` `                ``while` `(map.containsKey(val` `                                       ``+ t1)) {` `                    ``t1++;` `                ``}` `                ``if` `(t1 > max) {` `                    ``max = t1;` `                ``}` `            ``}` `        ``}`   `        ``// Printing the final answer` `        ``System.out.println(n - max);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``5``;` `        ``int` `arr[] = { ``45``, ``42``, ``46``, ``48``, ``47` `};`   `        ``// Function Call` `        ``minRemovalsConsecutive(arr, N);` `    ``}` `}`

## Python3

 `# Python 3 program for above approach` `def` `minRemovalsConsecutive(a, n):`   `    ``# Hashmap to store the elements` `    ``# in key-value pairs` `    ``map` `=` `{}`   `    ``for` `val ``in` `a:` `        ``map``[val] ``=` `True`   `    ``for` `it ``in` `map``:` `        ``if` `((it``-``1``) ``in` `map``):` `            ``map``[it] ``=` `False` `    ``max` `=` `0`   `    ``# Iterating for all keys in map` `    ``for` `it ``in` `map``:` `        ``if` `(it ``in` `map``):` `            ``t1 ``=` `1` `            ``while` `((it ``+` `t1) ``in` `map``):` `                ``t1 ``+``=` `1`   `            ``if` `(t1 > ``max``):` `                ``max` `=` `t1` `    ``# Printing the final answer` `    ``print``(n ``-` `max``)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `5` `    ``arr ``=` `[``45``, ``42``, ``46``, ``48``, ``47``]`   `    ``# Function Call` `    ``minRemovalsConsecutive(arr, N)`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {`   `  ``static` `void` `minRemovalsConsecutive(``int` `[]a, ``int` `n)` `  ``{` `    `  `    ``// Hashmap to store the elements` `    ``// in key-value pairs` `    ``Dictionary<``int``, ``bool``> map1 =` `      ``new` `Dictionary<``int``, ``bool``>();`   `    ``foreach` `(``int` `val ``in` `a) {` `      ``map1.Add(val, ``true``);` `    ``}`   `    ``Dictionary<``int``, ``bool``> map2 =` `      ``new` `Dictionary<``int``, ``bool``>();`   `    ``foreach``(KeyValuePair<``int``, ``bool``> k ``in` `map1){` `      ``if` `(map1.ContainsKey(k.Key - 1)) {` `        ``map2.Add(k.Key, ``false``);` `      ``}` `      ``else` `{` `        ``map2.Add(k.Key, ``true``);` `      ``}` `    ``}` `    ``int` `max = 0;`   `    ``// Iterating for all keys in map` `    ``foreach``(KeyValuePair<``int``, ``bool``> k ``in` `map2){` `      ``if` `(map2.ContainsKey(k.Key)) {` `        ``int` `t1 = 1;` `        ``while` `(map2.ContainsKey(k.Key` `                                ``+ t1)) {` `          ``t1++;` `        ``}` `        ``if` `(t1 > max) {` `          ``max = t1;` `        ``}` `      ``}` `    ``}`   `    ``// Printing the final answer` `    ``Console.WriteLine(n - max);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `N = 5;` `    ``int` `[]arr = { 45, 42, 46, 48, 47 };`   `    ``// Function Call` `    ``minRemovalsConsecutive(arr, N);` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`1`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles