algorithmable 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d896f5d72bec04a61e50d79c670e1ed9379b8cd
-  data.tar.gz: 701a49b6cb2d478a817baaef1ce743498a62813b
+  metadata.gz: e0f425945316b488e5f78067168f54dd56415392
+  data.tar.gz: c9dd9353cf0883de156a9860472d18233c227ea2
 SHA512:
-  metadata.gz: 45b738fc98edaaf14ee58050bdf24f8d78345fcda7b6d06394d1d6d9cc26dbb9151ea6832f27a3fd05d4906b1c9e80e7fb3d2684e70080574edb1aeacf12e4ab
-  data.tar.gz: 404eca38ab9c2775ba3f07d6760f2f37cbf303d5b59f36bbbf6fc03af59abe028d3b8bed31ada0c2b747f15eb5eefa92fec78cad1a0bbdaaa9e4c94b0446acfb
+  metadata.gz: 6fd0bb3ef1d1f3fe956aaa0fce478fcd1dc474d54b02ea86619802873ab620d181f3e49c7fefaf86c805fdd917f69e00d5a2e6f50f5971d97afb2462a91d62af
+  data.tar.gz: 5bdbf61cfb48f980c4d3d3721b7fc48a3f2c6aa26a249753b27bae965e83b41886855cbdae5e5b5904cbc621a3ee03456b826ee0e9345c1b59e338340dee923e

data/README.md

@@ -25,7 +25,7 @@ Library also contains solutions for several puzzles solved by implemented algori
 ## Graph Traversals
 
 - Breadth First Search (BFS)
-- Death First Search (DFS)
+- Depth First Search (DFS)
 
 ## Search Algorithms
 

data/lib/algorithmable/data_structs/bag.rb

@@ -37,6 +37,7 @@ module Algorithmable
           @succ.each(&block) if @succ
         end
       end
+      private_constant :Node
     end
   end
 end

data/lib/algorithmable/data_structs/deque.rb

@@ -1,10 +1,11 @@
 module Algorithmable
   module DataStructs
     class Deque
-      include Enumerable
       include Algorithmable::Errors
 
       Node = Struct.new(:prev, :next, :item)
+      private_constant :Node
+
       attr_reader :size
 
       def initialize(collection = [])
@@ -89,23 +90,37 @@ module Algorithmable
       end
 
       # represent fifo iterator
-      def each
-        return unless @front
-        node = @front
-        while node
-          yield node.item
-          node = node.next
-        end
+      def each(&block)
+        collect_items(:forward).each(&block)
       end
 
       # represent lifo iterator
-      def reverse_each
-        return unless @back
-        node = @back
-        while node
-          yield node.item
-          node = node.prev
+      def reverse_each(&block)
+        collect_items(:backward).each(&block)
+      end
+
+      def to_a
+        each.to_a
+      end
+
+      def map(&block)
+        each.map(&block)
+      end
+
+      private
+
+      def collect_items(order)
+        variable = order == :backward ? @back : @front
+        action = order == :backward ? :prev : :next
+        items = []
+        if variable
+          node = variable
+          while node
+            items << node.item
+            node = node.public_send action
+          end
         end
+        items
       end
     end
   end

data/lib/algorithmable/data_structs/linked_list.rb

@@ -95,6 +95,7 @@ module Algorithmable
           @succ = succ
         end
       end
+      private_constant :Node
     end
   end
 end

data/lib/algorithmable/data_structs/ordered_symbol_table.rb

@@ -1,239 +1,13 @@
 module Algorithmable
   module DataStructs
-    # 
-    # Ordered Symbol Table. Implementation using Unbalanced Binary Tree.
-    #
     class OrderedSymbolTable
-      def initialize(key_type, value_type)
-        @key_type = key_type
-        @value_type = value_type
-        @root = nil
-      end
-
-      def empty?
-        !size.nonzero?
-      end
-
-      def size
-        node_size(@root)
-      end
-
-      def key?(key)
-        assert_key_type(key)
-        !self[key].nil?
-      end
-
-      def [](key)
-        assert_key_type(key)
-        impl_get(@root, key)
-      end
-
-      def []=(key, value)
-        assert_value_type(value)
-        assert_key_type(key)
-        delete key
-        @root = impl_put(@root, key, value)
-        check_tree
-      end
-
-      def delete_min
-        @root = impl_delete_min @root
-        check_tree
-      end
-
-      def delete_max
-        @root = impl_delete_max @root
-        check_tree
-      end
-
-      def delete(key)
-        assert_key_type(key)
-        @root = impl_delete(@root, key)
-        check_tree
-      end
-
-      def min
-        impl_min(@root).key
-      end
-
-      def max
-        impl_max(@root).key
-      end
-
-      def floor(key)
-        assert_key_type(key)
-        return unless key || empty?
-        found = impl_floor(@root, key)
-        return unless found
-        found.key
-      end
-
-      def ceiling(key)
-        assert_key_type(key)
-        return unless key || empty?
-        found = impl_ceiling(@root, key)
-        return unless found
-        found.key
-      end
-
-      def select(integer)
-        return if integer < 0 || integer >= size
-        found = impl_select(@root, integer)
-        found.key
-      end
-
-      def rank(key)
-        assert_key_type(key)
-        return unless key
-        impl_rank @root, key
-      end
-
-      private
-
-      def check_tree
-        true
-      end
-
-      def assert_value_type(value)
-        fail "Type expectation not met. Use value type `#{@value_type}` instead." unless value.is_a? @value_type
-      end
-
-      def assert_key_type(key)
-        fail "Type expectation not met. Use key type `#{@key_type}` instead." unless key.is_a? @key_type
-      end
-
-      def impl_rank(node, key)
-        return 0 unless node
-        comparison = key <=> node.key
-        if comparison < 0
-          impl_rank(node.left, key)
-        elsif comparison > 0
-          1 + node_size(node.left) + impl_rank(node.right, key)
-        else
-          node_size node.left
-        end
-      end
-
-      def impl_select(node, index)
-        return unless node
-        left_size = node_size(node.left)
-        if left_size > index
-          impl_select(node.left, index)
-        elsif left_size < index
-          impl_select node.right, (index - left_size - 1)
-        else
-          node
-        end
-      end
-
-      def impl_ceiling(node, key)
-        return unless node
-        comparison = key <=> node.key
-        return node if 0 == comparison
-        if comparison < 0
-          found = impl_ceiling(node.left, key)
-          return found if found
-          return node
-        end
-        impl_ceiling node.right, key
-      end
-
-      def impl_floor(node, key)
-        return unless node
-        comparison = key <=> node.key
-        return node if 0 == comparison
-        return impl_floor(node.left, key) if comparison < 0
-        found = impl_floor(node.right, key)
-        return found if found
-        node
-      end
-
-      def impl_delete(node, key)
-        return unless node
-        comparison = key <=> node.key
-        if comparison < 0
-          node.left = impl_delete(node.left, key)
-        elsif comparison > 0
-          node.right = impl_delete(node.right, key)
-        else
-          return unless node.left || node.right
-          temp = node
-          node = impl_min(temp.right)
-          node.right = impl_delete_min(temp.right)
-          node.left = temp.left
-        end
-        node.size = computed_node_size(node)
-        node
-      end
-
-      def impl_max(node)
-        return node unless node.right
-        impl_max node.right
-      end
-
-      def impl_min(node)
-        return node unless node.left
-        impl_min node.left
-      end
-
-      def impl_delete_max(node)
-        return node.left unless node.right
-        node.right = impl_delete_max(node.right)
-        node.size = computed_node_size(node)
-        node
-      end
-
-      def impl_delete_min(node)
-        return node.right unless node.left
-        node.left = impl_delete_min(node.left)
-        node.size = computed_node_size(node)
-        node
-      end
-
-      def impl_put(node, key, value)
-        return Node.new(key, value, 1) unless node
-        comparison = key <=> node.key
-        if comparison < 0
-          node.left = impl_put(node.left, key, value)
-        elsif comparison > 0
-          node.right = impl_put(node.right, key, value)
-        else
-          node.value = value
-        end
-        node.size = computed_node_size(node)
-        node
-      end
-
-      def impl_get(node, key)
-        return unless node
-        comparison = key <=> node.key
-        if comparison < 0
-          impl_get(node.left, key)
-        elsif comparison > 0
-          impl_get(node.right, key)
-        else
-          node.value
-        end
-      end
-
-      def node_size(node)
-        node.nil? ? 0 : node.size
-      end
-
-      def computed_node_size(node)
-        1 + node_size(node.left) + node_size(node.right)
-      end
+      extend Forwardable
 
-      class Node
-        attr_accessor :key, :value, :left, :right, :size
+      def_delegators :@imp, :[]=, :[], :key?, :empty?, :size, :keys, :max, :min, :floor, :ceiling, :rank, :delete
 
-        def initialize(key = nil, value = nil, size = 0)
-          @key = key
-          @value = value
-          @left = nil
-          @right = nil
-          @size = size
-        end
+      def initialize(key_type, value_type)
+        search_strategy_factory = Object.new.extend Algorithmable::Searches
+        @imp = search_strategy_factory.new_binary_search_tree(key_type, value_type)
       end
     end
   end

data/lib/algorithmable/data_structs/queue.rb

@@ -2,10 +2,9 @@ module Algorithmable
   module DataStructs
     class Queue
       include Algorithmable::Errors
-      include Enumerable
       extend Forwardable
 
-      def_delegators :@imp, :empty?, :size, :each
+      def_delegators :@imp, :empty?, :size, :each, :map, :to_a
 
       def initialize(collection = [])
         @imp = Deque.new collection

data/lib/algorithmable/data_structs/stack.rb

@@ -2,10 +2,9 @@ module Algorithmable
   module DataStructs
     class Stack
       include Algorithmable::Errors
-      include Enumerable
       extend Forwardable
 
-      def_delegators :@imp, :empty?, :size, :each
+      def_delegators :@imp, :empty?, :size, :each, :map, :to_a
 
       def initialize(collection = [])
         @imp = Deque.new

data/lib/algorithmable/search/{binary.rb → binary_search.rb}

@@ -1,6 +1,6 @@
 module Algorithmable
-  module Search
-    class Binary
+  module Searches
+    class BinarySearch
       def self.lookup(element, in_collection)
         new.lookup(element, in_collection)
       end

data/lib/algorithmable/search/binary_search_tree.rb

@@ -0,0 +1,291 @@
+module Algorithmable
+  module Searches
+    class BinarySearchTree
+      def initialize(key_type, value_type)
+        @key_type = key_type
+        @value_type = value_type
+        @root = nil
+      end
+
+      def empty?
+        !size.nonzero?
+      end
+
+      def size
+        node_size(@root)
+      end
+
+      def key?(key)
+        assert_key_type(key)
+        !self[key].nil?
+      end
+
+      def [](key)
+        assert_key_type(key)
+        impl_get(@root, key)
+      end
+
+      def []=(key, value)
+        assert_value_type(value)
+        assert_key_type(key)
+        delete key
+        @root = impl_put(@root, key, value)
+        check_tree_consistency
+      end
+
+      def delete_min
+        @root = impl_delete_min @root
+        check_tree_consistency
+      end
+
+      def delete_max
+        @root = impl_delete_max @root
+        check_tree_consistency
+      end
+
+      def delete(key)
+        assert_key_type(key)
+        @root = impl_delete(@root, key)
+        check_tree_consistency
+      end
+
+      def min
+        return if empty?
+        impl_min(@root).key
+      end
+
+      def max
+        return if empty?
+        impl_max(@root).key
+      end
+
+      def floor(key)
+        assert_key_type(key)
+        return unless key || empty?
+        found = impl_floor(@root, key)
+        return unless found
+        found.key
+      end
+
+      def ceiling(key)
+        assert_key_type(key)
+        return unless key || empty?
+        found = impl_ceiling(@root, key)
+        return unless found
+        found.key
+      end
+
+      def select(integer)
+        return if integer < 0 || integer >= size
+        found = impl_select(@root, integer)
+        found.key
+      end
+
+      def rank(key)
+        assert_key_type(key)
+        return unless key
+        impl_rank @root, key
+      end
+
+      def size_consistent?
+        impl_size_consistent?(@root)
+      end
+
+      def rank_consistent?
+        size.times do |time|
+          break false unless time != rank(select(time))
+        end
+        keys.each do |key|
+          comparison = key <=> select(rank(key))
+          break false if comparison != 0
+        end
+        true
+      end
+
+      def symmetric_ordered?
+        impl_symmetric_ordered? @root
+      end
+
+      def keys(low = min, high = max)
+        queue = Algorithmable::DataStructs::Queue.new
+        impl_keys @root, queue, low, high
+        queue
+      end
+
+      private
+
+      def check_tree_consistency
+        $stderr.puts 'Tree is not in symmetric order' unless a = symmetric_ordered?
+        $stderr.puts 'Tree has size inconsistency' unless b = size_consistent?
+        $stderr.puts 'Tree has ranking inconsistency' unless c = rank_consistent?
+        a && b && c
+      end
+
+      def impl_symmetric_ordered?(node, min_key = nil, max_key = nil)
+        return true unless node
+        return false if !min_key.nil? && (node.key <=> min_key) <= 0
+        return false if !max_key.nil? && (node.key <=> max_key) >= 0
+        impl_symmetric_ordered?(node.left, min_key, node.key) && impl_symmetric_ordered?(node.right, node.key, max_key)
+      end
+
+      def impl_keys(node, queue, low, high)
+        return unless node
+        cmp_low = low <=> node.key
+        cmp_high = high <=> node.key
+        impl_keys(node.left, queue, low, high) if cmp_low < 0
+        queue.enqueue node.key if cmp_low <= 0 && cmp_high >= 0
+        impl_keys(node.right, queue, low, high) if cmp_high > 0
+      end
+
+      def impl_size_consistent?(node)
+        return true unless node
+        return false if (node.size != node_size(node.left) + node_size(node.right) + 1)
+        impl_size_consistent?(node.left) && impl_size_consistent?(node.right)
+      end
+
+      def assert_value_type(value)
+        fail "Type expectation not met. Use value type `#{@value_type}` instead." unless value.is_a? @value_type
+      end
+
+      def assert_key_type(key)
+        fail "Type expectation not met. Use key type `#{@key_type}` instead." unless key.is_a? @key_type
+      end
+
+      def impl_rank(node, key)
+        return 0 unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          impl_rank(node.left, key)
+        elsif comparison > 0
+          1 + node_size(node.left) + impl_rank(node.right, key)
+        else
+          node_size node.left
+        end
+      end
+
+      def impl_select(node, index)
+        return unless node
+        left_size = node_size(node.left)
+        if left_size > index
+          impl_select(node.left, index)
+        elsif left_size < index
+          impl_select node.right, (index - left_size - 1)
+        else
+          node
+        end
+      end
+
+      def impl_ceiling(node, key)
+        return unless node
+        comparison = key <=> node.key
+        return node if 0 == comparison
+        if comparison < 0
+          found = impl_ceiling(node.left, key)
+          return found if found
+          return node
+        end
+        impl_ceiling node.right, key
+      end
+
+      def impl_floor(node, key)
+        return unless node
+        comparison = key <=> node.key
+        return node if 0 == comparison
+        return impl_floor(node.left, key) if comparison < 0
+        found = impl_floor(node.right, key)
+        return found if found
+        node
+      end
+
+      def impl_delete(node, key)
+        return unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          node.left = impl_delete(node.left, key)
+        elsif comparison > 0
+          node.right = impl_delete(node.right, key)
+        else
+          return node.right if node.left.nil?
+          return node.left if node.right.nil?
+          temp = node
+          node = impl_min(temp.right)
+          node.right = impl_delete_min(temp.right)
+          node.left = temp.left
+        end
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_max(node)
+        return node unless node.right
+        impl_max node.right
+      end
+
+      def impl_min(node)
+        return node unless node.left
+        impl_min node.left
+      end
+
+      def impl_delete_max(node)
+        return node.left unless node.right
+        node.right = impl_delete_max(node.right)
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_delete_min(node)
+        return node.right unless node.left
+        node.left = impl_delete_min(node.left)
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_put(node, key, value)
+        return Node.new(key, value, 1) unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          node.left = impl_put(node.left, key, value)
+        elsif comparison > 0
+          node.right = impl_put(node.right, key, value)
+        else
+          node.value = value
+        end
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_get(node, key)
+        return unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          impl_get(node.left, key)
+        elsif comparison > 0
+          impl_get(node.right, key)
+        else
+          node.value
+        end
+      end
+
+      def node_size(node)
+        node.nil? ? 0 : node.size
+      end
+
+      def computed_node_size(node)
+        1 + node_size(node.left) + node_size(node.right)
+      end
+
+      class Node
+        attr_accessor :key, :value, :left, :right, :size
+
+        def initialize(key = nil, value = nil, size = 0)
+          @key = key
+          @value = value
+          @left = nil
+          @right = nil
+          @size = size
+        end
+      end
+      private_constant :Node
+    end
+  end
+end

data/lib/algorithmable/searches.rb

@@ -0,0 +1,14 @@
+module Algorithmable
+  module Searches
+    autoload :BinarySearch, 'algorithmable/search/binary_search'
+    autoload :BinarySearchTree, 'algorithmable/search/binary_search_tree'
+
+    def binary_search(element, collection)
+      BinarySearch.lookup(element, collection)
+    end
+
+    def new_binary_search_tree(key_type, value_type)
+      BinarySearchTree.new key_type, value_type
+    end
+  end
+end

data/lib/algorithmable/version.rb

@@ -1,3 +1,3 @@
 module Algorithmable
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
 end

data/lib/algorithmable.rb

@@ -7,7 +7,7 @@ require 'English'
 module Algorithmable
   autoload :Errors, 'algorithmable/errors'
   autoload :Sort, 'algorithmable/sort'
-  autoload :Search, 'algorithmable/search'
+  autoload :Searches, 'algorithmable/searches'
   autoload :DataStructs, 'algorithmable/data_structs'
   autoload :Graphs, 'algorithmable/graphs'
   autoload :Puzzles, 'algorithmable/puzzles'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithmable
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Roman Lishtaba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-09 00:00:00.000000000 Z
+date: 2016-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -157,8 +157,9 @@ files:
 - lib/algorithmable/puzzles.rb
 - lib/algorithmable/puzzles/dijkstras_two_stacks.rb
 - lib/algorithmable/puzzles/josephus_problem.rb
-- lib/algorithmable/search.rb
-- lib/algorithmable/search/binary.rb
+- lib/algorithmable/search/binary_search.rb
+- lib/algorithmable/search/binary_search_tree.rb
+- lib/algorithmable/searches.rb
 - lib/algorithmable/sort.rb
 - lib/algorithmable/sort/binary_heap.rb
 - lib/algorithmable/sort/bubble.rb

data/lib/algorithmable/search.rb

@@ -1,11 +0,0 @@
-module Algorithmable
-  module Search
-    autoload :Binary, 'algorithmable/search/binary'
-
-    class << self
-      def binary(element, collection)
-        Binary.lookup(element, collection)
-      end
-    end
-  end
-end