# 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
- 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
- Find elements of array using XOR of consecutive elements
- Find all elements in array which have at-least two greater elements
- Maximize the sum of X+Y elements by picking X and Y elements from 1st and 2nd array
- Generate original array from an array that store the counts of greater elements on right
- Find minimum value to assign all array elements so that array product becomes greater
- Check if there exist two elements in an array whose sum is equal to the sum of rest of the array
- Sum of array elements excluding the elements which lie between a and b

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.