grind 75 problems

Author: kumar91gopi

README.md

@@ -153,6 +153,7 @@ solution of many challenges of [HackerRank](https://www.hackerrank.com) and [Cod
 
 1. [Print Next Greatest Element for each element of array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/arrays/NextGreatestElement.rb)
 2. [Backspace String Compare](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/backspace_string_compare.rb)
+3. [Evaluate Reverse Polish Notation](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/evaluate_reverse_polish_notation.rb)
 
 <a name="linked_list"/>
 
@@ -162,7 +163,7 @@ solution of many challenges of [HackerRank](https://www.hackerrank.com) and [Cod
 3. [Linked List Cycle](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/linked_list_cycle.rb)
 4. [Merge Two Sorted Lists](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/merge_sorted_lists.rb)
 5. [Palindrome Linked List](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/palindrome_linked_list.rb)
-
+6. [Remove nth node from end in list](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/remove_nth_node_from_end_of_list.rb)
 
 <a name="bitAlgo"/>
 
@@ -274,6 +275,12 @@ solution of many challenges of [HackerRank](https://www.hackerrank.com) and [Cod
 34. [Reverse Bits](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/reverse_bits.rb)
 35. [Meeting Rooms](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/meeting_rooms.rb)
 36. [Roman to Integer](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/roman_to_integer.rb)
+37. [Merge Intervals](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/merge_intervals.rb)
+38. [Insert Intervals](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/insert_intervals.rb)
+39. [Product of Array Except self](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/product_of_array_except_self.rb)
+40. [Sort Colors](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/sort_colors.rb)
+41. [Evaluate Reverse Polish Notation](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/evaluate_reverse_polish_notation.rb)
+42. [Remove nth node from end in list](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/leetcode/grind75/remove_nth_node_from_end_of_list.rb)
 
 <a name="striver"/>
 

leetcode/grind75/evaluate_reverse_polish_notation.rb

@@ -0,0 +1,38 @@
+=begin
+You are given an array of strings tokens that represents an arithmetic expression in a Reverse Polish Notation.
+Evaluate the expression. Return an integer that represents the value of the expression.
+Note that:
+
+1. The valid operators are '+', '-', '*', and '/'.
+2. Each operand may be an integer or another expression.
+3. The division between two integers always truncates toward zero.(IMP: 6/-132 = -1 in ruby/python not 0 so modify / accordingly )
+4. There will not be any division by zero.
+5. The input represents a valid arithmetic expression in a reverse polish notation.
+6. The answer and all the intermediate calculations can be represented in a 32-bit integer.
+=end
+
+# Solution 
+def eval_rpn(tokens)
+    operations = {
+        "+" => ->(a,b) {a+b},
+        "-" => ->(a,b) {a-b},
+        "*" => ->(a,b) {a*b},
+        # "/" => lambda (a,b) { b.zero? ? raise ArgumentError: a/b} (if 4th confition was not given)
+        "/" => ->(a,b) {a*b<0 ? -1*(a.abs/b.abs): a/b } # To satisfy 3rd condition we divide absolute values
+    }
+    op_stack = []
+    tokens.each do |token|
+       #raise ArgumentError if (op_stack.empty? or op_stack.length==1 ) and operations.has_key?(token) (if 5th confition was not given)
+        if operations.has_key?(token)
+            b = op_stack.pop
+            a = op_stack.pop
+            result = operations[token].(a,b)
+            p [a,b,result]
+            op_stack.push(result)
+        else
+            op_stack.push(token.to_i)
+        end
+    end
+    op_stack[-1]
+end
+

leetcode/grind75/insert_intervals.rb

@@ -0,0 +1,40 @@
+=begin
+You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and the end of the ith interval
+and intervals is sorted in ascending order by starti. You are also given an interval newInterval = [start, end] that represents the start and end of another interval.
+Insert newInterval into intervals such that intervals is still sorted in ascending order by starti and intervals still does not have any overlapping intervals
+(merge overlapping intervals if necessary).
+
+Return intervals after the insertion.
+
+Note that you don't need to modify intervals in-place. You can make a new array and return it.
+
+=end
+
+# Solution
+def insert(intervals, new_interval)
+    #intervals = intervals.sort{ |a,b| a[0]<=>b[0]} (if intervals are not in sorted order then sort first)
+    curr_interval=new_interval
+    merged_intervals = []
+    for i in 0...intervals.length
+        if new_interval[0]>intervals[i][1]
+            merged_intervals.push(intervals[i])
+            next
+        end
+        if is_overlapping(intervals[i],curr_interval)
+            curr_interval[0] = [intervals[i][0],curr_interval[0]].min
+            curr_interval[1] = [intervals[i][1],curr_interval[1]].max
+            next
+        end
+        merged_intervals.push(curr_interval)
+        curr_interval = intervals[i]
+    end 
+    merged_intervals.push(curr_interval)
+    merged_intervals
+end
+
+def is_overlapping(given_intv,curr_intv)
+    # either interval 1's end time lies between interval 2 or vice-versa
+    (given_intv[1]>=curr_intv[0] and given_intv[1]<=curr_intv[1]) or \
+    (given_intv[0]<=curr_intv[1] and given_intv[1]>=curr_intv[1])
+end
+

leetcode/grind75/merge_intervals.rb

@@ -0,0 +1,43 @@
+=begin
+Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals,
+and return an array of the non-overlapping intervals that cover all the intervals in the input.
+=end
+
+#Solution 1 (use last pushed intervals to check overlap)
+def merge(intervals)
+    intervals = intervals.sort{ |a,b| a[0]<=>b[0]}
+    merged_intervals = [intervals[0]]
+    for i in 1...intervals.length
+        if is_overlapping(merged_intervals[-1],intervals[i])
+            merged_intervals[-1][1] = [merged_intervals[-1][1],intervals[i][1]].max
+            next
+        end
+        merged_intervals.push(intervals[i])
+    end
+    merged_intervals
+end
+
+def is_overlapping(intv1,intv2)
+    intv1[1]>=intv2[0]
+end
+
+#Solution 2
+def merge(intervals)
+    intervals = intervals.sort{ |a,b| a[0]<=>b[0]}
+    merged_intervals = []
+    curr_interval = intervals[0]
+    for i in 1...intervals.length
+        if is_overlapping(curr_interval,intervals[i])
+            curr_interval[1] = [curr_interval[1],intervals[i][1]].max
+            next
+        end
+        merged_intervals.push(curr_interval)
+        curr_interval = intervals[i]
+    end
+    merged_intervals.push(curr_interval)
+    merged_intervals
+end
+
+def is_overlapping(intv1,intv2)
+    intv1[1]>=intv2[0]
+end

leetcode/grind75/product_of_array_except_self.rb

@@ -0,0 +1,22 @@
+=begin
+
+=end
+
+#Solution
+#Approach:  I first pass populate result array with product of all
+# leftside elements then do the same for right side in second pass
+def product_except_self(nums)
+    n = nums.length
+    product_arr = [1]*n
+    left_product = 1
+    for i in 0...n
+        product_arr[i]=left_product
+        left_product*=nums[i]
+    end
+    right_product = 1
+    (n-1).downto(0) do |i|
+        product_arr[i]*=right_product
+        right_product*=nums[i]
+    end
+    product_arr
+end

leetcode/grind75/remove_nth_node_from_end_of_list.rb

@@ -0,0 +1,32 @@
+=begin
+Given the head of a linked list, remove the nth node from the end of the list and return its head.
+=end
+
+#Solution 1 (First find length and then remove l-n+1 node, O(n) requires 2 passes)
+
+#Solution 1 (fast and slow pointer approach)
+#Approach: Give a head start to a pointer by n steps then move other pointer till head_start reaches end of list
+
+def remove_nth_from_end(head, n)
+    return [] if head.nil?
+    head_start = head
+    follower = head
+    prev_node = nil
+    count = 0
+    while count<n
+        head_start = head_start.next
+        count+=1
+    end
+    while head_start
+        prev_node = follower
+        follower = follower.next
+        head_start = head_start.next
+    end
+    if prev_node.nil?
+        head = follower.next
+    else
+        prev_node.next = follower.next
+    end
+    head
+end
+   

leetcode/grind75/sort_colors.rb

@@ -0,0 +1,28 @@
+=begin
+Given an array a with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent,
+with the colors in the order red, white, and blue.
+We will use the integers 0, 1, and 2 to represent the color red, white, and blue, respectively.
+
+You must solve this problem without using the library's sort function.
+=end
+
+#Solution 1 (count the number of 0,1 and 2 and rewrite, need constant extra space but 2 paases)
+
+#Solution 2(Dutch Nation Flag Algo)
+#Approach: 3 pointers, left and right move according to value encountered at mid
+def sort_colors(a)
+    left,middle,right = 0,0,a.length-1
+    while middle<=right
+        if a[middle]==0
+            a[left],a[middle]=a[middle],a[left]
+            left+=1
+            middle+=1
+        elsif a[middle]==1
+            middle+=1
+        else
+            a[right],a[middle]=a[middle],a[right]
+            right-=1
+        end
+    end
+    a
+end