Related Articles

# Construct MEX array from the given array

• Difficulty Level : Medium
• Last Updated : 26 May, 2021

Given an array arr[] having N distinct positive elements, the task is to generate another array B[] such that, for every ith index in the array, arr[], B[i] is the minimum positive number missing from arr[] excluding arr[i].

Examples:

Input: arr[] = {2, 1, 5, 3}
Output: B[] = {2, 1, 4, 3}
Explanation: After excluding the arr, the array is {1, 5, 3}, and the minimum positive number which is not present in this array is 2. Therefore, B = 2. Similarly, after excluding arr, arr, arr, the minimum positive numbers which are not present in the array are 1, 4 and 3, respectively. Hence, B = 1, B = 4, B = 3.

Input: arr[] = {1, 9, 2, 4}
Output: B[] = {1, 3, 2, 3}

Naive Approach: The simplest approach to solve this problem is to traverse the array arr[] and for every index i, initialize an array hash[] and for every index j ( where j i), update hash[arr[j]] =1. Now traverse array hash[] from index 1 and find the minimum index k for which hash[k] = 0 and update B[i] = k. Finally, print the array B[] after completing the above step.

Time Complexity: O(N2) where N is the length of the given array.
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, the idea is to calculate MEX of the array arr[] and traverse the array arr[]. If arr[i] is less than MEX of the array arr[] then MEX excluding this element will be arr[i] itself, and if arr[i] is greater than MEX of array A[] then MEX of the array will not change after excluding this element.

Follow the steps below to solve the problem:

1. Initialize an array, say hash[], to store whether the value i is present in the array arr[] or not. If i is present hash[i] = 1 else hash[i] = 0.
2. Initialize a variable MexOfArr to store MEX of array arr[] and traverse array hash[] from 1 to find the minimum index j for which hash[j] = 0, which implies that the value j is not present in the array arr[] and store MexOfArr = j.
3. Now traverse the array, arr[] and if arr[i] is less than MexOfArr, then store B[i] = arr[i] else B[i] = MexOfArr.
4. After completing the above steps, print elements of the array B[] as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `#define MAXN 100001` `// Function to construct array B[] that``// stores MEX of array A[] excluding A[i]``void` `constructMEX(``int` `arr[], ``int` `N)``{``    ``// Stores elements present in arr[]``    ``int` `hash[MAXN] = { 0 };` `    ``// Mark all values 1, if present``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``hash[arr[i]] = 1;``    ``}` `    ``// Initialize variable to store MEX``    ``int` `MexOfArr;` `    ``// Find MEX of arr[]``    ``for` `(``int` `i = 1; i < MAXN; i++) {``        ``if` `(hash[i] == 0) {``            ``MexOfArr = i;``            ``break``;``        ``}``    ``}` `    ``// Stores MEX for all indices``    ``int` `B[N];` `    ``// Traverse the given array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update MEX``        ``if` `(arr[i] < MexOfArr)``            ``B[i] = arr[i];` `        ``// MEX default``        ``else``            ``B[i] = MexOfArr;``    ``}` `    ``// Print the array B``    ``for` `(``int` `i = 0; i < N; i++)``        ``cout << B[i] << ``' '``;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 1, 5, 3 };` `    ``// Given size``    ``int` `N = ``sizeof``(arr)``            ``/ ``sizeof``(arr);` `    ``// Function call``    ``constructMEX(arr, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{``    ` `static` `int` `MAXN = ``100001``;``  ` `// Function to construct array``// B[] that stores MEX of array``// A[] excluding A[i]``static` `void` `constructMEX(``int` `arr[],``                         ``int` `N)``{``  ``// Stores elements present``  ``// in arr[]``  ``int` `hash[] = ``new` `int``[MAXN];``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``hash[i] = ``0``;``  ``}` `  ``// Mark all values 1, if``  ``// present``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``hash[arr[i]] = ``1``;``  ``}` `  ``// Initialize variable to``  ``// store MEX``  ``int` `MexOfArr = ``0` `;` `  ``// Find MEX of arr[]``  ``for` `(``int` `i = ``1``; i < MAXN; i++)``  ``{``    ``if` `(hash[i] == ``0``)``    ``{``      ``MexOfArr = i;``      ``break``;``    ``}``  ``}` `  ``// Stores MEX for all``  ``// indices``  ``int` `B[] = ``new` `int``[N];` `  ``// Traverse the given array``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``// Update MEX``    ``if` `(arr[i] < MexOfArr)``      ``B[i] = arr[i];` `    ``// MEX default``    ``else``      ``B[i] = MexOfArr;``  ``}` `  ``// Print the array B``  ``for` `(``int` `i = ``0``; i < N; i++)``    ``System.out.print(B[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given array arr[]``  ``int` `arr[] = {``2``, ``1``, ``5``, ``3``};` `  ``// Size of array``  ``int` `N = arr.length;` `  ``// Function call``  ``constructMEX(arr, N);``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the``# above approach` `MAXN ``=` `100001` `# Function to construct``# array B[] that stores``# MEX of array A[] excluding``# A[i]``def` `constructMEX(arr, N):``  ` `    ``# Stores elements present``    ``# in arr[]``    ``hash` `=` `[``0``] ``*` `MAXN` `    ``# Mark all values 1,``    ``# if present``    ``for` `i ``in` `range``(N):``        ``hash``[arr[i]] ``=` `1` `    ``# Initialize variable to``    ``# store MEX``    ``MexOfArr ``=` `0` `    ``# Find MEX of arr[]``    ``for` `i ``in` `range``(``1``, MAXN):``        ``if` `(``hash``[i] ``=``=` `0``):``            ``MexOfArr ``=` `i``            ``break` `    ``# Stores MEX for all``    ``# indices``    ``B ``=` `[``0``] ``*` `N` `    ``# Traverse the given array``    ``for` `i ``in` `range``(N):` `        ``# Update MEX``        ``if` `(arr[i] < MexOfArr):``            ``B[i] ``=` `arr[i]` `        ``# MEX default``        ``else``:``            ``B[i] ``=` `MexOfArr` `    ``# Prthe array B``    ``for` `i ``in` `range``(N):``        ``print``(B[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``arr ``=` `[``2``, ``1``, ``5``, ``3``]` `    ``# Given size``    ``N ``=` `len``(arr)` `    ``# Function call``    ``constructMEX(arr, N)` `# This code is contributed by Mohit Kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `static` `int` `MAXN = 100001;``  ` `// Function to construct array``// B[] that stores MEX of array``// A[] excluding A[i]``static` `void` `constructMEX(``int``[] arr,``                         ``int` `N)``{``  ` `  ``// Stores elements present``  ``// in arr[]``  ``int``[] hash = ``new` `int``[MAXN];``  ``for``(``int` `i = 0; i < N; i++)``  ``{``    ``hash[i] = 0;``  ``}` `  ``// Mark all values 1, if``  ``// present``  ``for``(``int` `i = 0; i < N; i++)``  ``{``    ``hash[arr[i]] = 1;``  ``}` `  ``// Initialize variable to``  ``// store MEX``  ``int` `MexOfArr = 0;` `  ``// Find MEX of arr[]``  ``for``(``int` `i = 1; i < MAXN; i++)``  ``{``    ``if` `(hash[i] == 0)``    ``{``      ``MexOfArr = i;``      ``break``;``    ``}``  ``}``  ` `  ``// Stores MEX for all``  ``// indices``  ``int``[] B = ``new` `int``[N];` `  ``// Traverse the given array``  ``for``(``int` `i = 0; i < N; i++)``  ``{``    ` `    ``// Update MEX``    ``if` `(arr[i] < MexOfArr)``      ``B[i] = arr[i];` `    ``// MEX default``    ``else``      ``B[i] = MexOfArr;``  ``}` `  ``// Print the array B``  ``for``(``int` `i = 0; i < N; i++)``    ``Console.Write(B[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `Main()``{``  ` `  ``// Given array arr[]``  ``int``[] arr = { 2, 1, 5, 3 };``  ` `  ``// Size of array``  ``int` `N = arr.Length;``  ` `  ``// Function call``  ``constructMEX(arr, N);``}``}` `// This code is contributed by code_hunt`

## Javascript

 ``
Output:
`2 1 4 3`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up