#data-structure-algorithm

🧩 Sieve of Eratosthenes with Visualization | Finding Primes in the Smartest Way!

sieve of eratosthenes — best way to find Primes

Logarithms Made Easy

Learning Objectives

LeetCode Diaries #7: Consecutively Humbled — Two solutions and One Existential Crisis Later

Do you ever read a question and think to yourself — ‘Easy, I got this’? Except you really don’t ‘got this’. You had never really ‘got…

How to Start Your Software Development Career in 2026: A Complete Roadmap for Beginners

The software industry continues to create exciting opportunities for students, fresh graduates, and career changers. However, many aspiring…

break vs return in Java: What's the Difference?

One of the most common sources of confusion for beginners is understanding when to use break and when to use return. They both stop…

LeetCode Diaries #6: Turns Out the Most Optimal Solution isn’t the Most Intuitive One

It finally happened…for problem #6 I did in fact end up asking the powers that be for the best solution.

Java Basics — Input & Output

Hello! Welcome to my content… I’ll be honest here, I’m writing this for my personal reference- but I’m totally fine, sharing it with the…

I Stopped Grinding LeetCode Randomly. Here’s the Sheet That Fixed It.

Open the NeetCode 150 + Blind 75 tracker

LeetCode Diaries #5: I Put a Number in Front of My String and Called It a Day

Let us just hope our private information is not being encoded in the way I solved today’s problem.

Stop Memorizing Trees. Understand Why They Exist.

“Understanding the problem is more valuable than memorizing the solution.”

Machine Learning for Algorithmic Trading — Part 37 Risk, Guardrails, and Human-in-the-Loop

Part 5 of 6 — Building an autonomous trading agent, grounded in Stefan Jansen’s Machine Learning for Algorithmic Trading.

DSA Playbook: Part 2— Arrays

For instance, when processing massive datasets for machine learning models or high-throughput alert systems, the memory latency introduced…

Big O Notation Explained for Beginners

While learning Data Structures in college, I found almost every concept easy to understand — except one: Big O notation.

Learning Beyond Accepted | Engineering Thoughts ⭐

Whenever I solve a LeetCode problem, I have a simple objective.

I Found the Perfect Resource to Master Coding Interview Patterns and Its Awesome

My favorite place to learn coding interview patterns for FAANG

Data structures — Hash tables/ Associative Arrays

Lets discuss about hash table data structure and how is it used in Python. This blog is split into three sections, catering to readers from…

Solving Codeforces 473-B (Mahmoud and Ehab and the Message)

Why I Picked This Problem

Dynamic Programming — Part III: Beyond Two Choices (Coin Change)

“The hardest part of Dynamic Programming isn’t writing the recurrence. It’s discovering it.”

LeetCode Gets Easier Once You Recognize These 15 Coding Patterns

Stop memorizing solutions. Learn how to identify the structure hiding inside unfamiliar interview problems.

Dynamic Programming — Part I: From Recursion to Dynamic Programming (Using Kotlin)

“Dynamic Programming is not a technique you memorize. It is a technique you naturally discover when recursion starts doing unnecessary…

Stop Memorizing DSA Patterns — Learn to Recognize Them Instead

A recognition framework for 30 patterns — from Sliding Window and Prefix Sum to Heaps, BFS/DFS, Backtracking, and Dynamic Programming

How to Master Data Structures and Algorithms Without Feeling Lost 😞

A beginner-friendly guide to understanding DSA deeply, building real problem-solving skills, and avoiding the surface-level learning that…

I Stopped Memorizing Tree Traversals When I Understood One Simple Pattern

A few weeks ago, if someone had asked me to write a tree traversal from memory, I probably would have tried to memorize three different…

DFS to Backtracking — Understanding the Intuition Through Four Problems

Backtracking is one of those algorithms that often feels mysterious when we first encounter it. We memorize a template, learn where to add…

Manacher’s Algorithm

I was trying to solve a palindrome problem recently and it can be solved using dynamic programming, O(n²) solution. It’s pretty standard…

DSA Day 96/250: Task Scheduler (LeetCode 621)

Schedule tasks efficiently with cooling periods using a greedy counting approach.

Lesson 5: Breadth First Search (BFS) Through a Real Interview Problem

Finding The Shortest Path In An Unweighted Graph. This is one of the biggest “aha moments” in graph learning.

enumerate — permutation

有兩種方法：

Bubble Sort vs Selection Sort vs Insertion Sort: Understanding the Subtle Differences

When learning sorting algorithms, Bubble Sort, Selection Sort, and Insertion Sort are often introduced together because they all have the…

DSA Day 95/250: Find K Pairs with Smallest Sums (LeetCode 373)

Find the k pairs with the smallest sums using a min heap and sorted array properties.

DSA Day 94/250: Kth Smallest Element in a Sorted Matrix (LeetCode 378)

Find the kth smallest element efficiently using binary search on answer space.

The “Algorithmic Monoculture” Shuts Out Minorities from the Job Market

Job hunting has changed dramatically. With corporate job openings attracting a deluge of resumes, over 90% of U.S. employers now rely on…

DSA Day 93/250: K Closest Points to Origin (LeetCode 973)

Find the k closest points to the origin efficiently using a max heap.

The Algorithm Hidden Inside MS Paint: Understanding Flood Fill with DFS

Most computer science students learn Depth-First Search (DFS) by traversing graphs, visiting nodes, and solving competitive programming…

Flattened Balanced Binary Search Tree, a Hybrid of Balanced Binary Search Tree and B-Tree…

This article describes the data structure Flattened Balanced Binary Search Tree (FBBST), a container of ordered data supporting fast query…

Graph Thinking Patterns: Components, Distances, and Paths

In the previous article, we learned how Depth First Search (DFS) works on trees.

LeetCode 73: Set Matrix Zeroes

In this blog:

LeetCode taught us to solve, LeetPal will help with what to solve next!

Try Out LeetPal!

DFS on Trees: Three Patterns I Keep Seeing in Coding Interviews

When I first learned Depth First Search (DFS), I thought of it as a tree traversal technique.

String Tokenization Problem & Prefix Tree

Algorithmic Management and Workplace Autonomy: Opportunities, Challenges, and the Path Forward

Algorithmic management (AM) the deployment of data-driven algorithms and AI to direct, evaluate, and discipline workers is transforming…

Min Heap vs Max Heap: The Intuition That Finally Clicks

If you’ve ever been confused about when to use a min-heap vs max-heap, you’re not alone.

Merge Intervals Explained: From Brute Force to an Optimal O(n log n) Solution

Merge Intervals is a common technique used in everyday scenarios such as scheduling meetings, booking rooms, and managing time ranges. An…

Floyd’s Cycle Detection Algorithm — The “Circular Track” Intuition That Actually Sticks

If you’ve ever struggled to really understand Floyd’s Cycle Detection Algorithm (also called the Tortoise and Hare Algorithm), this…

Song Popularity Ranking

This is a data structure problem asked in online assessment for intern role at a MNC.

Understanding 0/1 Knapsack in the Easiest Way Possible (Recursion + Memoization)

If you are learning Dynamic Programming, chances are you have heard about the famous 0/1 Knapsack Problem. And chances are even higher that…

Sliding Window Mastery: 3 Problems That Build the Same Muscle

If you’ve ever confused different “substring” problems (I definitely have), you’re not alone. At first glance, these problems feel…

Mastering In-Place Array Problems: A Pattern That Solves 5+ Questions

If you’ve ever struggled with problems like removing duplicates, moving zeroes, or filtering elements in-place, you’re not alone. These…

Simplifying Graph Traversals: What’s up with the “visited” array?

Breadth-first traversal

The Mathematics of Hashing: From Uniform Distribution to Collision Resistance

Hashing is the cornerstone of modern computer science, transforming arbitrary inputs into fixed-size numerical outputs. This process…