Merge pull request neetcode-gh#409 from TedTran2019/ruby-solutions

Ruby solutions to 23** more problems

Author: TedTran2019

ruby/100-Same-Tree.rb

@@ -0,0 +1,11 @@
+def is_same_tree(p, q)
+  if p.nil? && q.nil?
+    true
+  elsif p && q
+    (p.val == q.val) &&
+      is_same_tree(p.left, q.left) &&
+      is_same_tree(p.right, q.right)
+  else
+    false
+  end
+end

ruby/104-Maximum-Depth-of-Binary-Tree.rb

@@ -0,0 +1,8 @@
+def max_depth(root)
+  return 0 if root.nil?
+  return 1 if root.left.nil? && root.right.nil?
+
+  left =  1 + max_depth(root.left)
+  right = 1 + max_depth(root.right)
+  left > right ? left : right
+end

ruby/1046-Last-Stone-Weight.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'algorithms'
+include Containers
+
+def last_stone_weight(stones)
+  heap = MaxHeap.new
+  stones.each { |stone| heap << stone }
+  until heap.size <= 1
+    stone1 = heap.pop
+    stone2 = heap.pop
+    heap << (stone1 - stone2).abs if stone1 != stone2
+  end
+  last = heap.pop
+  last.nil? ? 0 : last
+end

ruby/11-Container-With-Most-Water.rb

@@ -0,0 +1,17 @@
+def max_area(height)
+  idx_start = 0
+  idx_end = height.length - 1
+  max_water = 0
+  while idx_start < idx_end
+    challenger = (height[idx_start] > height[idx_end] ? height[idx_end] : height[idx_start])
+    challenger *= (idx_end - idx_start)
+    max_water = challenger if challenger > max_water
+
+    if height[idx_start] > height[idx_end]
+      idx_end -= 1
+    else
+      idx_start += 1
+    end
+  end
+  max_water
+end

ruby/110-Balanced-Binary-Tree.rb

@@ -0,0 +1,15 @@
+def is_balanced(root)
+  $balance = true
+  balanced?(root)
+  $balance
+end
+
+def balanced?(root)
+  return -1 if root.nil?
+
+  left_height = 1 + balanced?(root.left)
+  right_height = 1 + balanced?(root.right)
+  $balance = false if (left_height - right_height).abs > 1
+
+  left_height > right_height ? left_height : right_height
+end

ruby/121-Best-Time-To-Buy-and-Sell-Stock.rb

@@ -0,0 +1,10 @@
+def max_profit(prices)
+  max_profit = 0
+  min = prices.first
+  prices.each do |price|
+    min = price if price < min
+    profit = price - min
+    max_profit = profit if profit > max_profit
+  end
+  max_profit
+end

ruby/125-Valid-Palindrome.rb

@@ -0,0 +1,35 @@
+def is_palindrome(s)
+  str = s.downcase.chars.select { |char| /[a-zA-Z0-9]/.match?(char) }.join
+  idx_start = 0
+  idx_end = str.length - 1
+  while idx_start < idx_end
+    return false if str[idx_start] != str[idx_end]
+
+    idx_start += 1
+    idx_end -= 1
+  end
+  true
+end
+
+def is_palindrome(s)
+  idx_start = 0
+  idx_end = s.length - 1
+  while idx_start < idx_end
+    if !/[a-zA-Z0-9]/.match?(s[idx_start])
+      idx_start += 1
+    elsif !/[a-zA-Z0-9]/.match?(s[idx_end])
+      idx_end -= 1
+    else
+      return false if s[idx_start].downcase != s[idx_end].downcase
+
+      idx_start += 1
+      idx_end -= 1
+    end
+  end
+  true
+end
+
+def is_palindrome(s)
+  str = s.downcase.chars.select { |char| /[a-zA-Z0-9]/.match?(char) }
+  str == str.reverse
+end

ruby/141-Linked-List-Cycle.rb

@@ -0,0 +1,31 @@
+def hasCycle(head)
+  return false if head.nil?
+  return false if head.next.nil?
+
+  dict = {}
+  while head
+    return true if dict.key?(head)
+
+    dict[head] = true
+    head = head.next
+  end
+  false
+end
+
+# Tortoise and Hare solution
+def hasCycle(head)
+  return false if head.nil?
+  return false if head.next.nil?
+
+  fast = head
+  while head && fast
+    fast = fast.next
+    return false if fast.nil?
+
+    fast = fast.next
+    head = head.next
+
+    return true if head == fast
+  end
+  false
+end

ruby/15-3Sum.rb

@@ -0,0 +1,23 @@
+def three_sum(nums)
+  sums = []
+  nums.sort! # This is to get rid of duplicate solutions
+  nums.each_with_index do |num, idx|
+    next if idx.positive? && num == nums[idx - 1]
+
+    left = idx + 1
+    right = nums.length - 1
+    while left < right
+      case num + nums[left] + nums[right] <=> 0
+      when 1
+        right -= 1
+      when 0
+        sums << [num, nums[left], nums[right]]
+        left += 1
+        left += 1 while nums[left] == nums[left - 1] && left < right
+      when -1
+        left += 1
+      end
+    end
+  end
+  sums
+end

ruby/155-Min-Stack.rb

@@ -0,0 +1,33 @@
+class MinStack
+  def initialize
+    @stack = []
+  end
+
+  def push(val)
+    min = if @stack.empty?
+            val
+          else
+            val < @stack.last[1] ? val : @stack.last[1]
+          end
+
+    @stack << [val, min]
+    nil
+  end
+
+  def pop
+    @stack.pop
+    nil
+  end
+
+  def top
+    return nil if @stack.empty?
+
+    @stack.last[0]
+  end
+
+  def get_min
+    return nil if @stack.empty?
+
+    @stack.last[1]
+  end
+end