algorithmable 0.13.0 → 0.14.0

data/lib/algorithmable/cups/root_cube_issue.rb

@@ -0,0 +1,39 @@
+module Algorithmable
+  module Cups
+    module RootCubeIssue
+      # What is the fastest way to compute cube root?
+
+      ACCURACY = 0.0001
+
+      def self.binary_search(num, accuracy = ACCURACY)
+        low = 0
+        high = num
+        mid = 0
+
+        loop do
+          mid = (low + high) / 2.0
+          cube = mid * mid * mid
+          break if (cube - num).abs <= accuracy
+          if cube > num
+            high = mid
+          else
+            low = mid
+          end
+        end
+        mid
+      end
+
+      def self.newton_approximation(num, accuracy = ACCURACY)
+        x = 1
+        n = 10
+        loop do
+          0.upto(n).each do
+            x = (2 * x + num / (x * x)) / 3.0
+          end
+          break if ((x * x * x) - num).abs < accuracy
+        end
+        x
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stacks_and_queues/stack_sorter.rb

@@ -0,0 +1,25 @@
+module Algorithmable
+  module Cups
+    module StacksAndQueues
+      class StackSorter
+        include Algorithmable::DataStructs
+
+        def self.sort(stack)
+          new.sort(stack)
+        end
+
+        def sort(stack)
+          local_stack = new_lifo_queue
+          until stack.empty?
+            temp = stack.pop
+            while !local_stack.empty? && local_stack.peek < temp
+              stack.push local_stack.pop
+            end
+            local_stack.push temp
+          end
+          local_stack
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stacks_and_queues/stack_with_min.rb

@@ -0,0 +1,23 @@
+module Algorithmable
+  module Cups
+    module StacksAndQueues
+      class StackWithMin < Algorithmable::DataStructs::Stack
+        MAX_INT = 2**32
+        NodeWithMin = Struct.new(:item, :minimum)
+
+        private_constant :NodeWithMin
+
+        def push(item)
+          new_min = [item, min].min
+          node = NodeWithMin.new item, new_min
+          super node
+        end
+
+        def min
+          return MAX_INT if empty?
+          peek.min
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stacks_and_queues/towers_of_hanoi.rb

@@ -0,0 +1,48 @@
+module Algorithmable
+  module Cups
+    module StacksAndQueues
+      module TowersOfHanoi
+        class Tower
+          include Algorithmable::DataStructs
+
+          attr_reader :index
+
+          def initialize(index)
+            @disks = new_lifo_queue
+            @index = index
+          end
+
+          def add(disk)
+            fail "Error placing disk #{disk} on #{@disks.peek}." if !@disks.empty? && @disks.peek <= disk
+            @disks.push disk
+          end
+
+          def move_top_to_tower(other_tower)
+            top = @disks.pop
+            debug "Moving disk ##{top} from tower #{index} to #{other_tower.index}."
+            other_tower.add top
+          end
+
+          def move_disks(amount, destination, buffer)
+            return unless amount > 0
+            move_disks amount - 1, buffer, destination
+            move_top_to_tower destination
+            buffer.move_disks amount - 1, destination, self
+          end
+
+          def inspect
+            "#<Tower ##{index} #{@disks}>"
+          end
+
+          def to_a
+            @disks.to_a
+          end
+
+          def debug(message)
+            puts message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stacks_and_queues/triple_stack.rb

@@ -0,0 +1,52 @@
+module Algorithmable
+  module Cups
+    module StacksAndQueues
+      class TripleStack
+        MAX_INT = 2**32
+
+        def initialize(size)
+          @size = size + 1
+          @pointers = [0, 0, 0]
+          @array = Array.new (@size * 3)
+          0.upto(2).each do |index|
+            @array[@size * index] = MAX_INT
+          end
+        end
+
+        def push(stack_num, item)
+          pointer = get_stack_pointer(stack_num) + 1
+          @pointers[stack_num] += 1
+          @array[pointer] = item
+          item
+        end
+
+        def pop(stack_num)
+          pointer = get_stack_pointer(stack_num)
+          value = @array[pointer]
+          @array[pointer] = nil
+          @pointers[stack_num] -= 1
+          value
+        end
+
+        def peek(stack_num)
+          pointer = get_stack_pointer(stack_num)
+          @array[pointer]
+        end
+
+        def empty?(stack_num)
+          @pointers[stack_num].zero?
+        end
+
+        def inspect
+          "#<Stack @pointers=#{@pointers} @stacks=#{@array}>"
+        end
+
+        private
+
+        def get_stack_pointer(stack_num)
+          @size * stack_num + @pointers[stack_num]
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stacks_and_queues/two_stacks_queue.rb

@@ -0,0 +1,37 @@
+module Algorithmable
+  module Cups
+    module StacksAndQueues
+      class TwoStacksQueue
+        include Algorithmable::DataStructs
+
+        def initialize
+          @stack_a = new_lifo_queue
+          @stack_b = new_lifo_queue
+        end
+
+        def size
+          @stack_a.size + @stack_b.size
+        end
+
+        def enqueue(item)
+          unless @stack_b.empty?
+            @stack_a.push @stack_b.pop until @stack_b.empty?
+          end
+          @stack_a.push(item)
+        end
+
+        def dequeue
+          return @stack_b.dequeue unless @stack_b.empty?
+          @stack_b.push @stack_a.pop until @stack_a.empty?
+          @stack_b.pop
+        end
+
+        def peek
+          return @stack_b.peek unless @stack_b.empty?
+          @stack_b.push @stack_a.pop until @stack_a.empty?
+          @stack_b.peek
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stacks_and_queues.rb

@@ -0,0 +1,31 @@
+module Algorithmable
+  module Cups
+    module StacksAndQueues
+      autoload :TwoStacksQueue, 'algorithmable/cups/stacks_and_queues/two_stacks_queue'
+      autoload :StackWithMin, 'algorithmable/cups/stacks_and_queues/stack_with_min'
+      autoload :TripleStack, 'algorithmable/cups/stacks_and_queues/triple_stack'
+      autoload :StackSorter, 'algorithmable/cups/stacks_and_queues/stack_sorter'
+      autoload :TowersOfHanoi, 'algorithmable/cups/stacks_and_queues/towers_of_hanoi'
+
+      def new_triple_stack(size)
+        TripleStack.new size
+      end
+
+      def new_stack_with_min
+        StackWithMin.new
+      end
+
+      def new_two_stacks_queue
+        TwoStacksQueue.new
+      end
+
+      def sort_stack(stack)
+        StackSorter.sort stack
+      end
+
+      def new_tower_of_hanoi(index)
+        TowersOfHanoi::Tower.new index
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/stocks.rb

@@ -0,0 +1,80 @@
+module Algorithmable
+  module Cups
+    module Stocks
+      # If you were only permitted to buy one share of the stock and sell one share of the stock,
+      # design an algorithm to find the best times to buy and sell.
+      def get_best_time(stocks)
+        min = 0
+        max_diff = 0
+        buy = 0
+        sell = 0
+        0.upto(stocks.size - 1).each do |i|
+          min = i if stocks[i] < stocks[min]
+          diff = stocks[i] - stocks[min]
+          next unless diff > max_diff
+          buy = min
+          sell = i
+          max_diff = diff
+        end
+        { buy_at: buy, sell_at: sell, max_profit: max_diff }
+      end
+
+      # another way
+      #
+      def find_max_profit(arr)
+        max_diff = arr[1] - arr[0]
+        0.upto(arr.size).each do |i|
+          (i + 1).upto(arr.size - 1).each do |j|
+            max_diff = arr[j] - arr[i] if arr[j] - arr[i] > max_diff
+          end
+        end
+        max_diff
+      end
+
+      # The cost of a stock on each current_day is given in an array, find the max profit that you can make by
+      # buying and selling in those days.
+      # For example, if the given array is {100, 180, 260, 310, 40, 535, 695},
+      # the maximum profit can earned by buying on current_day 0, selling on current_day 3.
+      # Again buy on current_day 4 and sell on current_day 6. If the given array of prices is sorted in decreasing order,
+      # then profit cannot be earned at all.
+
+      # If we are allowed to buy and sell only once, then we can use following algorithm.
+      # Maximum difference between two elements. Here we are allowed to buy and sell multiple times.
+      #
+      # Following is algorithm for this problem.
+      # 1. Find the local minima and store it as starting index. If not exists, return.
+      # 2. Find the local maxima. and store it as ending index. If we reach the end, set the end as ending index.
+      # 3. Update the solution (Increment count of buy sell pairs)
+      # 4. Repeat the above steps if end is not reached.
+      #
+      # http://www.geeksforgeeks.org/stock-buy-sell/
+      def ruby_buy_and_sell_stocks(stocks)
+        total_days = stocks.size - 1
+        current_day = 0
+        series_count = 0
+        series = []
+
+        while current_day < total_days
+          while current_day <= total_days && stocks[current_day + 1] <= stocks[current_day]
+            current_day += 1
+          end
+
+          return series if current_day == total_days
+
+          series[series_count] = { buy: 0, sell: 0 }
+          series[series_count][:buy] = current_day
+          current_day += 1
+
+          while current_day <= total_days && stocks[current_day] >= stocks[current_day - 1]
+            current_day += 1
+          end
+
+          series[series_count][:sell] = current_day - 1
+          series_count += 1
+        end
+
+        series
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/task_shedule_with_coldtime.rb

@@ -0,0 +1,16 @@
+module Algorithmable
+  module Cups
+    class TaskScheduleWithColdTime
+      # Task schedule: given a sequence of task like A B C(means 3 different tasks), and a coldtime, which means you need to wait for that much time to start next [same] task. Now----
+      #
+      # Input: string, n
+      # Output: the best task-finishing sequence.
+      #
+      # eg. input: AAABBB, 2
+      # Output: AB_AB_AB
+      # ( "_" represents do nothing and wait)
+      def solve(sequence_of_tasks)
+      end
+    end
+  end
+end

data/lib/algorithmable/cups/two_sum.rb

@@ -0,0 +1,59 @@
+module Algorithmable
+  module Cups
+    module TwoSum
+      # Given an array of integers, find two numbers such that they add up to a specific target number.
+      #
+      # The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.
+      #
+      # For example:
+      #
+      # Input: numbers={2, 7, 11, 15}, target=9
+      # Output: index1=1, index2=2
+      class Quadratic
+        def solve(collection, target)
+          result = {}
+          collection.each_with_index do |_, index|
+            j = index + 1
+            while j < collection.size
+              if collection[index] + collection[j] == target
+                result[index] = collection[index]
+                result[j] = collection[j]
+              end
+              j += 1
+            end
+          end
+          result
+        end
+      end
+
+      # public class Solution {
+      #     public int[] twoSum(int[] numbers, int target) {
+      # 	  HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+      # 	  int[] result = new int[2];
+      #
+      # 	for (int i = 0; i < numbers.length; i++) {
+      # 		if (map.containsKey(numbers[i])) {
+      # 			int index = map.get(numbers[i]);
+      # 			result[0] = index+1 ;
+      # 			result[1] = i+1;
+      # 			break;
+      # 		} else {
+      # 			map.put(target - numbers[i], i);
+      # 		}
+      # 	 }
+      #
+      # 	return result;
+      #   }
+      # }
+
+      class Logarithmic
+        def solve(collection, target)
+        end
+      end
+
+      def new_quadratic_solution
+        Quadratic.new
+      end
+    end
+  end
+end

data/lib/algorithmable/cups.rb

@@ -1,5 +1,12 @@
 module Algorithmable
   module Cups
     autoload :Primitives, 'algorithmable/cups/primitives'
+    autoload :Stocks, 'algorithmable/cups/stocks'
+    autoload :StacksAndQueues, 'algorithmable/cups/stacks_and_queues'
+    autoload :NestedListsProblem, 'algorithmable/cups/nested_lists_problem'
+    autoload :TwoSum, 'algorithmable/cups/two_sum'
+    autoload :NumberOfOccurrencesInArray, 'algorithmable/cups/stacks_and_queues/number_of_occurrences_in_array'
+    autoload :LongestCommonSubSequence, 'algorithmable/cups/longest_common_subsequence'
+    autoload :RootCubeIssue, 'algorithmable/cups/root_cube_issue'
   end
 end

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

@@ -53,7 +53,15 @@ module Algorithmable
           fail NotImplementedError
         end
 
-        def reverse
+        def reverse!
+          fail NotImplementedError
+        end
+
+        def sort!
+          fail NotImplementedError
+        end
+
+        def merge!(_other_list)
           fail NotImplementedError
         end
 
@@ -61,6 +69,18 @@ module Algorithmable
           fail NotImplementedError
         end
 
+        def find_intersect(_other)
+          fail NotImplementedError
+        end
+
+        def to_s
+          to_a.join('->')
+        end
+
+        def to_a
+          each.map(&:item)
+        end
+
         private
 
         def search(item)