 GeeksforGeeks App
Open App Browser
Continue

# 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, B and B can be mapped to A, A and A respectively but B 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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:

Implementation:

## CPP

 `// C++ program to map elements of an array``// to equal elements of another array``#include ``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 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);``    ``int` `B[] = {1, 2, 5, 1, 2, 4, 2, 3, 2, 1};``    ``int` `M = ``sizeof``(B) / ``sizeof``(B);``    ``printMapping(A, B, N, M);``        ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.util.*;` `class` `GFG {``  ` `  ``// Function to print the mapping of elements``static` `void` `printMapping(``int` `A[], ``int` `B[], ``int` `N, ``int` `M)``{` `// Create a hash table where all indexes are``// stored for a given value``HashMap> m = ``new` `HashMap<>();``  ` `  ``for``(``int` `i:A){``      ``m.put(i,``new` `ArrayList());``  ``}``  ` `for` `(``int` `i=``0``; i ``0``)``    ``{``        ``System.out.print(m.get(B[i]).get(``0``) + ``" "``);``        ``m.get(B[i]).remove(``0``);``    ``}` `    ``else` `// No mapping found``    ``{``        ``System.out.print(``"NA"` `+ ``" "``);``    ``}``}``}``    ``public` `static` `void` `main (String[] args) {``            ``int` `A[] = {``2``, ``1``, ``2``, ``3``, ``3``, ``4``, ``2``, ``4``, ``1``};``    ``int` `N = A.length;``    ``int` `B[] = {``1``, ``2``, ``5``, ``1``, ``2``, ``4``, ``2``, ``3``, ``2``, ``1``};``    ``int` `M = B.length;``    ``printMapping(A, B, N, M);``    ` `    ``}``}`

## Python3

 `# Python3 program to map elements of an array``# to equal elements of another array` `# Function to print the mapping of elements``def` `printMapping(A, B):` `    ``# Create a hash table where all indexes are``    ``# stored for a given value``    ``m ``=` `{}``    ``for` `i ``in` `range``(``len``(A)):``        ``if` `A[i] ``in` `m:``            ``m[A[i]].append(i)``        ``else``:``            ``m[A[i]] ``=` `[i]` `    ``# Traverse through B[]``    ``for` `i ``in` `range``(``len``(B)):``    ` `        ``# 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` `B[i] ``in` `m ``and` `len``(m[B[i]]) > ``0``:``            ``print``(m[B[i]].pop(``0``),end``=``" "``)``        ``else``:``            ``print``(``"NA"``,end``=``" "``)` `# Driver code``A ``=` `[``2``, ``1``, ``2``, ``3``, ``3``, ``4``, ``2``, ``4``, ``1``]``B ``=` `[``1``, ``2``, ``5``, ``1``, ``2``, ``4``, ``2``, ``3``, ``2``, ``1``]``printMapping(A, B)` `# This code is contributed by akashish__`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``// Function to print the mapping of elements``  ``static` `void` `printMapping(``int``[] A, ``int``[] B, ``int` `N, ``int` `M)``  ``{` `    ``// Create a hash table where all indexes are``    ``// stored for a given value``    ``Dictionary<``int``, List<``int``> > m``      ``= ``new` `Dictionary<``int``, List<``int``> >();` `    ``for` `(``int` `i = 0; i < A.Length; i++) {``      ``if` `(!m.ContainsKey(A[i]))``        ``m.Add(A[i], ``new` `List<``int``>());``    ``}` `    ``for` `(``int` `i = 0; i < N; i++)``      ``m[A[i]].Add(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.ContainsKey(B[i]) && m[B[i]].Count > 0) {``        ``Console.Write(m[B[i]] + ``" "``);``        ``m[B[i]].RemoveAt(0);``      ``}` `      ``else` `// No mapping found``      ``{``        ``Console.Write(``"NA"``                      ``+ ``" "``);``      ``}``    ``}``  ``}``  ``static` `public` `void` `Main()``  ``{` `    ``int``[] A = { 2, 1, 2, 3, 3, 4, 2, 4, 1 };``    ``int` `N = A.Length;``    ``int``[] B = { 1, 2, 5, 1, 2, 4, 2, 3, 2, 1 };``    ``int` `M = B.Length;``    ``printMapping(A, B, N, M);``  ``}``}` `// This code is contributed by akashish__`

## Javascript

 `// JavaScript program to map elements of an array``// to equal elements of another array` `// Function to print the mapping of elements``function` `printMapping(A, B)``{` `    ``// Create a hash table where all indexes are``    ``// stored for a given value``    ``let m = ``new` `Map();``    ``for` `(let i = 0; i < A.length; i++) {``        ``if` `(m.has(A[i])) {``            ``m.get(A[i]).push(i);``        ``} ``else` `{``            ``m.set(A[i], [i]);``        ``}``    ``}` `    ``// Traverse through B[]``    ``for` `(let i = 0; i < B.length; 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.has(B[i]) && m.get(B[i]).length > 0) {``            ``console.log(m.get(B[i]).shift());``        ``} ``else` `{``            ``console.log(``"NA"``);``        ``}``    ``}``}` `// Driver code``let A = [2, 1, 2, 3, 3, 4, 2, 4, 1];``let B = [1, 2, 5, 1, 2, 4, 2, 3, 2, 1];``printMapping(A, B);` `// This code is contributed by akashish__`

Output

`1 0 NA 8 2 5 6 3 NA NA `

Time Complexity: O(N+M)

Auxiliary Space: O(N)

My Personal Notes arrow_drop_up