Array comparison and set operations in Ruby

Introduction

We use array comparison and set operations to find common, different, or combined items between lists. This helps us organize and compare data easily.

You want to find which friends you have in common with someone else.

You need to see what items are missing from your shopping list compared to a recipe.

You want to combine two lists of tasks without repeating any.

You want to check if two lists have exactly the same items.

You want to remove duplicates from a list.

Syntax

Ruby

array1 & array2   # Intersection: items common to both arrays
array1 | array2   # Union: all unique items from both arrays
array1 - array2   # Difference: items in array1 not in array2
array1 == array2  # Equality: checks if arrays have same items in same order
array1.eql?(array2) # Strict equality including type and order

The & operator finds items present in both arrays.

The | operator combines arrays but removes duplicates.

Examples

Intersection finds common items 2 and 3.

Ruby

a = [1, 2, 3]
b = [2, 3, 4]
puts a & b  # Output: [2, 3]

Union combines all unique items from both arrays.

Ruby

a = [1, 2, 3]
b = [3, 4, 5]
puts a | b  # Output: [1, 2, 3, 4, 5]

Difference shows items in a not in b.

Ruby

a = [1, 2, 3]
b = [2, 3]
puts a - b  # Output: [1]

Equality checks if arrays have same items in same order.

Ruby

a = [1, 2, 3]
b = [1, 2, 3]
puts a == b  # Output: true

Sample Program

This program shows how to compare two arrays using intersection, union, difference, and equality.

Ruby

array1 = [1, 2, 3, 4]
array2 = [3, 4, 5, 6]

puts "Array 1: #{array1}"
puts "Array 2: #{array2}"

intersection = array1 & array2
union = array1 | array2
difference = array1 - array2
are_equal = array1 == array2

puts "\nIntersection (common items): #{intersection}"
puts "Union (all unique items): #{union}"
puts "Difference (items in array1 not in array2): #{difference}"
puts "Are arrays equal? #{are_equal}"

Important Notes

Time complexity for these operations depends on array size, usually O(n*m) for intersection and difference.

Space complexity is O(n + m) because new arrays are created for results.

Common mistake: Using == checks order and content, not just content. Use set operations for content comparison.

Use intersection when you want common items, difference to find missing items, and union to combine without duplicates.

Summary

Array comparison helps find common, different, or combined items between lists.

Use & for intersection, | for union, and - for difference.

Equality == checks if arrays have the same items in the same order.

Practice

1.

Which operator in Ruby returns the common elements between two arrays?

[1, 2, 3] ? [2, 3, 4]

easy

A. & (intersection)

B. | (union)

C. - (difference)

D. == (equality)

Solution

1. Step 1: Understand the operators

   The & operator returns elements common to both arrays.

2. Step 2: Apply to example arrays

   For arrays [1, 2, 3] and [2, 3, 4], common elements are 2 and 3.

3. Final Answer:

   & (intersection) -> Option A

4. Quick Check:

   Common elements = & [OK]

Hint: Use & for common items between arrays [OK]

Common Mistakes:

• Confusing union (|) with intersection (&)
• Using - for common elements
• Thinking == compares elements regardless of order

2.

Which of the following is the correct syntax to find the difference between two arrays a and b in Ruby?

easy

A. a == b

B. a - b

C. a | b

D. a & b

Solution

1. Step 1: Recall difference operator

   The - operator returns elements in a not in b.

2. Step 2: Confirm syntax correctness

   Using a - b is the correct Ruby syntax for difference.

3. Final Answer:

   a - b -> Option B

4. Quick Check:

   Difference = - [OK]

Hint: Use a - b to get items in a but not in b [OK]

Common Mistakes:

• Using & instead of - for difference
• Using | which is union
• Using == which checks equality

3.

What is the output of the following Ruby code?

a = [1, 2, 3, 4]
b = [3, 4, 5, 6]
result = a | b
puts result.inspect

medium

A. [1, 2, 3, 4, 5, 6]

B. [3, 4]

C. [1, 2]

D. [1, 2, 3, 4]

Solution

1. Step 1: Understand the union operator

   The | operator combines all unique elements from both arrays.

2. Step 2: Apply union to arrays

   Arrays a and b combined uniquely are [1, 2, 3, 4, 5, 6].

3. Final Answer:

   [1, 2, 3, 4, 5, 6] -> Option A

4. Quick Check:

   Union = | [OK]

Hint: Use | to combine unique elements from both arrays [OK]

Common Mistakes:

• Confusing union with intersection
• Expecting duplicates in output
• Using - which removes elements

4.

Identify the error in the following Ruby code snippet:

a = [1, 2, 3]
b = [2, 3, 4]
result = a & b
puts result

What is the problem?

medium

A. Syntax error due to missing parentheses

B. Outputs all elements from both arrays

C. Runtime error because & is not defined for arrays

D. No error; code runs and outputs common elements

Solution

1. Step 1: Check syntax and operators

   The & operator is valid for arrays to find intersection.

2. Step 2: Verify output behavior

   The code outputs common elements [2, 3] without error.

3. Final Answer:

   No error; code runs and outputs common elements -> Option D

4. Quick Check:

   Intersection & works fine [OK]

Hint: & works for arrays to find common items without syntax errors [OK]

Common Mistakes:

• Thinking & causes syntax error
• Expecting union instead of intersection
• Confusing output with difference

5.

You have two arrays representing user IDs:

active_users = [101, 102, 103, 104, 105]
inactive_users = [103, 105, 107]

Which Ruby expression gives you the list of users who are active but not inactive?

hard

A. active_users | inactive_users

B. active_users & inactive_users

C. active_users - inactive_users

D. active_users == inactive_users

Solution

1. Step 1: Understand the problem

   We want users in active_users but not in inactive_users.

2. Step 2: Use difference operator

   The - operator returns elements in first array not in second.

3. Step 3: Apply to given arrays

   active_users - inactive_users = [101, 102, 104]

4. Final Answer:

   active_users - inactive_users -> Option C

5. Quick Check:

   Difference = - [OK]

Hint: Use - to exclude inactive from active users [OK]

Common Mistakes:

• Using & which gives only common users
• Using | which combines all users
• Using == which checks equality