Python_Implementation

Author: MayankVerma105

Max1.py

@@ -0,0 +1,3 @@
+l1=[1,34,23,67,35]
+print(max(l1))
+print(min(l1))

Pallindrome_Stack.py

@@ -0,0 +1,60 @@
+# Python3 implementation of the approach
+stack = []
+top = -1
+
+# push function
+def push(ele: str):
+	global top
+	top += 1
+	stack[top] = ele
+
+# pop function
+def pop():
+	global top
+	ele = stack[top]
+	top -= 1
+	return ele
+
+# Function that returns 1
+# if str is a palindrome
+def isPalindrome(string: str) -> bool:
+	global stack
+	length = len(string)
+
+	# Allocating the memory for the stack
+	stack = ['0'] * (length + 1)
+
+	# Finding the mid
+	mid = length // 2
+	i = 0
+	while i < mid:
+		push(string[i])
+		i += 1
+
+	# Checking if the length of the string
+	# is odd, if odd then neglect the
+	# middle character
+	if length % 2 != 0:
+		i += 1
+
+	# While not the end of the string
+	while i < length:
+		ele = pop()
+
+		# If the characters differ then the
+		# given string is not a palindrome
+		if ele != string[i]:
+			return False
+		i += 1
+	return True
+
+# Driver Code
+if __name__ == "__main__":
+
+	string = "madam"
+
+	if isPalindrome(string):
+		print("Yes")
+	else:
+		print("No")
+

balParenthesis.py

@@ -0,0 +1,28 @@
+def isBalanced(exp):
+    flag = True
+    count = 0
+    for i in range(len(exp)):
+        if(exp[i] == '('):
+            count += 1
+        else:
+            count -= 1
+        if(count < 0):
+            flag = False
+            break
+    if(count != 0):
+        flag = False
+    return flag
+if __name__ == '__main__':
+
+    exp1 = "((()))()()"
+    if(isBalanced(exp1)):
+        print("Balanced ")
+    else:
+        print("Not Balanced ")
+
+    exp2 = "())((())"
+
+    if(isBalanced(exp2)):
+        print("Balanced ")
+    else:
+        print("Not Balanced ")

binarySearch.py

@@ -0,0 +1,28 @@
+def binarySearch(lst,searchValue):
+    low, high = 0, len(lst) - 1
+    while low <= high:
+        mid = int((low + high)/2)
+        if lst[mid] == searchValue:
+            return mid
+        elif searchValue < lst[mid]:
+            high = mid - 1
+        else:
+            low = mid + 1
+    return None
+    
+def isSorted(lst):
+    for i in range(1, len(lst)):
+        if lst[i] < lst[i - 1]:
+            return False
+    return True
+
+def main():
+    lst = eval(input('Enter a sorted list : '))
+    if not(isSorted(lst)):
+        print('Given list is not Sorted')
+    else:
+        searchVal = eval(input('Enter the value to be searched'))
+        print(searchVal,'found index at',binarySearch(lst,searchVal))
+
+if __name__ == '__main__':
+    main()

bubbleSort.py

@@ -0,0 +1,15 @@
+def bubbleSort(lst):
+    n = len(lst) - 1
+    for i in range(0, n):
+        for j in range(0, i, -1):
+            if lst[j] < lst[j - 1]:
+                lst[j], lst[j - 1] = lst[j - 1], lst[j]
+
+def main():
+    lst = eval(input('Enter the list : '))
+    print('Sorted list')
+    lst.sort()
+    print(lst)
+
+if __name__=='__main__':
+    main()

bubbleSort1.py

@@ -0,0 +1,18 @@
+def bubbleSort(lst):
+    n = len(lst)-1
+    for i in range(0,n):
+        swap = False
+        for j in range(n, i ,-1):
+            if lst[j] < lst[j - 1]:
+                swap = True
+                lst[j], lst[j - 1] = lst [j - 1], lst[j]
+        if swap == False:
+            break
+def main():
+    lst = eval(input('Enter the list'))
+    print('Sorted list')
+    bubbleSort(lst)
+    print(lst)
+
+if __name__ == '__main__':
+    main()

enQueue.py

@@ -0,0 +1,55 @@
+class Queue:
+    def __init__(self, capacity):
+        self.front = self.size = 0
+        self.rear = capacity - 1
+        self.Q =[None]*capacity
+        self.capacity = capacity
+
+    def isFull(self):
+        return self.size == self.capacity
+
+    def isEmpty(self):
+        return self.size == 0
+
+    def EnQueue(self, item):
+        if self.isFull():
+            print('Full')
+            return
+        self.rear = (self.rear + 1) % (self.capacity)
+        self.Q[self.rear] = item
+        self.size = self.size + 1
+        print('% s enqueued to queue' %str(item))
+
+    def DeQueue(self):
+        if self.isEmpty():
+            print('Empty')
+            return
+
+        print('% s dequeued from queue' % str(self.Q[self.front]))
+        self.front = (self.front + 1) % (self.capacity)
+        self.size = self.size -1
+
+    def que_front(self):
+        if self.isEmpty():
+            print('Queue is empty')
+
+        print('Front item is ', self.Q[self.front])
+
+    def que_rear(self):
+        if self.isEmpty():
+            print('Queue is empty')
+
+        print('Rear item is ', self.Q[self.rear])
+
+#Driver Code
+
+if __name__ == '__main__':
+    queue = Queue(30)
+    queue.EnQueue(10)
+    queue.EnQueue(20)
+    queue.EnQueue(30)
+    queue.EnQueue(40)
+    queue.DeQueue()
+    queue.que_front()
+    queue.que_rear()
+            

evaluatePostfix.py

@@ -0,0 +1,22 @@
+from stack import Stack
+def evaluatePostfixExp(exp):
+    stk = Stack()
+    operations = ['+','-','*','/']
+    for symbol in exp:
+        if symbol in operations:
+            operand2 = stk.pop()
+            operand1 = stk.pop()
+            result = str(eval(operand1 + symbol + operand2 ))
+            stk.push(result)
+        else:
+            stk.push(symbol)
+    result = int(stk.pop())
+    return result
+
+def main():
+    exp = input('Enter a postfix expression use single digit number only:')
+    result = evaluatePostfixExp(exp)
+    print(result)
+
+if __name__ == '__main__':
+    main()

getmin.py

@@ -0,0 +1,98 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+    def __str__(self):
+        return 'Node ({})'.format(self.value)
+
+    __repr__ = __str__
+
+
+class Stack:
+    def __init__(self):
+        self.top = None
+        self.count = 0
+        self.minimum = None
+
+    def __str__(self):
+        temp = self.top
+        out = []
+        while temp:
+            out.append(str(temp.value))
+            temp = temp.next
+        out = '\n'.join(out)
+        return('Top {} \n\nStack : \n{}'.format(self.top.out))
+
+    def getMin(self):
+        if self.top is None:
+            return "Stack is empty"
+        else:
+            print("Minimum Element in the stack is: {}" .format(self.minimum))
+
+    def isEmpty(self):
+        if self.top == None:
+            return True
+        else:
+            return False
+
+    def __len__(self):
+        self.count = 0
+        tempNode = self.top
+        while tempNode:
+            tempNode = tempNode.next
+            self.count += 1
+        return self.count
+
+    def peek(self):
+        if self.top is None:
+            print('Stack is Empty')
+        else:
+            if self.top.value < self.minimum:
+                print('Top Most Element is : {}'.format(self.minimum))
+            else:
+                print('Top Most Element is : {}'.format(self.top.value))
+
+    def push(self,value):
+        if self.top is None:
+            self.top = Node(value)
+            self.minimum = value
+
+        elif value < self.minimum:
+            temp = (2 * value) - self.minimum
+            new_node = Node(temp)
+            new_node.next = self.top
+            self.top = new_node
+            self.minimum = value
+        else:
+            new_node = Node(value)
+            new_node.next = self.top
+            self.top = new_node
+        print('Number Inserted : {} '.format(value))
+
+    def pop(self):
+        if self.top is None:
+            print('Stack is empty')
+        else:
+            removedNode = self.top.value
+            self.top = self.top.next
+            if removedNode < self.minimum:
+                print("Top Most Element Removed :{} " .format(self.minimum))
+                self.minimum = ( ( 2 * self.minimum ) - removedNode )
+            else:
+                print ("Top Most Element Removed : {}" .format(removedNode))
+
+
+#Driver Class
+stack = Stack()
+ 
+stack.push(3)
+stack.push(5)
+stack.getMin()
+stack.push(2)
+stack.push(1)
+stack.getMin()    
+stack.pop()
+stack.getMin()
+stack.pop()
+stack.peek()

implementQueue.py

@@ -0,0 +1,55 @@
+class Queue:
+    def __init__(self, capacity):
+        self.front = self.size = 0
+        self.rear = capacity - 1
+        self.Q =[None]*capacity
+        self.capacity = capacity
+
+    def isFull(self):
+        return self.size == self.capacity
+
+    def isEmpty(self):
+        return self.size == 0
+
+    def EnQueue(self, item):
+        if self.isFull():
+            print('Full')
+            return
+        self.rear = (self.rear + 1) % (self.capacity)
+        self.Q[self.rear] = item
+        self.size = self.size + 1
+        print('% s enqueued to queue' %str(item))
+
+    def DeQueue(self):
+        if self.isEmpty():
+            print('Empty')
+            return
+
+        print('% s dequeued from queue' % str(self.Q[self.front]))
+        self.front = (self.front + 1) % (self.capacity)
+        self.size = self.size -1
+
+    def que_front(self):
+        if self.isEmpty():
+            print('Queue is empty')
+
+        print('Front item is ', self.Q[self.front])
+
+    def que_rear(self):
+        if self.isEmpty():
+            print('Queue is empty')
+
+        print('Rear item is ', self.Q[self.rear])
+
+#Driver Code
+
+if __name__ == '__main__':
+    queue = Queue(30)
+    queue.EnQueue(10)
+    queue.EnQueue(20)
+    queue.EnQueue(30)
+    queue.EnQueue(40)
+    queue.DeQueue()
+    queue.que_front()
+    queue.que_rear()
+