New Stack sol

Author: rahulcode22

Math/Sum_of_Multiples.py

@@ -0,0 +1,21 @@
+'''Given a number a and limit N. Find the sum of multiple of a upto N.'''
+#Simple Iterative O(n) Approach
+def sumUpto(a,n):
+    sum_ = 0
+    i = a
+    while i <= n:
+        sum_ += i
+        i += a
+    return sum_
+
+print sumUpto(7,49)
+
+
+#Another O(1) Approach
+def sumUpto(a,n):
+    m = n/a
+    sum_ = m*(m+1)/2
+    ans = a*sum_
+    return ans
+
+print sumUpto(7,49)

Stack/evaluateExpression.py

@@ -0,0 +1,30 @@
+'''Evaluate the value of an arithmetic expression in Reverse Polish Notation.
+
+Valid operators are +, -, *, /. Each operand may be an integer or another expression.
+
+'''
+class Solution:
+    # @param A : list of strings
+    # @return an integer
+    def evalRPN(self, tokens):
+        stack = []
+        for t in tokens:
+            if t not in ["+", "-", "*", "/"]:
+                stack.append(int(t))
+            else:
+                r, l = stack.pop(), stack.pop()
+                if t == "+":
+                    stack.append(l+r)
+                elif t == "-":
+                    stack.append(l-r)
+                elif t == "*":
+                    stack.append(l*r)
+                else:
+                # here take care of the case like "1/-22",
+                # in Python 2.x, it returns -1, while in
+                # Leetcode it should return 0
+                    if l*r < 0 and l % r != 0:
+                        stack.append(l/r+1)
+                    else:
+                        stack.append(l/r)
+        return stack.pop()

Stack/min-stack.py

@@ -0,0 +1,42 @@
+'''
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+'''
+class MinStack:
+    stack = []
+    minimums = []
+    # @param x, an integer
+    # @return an integer
+    def push(self, x):
+        if len(self.stack) == 0:
+            self.stack.append(x)
+            self.minimums.append(x)
+        else:
+            self.stack.append(x)
+            if x < self.minimums[-1]:
+                self.minimums.append(x)
+            else:
+                self.minimums.append(self.minimums[-1])
+
+    # @return nothing
+    def pop(self):
+        if len(self.stack) != 0:
+            self.stack.pop()
+            self.minimums.pop()
+
+    # @return an integer
+    def top(self):
+        if len(self.stack) == 0:
+            return -1
+        else:
+            return self.stack[-1]
+
+    # @return an integer
+    def getMin(self):
+        if len(self.stack) == 0:
+            return -1
+        else:
+            return self.minimums[-1]
+
+    def __init__(self):
+        self.stack = []
+        self.minimums = []

Stack/nearest-smaller-element.py

@@ -0,0 +1,22 @@
+'''
+
+Given an array, find the nearest smaller element G[i] for every element A[i] in the array such that the element has an index smaller than i.
+
+
+'''
+def smaller(arr):
+    res = []
+    stack = []
+    for i in range(len(arr)):
+        while len(stack) != 0 and stack[-1] >= arr[i]:
+            stack.pop()
+        if len(stack) == 0:
+            res.append(-1)
+        else:
+            res.append(stack[-1])
+
+        stack.append(arr[i])
+    return res
+
+arr = [1,3,0,2,5]
+print smaller(arr)

Stack/redundantBraces.py

@@ -0,0 +1,25 @@
+'''
+Write a program to validate if the input string has redundant braces?
+Return 0/1
+
+0 -> NO
+1 -> YES
+'''
+class Solution:
+    # @param A : string
+    # @return an integer
+    def braces(self, A):
+        stack = []
+        for el in A:
+            if el == "(":
+                stack.append(el)
+            elif el == "+" or el == "-" or el == "/" or el == "*":
+                stack.append("exp")
+            elif el == ")":
+                if stack[-1] == "exp":
+                    stack.pop()
+                    stack.pop()
+                else:
+                    return 1
+        else:
+            return 0

Stack/simplifydirectoryPath.py

@@ -0,0 +1,12 @@
+'''Given an absolute path for a file (Unix-style), simplify it.'''
+class Solution(object):
+    def simplifyPath(self, path):
+        places = [p for p in path.split("/") if p!="." and p!=""]
+        stack = []
+        for p in places:
+            if p == "..":
+                if len(stack) > 0:
+                    stack.pop()
+            else:
+                stack.append(p)
+        return "/" + "/".join(stack)