Find Anagram Mappings - Practice Coding Problems

Find Anagram Mappings - Problem

Find Anagram Mappings

You are given two integer arrays nums1 and nums2 where nums2 is an anagram of nums1. This means that nums2 contains exactly the same elements as nums1, just in a different order.

Your task is to return an index mapping array mapping where mapping[i] = j means the i-th element in nums1 appears at index j in nums2.

Important notes:
• Both arrays may contain duplicates
• If there are multiple valid answers, return any one of them
• The arrays are guaranteed to be anagrams of each other

Example: If nums1 = [12, 28, 46, 32, 50] and nums2 = [50, 12, 32, 46, 28], then one valid mapping would be [1, 4, 3, 2, 0] because:
• nums1[0] = 12 appears at nums2[1]
• nums1[1] = 28 appears at nums2[4]
• nums1[2] = 46 appears at nums2[3]
• And so on...

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [12, 28, 46, 32, 50], nums2 = [50, 12, 32, 46, 28]

› Output: [1, 4, 3, 2, 0]

💡 Note: nums1[0]=12 is found at nums2[1], nums1[1]=28 is found at nums2[4], nums1[2]=46 is found at nums2[3], nums1[3]=32 is found at nums2[2], nums1[4]=50 is found at nums2[0]

example_2.py — With Duplicates

$ Input: nums1 = [84, 46, 84], nums2 = [84, 46, 84]

› Output: [2, 1, 0] or [0, 1, 2]

💡 Note: Since there are duplicate 84s, multiple valid answers exist. One possibility: first 84 maps to index 2, 46 maps to index 1, second 84 maps to index 0

example_3.py — Single Element

$ Input: nums1 = [1], nums2 = [1]

› Output: [0]

💡 Note: The only element 1 in nums1 is found at index 0 in nums2

Constraints

1 ≤ nums1.length ≤ 100
nums2.length == nums1.length
0 ≤ nums1[i], nums2[i] ≤ 10⁵
nums2 is an anagram of nums1

Visualization

Tap to expand

Understanding the Visualization

Catalog Creation

Create a catalog (hash map) of where each item is stored

Quick Lookups

For each requested item, instantly find its location using the catalog

Handle Duplicates

Use a stack system to manage multiple copies of the same item

Complete Mapping

All locations found efficiently in linear time

Key Takeaway

🎯 Key Insight: Hash maps provide O(1) average lookup time, transforming an O(n²) search problem into an O(n) mapping problem. Like a well-organized library catalog, we can instantly find any book's location!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 10

The optimal solution uses a hash map to achieve O(n) time complexity. Build a map from nums2 values to their indices, using stacks to handle duplicates. Then iterate through nums1, looking up each element in the hash map and popping an index. This approach is much more efficient than the O(n²) brute force nested loop solution.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build hash map from nums2 first, then process nums1 in single optimized pass
Two-Pass Hash Table	O(n)	O(n)	Build hash map of nums2 indices first, then look up each nums1 element
Brute Force (Nested Loops)	O(n²)	O(n)	For each element in nums1, scan through nums2 to find its index

One-Pass Hash Table (Optimal) — Algorithm Steps

Build hash map from nums2: value -> stack of indices
Initialize result array
For each element in nums1:
Look up the element in hash map
Pop an index from the corresponding stack
Store the index in result array
Return result

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Create map: value → stack of indices from nums2

Process nums1

For each element, pop index from corresponding stack

Handle Duplicates

Stack automatically handles duplicates in LIFO order

Complete Result

All mappings found in optimal O(n) time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Hash table node for C implementation
typedef struct HashNode {
    int key;
    int* indices;
    int count;
    int capacity;
    struct HashNode* next;
} HashNode;

#define HASH_SIZE 1000

int hash_function(int key) {
    return abs(key) % HASH_SIZE;
}

int* anagramMappings(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    *returnSize = nums1Size;
    
    // Initialize hash table
    HashNode* hashTable[HASH_SIZE] = {NULL};
    
    // Build hash map from nums2
    for (int i = 0; i < nums2Size; i++) {
        int hashIdx = hash_function(nums2[i]);
        HashNode* current = hashTable[hashIdx];
        
        // Find or create node for this key
        while (current && current->key != nums2[i]) {
            current = current->next;
        }
        
        if (!current) {
            // Create new node
            current = (HashNode*)malloc(sizeof(HashNode));
            current->key = nums2[i];
            current->indices = (int*)malloc(nums2Size * sizeof(int));
            current->count = 0;
            current->capacity = nums2Size;
            current->next = hashTable[hashIdx];
            hashTable[hashIdx] = current;
        }
        
        current->indices[current->count++] = i;
    }
    
    // Build result array
    int* result = (int*)malloc(nums1Size * sizeof(int));
    
    for (int i = 0; i < nums1Size; i++) {
        int hashIdx = hash_function(nums1[i]);
        HashNode* current = hashTable[hashIdx];
        
        while (current && current->key != nums1[i]) {
            current = current->next;
        }
        
        // Pop from stack (take last element)
        result[i] = current->indices[--current->count];
    }
    
    // Cleanup memory
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* current = hashTable[i];
        while (current) {
            HashNode* next = current->next;
            free(current->indices);
            free(current);
            current = next;
        }
    }
    
    return result;
}

int main() {
    int nums1[] = {12, 28, 46, 32, 50};
    int nums2[] = {50, 12, 32, 46, 28};
    int returnSize;
    
    int* result = anagramMappings(nums1, 5, nums2, 5, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Building hash map takes O(n), then single pass through nums1 takes O(n), all hash map operations are O(1) average

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all elements from nums2 with their indices, plus result array

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler