add dp

Author: Aman Kumar

README.md

@@ -18,3 +18,5 @@ example: `ruby longest_consecutive_subsequence.rb` will print:
 
 # Contribute
 Did you find a bug? any way to do it better? please feel free to pull-request it :)
+
+

arrays/is_subsequence.rb

@@ -0,0 +1,29 @@
+# https://leetcode.com/problems/is-subsequence/
+# Given two strings s and t, check if s is a subsequence of t.
+
+# A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).
+
+# Example 1:
+
+# Input: s = "abc", t = "ahbgdc"
+# Output: true
+
+def is_subsequence(s, t)
+  t_id = 0
+  s_id = 0
+  while t_id < t.length && s_id < s.length
+    s_id += 1 if t[t_id] == s[s_id]
+    t_id += 1
+  end
+  s_id == s.length
+end
+
+# solution 2
+def is_subsequence(s, t)
+  s_index = 0
+  t.each_char do |c|
+    s_index += 1 if c == s[s_index]
+    break if s_index == s.length
+  end
+  s_index == s.length
+end

arrays/pair_whose_sum_equals_number.rb

@@ -28,6 +28,18 @@ def findPairUsingHash(ar, sum)
   pairs.to_s
 end
 
+# Leetcode solution
+def two_sum(nums, target)
+  return if nums.empty?
+
+  hash = {}
+  nums.each_with_index do |num, i|
+    return [i, hash[target - num]] if hash.key?(target - num)
+
+    hash[num] = i
+  end
+end
+
 ar = [0, 14, 0, 4, 7, 8, 3, 5, 7]
 sum = 11
 # puts findPairBrutforce(ar, sum)

dp/01_knapsack.rb

@@ -0,0 +1,54 @@
+def knapsack_rec(weights, values, capacity, length)
+  return 0 if length.zero? || capacity.zero?
+
+  # if weight is more than the capacity, so can't be included
+  return knapsack_rec(weights, values, capacity, length - 1) if weights[length - 1] > capacity
+
+  remaining_cap = capacity - weights[length - 1]
+
+  # Max of if we include the item or don't include
+  # If we include, we will add value also
+  [
+    values[length - 1] + knapsack_rec(weights, values, remaining_cap, length - 1),
+    knapsack_rec(weights, values, capacity, length - 1)
+  ].max
+end
+
+def knapsack_dp(weights, values, capacity)
+  return 0 if weights.empty? || capacity.zero?
+
+  length = weights.length
+  dp = Array.new(length + 1) { |_i| Array.new(capacity + 1, 0) }
+
+  (1..length).each do |item|
+    weight = weights[item - 1]
+    value = values[item - 1]
+    (1..capacity).each do |cap|
+      dp[item][cap] = if weight > cap
+                        dp[item - 1][cap]
+                      else
+                        [dp[item - 1][cap], dp[item - 1][cap - weight] + value].max
+                      end
+    end
+  end
+  # puts dp.to_s
+  dp[-1][-1]
+end
+values = [60, 100, 120]
+weights = [10, 20, 30]
+capacity = 50
+
+# puts knapsack_rec(weights, values, capacity, weights.length) #output 220
+
+puts knapsack_dp(weights, values, capacity) # output 220
+
+puts knapsack_dp(weights, values, capacity) # output 220
+
+weights = [[1, 2, 3, 4, 5],  [1, 3, 4, 6, 9],  [1, 2, 3, 5],     [3, 5]]
+values  = [[3, 5, 4, 8, 10], [5, 10, 4, 6, 8], [1, 19, 80, 100], [80, 100]]
+capacities = [5, 10, 6, 2]
+
+(0..3).each do |i|
+  puts "[DP] 0-1 Knapsack max value : #{knapsack_dp(weights[i], values[i], capacities[i])}"
+  puts "[Recursive] 0-1 Knapsack max value : #{knapsack_rec(weights[i], values[i], capacities[i], weights[i].length)}"
+end

dp/coin_change.rb

@@ -0,0 +1,26 @@
+# You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.
+
+# Return the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
+
+# You may assume that you have an infinite number of each kind of coin.
+
+def coin_change(coins, amount)
+  return 0 if amount.zero?
+
+  dp = Array.new(amount + 1, Float::INFINITY)
+
+  # To make 0 denomination, 0 coins needed
+  dp[0] = 0
+  coins.each do |coin|
+    # We cant make smaller amount with larger coin
+    # Example if coin value is 5, min amt possible is also 5
+    (coin..amount).each do |amt|
+      # Minimum of current value and 1 + value at remaining balance index
+      dp[amt] = [dp[amt], 1 + dp[amt - coin]].min
+    end
+  end
+
+  dp[amount] == Float::INFINITY ? -1 : dp[amount]
+end
+
+puts coin_change([1, 2, 5], 11)

dp/edit_distance.rb

@@ -0,0 +1,57 @@
+# Given two strings word1 and word2, return the minimum number of operations required to convert word1 to word2.
+
+# You have the following three operations permitted on a word:
+
+# Insert a character
+# Delete a character
+# Replace a character
+# Input: word1 = "horse", word2 = "ros"
+# Output: 3
+
+# horse -> rorse (replace 'h' with 'r')
+# rorse -> rose (remove 'r')
+# rose -> ros (remove 'e')
+# Let f(m, n) denote number of operations required to convert X(m) to Y(n) (X and Y are strings with m and n chars)
+
+# f(m, n) = f(m - 1, n - 1) if X[m - 1] == Y[n - 1] # Last character is already equal, that reduces the problem
+# else
+# f(m, n) = 1 + min of the three operations:
+#         = f(m - 1, n - 1) # Substituted last character of X with last character of Y
+#         = f(m - 1, n)     # Deleted last character of X
+#         = f(m, n - 1)     # Inserted last character of Y in end of X (now they have same last char)
+
+# Base Cases:
+# f(0, 0) = 0 # No operations required to convert empty string to empty string
+# f(0, j) = j # It'll take j insertions to convert empty string to string of size j
+# f(i, 0) = i # It'll take i deletions to convert string of i size to empty string
+
+def min_distance(word1, word2)
+  dp = Array.new(word1.size + 1) { Array.new(word2.size + 1) }
+
+  # increment values in 1st row and col
+  (0...dp.size).each do |i|
+    dp[i][0] = i
+  end
+  (0...dp[0].size).each do |j|
+    dp[0][j] = j
+  end
+
+  (1...dp.size).each do |i|
+    (1...dp[0].size).each do |j|
+      dp[i][j] = if word1[i - 1] == word2[j - 1]
+                   # if chars are same, value will be from diagonal upward
+                   dp[i - 1][j - 1]
+                 else
+                   [
+                     dp[i - 1][j - 1],
+                     dp[i][j - 1],
+                     dp[i - 1][j]
+                   ].min + 1
+                 end
+    end
+  end
+  dp[-1][-1]
+end
+
+puts min_distance('horse', 'ros')
+puts min_distance('intention', 'execution')

dp/fibonacci.rb

@@ -0,0 +1,36 @@
+def fibonacci_recursive(num)
+  return num if num < 2
+
+  fibonacci_recursive(num - 1) + fibonacci_recursive(num - 2)
+end
+
+def fibonacci_with_memoization(num, dp = [])
+  return num if num < 2
+  return dp[num] if dp[num]
+
+  dp[num] = fibonacci_with_memoization(num - 1) + fibonacci_with_memoization(num - 2)
+end
+
+def fibonacci_tabular(num)
+  dp = [0, 1]
+  (2..num).each do |i|
+    dp[i] = dp[i - 1] + dp[i - 2]
+  end
+  dp[num]
+end
+
+puts 'Fibonacci with recursive solution'
+puts fibonacci_recursive(7)
+# puts fibonacci_recursive(20)
+
+puts 'Fibonacci with DP - Memoization'
+puts fibonacci_with_memoization(5)
+puts fibonacci_with_memoization(6)
+puts fibonacci_with_memoization(7)
+puts fibonacci_with_memoization(20)
+
+puts 'Fibonacci with DP - Tabular'
+puts fibonacci_tabular(5)
+puts fibonacci_tabular(6)
+puts fibonacci_tabular(7)
+puts fibonacci_tabular(20)

dp/job_scheduling_max_profit.rb

@@ -4,34 +4,34 @@
 # @return {Integer}
 Job = Struct.new(:start, :end, :profit, :pos)
 def job_scheduling(start_time, end_time, profit)
-    return if start_time.length.zero?
-    return profit[0] if start_time.length == 1
+  return if start_time.length.zero?
+  return profit[0] if start_time.length == 1
 
-    jobs = []
-    for i in (0...start_time.length)
-        jobs << Job.new(start_time[i], end_time[i], profit[i], i+1)
-    end
-    jobs.sort_by!(&:profit).reverse!
-    schedule = Array.new(end_time.max)
-
-    profit = 0
+  jobs = []
+  (0...start_time.length).each do |i|
+    jobs << Job.new(start_time[i], end_time[i], profit[i], i + 1)
+  end
+  jobs.sort_by!(&:profit).reverse!
+  schedule = Array.new(end_time.max)
 
-    for i in (0...jobs.length)
-        available = true
-        current_job = jobs[i]
-        for j in (jobs[i].start...jobs[i].end)
-             if schedule[j]
-                 available = false
-                 break
-             end
-        end
-        next unless available
-        for j in (jobs[i].start...jobs[i].end)
-             schedule[j] = true
-        end
+  profit = 0
 
-        profit += jobs[i].profit
+  (0...jobs.length).each do |i|
+    available = true
+    current_job = jobs[i]
+    (jobs[i].start...jobs[i].end).each do |j|
+      if schedule[j]
+        available = false
+        break
+      end
+    end
+    next unless available
 
+    (jobs[i].start...jobs[i].end).each do |j|
+      schedule[j] = true
     end
-    profit
+
+    profit += jobs[i].profit
+  end
+  profit
 end

dp/max_sum_non_adjacent.rb

@@ -0,0 +1,26 @@
+# Given an array of integers, find the maximum sum of non-adjacent elements.
+# Consider the array 1,0,3,9,2 . The maximum sum would be (1+9)=10
+# Again, consider the array 2,4,6,2,5. The maximum should be (2+6+5)=13
+
+def max_sum_non_adjacent(arr)
+  return 0 if arr.empty?
+  return arr[0] if arr.length == 1
+
+  # base case, 1st element will be as it is
+  sums = [arr[0]]
+
+  # 2nd element will be max of 1st two numbers
+  sums[1] = arr[0..1].max
+
+  (2...arr.length).each do |i|
+    # max of previous element and (current array element + 2nd previous element)
+    sums[i] = [sums[i - 1], arr[i] + sums[i - 2]].max
+  end
+
+  sums[-1]
+end
+
+puts max_sum_non_adjacent([75, 105, 120, 75, 90, 135])
+puts max_sum_non_adjacent([5, 5, 10, 100, 10, 5])
+puts max_sum_non_adjacent([1, 2, 3])
+puts max_sum_non_adjacent([1, 20, 3])

dp/ways_to_make_coin_change.rb

@@ -0,0 +1,31 @@
+# You are given an integer array of coins representing coins of different denominations and an integer amount representing a total amount of money.
+# Return the number of combinations that make up that amount. If that amount of money cannot be made up by any combination of the coins, return 0.
+# You may assume that you have an infinite number of each kind of coin.
+# Input: amount = 5, coins = [1,2,5]
+# Output: 4
+# Explanation: there are 4 ways
+# 5=5
+# 5=2+2+1
+# 5=2+1+1+1
+# 5=1+1+1+1+1
+
+# Input: amount = 3, coins = [2]
+# Output: 0
+# Explanation: the amount of 3 cannot be made up just with coins of 2.
+#
+
+def change(amount, coins)
+  return 0 if coins.empty?
+
+  # TO make zero, there is one way. Dont give anything.
+  ways = Array.new(amount + 1, 0)
+  ways[0] = 1
+  coins.each do |coin|
+    (coin..amount).each do |amt|
+      ways[amt] += ways[amt - coin]
+    end
+  end
+  ways[-1]
+end
+
+puts change(5, [1, 2, 5])

graph/dfs.rb

@@ -0,0 +1,21 @@
+class Vertice
+  def initialize(name)
+    @children = []
+    @name = name
+  end
+
+  def add_child(name)
+    @children << Node.new(name)
+  end
+end
+
+class Graph
+  def initialize()
+    @vertices = []
+  end
+
+   def add_edge(node_a, node_b)
+    node_a.adjacents << node_b
+    node_b.adjacents << node_a
+  end
+end