Avatar of w1zeman1p

w1zeman1p's solution

to Custom Set in the Ruby Track

Published at Jul 13 2018 · 0 comments
Instructions
Test suite
Solution

Note:

This solution was written on an old version of Exercism. The tests below might not correspond to the solution code, and the exercise may have changed since this code was written.

Create a custom set type.

Sometimes it is necessary to define a custom data structure of some type, like a set. In this exercise you will define your own set. How it works internally doesn't matter, as long as it behaves like a set of unique elements.


For installation and learning resources, refer to the exercism help page.

For running the tests provided, you will need the Minitest gem. Open a terminal window and run the following command to install minitest:

gem install minitest

If you would like color output, you can require 'minitest/pride' in the test file, or note the alternative instruction, below, for running the test file.

Run the tests from the exercise directory using the following command:

ruby custom_set_test.rb

To include color from the command line:

ruby -r minitest/pride custom_set_test.rb

Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

custom_set_test.rb

require 'minitest/autorun'
require_relative 'custom_set'

# Common test data version: 1.0.1 4527635
class CustomSetTest < Minitest::Test
  def test_sets_with_no_elements_are_empty
    # skip
    set = CustomSet.new []
    assert_empty set
  end

  def test_sets_with_elements_are_not_empty
    skip
    set = CustomSet.new [1]
    refute_empty set
  end

  def test_nothing_is_contained_in_an_empty_set
    skip
    set = CustomSet.new []
    element = 1
    refute set.member? element
  end

  def test_when_the_element_is_in_the_set
    skip
    set = CustomSet.new [1, 2, 3]
    element = 1
    assert set.member? element
  end

  def test_when_the_element_is_not_in_the_set
    skip
    set = CustomSet.new [1, 2, 3]
    element = 4
    refute set.member? element
  end

  def test_empty_set_is_a_subset_of_another_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new []
    assert set1.subset? set2
  end

  def test_empty_set_is_a_subset_of_non_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new [1]
    assert set1.subset? set2
  end

  def test_non_empty_set_is_not_a_subset_of_empty_set
    skip
    set1 = CustomSet.new [1]
    set2 = CustomSet.new []
    refute set1.subset? set2
  end

  def test_set_is_a_subset_of_set_with_exact_same_elements
    skip
    set1 = CustomSet.new [1, 2, 3]
    set2 = CustomSet.new [1, 2, 3]
    assert set1.subset? set2
  end

  def test_set_is_a_subset_of_larger_set_with_same_elements
    skip
    set1 = CustomSet.new [1, 2, 3]
    set2 = CustomSet.new [4, 1, 2, 3]
    assert set1.subset? set2
  end

  def test_set_is_not_a_subset_of_set_that_does_not_contain_its_elements
    skip
    set1 = CustomSet.new [1, 2, 3]
    set2 = CustomSet.new [4, 1, 3]
    refute set1.subset? set2
  end

  def test_the_empty_set_is_disjoint_with_itself
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new []
    assert set1.disjoint? set2
  end

  def test_empty_set_is_disjoint_with_non_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new [1]
    assert set1.disjoint? set2
  end

  def test_non_empty_set_is_disjoint_with_empty_set
    skip
    set1 = CustomSet.new [1]
    set2 = CustomSet.new []
    assert set1.disjoint? set2
  end

  def test_sets_are_not_disjoint_if_they_share_an_element
    skip
    set1 = CustomSet.new [1, 2]
    set2 = CustomSet.new [2, 3]
    refute set1.disjoint? set2
  end

  def test_sets_are_disjoint_if_they_share_no_elements
    skip
    set1 = CustomSet.new [1, 2]
    set2 = CustomSet.new [3, 4]
    assert set1.disjoint? set2
  end

  def test_empty_sets_are_equal
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new []
    assert_equal set1, set2
  end

  def test_empty_set_is_not_equal_to_non_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new [1, 2, 3]
    refute_equal set1, set2
  end

  def test_non_empty_set_is_not_equal_to_empty_set
    skip
    set1 = CustomSet.new [1, 2, 3]
    set2 = CustomSet.new []
    refute_equal set1, set2
  end

  def test_sets_with_the_same_elements_are_equal
    skip
    set1 = CustomSet.new [1, 2]
    set2 = CustomSet.new [2, 1]
    assert_equal set1, set2
  end

  def test_sets_with_different_elements_are_not_equal
    skip
    set1 = CustomSet.new [1, 2, 3]
    set2 = CustomSet.new [1, 2, 4]
    refute_equal set1, set2
  end

  def test_add_to_empty_set
    skip
    set = CustomSet.new []
    expected = CustomSet.new [3]
    assert_equal expected, set.add(3)
  end

  def test_add_to_non_empty_set
    skip
    set = CustomSet.new [1, 2, 4]
    expected = CustomSet.new [1, 2, 3, 4]
    assert_equal expected, set.add(3)
  end

  def test_adding_an_existing_element_does_not_change_the_set
    skip
    set = CustomSet.new [1, 2, 3]
    expected = CustomSet.new [1, 2, 3]
    assert_equal expected, set.add(3)
  end

  def test_intersection_of_two_empty_sets_is_an_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new []
    expected = CustomSet.new []
    assert_equal expected, set2.intersection(set1)
  end

  def test_intersection_of_an_empty_set_and_non_empty_set_is_an_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new [3, 2, 5]
    expected = CustomSet.new []
    assert_equal expected, set2.intersection(set1)
  end

  def test_intersection_of_a_non_empty_set_and_an_empty_set_is_an_empty_set
    skip
    set1 = CustomSet.new [1, 2, 3, 4]
    set2 = CustomSet.new []
    expected = CustomSet.new []
    assert_equal expected, set2.intersection(set1)
  end

  def test_intersection_of_two_sets_with_no_shared_elements_is_an_empty_set
    skip
    set1 = CustomSet.new [1, 2, 3]
    set2 = CustomSet.new [4, 5, 6]
    expected = CustomSet.new []
    assert_equal expected, set2.intersection(set1)
  end

  def test_intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements
    skip
    set1 = CustomSet.new [1, 2, 3, 4]
    set2 = CustomSet.new [3, 2, 5]
    expected = CustomSet.new [2, 3]
    assert_equal expected, set2.intersection(set1)
  end

  def test_difference_of_two_empty_sets_is_an_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new []
    expected = CustomSet.new []
    assert_equal expected, set1.difference(set2)
  end

  def test_difference_of_empty_set_and_non_empty_set_is_an_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new [3, 2, 5]
    expected = CustomSet.new []
    assert_equal expected, set1.difference(set2)
  end

  def test_difference_of_a_non_empty_set_and_an_empty_set_is_the_non_empty_set
    skip
    set1 = CustomSet.new [1, 2, 3, 4]
    set2 = CustomSet.new []
    expected = CustomSet.new [1, 2, 3, 4]
    assert_equal expected, set1.difference(set2)
  end

  def test_difference_of_two_non_empty_sets_is_a_set_of_elements_that_are_only_in_the_first_set
    skip
    set1 = CustomSet.new [3, 2, 1]
    set2 = CustomSet.new [2, 4]
    expected = CustomSet.new [1, 3]
    assert_equal expected, set1.difference(set2)
  end

  def test_union_of_empty_sets_is_an_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new []
    expected = CustomSet.new []
    assert_equal expected, set1.union(set2)
  end

  def test_union_of_an_empty_set_and_non_empty_set_is_the_non_empty_set
    skip
    set1 = CustomSet.new []
    set2 = CustomSet.new [2]
    expected = CustomSet.new [2]
    assert_equal expected, set1.union(set2)
  end

  def test_union_of_a_non_empty_set_and_empty_set_is_the_non_empty_set
    skip
    set1 = CustomSet.new [1, 3]
    set2 = CustomSet.new []
    expected = CustomSet.new [1, 3]
    assert_equal expected, set1.union(set2)
  end

  def test_union_of_non_empty_sets_contains_all_unique_elements
    skip
    set1 = CustomSet.new [1, 3]
    set2 = CustomSet.new [2, 3]
    expected = CustomSet.new [3, 2, 1]
    assert_equal expected, set1.union(set2)
  end

  # Problems in exercism evolve over time, as we find better ways to ask
  # questions.
  # The version number refers to the version of the problem you solved,
  # not your solution.
  #
  # Define a constant named VERSION inside of the top level BookKeeping
  # module, which may be placed near the end of your file.
  #
  # In your file, it will look like this:
  #
  # module BookKeeping
  #   VERSION = 1 # Where the version number matches the one in the test.
  # end
  #
  # If you are curious, read more about constants on RubyDoc:
  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html

  def test_bookkeeping
    skip
    assert_equal 1, BookKeeping::VERSION
  end
end
class CustomSet

  def initialize(list=[])
    @data = {}
    list.each { |el| data[el] = true }
  end

  def put(element)
    data[element] = true
    self
  end

  def delete(element)
    data[element] = false
    self
  end

  def empty
    @data = {}
    self
  end

  def to_a
    data.to_a.select(&:last).map(&:first)
  end

  def ==(other)
    to_a.sort == other.to_a.sort
  end

  def size
    to_a.count
  end

  def difference(other)
    CustomSet.new(to_a - other.to_a)
  end

  def intersection(other)
    CustomSet.new(to_a & other.to_a)
  end

  def union(other)
    CustomSet.new(to_a | other.to_a)
  end

  def disjoint?(other)
    intersection(other).empty?
  end

  def member?(element)
    data[element]
  end

  def subset?(other)
    intersection_size = intersection(other).size
    intersection_size == other.size && intersection_size <= size
  end

  def empty?
    to_a.empty?
  end

  private

  attr_reader :data
end

Community comments

Find this solution interesting? Ask the author a question to learn more.

What can you learn from this solution?

A huge amount can be learned from reading other people’s code. This is why we wanted to give exercism users the option of making their solutions public.

Here are some questions to help you reflect on this solution and learn the most from it.

  • What compromises have been made?
  • Are there new concepts here that you could read more about to improve your understanding?