Replace empty spaces with numbers [1, 9] such that other Array is not a Subsequence

• Last Updated : 09 May, 2022

Given two arrays, arr1[] of length N1 and arr2[] of length N2, consisting of numbers from 1 to 9 and arr1[] has some missing entries denoted by 0, the task is to replace the missing entries of arr1[] with elements in range [1, 9] such that arr2[] is not a subsequence of the new array arr1[].

Examples:

Input: arr1[] = {2, 1, 0, 3}, N1 = 4, arr2[] = {1, 2}, N2 = 2
Output: {2, 1, 1, 3}
Explanation: Here arr1[2] = 0. So replace arr1[2] with 1.
So arr2[] is not a subsequence of the newly formed arr1[].

Input: arr1[] = {2, 2, 0, 3, 0, 4}, N1 = 6, arr2 = {2, 3}, N2 = 2
Output: IMPOSSIBLE
Explanation: It is not possible to form such an array that does not have
arr2[] as a subsequence. because arr1[] already has arr2[] as a subsequence.

Approach: The approach to the problem is based on the two possibilities given below:

1. arr2 is already a subsequence of arr1 (when not considering the missing elements).
2. arr2 is not already a subsequence of arr1 (when not considering the missing elements).

If arr2[] is not already a subsequence, try to fill all the empty elements of arr1[] with each of the entry from [1, 9] and check if the formed array has all the elements of arr2[] in order to check for arr2[] being a subsequence of the arr1[].

Follow the steps mentioned below to implement the idea.

• Iterate through all the possible elements in [1, 9], and store this in i.
• Construct an empty array, of size N1.
• Initialize a variable (say index = 0) to track how many elements of arr2 have appeared so far in the resultant array.
• Iterate through all elements of arr1[]
• If a missing element is encountered, place i at the corresponding index of the resultant array.
• Otherwise, just place the same element as in arr1[]
• If this element is equal to arr2[index] (i.e. the first element from arr2 that has not appeared in the resultant array), increment index by 1.
• After iterating through the elements of arr1, if index is not equal to N2, that means all elements of arr2 did not appear in resultant array.
• Return it as the final array.

Below is the implementation of the above approach:

C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// function to form the resultant array` `vector<``int``> formArr(vector<``int``>& arr1, ``int` `N1,` `                    ``vector<``int``>& arr2, ``int` `N2)` `{` `    ``// Iterating through all the possible` `    ``// values` `    ``for` `(``int` `i = 1; i < 10; i++) {` `        ``// Tracks how many elements of arr2` `        ``// have appeared so far` `        ``// in resultant array, arr3[]` `        ``int` `index = 0;`   `        ``// Initializing resultant array` `        ``vector<``int``> arr3(N1, INT_MAX);`   `        ``// Iterating through elements of arr1` `        ``for` `(``int` `j = 0; j < N1; j++) {`   `            ``// If element is not missing,` `            ``// just copy it to arr3` `            ``if` `(arr1[j])` `                ``arr3[j] = arr1[j];`   `            ``// Else, copy i to arr3` `            ``else` `                ``arr3[j] = i;`   `            ``// If arr2[index] == arr3[j], then` `            ``// another element of arr2 has` `            ``// appeared in the final array,` `            ``// and increase index counter by 1` `            ``if` `(N2 > index && arr2[index] == arr3[j])` `                ``index += 1;` `        ``}`   `        ``// If index != N2, then that means` `        ``// all elements of A2 did not appear` `        ``// in Arr. Therefore, it is NOT a` `        ``// subsequence` `        ``if` `(index != N2)` `            ``return` `arr3;` `    ``}`   `    ``return` `{};` `}`   `// Driver Code` `int` `main()` `{` `    ``vector<``int``> arr1 = { 2, 1, 0, 3 };` `    ``int` `N1 = 4;` `    ``vector<``int``> arr2 = { 1, 2 };` `    ``int` `N2 = 2;`   `    ``// Function Call` `    ``vector<``int``> ans = formArr(arr1, N1, arr2, N2);` `    ``if` `(ans.size() > 0) {` `        ``for` `(``int` `i : ans) {` `            ``cout << i << ``" "``;` `        ``}` `    ``}` `    ``else` `{`   `        ``cout << ``"IMPOSSIBLE"``;` `    ``}` `    ``return` `0;` `}`   `// This code is contributed by Rohit Pradhan`

Python3

 `# Python3 code to implement the approach`   `# function to form the resultant array` `def` `formArr(arr1, N1, arr2, N2):` `    ``# Iterating through all the possible ` `    ``# values` `    ``for` `i ``in` `range``(``1``, ``10``):` `        ``# Tracks how many elements of arr2` `        ``# have appeared so far ` `        ``# in resultant array, arr3[]` `        ``index ``=` `0` `        `  `        ``# Initializing resultant array` `        ``arr3 ``=` `[``None``] ``*` `N1` `        `  `        ``# Iterating through elements of arr1` `        ``for` `j ``in` `range``(N1):` `            `  `            ``# If element is not missing, ` `            ``# just copy it to arr3` `            ``if` `arr1[j]:` `                ``arr3[j] ``=` `arr1[j]` `            `  `            ``# Else, copy i to arr3` `            ``else``:` `                ``arr3[j] ``=` `i` `                `  `            ``# If arr2[index] == arr3[j], then` `            ``# another element of arr2 has ` `            ``# appeared in the final array,` `            ``# and increase index counter by 1` `            ``if` `N2 > index ``and` `arr2[index] ``=``=` `arr3[j]:` `                ``index ``+``=` `1` `        `  `        ``# If index != N2, then that means` `        ``# all elements of A2 did not appear ` `        ``# in Arr. Therefore, it is NOT a ` `        ``# subsequence` `        ``if` `index !``=` `N2:` `            ``return` `arr3` `    ``return` `[]`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr1 ``=` `[``2``, ``1``, ``0``, ``3``]` `    ``N1 ``=` `4` `    ``arr2 ``=` `[``1``, ``2``]` `    ``N2 ``=` `2` `    `  `    ``# Function Call` `    ``ans ``=` `formArr(arr1, N1, arr2, N2)` `    ``if` `ans:` `        ``print``(ans)` `    ``else``:` `        ``print``(``"IMPOSSIBLE"``)`

C#

 `// C# code to implement the approach` `using` `System;`   `class` `GFG` `{`   `  ``// function to form the resultant array` `  ``static` `int``[] formArr(``int``[] arr1, ``int` `N1, ``int``[] arr2,` `                       ``int` `N2)` `  ``{`   `    ``// Iterating through all the possible` `    ``// values` `    ``for` `(``int` `i = 1; i < 10; i++) {` `      ``// Tracks how many elements of arr2` `      ``// have appeared so far` `      ``// in resultant array, arr3[]` `      ``int` `index = 0;`   `      ``// Initializing resultant array` `      ``int``[] arr3 = ``new` `int``[N1];` `      ``for` `(``int` `x = 0; x < N1; x++) {` `        ``arr3[x] = Int32.MaxValue;` `      ``}`   `      ``// Iterating through elements of arr1` `      ``for` `(``int` `j = 0; j < N1; j++) {`   `        ``// If element is not missing,` `        ``// just copy it to arr3` `        ``if` `(arr1[j] != 0)` `          ``arr3[j] = arr1[j];`   `        ``// Else, copy i to arr3` `        ``else` `          ``arr3[j] = i;`   `        ``// If arr2[index] == arr3[j], then` `        ``// another element of arr2 has` `        ``// appeared in the final array,` `        ``// and increase index counter by 1` `        ``if` `(N2 > index && arr2[index] == arr3[j])` `          ``index += 1;` `      ``}`   `      ``// If index != N2, then that means` `      ``// all elements of A2 did not appear` `      ``// in Arr. Therefore, it is NOT a` `      ``// subsequence` `      ``if` `(index != N2)` `        ``return` `arr3;` `    ``}` `    ``int``[] empty = {};` `    ``return` `empty;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr1 = { 2, 1, 0, 3 };` `    ``int` `N1 = 4;` `    ``int``[] arr2 = { 1, 2 };` `    ``int` `N2 = 2;`   `    ``// Function Call` `    ``int``[] ans = formArr(arr1, N1, arr2, N2);` `    ``if` `(ans.Length > 0) {` `      ``for` `(``int` `i = 0; i < ans.Length; i++) {` `        ``Console.Write(ans[i] + ``" "``);` `      ``}` `    ``}` `    ``else` `{`   `      ``Console.Write(``"IMPOSSIBLE"``);` `    ``}` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

Javascript

 ``

Java

 `// Java code for above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `// function to form the resultant array` `public` `static` `int``[] formArr(``int``[] arr1, ``int` `N1, ``int``[] arr2,` `                    ``int` `N2)` `{`   `    ``// Iterating through all the possible` `    ``// values` `    ``for` `(``int` `i = ``1``; i < ``10``; i++) {` `    ``// Tracks how many elements of arr2` `    ``// have appeared so far` `    ``// in resultant array, arr3[]` `    ``int` `index = ``0``;`   `    ``// Initializing resultant array` `    ``int``[] arr3 = ``new` `int``[N1];` `    ``for` `(``int` `x = ``0``; x < N1; x++) {` `        ``arr3[x] = Integer.MAX_VALUE;` `    ``}`   `    ``// Iterating through elements of arr1` `    ``for` `(``int` `j = ``0``; j < N1; j++) {`   `        ``// If element is not missing,` `        ``// just copy it to arr3` `        ``if` `(arr1[j] != ``0``)` `        ``arr3[j] = arr1[j];`   `        ``// Else, copy i to arr3` `        ``else` `        ``arr3[j] = i;`   `        ``// If arr2[index] == arr3[j], then` `        ``// another element of arr2 has` `        ``// appeared in the final array,` `        ``// and increase index counter by 1` `        ``if` `(N2 > index && arr2[index] == arr3[j])` `        ``index += ``1``;` `    ``}`   `    ``// If index != N2, then that means` `    ``// all elements of A2 did not appear` `    ``// in Arr. Therefore, it is NOT a` `    ``// subsequence` `    ``if` `(index != N2)` `        ``return` `arr3;` `    ``}` `    ``int``[] empty = {};` `    ``return` `empty;` `}`     `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `     ``int``[] arr1 = { ``2``, ``1``, ``0``, ``3` `};` `    ``int` `N1 = ``4``;` `    ``int``[] arr2 = { ``1``, ``2` `};` `    ``int` `N2 = ``2``;`   `    ``// Function Call` `    ``int``[] ans = formArr(arr1, N1, arr2, N2);` `    ``if` `(ans.length > ``0``) {` `    ``for` `(``int` `i = ``0``; i < ans.length; i++) {` `        ``System.out.print(ans[i] + ``" "``);` `    ``}` `    ``}` `    ``else` `{`   `    ``System.out.print(``"IMPOSSIBLE"``);` `    ``}` `  ``}` `}`

Output

`[2, 1, 1, 3]`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :