Solve problems.

Author: deepakhb2

lib/Problems/daily-coding-problems/find_min_max_ary.rb

@@ -9,12 +9,32 @@
 #
 class Problem1
   def self.solution(values, k)
+    return store_seen(values, k)
+  end
+
+  # Time complexity: O(N) => Lookup in hash is O(1)
+  # Space complexity: O(N)
+  def self.store_seen(values, k)
+    seen = {}
+    values.each do |value|
+      if(seen[k - value])
+        return true
+      end
+      seen[value]=true
+    end
+    return false
+  end
+
+  # Time complexity: O(N^2)
+  # Space complexity: O(1)
+  def self.brute_fource(values, ke)
     size = values.size
     if(size <= 1 || k < 1)
       return false
     elsif(size == 2)
       return (values[0] + values[1]) == k
     end
+
     (0...size).each do |i|
       (1...size).each do |j|
         if(values[i]+values[j] == k)

lib/Problems/daily-coding-problems/problem1.rb

@@ -0,0 +1,78 @@
+# Given an array of numbers of length N, find both the minimum and maximum using less than 2 * (N - 2) comparisons.
+
+class Problem235
+
+  # Non Recursive
+  def self.non_recursive_solution(values, comparisons)
+    if(values.size == 1)
+      return values[0], values[0], comparisons
+    end
+    if(values.size == 2)
+      return (values[0] < values[1]) ? [values[0], values[1], comparisons+1] : [values[1], values[0], comparisons+1]
+    end
+    min = max = values[0]
+    compare = lambda { |x,y| x < y ? [x, y] : [y, x] }
+    values.each_slice(2) do |arr|
+      comparisons += 1
+      smaller, bigger = compare.call(arr[0], arr[1])
+      comparisons += 1
+      min = min(min, smaller)
+      comparisons += 1
+      max = max(max, bigger)
+    end
+    return min, max, comparisons
+  end
+  # Recursive
+  def self.recursive_solution(values, comparisons)
+    if(values.size == 1)
+      return values[0], values[0], comparisons
+    elsif(values.size == 2)
+      return (values[0] < values[1]) ? [values[0], values[1], comparisons+1] : [values[1], values[0], comparisons+1]
+    else
+      n = values.size / 2
+      lmin, lmax, comparisons = recursive_solution(values[0...n], comparisons+1)
+      rmin, rmax, comparisons = recursive_solution(values[n...values.size], comparisons+1)
+      return min(lmin, rmin), max(lmax, rmax), comparisons
+    end
+  end
+
+  def self.min(x, y)
+    x < y ? x : y
+  end
+
+  def self.max(x, y)
+    x > y ? x : y
+  end
+
+  def self.find_min_max_in_ary(values)
+    min, max = 0, 0
+    comparisons = 0
+    comparisons += 1
+    if(values.size == 1)
+      min = values[0]
+      max = values[0]
+      return min, max
+    end
+    comparisons += 1
+    if(values[0] <= values[1])
+      min = values[0]
+      max = values[1]
+    else
+      min = values[1]
+      max = values[0]
+    end
+    values.shift
+    values.shift
+    values.each do |value|
+      comparisons += 1
+      if(value < min)
+        min = value
+      end
+      comparisons += 1
+      if(value > max)
+        max = value
+      end
+    end
+    [min, max, comparisons]
+  end
+end

lib/Problems/daily-coding-problems/problem235.rb

@@ -0,0 +1,20 @@
+describe Problem235 do
+
+  # Given an array of numbers of length N, find both the minimum and
+  # maximum using less than 2 * (N - 2) comparisons.
+  describe '#non_recursive_solution' do
+    it 'return min and max value of array with "2 * (n-1)" comparison' do
+      values = [9, 2, 4, 6, 10, 1, 11, -1, 3, 5]
+      comparisons = 3 * (values.length / 2)
+      expect(Problem235.non_recursive_solution(values, 0)).to eq([-1, 11, comparisons])
+    end
+  end
+
+  describe '#recursive_solution' do
+    it 'return min and max value of array with "2 * (n-1)" comparison' do
+      values = [9, 2, 4, 6, 10, 1, 11, -1]
+      comparisons = 3 * (values.length / 2) - 2
+      expect(Problem235.recursive_solution(values, 0)).to eq([-1, 11, comparisons])
+    end
+  end
+end