algorithmable 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 484ef490b06d5cd0c396fc76651dec47edd406c8
-  data.tar.gz: ea9ba9dd9e2e6cbc886e3bf1a3022eda64badb21
+  metadata.gz: 2819e21aacb2d64cd559ea000b1e91a3e522ed64
+  data.tar.gz: 2c44dfea8b1f9552fd28d0de362b7c4617d9772f
 SHA512:
-  metadata.gz: d022c89e7953ee18649511d595c126892d7eb8d1c3bedfd21bdcc7804caf2cf592c7ecd8d019a3ec12555728ba17e541170b0b660d7368a879d5ff27961c18bc
-  data.tar.gz: 4497b73d3190fa9492a8c3966a50c2aa110dafd5e80656218c275d58ece61462859f4598c15a8c8441aa493afef371e09cc9f2b4bd183fb77ba760d98e472e69
+  metadata.gz: 7518a1f6a826af9f6a232f77ec85dd4e09d2f93ac1c272d01d3aa20a6ea1c1a25950ba81abcd28ce62c752ed15c599bb3e9de25321f9a1f8e1d0de32240647fc
+  data.tar.gz: 912456f9bb48de78827502407b6967c48321f4a8066d1e667f58db0cfca4f4ec16fddbe1408a065e517803f94a982964ed5359019556e890cb7ed2b43ffb1e56

data/.rubocop.yml

@@ -3,7 +3,7 @@ Documentation:
 Style/IndentHash:
   Enabled: false
 Metrics/LineLength:
-  Max: 100
+  Max: 130
 AllCops:
   Exclude:
     - doc/**/*

data/algorithmable.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'cucumber', '~> 1.3'
   spec.add_development_dependency 'rspec_junit_formatter', '~> 0'
   spec.add_development_dependency 'yard', '~> 0.8'
+  spec.add_development_dependency 'rbench'
 end

data/lib/algorithmable/cache/imp.rb

@@ -0,0 +1,19 @@
+module Algorithmable
+  module Cache
+    class Imp
+      extend Forwardable
+
+      def_delegators :@heap, :size, :empty?, :[]
+
+      def initialize(max_size, heap)
+        @max_size = max_size
+        @heap = heap
+      end
+
+      def []=(key, value)
+        @heap.pop if @heap.size >= @max_size
+        @heap[key] = value
+      end
+    end
+  end
+end

data/lib/algorithmable/cache/primitive_max_heap.rb

@@ -0,0 +1,38 @@
+module Algorithmable
+  module Cache
+    class PrimitiveMaxHeap
+      extend Forwardable
+
+      def_delegators :@index, :size, :empty?
+
+      def initialize(index = [])
+        @storage = {}
+        @index = index
+      end
+
+      def []=(key, value)
+        swim key
+        @storage[key] = value
+      end
+
+      def [](key)
+        @storage[key].tap do |value|
+          swim key if value
+        end
+      end
+
+      def pop
+        key = @index.delete @index.last
+        @storage.delete key
+      end
+
+      private
+
+      def swim(key)
+        @index.delete(key)
+        @index.unshift(key)
+      end
+    end
+    private_constant :PrimitiveMaxHeap
+  end
+end

data/lib/algorithmable/cache/primitive_min_heap.rb

@@ -0,0 +1,38 @@
+module Algorithmable
+  module Cache
+    class PrimitiveMinHeap
+      extend Forwardable
+
+      def_delegators :@index, :size, :empty?
+
+      def initialize(index = [])
+        @storage = {}
+        @index = index
+      end
+
+      def []=(key, value)
+        sink key
+        @storage[key] = value
+      end
+
+      def [](key)
+        @storage[key].tap do |value|
+          sink key if value
+        end
+      end
+
+      def pop
+        key = @index.delete @index.last
+        @storage.delete key
+      end
+
+      private
+
+      def sink(key)
+        @index.delete(key)
+        @index.push(key)
+      end
+    end
+    private_constant :PrimitiveMinHeap
+  end
+end

data/lib/algorithmable/cache.rb

@@ -0,0 +1,15 @@
+module Algorithmable
+  module Cache
+    autoload :Imp, 'algorithmable/cache/imp'
+    autoload :PrimitiveMinHeap, 'algorithmable/cache/primitive_min_heap'
+    autoload :PrimitiveMaxHeap, 'algorithmable/cache/primitive_max_heap'
+
+    def new_lru_cache(size, heap = PrimitiveMaxHeap.new)
+      Imp.new size, heap
+    end
+
+    def new_mru_cache(size, heap = PrimitiveMinHeap.new)
+      Imp.new size, heap
+    end
+  end
+end

data/lib/algorithmable/cups/circular_dependencies.rb

@@ -0,0 +1,27 @@
+module Algorithmable
+  module Cups
+    module CircularDependencies
+      def lib_dependencies(item, dependencies)
+        visited = []
+        dfs(item, dependencies, visited) do |entry, dep|
+          puts "circular dependency: #{entry} <=> #{dep}"
+        end
+        visited
+      end
+
+      def dfs(item, dependencies, visited, &block)
+        next_items = dependencies[item]
+        return [] unless next_items
+        visited << item
+
+        next_items.each do |dep|
+          if visited.include? dep
+            yield item, dep if block_given?
+            next
+          end
+          dfs(dep, dependencies, visited, &block)
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/longest_common_subsequence.rb

@@ -0,0 +1,46 @@
+module Algorithmable
+  module Cups
+    class LongestCommonSubSequence
+      #
+      # @see https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
+      #
+      # >> a = "aaaaabbbb34354354345"
+      # >> b = "abbb34aaabbbb"
+      # >> find(a, b)
+      # => "aaaabbbb"
+      #
+      def find(a, b)
+        max_len = Array.new(a.size + 1, 0)
+        max_len.map! { Array.new(b.size + 1, 0) }
+
+        (a.size - 1).downto(0) do |i|
+          (b.size - 1).downto(0) do |j|
+            if a[i] == b[j]
+              max_len[i][j] = 1 + max_len[i + 1][j + 1]
+            else
+              max_len[i][j] = [max_len[i + 1][j], max_len[i][j + 1]].max
+            end
+          end
+        end
+
+        res = ''
+        i = 0
+        j = 0
+        while max_len[i][j] != 0 && i < a.size && j < b.size
+          if a[i] == b[j]
+            res << a[i]
+            i += 1
+            j += 1
+          else
+            if max_len[i][j] == max_len[i + 1][j]
+              i += 1
+            else
+              j += 1
+            end
+          end
+        end
+        res
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/merge_two_arrays.rb

@@ -0,0 +1,31 @@
+module Algorithmable
+  module Cups
+    # Given two lists of numbers in descending order, write a function that returns a single list sorted in the same order.
+    #     E.g.
+    #     list1: 4, 2, 1
+    # list2: 7, 6, 5, 3
+    # Result list should be: 7,6,5,4,3,2,1
+
+    # right = [4, 2, 1]
+    # left = [7, 6, 5, 3]
+    #
+    # l1 = [1]
+    # l2 = []
+
+    def merge_arrays(left, right)
+      sorted = []
+
+      while !left.empty? && !right.empty?
+        if left[0] >= right[0]
+          sorted.push(left.shift)
+        else
+          sorted.push(right.shift)
+        end
+      end
+
+      sorted += left if right.empty?
+      sorted += right if left.empty?
+      sorted # [1]
+    end
+  end
+end

data/lib/algorithmable/cups/nested_lists_problem.rb

@@ -0,0 +1,105 @@
+module Algorithmable
+  module Cups
+    module NestedListsProblem
+      # /**
+      # * Given a nested list of integers, returns the sum of all integers in the list weighted by their depth
+      # * For example, given the list {{1,1},2,{1,1}} the function should return 10 (four 1's at depth 2, one 2 at depth 1)
+      # * Given the list {1,{4,{6}}} the function should return 27 (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3)
+      # */
+      #
+      # public int depthSum (List<NestedInteger> input)
+      # {
+      #   // ur implementation here
+      # }
+      #
+      # **
+      # * This is the interface that represents nested lists.
+      # * You should not implement it, or speculate about its implementation.
+      # */
+      # public interface NestedInteger
+      # {
+      #    /** @return true if this NestedInteger holds a single integer, rather than a nested list */
+      #    boolean isInteger();
+      #
+      #    /** @return the single integer that this NestedInteger holds, if it holds a single integer
+      #     *  Return null if this NestedInteger holds a nested list
+      #     */
+      #    Integer getInteger();
+      #
+      #    /** @return the nested list that this NestedInteger holds, if it holds a nested list
+      #     *  Return null if this NestedInteger holds a single integer
+      #    */
+      #    List<NestedInteger> getList();
+      #  }
+
+      def make_list(collection, level = 0, buffer = new_nested_list)
+        collection.each do |entry|
+          if entry.is_a? Array
+            buffer << make_list(entry, level + 1)
+          else
+            buffer << entry
+          end
+        end
+        buffer
+      end
+
+      def new_nested_list(collection = [])
+        NestedListImp.new collection
+      end
+
+      def solve_puzzle(nested_list)
+        PuzzleSolver.find_sum_of_nodes_in nested_list
+      end
+
+      class NestedListImp
+        attr_accessor :value
+
+        def initialize(collection = [])
+          @collection = collection
+        end
+
+        def integer?
+          @collection.is_a? Fixnum
+        end
+
+        def <<(other)
+          @collection << other
+        end
+
+        def value
+          @collection
+        end
+
+        def each(&block)
+          @collection.each(&block)
+        end
+      end
+
+      private_constant :NestedListImp
+
+      class PuzzleSolver
+        def self.find_sum_of_nodes_in(nested_list)
+          new.find_sum_of_nodes_in nested_list
+        end
+
+        def find_sum_of_nodes_in(nested_list)
+          recursive_sum nested_list, 1
+        end
+
+        def recursive_sum(list, at_level)
+          sum = 0
+          list.each do |entry|
+            if entry.integer?
+              sum += entry * at_level
+            else
+              sum += recursive_sum entry, at_level + 1
+            end
+          end
+          sum
+        end
+      end
+
+      private_constant :PuzzleSolver
+    end
+  end
+end

data/lib/algorithmable/cups/number_of_occurrences_in_array.rb

@@ -0,0 +1,49 @@
+module Algorithmable
+  module Cups
+    module NumberOfOccurrencesInArray
+      include Algorithmable::Searches
+
+      def linear_solve(collection, target)
+        result = Hash.new 0
+        collection.each do |item|
+          result[item] += 1
+        end
+        result[target]
+      end
+
+      def logarithmic(collection, target)
+        i = find_first_one collection, 0, collection.size - 1, target
+        j = find_last_one collection, i, collection.size - 1, target
+        j - i + 1
+      end
+
+      def find_first_one(collection, low, high, target)
+        #   if(high >= low)
+        #   {
+        #     int mid = (low + high)/2;  /*low + (high - low)/2;*/
+        #     if( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x)
+        #       return mid;
+        #     else if(x > arr[mid])
+        #       return first(arr, (mid + 1), high, x, n);
+        #     else
+        #       return first(arr, low, (mid -1), x, n);
+        #   }
+        #   return -1
+      end
+
+      def find_last_one(collection, low, high, target)
+        # if(high >= low)
+        #   {
+        #     int mid = (low + high)/2;  /*low + (high - low)/2;*/
+        #     if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x )
+        #       return mid;
+        #     else if(x < arr[mid])
+        #       return last(arr, low, (mid -1), x, n);
+        #     else
+        #       return last(arr, (mid + 1), high, x, n);
+        #   }
+        #   return -1;
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/primitives.rb

@@ -20,7 +20,7 @@ module Algorithmable
               j = index + 1
               chars[new_length - j] = char
             end
-            new_length = new_length - replacement.length
+            new_length -= replacement.length
           else
             new_length -= 1
             chars[new_length] = string[i]
@@ -71,7 +71,7 @@ module Algorithmable
       end
 
       def find_cycled_node(root)
-        return unless root.next or root.next.next
+        return unless root.next || root.next.next
         slow = root
         fast = root
 
@@ -93,6 +93,209 @@ module Algorithmable
         # at this point return value is a node which is tail pointing to.
         fast
       end
+
+      def ransom_note(note, magazine)
+        ascii_table = Hash.new 0
+        source = magazine.chars
+
+        source.each do |char|
+          ascii_table[char] += 1
+        end
+
+        note.chars.each do |char|
+          return false unless ascii_table[char].nonzero?
+          ascii_table[char] -= 1
+        end
+
+        true
+      end
+
+      def anagrams?(string, other_string)
+        return false unless string.size == other_string.size
+        registry = Hash.new 0
+        string.each_char do |char|
+          registry[char] += 1
+        end
+        other_string.chars.none? do |char|
+          (registry[char] -= 1) < 0
+        end
+      end
+
+      def parse_string_with_escapes(string)
+        app_state = {
+            chunk_id: 0,
+            escaping: false,
+            prev_char: nil,
+            chunks: Hash.new { |h, k| h[k] = [] }
+        }
+
+        string.each_char do |char|
+          parse_char char, app_state
+        end
+
+        app_state[:chunks].values
+      end
+
+      def parse_char(char, state)
+        chunk_id = state[:chunk_id]
+        case char
+        when /[\(\{\[\)\}\]]/
+          state[:escaping] = char != state[:prev_char]
+          state[:chunks][chunk_id] << char unless state[:escaping]
+        else
+          if state[:escaping]
+            chunk_id = state[:chunk_id] += 1
+            state[:escaping] = false
+          end
+          state[:chunks][chunk_id] << char
+        end
+        state[:prev_char] = char
+      end
+
+      def remove_duplicates_from_list(list)
+        map = {}
+        prev = nil
+        node = list.front
+
+        while node
+          if map[node.item]
+            prev.next = node.next
+          else
+            map[node.item] = true
+            prev = node
+          end
+          node = node.next
+        end
+      end
+
+      def nth_to_last_in_list(list, nth = 1)
+        return if list.nil? || list.empty?
+        node1 = list.front
+        node2 = list.front
+
+        nth.downto(nth).each do |_i|
+          if node1
+
+          end
+        end
+      end
+
+      #
+      # int maxDiff(int arr[], int arr_size)
+      # {
+      #   int max_diff = arr[1] - arr[0];
+      #   int i, j;
+      #   for(i = 0; i < arr_size; i++)
+      #   {
+      #     for(j = i+1; j < arr_size; j++)
+      #     {
+      #       if(arr[j] - arr[i] > max_diff)
+      #          max_diff = arr[j] - arr[i];
+      #     }
+      #   }
+      #   return max_diff;
+      # }
+      #
+      # getBestTime(int stocks[], int sz, int &buy, int &sell) {
+      #   int min = 0;
+      #   int maxDiff = 0;
+      #   buy = sell = 0;
+      #   for (int i = 0; i < sz; i++) {
+      #     if (stocks[i] < stocks[min])
+      #       min = i;
+      #     int diff = stocks[i] - stocks[min];
+      #     if (diff > maxDiff) {
+      #       buy = min;
+      #       sell = i;
+      #       maxDiff = diff;
+      #     }
+      #   }
+      # }
+      #
+
+      def sort_linked_list(node)
+        return unless node || node.empty?
+        swapped = false
+        prev = nil
+
+        begin
+          swapped = false
+          current = node
+
+          until current.next == prev
+            if current.item > current.next.item
+              swap_nodes current, current.next
+              swapped = true
+            end
+            current = current.next
+          end
+
+          prev = current
+        end while swapped
+      end
+
+      def swap_nodes(node1, node2)
+        tmp = node1.item
+        node1.item = node2.item
+        node2.item = tmp
+      end
+
+      # Write a program that gives count of common characters presented in an array of strings..(or array of character arrays)
+      #
+      # For eg.. for the following input strings..
+      #
+      # aghkafgklt
+      # dfghako
+      # qwemnaarkf
+      #
+      # The output should be 3. because the characters a, f and k are present in all 3 strings.
+      #
+      # Note: The input strings contains only lower case alphabets
+      def find_common_chars_in_words(collection)
+        map = Hash.new 0
+
+        collection.each_with_index do |word, index|
+          word.chars.each do |char|
+            map[char] += 1 if map[char] == index
+          end
+        end
+
+        map.select do |key, value|
+          { key => value } if value == collection.size
+        end
+      end
+
+      # /* This class will be given a list of words (such as might be tokenized
+      #  * from a paragraph of text), and will provide a method that takes two
+      #  * words and returns the shortest distance (in words) between those two
+      #  * words in the provided text.
+      #  * Example:
+      #  *   WordDistanceFinder finder = new WordDistanceFinder(Arrays.asList("the", "quick", "brown", "fox", "quick"));
+      #  *   assert(finder.distance("fox","the") == 3);
+      #  *   assert(finder.distance("quick", "fox") == 1);
+      #  * /
+
+      def find_distance_between_words(dictionary, from, to)
+        return 0 if from == to
+
+        dict_size = dictionary.size
+        distance = -1
+
+        dictionary.each_with_index do |word, index|
+          next unless [from, to].include? word
+          temp = word == from
+          to = temp ? to : from
+          distance += 1
+
+          i = index
+          while i < dict_size - 1 && dictionary[i] != to
+            i += 1
+            distance += 1
+            return distance if dictionary[i] == to
+          end
+        end
+        distance
+      end
     end
   end
 end