Merge branch 'master' into master

Author: sagivo

README.md

@@ -13,7 +13,12 @@ This is my way of saying - change your interview style. There are lots of smart
 
 | problem | solution |
 |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Unique binary search trees](https://leetcode.com/problems/unique-binary-search-trees/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/unique_bsts.rb) |
 | [House Robber](https://leetcode.com/problems/house-robber/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/house-robber.rb) |
+| [Coin change](https://leetcode.com/problems/coin-change/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/coin-change.rb) |
+| [Decode Strings](https://leetcode.com/problems/decode-string/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/decode_string.rb) |
+| [Wiggle Subsequence](https://leetcode.com/problems/wiggle-subsequence/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/wiggle_subsequence.rb) |
+| [Unix path](https://leetcode.com/problems/simplify-path/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/simplify_path.rb) |
 | [Array Product](https://leetcode.com/problems/product-of-array-except-self/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/product-of-array.rb) |
 | [Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/top-k-elements.rb) |
 | [Sum 4 arrays](https://leetcode.com/problems/4sum-ii/description/) | [click](https://github.com/sagivo/algorithms/blob/master/src/4-sum.rb) |
@@ -50,6 +55,7 @@ This is my way of saying - change your interview style. There are lots of smart
 | [Range minimum query sparse table algorithm](http://en.wikipedia.org/wiki/Range_minimum_query) | [click](https://github.com/sagivo/algorithms/blob/master/src/rmq.rb) |
 | [Insertion Sort](https://en.wikipedia.org/wiki/Insertion_sort) | [click](https://github.com/sagivo/algorithms/blob/master/src/insertion_sort.rb) |
 | [Towers of Hanoi using Stack](https://en.wikipedia.org/wiki/Tower_of_Hanoi) | [click](blob/master/src/towers_of_hanoi_with_stack.rb)
+| [Tarjan's strongly connected components finder](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm) | [click](https://github.com/sagivo/algorithms/blob/master/src/tarjan.rb) |
 
 
 # How? 

src/coin-change.rb

@@ -0,0 +1,21 @@
+# @param {Integer[]} coins
+# @param {Integer} amount
+# @return {Integer}
+def coin_change(coins, amount)
+ return 0 if coins.empty? or amount <= 0
+ max = 4000000000
+ res = Array.new(amount, 0)
+
+ (1..amount).each do |am|
+ res[am] = max
+
+ coins.each do |c|
+ next if c > am
+ res[am] = [res[am], 1 + res[am - c]].min
+ end
+ end
+
+ res[amount] == max ? -1 : res[amount]
+end
+
+p coin_change([1, 2, 5], 11) # => 3

src/decode_string.rb

@@ -0,0 +1,36 @@
+# @param {String} s
+# @return {String}
+def decode_string(s)
+ strings = ['']
+ dups = []
+ str = ''
+ i = 0
+ while i < s.size do
+ if (s[i].to_i > 0)
+ j = i+1
+ j += 1 while s[j] != '['
+ num = s[i...j].to_i
+ dups.push(num)
+ strings.push(str)
+ i = j+1
+ elsif s[i] == ']'
+ num = dups.pop
+ str = strings.pop
+ str *= num
+ prev = strings.pop
+ strings.push(prev + str)
+ str = ''
+ i+=1
+ elsif s[i] != '['
+ str = strings.pop || ''
+ str += s[i]
+ strings.push(str)
+ str = ''
+ i+=1
+ end
+ end
+
+ return strings.pop
+end
+
+p decode_string('2[abc]3[cd]ef') # => abcabccdcdcdef

src/min_insertions_for_palindrome.rb

@@ -1,11 +1,15 @@
-#from http://www.geeksforgeeks.org/dynamic-programming-set-28-minimum-insertions-to-form-a-palindrome/
-def min_for_palindrome str, left=0, right=nil
- right ||= str.size-1
- return Float::INFINITY if left > right
- return 0 if left == right or (left == right-1 and str[left] == str[right])
- return 1 if left == right-1
- if str[left] == str[right] then min_for_palindrome(str, left+1, right-1) else [min_for_palindrome(str,left+1, right), min_for_palindrome(str,left,right-1)].min + 1 end
+# #from http://www.geeksforgeeks.org/dynamic-programming-set-28-minimum-insertions-to-form-a-palindrome/
+def shortest_palindrome(s)
+ helper(s, 0, s.size-1)
 end
 
-#test
-p min_for_palindrome 'geek' #2 -> kgeegk
+def helper(s, i, j)
+ return 0 if i >= j
+ if s[i] == s[j]
+ return helper(s, i+1, j-1)
+ else
+ return 1 + [helper(s, i+1, j), helper(s, i, j-1)].min
+ end
+end
+
+p shortest_palindrome('geek') # => 2 (kgeegk)

src/simlify_path.rb

@@ -0,0 +1,19 @@
+# @param {String} path
+# @return {String}
+def simplify_path(path)
+ dirs = path.split("/")
+ stack = []
+
+ dirs.each do |dir|
+ next if dir.empty? || dir == "."
+ if dir == ".."
+ stack.pop unless stack.empty?
+ else
+ stack.push(dir)
+ end
+ end
+
+ "/" + stack.join("/")
+end
+
+p simplify_path("/a/./b/../../c/") # => "/c"

src/target_sum.rb

@@ -0,0 +1,15 @@
+# @param {Integer[]} nums
+# @param {Integer} s
+# @return {Integer}
+def find_target_sum_ways(nums, s, i = 0, dp = {})
+ return dp["#{s}-#{i}"] if dp["#{s}-#{i}"]
+ if i == nums.size
+ return dp["#{s}-#{i}"] = s == 0 ? 1 : 0
+ end
+
+ return dp["#{s}-#{i}"] ||=
+ find_target_sum_ways(nums, s + nums[i], i+1, dp) +
+ find_target_sum_ways(nums, s - nums[i], i+1, dp)
+end
+
+p find_target_sum_ways([1, 1, 1, 1, 1], 3) # => 5

src/tarjan.rb

@@ -0,0 +1,175 @@
+class Node
+ attr_accessor :name, :idx, :lowlink, :on_stack
+
+ def initialize(name)
+ @name = name
+ end
+
+ def ==(other)
+ if other.class == Node
+ other.name == self.name
+ elsif other.class == String
+ other == self.name
+ else
+ false
+ end
+ end
+
+ def to_s
+ @name
+ end
+end
+
+class Edge
+ attr_accessor :from, :to
+
+ def initialize(node_from, node_to)
+ @from, @to = node_from, node_to
+ end
+
+ def ==(other)
+ self.from == other.from && self.to == other.to
+ end
+
+ def to_s
+ "(#{from.to_s} -> #{to.to_s})"
+ end
+end
+
+class Graph
+ attr_accessor :nodes, :edges, :adjmt
+
+ def initialize(load_dict = {})
+ @nodes = []
+ @edges = []
+ @adjmt = {}
+
+ if load_dict.size > 0 && load_dict.class == Hash
+ load_dict.each do |v, edges|
+ node_from = self.add_node(v)
+ adjmt[node_from] = []
+ edges.each do |w|
+ node_to = self.add_node(w)
+ adjmt[node_from] << node_to
+ self.add_edge(v, w)
+ end
+ end
+ end
+ end
+
+ def add_node(node_name)
+ if nodes.index(node_name)
+ return nodes[nodes.index(node_name)]
+ else
+ node = Node.new(node_name)
+ nodes << node
+ return node
+ end
+ end
+
+ def add_edge(node_name_from, node_name_to)
+ node_from = nodes[nodes.index(node_name_from)]
+ node_to = nodes[nodes.index(node_name_to)]
+ edges << Edge.new(node_from, node_to)
+ end
+end
+
+class Tarjan
+ attr_accessor :graph, :idx, :stack, :sccs
+
+ def initialize(graph)
+ if graph.class == Graph
+ @graph = graph
+ elsif graph.class == Hash
+ @graph = Graph.new(graph)
+ end
+
+ if graph != nil
+ @idx = 0
+ @stack = []
+
+ # Runs Tarjan
+ # Set all node index to None
+ self.graph.nodes.each do |v|
+ v.idx = nil
+ end
+
+ @sccs = []
+ self.graph.nodes.each do |v|
+ if v.idx == nil
+ self.strongconnect(v, sccs)
+ end
+ end
+ end
+ end
+
+ def strongconnect(v, sccs)
+ # Set the depth index for v to the smallest unused index
+ v.idx = self.idx
+ v.lowlink = self.idx
+ self.idx += 1
+ stack << v
+ v.on_stack = true
+
+ if graph.adjmt[v] != nil
+ # Consider successors of v
+ graph.adjmt[v].each do |w|
+ if w.idx == nil
+ # Successor w has not yet been visited; recurse on it
+ self.strongconnect(w, sccs)
+ v.lowlink = [v.lowlink, w.lowlink].min
+ elsif w.on_stack
+ # Successor w is in stack S and hence in the current SCC
+ # If w is not on stack, then (v, w) is a cross-edge in the DFS tree and must be ignored
+ # Note: The next line may look odd - but is correct.
+ # It says w.index not w.lowlink; that is deliberate and from the original paper
+ v.lowlink = [v.lowlink, w.idx].min
+ end
+ end
+ end
+ 
+ # If v is a root node, pop the stack and generate an SCC
+ if v.lowlink == v.idx
+ # start a new strongly connected component
+ scc = []
+ while true
+ w = stack.pop()
+ w.on_stack = false
+ scc << w
+ if w == v
+ break
+ end
+ end
+ sccs << scc
+ end
+ end
+end
+
+# Graph from https://en.wikipedia.org/wiki/File:Scc.png
+example = {
+ 'A' => ['B'],
+ 'B' => ['C', 'E', 'F'],
+ 'C' => ['D', 'G'],
+ 'D' => ['C', 'H'],
+ 'E' => ['A', 'F'],
+ 'F' => ['G'],
+ 'G' => ['F'],
+ 'H' => ['D', 'G']
+}
+
+g = Tarjan.new(example)
+print g.sccs.map{|scc| scc.map{|v| v.to_s}}.to_s + "\n"
+
+# Graph from https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm#/media/File:Tarjan%27s_Algorithm_Animation.gif
+example = {
+ 'A' => ['E'],
+ 'B' => ['A'],
+ 'C' => ['B', 'D'],
+ 'D' => ['C'],
+ 'E' => ['B'],
+ 'F' => ['B', 'E', 'G'],
+ 'G' => ['F', 'C'],
+ 'H' => ['G', 'H', 'D']
+}
+g = Tarjan.new(example)
+print g.sccs.map{|scc| scc.map{|v| v.to_s}}.to_s + "\n"

src/unique_bsts.rb

@@ -0,0 +1,14 @@
+def unique_bsts(n)
+ a = Array.new(n+1, 0)
+ a[0] = a[1] = 1
+
+ (2..n).each do |i|
+ (1..i).each do |j|
+ a[i] += (a[j-1] * a[i-j])
+ end
+ end
+
+ return a[n]
+end
+
+p unique_bsts(4) # => 14

src/wiggle_subsequence.rb

@@ -0,0 +1,21 @@
+# @param {Integer[]} nums
+# @return {Integer}
+def wiggle_max_length(nums)
+ return nums.size if nums.size < 2
+ up = nil
+ i = 1; res = 0
+ while i < nums.size
+ while i < nums.size and (
+ (up == nil and nums[i] == nums[i-1]) or
+ (up == true && nums[i] >= nums[i-1]) or
+ (up == false && nums[i] <= nums[i-1]))
+ i += 1
+ end
+ up = (up == nil and i < nums.size) ? nums[i] > nums[i-1] : !up
+ res += 1
+ end
+
+ return res
+end
+
+p wiggle_max_length([1,17,5,10,13,15,10,5,16,8]) # => 7