Welcome back! Today, we're focusing on Ruby's Set — an essential tool for efficient collection manipulation. Ruby's Set resembles a mathematical set; it ensures uniqueness by preventing duplicates, akin to how a club assigns unique membership IDs to each member. In this session, you'll see how Set simplifies problems involving ensuring uniqueness and checking for overlaps. Let's explore how Set can transform lengthy, cumbersome operations into efficient, elegant code.

Imagine you're developing a feature for a social media platform that requires user groups to be exclusive — you need to ensure that users can't belong to more than one group at a time. It's like organizing events, where a guest should not appear on the lists for two different parties at the same venue — an overlap would be a significant issue.

Initially, you might consider checking for overlap by comparing each member of one group with every member of the other — a somewhat cumbersome O(n * m) operation. If you have hundreds or thousands of users in each group, the time it would take to compare them all grows exponentially. This approach is impractical and resource-intensive, especially on the scale of a social media platform with potentially millions of users.

def are_disjoint?(arr1, arr2)
  arr1.each do |num1|
    arr2.each do |num2|
      return false if num1 == num2 # An overlap is found.
    end
  end
  true # No overlaps found, sets are disjoint.
end

Instead, Set provides a swift and efficient method for achieving the same result. Let's step through the implementation:

require 'set'

def are_disjoint?(arr1, arr2)
  set1 = Set.new(arr1) # Populating the Set, preparing for constant-time checks
  
  arr2.each do |num|
    return false if set1.include?(num) # If found, the sets are not disjoint.
  end
  true
end

Set provides significant speed advantages due to its underlying hash-based structure, offering average constant time, O(1), for operations like add and include?. This efficiency comes from computing hash codes for swift element access and retrieval, unlike arrays that have linear time complexity, O(n), for similar operations. This ultimately combines into a function that has a time complexity of O(n). It inherently manages duplicates by allowing each element to be added only once, simplifying the logic for uniqueness checks. These features make Set an ideal choice for tasks requiring quick membership checks and ensuring unique elements.

Set also includes the intersect? method, which can be used with not to check if two sets are disjoint.