divvy_up 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1f81d17ce9ba4eafe46a66f3aa25828e44499cc
-  data.tar.gz: 009551861b5cfd507505eba3496164a1a17890d9
+  metadata.gz: 7428ae33e30e958f738f5af7e4ae41fdd667774c
+  data.tar.gz: 7b499f0c387fc0f36dbc6b6119d0e7ec0f624986
 SHA512:
-  metadata.gz: 91fa9383f65ae1ebb2aff88ab916ea7c08e9a17c10d5d8bb7baaf25ff77ea0dd21d1194a5ba4ba36b101b8103c2f273ae1a8661aa43515fa65144ffd5ad42d5f
-  data.tar.gz: c5a48f2b4c21ce19510a7f00f2421f794c4e293e8aaa97a93ccfb5625760e77cb979a928d57ef0d9cb9526048faf7a1b07ef4bc281b57263c121df314b2c3e63
+  metadata.gz: 5d6402894878432babb2ed1c555fd042b1aeed327a7c11b7f7cc4fd579e7daaa7b531cdd9ed30759c39e73f94c0fddf04fce8cbfe72d3f9f41d04e113dfecac8
+  data.tar.gz: 31025cac7d76fbe7294fbb0fcb41f25b56d04fd33a274703e6e604977b84efecb9d84ecacea46ba445a534982a4d293ec041f9cf7c93214cde5b49394c81ed13

data/CHANGELOG.md

@@ -4,7 +4,9 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-- Your contribution here!
+## [0.1.1] - 2015-07-05
+### Fixed
+- Resolve error occurring in `#split` method for certain list and group number combinations
 
 ## [0.1.0] - 2015-07-04
 ### Changed
@@ -13,5 +15,6 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ## 0.0.1 - 2015-03-09
 - Initial release
 
-[unreleased]: https://github.com/djpowers/divvy_up/compare/v0.1.0...HEAD
+[unreleased]: https://github.com/djpowers/divvy_up/compare/v0.1.1...HEAD
+[0.1.1]: https://github.com/djpowers/divvy_up/compare/v0.0.1...v0.1.1
 [0.1.0]: https://github.com/djpowers/divvy_up/compare/v0.0.1...v0.1.0

data/lib/divvy_up/list.rb

@@ -7,27 +7,27 @@ module DivvyUp
     end
 
     def split(groups)
-      return [self.items] if groups == 1
-      determine_best_result(groups)
+      @groups = groups
+      return [self.items] if @groups == 1
+      determine_best_result
     end
 
     private
 
-    def permute(groups)
-      permutations = generate_list_permutations
-      permutation_price_differences = calculate_permutation_price_differences(permutations, groups)
-      sorted_price_differences = generate_list_combinations(permutation_price_differences)
-      list_possibilities = find_full_list(permutation_price_differences, sorted_price_differences)
-      calculate_list_totals(list_possibilities, groups)
+    def permute
+      sublists = sublist_permutations
+      price_differences = sublist_price_differences(sublists)
+      sublist_options_sorted = sort_sublist_options(price_differences)
+      output_final_sublists(sublist_options_sorted)
     end
 
-    def snake(groups)
+    def snake
       unassigned_items = self.items.sort_by { |item, price| price }.to_a
       permutations = []
-      groups.times { permutations << {} }
+      @groups.times { permutations << {} }
       until unassigned_items.empty? do
         permutations.each do |permutation|
-          permutation[unassigned_items.last.first] = unassigned_items.last.last
+          permutation[unassigned_items.last.first] = unassigned_items.last.last unless unassigned_items.empty?
           unassigned_items.pop
         end
         permutations.reverse_each do |permutation|
@@ -35,66 +35,62 @@ module DivvyUp
           unassigned_items.pop
         end
       end
-      calculate_list_totals(permutations, groups)
+      output_final_sublists(permutations)
     end
 
-    def price_is_right(groups)
+    def price_is_right
       unassigned_items = self.items.sort_by { |item, price| price }.to_a
       permutations = []
-      groups.times { permutations << {} }
+      @groups.times { permutations << {} }
       permutations.each do |permutation|
         total = 0
-        until total > target_amount(groups) || unassigned_items.empty? do
+        until total > target_amount || unassigned_items.empty? do
           next_item = unassigned_items.pop
           permutation[next_item.first] = next_item.last
           total = permutation.values.reduce(:+).nil? ? 0 : permutation.values.reduce(:+)
-          if total > target_amount(groups)
+          if total > target_amount
             permutation.delete(next_item.first)
             unassigned_items << next_item
           end unless permutation == permutations.last || permutation.count == 1
         end
       end
-      calculate_list_totals(permutations, groups)
+      output_final_sublists(permutations)
     end
 
-    def target_amount(divisor)
-      (self.items.values.reduce(:+) / divisor).round(2)
+    def target_amount
+      (self.items.values.reduce(:+) / @groups).round(2)
     end
 
-    def generate_list_permutations
-      permutations = []
+    def sublist_permutations
+      sublists = []
       self.items.keys.size.times do |n|
-        sets = self.items.keys.combination(n+1)
-        sets.each do |set|
-          permutations << set
-        end
+        self.items.keys.combination(n+1).collect {|x| sublists << x}
       end
-      permutations
+      sublists
     end
 
-    def calculate_permutation_price_differences(permutations, divisor)
-      permutation_price_differences = {}
+    def sublist_price_differences(permutations)
+      price_differences = {}
       permutations.each do |permutation|
         total = 0.0
         permutation.each_with_index do |item, n|
           total += self.items[item]
         end
-        permutation_price_differences[permutation] = (target_amount(divisor) - total).abs
+        price_differences[permutation] = (target_amount - total).abs
       end
-      permutation_price_differences
-    end
-
-    def generate_list_combinations(permutation_price_differences)
-      permutation_price_differences.values.sort
+      price_differences
     end
 
-    def find_full_list(permutation_price_differences, sorted_price_differences)
+    def sort_sublist_options(price_differences)
       list = []
+      sorted_price_differences = price_differences.values.sort
       sorted_price_differences.each do |difference|
         if sorted_price_differences.count(difference) == 1
-          list << permutation_price_differences.key(difference)
+          list << price_differences.key(difference)
         else
-          permutation_price_differences.find_all{|k,v| v == difference}.map(&:first).each do |permutation|
+          price_differences.find_all do |k,v|
+            v == difference
+          end.map(&:first).each do |permutation|
             list << permutation
           end
           sorted_price_differences.delete(difference)
@@ -102,47 +98,46 @@ module DivvyUp
       end
       flattened_list = list.flatten
       if self.items.keys.sort == flattened_list.uniq.sort
-        output = []
+        sublist_options_sorted = []
         list.each do |sublist|
           item_price = {}
           sublist.each do |item|
             item_price[item] = self.items[item]
           end
-          output << item_price
+          sublist_options_sorted << item_price
         end
       end
-      output
+      sublist_options_sorted
     end
 
-    def calculate_list_totals(lists, groups)
-      output = []
+    def output_final_sublists(sublist_options_sorted)
+      sublists = []
       accounted_items = []
-      until output.size == groups
-        lists.each do |list|
+      until sublists.size == @groups
+        sublist_options_sorted.each do |list|
           if (accounted_items & list.keys).empty?
-            output << [list, (list.values.reduce(:+)).round(2)]
+            sublists << [list, (list.values.reduce(:+)).round(2)]
             accounted_items << list.keys
             accounted_items.flatten!
           end
         end
       end
-      output
+      sublists
     end
 
-    def determine_best_result(groups)
-      permute_result = permute(groups)
-      snake_result = snake(groups)
-      price_is_right_result = price_is_right(groups)
+    def determine_best_result
+      permute_result = permute
+      snake_result = snake
+      price_is_right_result = price_is_right
       results = [permute_result, snake_result, price_is_right_result]
-      target = target_amount(groups)
       result_differences = []
       results.each do |result|
         result_totals = []
         result.each do |list|
           result_totals << list.last
         end
-        min_difference = (result_totals.min - target).abs
-        max_difference = (result_totals.max - target).abs
+        min_difference = (result_totals.min - target_amount).abs
+        max_difference = (result_totals.max - target_amount).abs
         result_differences << (min_difference > max_difference ? min_difference : max_difference)
       end
       results[result_differences.index(result_differences.min)]

data/lib/divvy_up/version.rb

@@ -1,3 +1,3 @@
 module DivvyUp
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/divvy_up/list_spec.rb

@@ -76,5 +76,16 @@ module DivvyUp
         ]
       )
     end
+
+    it "splits a large list into three groups" do
+      shopping_list = { orange_juice: 3, eggs_dozen_1: 2.99, eggs_dozen_2: 2.99, frozen_strawberries: 2.99, spring_mix: 4.99, bacon: 4.99, onion: 1.25, rasberries: 3.99, paper_towels: 1.59 }
+      list = DivvyUp::List.new(shopping_list)
+      expect(list.split(2)).to eql(
+        [
+          [{orange_juice: 3, spring_mix: 4.99, bacon: 4.99, onion: 1.25}, 14.23],
+          [{eggs_dozen_1: 2.99, eggs_dozen_2: 2.99, frozen_strawberries: 2.99, rasberries: 3.99, paper_towels: 1.59}, 14.55]
+        ]
+      )
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: divvy_up
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dave Powers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-04 00:00:00.000000000 Z
+date: 2015-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler