# Maximum array from two given arrays keeping order same

Given two same sized arrays A[] and B[] (both arrays contain distinct elements individually but may have some common elements), task is to form a third (or result) array of same size. The result array should have maximum n elements from both array. It should have chosen elements of A[] first, then chosen elements of B[] in same order as they appear in original arrays. If there are common elements, then only one element should be present in res[] and priority should be given to A[].

Examples:

Input : A[] = [ 9 7 2 3 6 ] B[] = [ 7 4 8 0 1 ] Output : res[] = [9 7 6 4 8] res[] has maximum n elements of both A[] and B[] such that elements of A[] appear first (in same order), then elements of B[]. Also 7 is common and priority is given to A's 7. Input : A[] = [ 6 7 5 3 ] B[] = [ 5 6 2 9 ] Output : res[] = [ 6 7 5 9 ]

1) Create copies of both arrays and sort the copies in decreasing order.

2) Use a hash to pick unique n maximum elements of both arrays, giving priority to A[].

3) Initialize result array as empty.

4) Traverse through A[], copy those elements of A[] that are present in the hash. This is done to keep order of elements same.

5) Repeat step 4 for B[]. This time we only consider those elements that are not present in A[] (Do not appear twice in hash).

Below c++ implementation of above idea.

`// Make a set of maximum elements from two ` `// arrays A[] and B[] ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `void` `maximizeTheFirstArray(` `int` `A[], ` `int` `B[], ` ` ` `int` `n) ` `{ ` ` ` `// Create copies of A[] and B[] and sort ` ` ` `// the copies in descending order. ` ` ` `vector<` `int` `> temp1(A, A+n); ` ` ` `vector<` `int` `> temp2(B, B+n); ` ` ` `sort(temp1.begin(), temp1.end(), greater<` `int` `>()); ` ` ` `sort(temp2.begin(), temp2.end(), greater<` `int` `>()); ` ` ` ` ` `// Put maximum n distinct elements of ` ` ` `// both sorted arrays in a map. ` ` ` `unordered_map<` `int` `, ` `int` `> m; ` ` ` `int` `i = 0, j = 0; ` ` ` `while` `(m.size() < n) ` ` ` `{ ` ` ` `if` `(temp1[i] >= temp2[j]) ` ` ` `{ ` ` ` `m[temp1[i]]++; ` ` ` `i++; ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `m[temp2[j]]++; ` ` ` `j++; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Copy elements of A[] to that ` ` ` `// are present in hash m. ` ` ` `vector<` `int` `> res; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `if` `(m.find(A[i]) != m.end()) ` ` ` `res.push_back(A[i]); ` ` ` ` ` `// Copy elements of B[] to that ` ` ` `// are present in hash m. This time ` ` ` `// we also check if the element did ` ` ` `// not appear twice. ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `if` `(m.find(B[i]) != m.end() && ` ` ` `m[B[i]] == 1) ` ` ` `res.push_back(B[i]); ` ` ` ` ` `// print result ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `cout << res[i] << ` `" "` `; ` `} ` ` ` `// driver program ` `int` `main() ` `{ ` ` ` `int` `A[] = { 9, 7, 2, 3, 6 }; ` ` ` `int` `B[] = { 7, 4, 8, 0, 1 }; ` ` ` `int` `n = ` `sizeof` `(A) / ` `sizeof` `(A[0]); ` ` ` `maximizeTheFirstArray(A, B, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

9 7 6 4 8

Time complexity: O(n Log n)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Remove duplicates from string keeping the order according to last occurrences
- Maximum sum of increasing order elements from n arrays
- Maximum sum by picking elements from two arrays in order | Set 2
- Maximum sum by picking elements from two arrays in order
- Split the given array into K sub-arrays such that maximum sum of all sub arrays is minimum
- Find k maximum elements of array in original order
- Break an array into maximum number of sub-arrays such that their averages are same
- Divide array in two maximum equal length arrays of similar and dissimilar elements
- Find all unique pairs of maximum and second maximum elements over all sub-arrays in O(NlogN)
- Merging two unsorted arrays in sorted order
- Number of ways to merge two arrays such retaining order
- Maximize distinct elements by incrementing/decrementing an element or keeping it same
- Sort an array where a subarray of a sorted array is in reverse order
- Minimum size Subarray with maximum sum in non-increasing order
- Print elements of an array according to the order defined by another array | set 2
- Maximum OR sum of sub-arrays of two different arrays
- Find maximum topics to prepare in order to pass the exam
- Sort an array according to the order defined by another array
- Performance analysis of Row major and Column major order of storing arrays in C
- Maximum sum combination from two arrays

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.