kata-algorithms 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e796ad4d1ba7ced44cbcb08c5d8e76609d0ebec8
-  data.tar.gz: 3450d795d0db2cc5d0a80256b75c9bbe987c68b3
+  metadata.gz: 11473fc1abab0c3f6e5347346160f5e3879f148a
+  data.tar.gz: cc880d1f93c92b66dc1ed15726c62e11a8349c29
 SHA512:
-  metadata.gz: cc7265967142ef4aea31e8375e394a048161bd497d03c4be830b61fff9305eb3fca31e31779d87d35292f6412be073f06a03c934c705e337a73ca584a6b0b366
-  data.tar.gz: 4972a622b67c9e11a9a6a9e4afead3e80e4522ce04eb1e8cbd57c5a7823b029976c75d593fb5c2dbcfc3cf6f8fedba1c0333b8c8548f2c27d31772082d704efe
+  metadata.gz: dedc8a276befadff2ac0bc9bb44733eb50df0c5f9d10360f5a161a4dc1d402813ed23be1e79407a9d4bdfc83ba48f296690d6b7312e89c26d786a7deba24eeba
+  data.tar.gz: 6c7797e1ec4d940e6a0da4c545173f0dc71c682987040438cb839c200079324365ae06e1dcf81246f2345a0dc1a1cb19e872c77b7883b8c8dce1754df974fba4

data/CHANGELOG

@@ -1 +1,3 @@
+v0.3.0 Added the sum of three algorithms
+
 v0.2.0 Added algorithms for calculating GCD

data/kata-algorithms.gemspec

@@ -16,8 +16,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ["lib", File.join('lib', 'kata'),
+                               File.join('lib', 'kata', 'algorithms'),
+                               File.join('lib', 'kata', 'algorithms', 'sum_of_three')]
 
+  spec.add_dependency 'json'
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rspec"
 end

data/lib/kata/algorithms.rb

@@ -1,4 +1,5 @@
 require "kata/algorithms/version"
+require "kata/algorithms/all"
 
 module Kata
   module Algorithms

data/lib/kata/algorithms/all.rb

@@ -0,0 +1,4 @@
+require 'sorting'
+require 'sum_of_three/sum_of_three'
+require 'sum_of_three/sum_of_three_hash'
+require 'sum_of_three/sum_of_three_sort'

data/lib/kata/algorithms/sorting.rb

@@ -0,0 +1,24 @@
+module Kata
+  module Algorithms
+    module Sorting
+      # @param array_to_sort [Array{Integer}]
+      # @return the same array sorted using insertion sort
+      #
+      def self.insertion_sort(array_to_sort)
+        return array_to_sort if array_to_sort.nil? || array_to_sort.size == 0 || array_to_sort.size == 1
+        i = 1
+        while i < array_to_sort.size
+          value = array_to_sort[i]
+          j = i - 1
+          while j >= 0 && array_to_sort[j] >= value
+            array_to_sort[j + 1] = array_to_sort[j]
+            j -= 1
+          end
+          array_to_sort[j+1] = value
+          i += 1
+        end
+        array_to_sort
+      end
+    end
+  end
+end

data/lib/kata/algorithms/sum_of_three/README.markdown

@@ -0,0 +1,30 @@
+SUM of 3
+========
+
+Problem
+-------
+Finding a 3 Integer Subset in Ruby.
+Write a function (with tests) that takes an unsorted integer array, and returns a three element subset whose sum is zero.
+
+Example result:
+
+[3, -2, 1, -1, 0, -2]  => [1, -1, 0] or [3, -2, -1]
+
+Solution
+--------
+
+Two implementations are provided.
+
+1. Uses a hash to store the positions of the integers
+2. Sorts the input array first
+
+Details and documentation can be found inside the corresponding ruby files that have the implementations
+
+Test
+----
+
+```
+bundle exec rspec
+```
+
+You can also edit the file `spec/example_data/examples.json` to set expectations

data/lib/kata/algorithms/sum_of_three/sum_of_three.rb

@@ -0,0 +1,9 @@
+module Kata
+  module Algorithms
+    class SumOfThree < Struct.new(:array_of_integers)
+      def find_three
+        raise NotImplementedError.new("You have to implement this")
+      end
+    end
+  end
+end

data/lib/kata/algorithms/sum_of_three/sum_of_three_hash.rb

@@ -0,0 +1,84 @@
+require 'sum_of_three'
+
+module Kata
+  module Algorithms
+    class SumOfThreeHash < Kata::Algorithms::SumOfThree
+      attr_accessor :integer_positions
+
+      def initialize(array_of_integers)
+        super
+        self.integer_positions = build_hash(array_of_integers)
+      end
+
+      # Tries to find 3 integers that sum up to 0.
+      # In other words given an array a, we want to find
+      # the 3 integers that satisfy the equation:
+      #
+      #    a[i] + a[j] + a[k] == 0
+      #
+      # where i != j && i != k && j !=k
+      #
+      # This equation can be equally written:
+      #
+      #   a[i] == - a[j] - a[k]
+      #
+      # Hence, we are looking for pairs of integers in
+      # a, let's say a[j] and a[k], that their (- a[j] - a[k]) is
+      # another integer in the array.
+      #
+      # The algorithm will use a hash to store the integers
+      # of the array and their position. Then it will iterate
+      # all the pairs j, k and will try to see whether their (-a[j]-a[k])
+      # is in the hash and in which position.
+      # One might say, why do we keep an array of positions of each integer and
+      # not just keep a true/false flag to indicate that the result exists in the
+      # hash. This is done to avoid cases in which (-a[j]-a[k]) == a[j] or (-a[j]-a[k]) == a[k]
+      # For example, if the initial array is [-4, 8, 5], then if we just build the hash
+      # h = {-4 => true, 8 => true, 5 => true}, for j == 0 and k == 1, the (-a[j]-a[k]) == (+4-8) == -4
+      # and -4 exists in the hash and we falsely get the result -4, -8, -4.
+      # If we know that -4 => [0] we can see that 0 is == j and does not count as a valid
+      # found position.
+      #
+      # Note that this algorithm average and worst case performance is O(n^2)
+      # Note also that seaching in a hash entry to find a position that is different from j, k at hand
+      # is now done with Array#index, which does linear search. If the initial array has a lot of duplicates the search might take long.
+      #
+      def find_three
+        j = 0
+        size_of_array = array_of_integers.size
+        while j < size_of_array
+          k = j + 1
+          while k < size_of_array
+            i = - array_of_integers[j] - array_of_integers[k]
+            hash_entry = integer_positions[i]
+            # there has to be at least one integer position in the hash_entry which is not j or k
+            return [array_of_integers[j], array_of_integers[k], i] unless hash_entry.nil? || hash_entry.index {|item| ![j, k].include?(item)}.nil?
+            k += 1
+          end
+          j += 1
+        end
+        []
+      end
+
+      private
+
+      # Needs to take the input array and create a hash with the
+      # positions an integer is found. So, for the array
+      #
+      #    array_of_integers = [3, 2, 8, 3]
+      #
+      # it will create the hash
+      #
+      #    integer_positions = {3 => [0, 3], 2 => [1], 8 => [2]}
+      #
+      def build_hash(array_of_integers)
+        integer_positions = {}
+        array_of_integers.each_with_index do |i, index|
+          integer_positions[i] = [] if integer_positions[i].nil?
+          integer_positions[i] << index
+        end
+        integer_positions
+      end
+    end
+  end
+end

data/lib/kata/algorithms/sum_of_three/sum_of_three_sort.rb

@@ -0,0 +1,76 @@
+require 'sum_of_three'
+
+module Kata
+  module Algorithms
+    class SumOfThreeSort < Kata::Algorithms::SumOfThree
+
+      def initialize(array_of_integers)
+        super
+      end
+
+      # Tries to find 3 integers that sum up to 0.
+      # In other words given an array a, we want to find
+      # the 3 integers that satisfy the equation:
+      #
+      #    a[i] + a[j] + a[k] == 0
+      #
+      # where i != j && i != k && j !=k
+      #
+      # The algorithm first sorts the input array, and then follows a clever algorithm that does not have to
+      # use any search for pairs.
+      #
+      # This is the pseudo-algorithm
+      #
+      #  sort(array_of_integers);
+      #
+      #  for i=0 to n-3 do
+      #    a = S[i];
+      #    j = i+1;
+      #    k = size_of_array - 1;
+      #    while (j < k) do
+      #      b = S[j];
+      #      c = S[k];
+      #      if (a + b + c == 0) then
+      #        return a, b, c; # This is the happy case and we stop
+      #      else if (a + b + c > 0) then
+      #        k = k - 1; # In this case, the b + c is big enough and we need to make it smaller. We know for sure that c is quite big
+      #                   # because it has been set as the value of the element that is on the far right, a.k.a. the biggest one.
+      #                   # So, let us try to use the previous element, which is smaller than c. Hence we will make the (b+c) factor
+      #                   # smaller and the (a + b + c) moving closer to 0.
+      #      else
+      #        j = j + 1; # In this case, the b + c is small enough so that the (a + b + c) < 0. We need to increase b + c but
+      #                   # not so much to go over 0. We need to increase it a little bit. That's why we decide to pick up the
+      #                   # next biggest element, which is j + 1.
+      #      end
+      #    end
+      #  end
+      #
+      def find_three
+        array_of_integers.sort!
+        i = 0
+        size_of_array = array_of_integers.size
+        while i <= size_of_array - 3
+          a = array_of_integers[i]
+          j = i + 1
+          k = size_of_array - 1
+
+          while j < k
+            b = array_of_integers[j]
+            c = array_of_integers[k]
+            sum = a + b + c
+            if sum == 0
+              return [a, b, c]
+            elsif sum > 0
+              k -= 1
+            else
+              j += 1
+            end
+          end
+
+          i += 1
+        end
+        []
+      end
+    end
+  end
+end

data/lib/kata/algorithms/version.rb

@@ -1,5 +1,5 @@
 module Kata
   module Algorithms
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/spec/example_data/examples.json

@@ -0,0 +1,12 @@
+{ "examples" :
+    [
+        {"input" : [],                            "possible_results" : [[]]                           },
+        {"input" : [1],                           "possible_results" : [[]]                           },
+        {"input" : [1, 2],                        "possible_results" : [[]]                           },
+        {"input" : [1, 2, 3],                     "possible_results" : [[]]                           },
+        {"input" : [3, -2, 1, -1, 0, -2],         "possible_results" : [[1, -1, 0], [3, -2, -1]]      },
+        {"input" : [0, 0, 0],                     "possible_results" : [[0, 0, 0]]                    },
+        {"input" : [1, 6, 1, 8, -2, -20, 133, 2], "possible_results" : [[1, 1, -2]]                   },
+        {"input" : [-10, 32, -100, 70, -60, -4],  "possible_results" : [[-10, 70, -60], [32, 10, -4]] }
+    ]
+}

data/spec/kata/algorithms/sorting_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Kata::Algorithms::Sorting do
+  subject {
+    Kata::Algorithms::Sorting
+  }
+  context 'when nil array of integers' do
+    let(:array_to_sort) { nil }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to be_nil
+    end
+  end
+  context 'when empty array of integers' do
+    let(:array_to_sort) { [] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to be_empty
+    end
+  end
+  context 'when array of integers with one element' do
+    let(:array_to_sort) { [3] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to eq(array_to_sort.sort)
+    end
+  end
+  context 'when array of integers case 1' do
+    let(:array_to_sort) { [5, 9, 3, 0, 15, 1, 2] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to eq(array_to_sort.sort)
+    end
+  end
+  context 'when array of integers case 2' do
+    let(:array_to_sort) { [1, 1] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to eq(array_to_sort.sort)
+    end
+  end
+  context 'when array of integers case 3' do
+    let(:array_to_sort) { [2, 1] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to eq(array_to_sort.sort)
+    end
+  end
+  context 'when array of integers case 4' do
+    let(:array_to_sort) { [5, 4, 3, 2, 1] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to eq(array_to_sort.sort)
+    end
+  end
+  context 'when array of integers case 5' do
+    let(:array_to_sort) { [5, 4, 3, 2, 1, 0, 1, 2, 3, 4] }
+    it 'sorts the array' do
+      expect(subject.insertion_sort(array_to_sort)).to eq(array_to_sort.sort)
+    end
+  end
+end

data/spec/kata/algorithms/sum_of_three/shared_examples.rb

@@ -0,0 +1,7 @@
+shared_examples "method that finds three integers summing up to zero" do
+  it { expect(example['possible_results'].map{|a| a.sort}).to include(sum_of_three.find_three.sort)}
+end
+
+shared_examples "method that builds the integer positions" do
+  it { expect(sum_of_three.send(:build_hash, example['input'])).to eq(example['result']) }
+end

data/spec/kata/algorithms/sum_of_three/sum_of_three_hash_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+require 'shared_examples'
+
+describe Kata::Algorithms::SumOfThreeHash do
+  describe '#find_three' do
+    examples = Kata::Algorithms::SpecHelper::SumOfThree.read_examples_for_find_three
+    examples.each do |exmpl|
+      context "from #{exmpl['input']}" do
+        it_behaves_like "method that finds three integers summing up to zero" do
+          let(:example) { exmpl }
+          let(:sum_of_three) { Kata::Algorithms::SumOfThreeHash.new(example['input'])}
+        end
+      end
+    end
+  end
+
+  describe '#build_hash' do
+    examples = [
+        {'input' => [],                            'result' => {                                                                                   }},
+        {'input' => [1],                           'result' => {1   => [0]                                                                         }},
+        {'input' => [1, 2],                        'result' => {1   => [0],      2 => [1]                                                          }},
+        {'input' => [1, 2, 3],                     'result' => {1   => [0],      2 => [1],    3 => [2]                                             }},
+        {'input' => [3, -2, 1, -1, 0, -2],         'result' => {3   => [0],     -2 => [1, 5], 1 => [2], -1 => [3],   0 => [4]                      }},
+        {'input' => [0, 0, 0],                     'result' => {0   => [0, 1, 2]                                                                   }},
+        {'input' => [1, 6, 1, 8, -2, -20, 133, 2], 'result' => {1   => [0, 2],   6 => [1],    8 => [3], -2 => [4], -20 => [5], 133 => [6], 2 => [7]}},
+        {'input' => [-10, 32, -100, 70, -60, -4],  'result' => {-10 => [0],     32 => [1], -100 => [2], 70 => [3], -60 => [4],  -4 => [5]          }}
+    ]
+    examples.each do |exmpl|
+      context "from #{exmpl['input']}" do
+        it_behaves_like "method that builds the integer positions" do
+          let(:example) { exmpl }
+          let(:sum_of_three) { Kata::Algorithms::SumOfThreeHash.new(example['input'])}
+        end
+      end
+    end
+  end
+end

data/spec/kata/algorithms/sum_of_three/sum_of_three_sort_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+require 'shared_examples'
+
+describe Kata::Algorithms::SumOfThreeSort do
+  describe '#find_three' do
+    examples = Kata::Algorithms::SpecHelper::SumOfThree.read_examples_for_find_three
+    examples.each do |exmpl|
+      context "from #{exmpl['input']}" do
+        it_behaves_like "method that finds three integers summing up to zero" do
+          let(:example) { exmpl }
+          let(:sum_of_three) { Kata::Algorithms::SumOfThreeSort.new(example['input'])}
+        end
+      end
+    end
+  end
+end

data/spec/kata/algorithms/sum_of_three/sum_of_three_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Kata::Algorithms::SumOfThree do
+  describe '#find_three' do
+    subject { Kata::Algorithms::SumOfThree.new([]) }
+    it { expect { subject.find_three }.to raise_error(NotImplementedError) }
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,6 @@
 require 'kata/algorithms'
+ROOT = File.expand_path(File.join(File.expand_path('..', __FILE__), '..'))
+$: << File.join(ROOT, 'spec', 'support')
+$: << File.join(ROOT, 'spec', 'kata', 'algorithms', 'sum_of_three')
+require 'read_examples'
 

data/spec/support/read_examples.rb

@@ -0,0 +1,18 @@
+require 'json'
+
+module Kata
+  module Algorithms
+    module SpecHelper
+      module SumOfThree
+        def self.read_examples(file_name)
+          file = File.read(file_name)
+          JSON.parse(file)['examples']
+        end
+
+        def self.read_examples_for_find_three
+          Kata::Algorithms::SpecHelper::SumOfThree.read_examples(File.join(ROOT, 'spec', 'example_data', 'examples.json'))
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: kata-algorithms
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Panayotis Matsinopoulos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-30 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -64,9 +78,22 @@ files:
 - bin/multiplication
 - kata-algorithms.gemspec
 - lib/kata/algorithms.rb
+- lib/kata/algorithms/all.rb
+- lib/kata/algorithms/sorting.rb
+- lib/kata/algorithms/sum_of_three/README.markdown
+- lib/kata/algorithms/sum_of_three/sum_of_three.rb
+- lib/kata/algorithms/sum_of_three/sum_of_three_hash.rb
+- lib/kata/algorithms/sum_of_three/sum_of_three_sort.rb
 - lib/kata/algorithms/version.rb
+- spec/example_data/examples.json
+- spec/kata/algorithms/sorting_spec.rb
+- spec/kata/algorithms/sum_of_three/shared_examples.rb
+- spec/kata/algorithms/sum_of_three/sum_of_three_hash_spec.rb
+- spec/kata/algorithms/sum_of_three/sum_of_three_sort_spec.rb
+- spec/kata/algorithms/sum_of_three/sum_of_three_spec.rb
 - spec/kata/algorithms_spec.rb
 - spec/spec_helper.rb
+- spec/support/read_examples.rb
 homepage: ''
 licenses:
 - MIT
@@ -75,6 +102,9 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- lib/kata
+- lib/kata/algorithms
+- lib/kata/algorithms/sum_of_three
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -93,5 +123,12 @@ specification_version: 4
 summary: A series of algorithms implementation. This is more of a practice while reading
   books about algorithms
 test_files:
+- spec/example_data/examples.json
+- spec/kata/algorithms/sorting_spec.rb
+- spec/kata/algorithms/sum_of_three/shared_examples.rb
+- spec/kata/algorithms/sum_of_three/sum_of_three_hash_spec.rb
+- spec/kata/algorithms/sum_of_three/sum_of_three_sort_spec.rb
+- spec/kata/algorithms/sum_of_three/sum_of_three_spec.rb
 - spec/kata/algorithms_spec.rb
 - spec/spec_helper.rb
+- spec/support/read_examples.rb