algorithmable 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23dff715f8d8ae5e91a4e738ec6fe52f9da12fe7
-  data.tar.gz: dbfa9eb077c85ba9957f10edbb99513e793ca495
+  metadata.gz: 484ef490b06d5cd0c396fc76651dec47edd406c8
+  data.tar.gz: ea9ba9dd9e2e6cbc886e3bf1a3022eda64badb21
 SHA512:
-  metadata.gz: d5a1aedb5222032d612c3037a91c94c303a1f4cfe955d752b97d6e4543d210f444fc5d01a203fe60c91dd969f4ed453a8e7bc5055264906bbbc062fc51f6ab4d
-  data.tar.gz: 784476ad38e96e828f2360f6272ab4d7b2b9d176446183257592d9595cdf769c85f59994a6ce23437537acd9ad1620f7c02b299fea43fcda3a7a648916d4ec6d
+  metadata.gz: d022c89e7953ee18649511d595c126892d7eb8d1c3bedfd21bdcc7804caf2cf592c7ecd8d019a3ec12555728ba17e541170b0b660d7368a879d5ff27961c18bc
+  data.tar.gz: 4497b73d3190fa9492a8c3966a50c2aa110dafd5e80656218c275d58ece61462859f4598c15a8c8441aa493afef371e09cc9f2b4bd183fb77ba760d98e472e69

data/.gitignore

@@ -13,3 +13,4 @@
 /coverage
 /rspec.xml
 /bin
+/debugger.*

data/README.md

@@ -12,6 +12,7 @@ Library also contains solutions for several puzzles solved by implemented algori
 ## Data Structures
 
 - Bag (primitive collection without ability to delete elements)
+- Singly Linked List
 - Doubly Linked List
 - Deque (double-ended queue)
 - Queue (FIFO)
@@ -19,6 +20,7 @@ Library also contains solutions for several puzzles solved by implemented algori
 - Ordered Symbol Table BST. Implementation using Unbalanced Binary Search Tree.
 - Minimum Priority Queue
 - Maximum Priority Queue
+- Ordered Symbol Table
 
 ## Graphs
 
@@ -37,13 +39,18 @@ Library also contains solutions for several puzzles solved by implemented algori
 
 - Bubble sort
 - Merge sort
-- Heaport ( Binary Heap )
+- Heapsort ( Binary Heap )
 
 ## Algorithms
 
 - Levenshtein Distance algorithm (http://www.levenshtein.net)
 - Lawrence Philips' Metaphone Algorithm (http://aspell.net/metaphone)
 
+## Puzzles
+
+- Shunting-yard algorithm ( Dijkstras two stacks algorithm )
+- Josephus problem
+
 # Usage
 
 It is always better to check unit tests in order to understand how things going on.

data/lib/algorithmable/cups/primitives.rb

@@ -0,0 +1,98 @@
+module Algorithmable
+  module Cups
+    module Primitives
+      # this module contains a lot of C style code. It is done intentionally.
+      # All the methods avoiding using already existent algorithms in Ruby.
+      # Algorithms/solutions should be implemented in place
+
+      def replace_space_chars(string, expression = '%20')
+        return unless string
+        space_count = 0
+        length = string.length
+        replacement = expression.chars.reverse.freeze
+        length.times { |i| space_count += 1 if string[i] == ' ' }
+        new_length = length + space_count * 2
+        chars = Array.new(new_length, ?\x00)
+
+        (0..length.pred).to_a.reverse_each do |i|
+          if string[i] == ' '
+            replacement.each_with_index do |char, index|
+              j = index + 1
+              chars[new_length - j] = char
+            end
+            new_length = new_length - replacement.length
+          else
+            new_length -= 1
+            chars[new_length] = string[i]
+          end
+        end
+
+        chars.join
+      end
+
+      def chars_is_uniq?(string)
+        return unless string
+        map = Array.new 127, false
+        string.chars.each do |char|
+          return false if map[char.ord]
+          map[char.ord] = true
+        end
+      end
+
+      def reverse_string(string)
+        return unless string
+        chars = string.chars
+        reversed = ''
+        string.size.times { reversed << chars.pop }
+        reversed
+      end
+
+      def remove_duplicated_chars(chars = [])
+        return if chars.empty? || chars.size < 2
+        array_tail = 1
+
+        chars.size.times do |cur_char_index|
+          next unless cur_char_index.nonzero?
+          prev_char_index = 0
+
+          while prev_char_index < array_tail
+            break if chars[cur_char_index] == chars[prev_char_index]
+            prev_char_index += 1
+          end
+
+          if prev_char_index == array_tail
+            chars[array_tail] = chars[cur_char_index]
+            array_tail += 1
+          end
+        end
+
+        # trim all after new tail
+        chars[0...array_tail]
+      end
+
+      def find_cycled_node(root)
+        return unless root.next or root.next.next
+        slow = root
+        fast = root
+
+        until fast.next.nil?
+          slow = slow.next
+          fast = fast.next.next
+          break if slow == fast
+        end
+
+        # return, no cycle
+        return if fast.next.nil?
+
+        slow = root
+        until slow == fast
+          slow = slow.next
+          fast = fast.next
+        end
+
+        # at this point return value is a node which is tail pointing to.
+        fast
+      end
+    end
+  end
+end

data/lib/algorithmable/cups.rb

@@ -0,0 +1,5 @@
+module Algorithmable
+  module Cups
+    autoload :Primitives, 'algorithmable/cups/primitives'
+  end
+end

data/lib/algorithmable/data_structs/linked_list/base.rb

@@ -0,0 +1,92 @@
+module Algorithmable
+  module DataStructs
+    module LinkedList
+      class Base
+        attr_reader :size, :front
+
+        def initialize(collection = [])
+          @front = nil
+          @back = nil
+          @size = 0
+          collection.each { |item| push_front item }
+        end
+
+        def empty?
+          0 == size
+        end
+
+        def clear!
+          @front = nil
+          @back = nil
+          @size = 0
+        end
+
+        def peek_front
+          @front && @front.item
+        end
+
+        def peek_back
+          @back && @back.item
+        end
+
+        def include?(item)
+          !search(item).nil?
+        end
+
+        def push_back(_item)
+          fail NotImplementedError
+        end
+
+        def push_front(_item)
+          fail NotImplementedError
+        end
+
+        def pop_back
+          fail NotImplementedError
+        end
+
+        def pop_front
+          fail NotImplementedError
+        end
+
+        def delete(_item)
+          fail NotImplementedError
+        end
+
+        def reverse
+          fail NotImplementedError
+        end
+
+        def merge(_other_list)
+          fail NotImplementedError
+        end
+
+        private
+
+        def search(item)
+          return if empty?
+          node = @front
+          while node
+            break if node.item == item
+            node = node.next
+          end
+          node
+        end
+
+        def each(&block)
+          nodes = []
+          node = @front
+          until node.nil?
+            nodes << node
+            node = node.next
+          end
+          nodes.each(&block)
+        end
+
+        def new_node(_item, *_args)
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs/linked_list/doubly.rb

@@ -0,0 +1,86 @@
+module Algorithmable
+  module DataStructs
+    module LinkedList
+      class Doubly < Base
+        class Node
+          attr_accessor :item, :prev, :next
+
+          def initialize(item, prev_pointer = nil, next_pointer = nil)
+            @item = item
+            @prev = prev_pointer
+            @next = next_pointer
+          end
+        end
+
+        private_constant :Node
+
+        def push_front(item)
+          prev_front = @front
+          node = new_node item, nil, prev_front
+          @front = node
+
+          if prev_front
+            prev_front.prev = node
+          else
+            @back = node
+          end
+
+          @size += 1
+          item
+        end
+
+        def push_back(item)
+          prev_back = @back
+          node = Node.new item, prev_back, nil
+          @back = node
+
+          if prev_back
+            prev_back.next = node
+          else
+            @front = node
+          end
+
+          @size += 1
+          item
+        end
+
+        def pop_front
+          delete peek_front
+        end
+
+        def pop_back
+          delete peek_back
+        end
+
+        def delete(item)
+          node = search(item)
+          return unless node
+
+          prev_node = node.prev
+          next_node = node.next
+
+          if prev_node.nil?
+            @front = next_node
+          else
+            prev_node.next = next_node
+          end
+
+          if next_node.nil?
+            @back = prev_node
+          else
+            next_node.prev = prev_node
+          end
+
+          @size -= 1
+          item
+        end
+
+        private
+
+        def new_node(item, prev_pointer = nil, next_pinter = nil)
+          Node.new item, prev_pointer, next_pinter
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs/linked_list/singly.rb

@@ -0,0 +1,127 @@
+module Algorithmable
+  module DataStructs
+    module LinkedList
+      class Singly < Base
+        class Node
+          attr_accessor :item, :next
+
+          def initialize(item, next_pointer = nil)
+            @item = item
+            @next = next_pointer
+          end
+        end
+
+        private_constant :Node
+
+        def push_front(obj)
+          node = new_node(obj)
+          if @front
+            node.next = @front
+            @front = node
+          else
+            @front = node
+            @back = @front
+          end
+          @size += 1
+          obj
+        end
+
+        def push_back(obj)
+          node = new_node(obj)
+          if @back
+            @back.next = node
+            @back = node
+          else
+            @front = node
+            @back = @front
+          end
+          @size += 1
+          obj
+        end
+
+        def pop_front
+          return unless @front
+          node = @front
+
+          if @front == @back
+            clear!
+          else
+            @front = @front.next
+            @size -= 1
+          end
+
+          node.item
+        end
+
+        def pop_back
+          return unless @back
+          node = @back
+          if @front == @back
+            clear!
+          else
+            prev = @front
+            prev = prev.next while prev.next != @back
+            @back = prev
+            @back.next = nil
+            @size -= 1
+          end
+          node.item
+        end
+
+        def delete(item)
+          tmp_node = @front
+          prev_node = nil
+
+          until tmp_node.nil?
+            if tmp_node.item == item
+              if tmp_node == @front
+                next_node = @front.next
+                @back = next_node if @front == @back
+                @front = next_node
+                @size -= 1
+              else
+                prev_node.next = tmp_node.next
+                @back = prev_node if tmp_node == @back
+                @size -= 1
+              end
+              return true
+            else
+              prev_node = tmp_node
+            end
+
+            tmp_node = tmp_node.next
+          end
+        end
+
+        private
+
+        def reverse_imp(root)
+          return root if root.nil? || root.next.nil?
+          node = reverse_imp(root.next)
+          root.next.next = root
+          root.next = nil
+          node
+        end
+
+        def remove_next(prev)
+          if prev.nil?
+            pop_front
+          elsif prev.next == @back
+            @back = prev
+            @back.next = nil
+            @size -= 1
+          elsif prev == @back
+            return
+          else
+            prev.next = prev.next.next
+            @size -= 1
+          end
+        end
+
+        def new_node(item, next_pinter = nil)
+          Node.new item, next_pinter
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs/linked_list.rb

@@ -1,101 +1,19 @@
 module Algorithmable
   module DataStructs
-    class LinkedList
-      include Enumerable
-      attr_reader :length
+    module LinkedList
+      autoload :Base, 'algorithmable/data_structs/linked_list/base'
+      autoload :Singly, 'algorithmable/data_structs/linked_list/singly'
+      autoload :Doubly, 'algorithmable/data_structs/linked_list/doubly'
 
-      def initialize
-        @head = nil
-        @tail = nil
-        @length = 0
-        @op_counter = 0
-      end
-
-      def unshift(data)
-        link_head_node data
-      end
-
-      def push(data)
-        link_tail_node data
-      end
-
-      def first
-        @head ? @head.dup : fail_index_error
-      end
-
-      def last
-        @tail ? @tail.dup : fail_index_error
-      end
-
-      def each(&block)
-        next_node = @head
-        nodes = []
-        while next_node
-          nodes << next_node
-          next_node = next_node.succ
-        end
-        nodes.each(&block)
-      end
-
-      private
-
-      def link_head_node(data)
-        prev_head = @head
-        node = make_node data, nil, prev_head
-        @head = node
-
-        if prev_head
-          prev_head.pred = node
-        else
-          @tail = node
-        end
+      private_constant :Base
 
-        bump_length!
-        bump_op_counter!
+      def new_singly_linked_list(collection = [])
+        Singly.new collection
       end
 
-      def link_tail_node(data)
-        prev_tail = @tail
-        node = make_node data, prev_tail, nil
-        @tail = node
-
-        if prev_tail
-          prev_tail.succ = node
-        else
-          @head = node
-        end
-
-        bump_length!
-        bump_op_counter!
-      end
-
-      def make_node(data, pred = nil, succ = nil)
-        Node.new data, pred, succ
-      end
-
-      def bump_length!
-        @length = @length.next
-      end
-
-      def bump_op_counter!
-        @op_counter = @op_counter.next
-      end
-
-      def fail_index_error(message = nil)
-        fail IndexError, message
-      end
-
-      class Node
-        attr_accessor :pred, :succ
-        attr_reader :data
-
-        def initialize(data, pred = nil, succ = nil)
-          @data = data
-          @pred = pred
-          @succ = succ
-        end
+      def new_doubly_linked_list(collection = [])
+        Doubly.new collection
       end
-      private_constant :Node
     end
   end
 end

data/lib/algorithmable/data_structs.rb

@@ -8,14 +8,12 @@ module Algorithmable
     autoload :OrderedSymbolTable, 'algorithmable/data_structs/ordered_symbol_table'
     autoload :Heap, 'algorithmable/data_structs/heap'
 
+    include LinkedList
+
     def new_bag
       Bag.new
     end
 
-    def new_linked_list
-      LinkedList.new
-    end
-
     def new_fifo_queue
       Queue.new
     end
@@ -28,16 +26,16 @@ module Algorithmable
       OrderedSymbolTable.new(key_type, value_type)
     end
 
-    def new_max_priority_heap(collection = [])
-      Heap::Max.new(collection)
+    def new_priority_queue(collection, &block)
+      Heap::Max.new(collection, &block)
     end
 
-    alias_method :new_max_priority_queue, :new_max_priority_heap
+    def new_max_priority_queue(collection = [])
+      Heap::Max.new(collection)
+    end
 
-    def new_min_priority_heap(collection = [])
+    def new_min_priority_queue(collection = [])
       Heap::Min.new(collection)
     end
-
-    alias_method :new_min_priority_queue, :new_min_priority_heap
   end
 end

data/lib/algorithmable/sort/binary_heap.rb

@@ -8,7 +8,7 @@ module Algorithmable
       end
 
       def initialize(collection = [])
-        @heap = new_min_priority_heap collection
+        @heap = new_min_priority_queue collection
       end
 
       def sort

data/lib/algorithmable/version.rb

@@ -1,3 +1,3 @@
 module Algorithmable
-  VERSION = '0.11.0'
+  VERSION = '0.13.0'
 end

data/lib/algorithmable.rb

@@ -12,6 +12,7 @@ module Algorithmable
   autoload :Graphs, 'algorithmable/graphs'
   autoload :Puzzles, 'algorithmable/puzzles'
   autoload :LevenshteinDistance, 'algorithmable/levenshtein_distance'
+  autoload :Cups, 'algorithmable/cups'
 
   class << self
     def logger

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithmable
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Roman Lishtaba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-11 00:00:00.000000000 Z
+date: 2016-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -140,6 +140,8 @@ files:
 - algorithmable.gemspec
 - cucumber.yml
 - lib/algorithmable.rb
+- lib/algorithmable/cups.rb
+- lib/algorithmable/cups/primitives.rb
 - lib/algorithmable/data_structs.rb
 - lib/algorithmable/data_structs/bag.rb
 - lib/algorithmable/data_structs/deque.rb
@@ -148,6 +150,9 @@ files:
 - lib/algorithmable/data_structs/heap/max.rb
 - lib/algorithmable/data_structs/heap/min.rb
 - lib/algorithmable/data_structs/linked_list.rb
+- lib/algorithmable/data_structs/linked_list/base.rb
+- lib/algorithmable/data_structs/linked_list/doubly.rb
+- lib/algorithmable/data_structs/linked_list/singly.rb
 - lib/algorithmable/data_structs/ordered_symbol_table.rb
 - lib/algorithmable/data_structs/queue.rb
 - lib/algorithmable/data_structs/stack.rb