This page contains automated test results for code from O'Reilly's Ruby Cookbook. If this code looks interesting or useful, you might want to buy the whole book.

Partitioning or Classifying a Set
CodeExpectedActual
require 'set'
s = Set.new((1..10).collect)
 #<Set: {5, 6, 1, 7, 2, 8, 3, 9, 4, 10}> #<Set: {5, 6, 1, 7, 2, 8, 3, 9, 4, 10}> 
s.divide { |x| x < 5 }
 #<Set: {#<Set: {5, 6, 7, 8, 9, 10}>, #<Set: {1, 2, 3, 4}>}> #<Set: {#<Set: {5, 6, 7, 8, 9, 10}>, #<Set: {1, 2, 3, 4}>}> 
s.divide { |x| x % 2 }
 #<Set: {#<Set: {6, 2, 8, 4, 10}>, #<Set: {5, 1, 7, 3, 9}>}> #<Set: {#<Set: {5, 1, 7, 3, 9}>, #<Set: {6, 2, 8, 4, 10}>}> 
s = Set.new([1, 2, 3, 'a', 'b', 'c', -1.0, -2.0, -3.0])
 
Divide the set into the "String subset, the "Fixnum" subset, and the
"Float" subset.
 






s.divide { |x| x.class }

#<Set: {#<Set: {"a", "b", "c"}>,
#<Set: {#<Set: {"a", "b", "c"}>, #<Set: {1, 2, 3}>, #<Set: {-1.0, -3.0, -2.0}>}>





s = [1, 2, 3, -1, -2, -4].to_set


Divide the set into sets of numbers with the same absolute value.








s.divide { |x,y| x.abs == y.abs }

#<Set: {#<Set: {-1, 1}>,
#<Set: {#<Set: {-2, 2}>, #<Set: {-1, 1}>, #<Set: {3}>, #<Set: {-4}>}>





s.divide { |x,y| (x-y).abs == 1 }

#<Set: {#<Set: {1, 2, 3}>,
#<Set: {#<Set: {-2, -1}>, #<Set: {-4}>, #<Set: {1, 2, 3}>}>





s.classify { |x| x.class }

{String=>#<Set: {"a", "b", "c"}>,
{Fixnum=>#<Set: {-2, 1, -1, 2, 3, -4}>}





connections = { 1 => 2, 2 => 3, 3 => 1, 4 => 1 }
[1,2,3,4].to_set.divide { |x,y| connections[x] == y }

#<Set: {#<Set: {1, 2, 3}>, #<Set: {4}>}>
#<Set: {#<Set: {1, 2, 3}>, #<Set: {4}>}>





class Array
  def classify
    require 'set'
    h = {}
    each do |i|
      x = yield(i)
      (h[x] ||= self.class.new) << i
    end
    h
  end
  def divide(&block)
    Set.new(classify(&block).values)
  end
end
[1,1,2,6,6,7,101].divide { |x| x % 2 }

#<Set: {[2, 6, 6], [1, 1, 7, 101]}>
#<Set: {[2, 6, 6], [1, 1, 7, 101]}>





class Array
  def divide(&block)
    if block.arity == 2
      counts = inject({}) { |h, x| h[x] ||= 0; h[x] += 1; h}
      to_set.divide(&block).inject([]) do |divided, set|
        divided << set.inject([]) do |partition, e| 
          counts[e].times { partition << e }
          partition
        end
      end       
   else
      Set.new(classify(&block).values)
    end
  end
end
[1,1,2,6,6,7,101].divide { |x,y| (x-y).abs == 1 }

[[101], [1, 1, 2], [6, 6, 7]]
[[6, 6, 7], [101], [1, 1, 2]]