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 mappedInput: 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:
Implementation:
// 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;
} |
/*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<Integer,List<Integer>> m = new HashMap<>();
for ( int i:A){
m.put(i, new ArrayList<Integer>());
}
for ( int i= 0 ; i<N; i++)
m.get(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.get(B[i]).size() > 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 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__ |
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]][0] + " " );
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 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__ |
1 0 NA 8 2 5 6 3 NA NA
Time Complexity: O(N+M)
Auxiliary Space: O(N)