stakach-algorithms 1.0.4 → 1.0.5

data/lib/containers/stack.rb

@@ -1,71 +1,71 @@
-require 'containers/deque'
-=begin rdoc
-    A Stack is a container that keeps elements in a last-in first-out (LIFO) order. There are many
-    uses for stacks, including prefix-infix-postfix conversion and backtracking problems.
-
-    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
-
-=end
-module Algorithms
-  module Containers
-    class Stack
-      include Enumerable
-      # Create a new stack. Takes an optional array argument to initialize the stack.
-      #
-      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
-      #   s.pop #=> 3
-      #   s.pop #=> 2
-      def initialize(ary=[])
-        @container = Deque.new(ary)
-      end
-  
-      # Returns the next item from the stack but does not remove it.
-      #
-      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
-      #   s.next #=> 3
-      #   s.size #=> 3
-      def next
-        @container.back
-      end
-  
-      # Adds an item to the stack.
-      #
-      #   s = Algorithms::Containers::Stack.new([1])
-      #   s.push(2)
-      #   s.pop #=> 2
-      #   s.pop #=> 1
-      def push(obj)
-        @container.push_back(obj)
-      end
-      alias_method :<<, :push
-  
-      # Removes the next item from the stack and returns it.
-      #
-      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
-      #   s.pop #=> 3
-      #   s.size #=> 2
-      def pop
-        @container.pop_back
-      end
-  
-      # Return the number of items in the stack.
-      #
-      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
-      #   s.size #=> 3
-      def size
-        @container.size
-      end
-  
-      # Returns true if the stack is empty, false otherwise.
-      def empty?
-        @container.empty?
-      end
-  
-      # Iterate over the Stack in LIFO order.
-      def each(&block)
-        @container.each_backward(&block)
-      end
-
-    end
-  end
+require 'containers/deque'
+=begin rdoc
+    A Stack is a container that keeps elements in a last-in first-out (LIFO) order. There are many
+    uses for stacks, including prefix-infix-postfix conversion and backtracking problems.
+
+    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
+
+=end
+module Algorithms
+  module Containers
+    class Stack
+      include Enumerable
+      # Create a new stack. Takes an optional array argument to initialize the stack.
+      #
+      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
+      #   s.pop #=> 3
+      #   s.pop #=> 2
+      def initialize(ary=[])
+        @container = Deque.new(ary)
+      end
+  
+      # Returns the next item from the stack but does not remove it.
+      #
+      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
+      #   s.next #=> 3
+      #   s.size #=> 3
+      def next
+        @container.back
+      end
+  
+      # Adds an item to the stack.
+      #
+      #   s = Algorithms::Containers::Stack.new([1])
+      #   s.push(2)
+      #   s.pop #=> 2
+      #   s.pop #=> 1
+      def push(obj)
+        @container.push_back(obj)
+      end
+      alias_method :<<, :push
+  
+      # Removes the next item from the stack and returns it.
+      #
+      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
+      #   s.pop #=> 3
+      #   s.size #=> 2
+      def pop
+        @container.pop_back
+      end
+  
+      # Return the number of items in the stack.
+      #
+      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
+      #   s.size #=> 3
+      def size
+        @container.size
+      end
+  
+      # Returns true if the stack is empty, false otherwise.
+      def empty?
+        @container.empty?
+      end
+  
+      # Iterate over the Stack in LIFO order.
+      def each(&block)
+        @container.each_backward(&block)
+      end
+
+    end
+  end
 end

data/lib/containers/suffix_array.rb

@@ -1,72 +1,72 @@
-=begin rdoc
-    A suffix array enables fast substring search of a given string. An array of all possible substrings
-    is constructed and stored, and a binary search is then done to find a desired substring among those
-    stored. While more storage (and thus memory) is needed to create the SuffixArray, the advantage is
-    that substrings can be found in O(m log n) time, where m is the length of the substring to search for
-    and n is the total number of substrings.
-
-=end
-module Algorithms
-  module Containers
-    class SuffixArray
-      # Creates a new SuffixArray with a given string. Object of any class implementing a #to_s method can
-      # be passed in, such as integers.
-      #
-      # Complexity: O(n^2 log n)
-      #
-      #   s_array = Algorithms::Containers::SuffixArray.new("abracadabra")
-      #   s_array["abra"] #=> true
-      #
-      #   number = Algorithms::Containers::SuffixArray.new(1234567)
-      #   number[1] #=> true
-      #   number[13] #=> false 
-      def initialize(string)
-        string = string.to_s
-        raise ArgumentError, "SuffixArray needs to be initialized with a non-empty string" if string.empty?
-        @original_string = string
-        @suffixes = []
-        string.length.times do |i|
-          @suffixes << string[i..-1]
-        end
-
-        # Sort the suffixes in ascending order
-        @suffixes.sort! { |x, y| x <=> y }
-      end
-  
-      # Returns true if the substring occurs in the string, false otherwise.
-      #
-      # Complexity: O(m + log n)
-      #
-      #   s_array = Algorithms::Containers::SuffixArray.new("abracadabra")
-      #   s_array.has_substring?("a") #=> true
-      #   s_array.has_substring?("abra") #=> true
-      #   s_array.has_substring?("abracadabra") #=> true
-      #   s_array.has_substring?("acadabra") #=> true
-      #   s_array.has_substring?("adabra") #=> true
-      #   s_array.has_substring?("bra") #=> true
-      #   s_array.has_substring?("bracadabra") #=> true
-      #   s_array.has_substring?("cadabra") #=> true
-      #   s_array.has_substring?("dabra") #=> true
-      #   s_array.has_substring?("ra") #=> true
-      #   s_array.has_substring?("racadabra") #=> true
-      #   s_array.has_substring?("nope") #=> false
-      def has_substring?(substring)
-        substring = substring.to_s
-        return false if substring.empty?
-        substring_length = substring.length-1
-        l, r = 0, @suffixes.size-1
-        while(l <= r)
-          mid = (l + r) / 2
-          suffix = @suffixes[mid][0..substring_length]
-          case substring <=> suffix
-          when 0 then return true
-          when 1 then l = mid + 1
-          when -1 then r = mid - 1
-          end
-        end
-        return false
-      end
-      alias_method :[], :has_substring?
-    end
-  end
+=begin rdoc
+    A suffix array enables fast substring search of a given string. An array of all possible substrings
+    is constructed and stored, and a binary search is then done to find a desired substring among those
+    stored. While more storage (and thus memory) is needed to create the SuffixArray, the advantage is
+    that substrings can be found in O(m log n) time, where m is the length of the substring to search for
+    and n is the total number of substrings.
+
+=end
+module Algorithms
+  module Containers
+    class SuffixArray
+      # Creates a new SuffixArray with a given string. Object of any class implementing a #to_s method can
+      # be passed in, such as integers.
+      #
+      # Complexity: O(n^2 log n)
+      #
+      #   s_array = Algorithms::Containers::SuffixArray.new("abracadabra")
+      #   s_array["abra"] #=> true
+      #
+      #   number = Algorithms::Containers::SuffixArray.new(1234567)
+      #   number[1] #=> true
+      #   number[13] #=> false 
+      def initialize(string)
+        string = string.to_s
+        raise ArgumentError, "SuffixArray needs to be initialized with a non-empty string" if string.empty?
+        @original_string = string
+        @suffixes = []
+        string.length.times do |i|
+          @suffixes << string[i..-1]
+        end
+
+        # Sort the suffixes in ascending order
+        @suffixes.sort! { |x, y| x <=> y }
+      end
+  
+      # Returns true if the substring occurs in the string, false otherwise.
+      #
+      # Complexity: O(m + log n)
+      #
+      #   s_array = Algorithms::Containers::SuffixArray.new("abracadabra")
+      #   s_array.has_substring?("a") #=> true
+      #   s_array.has_substring?("abra") #=> true
+      #   s_array.has_substring?("abracadabra") #=> true
+      #   s_array.has_substring?("acadabra") #=> true
+      #   s_array.has_substring?("adabra") #=> true
+      #   s_array.has_substring?("bra") #=> true
+      #   s_array.has_substring?("bracadabra") #=> true
+      #   s_array.has_substring?("cadabra") #=> true
+      #   s_array.has_substring?("dabra") #=> true
+      #   s_array.has_substring?("ra") #=> true
+      #   s_array.has_substring?("racadabra") #=> true
+      #   s_array.has_substring?("nope") #=> false
+      def has_substring?(substring)
+        substring = substring.to_s
+        return false if substring.empty?
+        substring_length = substring.length-1
+        l, r = 0, @suffixes.size-1
+        while(l <= r)
+          mid = (l + r) / 2
+          suffix = @suffixes[mid][0..substring_length]
+          case substring <=> suffix
+          when 0 then return true
+          when 1 then l = mid + 1
+          when -1 then r = mid - 1
+          end
+        end
+        return false
+      end
+      alias_method :[], :has_substring?
+    end
+  end
 end

data/lib/containers/trie.rb

@@ -1,188 +1,188 @@
-=begin rdoc
-    A Trie is a data structure that stores key value pairs in a tree-like fashion. It allows
-    O(m) lookup speed, where m is the length of the key searched, and has no chance of collisions,
-    unlike hash tables. Because of its nature, search misses are quickly detected.
-    
-    Tries are often used for longest prefix algorithms, wildcard matching, and can be used to
-    implement a radix sort.
-
-    This implemention is based on a Ternary Search Tree.
-=end
-module Algorithms
-  module Containers
-    class Trie  
-      # Create a new, empty Trie.
-      #
-      #   t = 
-      # Trie.new
-      #   t["hello"] = "world"
-      #   t["hello] #=> "world"
-      def initialize
-        @root = nil
-      end
-  
-      # Adds a key, value pair to the Trie, and returns the value if successful. The to_s method is
-      # called on the parameter to turn it into a string.
-      #
-      # Complexity: O(m)
-      #
-      #   t = Algorithms::Containers::Trie.new
-      #   t["hello"] = "world"
-      #   t.push("hello", "world") # does the same thing
-      #   t["hello"] #=> "world"
-      #   t[1] = 1
-      #   t[1] #=> 1
-      def push(key, value)
-        key = key.to_s
-        return nil if key.empty?
-        @root = push_recursive(@root, key, 0, value)
-        value
-      end
-      alias_method :[]=, :push
-  
-      # Returns true if the key is contained in the Trie.
-      #
-      # Complexity: O(m) worst case
-      #
-      def has_key?(key)
-        key = key.to_s
-        return false if key.empty?
-        !(get_recursive(@root, key, 0).nil?)
-      end
-      alias_method :include?, :has_key?
-  
-      # Returns the value of the desired key, or nil if the key doesn't exist.
-      #
-      # Complexity: O(m) worst case
-      #
-      #   t = Algorithms::Containers::Trie.new
-      #   t.get("hello") = "world"
-      #   t.get("non-existant") #=> nil
-      def get(key)
-        key = key.to_s
-        return nil if key.empty?
-        node = get_recursive(@root, key, 0)
-        node ? node.last : nil
-      end
-      alias_method :[], :get
-  
-      # Returns the longest key that has a prefix in common with the parameter string. If
-      # no match is found, the blank string "" is returned.
-      #
-      # Complexity: O(m) worst case
-      #
-      #   t = Algorithms::Containers::Trie.new
-      #   t.push("Hello", "World")
-      #   t.push("Hello, brother", "World")
-      #   t.push("Hello, bob", "World")
-      #   t.longest_prefix("Hello, brandon") #=> "Hello"
-      #   t.longest_prefix("Hel") #=> ""
-      #   t.longest_prefix("Hello") #=> "Hello"
-      def longest_prefix(string)
-        string = string.to_s
-        return nil if string.empty?
-        len = prefix_recursive(@root, string, 0)
-        string[0...len]
-      end
-  
-      # Returns a sorted array containing strings that match the parameter string. The wildcard
-      # characters that match any character are '*' and '.' If no match is found, an empty
-      # array is returned.
-      #
-      # Complexity: O(n) worst case
-      #
-      #   t = Algorithms::Containers::Trie.new
-      #   t.push("Hello", "World")
-      #   t.push("Hilly", "World")
-      #   t.push("Hello, bob", "World")
-      #   t.wildcard("H*ll.") #=> ["Hello", "Hilly"]
-      #   t.wildcard("Hel") #=> []
-      def wildcard(string)
-        string = string.to_s
-        return nil if string.empty?
-        ary = [] 
-        ary << wildcard_recursive(@root, string, 0, "")
-        ary.flatten.compact.sort
-      end
-  
-      class Node # :nodoc: all
-        attr_accessor :left, :mid, :right, :char, :value, :end
-    
-        def initialize(char, value)
-          @char = char
-          @value = value
-          @left = @mid = @right = nil
-          @end = false
-        end
-    
-        def last?
-          @end == true
-        end
-      end
-  
-      def wildcard_recursive(node, string, index, prefix)
-        return nil if node.nil? || index == string.length
-        arr = []
-        char = string[index]
-        if (char.chr == "*" || char.chr == "." || char < node.char)
-          arr << wildcard_recursive(node.left, string, index, prefix)
-        end
-        if (char.chr == "*" || char.chr == "." || char > node.char)
-          arr << wildcard_recursive(node.right, string, index, prefix)
-        end
-        if (char.chr == "*" || char.chr == "." || char == node.char)
-          arr << "#{prefix}#{node.char.chr}" if node.last?
-          arr << wildcard_recursive(node.mid, string, index+1, prefix + node.char.chr)
-        end
-        arr
-      end
-  
-      def prefix_recursive(node, string, index)
-        return 0 if node.nil? || index == string.length
-        len = 0
-        rec_len = 0
-        char = string[index]
-        if (char < node.char)
-          rec_len = prefix_recursive(node.left, string, index)
-        elsif (char > node.char)
-          rec_len = prefix_recursive(node.right, string, index)
-        else
-          len = index+1 if node.last?
-          rec_len = prefix_recursive(node.mid, string, index+1)
-        end
-        len > rec_len ? len : rec_len
-      end
-  
-      def push_recursive(node, string, index, value)
-        char = string[index]
-        node = Node.new(char, value) if node.nil?
-        if (char < node.char)
-          node.left = push_recursive(node.left, string, index, value)
-        elsif (char > node.char)
-          node.right = push_recursive(node.right, string, index, value)
-        elsif (index < string.length-1) # We're not at the end of the input string; add next char
-          node.mid = push_recursive(node.mid, string, index+1, value)
-        else
-          node.end = true
-          node.value = value
-        end
-        node
-      end
-  
-      # Returns [char, value] if found
-      def get_recursive(node, string, index)
-        return nil if node.nil?
-        char = string[index]
-        if (char < node.char)
-          return get_recursive(node.left, string, index)
-        elsif (char > node.char)
-          return get_recursive(node.right, string, index)
-        elsif (index < string.length-1) # We're not at the end of the input string; add next char
-          return get_recursive(node.mid, string, index+1)
-        else
-          return node.last? ? [node.char, node.value] : nil
-        end
-      end
-    end
-  end
+=begin rdoc
+    A Trie is a data structure that stores key value pairs in a tree-like fashion. It allows
+    O(m) lookup speed, where m is the length of the key searched, and has no chance of collisions,
+    unlike hash tables. Because of its nature, search misses are quickly detected.
+    
+    Tries are often used for longest prefix algorithms, wildcard matching, and can be used to
+    implement a radix sort.
+
+    This implemention is based on a Ternary Search Tree.
+=end
+module Algorithms
+  module Containers
+    class Trie  
+      # Create a new, empty Trie.
+      #
+      #   t = 
+      # Trie.new
+      #   t["hello"] = "world"
+      #   t["hello] #=> "world"
+      def initialize
+        @root = nil
+      end
+  
+      # Adds a key, value pair to the Trie, and returns the value if successful. The to_s method is
+      # called on the parameter to turn it into a string.
+      #
+      # Complexity: O(m)
+      #
+      #   t = Algorithms::Containers::Trie.new
+      #   t["hello"] = "world"
+      #   t.push("hello", "world") # does the same thing
+      #   t["hello"] #=> "world"
+      #   t[1] = 1
+      #   t[1] #=> 1
+      def push(key, value)
+        key = key.to_s
+        return nil if key.empty?
+        @root = push_recursive(@root, key, 0, value)
+        value
+      end
+      alias_method :[]=, :push
+  
+      # Returns true if the key is contained in the Trie.
+      #
+      # Complexity: O(m) worst case
+      #
+      def has_key?(key)
+        key = key.to_s
+        return false if key.empty?
+        !(get_recursive(@root, key, 0).nil?)
+      end
+      alias_method :include?, :has_key?
+  
+      # Returns the value of the desired key, or nil if the key doesn't exist.
+      #
+      # Complexity: O(m) worst case
+      #
+      #   t = Algorithms::Containers::Trie.new
+      #   t.get("hello") = "world"
+      #   t.get("non-existant") #=> nil
+      def get(key)
+        key = key.to_s
+        return nil if key.empty?
+        node = get_recursive(@root, key, 0)
+        node ? node.last : nil
+      end
+      alias_method :[], :get
+  
+      # Returns the longest key that has a prefix in common with the parameter string. If
+      # no match is found, the blank string "" is returned.
+      #
+      # Complexity: O(m) worst case
+      #
+      #   t = Algorithms::Containers::Trie.new
+      #   t.push("Hello", "World")
+      #   t.push("Hello, brother", "World")
+      #   t.push("Hello, bob", "World")
+      #   t.longest_prefix("Hello, brandon") #=> "Hello"
+      #   t.longest_prefix("Hel") #=> ""
+      #   t.longest_prefix("Hello") #=> "Hello"
+      def longest_prefix(string)
+        string = string.to_s
+        return nil if string.empty?
+        len = prefix_recursive(@root, string, 0)
+        string[0...len]
+      end
+  
+      # Returns a sorted array containing strings that match the parameter string. The wildcard
+      # characters that match any character are '*' and '.' If no match is found, an empty
+      # array is returned.
+      #
+      # Complexity: O(n) worst case
+      #
+      #   t = Algorithms::Containers::Trie.new
+      #   t.push("Hello", "World")
+      #   t.push("Hilly", "World")
+      #   t.push("Hello, bob", "World")
+      #   t.wildcard("H*ll.") #=> ["Hello", "Hilly"]
+      #   t.wildcard("Hel") #=> []
+      def wildcard(string)
+        string = string.to_s
+        return nil if string.empty?
+        ary = [] 
+        ary << wildcard_recursive(@root, string, 0, "")
+        ary.flatten.compact.sort
+      end
+  
+      class Node # :nodoc: all
+        attr_accessor :left, :mid, :right, :char, :value, :end
+    
+        def initialize(char, value)
+          @char = char
+          @value = value
+          @left = @mid = @right = nil
+          @end = false
+        end
+    
+        def last?
+          @end == true
+        end
+      end
+  
+      def wildcard_recursive(node, string, index, prefix)
+        return nil if node.nil? || index == string.length
+        arr = []
+        char = string[index]
+        if (char.chr == "*" || char.chr == "." || char < node.char)
+          arr << wildcard_recursive(node.left, string, index, prefix)
+        end
+        if (char.chr == "*" || char.chr == "." || char > node.char)
+          arr << wildcard_recursive(node.right, string, index, prefix)
+        end
+        if (char.chr == "*" || char.chr == "." || char == node.char)
+          arr << "#{prefix}#{node.char.chr}" if node.last?
+          arr << wildcard_recursive(node.mid, string, index+1, prefix + node.char.chr)
+        end
+        arr
+      end
+  
+      def prefix_recursive(node, string, index)
+        return 0 if node.nil? || index == string.length
+        len = 0
+        rec_len = 0
+        char = string[index]
+        if (char < node.char)
+          rec_len = prefix_recursive(node.left, string, index)
+        elsif (char > node.char)
+          rec_len = prefix_recursive(node.right, string, index)
+        else
+          len = index+1 if node.last?
+          rec_len = prefix_recursive(node.mid, string, index+1)
+        end
+        len > rec_len ? len : rec_len
+      end
+  
+      def push_recursive(node, string, index, value)
+        char = string[index]
+        node = Node.new(char, value) if node.nil?
+        if (char < node.char)
+          node.left = push_recursive(node.left, string, index, value)
+        elsif (char > node.char)
+          node.right = push_recursive(node.right, string, index, value)
+        elsif (index < string.length-1) # We're not at the end of the input string; add next char
+          node.mid = push_recursive(node.mid, string, index+1, value)
+        else
+          node.end = true
+          node.value = value
+        end
+        node
+      end
+  
+      # Returns [char, value] if found
+      def get_recursive(node, string, index)
+        return nil if node.nil?
+        char = string[index]
+        if (char < node.char)
+          return get_recursive(node.left, string, index)
+        elsif (char > node.char)
+          return get_recursive(node.right, string, index)
+        elsif (index < string.length-1) # We're not at the end of the input string; add next char
+          return get_recursive(node.mid, string, index+1)
+        else
+          return node.last? ? [node.char, node.value] : nil
+        end
+      end
+    end
+  end
 end