Find missing elements of a range
Last Updated : 23 Oct, 2024
Given an array, arr[0..n-1] of distinct elements and a range [low, high], find all numbers that are in a range, but not the array. The missing elements should be printed in sorted order.
Examples:
Input: arr[] = {10, 12, 11, 15},
low = 10, high = 15
Output: 13, 14
Input: arr[] = {1, 14, 11, 51, 15},
low = 50, high = 55
Output: 50, 52, 53, 54 55
Naive Approach - O(n^2) Time and O(1) Space
The naive approach for the problem can be to use two nested loops: one to traverse numbers from low to high and other one to traverse entire array to find out whether the element of the outer loop exists in the array or not. If it doesn't exist we will print it else continue to next iteration.
C++ // C++ code for the approach #include <bits/stdc++.h> using namespace std; // Function to find and print missing // elements in the given range void findMissing(int arr[], int n, int low, int high) { // Loop through the range of numbers from low to high for (int i = low; i <= high; i++) { bool found = false; // Loop through the array to check if i exists in it for (int j = 0; j < n; j++) { if (arr[j] == i) { found = true; break; } } // If i is not found in the array, print it if (!found) { cout << i << " "; } } } // Driver's code int main() { // Input array int arr[] = { 1, 3, 5, 4 }; int n = sizeof(arr) / sizeof(arr[0]); int low = 1, high = 10; // Function call findMissing(arr, n, low, high); return 0; } // Java code for the approach import java.util.*; public class GFG { // Function to find and print missing // elements in the given range static void findMissing(int[] arr, int n, int low, int high) { // Loop through the range of numbers from low to // high for (int i = low; i <= high; i++) { boolean found = false; // Loop through the array to check if i exists // in it for (int j = 0; j < n; j++) { if (arr[j] == i) { found = true; break; } } // If i is not found in the array, print it if (!found) { System.out.print(i + " "); } } } // Driver's code public static void main(String[] args) { // Input array int[] arr = { 1, 3, 5, 4 }; int n = arr.length; int low = 1, high = 10; // Function call findMissing(arr, n, low, high); } } # Function to find and print missing # elements in the given range def findMissing(arr, n, low, high): # Loop through the range of numbers from low to high for i in range(low, high+1): found = False # Loop through the array to check if i exists in it for j in range(n): if arr[j] == i: found = True break # If i is not found in the array, print it if not found: print(i, end=' ') # Driver's code if __name__ == '__main__': # Input array arr = [1, 3, 5, 4] n = len(arr) low = 1 high = 10 # Function call findMissing(arr, n, low, high)
using System; class GFG { // Function to find and print missing // elements in the given range static void FindMissing(int[] arr, int n, int low, int high) { // Loop through the range of numbers from low to // high for (int i = low; i <= high; i++) { bool found = false; // Loop through the array to check if i exists // in it for (int j = 0; j < n; j++) { if (arr[j] == i) { found = true; break; } } // If i is not found in the array, print it if (!found) { Console.Write(i + " "); } } } // Driver's code static void Main() { // Input array int[] arr = { 1, 3, 5, 4 }; int n = arr.Length; int low = 1, high = 10; // Function call FindMissing(arr, n, low, high); } } // This code is contributed by rambabuguphka // Function to find and print missing // elements in the given range function findMissing(arr, low, high) { const missing = []; // Loop through the range of numbers from low to high for (let i = low; i <= high; i++) { let found = false; // Loop through the array to check if i exists in it for (let j = 0; j < arr.length; j++) { if (arr[j] === i) { found = true; break; } } // If i is not found in the array, add it to the missing array if (!found) { missing.push(i); } } // Print the missing elements for (let i = 0; i < missing.length; i++) { console.log(missing[i] + " "); } } // Driver's code const arr = [1, 3, 5, 4]; const low = 1, high = 10; // Function call findMissing(arr, low, high); // THIS CODE IS CONTRIBUTED BY CHANDAN AGARWAL
Better Approach - Sorting - O(n Log n) Time and O(1) Space
Sort the array, then do a binary search for 'low'. Once the location of low is found, start traversing the array from that location and keep printing all missing numbers.
C++ // A sorting based C++ program to find missing // elements from an array #include <bits/stdc++.h> using namespace std; // Print all elements of range [low, high] that // are not present in arr[0..n-1] void printMissing(int arr[], int n, int low, int high) { // Sort the array sort(arr, arr + n); // Do binary search for 'low' in sorted // array and find index of first element // which either equal to or greater than // low. int* ptr = lower_bound(arr, arr + n, low); int index = ptr - arr; // Start from the found index and linearly // search every range element x after this // index in arr[] int i = index, x = low; while (i < n && x <= high) { // If x doesn't match with current element // print it if (arr[i] != x) cout << x << " "; // If x matches, move to next element in arr[] else i++; // Move to next element in range [low, high] x++; } // Print range elements that are greater than the // last element of sorted array. while (x <= high) cout << x++ << " "; } // Driver program int main() { int arr[] = { 1, 3, 5, 4 }; int n = sizeof(arr) / sizeof(arr[0]); int low = 1, high = 10; printMissing(arr, n, low, high); return 0; } // A sorting based Java program to find missing // elements from an array import java.util.Arrays; public class PrintMissing { // Print all elements of range [low, high] that // are not present in arr[0..n-1] static void printMissing(int ar[], int low, int high) { Arrays.sort(ar); // Do binary search for 'low' in sorted // array and find index of first element // which either equal to or greater than // low. int index = ceilindex(ar, low, 0, ar.length - 1); int x = low; // Start from the found index and linearly // search every range element x after this // index in arr[] while (index < ar.length && x <= high) { // If x doesn't match with current element // print it if (ar[index] != x) { System.out.print(x + " "); } // If x matches, move to next element in arr[] else index++; // Move to next element in range [low, high] x++; } // Print range elements that are greater than the // last element of sorted array. while (x <= high) { System.out.print(x + " "); x++; } } // Utility function to find ceil index of given element static int ceilindex(int ar[], int val, int low, int high) { if (val < ar[0]) return 0; if (val > ar[ar.length - 1]) return ar.length; int mid = (low + high) / 2; if (ar[mid] == val) return mid; if (ar[mid] < val) { if (mid + 1 < high && ar[mid + 1] >= val) return mid + 1; return ceilindex(ar, val, mid + 1, high); } else { if (mid - 1 >= low && ar[mid - 1] < val) return mid; return ceilindex(ar, val, low, mid - 1); } } // Driver program to test above function public static void main(String[] args) { int arr[] = { 1, 3, 5, 4 }; int low = 1, high = 10; printMissing(arr, low, high); } } // This code is contributed by Rishabh Mahrsee # Python library for binary search from bisect import bisect_left # A sorting based C++ program to find missing # elements from an array # Print all elements of range [low, high] that # are not present in arr[0..n-1] def printMissing(arr, n, low, high): # Sort the array arr.sort() # Do binary search for 'low' in sorted # array and find index of first element # which either equal to or greater than # low. ptr = bisect_left(arr, low) index = ptr # Start from the found index and linearly # search every range element x after this # index in arr[] i = index x = low while (i < n and x <= high): # If x doesn't match with current element # print it if(arr[i] != x): print(x, end =" ") # If x matches, move to next element in arr[] else: i = i + 1 # Move to next element in range [low, high] x = x + 1 # Print range elements that are greater than the # last element of sorted array. while (x <= high): print(x, end =" ") x = x + 1 # Driver code arr = [1, 3, 5, 4] n = len(arr) low = 1 high = 10 printMissing(arr, n, low, high); # This code is contributed by YatinGupta
// A sorting based Java program to // find missing elements from an array using System; class GFG { // Print all elements of range // [low, high] that are not // present in arr[0..n-1] static void printMissing(int[] ar, int low, int high) { Array.Sort(ar); // Do binary search for 'low' in sorted // array and find index of first element // which either equal to or greater than // low. int index = ceilindex(ar, low, 0, ar.Length - 1); int x = low; // Start from the found index and linearly // search every range element x after this // index in arr[] while (index < ar.Length && x <= high) { // If x doesn't match with current // element print it if (ar[index] != x) { Console.Write(x + " "); } // If x matches, move to next // element in arr[] else index++; // Move to next element in // range [low, high] x++; } // Print range elements that // are greater than the // last element of sorted array. while (x <= high) { Console.Write(x + " "); x++; } } // Utility function to find // ceil index of given element static int ceilindex(int[] ar, int val, int low, int high) { if (val < ar[0]) return 0; if (val > ar[ar.Length - 1]) return ar.Length; int mid = (low + high) / 2; if (ar[mid] == val) return mid; if (ar[mid] < val) { if (mid + 1 < high && ar[mid + 1] >= val) return mid + 1; return ceilindex(ar, val, mid + 1, high); } else { if (mid - 1 >= low && ar[mid - 1] < val) return mid; return ceilindex(ar, val, low, mid - 1); } } // Driver Code static public void Main() { int[] arr = { 1, 3, 5, 4 }; int low = 1, high = 10; printMissing(arr, low, high); } } // This code is contributed // by Sach_Code <script> // JavaScript code for the above approach // Print all elements of range [low, high] that // are not present in arr[0..n-1] function printMissing(ar, low, high) { ar.sort(); // Do binary search for 'low' in sorted // array and find index of first element // which either equal to or greater than // low. let index = ceilindex(ar, low, 0, ar.length - 1); let x = low; // Start from the found index and linearly // search every range element x after this // index in arr[] while (index < ar.length && x <= high) { // If x doesn't match with current element // print it if (ar[index] != x) { document.write(x + " "); } // If x matches, move to next element in arr[] else index++; // Move to next element in range [low, high] x++; } // Print range elements that are greater than the // last element of sorted array. while (x <= high) { document.write(x + " "); x++; } } // Utility function to find ceil index of given element function ceilindex(ar, val, low, high) { if (val < ar[0]) return 0; if (val > ar[ar.length - 1]) return ar.length; let mid = Math.floor((low + high) / 2); if (ar[mid] == val) return mid; if (ar[mid] < val) { if (mid + 1 < high && ar[mid + 1] >= val) return mid + 1; return ceilindex(ar, val, mid + 1, high); } else { if (mid - 1 >= low && ar[mid - 1] < val) return mid; return ceilindex(ar, val, low, mid - 1); } } // Driver Code let arr = [ 1, 3, 5, 4 ]; let low = 1, high = 10; printMissing(arr, low, high); </script> Expected Approach 1 - Using Boolean Array - O(n + high - low + 1) Time and O(high - low + 1) Space
Create a boolean array, where each index will represent whether the (i+low)th element is present in the array or not. Mark all those elements which are in the given range and are present in the array. Once all array items present in the given range have been marked true in the array, we traverse through the Boolean array and print all elements whose value is false.
C++14 // An array based C++ program // to find missing elements from // an array #include <bits/stdc++.h> using namespace std; // Print all elements of range // [low, high] that are not present // in arr[0..n-1] void printMissing( int arr[], int n, int low, int high) { // Create boolean array of size // high-low+1, each index i representing // whether (i+low)th element found or not. bool points_of_range[high - low + 1] = { false }; for (int i = 0; i < n; i++) { // if ith element of arr is in // range low to high then mark // corresponding index as true in array if (low <= arr[i] && arr[i] <= high) points_of_range[arr[i] - low] = true; } // Traverse through the range and // print all elements whose value // is false for (int x = 0; x <= high - low; x++) { if (points_of_range[x] == false) cout << low + x << " "; } } // Driver program int main() { int arr[] = { 1, 3, 5, 4 }; int n = sizeof(arr) / sizeof(arr[0]); int low = 1, high = 10; printMissing(arr, n, low, high); return 0; } // This code is contributed by Shubh Bansal // An array based Java program // to find missing elements from // an array import java.util.Arrays; public class Print { // Print all elements of range // [low, high] that are not present // in arr[0..n-1] static void printMissing( int arr[], int low, int high) { // Create boolean array of // size high-low+1, each index i // representing whether (i+low)th // element found or not. boolean[] points_of_range = new boolean [high - low + 1]; for (int i = 0; i < arr.length; i++) { // if ith element of arr is in // range low to high then mark // corresponding index as true in array if (low <= arr[i] && arr[i] <= high) points_of_range[arr[i] - low] = true; } // Traverse through the range and print all // elements whose value is false for (int x = 0; x <= high - low; x++) { if (points_of_range[x] == false) System.out.print((low + x) + " "); } } // Driver program to test above function public static void main(String[] args) { int arr[] = { 1, 3, 5, 4 }; int low = 1, high = 10; printMissing(arr, low, high); } } // This code is contributed by Shubh Bansal # An array-based Python3 program to # find missing elements from an array # Print all elements of range # [low, high] that are not # present in arr[0..n-1] def printMissing(arr, n, low, high): # Create boolean list of size # high-low+1, each index i # representing whether (i+low)th # element found or not. points_of_range = [False] * (high-low+1) for i in range(n) : # if ith element of arr is in range # low to high then mark corresponding # index as true in array if ( low <= arr[i] and arr[i] <= high ) : points_of_range[arr[i]-low] = True # Traverse through the range # and print all elements whose value # is false for x in range(high-low+1) : if (points_of_range[x]==False) : print(low+x, end = " ") # Driver Code arr = [1, 3, 5, 4] n = len(arr) low, high = 1, 10 printMissing(arr, n, low, high) # This code is contributed # by Shubh Bansal
// An array based C# program // to find missing elements from // an array using System; class GFG{ // Print all elements of range // [low, high] that are not present // in arr[0..n-1] static void printMissing(int[] arr, int n, int low, int high) { // Create boolean array of size // high-low+1, each index i representing // whether (i+low)th element found or not. bool[] points_of_range = new bool[high - low + 1]; for(int i = 0; i < high - low + 1; i++) points_of_range[i] = false; for(int i = 0; i < n; i++) { // If ith element of arr is in // range low to high then mark // corresponding index as true in array if (low <= arr[i] && arr[i] <= high) points_of_range[arr[i] - low] = true; } // Traverse through the range and // print all elements whose value // is false for(int x = 0; x <= high - low; x++) { if (points_of_range[x] == false) Console.Write("{0} ", low + x); } } // Driver code public static void Main() { int[] arr = { 1, 3, 5, 4 }; int n = arr.Length; int low = 1, high = 10; printMissing(arr, n, low, high); } } // This code is contributed by subhammahato348 <script> // Javascript program to find missing elements from // an array // Print all elements of range // [low, high] that are not present // in arr[0..n-1] function printMissing( arr, low, high) { // Create boolean array of // size high-low+1, each index i // representing whether (i+low)th // element found or not. let points_of_range = Array(high - low + 1).fill(0); for (let i = 0; i < arr.length; i++) { // if ith element of arr is in // range low to high then mark // corresponding index as true in array if (low <= arr[i] && arr[i] <= high) points_of_range[arr[i] - low] = true; } // Traverse through the range and print all // elements whose value is false for (let x = 0; x <= high - low; x++) { if (points_of_range[x] == false) document.write((low + x) + " "); } } // Driver program let arr = [ 1, 3, 5, 4 ]; let low = 1, high = 10; printMissing(arr, low, high); // This code is contributed by code_hunt. </script> Expected Approach 2 - Use Hashing - O(n + high - low + 1) Time and O(n) Space
Create a hash table and insert all array items into the hash table. Once all items are in hash table, traverse through the range and print all missing elements.
C++ // A hashing based C++ program to find missing // elements from an array #include <bits/stdc++.h> using namespace std; // Print all elements of range [low, high] that // are not present in arr[0..n-1] void printMissing(int arr[], int n, int low, int high) { // Insert all elements of arr[] in set unordered_set<int> s; for (int i = 0; i < n; i++) s.insert(arr[i]); // Traverse through the range an print all // missing elements for (int x = low; x <= high; x++) if (s.find(x) == s.end()) cout << x << " "; } // Driver program int main() { int arr[] = { 1, 3, 5, 4 }; int n = sizeof(arr) / sizeof(arr[0]); int low = 1, high = 10; printMissing(arr, n, low, high); return 0; } // A hashing based Java program to find missing // elements from an array import java.util.Arrays; import java.util.HashSet; public class Print { // Print all elements of range [low, high] that // are not present in arr[0..n-1] static void printMissing(int ar[], int low, int high) { HashSet<Integer> hs = new HashSet<>(); // Insert all elements of arr[] in set for (int i = 0; i < ar.length; i++) hs.add(ar[i]); // Traverse through the range an print all // missing elements for (int i = low; i <= high; i++) { if (!hs.contains(i)) { System.out.print(i + " "); } } } // Driver program to test above function public static void main(String[] args) { int arr[] = { 1, 3, 5, 4 }; int low = 1, high = 10; printMissing(arr, low, high); } } // This code is contributed by Rishabh Mahrsee # A hashing based Python3 program to # find missing elements from an array # Print all elements of range # [low, high] that are not # present in arr[0..n-1] def printMissing(arr, n, low, high): # Insert all elements of # arr[] in set s = set(arr) # Traverse through the range # and print all missing elements for x in range(low, high + 1): if x not in s: print(x, end = ' ') # Driver Code arr = [1, 3, 5, 4] n = len(arr) low, high = 1, 10 printMissing(arr, n, low, high) # This code is contributed # by SamyuktaSHegde
// A hashing based C# program to // find missing elements from an array using System; using System.Collections.Generic; class GFG { // Print all elements of range // [low, high] that are not // present in arr[0..n-1] static void printMissing(int[] arr, int n, int low, int high) { // Insert all elements of arr[] in set HashSet<int> s = new HashSet<int>(); for (int i = 0; i < n; i++) { s.Add(arr[i]); } // Traverse through the range // an print all missing elements for (int x = low; x <= high; x++) if (!s.Contains(x)) Console.Write(x + " "); } // Driver Code public static void Main() { int[] arr = { 1, 3, 5, 4 }; int n = arr.Length; int low = 1, high = 10; printMissing(arr, n, low, high); } } // This code is contributed by ihritik <script> // A hashing based Java program to find missing // elements from an array // Print all elements of range [low, high] that // are not present in arr[0..n-1] function printMissing(ar, low, high) { let hs = new Set(); // Insert all elements of arr[] in set for (let i = 0; i < ar.length; i++) hs.add(ar[i]); // Traverse through the range an print all // missing elements for (let i = low; i <= high; i++) { if (!hs.has(i)) { document.write(i + " "); } } } // Driver program to test above function let arr = [1, 3, 5, 4]; let low = 1, high = 10; printMissing(arr, low, high); // This code is contributed by gfgking </script>
Which approach is better?
The time complexity of the first approach is O(nLogn + k) where k is the number of missing elements (Note that k may be more than n Log n if the array is small and the range is big)
The time complexity of the second and third solutions is O(n + (high-low+1)).
If the given array has almost all elements of the range, i.e., n is close to the value of (high-low+1), then the second and third approaches are definitely better as there is no Log n factor. But if n is much smaller than the range, then the first approach is better as it doesn't require extra space for hashing. We can also modify the first approach to print adjacent missing elements as range to save time. For example, if 50, 51, 52, 53, 54, 59 are missing, we can print them as 50-54, 59 in the first method. And if printing this way is allowed, the first approach takes only O(n Log n) time. Out of the Second and Third Solutions, the second solution is better because the worst-case time complexity of the second solution is better than the third.
Similar Reads
Hashing in Data Structure Hashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
3 min read
Introduction to Hashing Hashing refers to the process of generating a small sized output (that can be used as index in a table) from an input of typically large and variable size. Hashing uses mathematical formulas known as hash functions to do the transformation. This technique determines an index or location for the stor
7 min read
What is Hashing? Hashing refers to the process of generating a fixed-size output from an input of variable size using the mathematical formulas known as hash functions. This technique determines an index or location for the storage of an item in a data structure. Need for Hash data structureThe amount of data on the
3 min read
Index Mapping (or Trivial Hashing) with negatives allowed Index Mapping (also known as Trivial Hashing) is a simple form of hashing where the data is directly mapped to an index in a hash table. The hash function used in this method is typically the identity function, which maps the input data to itself. In this case, the key of the data is used as the ind
7 min read
Separate Chaining Collision Handling Technique in Hashing Separate Chaining is a collision handling technique. Separate chaining is one of the most popular and commonly used techniques in order to handle collisions. In this article, we will discuss about what is Separate Chain collision handling technique, its advantages, disadvantages, etc.There are mainl
3 min read
Open Addressing Collision Handling technique in Hashing Open Addressing is a method for handling collisions. In Open Addressing, all elements are stored in the hash table itself. So at any point, the size of the table must be greater than or equal to the total number of keys (Note that we can increase table size by copying old data if needed). This appro
7 min read
Double Hashing Double hashing is a collision resolution technique used in hash tables. It works by using two hash functions to compute two different hash values for a given key. The first hash function is used to compute the initial hash value, and the second hash function is used to compute the step size for the
15+ min read
Load Factor and Rehashing Prerequisites: Hashing Introduction and Collision handling by separate chaining How hashing works: For insertion of a key(K) - value(V) pair into a hash map, 2 steps are required: K is converted into a small integer (called its hash code) using a hash function.The hash code is used to find an index
15+ min read
Easy problems on Hashing
Check if an array is subset of another arrayGiven two arrays a[] and b[] of size m and n respectively, the task is to determine whether b[] is a subset of a[]. Both arrays are not sorted, and elements are distinct.Examples: Input: a[] = [11, 1, 13, 21, 3, 7], b[] = [11, 3, 7, 1] Output: trueInput: a[]= [1, 2, 3, 4, 5, 6], b = [1, 2, 4] Output
13 min read
Union and Intersection of two Linked List using HashingGiven two singly Linked Lists, create union and intersection lists that contain the union and intersection of the elements present in the given lists. Each of the two linked lists contains distinct node values.Note: The order of elements in output lists doesn’t matter. Examples:Input:head1 : 10 -
10 min read
Two Sum - Pair with given SumGiven an array arr[] of n integers and a target value, the task is to find whether there is a pair of elements in the array whose sum is equal to target. This problem is a variation of 2Sum problem.Examples: Input: arr[] = [0, -1, 2, -3, 1], target = -2Output: trueExplanation: There is a pair (1, -3
15+ min read
Max Distance Between Two OccurrencesGiven an array arr[], the task is to find the maximum distance between two occurrences of any element. If no element occurs twice, return 0.Examples: Input: arr = [1, 1, 2, 2, 2, 1]Output: 5Explanation: distance for 1 is: 5-0 = 5, distance for 2 is: 4-2 = 2, So max distance is 5.Input : arr[] = [3,
8 min read
Most frequent element in an arrayGiven an array, the task is to find the most frequent element in it. If there are multiple elements that appear a maximum number of times, return the maximum element.Examples: Input : arr[] = [1, 3, 2, 1, 4, 1]Output : 1Explanation: 1 appears three times in array which is maximum frequency.Input : a
10 min read
Only Repeating From 1 To n-1Given an array arr[] of size n filled with numbers from 1 to n-1 in random order. The array has only one repetitive element. The task is to find the repetitive element.Examples:Input: arr[] = [1, 3, 2, 3, 4]Output: 3Explanation: The number 3 is the only repeating element.Input: arr[] = [1, 5, 1, 2,
15+ min read
Check for Disjoint Arrays or SetsGiven two arrays a and b, check if they are disjoint, i.e., there is no element common between both the arrays.Examples: Input: a[] = {12, 34, 11, 9, 3}, b[] = {2, 1, 3, 5} Output: FalseExplanation: 3 is common in both the arrays.Input: a[] = {12, 34, 11, 9, 3}, b[] = {7, 2, 1, 5} Output: True Expla
11 min read
Non-overlapping sum of two setsGiven two arrays A[] and B[] of size n. It is given that both array individually contains distinct elements. We need to find the sum of all elements that are not common.Examples: Input : A[] = {1, 5, 3, 8} B[] = {5, 4, 6, 7}Output : 291 + 3 + 4 + 6 + 7 + 8 = 29Input : A[] = {1, 5, 3, 8} B[] = {5, 1,
9 min read
Check if two arrays are equal or notGiven two arrays, a and b of equal length. The task is to determine if the given arrays are equal or not. Two arrays are considered equal if:Both arrays contain the same set of elements.The arrangements (or permutations) of elements may be different.If there are repeated elements, the counts of each
6 min read
Find missing elements of a rangeGiven an array, arr[0..n-1] of distinct elements and a range [low, high], find all numbers that are in a range, but not the array. The missing elements should be printed in sorted order.Examples: Input: arr[] = {10, 12, 11, 15}, low = 10, high = 15Output: 13, 14Input: arr[] = {1, 14, 11, 51, 15}, lo
15+ min read
Minimum Subsets with Distinct ElementsYou are given an array of n-element. You have to make subsets from the array such that no subset contain duplicate elements. Find out minimum number of subset possible.Examples : Input : arr[] = {1, 2, 3, 4}Output :1Explanation : A single subset can contains all values and all values are distinct.In
9 min read
Remove minimum elements such that no common elements exist in two arraysGiven two arrays arr1[] and arr2[] consisting of n and m elements respectively. The task is to find the minimum number of elements to remove from each array such that intersection of both arrays becomes empty and both arrays become mutually exclusive.Examples: Input: arr[] = { 1, 2, 3, 4}, arr2[] =
8 min read
2 Sum - Count pairs with given sumGiven an array arr[] of n integers and a target value, the task is to find the number of pairs of integers in the array whose sum is equal to target.Examples: Input: arr[] = {1, 5, 7, -1, 5}, target = 6Output: 3Explanation: Pairs with sum 6 are (1, 5), (7, -1) & (1, 5). Input: arr[] = {1, 1, 1,
9 min read
Count quadruples from four sorted arrays whose sum is equal to a given value xGiven four sorted arrays each of size n of distinct elements. Given a value x. The problem is to count all quadruples(group of four numbers) from all the four arrays whose sum is equal to x.Note: The quadruple has an element from each of the four arrays. Examples: Input : arr1 = {1, 4, 5, 6}, arr2 =
15+ min read
Sort elements by frequency | Set 4 (Efficient approach using hash)Print the elements of an array in the decreasing frequency if 2 numbers have the same frequency then print the one which came first. Examples: Input : arr[] = {2, 5, 2, 8, 5, 6, 8, 8} Output : arr[] = {8, 8, 8, 2, 2, 5, 5, 6} Input : arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8} Output : arr[] = {8,
12 min read
Find all pairs (a, b) in an array such that a % b = kGiven an array with distinct elements, the task is to find the pairs in the array such that a % b = k, where k is a given integer. You may assume that a and b are in small range Examples : Input : arr[] = {2, 3, 5, 4, 7} k = 3Output : (7, 4), (3, 4), (3, 5), (3, 7)7 % 4 = 33 % 4 = 33 % 5 = 33 % 7 =
15 min read
Group words with same set of charactersGiven a list of words with lower cases. Implement a function to find all Words that have the same unique character set. Example: Input: words[] = { "may", "student", "students", "dog", "studentssess", "god", "cat", "act", "tab", "bat", "flow", "wolf", "lambs", "amy", "yam", "balms", "looped", "poodl
8 min read
k-th distinct (or non-repeating) element among unique elements in an array.Given an integer array arr[], print kth distinct element in this array. The given array may contain duplicates and the output should print the k-th element among all unique elements. If k is more than the number of distinct elements, print -1.Examples:Input: arr[] = {1, 2, 1, 3, 4, 2}, k = 2Output:
7 min read
Intermediate problems on Hashing
Find Itinerary from a given list of ticketsGiven a list of tickets, find the itinerary in order using the given list.Note: It may be assumed that the input list of tickets is not cyclic and there is one ticket from every city except the final destination.Examples:Input: "Chennai" -> "Bangalore" "Bombay" -> "Delhi" "Goa" -> "Chennai"
11 min read
Find number of Employees Under every ManagerGiven a 2d matrix of strings arr[][] of order n * 2, where each array arr[i] contains two strings, where the first string arr[i][0] is the employee and arr[i][1] is his manager. The task is to find the count of the number of employees under each manager in the hierarchy and not just their direct rep
9 min read
Longest Subarray With Sum Divisible By KGiven an arr[] containing n integers and a positive integer k, he problem is to find the longest subarray's length with the sum of the elements divisible by k.Examples:Input: arr[] = [2, 7, 6, 1, 4, 5], k = 3Output: 4Explanation: The subarray [7, 6, 1, 4] has sum = 18, which is divisible by 3.Input:
10 min read
Longest Subarray with 0 Sum Given an array arr[] of size n, the task is to find the length of the longest subarray with sum equal to 0.Examples:Input: arr[] = {15, -2, 2, -8, 1, 7, 10, 23}Output: 5Explanation: The longest subarray with sum equals to 0 is {-2, 2, -8, 1, 7}Input: arr[] = {1, 2, 3}Output: 0Explanation: There is n
10 min read
Longest Increasing consecutive subsequenceGiven N elements, write a program that prints the length of the longest increasing consecutive subsequence. Examples: Input : a[] = {3, 10, 3, 11, 4, 5, 6, 7, 8, 12} Output : 6 Explanation: 3, 4, 5, 6, 7, 8 is the longest increasing subsequence whose adjacent element differs by one. Input : a[] = {6
10 min read
Count Distinct Elements In Every Window of Size KGiven an array arr[] of size n and an integer k, return the count of distinct numbers in all windows of size k. Examples: Input: arr[] = [1, 2, 1, 3, 4, 2, 3], k = 4Output: [3, 4, 4, 3]Explanation: First window is [1, 2, 1, 3], count of distinct numbers is 3. Second window is [2, 1, 3, 4] count of d
10 min read
Design a data structure that supports insert, delete, search and getRandom in constant timeDesign a data structure that supports the following operations in O(1) time.insert(x): Inserts an item x to the data structure if not already present.remove(x): Removes item x from the data structure if present. search(x): Searches an item x in the data structure.getRandom(): Returns a random elemen
5 min read
Subarray with Given Sum - Handles Negative NumbersGiven an unsorted array of integers, find a subarray that adds to a given number. If there is more than one subarray with the sum of the given number, print any of them.Examples: Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33Output: Sum found between indexes 2 and 4Explanation: Sum of elements betwee
13 min read
Implementing our Own Hash Table with Separate Chaining in JavaAll data structure has their own special characteristics, for example, a BST is used when quick searching of an element (in log(n)) is required. A heap or a priority queue is used when the minimum or maximum element needs to be fetched in constant time. Similarly, a hash table is used to fetch, add
10 min read
Implementing own Hash Table with Open Addressing Linear ProbingIn Open Addressing, all elements are stored in the hash table itself. So at any point, size of table must be greater than or equal to total number of keys (Note that we can increase table size by copying old data if needed).Insert(k) - Keep probing until an empty slot is found. Once an empty slot is
13 min read
Maximum possible difference of two subsets of an arrayGiven an array of n-integers. The array may contain repetitive elements but the highest frequency of any element must not exceed two. You have to make two subsets such that the difference of the sum of their elements is maximum and both of them jointly contain all elements of the given array along w
15+ min read
Sorting using trivial hash functionWe have read about various sorting algorithms such as heap sort, bubble sort, merge sort and others. Here we will see how can we sort N elements using a hash array. But this algorithm has a limitation. We can sort only those N elements, where the value of elements is not large (typically not above 1
15+ min read
Smallest subarray with k distinct numbersWe are given an array consisting of n integers and an integer k. We need to find the smallest subarray [l, r] (both l and r are inclusive) such that there are exactly k different numbers. If no such subarray exists, print -1 and If multiple subarrays meet the criteria, return the one with the smalle
14 min read