# Map elements of an array to elements of another array

Given two arrays *A* and *B* of positive integers, elements of array *B* can be mapped to elements of array *A* only if both the elements have same value. The task is to compute the positions in array *A* to which elements of array *B* will be mapped. Print NA if mapping for a particular element cannot be done.

**Note:** For one position only one integer can be mapped.

**Examples:**

Input:A[] = {1, 5, 2, 4, 4, 3}, B[] = {1, 2, 5, 1}

Output:0 2 1 NA

B[0], B[1] and B[2] can be mapped to A[0], A[2] and A[1] respectively but B[3] cannot be mapped to any element of A because the only ‘1’ in A has already been mapped

Input:A[] = {2, 1, 2, 3, 3, 4, 2, 4, 1}, B[] = {1, 2, 5, 1, 2, 4, 2, 3, 2, 1}

Output:1 0 NA 8 2 5 6 3 NA NA

The idea is to use a hash table where keys are elements of A[] and values are indexes of these elements. Since there can be more than one occurrences of an element, we use a list of items as values in the hash table.

Below is the implementation of the above problem:

`// C++ program to map elements of an array ` `// to equal elements of another array ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to print the mapping of elements ` `void` `printMapping(` `int` `A[], ` `int` `B[], ` `int` `N, ` `int` `M) ` `{ ` ` ` ` ` `// Create a hash table where all indexes are ` ` ` `// stored for a given value ` ` ` `unordered_map<` `int` `, list<` `int` `>> m; ` ` ` `for` `(` `int` `i=0; i<N; i++) ` ` ` `m[A[i]].push_back(i); ` ` ` ` ` `// Traverse through B[] ` ` ` `for` `(` `int` `i=0; i<M; i++) ` ` ` `{ ` ` ` `// If a mapping is found, print the mapping and ` ` ` `// remove the index from hash table so that the ` ` ` `// same element of A[] is not mapped again. ` ` ` `if` `(m.find(B[i]) != m.end() && m[B[i]].size() > 0) ` ` ` `{ ` ` ` `cout << m[B[i]].front() << ` `" "` `; ` ` ` `m[B[i]].pop_front(); ` ` ` `} ` ` ` ` ` `else` `// No mapping found ` ` ` `{ ` ` ` `cout << ` `"NA "` `; ` ` ` `} ` ` ` `} ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `A[] = {2, 1, 2, 3, 3, 4, 2, 4, 1}; ` ` ` `int` `N = ` `sizeof` `(A) / ` `sizeof` `(A[0]); ` ` ` `int` `B[] = {1, 2, 5, 1, 2, 4, 2, 3, 2, 1}; ` ` ` `int` `M = ` `sizeof` `(B) / ` `sizeof` `(B[0]); ` ` ` `printMapping(A, B, N, M); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

1 0 NA 8 2 5 6 3 NA NA

## Recommended Posts:

- Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
- Find original array from encrypted array (An array of sums of other elements)
- Average of remaining elements after removing K largest and K smallest elements from array
- Elements to be added so that all elements of a range are present in array
- Find elements larger than half of the elements in an array
- Find elements of array using XOR of consecutive elements
- Count number of elements between two given elements in array
- Count array elements that divide the sum of all other elements
- Replace array elements by sum of next two consecutive elements
- Maximize the sum of X+Y elements by picking X and Y elements from 1st and 2nd array
- Generate an array of K elements such that sum of elements is N and the condition a[i] < a[i+1] <= 2*a[i] is met | Set 2
- Find all elements in array which have at-least two greater elements
- Find minimum value to assign all array elements so that array product becomes greater
- Generate original array from an array that store the counts of greater elements on right
- Check if there exist two elements in an array whose sum is equal to the sum of rest of the array

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.