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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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


Output:

1 0 NA 8 2 5 6 3 NA NA


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.