Find the Distinct Difference Array - Practice Coding Problems

Find the Distinct Difference Array - Problem

You're given a 0-indexed array nums of length n. Your task is to create a distinct difference array that reveals interesting patterns about unique elements!

The distinct difference array diff has the same length n, where each diff[i] represents:

Number of distinct elements in the prefix nums[0...i] (left side including current)
MINUS the number of distinct elements in the suffix nums[i+1...n-1] (right side excluding current)

Goal: Return the distinct difference array that shows how the balance of unique elements changes at each position.

Example: For nums = [1,2,3,4,5], at index 2 (value 3):
• Prefix [1,2,3] has 3 distinct elements
• Suffix [4,5] has 2 distinct elements
• So diff[2] = 3 - 2 = 1

Input & Output

example_1.py — Basic Example

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

› Output: [-3,-1,1,3,5]

💡 Note: For each position i: diff[0] = 1-4=-3 (prefix {1}, suffix {2,3,4,5}), diff[1] = 2-3=-1 (prefix {1,2}, suffix {3,4,5}), diff[2] = 3-2=1 (prefix {1,2,3}, suffix {4,5}), diff[3] = 4-1=3 (prefix {1,2,3,4}, suffix {5}), diff[4] = 5-0=5 (prefix {1,2,3,4,5}, empty suffix)

example_2.py — Duplicate Elements

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

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

💡 Note: With duplicates, distinct counts are different: diff[0] = 1-3=-2 (prefix {3}, suffix {2,4}), diff[1] = 2-3=-1 (prefix {3,2}, suffix {3,4,2} has {3,4,2}), diff[2] = 2-2=0 (prefix {3,2}, suffix {4,2}), diff[3] = 3-1=2 (prefix {3,2,4}, suffix {2}), diff[4] = 3-0=3 (all distinct elements in prefix)

example_3.py — Single Element

$ Input: nums = [1]

› Output: [1]

💡 Note: Edge case with single element: prefix has {1} (1 distinct), suffix is empty (0 distinct), so diff[0] = 1 - 0 = 1

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50
Note: Small constraints allow for O(n²) brute force solutions

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with array [1,2,3,4,5] and prepare to slide divider

Position 0

Divider after 1: left has {1}, right has {2,3,4,5} → 1-4=-3

Position 1

Divider after 2: left has {1,2}, right has {3,4,5} → 2-3=-1

Continue

Pattern emerges: prefix grows, suffix shrinks, difference increases

Key Takeaway

🎯 Key Insight: Pre-compute suffix counts once, then build prefix incrementally - this transforms O(n²) nested loops into O(n) linear time!

Asked in

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

The optimal solution uses a two-pass approach with hash sets. First pass computes suffix distinct counts from right to left. Second pass builds prefix counts incrementally while using pre-computed suffix counts, achieving O(n) time complexity by eliminating redundant calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table Optimization	O(n)	O(n)	Pre-compute suffix counts, then build prefix counts incrementally
Brute Force (Nested Loops)	O(n²)	O(n)	For each position, scan left and right to count distinct elements

Two-Pass Hash Table Optimization — Algorithm Steps

First pass: scan from right to left, maintaining suffix distinct counts
Store suffix counts for each position in an array
Second pass: scan from left to right
Build prefix set incrementally, adding current element
Use pre-computed suffix count to calculate diff[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Pass 1: Right to Left

Pre-compute suffix distinct counts

Pass 2: Left to Right

Build prefix incrementally using pre-computed suffix

Code -

solution.c — C

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

typedef struct {
    int *data;
    int size;
    int capacity;
} IntSet;

IntSet* createSet() {
    IntSet* set = malloc(sizeof(IntSet));
    set->capacity = 1000;
    set->data = calloc(set->capacity, sizeof(int));
    set->size = 0;
    return set;
}

void addToSet(IntSet* set, int val) {
    for (int i = 0; i < set->size; i++) {
        if (set->data[i] == val) return;
    }
    set->data[set->size++] = val;
}

void freeSet(IntSet* set) {
    free(set->data);
    free(set);
}

int* distinctDifferenceArray(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    
    // First pass: compute suffix distinct counts
    int* suffixCounts = calloc(numsSize, sizeof(int));
    IntSet* suffixSet = createSet();
    
    // Fill suffix counts from right to left
    for (int i = numsSize - 1; i >= 0; i--) {
        if (i == numsSize - 1) {
            suffixCounts[i] = 0; // No suffix for last element
        } else {
            suffixCounts[i] = suffixSet->size;
        }
        addToSet(suffixSet, nums[i]);
    }
    
    // Second pass: build prefix counts and compute differences
    int* diff = malloc(numsSize * sizeof(int));
    IntSet* prefixSet = createSet();
    
    for (int i = 0; i < numsSize; i++) {
        addToSet(prefixSet, nums[i]);
        diff[i] = prefixSet->size - suffixCounts[i];
    }
    
    freeSet(suffixSet);
    freeSet(prefixSet);
    free(suffixCounts);
    
    return diff;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    int returnSize;
    int* result = distinctDifferenceArray(nums, n, &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)

Two passes through array, each taking O(n) time with O(1) set operations on average

✓ Linear Growth

Space Complexity

O(n)

Extra array for suffix counts plus sets for distinct elements

⚡ Linearithmic Space

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

Two-Pass Hash Table Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler