Find Anagram Mappings

Find Anagram Mappings - Problem

You are given two integer arrays nums1 and nums2 where nums2 is an anagram of nums1. Both arrays may contain duplicates.

Return an index mapping array mapping from nums1 to nums2 where mapping[i] = j means the i^th element in nums1 appears in nums2 at index j.

If there are multiple answers, return any of them. An array a is an anagram of an array b means b is made by randomizing the order of the elements in a.

Input & Output

Example 1 — Basic Mapping

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

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

💡 Note: 12 maps to index 1, 28 maps to index 4, 46 maps to index 3, 32 maps to index 2, 50 maps to index 0

Example 2 — With Duplicates

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

› Output: [0,1]

💡 Note: nums1[0]=84 maps to nums2[0]=84, nums1[1]=46 maps to nums2[1]=46

Example 3 — Multiple Same Values

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

› Output: [0,1,2]

💡 Note: First 40 maps to index 0, second 40 maps to index 1, third 40 maps to index 2

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 A Amazon 18 f Facebook 12

The key insight is to create a mapping from values to their indices in nums2. The optimal approach uses a hash map to store each value and its list of indices, then processes nums1 to build the result mapping in O(n) time.

Common Approaches

✓ Brute Force Linear Search

⏱️ Time: O(n²) Space: O(n)

For each element at position i in nums1, we iterate through nums2 from the beginning until we find the same value. We record that index and mark it as used to handle duplicates correctly.

Hash Map with Index Tracking

⏱️ Time: O(n) Space: O(n)

First pass builds a hash map where each value maps to a list of all its indices in nums2. Second pass iterates through nums1, looking up each value in the map and consuming indices one by one to handle duplicates.

Brute Force Linear Search — Algorithm Steps

Iterate through each element in nums1
For each element, search nums2 linearly for first unused occurrence
Mark found index as used and add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with nums1[0]

Search nums2 from beginning for value 12

Linear search

Check each position until we find 12 at index 1

Mark as used

Record mapping[0] = 1 and mark nums2[1] as used

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>

int* solution(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    *returnSize = nums1Size;
    int* result = (int*)malloc(nums1Size * sizeof(int));
    bool* used = (bool*)malloc(nums2Size * sizeof(bool));
    
    for (int i = 0; i < nums2Size; i++) {
        used[i] = false;
    }
    
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            if (!used[j] && nums1[i] == nums2[j]) {
                result[i] = j;
                used[j] = true;
                break;
            }
        }
    }
    
    free(used);
    return result;
}

int parseNumber(char** p) {
    while (**p && (**p == ' ' || **p == '\t')) (*p)++; // skip whitespace
    
    int sign = 1;
    if (**p == '-') {
        sign = -1;
        (*p)++;
    }
    
    int num = 0;
    while (**p && isdigit(**p)) {
        num = num * 10 + (**p - '0');
        (*p)++;
    }
    
    return sign * num;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums1[100], nums2[100];
    int n1 = 0, n2 = 0;
    
    char* p = strchr(line1, '[') + 1;
    while (*p && *p != ']') {
        nums1[n1++] = parseNumber(&p);
        while (*p && *p != ',' && *p != ']') p++;
        if (*p == ',') p++;
    }
    
    p = strchr(line2, '[') + 1;
    while (*p && *p != ']') {
        nums2[n2++] = parseNumber(&p);
        while (*p && *p != ',' && *p != ']') p++;
        if (*p == ',') p++;
    }
    
    int returnSize;
    int* result = solution(nums1, n1, nums2, n2, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element in nums1 (n elements), we search through nums2 (n elements) linearly

⚠ Quadratic Growth

Space Complexity

O(n)

Need to track used indices in nums2 and store the result mapping array

⚡ Linearithmic Space

32.5K Views

Medium Frequency

~15 min Avg. Time

684 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

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler