 GeeksforGeeks App
Open App Browser
Continue

# Find K missing numbers from given Array in range [1, M] such that total average is X

Given an array arr[] of integers of size N where each element can be in the range [1, M], and two integers X and K. The task is to find K possible numbers in range [1, M] such that the average of all the (N + K) numbers is equal to X. If there are multiple valid answers, any one is acceptable.

Examples:

Input: arr[] = {3, 2, 4, 3}, M = 6, K = 2, X = 4
Output: 6 6
Explanation: The mean of all elements is (3 + 2 + 4 + 3 + 6 + 6) / 6 = 4.

Input: arr[] = {1}, M = 8, K = 1, X = 4
Output: 7
Explanation: The mean of all elements is (1 + 7) / 2 = 4.

Input: arr[] = {1, 2, 3, 4}, M = 6, K = 4, X = 6
Output: []
Explanation: It is impossible for the mean to be 6 no matter what the 4 missing elements are.

Approach: The approach is based on the following mathematical observation. If the total expected sum after adding M elements is such that the sum of the M elements added needs to be less than M or greater than K*M then no solution is possible. Otherwise, there is always a possible solution.

1. Find the sum of missing elements(Y), that is = X*(K + N) – sum(arr).
2. If this is less than K or greater than K*M then the array cannot be created. So return an empty array.
3. Otherwise, try to equally divide the value Y in K elements, i.e assign all the K elements with value Y/K.
4. if still some value remains to be assigned then after assigning every element equally, the value left will be = (Y%K). So add 1 to (Y%K) elements of the new array.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement above approach``#include ``using` `namespace` `std;` `// Function to get the missing elements``vector<``int``> missing(vector<``int``>& arr,``                    ``int` `M, ``int` `X, ``int` `K)``{``    ``int` `N = arr.size(),``        ``sum = accumulate(arr.begin(),``                         ``arr.end(), 0),``        ``newsum = 0;``    ``newsum = X * (K + N) - sum;``    ``// If this newsum is less than M``    ``// or greater than K*M then``    ``// no array can be created.``    ``if` `(newsum < K || newsum > K * M)``        ``return` `{};` `    ``int` `mod = newsum % K;``    ``vector<``int``> ans(K, newsum / K);``    ``for` `(``int` `i = 0; i < mod; i++)``        ``ans[i] += 1;``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``vector<``int``> arr{ 3, 2, 4, 3 };``    ``int` `X = 4;``    ``int` `K = 2;``    ``int` `M = 6;` `    ``// Vector to store resultant list``    ``vector<``int``> ans = missing(arr, M, X, K);` `    ``for` `(``auto` `i : ans)``        ``cout << i << ``" "``;``    ``return` `0;``}`

## Java

 `// Java code to implement above approach``import` `java.util.*;``class` `GFG{` `// Function to get the missing elements``static`  `int` `[]missing(``int` `[]arr,``                    ``int` `M, ``int` `X, ``int` `K)``{``    ``int` `N = arr.length,``        ``sum = accumulate(arr,``0``,N),``        ``newsum = ``0``;``    ``newsum = X * (K + N) - sum;``  ` `    ``// If this newsum is less than M``    ``// or greater than K*M then``    ``// no array can be created.``    ``if` `(newsum < K || newsum > K * M)``        ``return` `new` `int``[]{};` `    ``int` `mod = newsum % K;``    ``int` `[]ans = ``new` `int``[K];``    ``Arrays.fill(ans, newsum / K);``    ``for` `(``int` `i = ``0``; i < mod; i++)``        ``ans[i] += ``1``;``    ``return` `ans;``}``static` `int` `accumulate(``int``[] arr, ``int` `start, ``int` `end){``    ``int` `sum=``0``;``    ``for``(``int` `i= ``0``; i < arr.length; i++)``        ``sum+=arr[i];``    ``return` `sum;``}``  ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int``[]arr = { ``3``, ``2``, ``4``, ``3` `};``    ``int` `X = ``4``;``    ``int` `K = ``2``;``    ``int` `M = ``6``;` `    ``// Vector to store resultant list``    ``int` `[]ans = missing(arr, M, X, K);` `    ``for` `(``int` `i : ans)``        ``System.out.print(i+ ``" "``);``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python code for the above approach` `# Function to get the missing elements``def` `missing(arr, M, X, K):``    ``N ``=` `len``(arr)``    ``sum` `=` `0``    ``for` `i ``in` `range``(``len``(arr)):``        ``sum` `+``=` `arr[i]``    ``newsum ``=` `0``    ``newsum ``=` `X ``*` `(K ``+` `N) ``-` `sum` `    ``# If this newsum is less than M``    ``# or greater than K*M then``    ``# no array can be created.``    ``if` `(newsum < K ``or` `newsum > K ``*` `M):``        ``return` `[]` `    ``mod ``=` `newsum ``%` `K``    ``ans ``=` `[newsum ``/``/` `K] ``*` `K` `    ``for` `i ``in` `range``(mod):``        ``ans[i] ``+``=` `1``    ``return` `ans` `# Driver code``arr ``=` `[``3``, ``2``, ``4``, ``3``]``X ``=` `4``K ``=` `2``M ``=` `6` `# Vector to store resultant list``ans ``=` `missing(arr, M, X, K)` `for` `i ``in` `ans:``    ``print``(i, end``=``" "``)` `# This code is contributed by gfgking`

## C#

 `// C# code to implement above approach``using` `System;` `class` `GFG {` `    ``// Function to get the missing elements``    ``static` `int``[] missing(``int``[] arr, ``int` `M, ``int` `X, ``int` `K)``    ``{``        ``int` `N = arr.Length, sum = accumulate(arr, 0, N),``            ``newsum = 0;``        ``newsum = X * (K + N) - sum;` `        ``// If this newsum is less than M``        ``// or greater than K*M then``        ``// no array can be created.``        ``if` `(newsum < K || newsum > K * M)``            ``return` `new` `int``[] {};` `        ``int` `mod = newsum % K;``        ``int``[] ans = ``new` `int``[K];``        ``Array.Fill(ans, newsum / K);``        ``for` `(``int` `i = 0; i < mod; i++)``            ``ans[i] += 1;``        ``return` `ans;``    ``}``    ``static` `int` `accumulate(``int``[] arr, ``int` `start, ``int` `end)``    ``{``        ``int` `sum = 0;``        ``for` `(``int` `i = 0; i < arr.Length; i++)``            ``sum += arr[i];``        ``return` `sum;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 3, 2, 4, 3 };``        ``int` `X = 4;``        ``int` `K = 2;``        ``int` `M = 6;` `        ``// Vector to store resultant list``        ``int``[] ans = missing(arr, M, X, K);` `        ``foreach``(``int` `i ``in` `ans) Console.Write(i + ``" "``);``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 `  ```

Output

`6 6 `

Time Complexity: O(N)
Auxiliary Space: O(1) When space of the resultant list is not considered

My Personal Notes arrow_drop_up