DEV Community: Anil Nayak

Mastering Two Pointers & Sliding Window Techniques in Coding Interviews

Anil Nayak — Wed, 16 Apr 2025 14:19:04 +0000

if you’re prepping for coding interviews, you’ve likely come across problems like:

"Find two numbers in an array that add up to a target."

"Find the longest substring without repeating characters."

"Find the maximum sum of a subarray of size k."

Guess what? Most of these can be solved using two powerful techniques: Two Pointers and Sliding Window.

Let’s break them down and see how they can save you from brute force nightmares 😅

🔁 What is the Two Pointers Technique?

This technique involves using two indices (pointers) to iterate through a data structure. It's especially useful for:

Sorted arrays

Linked lists

Comparing elements from both ends

✅ Example 1: Two Sum (Sorted Array)

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

    while left < right:
        curr_sum = nums[left] + nums[right]
        if curr_sum == target:
            return [left, right]
        elif curr_sum < target:
            left += 1
        else:
            right -= 1
    return []

🧠 Time Complexity: O(n)

🪟 What is the Sliding Window Technique?

Used for problems involving subarrays or substrings — you "slide" a window (range) over the data to keep track of a condition (e.g., sum, length, uniqueness).

✅ Example 2: Maximum Sum of Subarray of Size k

def max_sum_subarray(nums, k):
    max_sum = window_sum = sum(nums[:k])
    for i in range(k, len(nums)):
        window_sum += nums[i] - nums[i - k]
        max_sum = max(max_sum, window_sum)
    return max_sum

🧠 Time Complexity: O(n)

✅ Example 3: Longest Substring Without Repeating Characters

def length_of_longest_substring(s):
    seen = set()
    left = max_len = 0

    for right in range(len(s)):
        while s[right] in seen:
            seen.remove(s[left])
            left += 1
        seen.add(s[right])
        max_len = max(max_len, right - left + 1)

    return max_len

This is both Two Pointers + Sliding Window magic ✨

🤔 When to Use What?

Problem Type	Technique
Sorted array, find pair/triplet	Two Pointers
Subarray of fixed size	Sliding Window
Subarray/substring with condition	Sliding Window
Reversing or merging sorted arrays	Two Pointers

💡 Final Tips

Sliding window is like an adjustable “view” into your array or string.

Two pointers are perfect when the data is sorted or needs comparing from both ends.

Practice makes patterns — soon you’ll spot these problems in seconds.

👨‍💻 Practice Problems

Leetcode 3: Longest Substring Without Repeating Characters

Leetcode 209: Minimum Size Subarray Sum

Leetcode 167: Two Sum II - Input Array is Sorted

Hope this helps you in your coding journey! 🚀
Feel free to drop your thoughts or questions in the comments below. 🙌

🚀 Sorting Algorithms Demystified: A Beginner's Guide with Python Examples

Anil Nayak — Tue, 08 Apr 2025 19:22:28 +0000

Sorting is one of the most fundamental concepts in computer science. Whether you're a student, job seeker, or just a curious dev, understanding sorting algorithms is essential.

In this post, I'll break down the most popular sorting algorithms — Bubble Sort, Merge Sort, Quick Sort, Insertion Sort, Selection Sort, and Heap Sort — using simple Python examples and visuals in mind.

🔄 1. Bubble Sort – The Slow but Steady One

How it works:

Bubble Sort repeatedly compares and swaps adjacent elements if they are in the wrong order.

def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(len(arr) - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

📌 Time Complexity: O(n²)
📌 Space Complexity: O(1)
📌 Best used for: Small datasets and educational purposes.

🧩 2. Merge Sort – Divide and Conquer FTW

How it works:
Split the list in half, recursively sort each half, and merge them back together in order.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

📌 Time Complexity: O(n log n)
📌 Space Complexity: O(n)
📌 Best used for: Large datasets that need stable sorting.

⚡ 3. Quick Sort – The Speed Demon

How it works:
Choose a pivot, then split the list into elements less than and greater than the pivot. Recursively sort both parts.

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[0]
    less = [x for x in arr[1:] if x <= pivot]
    greater = [x for x in arr[1:] if x > pivot]

    return quick_sort(less) + [pivot] + quick_sort(greater)

📌 Time Complexity:

Best/Average: O(n log n)

Worst: O(n²) (rare case)
📌 Space Complexity: O(log n)
📌 Best used for: General-purpose sorting, fast in practice.

📥 4. Insertion Sort – Best for Nearly Sorted Data

How it works:
Build the sorted array one item at a time by inserting each element into its correct position.

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

📌 Time Complexity: O(n²)
📌 Space Complexity: O(1)
📌 Best used for: Small or nearly sorted arrays.

🔍 5. Selection Sort – Simple but Inefficient

How it works:
Find the minimum element in the unsorted part and move it to the beginning.

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

📌 Time Complexity: O(n²)
📌 Space Complexity: O(1)
📌 Best used for: Simple educational use cases.

⛏️ 6. Heap Sort – Uses a Heap Data Structure

How it works:
Turn the array into a max-heap, repeatedly extract the maximum element and heapify the remaining.

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2

    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)

    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)

    return arr

📌 Time Complexity: O(n log n)
📌 Space Complexity: O(1)
📌 Best used for: Time-efficient and memory-constrained tasks.

🧠 Key Takeaways

Algorithm	Time Complexity	Space Complexity	Best For
Bubble Sort	O(n²)	O(1)	Teaching, tiny datasets
Insertion Sort	O(n²)	O(1)	Small or nearly sorted data
Selection Sort	O(n²)	O(1)	Educational simplicity
Merge Sort	O(n log n)	O(n)	Large datasets, stable sorting
Quick Sort	O(n log n)/O(n²)	O(log n)	Fast, general-purpose sorting
Heap Sort	O(n log n)	O(1)	Efficient in-place sorting

🧪 Want to Practice?

Try implementing these algorithms in:

✅ JavaScript or C++

✅ Visualize them using animations (React + Chart.js or Python Turtle)

✅ Sort real-world data (JSON files, user input, logs)

🙌 Final Thoughts

Sorting may sound boring, but once you understand it — you've unlocked a superpower for solving real-world problems and cracking coding interviews.

If this helped you, consider giving it a ❤️ or sharing with a friend!

👋 Let's Connect!

📌 GitHub

📌 LinkedIn

📌 Portfolio

🚀 Complete Guide to Mastering Data Structures and Algorithms (DSA) – From Beginner to Pro

Anil Nayak — Mon, 07 Apr 2025 05:54:44 +0000

“Programming isn’t about what you know; it’s about what you can figure out.” — Chris Pine

👋 Welcome, Devs!

Whether you're preparing for coding interviews or want to write efficient code, this post covers everything you need to master DSA. You’ll find:

✅ Core data structures

✅ Searching and sorting algorithms

✅ Trees and graphs

✅ Recursion & dynamic programming

✅ Practice tips & roadmap

✅ Code snippets in Python

✅ Resources and visuals

✅ Your journey checklist!

🧠 What Is DSA?

Data Structures and Algorithms (DSA) is the foundation of computer science. It’s how data is organized and manipulated, and it helps solve problems optimally and efficiently.

🧰 Core Data Structures

Data Structure	Use Case	Python Example
Array/List	Store items in order	`arr = [1, 2, 3]`
Stack	Undo/Back navigation	`stack.append(x); stack.pop()`
Queue	Scheduling, BFS	`from collections import deque`
HashMap/Dict	Fast lookup	`dict = {"a": 1}`
Set	Unique items	`myset = set()`
Linked List	Dynamic memory	Custom node-based classes
Heap	Priority Queue	`import heapq`
Graph	Maps, Networks	Dictionary of lists/sets

🔍 Searching Algorithms

✅ Binary Search

def binary_search(arr, x):
    left, right = 0, len(arr)-1
    while left <= right:
        mid = (left+right)//2
        if arr[mid] == x:
            return mid
        elif arr[mid] < x:
            left = mid + 1
        else:
            right = mid - 1
    return -1

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

🔃 Sorting Algorithms Overview

Algorithm	Best	Average	Worst	Space	Stable
Bubble Sort	O(n)	O(n²)	O(n²)	O(1)	✅ Yes
Selection Sort	O(n²)	O(n²)	O(n²)	O(1)	❌ No
Insertion Sort	O(n)	O(n²)	O(n²)	O(1)	✅ Yes
Merge Sort	O(n log n)	O(n log n)	O(n log n)	O(n)	✅ Yes
Quick Sort	O(n log n)	O(n log n)	O(n²)	O(log n)	❌ No
Heap Sort	O(n log n)	O(n log n)	O(n log n)	O(1)	❌ No
Counting Sort	O(n + k)	O(n + k)	O(n + k)	O(k)	✅ Yes
Radix Sort	O(nk)	O(nk)	O(nk)	O(n + k)	✅ Yes

🌲 Trees & Graphs

✅ DFS (Depth-First Search)

def dfs(graph, node, visited=set()):
    if node not in visited:
        print(node, end=" ")
        visited.add(node)
        for neighbor in graph[node]:
            dfs(graph, neighbor, visited)

✅ BFS (Breadth-First Search)

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        node = queue.popleft()
        if node not in visited:
            print(node, end=" ")
            visited.add(node)
            queue.extend(graph[node])

Both take: O(V + E) time

📦 Recursion & Dynamic Programming

🧠 Fibonacci with DP (Memoization)

def fib(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

📈 DSA Practice Plan

Week	Topics
1	Arrays, Strings
2	Recursion, Searching, Sorting
3	Stacks, Queues, Linked Lists
4	Trees, Heaps
5	Graphs
6	DP, Backtracking
7+	Practice: LeetCode, Codeforces, GFG

🛠 Resources

🔗 VisualAlgo
📘 Cracking the Coding Interview
📺 YouTube Channels: Take U Forward, NeetCode, Abdul Bari
📚 GeeksforGeeks DSA Sheet

✅ Final Checklist Before Interviews

Know basic data structures
Solve 100+ DSA problems
Master recursion & DP
Understand time & space complexity
Be confident with graphs & trees

✨ Connect with Me!

🔗 GitHub: github.com/Anilnayak126

🧠 LinkedIn: linkedin.com/in/anil-kumar-nayak

✍️ Medium: medium.com/@nayakanil43603

🔥 Final Words

Data Structures and Algorithms are like the grammar of programming. Don’t just memorize—practice and internalize. Stick to the plan, keep coding, and trust the process. You're closer than you think!

"Success is the sum of small efforts repeated day in and day out."

Emerging Tech Trends That Will Shape the Future

Anil Nayak — Sat, 15 Mar 2025 14:35:32 +0000

Technology is advancing at an incredible pace, bringing new opportunities and challenges. Here are some of the most impactful emerging tech trends that are set to shape our digital landscape.

🤖 1. AI and Generative Models

AI is transforming industries with generative models that create text, images, and even code. Tools like ChatGPT, DALL·E, and MidJourney are making AI more accessible for businesses and developers alike.

🌍 2. Sustainable Tech and Green Computing

With climate concerns growing, companies are investing in green computing solutions, such as energy-efficient AI models and sustainable hardware production. Cloud providers are also focusing on carbon-neutral data centers.

🔗 3. Web3 and Smart Contracts

Decentralization is redefining online security and ownership. Developers are exploring blockchain for smart contracts, digital identity verification, and decentralized finance (DeFi), making applications more secure and user-driven.

📡 4. 6G and the Future of Connectivity

While 5G is still expanding, researchers are already working on 6G, which promises even faster speeds and ultra-low latency. This will unlock new possibilities for smart cities, IoT, and real-time AI applications.

🕶️ 5. The Rise of Spatial Computing

Apple’s Vision Pro and advancements in AR/VR are paving the way for spatial computing. Developers are building immersive applications for work, entertainment, and social interactions.

🏗️ 6. Low-Code/No-Code Expansion

Platforms like Bubble, Webflow, and OutSystems are enabling rapid application development. While traditional coding remains essential, these tools empower non-developers to bring their ideas to life.

🚀 Looking Ahead

The future of technology is filled with exciting innovations. Which trend do you think will have the biggest impact? Let’s discuss in the comments! 🔥

My Journey as a Python Full-Stack Developer 🚀

Anil Nayak — Fri, 14 Mar 2025 06:14:24 +0000

Hey Devs! 👋

I'm excited to share my journey as a Python full-stack developer. Over the past months, I’ve been working with Django, Django Rest Framework, React, and Tailwind CSS to build some awesome projects.

🔥 How It All Started

I started with Python for scripting and small automation tasks. But as my curiosity grew, I dived into Django to understand backend development. Soon, I explored React to enhance my frontend skills, and that’s how I became a full-stack developer.

💡 What I Have Built So Far

Some of my projects include:

LMS (Learning Management System) using React & Tailwind CSS
YouTube Clone using React & RapidAPI
File Sharing App with Django DRF
Vintage Book Market – A platform for buying and selling second-hand books, built with Django, React, Redux, and Tailwind CSS

⚡ Challenges & Learnings

One major challenge was integrating the frontend and backend smoothly. Managing APIs, authentication, and state was tough initially, but using Redux and Django DRF made things easier.

For Vintage Book Market, handling real-time book availability and user interactions was a key focus. Implementing secure payments and efficient search functionality was a learning experience.

🎯 What’s Next?

I'm currently learning advanced backend optimizations & cloud deployment. I also plan to explore Next.js & AWS to enhance my stack.

🚀 Let’s Connect!

I’d love to hear your thoughts! Are you also working on Python full-stack projects? Share your experiences in the comments!