Find the Distinct Difference Array

Find the Distinct Difference Array - Problem

You are given a 0-indexed array nums of length n.

The distinct difference array of nums is an array diff of length n such that diff[i] is equal to the number of distinct elements in the suffix nums[i + 1, ..., n - 1] subtracted from the number of distinct elements in the prefix nums[0, ..., i].

Return the distinct difference array of nums.

Note: nums[i, ..., j] denotes the subarray of nums starting at index i and ending at index j inclusive. If i > j, then nums[i, ..., j] denotes an empty subarray.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3,4,1]

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

💡 Note: At i=0: prefix {1} has 1 distinct, suffix {2,3,4,1} has 3 distinct → 1-3 = -2. At i=1: prefix {1,2} has 2 distinct, suffix {3,4,1} has 3 distinct → 2-3 = -1. At i=2: prefix {1,2,3} has 3 distinct, suffix {4,1} has 2 distinct → 3-2 = 1. At i=3: prefix {1,2,3,4} has 4 distinct, suffix {1} has 1 distinct → 4-1 = 3. At i=4: prefix {1,2,3,4,1} has 4 distinct, suffix {} has 0 distinct → 4-0 = 4.

Example 2 — All Same Elements

$ Input: nums = [3,3,3]

› Output: [0,0,1]

💡 Note: At i=0: prefix {3} has 1 distinct, suffix {3,3} has 1 distinct → 1-1 = 0. At i=1: prefix {3,3} has 1 distinct, suffix {3} has 1 distinct → 1-1 = 0. At i=2: prefix {3,3,3} has 1 distinct, suffix {} has 0 distinct → 1-0 = 1.

Example 3 — No Duplicates

$ Input: nums = [1,2,3]

› Output: [-1,1,3]

💡 Note: At i=0: prefix {1} has 1 distinct, suffix {2,3} has 2 distinct → 1-2 = -1. At i=1: prefix {1,2} has 2 distinct, suffix {3} has 1 distinct → 2-1 = 1. At i=2: prefix {1,2,3} has 3 distinct, suffix {} has 0 distinct → 3-0 = 3.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 10 M Microsoft 8

The key insight is to precompute distinct element counts for prefixes and suffixes to avoid redundant calculations. Best approach uses two-pass hash map method. Time: O(n), Space: O(n)

Common Approaches

✓ Optimized

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

Greedy

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

Brute Force

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

At each index i, create sets for prefix nums[0..i] and suffix nums[i+1..n-1], then compute their size difference. This recalculates distinct counts from scratch for every position.

Two Pass with Precomputation

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

First pass builds prefix distinct counts from left to right. Second pass builds suffix distinct counts from right to left. Finally, compute the difference for each position using precomputed values.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int* result) {
    for (int i = 0; i < numsSize; i++) {
        // Count distinct elements in prefix nums[0..i]
        int prefixDistinct = 0;
        for (int j = 0; j <= i; j++) {
            int found = 0;
            for (int k = 0; k < j; k++) {
                if (nums[k] == nums[j]) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                prefixDistinct++;
            }
        }
        
        // Count distinct elements in suffix nums[i+1..n-1]
        int suffixDistinct = 0;
        for (int j = i + 1; j < numsSize; j++) {
            int found = 0;
            for (int k = i + 1; k < j; k++) {
                if (nums[k] == nums[j]) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                suffixDistinct++;
            }
        }
        
        result[i] = prefixDistinct - suffixDistinct;
    }
    return numsSize;
}

int parseInt(char* str) {
    int result = 0;
    int sign = 1;
    int i = 0;
    
    while (str[i] == ' ') i++;
    
    if (str[i] == '-') {
        sign = -1;
        i++;
    } else if (str[i] == '+') {
        i++;
    }
    
    while (str[i] >= '0' && str[i] <= '9') {
        result = result * 10 + (str[i] - '0');
        i++;
    }
    
    return sign * result;
}

int main() {
    char line[10000];
    
    // Read nums
    fgets(line, sizeof(line), stdin);
    int nums[1000];
    int numsSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* end = strchr(ptr, ']');
        if (end) *end = '\0';
        
        char* token = strtok(ptr, ",");
        while (token != NULL) {
            while (*token == ' ') token++;
            nums[numsSize++] = parseInt(token);
            token = strtok(NULL, ",");
        }
    }
    
    int result[1000];
    solution(nums, numsSize, result);
    
    printf("[");
    for (int i = 0; i < numsSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

421 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