Word Break: DP with a Word Dictionary
Solve Word Break with bottom-up dynamic programming. Includes brute force, edge cases, complexity analysis, and an interview script.
·6 min read · #dsa#leetcode#dynamic-programming
#dsa
277 posts · page 6 of 6
Word Ladder — BFS Over Wildcard-Pattern Buckets
The wildcard-pattern adjacency trick, why BFS is mandatory, and the bidirectional speedup.
·6 min read · #dsa#leetcode#graphs
Math for Coding Interviews: GCD, Primes, Modular Arithmetic
The essential math toolkit for interviews: Euclidean GCD, sieve of Eratosthenes, modular exponentiation, modular inverses, and common pitfalls.
·7 min read · #dsa#math#intermediate
Segment Tree: Range Queries and Updates
Learn segment trees for fast range sum, min, and max queries with point updates, including a clean iterative Python implementation.
·6 min read · #data-structures#segment-tree#intermediate
Topological Sort: Two Approaches Compared
Compare Kahn's BFS-based topological sort with DFS-based postorder, with Python implementations, complexity, and cycle detection.
·5 min read · #graphs#topological-sort#intermediate
Tries: The Data Structure Behind Autocomplete
A practical introduction to tries: node structure, insert, search, prefix queries, memory tradeoffs, and classic interview problems like word search.
·6 min read · #dsa#trie#beginner
Union-Find / Disjoint Set Union (DSU) Explained
Learn the union-find data structure with union by rank and path compression, why it runs in near-O(1) amortized, and how it powers Kruskal and islands.
·6 min read · #dsa#union-find#intermediate
Arrays: Common Operations and Patterns
The everyday array patterns every DSA learner should know — traversal, linear search, insertion, deletion, reversal, rotation, prefix sums, Kadane's preview, and the one-pass habit.
·11 min read · #dsa#arrays#intermediate
Arrays in DSA: Introduction
A beginner's introduction to arrays — contiguous memory, indexing, the Python list vs C array caveat, time complexity of read/write/insert/delete, and 1D vs 2D arrays.
·10 min read · #dsa#arrays#beginners
Arrays: 10 Practice Problems with Solutions
Ten classic array interview problems with examples, approach, complexity, and clean Python solutions — Two Sum, Best Time to Buy/Sell Stock, Kadane's, Rotate Array, Product Except Self, and more.
·13 min read · #dsa#arrays#practice
Big-O Notation: Time and Space Complexity Explained
A practical guide to Big-O notation — O(1), O(log n), O(n), O(n log n), O(n^2), and beyond, with code examples, best/average/worst case, and a brief look at amortized and space complexity.
·11 min read · #dsa#beginners#complexity
Binary Trees in DSA: Introduction
A practical introduction to binary trees — the TreeNode class, terminology (full, complete, perfect, balanced), height vs depth, BSTs, and the small calculations you need to reason about tree problems.
·9 min read · #dsa#trees#beginners
Binary Tree Traversals: Inorder, Preorder, Postorder, Level-Order
A practical guide to the four canonical binary tree traversals — recursive and iterative versions, when to use each, and the patterns that make them click.
·7 min read · #dsa#trees#intermediate
Binary Trees: 8 Practice Problems with Solutions
Eight classic binary tree interview problems with examples, approach notes, and clean Python solutions — max depth, same tree, invert, symmetric, path sum, LCA, validate BST, and serialize/deserialize.
·9 min read · #dsa#trees#practice
Bit Manipulation Basics: AND, OR, XOR, NOT, Shifts
A practical introduction to bit manipulation in Python — binary representation, the bitwise operators, two's complement, and the common operations to set, clear, toggle, and check individual bits.
·10 min read · #dsa#bit-manipulation#beginners
Bit Manipulation: Tricks and 6 Practice Problems
Six classic bit manipulation problems — Single Number, Number of 1 Bits, Power of Two, Counting Bits, Missing Number, Reverse Bits — plus the tricks that make them tick: n & (n-1), n & -n, and XOR cancellation.
·9 min read · #dsa#bit-manipulation#practice
Dynamic Programming: 8 Classic Problems with Solutions
Eight classic dynamic programming problems — Climbing Stairs, House Robber, Coin Change, LIS, Word Break, 0/1 Knapsack, Edit Distance, and LCS — each with Python solutions and DP tables.
·10 min read · #dsa#dynamic-programming#practice
Dynamic Programming: Memoization and Tabulation
An introduction to dynamic programming — overlapping subproblems, optimal substructure, top-down memoization, and bottom-up tabulation, with worked examples in Python.
·8 min read · #dsa#dynamic-programming#intermediate
Graph Traversals: BFS and DFS
A practical guide to BFS and DFS on graphs — recursive and iterative DFS, BFS with a deque, shortest paths on unweighted graphs, connected components, cycle detection, and five classic practice problems.
·11 min read · #dsa#graphs#intermediate
Graphs in DSA: Introduction and Representations
A practical introduction to graphs — directed vs undirected, weighted vs unweighted, cyclic vs acyclic, and the three main representations (adjacency list, adjacency matrix, edge list) with Python code.
·9 min read · #dsa#graphs#beginners
Greedy Algorithms: When Locally Best Wins Globally
An introduction to greedy algorithms — when the locally best choice gives a globally optimal answer, when it doesn't, the exchange argument, and six classic problems.
·8 min read · #dsa#greedy#intermediate
Hashing and Hash Maps in DSA
How hash functions, hash maps, and hash sets work — the intuition behind buckets and collisions, chaining vs open addressing, average and worst-case complexity, and the Python containers built on them.
·9 min read · #dsa#hashing#intermediate
Hashing: 8 Practice Problems with Solutions
Eight classic hash map problems with worked Python solutions — Two Sum, Group Anagrams, Subarray Sum Equals K, Longest Consecutive Sequence, Top K Frequent Elements, and more.
·10 min read · #dsa#hashing#practice
Linked List Operations: Insert, Delete, Reverse
The core operations every linked list problem builds on — inserting at head/tail/middle, deleting by value, reversing iteratively and recursively, finding the middle, and detecting a cycle.
·10 min read · #dsa#linked-lists#intermediate
Linked Lists in DSA: Introduction
A practical introduction to linked lists — what a node is, singly vs doubly linked, head and tail, how arrays and linked lists differ, and a clean Python implementation you can build on.
·9 min read · #dsa#linked-lists#beginners
Linked Lists: 8 Practice Problems with Solutions
Eight classic linked-list interview problems — reverse, detect cycle, merge sorted lists, remove Nth from end, cycle start, palindrome, add two numbers, and intersection — each with a worked Python solution.
·11 min read · #dsa#linked-lists#practice
Recursion Fundamentals: Base Case, Recursive Case, and the Call Stack
A practical introduction to recursion — the base case, the recursive case, the call stack, and how to think about problems that solve themselves through smaller versions of themselves.
·9 min read · #dsa#recursion#beginners
Binary Search: The Pattern That Powers a Hundred Problems
A practical guide to binary search — the classic template, off-by-one traps, Python's bisect module, and the binary-search-on-answer pattern, with six worked problems.
·9 min read · #dsa#searching#binary-search
The Sliding Window Technique
A practical guide to sliding window — fixed-size vs variable-size windows, expand/shrink invariants, and six classic problems with worked Python solutions.
·9 min read · #dsa#sliding-window#intermediate
Sorting Algorithms: Bubble, Insertion, Merge, Quick, Heap
A tour of the five sorting algorithms every programmer should know — their ideas, Big-O time and space, stability, and Python implementations, plus when to just use sort().
·8 min read · #dsa#sorting#intermediate
Stacks and Queues in DSA
A practical introduction to stacks and queues — LIFO vs FIFO, using a Python list as a stack, collections.deque as a queue, and the real-world problems each one solves cleanly.
·10 min read · #dsa#stacks#queues
Stacks & Queues: 8 Practice Problems with Solutions
Eight classic stack and queue interview problems with worked Python solutions — Valid Parentheses, Min Stack, Daily Temperatures, Sliding Window Maximum, and more.
·10 min read · #dsa#stacks#queues
Strings in DSA: Operations and Patterns
An introduction to strings for data structures and algorithms — immutability, indexing, slicing, common operations, ASCII versus Unicode, and the two-pointer and frequency-counter patterns you will use everywhere.
·8 min read · #dsa#strings#beginners
String Pattern Matching: Naive, KMP, and Rabin-Karp
A practical tour of substring search — the naive O(n·m) scan, the KMP algorithm with its LPS array, and the Rabin-Karp rolling hash. Worked examples, code, and intuition for when to use each.
·8 min read · #dsa#strings#intermediate
Strings: 8 Practice Problems with Solutions
Eight classic string problems with worked Python solutions — Valid Anagram, Group Anagrams, Longest Substring Without Repeating Characters, Longest Palindromic Substring, and more.
·9 min read · #dsa#strings#practice
The Two Pointers Technique: A Practical Guide
A practical guide to the two pointers technique — opposite-end and same-direction patterns, when to use each, and six classic interview problems with worked solutions.
·9 min read · #dsa#two-pointers#intermediate
What Is DSA? Data Structures and Algorithms Explained
A beginner-friendly introduction to data structures and algorithms — what they are, why they matter for interviews and real performance, and how to actually start learning DSA.
·9 min read · #dsa#beginners