kata-algorithms 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90aac947c57fde27f904e20c09ae9276ae21f3b4
-  data.tar.gz: 0ebcc3abc31c17bfed448377b3dab7a38019c505
+  metadata.gz: e796ad4d1ba7ced44cbcb08c5d8e76609d0ebec8
+  data.tar.gz: 3450d795d0db2cc5d0a80256b75c9bbe987c68b3
 SHA512:
-  metadata.gz: e8ce09b15a615dc8c1f1af17fd194e760f48cc7ff4f61a7a5aac09ef828a97d5ec8cc692d00cf97c592ea3b5b6a6626c41a0caf8e6471020283214afa34f436c
-  data.tar.gz: 26624f7cfee3cec901b680c3477d52d5716beae2df75b97c1fda9cbbca2ec14a2ece0f53778b887fb5157edb07914249a9fd6e058fce3fba324c9c73135d3c0c
+  metadata.gz: cc7265967142ef4aea31e8375e394a048161bd497d03c4be830b61fff9305eb3fca31e31779d87d35292f6412be073f06a03c934c705e337a73ca584a6b0b366
+  data.tar.gz: 4972a622b67c9e11a9a6a9e4afead3e80e4522ce04eb1e8cbd57c5a7823b029976c75d593fb5c2dbcfc3cf6f8fedba1c0333b8c8548f2c27d31772082d704efe

data/CHANGELOG

@@ -0,0 +1 @@
+v0.2.0 Added algorithms for calculating GCD

data/bin/gcd_modulo

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "kata/algorithms"
+
+print "Give me the first number: "
+a = gets.strip.to_i
+
+print "Give me the second number: "
+b = gets.strip.to_i
+
+result = Kata::Algorithms.gcd_recursive_modulo(a, b)
+
+puts "Result is #{result}"
+
+

data/bin/gcd_recursive_modulo

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "kata/algorithms"
+
+print "Give me the first number: "
+a = gets.strip.to_i
+
+print "Give me the second number: "
+b = gets.strip.to_i
+
+result = Kata::Algorithms.gcd_recursive_modulo(a, b)
+
+puts "Result is #{result}"
+
+

data/bin/gcd_recursive_subtraction

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "kata/algorithms"
+
+print "Give me the first number: "
+a = gets.strip.to_i
+
+print "Give me the second number: "
+b = gets.strip.to_i
+
+result = Kata::Algorithms.gcd_recursive_subtraction(a, b)
+
+puts "Result is #{result}"
+
+

data/lib/kata/algorithms/version.rb

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

data/lib/kata/algorithms.rb

@@ -130,5 +130,84 @@ module Kata
       end
       result
     end
+
+    # GREATEST COMMON DIVISOR (recursive implementation with modulo)
+    # ======================= --------------------------------------
+    #
+    # We are using the Euclidean algorithm to calculate the GCD or Greatest Common Divisor.
+    # This is also called GCF (Greatest Common Factor) or HCF (Highest Common Factor).
+    #
+    # The algorithm goes as follows:
+    #
+    #    gcd(a, 0) is a
+    #    gcd(a, b) is equal to gcd(b, a mod b) - consider a >= b
+    #
+    # We are going to use a recursive call to implement it.
+    #
+    def self.gcd_recursive_modulo(a, b)
+      return b if a == 0
+      return a if b == 0
+      if a >= b
+        gcd_recursive_modulo(b, a % b)
+      else
+        gcd_recursive_modulo(a, b % a)
+      end
+    end
+
+    # GREATEST COMMON DIVISOR (recursive implementation with subtraction)
+    # ======================= -------------------------------------------
+    #
+    # We are using the Euclidean algorithm to calculate the GCD or Greatest Common Divisor.
+    # This is also called GCF (Greatest Common Factor) or HCF (Highest Common Factor).
+    #
+    # The algorithm goes as follows:
+    #
+    #    gcd(a, 0) is a
+    #    gcd(a, b) is equal to gcd(a - b, b) - consider a >= b
+    #
+    # We are going to use a recursive call to implement it.
+    #
+    def self.gcd_recursive_subtraction(a, b)
+      return b if a == 0
+      return a if b == 0
+      if a >= b
+        gcd_recursive_subtraction(a - b, b)
+      else
+        gcd_recursive_subtraction(b - a, a)
+      end
+    end
+
+    # GREATEST COMMON DIVISOR (implementation with modulo)
+    # ======================= ----------------------------
+    #
+    # We are using the Euclidean algorithm to calculate the GCD or Greatest Common Divisor.
+    # This is also called GCF (Greatest Common Factor) or HCF (Highest Common Factor).
+    #
+    # The algorithm goes as follows:
+    #
+    #   a |- b => quotient and remainder
+    #     if remainder == 0 then b is the GCD
+    #     else a = b, b = r
+    #     and repeat
+    #
+    def self.gcd_modulo(a, b)
+      return b if a == 0
+      return a if b == 0
+
+      if b > a
+        temp = b
+        b    = a
+        a    = temp
+      end
+      # now a >= b
+
+      r = a % b
+      while r > 0
+        a = b
+        b = r
+        r = a % b
+      end
+      b
+    end
   end
 end

data/spec/kata/algorithms_spec.rb

@@ -97,5 +97,131 @@ describe Kata::Algorithms do
       it { expect(subject.multiplication(a, b)).to eq((a.to_i * b.to_i).to_s) }
     end
   end
+  describe '.gcd_recursive_modulo' do
+    context 'when a is 48 and b is 18' do
+      let(:a) { 48 }
+      let(:b) { 18 }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(6) }
+    end
+    context 'when a is 100 and b is 50' do
+      let(:a) { 100 }
+      let(:b) { 50  }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(50) }
+    end
+    context 'when a is 10000 and b is 1' do
+      let(:a) { 1000 }
+      let(:b) { 1    }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(1) }
+    end
+    context 'when a is 8 and b is 12' do
+      let(:a) { 8  }
+      let(:b) { 12 }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(4) }
+    end
+    context 'when a is 54 and b is 24' do
+      let(:a) { 54 }
+      let(:b) { 24 }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(6) }
+    end
+    context 'when a is 18 and b is 84' do
+      let(:a) { 18 }
+      let(:b) { 84 }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(6) }
+    end
+    context 'when a is 48 and b is 180' do
+      let(:a) { 48  }
+      let(:b) { 180 }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(12) }
+    end
+    context 'when a is 1 and b is 1' do
+      let(:a) { 1 }
+      let(:b) { 1 }
+      it { expect(subject.gcd_recursive_modulo(a, b)).to eq(1) }
+    end
+  end
+  describe '.gcd_recursive_subtraction' do
+    context 'when a is 48 and b is 18' do
+      let(:a) { 48 }
+      let(:b) { 18 }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(6) }
+    end
+    context 'when a is 100 and b is 50' do
+      let(:a) { 100 }
+      let(:b) { 50  }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(50) }
+    end
+    context 'when a is 10000 and b is 1' do
+      let(:a) { 1000 }
+      let(:b) { 1    }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(1) }
+    end
+    context 'when a is 8 and b is 12' do
+      let(:a) { 8  }
+      let(:b) { 12 }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(4) }
+    end
+    context 'when a is 54 and b is 24' do
+      let(:a) { 54 }
+      let(:b) { 24 }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(6) }
+    end
+    context 'when a is 18 and b is 84' do
+      let(:a) { 18 }
+      let(:b) { 84 }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(6) }
+    end
+    context 'when a is 48 and b is 180' do
+      let(:a) { 48  }
+      let(:b) { 180 }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(12) }
+    end
+    context 'when a is 1 and b is 1' do
+      let(:a) { 1 }
+      let(:b) { 1 }
+      it { expect(subject.gcd_recursive_subtraction(a, b)).to eq(1) }
+    end
+  end
+  describe '.gcd_modulo' do
+    context 'when a is 48 and b is 18' do
+      let(:a) { 48 }
+      let(:b) { 18 }
+      it { expect(subject.gcd_modulo(a, b)).to eq(6) }
+    end
+    context 'when a is 100 and b is 50' do
+      let(:a) { 100 }
+      let(:b) { 50  }
+      it { expect(subject.gcd_modulo(a, b)).to eq(50) }
+    end
+    context 'when a is 10000 and b is 1' do
+      let(:a) { 1000 }
+      let(:b) { 1    }
+      it { expect(subject.gcd_modulo(a, b)).to eq(1) }
+    end
+    context 'when a is 8 and b is 12' do
+      let(:a) { 8  }
+      let(:b) { 12 }
+      it { expect(subject.gcd_modulo(a, b)).to eq(4) }
+    end
+    context 'when a is 54 and b is 24' do
+      let(:a) { 54 }
+      let(:b) { 24 }
+      it { expect(subject.gcd_modulo(a, b)).to eq(6) }
+    end
+    context 'when a is 18 and b is 84' do
+      let(:a) { 18 }
+      let(:b) { 84 }
+      it { expect(subject.gcd_modulo(a, b)).to eq(6) }
+    end
+    context 'when a is 48 and b is 180' do
+      let(:a) { 48  }
+      let(:b) { 180 }
+      it { expect(subject.gcd_modulo(a, b)).to eq(12) }
+    end
+    context 'when a is 1 and b is 1' do
+      let(:a) { 1 }
+      let(:b) { 1 }
+      it { expect(subject.gcd_modulo(a, b)).to eq(1) }
+    end
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kata-algorithms
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Panayotis Matsinopoulos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-29 00:00:00.000000000 Z
+date: 2013-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,17 +43,24 @@ email:
 - panayotis@matsinopoulos.gr
 executables:
 - addition
+- gcd_modulo
+- gcd_recursive_modulo
+- gcd_recursive_subtraction
 - multiplication
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - .rvmrc
+- CHANGELOG
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/addition
+- bin/gcd_modulo
+- bin/gcd_recursive_modulo
+- bin/gcd_recursive_subtraction
 - bin/multiplication
 - kata-algorithms.gemspec
 - lib/kata/algorithms.rb