DEV Community: M.T.Ramkrushna

DSA: Topic 8: Linked Lists

M.T.Ramkrushna — Mon, 14 Sep 2026 12:58:05 +0000

Interview frequency: ⭐⭐⭐⭐☆

Linked Lists are a common DSA interview topic, especially for questions involving pointers, reversing, and detecting cycles.

Since you're learning DSA in Python for exams and interviews, we'll focus on the patterns that actually matter.

1. What is a Linked List?

A linked list is a sequence of nodes.

Each node contains:

A value.
A reference to the next node.

Singly linked list

Each node points to the next node. The last node points to None.

Unlike an array, linked list nodes do not need to be stored next to each other in memory.

Why does this matter?

In a Python list:

Python

Run

arr = [10, 20, 30]

You can directly access:

Python

Run

arr[1]  # O(1)

In a linked list, to reach the second node, you follow the first node's reference.

Accessing the kth node takes O(n) in the worst case.

2. Create a Linked List in Python

This is the basic implementation you should know for interviews.

Python

Run

class ListNode:

    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

Create nodes:

Python

Run

a = ListNode(10)
b = ListNode(20)
c = ListNode(30)

a.next = b
b.next = c

The linked list is:

10 → 20 → 30 → None

The head is:

Python

Run

head = a

3. Traversing a Linked List

Unlike arrays, you cannot use indexes.

Python

Run

def print_list(head):
    curr = head

    while curr:
        print(curr.val)
        curr = curr.next

Output:

10
20
30

Complexity

Time: O(n)
Space: O(1)

curr moves through the nodes one by one.

4. Linked List Complexity

Singly linked list

Access by index

O(n)

O(n)

Insert at head

O(1)

Delete at head

O(1)

Insert after known node

O(1)

Delete after known node

O(1)

Insert at tail with tail pointer

O(1)

Important: Inserting or deleting a node is O(1) only when you already have the necessary node/reference. Finding that position may take O(n).

5. Most Important Interview Problem: Reverse Linked List ⭐⭐⭐⭐⭐

LeetCode 206 — Easy, but a must-know.

Problem

Input:

1 → 2 → 3 → 4 → None

Output:

4 → 3 → 2 → 1 → None

The interviewer usually expects an iterative O(1) extra-space solution.

The key idea: Three pointers

Use:

prev
curr
next_node

Initially:

prev = None
curr = head

Step 1

None ← 1    2 → 3 → 4
       ↑    ↑
      prev curr

Save the next node before reversing.

Step 2

Python

Run

next_node = curr.next
curr.next = prev
prev = curr
curr = next_node

Repeat until curr becomes None.

Python solution

Python

Run

def reverse_list(head):
    prev = None
    curr = head

    while curr:
        next_node = curr.next

        curr.next = prev

        prev = curr
        curr = next_node

    return prev

Dry run

For:

1 → 2 → 3 → None

curr

Start

None

2 → 1

3 → 2 → 1

None

Return prev.

Complexity

Time: O(n)
Space: O(1)

Critical mistake

Never overwrite curr.next before saving the original next node.

Bad:

Python

Run

curr.next = prev
curr = curr.next

You lose the rest of the list.

6. Fast and Slow Pointers

You learned this pattern earlier. Now we apply it to linked lists.

Use:

slow moves one step.
fast moves two steps.

slow → one step
fast → two steps

This pattern solves:

Find middle of linked list.
Detect cycle.
Find the start of a cycle.
Find the kth node from the end (using two pointers with a gap).

7. Interview Problem: Middle of Linked List

LeetCode 876 — Easy

Input:

1 → 2 → 3 → 4 → 5

Output:

Code

Python

Run

def middle_node(head):
    slow = head
    fast = head

    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next

    return slow

Why it works

When fast reaches the end, slow has moved half as far.

For an even-length list, this returns the second middle node.

Example:

1 → 2 → 3 → 4

Returns node 3.

Complexity

Time: O(n)
Space: O(1)

8. Interview Problem: Linked List Cycle

LeetCode 141 — Easy

Problem

Determine whether a linked list contains a cycle.

Example:

1 → 2 → 3 → 4
    ↑       |
    └───────┘

There is a cycle because the last node points back to an earlier node.

Brute force

Use a set of visited nodes.

Python

Run

def has_cycle_set(head):
    seen = set()
    curr = head

    while curr:
        if curr in seen:
            return True

        seen.add(curr)
        curr = curr.next

    return False

Complexity:

Time: O(n)
Space: O(n)

Optimised: Floyd's Cycle Detection

Use slow and fast pointers.

Python

Run

def has_cycle(head):
    slow = head
    fast = head

    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next

        if slow is fast:
            return True

    return False

Why is? We want to know whether both variables refer to the exact same node, not whether their values happen to be equal.

Complexity:

Time: O(n)
Space: O(1)

9. Interview Problem: Remove Nth Node From End

LeetCode 19 — Medium

Input:

1 → 2 → 3 → 4 → 5

Remove the 2nd node from the end.

Output:

1 → 2 → 3 → 5

Key idea

Use two pointers with a gap of n nodes.

Then move both pointers together.

When fast reaches the end, slow is positioned just before the node to delete.

Python solution

Python

Run

def remove_nth_from_end(head, n):
    dummy = ListNode(0, head)

    slow = dummy
    fast = dummy

    for _ in range(n):
        fast = fast.next

    while fast.next:
        slow = slow.next
        fast = fast.next

    slow.next = slow.next.next

    return dummy.next

Why use a dummy node?

It handles edge cases such as deleting the head.

For example:

1 → 2 → 3

Remove the 1st node from the end:

1 → 2

Without a dummy node, deleting the head needs special handling.

Complexity

Time: O(n)
Space: O(1)

10. Linked List Patterns You Must Know

Reverse Linked List

Three pointers: prev, curr, next.

Fast and slow pointers

Middle, cycle detection, nth from end.

Dummy node

Simplifies insertion and deletion at the head.

11. Real Interview Questions

Difficulty

Reverse Linked List

Easy

Middle of the Linked List

Easy

Linked List Cycle

Easy

Merge Two Sorted Lists

Easy

Remove Nth Node From End

Medium

Add Two Numbers

Medium

Reorder List

Medium

Linked List Cycle II

Medium

Copy List with Random Pointer

Medium

Reverse Nodes in k-Group

Hard

12. Exam Cheat Sheet

Think

Reverse a linked list

Three pointers

Find middle

Slow + fast

Detect cycle

Floyd's algorithm

Remove kth from end

Two pointers + dummy

Merge sorted lists

Two pointers

Reverse in groups

Iterative pointer manipulation

Practice question

Try this without looking at the solution:

Reverse a Linked List

Python

Run

def reverse_list(head):
    pass

Input:

1 → 2 → 3 → 4 → None

Expected:

4 → 3 → 2 → 1 → None

Try to solve it using only prev, curr, and next_node.

Next topic: Trees

We'll learn Binary Trees, DFS, BFS, tree height, traversals, and the most common interview problem: Maximum Depth of Binary Tree.

DSA: Topic 7: Queues, Deques & BFS

M.T.Ramkrushna — Mon, 14 Sep 2026 12:57:59 +0000

Interview frequency: ⭐⭐⭐⭐☆

Today we'll learn queues from a real coding interview perspective, not just definitions.

This topic is important because queues are the foundation of BFS (Breadth-First Search), which is used in trees, graphs, grids, shortest-path problems, and many coding assessments.

1. What is a Queue?

A queue follows FIFO:

First In, First Out.

Think of people standing in a line. The person who enters first leaves first.

Queue visualization

← Dequeue (front)

Enqueue (rear) →

Basic operations

Meaning

Enqueue

Add element

Dequeue

Remove front element

Front / Peek

See first element

IsEmpty

Check if empty

2. Python Queue: `deque`

Use collections.deque for an efficient queue.

Python

Run

from collections import deque

q = deque()

q.append(10)
q.append(20)
q.append(30)

print(q.popleft())  # 10
print(q)            # deque([20, 30])

Complexity

Time

append()

O(1)

popleft()

O(1)

q[0]

O(1)

len(q)

O(1)

Important interview mistake

Don't use:

Python

Run

q.pop(0)

Python lists don't support pop(0) efficiently. Removing the first element requires shifting the remaining elements, which is O(n).

Use:

Python

Run

q.popleft()

3. Queue vs Stack

| |
Stack

Queue

Rule

LIFO

FIFO

Python

list

deque

Add

append()

append()

Remove

pop()

popleft()

Common use

DFS, brackets

BFS, scheduling

Remember: DFS usually explores deeply; BFS explores level by level.

4. BFS — The Most Important Part ⭐⭐⭐⭐⭐

BFS stands for Breadth-First Search.

It explores all nodes at the current distance or level before moving to the next.

Example tree:

          1
        /   \
       2     3
      / \     \
     4   5     6

BFS order:

1 → 2 → 3 → 4 → 5 → 6

Level by level:

Level 0: [1]

Level 1: [2, 3]

Level 2: [4, 5, 6]

A queue makes this natural.

5. Interview Problem: Binary Tree Level Order Traversal

LeetCode 102 — Medium

Problem

Given the root of a binary tree, return its level-order traversal.

Expected:

Python

Run

[
    [1],
    [2, 3],
    [4, 5, 6]
]

Interview thinking

When you see:

Level order
Minimum number of steps
Shortest path in an unweighted graph
Nearest / closest
Spread to neighboring cells

Think:

BFS + Queue

Python solution

Python

Run

from collections import deque

def level_order(root):
    if not root:
        return []

    result = []
    q = deque([root])

    while q:

        level = []

        for _ in range(len(q)):
            node = q.popleft()

            level.append(node.val)

            if node.left:
                q.append(node.left)

            if node.right:
                q.append(node.right)

        result.append(level)

    return result

Complexity

For n nodes:

Time: O(n) — each node is processed once.
Space: O(n) — queue and output can hold O(n) elements.

Important trick: `for _ in range(len(q))`

This processes exactly the nodes in the current level.

Why not simply use:

Python

Run

while q:

You can, but then you need another way to separate levels. The len(q) trick is the standard interview approach.

6. BFS on a Grid

This is extremely common in online assessments.

Problem: Number of Islands

LeetCode 200 — Medium

Given a grid:

1 = Land
0 = Water

Find the number of islands.

An island consists of connected land cells in the four directions:

Up
Down
Left
Right

Interview approach

Visit every cell.
If it's land (1), you found a new island.
Start BFS to visit all connected land.
Mark visited cells.
Continue scanning.

Python solution

Python

Run

from collections import deque

def num_islands(grid):
    if not grid:
        return 0

    rows = len(grid)
    cols = len(grid[0])
    islands = 0

    for r in range(rows):
        for c in range(cols):

            if grid[r][c] != "1":
                continue

            islands += 1

            q = deque([(r, c)])
            grid[r][c] = "0"

            while q:
                x, y = q.popleft()

                for dx, dy in [
                    (1, 0),
                    (-1, 0),
                    (0, 1),
                    (0, -1)
                ]:
                    nx = x + dx
                    ny = y + dy

                    if (
                        0 <= nx < rows
                        and 0 <= ny < cols
                        and grid[nx][ny] == "1"
                    ):
                        grid[nx][ny] = "0"
                        q.append((nx, ny))

    return islands

Complexity

Let the grid have R rows and C columns.

Time: O(R × C)
Space: O(R × C) worst case for the queue.

Interview insight

Mark a cell visited when you add it to the queue, not when you remove it. This prevents adding the same cell multiple times.

7. BFS for Shortest Path

This is a very important pattern.

Example

You have a grid with obstacles:

S . . #
# . . #
# . . E

Find the minimum number of steps from S to E.

If every move costs exactly 1, BFS finds the shortest path.

Why?

BFS visits cells in order of distance:

Distance 0
    ↓
Distance 1
    ↓
Distance 2
    ↓
Distance 3

The first time you reach the destination, you have found a shortest path.

Important: This applies to unweighted graphs (or edges with equal cost). For weighted edges, use algorithms such as Dijkstra when appropriate.

8. Multi-Source BFS ⭐⭐⭐⭐☆

This is an advanced BFS pattern.

Instead of starting from one source, you start from multiple sources simultaneously.

Example: Rotting Oranges

LeetCode 994 — Medium

2 = Rotten orange
1 = Fresh orange
0 = Empty

2 1 1
1 1 0
0 1 1

Every minute, rotten oranges infect their adjacent fresh oranges.

Find the time until all oranges are rotten.

Interview clue

If the question says:

Spread simultaneously
Minimum minutes
Multiple starting points
Nearest distance from any source

Think:

Multi-Source BFS

Initialize the queue with every rotten orange, then process one level at a time.

9. BFS Template for Interviews

Tree or graph BFS

Python

Run

from collections import deque

def bfs(start):
    q = deque([start])
    visited = {start}

    while q:
        node = q.popleft()

        for neighbor in neighbors(node):
            if neighbor not in visited:
                visited.add(neighbor)
                q.append(neighbor)

Grid BFS

Python

Run

from collections import deque

q = deque([(start_r, start_c)])
visited = {(start_r, start_c)}

while q:
    r, c = q.popleft()

    for dr, dc in directions:
        nr = r + dr
        nc = c + dc

        # Check bounds and validity
        # Mark visited
        # Add to queue

10. How to Recognise BFS vs DFS

Preferred approach

Level order traversal

BFS

Shortest path, unweighted graph

BFS

Minimum number of moves

BFS

Spread in minutes

Multi-source BFS

Explore all connected components

BFS or DFS

Explore deep paths / backtracking

DFS

Tree height / recursive subtree calculations

Often DFS

Very important: BFS is not always the only correct solution. Some problems can be solved with either BFS or DFS.

11. Real Interview Problems to Practice

Easy

Binary Tree Level Order Traversal — LeetCode 102
Flood Fill — LeetCode 733

Medium

Number of Islands — LeetCode 200
Rotting Oranges — LeetCode 994
Shortest Path in Binary Matrix — LeetCode 1091
Open the Lock — LeetCode 752
Binary Tree Zigzag Level Order Traversal — LeetCode 103

Advanced

Word Ladder — LeetCode 127
01 Matrix — LeetCode 542
Walls and Gates — classic multi-source BFS problem

12. Exam Cheat Sheet

Queue

FIFO. Use deque in Python.

BFS

Explore level by level using a queue.

Grid problems

Use directions, bounds checks, and visited tracking.

Practice question

Try this before looking at the solution:

Rotting Oranges

Python

Run

grid = [
    [2, 1, 1],
    [1, 1, 0],
    [0, 1, 1]
]

Return the minimum minutes required to rot all oranges. If impossible, return -1.

Hint: Use multi-source BFS.

Next topic: Linked Lists

We'll cover linked list structure, reversing a linked list, fast and slow pointers, detecting cycles, and the classic interview question Reverse Linked List.

DSA: Topic 6: Stacks & Monotonic Stack

M.T.Ramkrushna — Mon, 14 Sep 2026 12:57:37 +0000

Interview frequency: ⭐⭐⭐⭐⭐

We are continuing from Arrays → Hash Maps → Two Pointers → Sliding Window → Binary Search.

Today you'll learn Stacks from a real coding interview perspective, including the important Monotonic Stack pattern used in medium and hard problems.

1. What is a Stack?

A stack follows LIFO:

Last In, First Out.

Think of a stack of plates. The last plate you put on is the first one you remove.

Stack visualization

LIFO

30 — Top

10 — Bottom

Push and pop happen at the top.

Python implementation

Python lists work as stacks.

Python

Run

stack = []

# Push
stack.append(10)
stack.append(20)
stack.append(30)

# Pop
print(stack.pop())  # 30

print(stack)       # [10, 20]

Time complexity

Python list

Push (append)

O(1) amortized

Pop (pop())

O(1)

Peek (stack[-1])

O(1)

Check empty

O(1)

Interview tip: Never use pop(0) for a stack. It takes O(n). For a queue, use collections.deque.

2. When should you think "Stack"?

These are the major clues:

Matching parentheses or brackets.
Undo / redo operations.
Nested structures.
Next greater or smaller element.
Previous greater or smaller element.
Removing elements based on previous elements.
Evaluating expressions.

The most important recognition rule:

If the problem asks about the nearest previous or next element that satisfies a condition, think Monotonic Stack.

3. Interview Problem #1: Valid Parentheses

LeetCode 20 — Easy, but very important.

Problem

Given a string containing (), {}, and [], determine whether the brackets are valid.

Examples:

"()[]{}"  → True

"([{}])"  → True

"(]"      → False

"([)]"    → False

Interviewer's expectation

You should recognise that brackets need to close in the reverse order they open.

That is exactly LIFO → Stack.

Step-by-step thinking

For:

"({[]})"

Stack

(

(

{

( {

[

( { [

]

( {

}

(

)

Empty

Every closing bracket must match the latest opening bracket.

Python solution

Python

Run

def is_valid(s):
    stack = []

    pairs = {
        ')': '(',
        ']': '[',
        '}': '{'
    }

    for ch in s:
        if ch in pairs:
            if not stack or stack[-1] != pairs[ch]:
                return False

            stack.pop()
        else:
            stack.append(ch)

    return len(stack) == 0

Complexity

Time: O(n)
Space: O(n)

Common mistakes

Popping from an empty stack.
Checking only whether a bracket exists, rather than matching the correct type.
Forgetting to check that the stack is empty at the end.

4. Interview Problem #2: Min Stack

LeetCode 155 — Medium

Problem

Design a stack that supports:

push(x)
pop()
top()
getMin()

All operations must be O(1).

Example:

Python

Run

push(5)
push(3)
push(7)
push(2)

Minimum:

After popping 2, minimum becomes:

Why a normal stack is not enough

If you scan the whole stack every time you want the minimum:

Python

Run

min(stack)

That takes O(n).

The interviewer wants O(1).

Key idea: Two stacks

stack: stores all values.
min_stack: stores the minimum value at each stage.

Python

Run

class MinStack:

    def __init__(self):
        self.stack = []
        self.min_stack = []

    def push(self, val):
        self.stack.append(val)

        if not self.min_stack:
            self.min_stack.append(val)
        else:
            self.min_stack.append(
                min(val, self.min_stack[-1])
            )

    def pop(self):
        self.stack.pop()
        self.min_stack.pop()

    def top(self):
        return self.stack[-1]

    def getMin(self):
        return self.min_stack[-1]

Complexity

Time

Push

O(1)

Pop

O(1)

Top

O(1)

Get minimum

O(1)

This is a great example of using extra memory to optimise time.

5. Monotonic Stack ⭐⭐⭐⭐⭐

This is the advanced part of today's topic.

A monotonic stack maintains elements in either:

Increasing order.
Decreasing order.

It is used when you need to find the next or previous greater/smaller element efficiently.

Example: Next Greater Element

Given:

Python

Run

nums = [2, 1, 5, 3, 4]

For every element, find the first greater element to its right.

Expected output:

Python

Run

[5, 5, -1, 4, -1]

Explanation:

Next greater

-1

-1

Brute force

For each element, scan everything to the right.

Python

Run

def next_greater_brute(nums):
    result = []

    for i in range(len(nums)):
        found = -1

        for j in range(i + 1, len(nums)):
            if nums[j] > nums[i]:
                found = nums[j]
                break

        result.append(found)

    return result

Complexity:

Time: O(n²)
Space: O(n)

Optimised: Monotonic decreasing stack

We process the array from right to left.

Why?

Because the answer for an element is somewhere on its right.

Python

Run

def next_greater(nums):
    n = len(nums)
    result = [-1] * n
    stack = []

    for i in range(n - 1, -1, -1):

        while stack and stack[-1] <= nums[i]:
            stack.pop()

        if stack:
            result[i] = stack[-1]

        stack.append(nums[i])

    return result

Dry run

For:

Python

Run

[2, 1, 5, 3, 4]

Start from the right:

Stack after processing

Answer

[4]

-1

[4, 3]

[5]

-1

[5, 1]

[5, 2]

Final:

Python

Run

[5, 5, -1, 4, -1]

Why is it O(n)?

Every element:

Enters the stack once.
Leaves the stack at most once.

Therefore, total stack operations are O(n).

Time: O(n)

This is called amortized analysis.

6. Important Monotonic Stack Problems

Pattern

Next Greater Element

Decreasing stack

Daily Temperatures

Decreasing stack of indices

Next Greater Element II

Circular array

Stock Span

Previous greater element

Largest Rectangle in Histogram

Previous/next smaller

Sum of Subarray Minimums

Contribution counting

Trapping Rain Water

Stack-based solution

Daily Temperatures — Very Important

LeetCode 739 — Medium

Problem

Given daily temperatures, return how many days you must wait until a warmer temperature.

Python

Run

temperatures = [73, 74, 75, 71, 69, 72, 76, 73]

Output:

Python

Run

[1, 1, 4, 2, 1, 1, 0, 0]

Why use a stack?

For each day, find the next greater temperature to the right.

The stack stores indices of temperatures that are waiting for a warmer day.

Python solution

Python

Run

def daily_temperatures(temperatures):
    result = [0] * len(temperatures)
    stack = []

    for i, temp in enumerate(temperatures):

        while stack and temp > temperatures[stack[-1]]:
            prev = stack.pop()
            result[prev] = i - prev

        stack.append(i)

    return result

Complexity

Time: O(n)
Space: O(n)

Interview insight: Store indices, not just values, because the answer asks for the number of days.

7. Stack vs Queue vs Heap

Main behavior

Python

Stack

LIFO

list

Queue

FIFO

deque

Heap

Priority-based removal

heapq

We will cover queues and heaps in their own topics.

8. Interview Cheat Sheet

Matching brackets

Use a normal stack.

Next greater / smaller

Think monotonic stack.

Need O(1) minimum or maximum

Consider an auxiliary stack.

Practice: Your interview question

Try this before looking at the solution.

Question: Remove adjacent duplicates

Given a string, remove adjacent duplicate characters repeatedly.

Examples:

"abbaca" → "ca"

"azxxzy" → "ay"

For "abbaca":

a b b a c a
  ↑ ↑
Remove "bb"

a a c a
↑ ↑
Remove "aa"

c a

Your task

Write a Python function:

Python

Run

def remove_duplicates(s):
    pass

Return the final string after all adjacent duplicates are removed.

Hint: Use a stack. If the current character equals the top of the stack, pop it. Otherwise, push it.

Next topic

Topic 7: Queues, Deques & BFS basics

We'll learn FIFO, Python's collections.deque, and how queues are used in real interview problems such as Number of Islands and Binary Tree Level Order Traversal.

DSA: Topic 5: Binary Search

M.T.Ramkrushna — Mon, 14 Sep 2026 12:57:31 +0000

Interview frequency: ⭐⭐⭐⭐⭐

Most beginners think Binary Search is just:

"Find an element in a sorted array."

In reality, that's only 10% of its interview usage.

Most interview questions use Binary Search on the Answer.

What Interviewers Want

When interviewers ask a Binary Search question, they're testing whether you can recognise:

A sorted search space.
A monotonic condition (once something becomes true, it stays true—or vice versa).
How to reduce a search from O(n) to O(log n).

Part 1: Classic Binary Search

Suppose you have:

nums = [2, 5, 8, 10, 15, 20, 30]
target = 15

Instead of checking each element:

2 → 5 → 8 → 10 → 15

Binary Search repeatedly cuts the search space in half.

2 5 8 10 15 20 30
      ↑
     mid

If:

nums[mid] == target

You're done.

If:

nums[mid] < target

Discard the left half.

If:

nums[mid] > target

Discard the right half.

Code

def binary_search(nums, target):
    left = 0
    right = len(nums) - 1

    while left <= right:

        mid = left + (right - left) // 2

        if nums[mid] == target:
            return mid

        elif nums[mid] < target:
            left = mid + 1

        else:
            right = mid - 1

    return -1

Complexity:

Time : O(log n)

Space: O(1)

Why is it O(log n)?

Imagine:

1,000,000 elements

Linear Search

Worst case

1,000,000 comparisons

Binary Search

1,000,000

↓

500,000

↓

250,000

↓

125,000

↓

...

Only about 20 comparisons.

That's why it's so powerful.

Interview Trick #1

The array must be sorted.

If it isn't:

Don't immediately think Binary Search.

Part 2: First and Last Occurrence

Example

[1,2,2,2,2,3,4]

Find the first occurrence of 2.

Normal Binary Search might return:

index = 3

Wrong.

Expected:

index = 1

Interview trick:

When you find the target,

don't stop.

Continue searching the left half.

Similarly,

for the last occurrence,

continue searching the right half.

Part 3: Lower Bound & Upper Bound

Many companies ask this.

Example

nums = [2,4,4,4,8]

Lower Bound of 4

First position ≥ 4

Answer

Upper Bound

First position > 4

Answer

Part 4: Binary Search on the Answer ⭐⭐⭐⭐⭐

This is where interviews become interesting.

Suppose the interviewer asks:

Koko eats bananas.

Find the minimum eating speed.

The array is not sorted.

Can we still use Binary Search?

Yes.

Because the answer space is sorted.

Possible speeds:

Suppose:

Speed = 3

Impossible

Speed = 4

Possible

Speed = 5

Possible

Speed = 6

Possible

Notice the pattern.

False False False True True True

This is called a monotonic condition.

Binary Search works because once it becomes True, it stays True.

How to Recognise Binary Search on the Answer

Ask yourself:

Am I searching for the minimum or maximum value that satisfies a condition?

Examples:

Minimum speed
Minimum capacity
Maximum distance
Smallest feasible answer

These are strong hints.

Generic Template

left = minimum_possible_answer
right = maximum_possible_answer

while left < right:

    mid = (left + right) // 2

    if is_possible(mid):
        right = mid
    else:
        left = mid + 1

return left

This template appears in many interview problems.

Common Interview Mistakes

Mistake 1

Using:

mid = (left + right) // 2

This is fine in Python because integers don't overflow, but in languages like Java or C++, interviewers often expect:

mid = left + (right - left) // 2

It's a good habit across languages.

Mistake 2

Wrong loop condition

Many candidates write:

while left < right

when they should use

while left <= right

Know which variant you're implementing.

Mistake 3

Updating the wrong pointer.

Remember:

Target is larger

↓

Move left

Target is smaller

↓

Move right

Real Interview Questions

Easy

Binary Search ⭐⭐⭐⭐⭐
Search Insert Position ⭐⭐⭐⭐

Medium

First & Last Position ⭐⭐⭐⭐⭐
Search in Rotated Sorted Array ⭐⭐⭐⭐⭐
Find Minimum in Rotated Sorted Array ⭐⭐⭐⭐
Peak Element ⭐⭐⭐⭐

Binary Search on Answer

Koko Eating Bananas ⭐⭐⭐⭐⭐
Capacity to Ship Packages Within D Days ⭐⭐⭐⭐⭐
Split Array Largest Sum ⭐⭐⭐⭐⭐
Aggressive Cows (very popular in competitive programming and some interviews) ⭐⭐⭐⭐

Interview Checklist

When you read a question, ask:

Is the data already sorted?

If yes → Consider classic Binary Search.

Am I searching for a minimum or maximum feasible value?

If yes → Think Binary Search on the Answer.

Does the condition change only once?

Example:

 False False False True True True

 True True True False False

If yes → Binary Search is likely applicable.

Summary of Topics Covered

Topic	Interview Frequency	Key Idea
Arrays	⭐⭐⭐⭐⭐	Traversal and manipulation
Hash Maps & Sets	⭐⭐⭐⭐⭐	Fast lookups and counting
Two Pointers	⭐⭐⭐⭐⭐	Efficient pair and in-place problems
Sliding Window	⭐⭐⭐⭐⭐	Contiguous subarrays/substrings
Binary Search	⭐⭐⭐⭐⭐	Search efficiently in sorted or monotonic spaces

These five topics form the foundation of a large portion of coding interview problems. The next topic is Stacks & Monotonic Stacks, another extremely common interview pattern used for problems like Valid Parentheses, Daily Temperatures, Next Greater Element, and Largest Rectangle in a Histogram.

DSA: Topic 4: Sliding Window

M.T.Ramkrushna — Mon, 14 Sep 2026 12:36:52 +0000

Interview frequency: ⭐⭐⭐⭐⭐

Many candidates confuse Two Pointers and Sliding Window.

The difference is:

Two Pointers: Usually solving pair/comparison problems.
Sliding Window: Solving subarray or substring problems.

If you master Sliding Window, you can solve dozens of interview questions.

When should you think "Sliding Window"?

Whenever you see words like:

Longest...
Shortest...
Maximum...
Minimum...
Continuous
Contiguous
Subarray
Substring

For example:

Find the longest substring without repeating characters.

Maximum sum of a subarray of size k.

Smallest subarray with sum ≥ k.

These are classic sliding window problems.

What is a Sliding Window?

Imagine a window moving across the array.

Example:

Array: [2, 1, 5, 1, 3, 2]

Window size = 3

[2,1,5] 1 3 2
 2 [1,5,1] 3 2
 2 1 [5,1,3] 2
 2 1 5 [1,3,2]

Instead of recalculating every window from scratch, update the window efficiently.

Problem 1: Maximum Sum Subarray of Size K

Example

nums = [2,1,5,1,3,2]
k = 3

Windows:

2+1+5 = 8

1+5+1 = 7

5+1+3 = 9

1+3+2 = 6

Answer:

Brute Force

For every position:

Compute the sum again.

Time = O(n × k)

Too slow for large inputs.

Optimised Sliding Window

Step 1

Compute the first window.

window_sum = sum(nums[:k])
max_sum = window_sum

Current window:

[2,1,5]

Sum = 8

Step 2

Move one step.

Instead of adding everything again,

Subtract the element leaving the window.

Add the new element entering.

Old window

2 1 5

↓

Remove 2

Add 1

↓

1 5 1

Formula:

window_sum = window_sum - nums[left] + nums[right]

Complete solution:

def max_sum(nums, k):
    window_sum = sum(nums[:k])
    max_sum = window_sum

    for right in range(k, len(nums)):
        window_sum += nums[right]
        window_sum -= nums[right-k]

        max_sum = max(max_sum, window_sum)

    return max_sum

Complexity

Time : O(n)

Space: O(1)

Fixed vs Variable Sliding Window

There are two types.

1. Fixed Window

Size never changes.

Example:

Window size = 4

Questions:

Maximum sum of size k
Average of size k
First negative number in every window

2. Variable Window

Window expands and shrinks.

Example:

Longest substring without repeating characters

Here the size changes dynamically.

Variable Window Example

Longest Substring Without Repeating Characters

Input

abcabcbb

Start:

[a]

Expand:

[a b]

Expand:

[a b c]

Next character:

Already exists.

Now shrink from the left until the duplicate is removed.

Continue expanding.

This "expand → shrink → expand" idea is the heart of variable sliding windows.

Generic Sliding Window Template

left = 0

for right in range(len(nums)):

    # Expand window

    while window_is_invalid:
        # Shrink window
        left += 1

    # Update answer

This template solves many interview questions with only small changes.

How to Recognise Sliding Window Problems

Ask yourself:

Does the problem mention:

Subarray?
Substring?
Contiguous?

Think:

Sliding Window.

Does it ask:

Longest...

Shortest...

Maximum...

Minimum...

Think:

Sliding Window.

Can I move from one window to the next by removing one element and adding one element?

If yes,

Definitely Sliding Window.

Common Interview Mistakes

Mistake 1

Recalculating every window.

Example:

sum(nums[i:i+k])

inside a loop.

That becomes

O(nk)

instead of

O(n)

Mistake 2

Forgetting to shrink.

Many candidates only expand.

A valid variable sliding window must:

Expand

↓

Become invalid

↓

Shrink

↓

Become valid

↓

Expand again

Mistake 3

Using a list instead of a set/dictionary.

For

Longest substring without repeating characters

checking duplicates with a list is slow.

Use

set()

or

dict()

Real Interview Questions

Master these:

Easy

Maximum Average Subarray I ⭐⭐⭐⭐⭐
Maximum Sum Subarray of Size K ⭐⭐⭐⭐

Medium

Longest Substring Without Repeating Characters ⭐⭐⭐⭐⭐
Longest Repeating Character Replacement ⭐⭐⭐⭐⭐
Minimum Size Subarray Sum ⭐⭐⭐⭐
Permutation in String ⭐⭐⭐⭐
Find All Anagrams in a String ⭐⭐⭐⭐

Hard

Minimum Window Substring ⭐⭐⭐⭐⭐

Interview Trick

When reading a question, ask yourself these three questions:

Is the input contiguous? (subarray/substring)
Am I looking for a longest, shortest, maximum, or minimum answer?
Can I avoid recalculating by reusing information from the previous window?

If the answer is yes, Sliding Window is often the right approach.

Comparison of the First Four Topics

Pattern	Best Used For	Time Complexity
Arrays	Basic traversal and manipulation	Usually O(n)
Hash Map/Set	Fast lookups, counting, duplicates	O(n)
Two Pointers	Sorted arrays, pairs, in-place operations	O(n)
Sliding Window	Contiguous subarrays/substrings	O(n)

These four patterns alone cover a large percentage of array and string interview questions.

Next Topic

We'll move to Binary Search, where you'll learn that it's much more than searching a sorted array. Interviewers often expect you to apply it to "search on the answer" problems, making it another ⭐⭐⭐⭐⭐ pattern for coding interviews.

DSA: Topic 3: Two Pointers

M.T.Ramkrushna — Mon, 14 Sep 2026 12:36:43 +0000

Interview frequency: ⭐⭐⭐⭐⭐ (Top 5 pattern)

Many candidates fail interviews not because they don't know algorithms, but because they don't recognise when to use Two Pointers.

What is the Two Pointers technique?

Instead of using one index:

i = 0

you use two indices.

left = 0
right = len(arr) - 1

These pointers move based on the problem.

Example:

Index : 0  1  2  3  4

Array : 2  4  7  9  15
         ↑         ↑
       left      right

The pointers may:

Move towards each other
Move in the same direction
Move at different speeds

When should you think of Two Pointers?

This is the most important part.

Whenever you see:

Sorted array
Pair problems
Remove duplicates
Move elements
Reverse array/string
Palindrome
Merge sorted arrays

Your brain should immediately ask:

"Can I solve this using two pointers?"

Pattern 1: Opposite Direction

Pointers start from both ends.

L ------------->

<------------- R

Used for:

Pair Sum
Reverse Array
Palindrome
Container With Most Water

Example 1: Reverse an Array

Input

nums = [1,2,3,4,5]

Instead of creating another array, swap from both ends.

left = 0
right = len(nums)-1

while left < right:
    nums[left], nums[right] = nums[right], nums[left]

    left += 1
    right -= 1

Output

[5,4,3,2,1]

Complexity

Time : O(n)

Space: O(1)

Interviewers love in-place solutions.

Example 2: Valid Palindrome

madam

m == m

a == a

d

Algorithm

left = 0

right = len(s)-1

while left < right:

    if s[left] != s[right]:
        return False

    left += 1

    right -= 1

return True

Time

O(n)

Very common interview problem.

Example 3: Two Sum II (Sorted Array)

Input

[2,4,7,11,15]

target = 18

Instead of checking every pair:

2 + 15 = 17

Need larger

Move left

4 + 15 = 19

Too large

Move right

4 + 11 = 15

Need larger

Move left

7 + 11 = 18

Found

Code

left = 0
right = len(nums)-1

while left < right:

    total = nums[left] + nums[right]

    if total == target:
        return [left,right]

    elif total < target:
        left += 1

    else:
        right -= 1

Notice how the sorted property lets us decide which pointer to move.

Pattern 2: Same Direction

Used for:

Remove duplicates
Move zeroes
Partition arrays

Example:

[0,1,0,3,12]

Expected

[1,3,12,0,0]

Use

slow

fast

Fast explores.

Slow remembers where the next valid element should go.

Move Zeroes

slow = 0

for fast in range(len(nums)):

    if nums[fast] != 0:

        nums[slow], nums[fast] = nums[fast], nums[slow]

        slow += 1

Output

[1,3,12,0,0]

Interview frequency:

⭐⭐⭐⭐⭐

Pattern 3: Fast and Slow Pointer

Mostly used in Linked Lists.

slow

fast

slow -> 1 step

fast -> 2 steps

Applications

Detect cycle
Find middle node
Happy Number

We'll revisit this when we study linked lists.

How to Identify Two Pointer Problems

Ask yourself:

Is the array sorted?

Example

Pair Sum

Use opposite pointers.

Do I need to compare two ends?

Palindrome

Reverse String

Use opposite pointers.

Am I moving/removing elements?

Move Zeroes

Remove Duplicates

Use slow and fast pointers.

Am I merging two sorted arrays?

Use one pointer for each array.

Common Interview Mistakes

Mistake 1

Using nested loops.

for i:

    for j:

Many pair problems can be solved with two pointers in O(n) instead of O(n²).

Mistake 2

Using Two Pointers on an unsorted array when the problem depends on order.

For example:

Two Sum

If the array isn't sorted and you can't sort it (because you need original indices), use a Hash Map instead.

Mistake 3

Moving the wrong pointer.

Remember:

If the array is sorted:

Sum too small

Move left

Sum too big

Move right

Real Interview Questions

Master these:

Valid Palindrome ⭐⭐⭐⭐⭐
Reverse String ⭐⭐⭐⭐⭐
Two Sum II ⭐⭐⭐⭐
Move Zeroes ⭐⭐⭐⭐⭐
Remove Duplicates from Sorted Array ⭐⭐⭐⭐⭐
Squares of a Sorted Array ⭐⭐⭐⭐
Container With Most Water ⭐⭐⭐⭐
3Sum ⭐⭐⭐⭐⭐ (advanced extension)

Interview Thinking Process

Suppose you're asked:

"Given a sorted array, find two numbers whose sum is target."

A strong interview approach is:

Notice the array is sorted.
Recognise that brute force (O(n²)) is unnecessary.
Suggest using two pointers (left, right).
Explain why moving left increases the sum and moving right decreases it.
Code the O(n) solution.

This demonstrates both algorithmic knowledge and problem-solving, which is exactly what interviewers evaluate.

Next Topic

The next topic is Sliding Window, which is often confused with Two Pointers but solves a different class of problems such as:

Longest substring without repeating characters
Maximum sum subarray of size k
Minimum window substring
Longest repeating character replacement

Sliding Window is another ⭐⭐⭐⭐⭐ interview pattern and builds directly on the pointer concepts you've just learned.

DSA: Topic 2: Hash Maps & Sets

M.T.Ramkrushna — Mon, 14 Sep 2026 11:21:11 +0000

Why interviewers ask hash map questions

They want to see if you can:

Trade a little extra memory for much faster runtime.
Recognise repeated lookups.
Avoid nested loops.

A common interview progression is:

Candidate writes O(n²) → Interviewer asks, "Can you optimise this?" → Expected answer: use a hash map.

What is a Hash Map?

In Python, a hash map is a dictionary.

student = {
    "Alice": 95,
    "Bob": 88,
    "Charlie": 91
}

Accessing a value:

print(student["Bob"])
# 88

Average time complexity:

Insert: O(1)
Search: O(1)
Delete: O(1)

This is why dictionaries are so powerful.

What is a Set?

A set stores unique elements.

nums = {3, 7, 2}

print(7 in nums)
# True

Use a set when:

You only care whether an item exists.
You need to remove duplicates.

Example:

nums = [1, 2, 2, 3, 3, 4]

unique = set(nums)

print(unique)
# {1, 2, 3, 4}

When should you think "Hash Map"?

Ask yourself these questions:

Am I repeatedly searching for values?
Am I checking if something already exists?
Am I counting frequencies?
Am I matching pairs?
Am I removing duplicates?

If the answer is "yes", a dictionary or set is often the right tool.

Interview Pattern 1: Frequency Counting

Problem

Find the number that appears most often.

Example:

nums = [1, 2, 1, 3, 2, 1]

Instead of counting each number repeatedly (which is slow), build a frequency table:

freq = {}

for num in nums:
    freq[num] = freq.get(num, 0) + 1

print(freq)

Output:

{1: 3, 2: 2, 3: 1}

This pattern appears in problems like:

Majority Element
Top K Frequent Elements
First Unique Character

Interview Pattern 2: Fast Lookup

Problem

Does the array contain duplicates?

Brute force:

Compare every pair

Time: O(n²)

Optimised:

seen = set()

for num in nums:
    if num in seen:
        return True
    seen.add(num)

return False

Time: O(n)

This is the expected interview solution.

Interview Pattern 3: Two Sum

This is one of the most famous interview questions.

Problem

nums = [2, 7, 11, 15]
target = 9

Return the indices of two numbers whose sum is 9.

Brute Force

for i in range(len(nums)):
    for j in range(i + 1, len(nums)):
        if nums[i] + nums[j] == target:
            return [i, j]

Time: O(n²)

Optimised Solution

Keep a dictionary of numbers you've already seen.

def two_sum(nums, target):
    seen = {}

    for i, num in enumerate(nums):
        complement = target - num

        if complement in seen:
            return [seen[complement], i]

        seen[num] = i

Time: O(n)

This is the solution interviewers usually expect.

Common Dictionary Methods

d = {}

d["apple"] = 5          # Insert/update

print(d["apple"])       # Access

print(d.get("banana"))  # None (instead of KeyError)

print(d.get("banana", 0))  # Default value

Iterating:

for key, value in d.items():
    print(key, value)

Common Set Methods

s = set()

s.add(5)

s.add(10)

s.remove(5)

print(10 in s)

Common Interview Mistakes

Mistake 1: Forgetting duplicate keys overwrite values

d = {}

d[1] = "A"
d[1] = "B"

print(d)

Output:

{1: 'B'}

The second assignment replaces the first.

Mistake 2: Accessing a missing key directly

count = {}

print(count["apple"])

This raises a KeyError.

Safer:

count.get("apple", 0)

Mistake 3: Using a list instead of a set for membership checks

if x in my_list:

This is O(n).

If you're only checking existence many times, use a set:

if x in my_set:

Average time: O(1).

Real Interview Problems

Master these:

Two Sum ⭐⭐⭐⭐⭐
Contains Duplicate ⭐⭐⭐⭐⭐
Valid Anagram ⭐⭐⭐⭐
Group Anagrams ⭐⭐⭐⭐
Majority Element ⭐⭐⭐⭐
Top K Frequent Elements ⭐⭐⭐⭐
First Unique Character ⭐⭐⭐
Happy Number ⭐⭐⭐

Interview Tip

When you're given an array, pause before coding and ask:

"Will I need to search or count elements repeatedly?"

If the answer is yes, consider a dictionary or set before reaching for nested loops. This habit alone can turn many brute-force solutions into optimal ones.

Practice

Try solving these without looking up solutions:

Return True if an array contains duplicates.
Count the frequency of each word in a list of strings.
Solve Two Sum in O(n).
Find the first non-repeating character in a string.

Once you're comfortable with hash maps and sets, the next topic is Two Pointers, one of the most frequently tested techniques for array and string problems.

DSA: Topic 1: Array

M.T.Ramkrushna — Mon, 14 Sep 2026 10:57:58 +0000

Why are arrays so important?

Around 30–40% of interview questions involve arrays, either directly or as the underlying data structure.

Companies don't ask:

"What is an array?"

They ask:

Can you identify the right pattern?
Can you optimise from O(n²) to O(n)?
Can you write bug-free code?

What interviewers test

1. Traversal

Can you process every element exactly once?

Example:

nums = [4, 2, 8, 1]

Find the maximum.

Naive approach:

mx = nums[0]

for num in nums:
    if num > mx:
        mx = num

Time Complexity

O(n)

This is the expected solution.

2. Updating Values

Example

Increase every element by 10.

for i in range(len(nums)):
    nums[i] += 10

Interviewers want to know whether you understand when to modify a list in place versus creating a new one.

3. Searching

Suppose the interviewer asks:

Find whether 37 exists.

You scan once.

for num in nums:
    if num == 37:
        return True

Complexity

O(n)

A common follow-up is:

Can you do better?

If the array is sorted, you should think of Binary Search (O(log n)).

4. Insertion & Deletion Costs

Interviewers expect you to know these complexities without hesitation:

Operation	Complexity	Why?
Access `arr[i]`	O(1)	Direct indexing
Append	O(1) amortised	Usually adds to the end
Insert at front	O(n)	Elements shift right
Delete at front	O(n)	Elements shift left
Search	O(n)	May examine every element

Understanding why matters more than memorising the table.

The first optimisation interviewers expect

Consider this question:

Given an array, return the sum.

Most candidates write:

total = 0

for num in nums:
    total += num

That's perfectly fine.

However, if asked for:

Sum from index l to r for many different queries,

doing a loop each time is too slow. This leads to the Prefix Sum technique, where you preprocess once and answer each query in O(1). Interviewers often expect you to recognise when repeated work can be avoided.

The biggest interview lesson

Most array problems aren't about arrays—they're about recognising patterns.

For example:

Problem 1

Find two numbers whose sum equals a target.

Many candidates first think:

Check every pair

O(n²)

But interviewers expect you to recognise the Hash Map pattern and achieve:

O(n)

Problem 2

Move all zeros to the end.

Naive:

O(n²)

Expected:

O(n)

using the Two Pointers technique.

Problem 3

Longest substring without repeating characters.

Expected approach:

Sliding Window.

Most common array patterns

You should learn these in this order:

Simple traversal
Prefix Sum
Hashing
Two Pointers
Sliding Window
Binary Search on arrays
Sorting + scanning
Greedy on arrays

These patterns solve the majority of interview-style array questions.

Real interview questions to master

Two Sum
Best Time to Buy and Sell Stock
Contains Duplicate
Product of Array Except Self
Move Zeroes
Merge Sorted Array
Rotate Array
Maximum Subarray (Kadane's Algorithm)
Majority Element
Missing Number

If you can solve these confidently, you'll have a strong foundation in array problems.

How we'll learn

For each topic, we'll use the same structure:

Core concept (what you need to know)
How interviewers think (what they're testing)
Brute-force solution (often acceptable as a starting point)
Optimised solution (the expected answer)
Common mistakes and follow-up questions
3–5 real interview problems, solved step by step in Python.

This approach mirrors how technical interviews are conducted and helps you build problem-solving skills rather than just memorising algorithms.

From Python Basics to Building an Async Task Processing API

M.T.Ramkrushna — Wed, 24 Jun 2026 17:27:47 +0000

Most tutorials teach concepts separately:

Classes
Decorators
Async
Generators
Type hints
Pytest

The problem?

Real applications use all of them together.

Let's build something useful.

Project Goal

Build an Async Task Processing API.

Users can:

Submit tasks
Check status
Process tasks in background

Think:

Video processing
Email sending
Report generation
AI jobs

Exactly how modern SaaS products work.

Step 1: Python Syntax Refresh

Variables:

name = "John"
age = 25

Functions:

def greet(name):
    return f"Hello {name}"

Lists:

tasks = ["email", "sms"]

Dictionaries:

task = {
    "id": 1,
    "status": "pending"
}

Step 2: Classes

Represent a task.

class Task:
    def __init__(self, task_id, name):
        self.task_id = task_id
        self.name = name
        self.status = "pending"

Usage:

task = Task(1, "Send Email")

Think of a class as a blueprint.

Like an architect's drawing before building a house.

Step 3: Type Hints

def create_task(
    name: str
) -> str:
    return name

Benefits:

Better IDE support
Easier maintenance
Self-documenting code

Step 4: Pydantic

from pydantic import BaseModel

class TaskRequest(BaseModel):
    name: str

Incoming requests validated automatically.

Step 5: Async/Await

Task simulation:

import asyncio

async def process_task():
    await asyncio.sleep(5)

The server remains available while waiting.

Step 6: Decorators

Logging decorator.

def log(func):
    def wrapper(*args, **kwargs):
        print("Running...")
        return func(*args, **kwargs)

    return wrapper

Usage:

@log
def create_task():
    pass

Think of decorators as middleware for functions.

Step 7: Generators

Large task stream.

def task_stream():
    for i in range(1000000):
        yield i

Memory friendly.

Only one value exists at a time.

Step 8: FastAPI API

from fastapi import FastAPI

app = FastAPI()

Create task:

@app.post("/tasks")
async def create_task():
    pass

Check status:

@app.get("/tasks/{id}")
async def get_task():
    pass

Step 9: Background Processing

asyncio.create_task(
    process_task()
)

Request returns immediately.

Processing continues.

This is how:

YouTube
Uber
Airbnb
Stripe

handle long-running work.

Step 10: Pytest

Test task creation.

def test_create_task():
    assert 1 + 1 == 2

API testing:

def test_task_api():
    response = client.post(
        "/tasks"
    )

    assert response.status_code == 200

Testing is insurance.

Nobody notices it until something breaks.

Final Architecture

Request

↓

Pydantic Validation

↓

FastAPI Endpoint

↓

Background Async Task

↓

Task Storage

↓

Status Endpoint

↓

Client

What You'll Learn in One Project

✓ Python Syntax

✓ Classes

✓ Type Hints

✓ Decorators

✓ Generators

✓ Async/Await

✓ Pydantic

✓ FastAPI

✓ Pytest

✓ Real Backend Architecture

This single project mirrors the foundations used inside modern AI products, SaaS platforms, and cloud-native backend systems.

Once you can build this confidently, you're no longer learning Python concepts.

You're building production systems.

Pydantic Explained Simply: The Security Guard of Your API

M.T.Ramkrushna — Wed, 24 Jun 2026 17:26:29 +0000

One of the biggest beginner mistakes in backend development is trusting user input.

Users can send:

{
  "name": 123,
  "email": false,
  "age": "banana"
}

Your application expects:

{
  "name": "John",
  "email": "john@gmail.com",
  "age": 25
}

How do we stop bad data?

Enter Pydantic.

Think of an Airport Security Check

Before passengers board a plane:

Identity checked
Bags checked
Documents checked

Not because passengers are bad.

Because systems fail when validation is skipped.

Pydantic does the same for APIs.

Without Pydantic

data = request.json()

name = data["name"]
age = data["age"]

What if:

{
  "age": "hello"
}

Crash.

With Pydantic

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

Input:

User(
    name="John",
    age=25
)

Works.

Input:

User(
    name="John",
    age="hello"
)

Validation error.

Why FastAPI Loves Pydantic

FastAPI automatically:

Validates requests
Generates documentation
Creates schemas
Returns useful errors

Example:

from fastapi import FastAPI

app = FastAPI()

@app.post("/users")
async def create_user(user: User):
    return user

That's all.

Validation included.

Real Business Example

Imagine a payment API.

You expect:

amount: float

User sends:

{
  "amount": "one million"
}

Without validation:

Database corruption
Failed transactions
Production incidents

With Pydantic:

Request rejected instantly.

Hidden Superpower

Pydantic can transform data.

Input:

{
  "age": "25"
}

Model:

class User(BaseModel):
    age: int

Output:

age = 25

Automatic conversion.

Magic with safety.

Think of Pydantic Like This

Database = Vault

API = Front Door

Pydantic = Security Guard

Without a guard, anyone walks in.

With a guard, only valid data enters.

That's why nearly every serious FastAPI project uses Pydantic.

Understanding Async/Await Visually: The Restaurant Analogy Every Developer Remembers

M.T.Ramkrushna — Tue, 23 Jun 2026 14:19:55 +0000

Most developers learn async/await by reading definitions like:

"Async programming allows non-blocking execution of code."

Sounds smart.

But many still can't explain what actually happens.

Let's fix that.

Imagine a Restaurant

You walk into a restaurant.

Synchronous World

A waiter takes your order.

Then stands next to the kitchen.

And waits.

For 20 minutes.

Doing nothing.

Then brings your food.

Then serves the next customer.

Ridiculous, right?

Yet this is exactly how synchronous code behaves.

import time

def make_pizza():
    time.sleep(20)
    return "Pizza Ready"

pizza = make_pizza()
print(pizza)

The program waits.

Nothing else happens.

Async World

Now imagine a smarter waiter.

He takes your order.

Gives it to the kitchen.

Moves to another table.

Takes more orders.

Serves drinks.

Answers questions.

When the pizza is ready, he comes back.

That's async programming.

The waiter doesn't stop working.

The kitchen works independently.

import asyncio

async def make_pizza():
    await asyncio.sleep(20)
    return "Pizza Ready"

Notice the keyword:

await

This means:

"I'm waiting for something. While waiting, let someone else work."

Why Async Exists

Modern applications spend most of their time waiting:

Database queries
API calls
File uploads
Payment gateways
Email services

The CPU isn't busy.

It's waiting.

Async lets us use that waiting time productively.

Real Example: Fetching User Data

Without async:

user = get_user()
orders = get_orders()
payments = get_payments()

Time:

1 sec + 1 sec + 1 sec = 3 sec

With async:

user, orders, payments = await asyncio.gather(
    get_user(),
    get_orders(),
    get_payments()
)

Time:

max(1,1,1) = 1 sec

Same work.

3x faster.

Common Beginner Mistake

People think async means:

Faster CPU execution.

Wrong.

Async doesn't make calculations faster.

It makes waiting smarter.

Think:

CPU work → multiprocessing
Waiting work → async

Mental Model

Imagine every function holding a microphone.

Normal function:

"Nobody talks until I'm done."

Async function:

"While I'm waiting, someone else can speak."

That single idea explains 90% of async programming.

Where You'll Use Async

Almost every modern backend framework:

FastAPI
Starlette
Sanic
Node.js
Deno
Modern Django

If your application talks to databases, APIs, queues, or cloud services, async is becoming mandatory knowledge.

Final Takeaway

Async programming is not about speed.

It's about efficiency.

A waiter who serves one table at a time creates a queue.

A waiter who keeps moving creates a business.

Your code works exactly the same way.

Why pytest Makes Python Testing Surprisingly Enjoyable

M.T.Ramkrushna — Tue, 19 May 2026 03:11:01 +0000

Many developers avoid testing because traditional testing frameworks feel heavy.

But pytest changed that perception for Python developers.

It’s minimal, readable, and extremely powerful.

Real-Life Problem

Imagine deploying:

payment systems,
trading bots,
AI pipelines,
order management systems.

One unnoticed bug can:

lose money,
corrupt data,
crash services.

Testing is insurance.

Traditional Testing Feels Verbose

Older frameworks often require:

large setup code,
boilerplate classes,
repetitive assertions.

pytest keeps things simple.

Basic Example

Suppose you have:

def calculate_total(price: int, quantity: int) -> int:
    return price * quantity

Test:

def test_calculate_total():
    result = calculate_total(100, 3)

    assert result == 300

That’s it.

No huge setup required.

Why Developers Love pytest

It provides:

simple syntax,
detailed failure reports,
fixtures,
parameterized testing,
async testing support.

Real Backend Example

Imagine validating order status.

class Order:

    def __init__(self):
        self.status = "pending"

    def complete(self):
        self.status = "completed"

Test:

def test_order_completion():
    order = Order()

    order.complete()

    assert order.status == "completed"

Readable even for non-Python developers.

Testing Async Code

Modern systems are async-heavy.

pytest handles this beautifully.

import pytest
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "success"

@pytest.mark.asyncio
async def test_fetch_data():
    result = await fetch_data()

    assert result == "success"

This becomes essential in:

FastAPI,
AI agents,
websocket systems,
realtime apps.

Fixtures: Reusable Test Setup

Suppose multiple tests need a sample user.

import pytest

@pytest.fixture
def sample_user():
    return {
        "name": "Ali",
        "age": 26
    }

def test_user_name(sample_user):
    assert sample_user["name"] == "Ali"

Fixtures reduce duplication massively.

Real Industry Usage

Companies use pytest for:

backend APIs,
ML pipelines,
infra automation,
data engineering,
AI systems.

Testing becomes even more important as systems scale.

Final Thoughts

pytest is one reason Python developer experience feels so good.

It encourages testing without making it painful.

And developers who write tests consistently usually:

ship faster,
debug less,
break production less often.

That becomes a serious career advantage over time.

DEV Community: M.T.Ramkrushna

DSA: Topic 8: Linked Lists

1. What is a Linked List?

Singly linked list

Why does this matter?

2. Create a Linked List in Python

3. Traversing a Linked List

Complexity

4. Linked List Complexity

5. Most Important Interview Problem: Reverse Linked List ⭐⭐⭐⭐⭐

Problem

The key idea: Three pointers

Step 1

Step 2

Python solution

Dry run

Complexity

Critical mistake

6. Fast and Slow Pointers

7. Interview Problem: Middle of Linked List

Code

Why it works

Complexity

8. Interview Problem: Linked List Cycle

Problem

Brute force

Optimised: Floyd's Cycle Detection

9. Interview Problem: Remove Nth Node From End

Key idea

Python solution

Why use a dummy node?

Complexity

10. Linked List Patterns You Must Know

11. Real Interview Questions

12. Exam Cheat Sheet

Practice question

Next topic: Trees

DSA: Topic 7: Queues, Deques & BFS

1. What is a Queue?

Queue visualization

Basic operations

2. Python Queue: deque

Complexity

Important interview mistake

3. Queue vs Stack

4. BFS — The Most Important Part ⭐⭐⭐⭐⭐

5. Interview Problem: Binary Tree Level Order Traversal

Problem

Interview thinking

Python solution

Complexity

Important trick: for _ in range(len(q))

6. BFS on a Grid

Problem: Number of Islands

Interview approach

Python solution

Complexity

Interview insight

7. BFS for Shortest Path

Example

8. Multi-Source BFS ⭐⭐⭐⭐☆

Example: Rotting Oranges

Interview clue

9. BFS Template for Interviews

Tree or graph BFS

Grid BFS

10. How to Recognise BFS vs DFS

11. Real Interview Problems to Practice

Easy

Medium

Advanced

12. Exam Cheat Sheet

Practice question

Next topic: Linked Lists

DSA: Topic 6: Stacks & Monotonic Stack

1. What is a Stack?

Stack visualization

Python implementation

Time complexity

2. When should you think "Stack"?

2. Python Queue: `deque`

Important trick: `for _ in range(len(q))`