# 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