# Maximize MEX by adding or subtracting K from Array elements

• Difficulty Level : Easy
• Last Updated : 14 Sep, 2022

Given an arr[] of size N and an integer, K, the task is to find the maximum possible value of MEX by adding or subtracting K any number of times from the array elements.

MEX is the minimum non-negative integer that is not present in the array

Examples:

Input: arr[]={1, 3, 4}, K = 2
Output: 2
Explanation: After subtracting K from arr twice,
the final array will be {1, 3, 0}.
So the MEX is 2 which is maximum possible answer.

Input: arr[] = {0, 1, 2, 1, 3}, K = 3
Output: 5
Explanation: After adding K to arr, the final array will be {0, 4, 2, 1, 3}.
So the MEX is 5 which is maximum possible answer.

Approach: Follow the below idea to solve the problem:

The maximum MEX which can be achieved from an array of size N is N. For this, we need to have all the elements from 0 to N – 1 by doing some operations.  If there is a number that is not achievable by doing some operation then this is the answer.

We can generate a number x from a number p by doing addition or subtraction if both remainders are same by diving it with K [i.e., the difference between them is divisible by K].

Follow the steps to solve the problem:

• Create a map that stores the frequency of the remainders of all the elements of the array.
• Traverse from 0 to N-1 and check if there is a need to generate the number x then x % K must be present in the map.
• If it is present in the map then decrease the frequency of x % K and continue.
• Else, return the number as the answer.

Below is the implementation for the above approach:

## C++

 `// C++ code for the above approach` `#include ``using` `namespace` `std;` `// Function to find maximum MEX of the array``// after doing some addition and subtraction``int` `mex(``int` `arr[], ``int` `n, ``int` `K)``{``    ``// Create a map to store the frequency of``    ``// remainder of all element by K``    ``unordered_map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``mp[arr[i] % K]++;``    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// In order to generate i find an``        ``// element whose modulo value is equal``        ``// to i%K, return i as answer if no``        ``// such value is found``        ``if` `(mp.find(i % K) == mp.end()) {``            ``return` `i;``        ``}` `        ``// If we find element whose modulo``        ``// value equal to i%K``        ``mp[i % K]--;``        ``if` `(mp[i % K] == 0)``            ``mp.erase(i % K);``    ``}` `    ``return` `n;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 0, 1, 2, 1, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = 3;` `    ``// Function call``    ``cout << mex(arr, N, K) << endl;``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``import` `java.util.*;``import` `java.util.HashMap;` `class` `GFG {` `  ``// Function to find maximum MEX of the array``  ``// after doing some addition and subtraction``  ``public` `static` `int` `mex(``int``[] arr, ``int` `n, ``int` `K)``  ``{``    ` `    ``// Create a map to store the frequency of``    ``// remainder of all element by K``    ``HashMap mp``      ``= ``new` `HashMap();` `    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``mp.put(i, ``0``);``    ``}``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``mp.put(mp.get(arr[i] % K),``             ``mp.get(arr[i] % K) + ``1``);``    ``}` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``// In order to generate i find an``      ``// element whose modulo value is equal``      ``// to i%K, return i as answer if no``      ``// such value is found``      ``if` `(mp.get(i%K) > ``1` `){``        ``return` `i;``      ``}` `      ``// If we find element whose modulo``      ``// value equal to i%K``      ``mp.put(mp.get(arr[i] % K),``             ``mp.get(arr[i] % K) - ``1``);``      ``if` `(mp.get(i % K) <= ``0``)``        ``mp.put(mp.get(arr[i] % K),``               ``0``);``    ``}``    ``return` `n;``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``0``, ``1``, ``2``, ``1``, ``3` `};``    ``int` `N = arr.length;``    ``int` `K = ``3``;` `    ``// Function call``    ``System.out.println(mex(arr, N, K));``  ``}``}` `// This code is contributed by akashish__`

## Python3

 `# Python code to implement the approach``from` `collections ``import` `defaultdict` `# Function to find maximum MEX of the array``# after doing some addition and subtraction``def` `mex(arr, n, K) :``    ` `    ``# Create a map to store the frequency of``    ``# remainder of all element by K``    ``mp ``=` `defaultdict(``lambda` `: ``0``)`` ` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):`` ` `        ``# Update frequency of arr[i]``        ``mp[arr[i] ``%` `K] ``+``=` `1``;``    ` `    ``for` `i ``in` `range``(n):` `        ``# In order to generate i find an``        ``# element whose modulo value is equal``        ``# to i%K, return i as answer if no``        ``# such value is found``        ``if` `((i ``%` `K) ``not` `in` `mp) :``            ``return` `i``        ` `        ``# If we find element whose modulo``        ``# value equal to i%K``        ``mp[i ``%` `K] ``-``=` `1``        ``if` `(mp[i ``%` `K] ``=``=` `0``) :``            ``del` `mp[i ``%` `K]``    ` `    ``return` `n` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``arr ``=` `[ ``0``, ``1``, ``2``, ``1``, ``3` `]``    ``N ``=` `len``(arr)``    ``K ``=` `3` `    ``# Function call``    ``print``(mex(arr, N, K))` `# This code is contributed by sanjoy_62.`

## C#

 `/*package whatever //do not write package name here */``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``// Function to find maximum MEX of the array``  ``// after doing some addition and subtraction``  ``public` `static` `int` `mex(``int``[] arr, ``int` `n, ``int` `K)``  ``{``    ` `    ``// Create a map to store the frequency of``    ``// remainder of all element by K``    ``Dictionary<``int``, ``int``> mp``      ``= ``new` `Dictionary<``int``, ``int``>();` `    ``for` `(``int` `i = 0; i < n; i++) {``      ``mp.Add(i, 0);``    ``}``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if``(mp.ContainsKey(arr[i] % K))``              ``mp[mp[arr[i] % K]]=``             ``mp[arr[i] % K] + 1;``        ``else``            ``mp.Add(mp[arr[i] % K],``               ``1);``    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``// In order to generate i find an``      ``// element whose modulo value is equal``      ``// to i%K, return i as answer if no``      ``// such value is found``      ``if` `(mp[i%K] > 1 ){``        ``return` `i;``      ``}` `      ``// If we find element whose modulo``      ``// value equal to i%K``    ``if``(mp.ContainsKey(arr[i] % K))``      ``mp[mp[arr[i] % K]]=``             ``mp[arr[i] % K] - 1;``      ``if` `(mp.ContainsKey(i % K) && mp[i % K] <= 0)``        ``mp[mp[arr[i] % K]]=``               ``0;``    ``}``    ``return` `n;``  ``}` `  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int` `[]arr = { 0, 1, 2, 1, 3 };``    ``int` `N = arr.Length;``    ``int` `K = 3;` `    ``// Function call``    ``Console.WriteLine(mex(arr, N, K));``  ``}``}`  `// This code contributed by shikhasingrajput`

## Javascript

 `  ```

Output

`5`

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

My Personal Notes arrow_drop_up