Code Logo

Anagram Mapping

Published at25 Jul 2026
Created by
Easy 0 views
Like0

You are given two arrays A and B, where B is an anagram of A (B contains the same elements as A but possibly in a different order). Each element in A also appears in B exactly once (for distinct elements). For duplicate values, map each occurrence in A to the corresponding occurrence in B.

Return an array P where P[i] is the index of A[i] in B. For duplicate values, use the first unclaimed occurrence of that value in B to ensure a valid mapping.

Build a hash map from each value in B to a list of its indices. Iterate through A. For each element, look up its list of indices in B, take the first one (pop from the front), and record it in the result array. This handles duplicates correctly by consuming one index at a time.

Time complexity is O(n) and space complexity is O(n) where n is the array length. The hash map allows O(1) lookup per element, and the queue-like handling of duplicate indices ensures each occurrence is uniquely mapped.

Edge cases include empty arrays (return empty array), single-element arrays, and arrays with duplicate values where multiple occurrences of the same number exist in both arrays.

Example Input & Output

Example 1
Input
[],[]
Output
[]
Explanation

Empty arrays

Example 2
Input
[12,28,46,32,50],[50,12,32,46,28]
Output
[1,4,3,2,0]
Explanation

A[0]=12 at B[1]; A[1]=28 at B[4]; A[2]=46 at B[3]; A[3]=32 at B[2]; A[4]=50 at B[0]

Example 3
Input
[5],[5]
Output
[0]
Explanation

Single element

Example 4
Input
[1,2,3],[3,2,1]
Output
[2,1,0]
Explanation

Each element maps to its position in B

Example 5
Input
[10,20,30,20],[20,10,20,30]
Output
[1,0,3,2]
Explanation

Duplicate values: first occurrence mapping

Algorithm Flow

Recommendation Algorithm Flow for Anagram Mapping
Recommendation Algorithm Flow for Anagram Mapping

Solution Approach

Given two arrays A and B where B is an anagram of A, find the mapping from A's elements to their positions in B. Build a hash map from B: for each element, store its index. Then for each element in A, look up its index in the map.

function anagramMapping(A, B) {
  var map = {}, result = [];
  for (var i = 0; i < B.length; i++) map[B[i]] = i;
  for (var i = 0; i < A.length; i++) result.push(map[A[i]]);
  return result;
}

Since B contains the same elements as A, each element in A maps to exactly one index in B. The hash map provides O(1) lookup for each element.

Time complexity is O(n), space complexity is O(n).

Best Answers

java
import java.util.*;
class Solution {
    public int[] solution(int[] A, int[] B) {
        Map<Integer, Queue<Integer>> map = new HashMap<>();
        for (int i = 0; i < B.length; i++) {
            map.computeIfAbsent(B[i], k -> new LinkedList<>()).add(i);
        }
        int[] res = new int[A.length];
        for (int i = 0; i < A.length; i++) {
            res[i] = map.get(A[i]).poll();
        }
        return res;
    }
}