🔰 Beginner Level

🟢 Intermediate Level

🚀 Advanced Level

1️⃣ Arrays & Hashing

Lists

names= ['Badhan','Anik','Alamin']ages= [30,29,29]forname,ageinzip(names,ages):print(name,age)"""OutputBadhan 30Anik 29Alamin 29"""

Resizable List Part 1

my_list= [1,2,3]my_list.append(4)# Adds a single element to the endprint(my_list)# Output: [1, 2, 3, 4]

Resizable List Part 2

my_list= [1,2,3,4]my_list.pop()# Removes and returns the last itemprint(my_list)# Output: [1, 2, 3]my_list.remove(2)# Removes the first occurrence of the valueprint(my_list)# Output: [1, 3]

List Concat

list1= [1,2]list2= [3,4]concatenated_list=list1+list2# Using +print(concatenated_list)# Output: [1, 2, 3, 4]list1.extend(list2)# Using extend()print(list1)# Output: [1, 2, 3, 4]

List Initialization

empty_list= []# Empty listlist_with_values= [1,2,3]# List with initial valueslist_from_range=list(range(5))# List from rangeprint(list_from_range)# Output: [0, 1, 2, 3, 4]

List Clone

original_list= [1,2,3]cloned_list=original_list[:]# Using slicingprint(cloned_list)# Output: [1, 2, 3]another_clone=original_list.copy()# Using copy()print(another_clone)# Output: [1, 2, 3]

List Comprehension

squares= [x**2forxinrange(5)]print(squares)# Output: [0, 1, 4, 9, 16]

List methods

list.pop(i)# O(n)list.insert(i,val)# O(n)

2D or 3D list

n=4# Number of rowsm=5# Number of columnsdefault_value=0# Default value for each cell# Create n x m 2D gridgrid_2d= [[default_valuefor_inrange(m)]for_inrange(n)]# Print the 2D gridforrowingrid_2d:print(row)"""Output[0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0]"""l=3# Number of layersn=4# Number of rowsm=5# Number of columnsdefault_value=0# Default value for each cell# Create l x n x m 3D gridgrid_3d= [[[default_valuefor_inrange(m)]for_inrange(n)]for_inrange(l)]# Print the 3D gridforlayeringrid_3d:print("Layer:")forrowinlayer:print(row)"""OutputLayer:[0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0]Layer:[0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0]Layer:[0, 0, 0, 0, 0][0, 0, 0, 0, 0][0, 0, 0, 0, 0]"""

Hashmaps and Hashsets

# Initialize a dictionarymy_dict= {'a':1,'b':2,'c':3}# Access Methodsvalue=my_dict.get('d',0)# O(1)keys=my_dict.keys()# O(1)values=my_dict.values()# O(1)items=my_dict.items()# O(1)# Using a for loopforkeyinmy_dict:print(key)# Using the dict.keys() methodforkeyinmy_dict.keys():print(key)# Using the dict.values() methodforvalueinmy_dict.values():print(value)# Using the dict.items() methodforkey,valueinmy_dict.items():print(key,value)# Modification Methodspopped_value=my_dict.pop('b',0)# O(1)popped_item=my_dict.popitem()# O(1), Removes and returns the last inserted itemmy_dict.update({'d':4,'e':5})# O(k), where k is the number of items being addedmy_dict.clear()# O(n)copy_dict=my_dict.copy()# O(n)value=my_dict.setdefault('z',30)# O(1)# Check Key Existenceif'x'inmy_dict:# O(1)print('Key exists')# Create a dictionary of squaressquares= {x:x*xforxinrange(6)}# O(n)# defaultdictfromcollectionsimportdefaultdict# Create a default dictionary with int as the default factory# The key will be the default value of int, which is 0.dict1=defaultdict(int)# Create a defaultdict with -1 as the default valuedict2=defaultdict(lambda:-1)default_dict=defaultdict(int)# O(1)default_dict['a']+=1# O(1)# CounterfromcollectionsimportCountercounter=Counter(['a','b','c','a','b','a'])# O(n)print(counter.most_common(2))# O(k log k), where k is the number of unique elements# Tuples as Keystuple_keys= {(1,2):'a', (3,4):'b'}# O(1) for access and insertiontuple_keys[(5,6)]='c'fromcollectionsimportCounter# Sample counter mapcounter_map=Counter({'a':5,'b':1,'c':3,'d':4})# Sorting using sorted() functionsorted_items=sorted(counter_map.items(),key=lambdax:x[1],reverse=True)# This will create a list not map# Printing sorted itemsprint(sorted_items)# [('a', 5), ('d', 4), ('c', 3), ('b', 1)]

Time Complexity Table

# Sets= {1,2,3}s.clear()# O(1), Clear the sets= {1,2,3}s.add(4)# O(1)print("After add(4):",s)# {1, 2, 3, 4}# Remove element (throws KeyError if item is not present)s.remove(2)# O(1)print("After remove(2):",s)# {2, 3, 4}# Discard element (no error if item is not present)s.discard(5)# O(1)s.remove(3)# O(1)print("After discard(5) and remove(3):",s)# {2, 4}# Pop a random elementpopped_item=s.pop()# O(1), removes random item (since unordered)print(f"Popped item:{popped_item}")print("After pop():",s)# Set ComparisonsA= {1,2,3}B= {3,4,5}# Check if sets are disjoint (no common elements)print("A.isdisjoint(B):",A.isdisjoint(B))# False (O(min(len(A), len(B))))# Check if A is subset of B (A <= B)print("A.issubset(B):",A.issubset(B))# False (O(min(len(A), len(B))))# Check if A is superset of B (A >= B)print("A.issuperset(B):",A.issuperset(B))# False (O(min(len(A), len(B))))# Set Operations# Difference: Returns elements in A but not in Bprint("A.difference(B):",A.difference(B))# {1, 2} (O(len(A)))# Update A with difference of BA.difference_update(B)# O(len(B))print("After A.difference_update(B):",A)# Intersection: Returns elements in both A and BA= {1,2,3}print("A.intersection(B):",A.intersection(B))# {3} (O(min(len(A), len(B))))# Update A with intersection of A and BA.intersection_update(B)# O(min(len(A), len(B)))print("After A.intersection_update(B):",A)# Symmetric Difference: Returns elements in A or B but not bothA= {1,2,3}print("A.symmetric_difference(B):",A.symmetric_difference(B))# {1, 2, 4, 5} (O(len(A) + len(B)))# Update A with symmetric difference of A and BA.symmetric_difference_update(B)# O(len(A) + len(B))print("After A.symmetric_difference_update(B):",A)# Union OperationsA= {1,2,3}B= {3,4,5}# Union: Returns elements in A or B (without duplicates)print("A.union(B):",A.union(B))# {1, 2, 3, 4, 5} (O(len(A) + len(B)))# Update A with the union of A and BA.update(B)# O(len(B))print("After A.update(B):",A)

Time Complexity Table

2️⃣ Strings

fromcollectionsimportCounter# Example strings="hello world"print("Original string:",s)# Output: hello world# 1. Length of the stringprint("Length of string:",len(s))# O(1), Output: 11# 2. Strip whitespaces_padded="   hello world   "print("Stripped:",s_padded.strip())# O(n), Output: hello worldprint("Left Stripped:",s_padded.lstrip())# O(n), Output: hello worldprint("Right Stripped:",s_padded.rstrip())# O(n), Output:    hello world# 3. Split and joinfruits="apple,banana,cherry"fruit_list=fruits.split(",")# O(n)print("Split into list:",fruit_list)# Output: ['apple', 'banana', 'cherry']print("Joined with ', ':",", ".join(fruit_list))# O(n), Output: apple, banana, cherry# 4. Finding substringsprint("First occurrence of 'o':",s.find("o"))# O(n), Output: 4print("Last occurrence of 'o':",s.rfind("o"))# O(n), Output: 7print("Index of 'world':",s.index("world"))# O(n), Output: 6# 5. Replace substringsprint("Replace 'world' with 'Python':",s.replace("world","Python"))# O(n), Output: hello Python# 6. Count occurrencesprint("Count of 'l' in string:",s.count("l"))# O(n), Output: 3# 7. Startswith and endswithprint("Starts with 'hello':",s.startswith("hello"))# O(n), Output: Trueprint("Ends with 'world':",s.endswith("world"))# O(n), Output: True# 8. Check for alpha, digit, alphanumeric, and whitespacesample="abc123"print("Is alpha:",sample.isalpha())# O(n), Output: Falseprint("Is digit:","123".isdigit())# O(n), Output: Trueprint("Is alphanumeric:",sample.isalnum())# O(n), Output: Trueprint("Is whitespace:","   ".isspace())# O(n), Output: True# 9. Changing caseprint("Uppercase:",s.upper())# O(n), Output: HELLO WORLDprint("Lowercase:",s.lower())# O(n), Output: hello worldprint("Capitalized:",s.capitalize())# O(n), Output: Hello worldprint("Title case:",s.title())# O(n), Output: Hello World# 10. ASCII and Unicode conversionsprint("ASCII value of 'a':",ord('a'))# O(1), Output: 97print("Character for ASCII 97:",chr(97))# O(1), Output: a# 11. Checking substring existenceprint("'world' in string:","world"ins)# O(n), Output: True# Palindrome checkdefis_palindrome(st):st=st.lower()returnst==st[::-1]# O(n)print("Is 'Madam' a palindrome?",is_palindrome("Madam"))# Output: True# Character frequency countfrequency=Counter(s)# O(n)print("Character frequency:",frequency)# Output: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})# Anagram checkdefis_anagram(s1,s2):returnsorted(s1)==sorted(s2)# O(n log n)print("Is 'listen' an anagram of 'silent'?",is_anagram("listen","silent"))# Output: True# Removing duplicatesdefremove_duplicates(st):return"".join(dict.fromkeys(st))# O(n)print("Remove duplicates from 'aabbcc':",remove_duplicates("aabbcc"))# Output: abc

String Operations Time Complexity Table

3️⃣ Sorting

Sort Ascending

elements= [5,3,6,2,1]elements.sort()print(elements)# [1, 2, 3, 5, 6]elements= ["grape","apple","banana","orange"]elements.sort()print(elements)# ['apple', 'banana', 'grape', 'orange']

Sort Descending

defsort(key=None,reverse=False)->None:

elements= [5,3,6,2,1]elements.sort(None,True)# elements.sort(True)print(elements)# [6, 5, 3, 2, 1]

Sort Custom

defget_word_length(word:str)->int:returnlen(word)words= ["apple","banana","kiwi","pear","watermelon","blueberry","cherry"]words.sort(key=get_word_length)print(words)# ['kiwi', 'pear', 'apple', 'banana', 'cherry', 'blueberry', 'watermelon']# Problem link: https://leetcode.com/problems/reorder-data-in-log-files/# AC, LC:BadhansenclassSolution:defsort_by_requirements(self,log:str)->tuple:identifier,content=log.split(" ",1)ifcontent[0].isdigit():return (1,"","")else:return (0,content,identifier)defreorderLogFiles(self,logs:List[str])->List[str]:logs.sort(key=self.sort_by_requirements)returnlogs

words= ["apple","banana","kiwi","pear","watermelon","blueberry","cherry"]words.sort(key=lambdaword:len(word))print(words)# ['kiwi', 'pear', 'apple', 'banana', 'cherry', 'blueberry', 'watermelon']

fromcollectionsimportCounter# Example Counter objectcounter=Counter({'apple':3,'banana':2,'orange':5})# 1. Sort by count (descending order)sorted_by_count_desc=sorted(counter.items(),key=lambdax:x[1],reverse=True)print("Sorted by count (descending):",sorted_by_count_desc)# 2. Sort by count (ascending order)sorted_by_count_asc=sorted(counter.items(),key=lambdax:x[1])print("Sorted by count (ascending):",sorted_by_count_asc)# 3. Sort by key (alphabetical order)sorted_by_key=sorted(counter.items())print("Sorted by key:",sorted_by_key)

Sorted Copy

words= ["kiwi","pear","apple","banana","cherry","blueberry"]sorted_words=sorted(words)print(sorted_words)# ['apple', 'banana', 'blueberry', 'cherry', 'kiwi', 'pear']

numbers= [5,-3,2,-4,6,-2,4]sorted_numbers=sorted(numbers,reverse=True)print(sorted_numbers)# [6, 5, 4, 2, -2, -3, -4]

numbers= [5,-3,2,-4,6,-2,4]sorted_numbers=sorted(numbers,key=abs)print(sorted_numbers)# [2, -2, -3, 4, -4, 5, 6]

Sorting based on values and order

profits= [1,2,3]capital= [0,1,1]pairs= [(profits[i],capital[i])foriinrange(len(profits))]# (profit, capital)pairs.sort(key=lambdap:(p[1],-p[0]))print(pairs)# [(1, 0), (3, 1), (2, 1)]

Time and Space Complexity

Merge Sort

# Problem Link: https://leetcode.com/problems/sort-an-array/# AC, LC: BadhansenclassSolution:defmergeSort(self,nums,l,r):ifl<r:m= (l+r)//2self.mergeSort(nums,l,m)self.mergeSort(nums,m+1,r)self.merge(nums,l,m,r)defmerge(self,nums,l,m,r):i=lj=m+1res= []whilei<=mandj<=r:ifnums[i]<=nums[j]:res.append(nums[i])i+=1else:res.append(nums[j])j+=1whilei<=m:res.append(nums[i])i+=1whilej<=r:res.append(nums[j])j+=1index=0forkinrange(l,r+1):nums[k]=res[index]index+=1defsortArray(self,nums:List[int])->List[int]:self.mergeSort(nums,0,len(nums)-1)returnnums

4️⃣ Stack

stack= []# Push elements onto the stackstack.append(1)# O(1)stack.append(2)stack.append(3)print(stack)# Output: [1, 2, 3]# Pop elements from the stacktop_element=stack.pop()# O(1)# Check the elementvalue=stack[-1]# O(1)print(value)# Output: 3print(top_element)# Output: 3print(stack)# Output: [1, 2]

5️⃣ Queue & Heap

Queue

fromcollectionsimportdequequeue=deque()# Enqueue elementsqueue.append(1)# O(1)queue.append(2)queue.append(3)print(queue)# Output: deque([1, 2, 3])# Dequeue elementsfront_element=queue.popleft()# O(1)print(front_element)# Output: 1print(queue)# Output: deque([2, 3])

Double Ended Queue (Deque)

fromcollectionsimportdequedeque_obj=deque()# Add elements to both endsdeque_obj.append(1)# O(1), Add to the rightdeque_obj.appendleft(2)# O(1), Add to the leftprint(deque_obj)# Output: deque([2, 1])# Remove elements from both endsright_element=deque_obj.pop()# O(1)left_element=deque_obj.popleft()# O(1)print(right_element)# Output: 1print(left_element)# Output: 2print(deque_obj)# Output: deque([])# Create a dequedq=deque([10,20,30,40,50])# Access the first elementfirst_element=dq[0]# O(1)print("First element:",first_element)# Access the last elementlast_element=dq[-1]# O(1)print("Last element:",last_element)# Insert at a specific position (e.g., index 2)dq.insert(2,25)# O(n)print("After insert:",dq)# Access an element by index (not the ends)middle_element=dq[2]# O(n)print("Element at index 2:",middle_element)# Iterate through all elementsforelemindq:# O(n)print(elem,end=" ")

Heaps or Priority Queues

importheapq# Min-Heap by default# Initialize an empty list to act as a heapheap= []# Push elements onto the heapheapq.heappush(heap,10)# O(log n)heapq.heappush(heap,5)# O(log n)heapq.heappush(heap,15)# O(log n)heapq.heappush(heap,3)# O(log n)print("Heap after pushing elements:",heap)# Output: Heap after pushing elements: [3, 5, 15, 10]# Pop the smallest element from the heapsmallest=heapq.heappop(heap)# O(log n)print("Smallest element:",smallest)# Output: Smallest element: 3print("Heap after popping the smallest element:",heap)# Output: Heap after popping the smallest element: [5, 10, 15]# Convert a list into a heapnums= [5,7,9,1,3]heapq.heapify(nums)# O(n)print("Heapified list:",nums)# Output: Heapified list: [1, 3, 9, 7, 5]# Push an element into the heapheapq.heappush(nums,4)# O(log n)print("Heap after pushing 4:",nums)# Output: Heap after pushing 4: [1, 3, 4, 7, 5, 9]# Pop the smallest element from the heapvalue=heapq.heappop(nums)# O(log n)print("Popped smallest element:",value)# Output: Popped smallest element: 1print("Heap after popping the smallest element:",nums)# Output: Heap after popping the smallest element: [3, 5, 4, 7, 9]

Custom Heaps

importheapq# Initialize the list of tupleselements= [(3,300), (3,140), (3,140), (3,10), (5,55), (5,50), (10,200), (10,100)]# Convert the list to a heapheapq.heapify(elements)print("Heapified list:")whileelements:val=heapq.heappop(elements)print(val)'''Heapified list:(3, 10)(3, 140)(3, 140)(3, 300)(5, 50)(5, 55)(10, 100)(10, 200)'''

importheapqelements= [(3,300), (3,140), (3,140), (3,10), (5,55), (5,50), (10,200), (10,100)]heap= []forcost,profitinelements:heapq.heappush(heap, (cost,-profit))print("Heapified list:")whileheap:cost,profit=heapq.heappop(heap)print(cost,-profit)'''Heapified list:3 3003 1403 1403 105 555 5010 20010 100'''

importheapqelements= [(3,300), (3,140), (3,140), (3,10), (5,55), (5,50), (10,200), (10,100)]heap= []forcost,profitinelements:heapq.heappush(heap, (-cost,-profit))print("Heapified list:")whileheap:cost,profit=heapq.heappop(heap)print(-cost,-profit)'''Heapified list:10 20010 1005 555 503 3003 1403 1403 10'''

6️⃣ Linked Lists

Singly Linked List

classNode:def__init__(self,data):self.data=dataself.next=NoneclassLinkedList:def__init__(self):self.head=Noneself.tail=Noneself.size=0defappend(self,data):"""Add element to the end of the list with O(1) time complexity"""new_node=Node(data)ifself.headisNone:# List is emptyself.head=new_nodeself.tail=new_nodeelse:# Add to the endself.tail.next=new_nodeself.tail=new_nodeself.size+=1defappendleft(self,data):"""Add element to the beginning of the list with O(1) time complexity"""new_node=Node(data)ifself.headisNone:# List is emptyself.head=new_nodeself.tail=new_nodeelse:# Add to the beginningnew_node.next=self.headself.head=new_nodeself.size+=1defdisplay(self):"""Display all elements in the linked list"""current=self.headwhilecurrent:print(current.data,end=" -> ")current=current.nextprint("None")defget_size(self):"""Return the number of elements in the list"""returnself.size

Doubly Linked List

classNode:def__init__(self,data):self.data=dataself.prev=Noneself.next=NoneclassDoublyLinkedList:def__init__(self):self.head=Noneself.tail=Noneself.size=0# Add a node at the end of the listdefappend(self,data):new_node=Node(data)ifself.headisNone:# If the list is emptyself.head=self.tail=new_nodeelse:self.tail.next=new_node# Link the current tail to the new nodenew_node.prev=self.tail# Link the new node back to the current tailself.tail=new_node# Update the tail referenceself.size+=1# Add a node at the beginning of the listdefappendleft(self,data):new_node=Node(data)ifself.headisNone:# If the list is emptyself.head=self.tail=new_nodeelse:new_node.next=self.head# Link the new node to the current headself.head.prev=new_node# Link the current head back to the new nodeself.head=new_node# Update the head referenceself.size+=1# Delete the first node (from the head)defdelete_from_head(self):ifself.headisNone:# If the list is emptyreturnNonecurrent_data=self.head.data# Store the value of the head# If only one node existsifself.head==self.tail:self.head=self.tail=Noneelse:self.head=self.head.next# Move the head pointer forwardself.head.prev=None# Remove reference to the deleted nodeself.size-=1returncurrent_data# Delete the last node (from the tail)defdelete_from_tail(self):ifself.tailisNone:# If the list is emptyreturnNonecurrent_data=self.tail.data# Store the value of the tail# If only one node existsifself.head==self.tail:self.head=self.tail=Noneelse:self.tail=self.tail.prev# Move the tail pointer backwardself.tail.next=None# Remove reference to the deleted nodeself.size-=1returncurrent_data# Get the current size of the listdefget_size(self):returnself.size# Check if the list is emptydefis_empty(self):returnself.headisNone# Display the list in forward orderdefdisplay(self):ifself.is_empty():print("Empty list")returncurrent=self.headwhilecurrent:print(current.data,end=" <--> ")current=current.nextprint("None")

7️⃣ Trees & Graphs

Tree

Example uses:

Leaves, Depth, and Height

Pre Order Traversal

In Order Traversal

Post Order Traversal

Binary Trees

Full binary trees

Perfect binary trees

Complete binary trees

Balanced binary trees

classTreeNode:def__init__(self,value):self.value=valueself.left=Noneself.right=NoneclassSolution:defpreorder(self,root):ifrootisNone:returnprint(root.value,end=" ")self.preorder(root.left)self.preorder(root.right)definorder(self,root):ifrootisNone:returnself.inorder(root.left)print(root.value,end=" ")self.inorder(root.right)defpostorder(self,root):ifrootisNone:returnself.postorder(root.left)self.postorder(root.right)print(root.value,end=" ")

Graphs

Strengths:

Directed or undirected

Cyclic or acyclic

Weighted or unweighted

Legal coloring

Representations

Edge list

graph= [[0,1], [1,2], [1,3], [2,3]]

Adjacency list

graph= [    [1],    [0,2,3],    [1,3],    [1,2],]

graph= {0: [1],1: [0,2,3],2: [1,3],3: [1,2],}

Adjacency matrix

graph= [    [0,1,0,0],    [1,0,1,1],    [0,1,0,1],    [0,1,1,0],]

Tree Traversals

Breadth First Search (BFS)

Depth First Search (DFS)

Comparing BFS and DFS

# Edge list representationedges= [    (0,1),    (1,2),    (1,3),    (2,3)]# Example: Iterate through edgesforedgeinedges:print(f"Edge between{edge[0]} and{edge[1]}")# Adjacency list representationgraph= {0: [1],1: [0,2,3],2: [1,3],3: [1,2]}# Example: Iterate through neighbors of each nodefornode,neighborsingraph.items():print(f"Node{node} has neighbors{neighbors}")# Adjacency matrix representationgraph= [    [0,1,0,0],# Node 0 is connected to Node 1    [1,0,1,1],# Node 1 is connected to Nodes 0, 2, and 3    [0,1,0,1],# Node 2 is connected to Nodes 1 and 3    [0,1,1,0]# Node 3 is connected to Nodes 1 and 2]# Example: Print connectionsforiinrange(len(graph)):forjinrange(len(graph[i])):ifgraph[i][j]==1:print(f"Node{i} is connected to Node{j}")# Weighted graph using adjacency listgraph= {0: [(1,4)],# Node 0 is connected to Node 1 with weight 41: [(0,4), (2,3)],# Node 1 is connected to Nodes 0 and 2 with weights 4 and 32: [(1,3), (3,2)],# Node 2 is connected to Nodes 1 and 3 with weights 3 and 23: [(2,2)]# Node 3 is connected to Node 2 with weight 2}# Example: Print weighted edgesfornode,neighborsingraph.items():forneighbor,weightinneighbors:print(f"Edge from{node} to{neighbor} with weight{weight}")# Weighted graph using edge listedges= [    (0,1,4),# Edge from Node 0 to Node 1 with weight 4    (1,2,3),# Edge from Node 1 to Node 2 with weight 3    (2,3,2)# Edge from Node 2 to Node 3 with weight 2]# Example: Print weighted edgesforu,v,weightinedges:print(f"Edge from{u} to{v} with weight{weight}")# bfs implementation# Problem link: https://leetcode.com/problems/course-schedule-ii/# @Author: Badhan SenclassSolution:deffindOrder(self,numCourses:int,prerequisites:List[List[int]])->List[int]:graph=defaultdict(list)indegree= [0]*numCoursesforu,vinprerequisites:graph[v].append(u)indegree[u]+=1sources=deque([iforiinrange(numCourses)ifindegree[i]==0])res= []whilesources:src=sources.popleft()res.append(src)fordestingraph[src]:indegree[dest]-=1ifindegree[dest]==0:sources.append(dest)returnresiflen(res)==numCourseselse []"""Time and space complexity: O(v + e)"""classSolution:deffindOrder(self,numCourses:int,prerequisites:List[List[int]])->List[int]:graph=defaultdict(list)indegree= [0]*numCoursesforu,vinprerequisites:graph[v].append(u)indegree[u]+=1sources=deque([iforiinrange(numCourses)ifindegree[i]==0])res= []whilesources:size=len(sources)foriinrange(size):src=sources.popleft()res.append(src)fordestingraph[src]:indegree[dest]-=1ifindegree[dest]==0:sources.append(dest)returnresiflen(res)==numCourseselse []# dfs implementation using colors or numberclassSolution:deffindOrder(self,numCourses:int,prerequisites:List[List[int]])->List[int]:graph=defaultdict(set)foru,vinprerequisites:graph[v].add(u)res= []visited=defaultdict(lambda:0)defdfs(src):# Return false if the node is visited and viewed again before completionifvisited[src]==1:returnFalse# Return true if the node is completed processingifvisited[src]==2:returnTruevisited[src]=1fordestingraph[src]:ifnotdfs(dest):returnFalsevisited[src]=2# Mark as processedres.append(src)returnTrueforcinrange(numCourses):dfs(c)returnres[::-1]iflen(res)==numCourseselse []"""Time and space complexity: O(v + e)"""

8️⃣ Recursion & Backtracking

Example 1:Input: nums = [1,2,3]Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]Example 2:Input: nums = [0]Output: [[],[0]]

Example 1:Input: nums = [1,2,2]Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]Example 2:Input: nums = [0]Output: [[],[0]]

Input: nums = [1,2,3]Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

Input: nums = [0,1]Output: [[0,1],[1,0]]

Input: nums = [1]Output: [[1]]