Non-negative set subtraction in JavaScript

In JavaScript, non-negative set subtraction involves removing elements from one set that exist in another set, while ensuring the result contains only non-negative values. This operation combines set theory with value filtering using JavaScript's built-in Set object and forEach method.

What is the Set Object?

The Set is a built-in data structure introduced in ES6 that stores unique values of any type. Unlike arrays, Sets automatically eliminate duplicates and maintain insertion order. Key characteristics include:

• Uniqueness: Only unique elements are stored
• Insertion order: Elements maintain their order of insertion
• Reference equality: Objects are compared by reference

The forEach Method

The forEach method allows iteration over Set elements, executing a callback function for each item:

let mySet = new Set();

mySet.add("apple");
mySet.add("banana"); 
mySet.add("cherry");

mySet.forEach(function(value) {
   console.log(value);
});

apple
banana
cherry

Understanding Non-Negative Set Subtraction

Non-negative set subtraction removes elements from set A that exist in set B, while filtering out any negative values from the result. This ensures the final set contains only positive numbers and zero.

Implementation Algorithm

Step 1: Create a function that accepts two sets as parameters

Step 2: Initialize an empty result set

Step 3: Iterate through the first set using forEach

Step 4: For each element, check if it's not in the second set AND is non-negative

Step 5: Add qualifying elements to the result set

Basic Set Subtraction

function basicSetSubtraction(setA, setB) {
   let resultSet = new Set();

   setA.forEach(function(element) {
      if (!setB.has(element)) {
         resultSet.add(element);
      }
   });

   return resultSet;
}

let set1 = new Set([1, 2, 3, 4, 5]);
let set2 = new Set([3, 4, 5, 6, 7]);
let result = basicSetSubtraction(set1, set2);

console.log("Set A:", set1);
console.log("Set B:", set2);
console.log("A - B:", result);

Set A: Set { 1, 2, 3, 4, 5 }
Set B: Set { 3, 4, 5, 6, 7 }
A - B: Set { 1, 2 }

Non-Negative Set Subtraction

function nonNegativeSetSubtraction(setA, setB) {
   let resultSet = new Set();

   setA.forEach(function(element) {
      // Check if element is not in setB AND is non-negative
      if (!setB.has(element) && element >= 0) {
         resultSet.add(element);
      }
   });

   return resultSet;
}

// Example with negative numbers
let setA = new Set([-2, -1, 0, 1, 2, 3, 4]);
let setB = new Set([2, 3, 5, 6]);
let result = nonNegativeSetSubtraction(setA, setB);

console.log("Set A:", setA);
console.log("Set B:", setB);
console.log("Non-negative A - B:", result);

Set A: Set { -2, -1, 0, 1, 2, 3, 4 }
Set B: Set { 2, 3, 5, 6 }
Non-negative A - B: Set { 0, 1, 4 }

Modern ES6+ Approach

function nonNegativeSetSubtractionES6(setA, setB) {
   return new Set([...setA].filter(element => 
      !setB.has(element) && element >= 0
   ));
}

let setX = new Set([-3, -1, 0, 2, 4, 6, 8]);
let setY = new Set([0, 2, 7, 9]);
let resultES6 = nonNegativeSetSubtractionES6(setX, setY);

console.log("Using ES6 approach:", resultES6);

Using ES6 approach: Set { 4, 6, 8 }

Comparison of Approaches

Time Complexity

The time complexity is O(n), where n is the number of elements in the first set. The Set.has() operation has O(1) average complexity, making the overall algorithm efficient for most use cases.

Conclusion

Non-negative set subtraction effectively combines set operations with value filtering. The forEach method provides a clear, efficient approach, while modern ES6 syntax offers more concise alternatives for handling unique collections in JavaScript.