increment 1

data_structures/stacks/Stock-Span-Problem.py

@@ -0,0 +1,52 @@
+'''
+The stock span problem is a financial problem where we have a series of n daily 
+price quotes for a stock and we need to calculate span of stock's price for all n days.
+
+The span Si of the stock's price on a given day i is defined as the maximum 
+number of consecutive days just before the given day, for which the price of the stock 
+on the current day is less than or equal to its price on the given day.
+'''
+from __future__ import print_function
+def calculateSpan(price, S): 
+      
+    n = len(price) 
+    # Create a stack and push index of fist element to it 
+    st = []  
+    st.append(0) 
+  
+    # Span value of first element is always 1 
+    S[0] = 1 
+  
+    # Calculate span values for rest of the elements 
+    for i in range(1, n): 
+          
+        # Pop elements from stack whlie stack is not 
+        # empty and top of stack is smaller than price[i] 
+        while( len(st) > 0 and price[st[0]] <= price[i]): 
+            st.pop() 
+  
+        # If stack becomes empty, then price[i] is greater 
+        # than all elements on left of it, i.e. price[0], 
+        # price[1], ..price[i-1]. Else the price[i]  is 
+        # greater than elements after top of stack 
+        S[i] = i+1 if len(st) <= 0 else (i - st[0]) 
+  
+        # Push this element to stack 
+        st.append(i) 
+  
+  
+# A utility function to print elements of array 
+def printArray(arr, n): 
+    for i in range(0,n): 
+        print (arr[i],end =" ") 
+  
+  
+# Driver program to test above function 
+price = [10, 4, 5, 90, 120, 80] 
+S = [0 for i in range(len(price)+1)] 
+  
+# Fill the span values in array S[] 
+calculateSpan(price, S) 
+  
+# Print the calculated span values 
+printArray(S, len(price)) 

data_structures/stacks/__init__.py

@@ -0,0 +1,23 @@
+class Stack:
+
+   def __init__(self):
+      self.stack = []
+      self.top = 0
+
+   def is_empty(self):
+      return (self.top == 0)
+
+   def push(self, item):
+      if self.top < len(self.stack):
+         self.stack[self.top] = item
+      else:
+         self.stack.append(item)
+
+      self.top += 1
+
+   def pop(self):
+      if self.is_empty():
+         return None
+      else:
+         self.top -= 1
+         return self.stack[self.top]

data_structures/stacks/balanced_parentheses.py

@@ -0,0 +1,23 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from .Stack import Stack
+
+__author__ = 'Omkar Pathak'
+
+
+def balanced_parentheses(parentheses):
+    """ Use a stack to check if a string of parentheses are balanced."""
+    stack = Stack(len(parentheses))
+    for parenthesis in parentheses:
+        if parenthesis == '(':
+            stack.push(parenthesis)
+        elif parenthesis == ')':
+            stack.pop()
+    return not stack.is_empty()
+
+
+if __name__ == '__main__':
+    examples = ['((()))', '((())']
+    print('Balanced parentheses demonstration:\n')
+    for example in examples:
+        print(example + ': ' + str(balanced_parentheses(example)))

data_structures/stacks/infix_to_postfix_conversion.py

@@ -0,0 +1,64 @@
+from __future__ import print_function
+from __future__ import absolute_import
+import string
+
+from .Stack import Stack
+
+__author__ = 'Omkar Pathak'
+
+
+def is_operand(char):
+    return char in string.ascii_letters or char in string.digits
+
+
+def precedence(char):
+    """ Return integer value representing an operator's precedence, or
+    order of operation.
+
+    https://en.wikipedia.org/wiki/Order_of_operations
+    """
+    dictionary = {'+': 1, '-': 1,
+                  '*': 2, '/': 2,
+                  '^': 3}
+    return dictionary.get(char, -1)
+
+
+def infix_to_postfix(expression):
+    """ Convert infix notation to postfix notation using the Shunting-yard
+    algorithm.
+
+    https://en.wikipedia.org/wiki/Shunting-yard_algorithm
+    https://en.wikipedia.org/wiki/Infix_notation
+    https://en.wikipedia.org/wiki/Reverse_Polish_notation
+    """
+    stack = Stack(len(expression))
+    postfix = []
+    for char in expression:
+        if is_operand(char):
+            postfix.append(char)
+        elif char not in {'(', ')'}:
+            while (not stack.is_empty()
+                    and precedence(char) <= precedence(stack.peek())):
+                postfix.append(stack.pop())
+            stack.push(char)
+        elif char == '(':
+            stack.push(char)
+        elif char == ')':
+            while not stack.is_empty() and stack.peek() != '(':
+                postfix.append(stack.pop())
+            # Pop '(' from stack. If there is no '(', there is a mismatched
+            # parentheses.
+            if stack.peek() != '(':
+                raise ValueError('Mismatched parentheses')
+            stack.pop()
+    while not stack.is_empty():
+        postfix.append(stack.pop())
+    return ' '.join(postfix)
+
+
+if __name__ == '__main__':
+    expression = 'a+b*(c^d-e)^(f+g*h)-i'
+
+    print('Infix to Postfix Notation demonstration:\n')
+    print('Infix notation: ' + expression)
+    print('Postfix notation: ' + infix_to_postfix(expression))

data_structures/stacks/next.py

@@ -0,0 +1,17 @@
+from __future__ import print_function
+# Function to print element and NGE pair for all elements of list
+def printNGE(arr):
+ 
+    for i in range(0, len(arr), 1):
+ 
+        next = -1
+        for j in range(i+1, len(arr), 1):
+            if arr[i] < arr[j]:
+                next = arr[j]
+                break
+             
+        print(str(arr[i]) + " -- " + str(next))
+ 
+# Driver program to test above function
+arr = [11,13,21,3]
+printNGE(arr)

data_structures/stacks/stack.py

@@ -0,0 +1,69 @@
+from __future__ import print_function
+__author__ = 'Omkar Pathak'
+
+
+class Stack(object):
+    """ A stack is an abstract data type that serves as a collection of
+    elements with two principal operations: push() and pop(). push() adds an
+    element to the top of the stack, and pop() removes an element from the top
+    of a stack. The order in which elements come off of a stack are
+    Last In, First Out (LIFO).
+
+    https://en.wikipedia.org/wiki/Stack_(abstract_data_type)
+    """
+
+    def __init__(self, limit=10):
+        self.stack = []
+        self.limit = limit
+
+    def __bool__(self):
+        return not bool(self.stack)
+
+    def __str__(self):
+        return str(self.stack)
+
+    def push(self, data):
+        """ Push an element to the top of the stack."""
+        if len(self.stack) >= self.limit:
+            raise StackOverflowError
+        self.stack.append(data)
+
+    def pop(self):
+        """ Pop an element off of the top of the stack."""
+        if self.stack:
+            return self.stack.pop()
+        else:
+            raise IndexError('pop from an empty stack')
+
+    def peek(self):
+        """ Peek at the top-most element of the stack."""
+        if self.stack:
+            return self.stack[-1]
+
+    def is_empty(self):
+        """ Check if a stack is empty."""
+        return not bool(self.stack)
+
+    def size(self):
+        """ Return the size of the stack."""
+        return len(self.stack)
+
+
+class StackOverflowError(BaseException):
+    pass
+
+
+if __name__ == '__main__':
+    stack = Stack()
+    for i in range(10):
+        stack.push(i)
+
+    print('Stack demonstration:\n')
+    print('Initial stack: ' + str(stack))
+    print('pop(): ' + str(stack.pop()))
+    print('After pop(), the stack is now: ' + str(stack))
+    print('peek(): ' + str(stack.peek()))
+    stack.push(100)
+    print('After push(100), the stack is now: ' + str(stack))
+    print('is_empty(): ' + str(stack.is_empty()))
+    print('size(): ' + str(stack.size()))