Welcome to our Ruby Sets lesson! In Ruby, sets are collections that store unique elements, similar to arrays but without duplicates. Sets are part of the Set class, which offers a variety of methods to manage unique collections efficiently. Throughout this lesson, you'll learn how to create and manipulate sets in Ruby, perform set operations, and understand the performance benefits they provide. Let’s dive in!

To work with sets in Ruby, you’ll need to require the set library. You can create a set using the Set.new method.

When you create a set using Set.new, duplicates in the input array are automatically removed because sets enforce uniqueness. Sets use a hash-based structure under the hood, where each element’s value is hashed. This ensures that duplicates are identified and ignored during initialization.

Ruby
Copy to clipboard
1require 'set'
2
3# Creating a set with unique elements
4my_set = Set.new([1, 2, 3, 4, 5, 5, 5])
5puts my_set.inspect  # Output: #<Set: {1, 2, 3, 4, 5}>
6
7# Adding an element to the set
8my_set.add(6)
9puts my_set.include?(1)  # Output: true
10
11# Removing an element
12my_set.delete(1)
13puts my_set.include?(1)  # Output: false
14
15# Trying to remove a non-existent element
16my_set.delete(7)  # No error, just no change if element doesn't exist

Ruby’s Set provides methods like add, include?, and delete, making it straightforward to manage collections of unique items.

Ruby’s Set class supports powerful operations that allow you to combine, intersect, or find the difference between sets, making it ideal for handling unique collections.

Ruby
Copy to clipboard
1require 'set'
2
3set_1 = Set.new([1, 2, 3, 4])
4set_2 = Set.new([3, 4, 5, 6])
5
6# Union of two sets
7puts (set_1 | set_2).inspect  # Output: #<Set: {1, 2, 3, 4, 5, 6}>
8
9# Intersection of two sets
10puts (set_1 & set_2).inspect  # Output: #<Set: {3, 4}>
11
12# Difference of two sets
13puts (set_1 - set_2).inspect  # Output: #<Set: {1, 2}>
14
15# Symmetric difference of two sets
16puts (set_1 ^ set_2).inspect  # Output: #<Set: {1, 2, 5, 6}>

• Union (|): Combines elements from both sets, excluding duplicates.
• Intersection (&): Finds only the elements common to both sets.
• Difference (-): Returns elements present in the first set but not in the second set.
• Symmetric Difference (^): Returns elements in either set, but not in both (exclusive OR).

These operations provide a simple and efficient way to work with unique collections.

One of the key advantages of using sets is their efficient performance for membership tests, thanks to their hash-based structure. This makes sets significantly faster for lookups compared to arrays, especially as the collection grows.

Ruby
Copy to clipboard
1require 'set'
2require 'benchmark'
3
4my_set = Set.new(0...1000000)  # A set with 1,000,000 elements
5my_array = (0...1000000).to_a  # An array with the same elements
6
7# Measuring membership test time for a set
8set_time = Benchmark.realtime do
9  puts my_set.include?(999999)  # Output: true
10end
11puts "Time taken for set: #{set_time} seconds"
12
13# Measuring membership test time for an array
14array_time = Benchmark.realtime do
15  puts my_array.include?(999999)  # Output: true
16end
17puts "Time taken for array: #{array_time} seconds"

• Sets: Utilize a hash-based structure, allowing for constant time complexity O(1) for membership checks. This efficiency comes from directly accessing the hashed value, making it ideal for large collections where frequent lookups are needed.
• Arrays: Require a linear search O(n) for membership checks, meaning the time taken increases with the size of the array. Each element must be checked sequentially until the desired element is found or the end is reached.

Using sets for large collections where you frequently check for membership can greatly improve performance.

Well done! In this lesson, you learned how to create and manipulate sets using Ruby's Set class, perform essential set operations like union, intersection, and difference, and understand the performance benefits of using sets for unique collections. Practicing these techniques will help you make the most of unique collections in your Ruby applications. Happy coding!