Python Set Operations: Building Blocks of Data Management

Sets are fundamental data structures in computer science, providing efficient ways to store unique elements and perform operations like union, intersection, and difference. This challenge will test your understanding of these operations by requiring you to implement them from scratch for custom list-based "sets."

Problem Description

You are tasked with creating a Python class, CustomSet, that mimics the behavior of Python's built-in set data structure. Your CustomSet class should represent a set using a Python list internally, ensuring that no duplicate elements are stored. You will then implement several key set operations: union, intersection, and difference.

Key Requirements:

1. CustomSet Class:

   • Initialize with an optional iterable (e.g., list, tuple) to populate the set.
   • Ensure that the internal representation of the set (a list) contains only unique elements. If duplicates are provided during initialization, they should be automatically handled.
   • Implement a __str__ method to return a user-friendly string representation of the set, similar to Python's built-in sets (e.g., {1, 2, 3}).
   • Implement an __eq__ method to compare two CustomSet instances for equality. Two sets are equal if they contain the same elements, regardless of order.

2. Set Operations:

   • union(other_set): Returns a new CustomSet containing all elements from both self and other_set.
   • intersection(other_set): Returns a new CustomSet containing only elements that are present in both self and other_set.
   • difference(other_set): Returns a new CustomSet containing elements that are in self but not in other_set.

Expected Behavior:

• When initializing CustomSet with duplicates, the duplicates should be ignored.
• Set operations should return new CustomSet objects and not modify the original sets.
• The order of elements in the string representation does not strictly matter, but it should be consistent for the same set.
• Comparisons for equality should be order-independent.

Edge Cases:

• Initializing CustomSet with an empty iterable.
• Performing operations between an empty set and a non-empty set.
• Performing operations between two empty sets.
• Sets containing elements of different data types (though the core operations should still work if elements are comparable).

Examples

Example 1: Initialization and Basic Operations

set1 = CustomSet([1, 2, 3, 2, 4])
set2 = CustomSet([3, 4, 5, 6])

print(set1)
# Expected Output: {1, 2, 3, 4} (or any permutation like {4, 1, 3, 2})

print(set2)
# Expected Output: {3, 4, 5, 6} (or any permutation)

union_set = set1.union(set2)
print(union_set)
# Expected Output: {1, 2, 3, 4, 5, 6} (or any permutation)

intersection_set = set1.intersection(set2)
print(intersection_set)
# Expected Output: {3, 4} (or {4, 3})

difference_set = set1.difference(set2)
print(difference_set)
# Expected Output: {1, 2} (or {2, 1})

Explanation: set1 is initialized, duplicates of 2 are removed. set2 is initialized. The union combines all unique elements from both sets. The intersection finds common elements. The difference finds elements unique to set1 when compared against set2.

Example 2: Equality and Empty Sets

set3 = CustomSet([1, 2, 3])
set4 = CustomSet([3, 1, 2])
set5 = CustomSet([1, 2])
empty_set = CustomSet()

print(set3 == set4)
# Expected Output: True

print(set3 == set5)
# Expected Output: False

print(set3.union(empty_set))
# Expected Output: {1, 2, 3} (or any permutation)

print(empty_set.intersection(set3))
# Expected Output: {}

print(set3.difference(empty_set))
# Expected Output: {1, 2, 3} (or any permutation)

Explanation: set3 and set4 are equal because they contain the same elements, despite the different order. set3 and set5 are not equal as they have different elements. Operations involving an empty set demonstrate how they behave correctly.

Constraints

• The internal representation of a CustomSet should be a Python list.
• The operations (union, intersection, difference) should return new CustomSet objects.
• The number of elements in any given set will not exceed 1000.
• The elements within a set can be any hashable Python type (e.g., integers, strings, tuples).
• The time complexity for initialization should be as efficient as possible, ideally O(N) where N is the number of elements in the input iterable.
• Set operations (union, intersection, difference) should aim for an average time complexity of O(N+M) or better, where N and M are the sizes of the two sets involved.

Notes

• Consider how to efficiently check for the existence of an element in your internal list to prevent duplicates and for performing set operations.
• The __str__ method should produce a consistent, readable output. You might want to sort the elements before stringifying for predictability, though it's not strictly required by the problem description.
• The __eq__ method is crucial for testing your set equality. Think about how to compare two lists of unique elements for equality, irrespective of their order.