Set Operations Implementer - Problem

Implement four fundamental set operations without using built-in set functions or libraries. Given two arrays representing sets (containing unique elements), implement:

Union: All elements that appear in either set
Intersection: Elements that appear in both sets
Difference: Elements in the first set but not the second
Symmetric Difference: Elements in either set but not in both

Return a 2D array where each row contains the result of one operation in the order: [union, intersection, difference, symmetric_difference].

Note: The order of elements in each result array doesn't matter, but duplicates should be eliminated.

Input & Output

Example 1 — Basic Sets

$ Input: set1 = [1,2,3], set2 = [2,4]

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

💡 Note: Union combines all unique elements [1,2,3,4]. Intersection finds common element [2]. Difference shows elements only in set1 [1,3]. Symmetric difference shows elements in exactly one set [1,3,4].

Example 2 — Disjoint Sets

$ Input: set1 = [1,3], set2 = [2,4]

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

💡 Note: No common elements, so intersection is empty []. Union and symmetric difference are the same since sets don't overlap. Difference contains all of set1 [1,3].

Example 3 — Identical Sets

$ Input: set1 = [5,10], set2 = [5,10]

› Output: [[5,10], [5,10], [], []]

💡 Note: Sets are identical. Union equals both sets [5,10]. Intersection is the full set [5,10]. Difference and symmetric difference are empty since no elements are unique to either set.

Constraints

1 ≤ set1.length, set2.length ≤ 1000
-10⁶ ≤ set1[i], set2[i] ≤ 10⁶
All elements within each set are unique

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is using frequency counting to track how many times each element appears across both sets. The optimal approach uses a hash map to count occurrences in O(n+m) time - elements appearing once are in exactly one set, elements appearing twice are in both sets. This enables generating all four set operations in a single pass through the frequency map. Time: O(n+m), Space: O(n+m).

Common Approaches

✓ Hash Map Frequency Counting

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

Build a frequency map by counting how many times each element appears across both sets. Elements with frequency 1 appear in one set, frequency 2 appear in both sets.

Nested Loop Approach

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

For each operation, iterate through elements and use nested loops to check membership. This approach is straightforward but inefficient due to repeated linear searches.

Hash Map Frequency Counting — Algorithm Steps

Step 1: Create frequency map and count all elements from set1
Step 2: Process set2 elements, incrementing counts for existing elements or adding new ones
Step 3: Scan frequency map once to generate all four results based on counts
Step 4: Return results in order: union, intersection, difference, symmetric difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Frequency Map

Count occurrences: elements in both sets get count=2, others get count=1

Generate Results

Single scan of frequency map generates all four operations simultaneously

Output

Return [union, intersection, difference, symmetric_difference]

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

int hashFunction(int key) {
    return abs(key) % HASH_SIZE;
}

void insertHash(int key) {
    int index = hashFunction(key);
    HashNode* node = hashTable[index];
    
    while (node != NULL) {
        if (node->key == key) {
            node->value++;
            return;
        }
        node = node->next;
    }
    
    // Create new node
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = 1;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

int getHash(int key) {
    int index = hashFunction(key);
    HashNode* node = hashTable[index];
    
    while (node != NULL) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

int isInSet(int* set, int size, int elem) {
    for (int i = 0; i < size; i++) {
        if (set[i] == elem) return 1;
    }
    return 0;
}

int* parseArray(char* s, int* size) {
    int* arr = malloc(MAX_SIZE * sizeof(int));
    *size = 0;
    
    // Remove brackets
    char* start = strchr(s, '[') + 1;
    char* end = strrchr(s, ']');
    *end = '\0';
    
    if (strlen(start) == 0) return arr;
    
    char* token = strtok(start, ",");
    while (token != NULL) {
        arr[(*size)++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    return arr;
}

void printArray(int* arr, int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("%d", arr[i]);
    }
    printf("]");
}

void solution(int* set1, int size1, int* set2, int size2) {
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    // Build frequency map
    for (int i = 0; i < size1; i++) {
        insertHash(set1[i]);
    }
    for (int i = 0; i < size2; i++) {
        insertHash(set2[i]);
    }
    
    int union_arr[MAX_SIZE], union_size = 0;
    int intersection[MAX_SIZE], inter_size = 0;
    int difference[MAX_SIZE], diff_size = 0;
    int sym_diff[MAX_SIZE], sym_size = 0;
    
    // Process all unique elements
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = hashTable[i];
        while (node != NULL) {
            int elem = node->key;
            int count = node->value;
            
            union_arr[union_size++] = elem;
            
            if (count == 2) {
                intersection[inter_size++] = elem;
            } else if (count == 1) {
                sym_diff[sym_size++] = elem;
                if (isInSet(set1, size1, elem)) {
                    difference[diff_size++] = elem;
                }
            }
            
            node = node->next;
        }
    }
    
    printf("[");
    printArray(union_arr, union_size);
    printf(",");
    printArray(intersection, inter_size);
    printf(",");
    printArray(difference, diff_size);
    printf(",");
    printArray(sym_diff, sym_size);
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = hashTable[i];
        while (node != NULL) {
            HashNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int size1, size2;
    int* set1 = parseArray(line1, &size1);
    int* set2 = parseArray(line2, &size2);
    
    solution(set1, size1, set2, size2);
    
    free(set1);
    free(set2);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n+m)

Single pass through each set to build frequency map, plus one pass through map to generate results

✓ Linear Growth

Space Complexity

O(n+m)

Hash map stores at most n+m unique elements, plus space for result arrays

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

945 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

Set Operations Implementer - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Map Frequency Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler