class MinHeap: for _ in range(int(input("How many?

"))):
def __init__(self, maxsize): heap.insert(int(input("Enter element: ")))
self.maxsize, self.size, self.Heap = maxsize, 0, [0] # Dummy index 0 heap.print_heap()
def parent(self, pos): return pos // 2 elif ch == "delete":
def leftChild(self, pos): return 2 * pos print(f"Removed: {heap.remove() if not heap.is_empty() else 'Heap is empty'}")
def rightChild(self, pos): return (2 * pos) + 1 heap.print_heap()
def isLeaf(self, pos): return pos * 2 > self.size elif ch == "e":
def swap(self, fpos, spos): self.Heap[fpos], self.Heap[spos] = self.Heap[spos], break
self.Heap[fpos] else:
def is_empty(self): return self.size == 0 print("Invalid choice!")
HEIGHT AND DEPTH OF A NODE IN TREE
def minHeapify(self, pos): class Node:
if not self.isLeaf(pos): def __init__(self, data):
left, right = self.leftChild(pos), self.rightChild(pos) self.left = self.right = None
smallest = left if left <= self.size and self.Heap[left] < self.Heap[pos] else pos self.data = data
if right <= self.size and self.Heap[right] < self.Heap[smallest]: smallest = right
if smallest != pos: class Tree:
self.swap(pos, smallest) def __init__(self, root):
self.minHeapify(smallest) self.root = Node(root)

def insert(self, element): def insert(self, node, data):

if self.size >= self.maxsize: if node is None: return Node(data)
print("Heap overflow!") if data < node.data: node.left = self.insert(node.left, data)
else: else: node.right = self.insert(node.right, data)
self.size += 1 return node
self.Heap.append(element)
curr = self.size def height(self, node):
while curr > 1 and self.Heap[curr] < self.Heap[self.parent(curr)]: return -1 if node is None else max(self.height(node.left), self.height(node.right)) +
self.swap(curr, self.parent(curr)) 1
curr = self.parent(curr)
def find_height(self, root, x):
def remove(self): if root is None: return -1
if self.is_empty(): return -1 if root.data == x: return self.height(root)
popped, self.Heap[1] = self.Heap[1], self.Heap.pop() return self.find_height(root.left, x) if x < root.data else self.find_height(root.right,
self.size -= 1 x)
self.minHeapify(1)
return popped def depth(self, root, x, d=0):
if root is None: return -1
def print_heap(self): print("Heap:", self.Heap[1:]) if root.data == x: return d
left = self.depth(root.left, x, d + 1)
if __name__ == "__main__": return left if left != -1 else self.depth(root.right, x, d + 1)
heap = MinHeap(int(input("Enter max heap size: ")))
while True: if __name__ == "__main__":
ch = input("\n(insert/delete/e to exit): ").strip().lower() tree = Tree(int(input("Enter root node: ")))
if ch == "insert": while True:
 ch = input("\n(insert/height/depth/exit): ").strip().lower() self.preorder(node.left)
if ch == "insert": self.preorder(node.right)
for _ in range(int(input("How many? "))):
tree.insert(tree.root, int(input("Enter node: "))) def postorder(self, node):
elif ch == "height": if node:
print(f"Height: {tree.find_height(tree.root, int(input('Node: ')))}") self.postorder(node.left)
elif ch == "depth": self.postorder(node.right)
print(f"Depth: {tree.depth(tree.root, int(input('Node: ')))}") print(node.data, end=" ")
elif ch == "exit": break
else: print("Invalid choice!") def traverse(self):
if not self.root:
TREE TRAVERSAL print("Tree is empty!")
class Node: return
def __init__(self, data): ch = input("\nChoose traversal (inorder/preorder/postorder/bfs):
self.left = self.right = None ").strip().lower()
self.data = data print(f"\n{ch.capitalize()} Traversal:")
if ch == "inorder": self.inorder(self.root)
class Tree: elif ch == "preorder": self.preorder(self.root)
def __init__(self, root): elif ch == "postorder": self.postorder(self.root)
self.root = Node(root) elif ch == "bfs": self.bfs(self.root)
else: print("Invalid choice!")
def insert(self, node, data):
if not node: return Node(data) if __name__ == "__main__":
if data < node.data: node.left = self.insert(node.left, data) tree = Tree(int(input("Enter root node: ")))
else: node.right = self.insert(node.right, data) while True:
return node ch = input("\n(insert/traverse/exit): ").strip().lower()
if ch == "insert":
def bfs(self, node): for _ in range(int(input("How many? "))):
if not node: return tree.insert(tree.root, int(input("Enter node: ")))
queue = [node] elif ch == "traverse":
while queue: tree.traverse()
curr = queue.pop(0) elif ch == "exit": break
print(curr.data, end=" ") else: print("Invalid choice!")
if curr.left: queue.append(curr.left)
if curr.right: queue.append(curr.right) REVERSE QUEUE
from collections import deque
def inorder(self, node):
if node: class RevQueue:
self.inorder(node.left) def __init__(self):
print(node.data, end=" ") self.q = deque()
self.inorder(node.right)
def enqueue(self, ele):
def preorder(self, node): self.q.append(ele)
if node:
print(node.data, end=" ") def dequeue(self):
 return self.q.popleft() if self.q else "Queue is empty" def display(self):
print(self.stack)
def reverse(self):
if len(self.q) > 1: st = RevStack()
self.q.reverse() while True:
else: ch = input("\n(push/pop/display/reverse/exit): ").strip().lower()
print("Queue should have more than 1 element.") if ch == "push":
st.push(input("Enter element: "))
def display(self): elif ch == "pop":
print(list(self.q)) print(f"Popped: {st.pop()}")
elif ch == "display":
q = RevQueue() st.display()
while True: elif ch == "reverse":
ch = input("\n(insert/delete/display/reverse/exit): ").strip().lower() st.reverse()
if ch == "insert": st.display()
q.enqueue(input("Enter element: ")) elif ch == "exit":
elif ch == "delete": break
print(f"Deleted: {q.dequeue()}") else:
elif ch == "display": print("Invalid choice!")
q.display()
elif ch == "reverse":
q.reverse() QUEUE USING CLASS
q.display() from collections import deque
elif ch == "exit":
break class Queue:
else: def __init__(self):
print("Invalid choice!") self.q = deque()

REVERSE STACK def enqueue(self, item):

class RevStack: self.q.append(item)
def __init__(self): print(f"Inserted: {item}")
self.stack = []
def dequeue(self):
def push(self, ele): print(f"Deleted: {self.q.popleft()}" if self.q else "Queue is empty.")
self.stack.append(ele)
def display(self):
def pop(self): print("Queue:", list(self.q) if self.q else "Queue is empty.")
return self.stack.pop() if self.stack else "Stack is empty"
q = Queue()
def reverse(self): while True:
if len(self.stack) > 1: ch = input("\n(insert/delete/display/exit): ").strip().lower()
self.stack.reverse() if ch == "insert":
else: q.enqueue(input("Enter element: "))
print("Stack should have more than 1 element.") elif ch == "delete":
q.dequeue()
 elif ch == "display": def sort_data(self):
q.display() print("Original list:", self.lst)
elif ch == "exit": self.qsort(self.lst, 0, len(self.lst) - 1)
break print("Sorted list:", self.lst)
else:
print("Invalid choice!") def partition(self, lst, left, right):
pivot, i = lst[right], left
STACK USING CLASS for j in range(left, right):
class Stack: if lst[j] < pivot:
def __init__(self): lst[i], lst[j] = lst[j], lst[i]
self.stk = [] i += 1
lst[i], lst[right] = lst[right], lst[i]
def push(self, item): return i
self.stk.append(item)
print(f"Pushed: {item}") def qsort(self, lst, left, right):
if left < right:
def pop(self): pi = self.partition(lst, left, right)
print(f"Popped: {self.stk.pop()}" if self.stk else "Stack is empty.") self.qsort(lst, left, pi - 1)
self.qsort(lst, pi + 1, right)
def display(self):
print("Stack:", self.stk if self.stk else "Stack is empty.") # Driver code
qs = QuickSort()
st = Stack() qs.read_data()
while True: qs.sort_data()
ch = input("\n(push/pop/display/exit): ").strip().lower()
if ch == "push": MERGE SORT
st.push(input("Enter element: ")) class MergeSort:
elif ch == "pop": def __init__(self):
st.pop() self.lst = [int(input(f"Enter element {i+1}: ")) for i in range(int(input("Enter
elif ch == "display": number of elements: ")))]
st.display()
elif ch == "exit": def sort_data(self):
break print("Original list:", self.lst)
else: self.lst = self.merge_sort(self.lst)
print("Invalid choice!") print("Sorted list:", self.lst)

QUICK SORT def merge_sort(self, lst):

class QuickSort: if len(lst) > 1:
def __init__(self): mid = len(lst) // 2
self.lst = [] left, right = lst[:mid], lst[mid:]
left, right = self.merge_sort(left), self.merge_sort(right)
def read_data(self): return self.merge(left, right)
self.lst = [int(input(f"Enter element {i+1}: ")) for i in range(int(input("Enter return lst
number of elements: ")))]
def merge(self, left, right):
 merged, i, j = [], 0, 0 def __init__(self, name, age, gender):
while i < len(left) and j < len(right): self.name, self.age, self.gender = name, age, gender.lower()
merged.append(left[i] if left[i] < right[j] else right[j])
i, j = (i + 1, j) if left[i] < right[j] else (i, j + 1) def greeting(self):
return merged + left[i:] + right[j:] print(f"Hello {'Mr.' if self.gender == 'male' else 'Ms./Mrs.'} {self.name}")

# Driver code class Student(Person):

ms = MergeSort() def __init__(self, name, age, gender, course, branch):
ms.sort_data() super().__init__(name, age, gender)
self.course, self.branch = course, branch
BINARY SEARCH
class BinarySearchRec: def details(self):
def __init__(self): print(f"Name: {self.name}\nAge: {self.age}\nGender: {self.gender}\nCourse:
self.L = [] {self.course}\nBranch: {self.branch}")

def read_data(self): # Driver code

self.L = [input("Enter name: ") for _ in range(int(input("Enter no. of names: ")))] s1 = Student(input("Enter name: "), int(input("Enter age: ")), input("Enter gender: "),
input("Enter course: "), input("Enter branch: "))
def input_search_data(self): s1.greeting()
while input("Do you wanna search again? y/n: ").lower() == 'y': s1.details()
name = input("Enter name to search: ")
self.search(name) CLASS
class Person:
def search(self, x, s=0, e=None, count=1): def __init__(self, name, age, gender):
if e is None: self.name, self.age, self.gender = name, age, gender.lower()
e = len(self.L) - 1
self.L.sort() def greeting(self):
if s <= e: print(f"Hello {'Mr.' if self.gender == 'male' else 'Ms./Mrs.'} {self.name}")
mid = (s + e) // 2 p1 = Person(input("Enter your name: "), int(input("Enter your age: ")), input("Enter
if self.L[mid] == x: your gender: "))
print(f"Name found at iteration {count}") p1.greeting()
elif self.L[mid] < x:
self.search(x, mid + 1, e, count + 1) POLYMORPHISM
else: def add(a, b): return a + b
self.search(x, s, mid - 1, count + 1) # Calling add() for different argument types
else: print(add(13, 14))
print("Name is not in the list") print(add("Hello ", "world"))
# Using len() for both list and string
# Driver code print("Length of the list:", len(['apple', 'banana', 'watermelon']))
bs = BinarySearchRec() print("Length of the string:", len("Hello world"))
bs.read_data()
bs.input_search_data() USER-DEFINE FUNCTION
def fullname(fname, lname): return f"\nHi {fname} {lname}"
INHERITANCE print(fullname(input("Enter your first name: "), input("Enter your last name: ")))
class Person:
STRING OPERATION & INDEX OF THE CHARACTER IN STRING marks = int(input("Enter your subject marks: "))
for i, ch in enumerate(input("Enter a string: ")): if marks >= 50: print("Congratulations! You cleared the subject")
print(f"\n\t {i} \t {ch}") else: print("You failed. Better luck next time")

WHILE LOOP SPLIT() BUILT-IN FUNCTION

total = 0 x, y = map(int, input("Enter x and y: ").split())
number = int(input("Enter an integer below 20: ")) print(f"x = {x}\ny = {y}")
while number <= 20: total, number = total + number, number + 1
print(f"Total: {total}" if number <= 20 else "Value is greater than 20") TYPE() BUILT-IN FUNCTION
number = int(input("Enter a Number"))
PRIME NUMBER USING GIVEN RANGE print(f"The Number is {number}\ntype(Number) is {type(number)}")
def isprime(n): return n > 1 and all(n % i for i in range(2, n))
N = int(input("Enter a number: ")) LIST OBJECT EXAMPLE
print("Prime numbers:", *[i for i in range(2, N + 1) if isprime(i)]) list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 8, 3]
FOR LOOP USING OBJECT-LIST list3 = ["true", "false"]
Fruit = ['Apple', 'Banana', 'Grapes', 'Cherry']
print("Fruits are:", *Fruit) print(list1, list2, list3, f"\n3rd item in list1: {list1[2]}")
for item in Fruit: print("Items are:", item) print("\nlist1 items:")
for item in list1: print(item)
FOR LOOP USING OBJECT-STRING
Str = "Computer Science" INTEGER AND STRING EXAMPLE
for word in Str: print("Letters are:", word) temp = 30
print("----This is Outside String---") print("Temp =", temp, f"\ntemp_alias = {temp}")
temp_alias = 35.5
FOR LOOP USING RANGE() print(f"Temp = {temp}, temp_alias = {temp_alias}")
for number in range(9, 14): print(number) temp = "ABC"
print() print(f"Temp = {temp}, Type = {type(temp)}")
for num in range(5, 18, 2): print(num)
VARIABLE IN PYTHON
CONDITIONAL STATEMENT(NESTED IF) x, y = 5, "hello, world!"
age = int(input("Enter your age: ")) print(x, y)
if age < 18: print("You are minor\nYou are not eligible for work")
elif age <= 60: print("You are eligible for work\nPlease fill the form") SUM OF TWO NUMBER
else: print("You are too old to work as per government order") while input("Do you want to continue? y/n: ") == "y":
n1, n2 = int(input("Enter a number: ")), int(input("Enter another number: "))
print(f"Sum of {n1} + {n2} = {n1 + n2}")
CONDITIONAL STATEMENT(IF-ELIF- ELSE)
Totalmarks = int(input("Enter your total marks: "))
if Totalmarks >= 540: print("Congrats! You are eligible for full scholarship")
elif Totalmarks >= 480: print("Congrats! You are eligible for 50% scholarship")
elif Totalmarks >= 400: print("Congrats! You are eligible for 10% scholarship")
else: print("Sorry, you are not eligible for a scholarship")

CONDITIONAL STATEMENT(IF ELSE)