DEV Community: DSAwithSM

5 LeetCode Problems: Word Search, Implement Trie (Prefix Tree), Palindromic Substrings, Decode Ways | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 09:32:55 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟡 Word Search (LeetCode #79) · Medium · Backtracking
🟡 Implement Trie (Prefix Tree) (LeetCode #208) · Medium · Trie
🟡 Palindromic Substrings (LeetCode #647) · Medium · Dynamic Programming
🟡 Decode Ways (LeetCode #91) · Medium · Dynamic Programming

🟡 Word Search

Difficulty: Medium | Topic: Backtracking | LeetCode #79

Problem

Given an m x n grid of characters board and a string word, return true if word exists in the grid. The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

Solution

def exist(board, word):
    rows, cols = len(board), len(board[0])
    path = set()

    def dfs(r, c, i):
        if i == len(word):
            return True
        if (r < 0 or c < 0 or r >= rows or c >= cols
                or word[i] != board[r][c] or (r, c) in path):
            return False
        path.add((r, c))
        res = (dfs(r+1, c, i+1) or dfs(r-1, c, i+1) or
               dfs(r, c+1, i+1) or dfs(r, c-1, i+1))
        path.remove((r, c))
        return res

    for r in range(rows):
        for c in range(cols):
            if dfs(r, c, 0):
                return True
    return False

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Implement Trie (Prefix Tree)

Difficulty: Medium | Topic: Trie | LeetCode #208

Problem

A trie (pronounced as 'try') or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. Implement the Trie class with insert(word), search(word) that returns true if word is in the trie, and startsWith(prefix) that returns true if there is any word in the trie that starts with the given prefix.

Solution

class Trie:
    def __init__(self):
        self.children = {}
        self.is_end = False

    def insert(self, word):
        node = self
        for ch in word:
            if ch not in node.children:
                node.children[ch] = Trie()
            node = node.children[ch]
        node.is_end = True

    def search(self, word):
        node = self
        for ch in word:
            if ch not in node.children:
                return False
            node = node.children[ch]
        return node.is_end

    def starts_with(self, prefix):
        node = self
        for ch in prefix:
            if ch not in node.children:
                return False
            node = node.children[ch]
        return True

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Palindromic Substrings

Difficulty: Medium | Topic: Dynamic Programming | LeetCode #647

Problem

Given a string s, return the number of palindromic substrings in it. A string is a palindrome when it reads the same backward as forward. A substring is a contiguous sequence of characters within the string.

Solution

def count_substrings(s):
    count = 0

    def expand(l, r):
        nonlocal count
        while l >= 0 and r < len(s) and s[l] == s[r]:
            count += 1
            l -= 1
            r += 1

    for i in range(len(s)):
        expand(i, i)      # odd length
        expand(i, i + 1)  # even length
    return count

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Decode Ways

Difficulty: Medium | Topic: Dynamic Programming | LeetCode #91

Problem

A message containing letters from A-Z can be encoded into numbers using 'A' -> '1', 'B' -> '2', ..., 'Z' -> '26'. Given a string s containing only digits, return the number of ways to decode it. If there are no valid ways to decode the message, return 0.

Solution

def num_decodings(s):
    dp = {len(s): 1}

    for i in range(len(s) - 1, -1, -1):
        if s[i] == '0':
            dp[i] = 0
        else:
            dp[i] = dp[i + 1]
        if (i + 1 < len(s) and
                (s[i] == '1' or s[i] == '2' and s[i + 1] in '0123456')):
            dp[i] += dp.get(i + 2, 1)
    return dp[0]

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🔔 Follow Along

New problems every 2 days — subscribe to stay consistent with your DSA prep!

📺 YouTube — DSA Decoded
💻 GitHub — all solutions

Drop a comment with your approach — always curious to see other solutions!

5 LeetCode Problems #236, #198, #322, #300, #39 Explained | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 09:32:49 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟡 Lowest Common Ancestor of a Binary Tree (LeetCode #236) · Medium · Trees
🟡 House Robber (LeetCode #198) · Medium · Dynamic Programming
🟡 Coin Change (LeetCode #322) · Medium · Dynamic Programming
🟡 Longest Increasing Subsequence (LeetCode #300) · Medium · Dynamic Programming
🟡 Combination Sum (LeetCode #39) · Medium · Backtracking

🟡 Lowest Common Ancestor of a Binary Tree

Difficulty: Medium | Topic: Trees | LeetCode #236

Problem

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes p and q. The LCA is the lowest node in the tree that has both p and q as descendants (a node can be a descendant of itself).

Solution

def lowest_common_ancestor(root, p, q):
    if not root or root == p or root == q:
        return root
    left  = lowest_common_ancestor(root.left,  p, q)
    right = lowest_common_ancestor(root.right, p, q)
    if left and right:
        return root
    return left if left else right

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 House Robber

Difficulty: Medium | Topic: Dynamic Programming | LeetCode #198

Problem

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. You cannot rob two adjacent houses because the security system will alert the police. Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.

Solution

def rob(nums):
    rob1, rob2 = 0, 0
    for n in nums:
        new_rob = max(rob1 + n, rob2)
        rob1 = rob2
        rob2 = new_rob
    return rob2

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Coin Change

Difficulty: Medium | Topic: Dynamic Programming | LeetCode #322

Problem

You are given an integer array coins representing coins of various denominations and an integer amount representing a total amount of money. Return the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1. You may assume that you have an infinite number of each kind of coin.

Solution

def coin_change(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for a in range(1, amount + 1):
        for c in coins:
            if a - c >= 0:
                dp[a] = min(dp[a], 1 + dp[a - c])
    return dp[amount] if dp[amount] != float('inf') else -1

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Longest Increasing Subsequence

Difficulty: Medium | Topic: Dynamic Programming | LeetCode #300

Problem

Given an integer array nums, return the length of the longest strictly increasing subsequence. A subsequence is derived from the array by deleting some or no elements without changing the order of the remaining elements.

Solution

def length_of_lis(nums):
    dp = [1] * len(nums)
    for i in range(1, len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Combination Sum

Difficulty: Medium | Topic: Backtracking | LeetCode #39

Problem

Given an array of distinct integers candidates and a target integer target, return a list of all unique combinations of candidates where the chosen numbers sum to target. You may return the combinations in any order. The same number may be chosen from candidates an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.

Solution

def combination_sum(candidates, target):
    result = []

    def backtrack(start, current, total):
        if total == target:
            result.append(list(current))
            return
        if total > target:
            return
        for i in range(start, len(candidates)):
            current.append(candidates[i])
            backtrack(i, current, total + candidates[i])
            current.pop()

    backtrack(0, [], 0)
    return result

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🔔 Follow Along

New problems every 2 days — subscribe to stay consistent with your DSA prep!

📺 YouTube — DSA Decoded
💻 GitHub — all solutions

Drop a comment with your approach — always curious to see other solutions!

5 LeetCode Problems #207, #572, #994, #112, #235 Explained | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 09:32:43 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟡 Course Schedule (LeetCode #207) · Medium · Graphs
🟢 Subtree of Another Tree (LeetCode #572) · Easy · Trees
🟡 Rotting Oranges (LeetCode #994) · Medium · Graphs
🟢 Path Sum (LeetCode #112) · Easy · Trees
🟢 Lowest Common Ancestor of a Binary Search Tree (LeetCode #235) · Easy · Trees

🟡 Course Schedule

Difficulty: Medium | Topic: Graphs | LeetCode #207

Problem

There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai. Return true if you can finish all courses otherwise return false.

Solution

from collections import defaultdict

def can_finish(numCourses, prerequisites):
    graph = defaultdict(list)
    for a, b in prerequisites:
        graph[b].append(a)

    # 0=unvisited 1=visiting 2=done
    state = [0] * numCourses

    def dfs(node):
        if state[node] == 1: return False
        if state[node] == 2: return True
        state[node] = 1
        for nb in graph[node]:
            if not dfs(nb): return False
        state[node] = 2
        return True

    return all(dfs(i) for i in range(numCourses))

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟢 Subtree of Another Tree

Difficulty: Easy | Topic: Trees | LeetCode #572

Problem

Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.

Solution

def is_subtree(root, subRoot):
    def is_same(p, q):
        if not p and not q: return True
        if not p or not q or p.val != q.val: return False
        return is_same(p.left, q.left) and is_same(p.right, q.right)

    if not root: return False
    if is_same(root, subRoot): return True
    return is_subtree(root.left, subRoot) or is_subtree(root.right, subRoot)

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Rotting Oranges

Difficulty: Medium | Topic: Graphs | LeetCode #994

Problem

You are given an m x n grid where each cell can have value 0 (empty), 1 (fresh orange), or 2 (rotten orange). Every minute, any fresh orange that is 4-directionally adjacent to a rotten orange becomes rotten. Return the minimum number of minutes that must elapse until no cell has a fresh orange. If this is impossible, return -1.

Solution

from collections import deque

def oranges_rotting(grid):
    rows, cols = len(grid), len(grid[0])
    fresh = 0
    queue = deque()
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == 2: queue.append((r, c, 0))
            elif grid[r][c] == 1: fresh += 1
    minutes = 0
    while queue:
        r, c, t = queue.popleft()
        for dr, dc in [(1,0),(-1,0),(0,1),(0,-1)]:
            nr, nc = r+dr, c+dc
            if 0<=nr<rows and 0<=nc<cols and grid[nr][nc]==1:
                grid[nr][nc] = 2
                fresh -= 1
                minutes = t + 1
                queue.append((nr, nc, t+1))
    return minutes if fresh == 0 else -1

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟢 Path Sum

Difficulty: Easy | Topic: Trees | LeetCode #112

Problem

Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum. A leaf is a node with no children.

Solution

def has_path_sum(root, targetSum):
    if not root:
        return False
    if not root.left and not root.right:
        return root.val == targetSum
    return (has_path_sum(root.left, targetSum - root.val) or
            has_path_sum(root.right, targetSum - root.val))

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟢 Lowest Common Ancestor of a Binary Search Tree

Difficulty: Easy | Topic: Trees | LeetCode #235

Problem

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes p and q in the BST. The LCA is defined as the lowest node that has both p and q as descendants (where a node can be a descendant of itself).

Solution

def lowest_common_ancestor(root, p, q):
    if p.val < root.val and q.val < root.val:
        return lowest_common_ancestor(root.left, p, q)
    if p.val > root.val and q.val > root.val:
        return lowest_common_ancestor(root.right, p, q)
    return root

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🔔 Follow Along

New problems every 2 days — subscribe to stay consistent with your DSA prep!

📺 YouTube — DSA Decoded
💻 GitHub — all solutions

Drop a comment with your approach — always curious to see other solutions!

5 LeetCode Problems #543, #100, #102, #200, #133 Explained | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 09:32:37 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟢 Diameter of Binary Tree (LeetCode #543) · Easy · Trees
🟢 Same Tree (LeetCode #100) · Easy · Trees
🟡 Binary Tree Level Order Traversal (LeetCode #102) · Medium · Trees
🟡 Number of Islands (LeetCode #200) · Medium · Graphs
🟡 Clone Graph (LeetCode #133) · Medium · Graphs

🟢 Diameter of Binary Tree

Difficulty: Easy | Topic: Trees | LeetCode #543

Problem

Given the root of a binary tree, return the length of the diameter of the tree. The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.

Solution

def diameter_of_binary_tree(root):
    result = [0]

    def depth(node):
        if not node:
            return 0
        left = depth(node.left)
        right = depth(node.right)
        result[0] = max(result[0], left + right)
        return 1 + max(left, right)

    depth(root)
    return result[0]

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟢 Same Tree

Difficulty: Easy | Topic: Trees | LeetCode #100

Problem

Given the roots of two binary trees p and q, write a function to check if they are the same or not. Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

Solution

def is_same_tree(p, q):
    if not p and not q:
        return True
    if not p or not q or p.val != q.val:
        return False
    return is_same_tree(p.left, q.left) and is_same_tree(p.right, q.right)

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Binary Tree Level Order Traversal

Difficulty: Medium | Topic: Trees | LeetCode #102

Problem

Given the root of a binary tree, return the level order traversal of its nodes' values (i.e., from left to right, level by level).

Solution

from collections import deque

def level_order(root):
    if not root:
        return []
    result, queue = [], deque([root])
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left:  queue.append(node.left)
            if node.right: queue.append(node.right)
        result.append(level)
    return result

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Number of Islands

Difficulty: Medium | Topic: Graphs | LeetCode #200

Problem

Given an m x n 2D binary grid which represents a map of '1's (land) and '0's (water), return the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically.

Solution

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

    def dfs(r, c):
        if r < 0 or r >= len(grid) or c < 0 or c >= len(grid[0]) or grid[r][c] != '1':
            return
        grid[r][c] = '0'
        dfs(r+1, c); dfs(r-1, c); dfs(r, c+1); dfs(r, c-1)

    for r in range(len(grid)):
        for c in range(len(grid[0])):
            if grid[r][c] == '1':
                dfs(r, c)
                count += 1
    return count

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟡 Clone Graph

Difficulty: Medium | Topic: Graphs | LeetCode #133

Problem

Given a reference of a node in a connected undirected graph, return a deep copy (clone) of the graph. Each node in the graph contains a value (int) and a list of its neighbors.

Solution

class Node:
    def __init__(self, val=0, neighbors=None):
        self.val = val
        self.neighbors = neighbors or []

def clone_graph(node):
    if not node:
        return None
    clones = {}

    def dfs(n):
        if n in clones:
            return clones[n]
        clone = Node(n.val)
        clones[n] = clone
        for nb in n.neighbors:
            clone.neighbors.append(dfs(nb))
        return clone

    return dfs(node)

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🔔 Follow Along

New problems every 2 days — subscribe to stay consistent with your DSA prep!

📺 YouTube — DSA Decoded
💻 GitHub — all solutions

Drop a comment with your approach — always curious to see other solutions!

5 LeetCode Problems #215, #455, #347, #226, #104 Explained | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 09:32:31 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟡 Kth Largest Element in an Array (LeetCode #215) · Medium · Heap
🟢 Assign Cookies (LeetCode #455) · Easy · Greedy
🟡 Top K Frequent Elements (LeetCode #347) · Medium · Heap
🟢 Invert Binary Tree (LeetCode #226) · Easy · Trees
🟢 Maximum Depth of Binary Tree (LeetCode #104) · Easy · Trees

🟡 Kth Largest Element in an Array

Difficulty: Medium | Topic: Heap | LeetCode #215

Problem

Given an integer array nums and an integer k, return the kth largest element in the array. Note that it is the kth largest element in the sorted order, not the kth distinct element. Can you solve it without sorting?

Solution

import heapq

def find_kth_largest(nums, k):
    min_heap = []
    for num in nums:
        heapq.heappush(min_heap, num)
        if len(min_heap) > k:
            heapq.heappop(min_heap)
    return min_heap[0]

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟢 Assign Cookies

Difficulty: Easy | Topic: Greedy | LeetCode #455

Problem

Assume you are an awesome parent and want to give your children some cookies. Each child i has a greed factor g[i], which is the minimum size of a cookie that the child will be content with. Each cookie j has a size s[j]. If s[j] >= g[i], we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.

Solution

def find_content_children(g, s):
    g.sort()
    s.sort()
    child = cookie = 0
    while child < len(g) and cookie < len(s):
        if s[cookie] >= g[child]:
            child += 1
        cookie += 1
    return child

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟡 Top K Frequent Elements

Difficulty: Medium | Topic: Heap | LeetCode #347

Problem

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

Solution

import heapq
from collections import Counter

def top_k_frequent(nums, k):
    count = Counter(nums)
    return heapq.nlargest(k, count.keys(), key=count.get)

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟢 Invert Binary Tree

Difficulty: Easy | Topic: Trees | LeetCode #226

Problem

Given the root of a binary tree, invert the tree, and return its root. Inverting means swapping the left and right children of every node in the tree.

Solution

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def invert_tree(root):
    if not root:
        return None
    root.left, root.right = invert_tree(root.right), invert_tree(root.left)
    return root

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🟢 Maximum Depth of Binary Tree

Difficulty: Easy | Topic: Trees | LeetCode #104

Problem

Given the root of a binary tree, return its maximum depth. A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Solution

def max_depth(root):
    if not root:
        return 0
    return 1 + max(max_depth(root.left), max_depth(root.right))

🔗 Solve on LeetCode · 📺 Watch video explanation · 💻 Full solution + tests on GitHub

🔔 Follow Along

New problems every 2 days — subscribe to stay consistent with your DSA prep!

📺 YouTube — DSA Decoded
💻 GitHub — all solutions

Drop a comment with your approach — always curious to see other solutions!

5 LeetCode Problems #206, #78, #33, #875, #56 Explained | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 09:32:11 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟢 Reverse Linked List (LeetCode #206) · Easy · Recursion
🟡 Subsets (LeetCode #78) · Medium · Backtracking
🟡 Search in Rotated Sorted Array (LeetCode #33) · Medium · Binary Search
🟡 Koko Eating Bananas (LeetCode #875) · Medium · Binary Search
🟡 Merge Intervals (LeetCode #56) · Medium · Intervals

🟢 Reverse Linked List

Difficulty: Easy | Topic: Recursion | LeetCode #206

Problem

Given the head of a singly linked list, reverse the list, and return the reversed list. Solve it both iteratively and recursively.

Solution

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

def reverse_list(head):
    if not head or not head.next:
        return head
    new_head = reverse_list(head.next)
    head.next.next = head
    head.next = None
    return new_head

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟡 Subsets

Difficulty: Medium | Topic: Backtracking | LeetCode #78

Problem

Given an integer array nums of unique elements, return all possible subsets (the power set). The solution set must not contain duplicate subsets. Return the solution in any order.

Solution

def subsets(nums):
    result = []

    def backtrack(start, current):
        result.append(current[:])
        for i in range(start, len(nums)):
            current.append(nums[i])
            backtrack(i + 1, current)
            current.pop()

    backtrack(0, [])
    return result

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟡 Search in Rotated Sorted Array

Difficulty: Medium | Topic: Binary Search | LeetCode #33

Problem

There is an integer array nums sorted in ascending order (with distinct values). Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k. Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums. You must write an algorithm with O(log n) runtime complexity.

Solution

def search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        if nums[left] <= nums[mid]:
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        else:
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
    return -1

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟡 Koko Eating Bananas

Difficulty: Medium | Topic: Binary Search | LeetCode #875

Problem

Koko loves to eat bananas. There are n piles of bananas, the i-th pile has piles[i] bananas. The guards have gone and will come back in h hours. Koko can decide her bananas-per-hour eating speed of k. Each hour, she chooses some pile of bananas and eats k bananas from that pile. She can finish the pile in one sitting if it's smaller. Return the minimum integer k such that she can eat all the bananas within h hours.

Solution

import math

def min_eating_speed(piles, h):
    left, right = 1, max(piles)
    result = right
    while left <= right:
        k = (left + right) // 2
        hours = sum(math.ceil(p / k) for p in piles)
        if hours <= h:
            result = k
            right = k - 1
        else:
            left = k + 1
    return result

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟡 Merge Intervals

Difficulty: Medium | Topic: Intervals | LeetCode #56

Problem

Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.

Solution

def merge(intervals):
    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]
    for start, end in intervals[1:]:
        if start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🔔 Follow Along

New problems every 2 days — subscribe to stay consistent with your DSA prep!

📺 YouTube — DSA Decoded
💻 GitHub — all solutions

Drop a comment with your approach — always curious to see other solutions!

5 LeetCode Problems #1, #121, #20, #53, #70 Explained | DSA Decoded

DSAwithSM — Tue, 27 Oct 2026 07:36:52 +0000

🧠 5 LeetCode Problems Explained with Code + Video

Part of the DSA Decoded series — step-by-step Python solutions with video walkthroughs.

Problems covered in this post:

🟢 Two Sum (LeetCode #1) · Easy · Arrays
🟢 Best Time to Buy and Sell Stock (LeetCode #121) · Easy · Arrays
🟢 Valid Parentheses (LeetCode #20) · Easy · Stack
🟡 Maximum Subarray (LeetCode #53) · Medium · Dynamic Programming
🟢 Climbing Stairs (LeetCode #70) · Easy · Dynamic Programming

🟢 Two Sum

Difficulty: Easy | Topic: Arrays | LeetCode #1

Problem

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not use the same element twice.

Solution

def two_sum(nums, target):
    seen = {}
    for i, n in enumerate(nums):
        comp = target - n
        if comp in seen:
            return [seen[comp], i]
        seen[n] = i

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟢 Best Time to Buy and Sell Stock

Difficulty: Easy | Topic: Arrays | LeetCode #121

Problem

You are given an array prices where prices[i] is the price of a given stock on the i-th day. You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock. Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.

Solution

def max_profit(prices):
    min_price = float('inf')
    max_profit = 0
    for price in prices:
        if price < min_price:
            min_price = price
        elif price - min_price > max_profit:
            max_profit = price - min_price
    return max_profit

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟢 Valid Parentheses

Difficulty: Easy | Topic: Stack | LeetCode #20

Problem

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. An input string is valid if: open brackets must be closed by the same type of brackets, and open brackets must be closed in the correct order.

Solution

def is_valid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            top = stack.pop() if stack else '#'
            if mapping[char] != top:
                return False
        else:
            stack.append(char)
    return not stack

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟡 Maximum Subarray

Difficulty: Medium | Topic: Dynamic Programming | LeetCode #53

Problem

Given an integer array nums, find the subarray with the largest sum, and return its sum. A subarray is a contiguous non-empty sequence of elements within an array.

Solution

def max_subarray(nums):
    max_sum = nums[0]
    current_sum = nums[0]
    for num in nums[1:]:
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)
    return max_sum

🔗 Solve on LeetCode · 💻 Full solution + tests on GitHub

🟢 Climbing Stairs

Difficulty: Easy | Topic: Dynamic Programming | LeetCode #70

Problem

You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Solution

def climb_stairs(n):
    if n <= 2:
        return n
    a, b = 1, 2
    for _ in range(3, n + 1):
        a, b = b, a + b
    return b