Find the Difference of Two Arrays

Find the Difference of Two Arrays - Problem

Given two 0-indexed integer arrays nums1 and nums2, return a list answer of size 2 where:

answer[0] is a list of all distinct integers in nums1 which are not present in nums2.
answer[1] is a list of all distinct integers in nums2 which are not present in nums1.

Note that the integers in the lists may be returned in any order.

Input & Output

Example 1 — Basic Case

$ Input: nums1 = [1,2,3], nums2 = [2,4,6]

› Output: [[1,3],[4,6]]

💡 Note: Elements 1 and 3 are in nums1 but not nums2. Elements 4 and 6 are in nums2 but not nums1.

Example 2 — With Duplicates

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

› Output: [[3],[]]

💡 Note: Element 3 is in nums1 but not nums2. All elements of nums2 exist in nums1, so second array is empty.

Example 3 — No Common Elements

$ Input: nums1 = [1,2], nums2 = [3,4]

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

💡 Note: No elements are common between arrays, so each array contains all its unique elements.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
-1000 ≤ nums1[i], nums2[i] ≤ 1000

Visualization

Tap to expand

Asked in

A Amazon 15 G Google 12

The key insight is using hash sets for O(1) membership checking instead of linear search. Best approach is Two-Pass Hash Set: convert arrays to sets, then check each element's membership in the other set. Time: O(n+m), Space: O(n+m)

Common Approaches

✓ Sort First

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

Brute Force - Nested Loops

⏱️ Time: O(n×m) Space: O(k)

For each element in nums1, iterate through all of nums2 to see if it exists. Do the same for nums2 elements against nums1. Use sets to avoid duplicates in results.

Two-Pass Hash Set

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

First convert both arrays to hash sets to eliminate duplicates and enable fast lookups. Then iterate through each set and check if elements exist in the other set.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
} IntArray;

void parseArray(const char* str, IntArray* arr) {
    arr->size = 0;
    arr->data = malloc(1000 * sizeof(int));
    
    if (strcmp(str, "[]") == 0) {
        return;
    }
    
    char* copy = malloc(strlen(str) + 1);
    strcpy(copy, str);
    
    char* token = strtok(copy, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ']' && token[0] != '\n') {
            arr->data[arr->size++] = (int)strtol(token, NULL, 10);
        }
        token = strtok(NULL, "[,]");
    }
    
    free(copy);
}

bool contains(IntArray* arr, int val) {
    for (int i = 0; i < arr->size; i++) {
        if (arr->data[i] == val) return true;
    }
    return false;
}

void removeDuplicates(IntArray* arr) {
    if (arr->size <= 1) return;
    
    int writeIdx = 0;
    for (int i = 0; i < arr->size; i++) {
        bool found = false;
        for (int j = 0; j < writeIdx; j++) {
            if (arr->data[j] == arr->data[i]) {
                found = true;
                break;
            }
        }
        if (!found) {
            arr->data[writeIdx++] = arr->data[i];
        }
    }
    arr->size = writeIdx;
}

void solution(IntArray* nums1, IntArray* nums2, IntArray* diff1, IntArray* diff2) {
    diff1->size = 0;
    diff2->size = 0;
    diff1->data = malloc(1000 * sizeof(int));
    diff2->data = malloc(1000 * sizeof(int));
    
    // Remove duplicates first
    removeDuplicates(nums1);
    removeDuplicates(nums2);
    
    // Find elements in nums1 not in nums2
    for (int i = 0; i < nums1->size; i++) {
        if (!contains(nums2, nums1->data[i])) {
            diff1->data[diff1->size++] = nums1->data[i];
        }
    }
    
    // Find elements in nums2 not in nums1
    for (int i = 0; i < nums2->size; i++) {
        if (!contains(nums1, nums2->data[i])) {
            diff2->data[diff2->size++] = nums2->data[i];
        }
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    IntArray nums1, nums2, diff1, diff2;
    parseArray(line1, &nums1);
    parseArray(line2, &nums2);
    
    solution(&nums1, &nums2, &diff1, &diff2);
    
    printf("[[");
    for (int i = 0; i < diff1.size; i++) {
        if (i > 0) printf(",");
        printf("%d", diff1.data[i]);
    }
    printf("],[");
    for (int i = 0; i < diff2.size; i++) {
        if (i > 0) printf(",");
        printf("%d", diff2.data[i]);
    }
    printf("]]\n");
    
    free(nums1.data);
    free(nums2.data);
    free(diff1.data);
    free(diff2.data);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

950 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