Find the Prefix Common Array of Two Arrays

Find the Prefix Common Array of Two Arrays - Problem

You are given two 0-indexed integer permutations A and B of length n.

A prefix common array of A and B is an array C such that C[i] is equal to the count of numbers that are present at or before the index i in both A and B.

Return the prefix common array of A and B.

A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.

Input & Output

Example 1 — Basic Case

$ Input: A = [1,3,2,4], B = [3,1,2,4]

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

💡 Note: At index 0: A[0]=1, B[0]=3, no common elements → 0. At index 1: A[0:1]=[1,3], B[0:1]=[3,1], common=[1,3] → 2. At index 2: A[0:2]=[1,3,2], B[0:2]=[3,1,2], common=[1,2,3] → 3. At index 3: A[0:3]=[1,3,2,4], B[0:3]=[3,1,2,4], common=[1,2,3,4] → 4.

Example 2 — Same Elements Different Order

$ Input: A = [2,3,1], B = [3,1,2]

› Output: [0,0,3]

💡 Note: At index 0: A[0]=2, B[0]=3, no common → 0. At index 1: A[0:1]=[2,3], B[0:1]=[3,1], common=[3] but we need both → 0 (only 3 is common). At index 2: A[0:2]=[2,3,1], B[0:2]=[3,1,2], all elements are now common → 3.

Example 3 — Minimum Size

$ Input: A = [1,2], B = [2,1]

› Output: [0,2]

💡 Note: At index 0: A[0]=1, B[0]=2, no common elements → 0. At index 1: A[0:1]=[1,2], B[0:1]=[2,1], both elements are common → 2.

Constraints

1 ≤ A.length == B.length ≤ 1000
1 ≤ A[i], B[i] ≤ A.length
A and B are permutations of integers from 1 to A.length

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use a frequency counter to track when elements become common between prefixes. The optimal approach uses a single pass with O(n) time and O(n) space, incrementing a counter whenever an element's frequency reaches 2 (meaning it appears in both arrays' prefixes).

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force

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

At each index i, iterate through all positions 0 to i in both arrays A and B to find elements that appear in both prefixes. This requires nested loops for each position.

Optimized Single Pass

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

Use a frequency array to track elements. When we see an element in array A, increment its frequency. When we see the same element in B, check if it was already seen in A. If both arrays have seen the element, it contributes to the common count.

Two Pass with Hash Maps

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

Use hash maps to track which elements we've seen in each array so far. As we process each position, we check if the current element creates a new common element between the prefixes.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* queue;
    int size;
    int capacity;
    int freq[200001];
} FirstUnique;

void firstUniqueAdd(FirstUnique* obj, int value);

FirstUnique* firstUniqueCreate(int* nums, int numsSize) {
    FirstUnique* obj = (FirstUnique*)malloc(sizeof(FirstUnique));
    obj->capacity = numsSize + 100;
    obj->queue = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    memset(obj->freq, 0, sizeof(obj->freq));
    for (int i = 0; i < numsSize; i++) {
        firstUniqueAdd(obj, nums[i]);
    }
    return obj;
}

int firstUniqueShowFirstUnique(FirstUnique* obj) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->freq[obj->queue[i] + 100000] == 1) {
            return obj->queue[i];
        }
    }
    return -1;
}

void firstUniqueAdd(FirstUnique* obj, int value) {
    obj->freq[value + 100000]++;
    if (obj->freq[value + 100000] == 1) {
        obj->queue[obj->size++] = value;
    }
}

int* solution(int* nums, int numsSize, int* returnSize) {
    FirstUnique* obj = firstUniqueCreate(nums, numsSize);
    int* result = (int*)malloc(3 * sizeof(int));
    int firstUnique = firstUniqueShowFirstUnique(obj);
    result[0] = firstUnique;
    
    // Add the first unique element (or first element if no unique) twice
    int addValue = firstUnique != -1 ? firstUnique : (numsSize > 0 ? nums[0] : 0);
    firstUniqueAdd(obj, addValue);
    result[1] = firstUniqueShowFirstUnique(obj);
    firstUniqueAdd(obj, addValue);
    result[2] = firstUniqueShowFirstUnique(obj);
    *returnSize = 3;
    free(obj->queue);
    free(obj);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    if (strlen(line) > 2) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            nums[numsSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &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

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

29.8K 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