Interview Prep·January 18, 2026·18 min read

20 Most Common Coding Interview Problems (With Python Solutions)

The most frequently asked coding interview problems at Google, Meta, Amazon, and Microsoft — with Python solutions, time complexity analysis, and interview tips.

coding interview problemstwo sum pythonleetcode pythongoogle interview questionsamazon interview questionscoding interview preppython interview problemsfaang interviewalgorithm problems pythondata structures interview

These are the 20 problems that show up most often in real interviews at Google, Meta, Amazon, Microsoft, and other top tech companies. Each one includes a Python solution, the key insight to recognize the pattern, and the time/space complexity.

If you only have two weeks to prepare, solve every problem on this list.

1. Two Sum

Frequency: Extremely high (asked by almost every company) Pattern: Hash map for O(1) lookups

def two_sum(nums: list[int], target: int) -> list[int]:
    seen = {}  # value -> index
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:

Interview Prep

How to Prepare for a Technical Coding Interview in 2026

15 min read

Interview Prep

Top 20 C++ Interview Questions (With Answers & Code)

20 min read

Interview Prep

Top 20 C# Interview Questions (With Answers & Code)

19 min read

Get new articles in your inbox

We write about Go, Python, interview prep, and software engineering careers. No spam — unsubscribe anytime.

Create a free account →

Practice what you just read

uByte has interactive coding tutorials, curated interview problems, and timed certification exams — all in your browser.

Try Interview Prep →View Certifications

def is_valid(s: str) -> bool:
    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
 
print(is_valid("()[]{}"))  # True
print(is_valid("(]"))      # False

def max_profit(prices: list[int]) -> int:
    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
 
print(max_profit([7, 1, 5, 3, 6, 4]))  # 5

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
 
def merge_two_lists(l1: ListNode, l2: ListNode) -> ListNode:
    dummy = ListNode(0)
    current = dummy
 
    while l1 and l2:
        if l1.val <= l2.val:
            current.next = l1
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next
 
    current.next = l1 or l2
    return dummy.next

def max_sub_array(nums: list[int]) -> int:
    max_sum = 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
 
print(max_sub_array([-2, 1, -3, 4, -1, 2, 1, -5, 4]))  # 6

def binary_search(nums: list[int], target: int) -> int:
    left, right = 0, len(nums) - 1
 
    while left <= right:
        mid = left + (right - left) // 2  # avoids overflow
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
 
    return -1
 
print(binary_search([1, 3, 5, 7, 9, 11], 7))  # 3

def num_islands(grid: list[list[str]]) -> int:
    if not grid:
        return 0
 
    rows, cols = len(grid), len(grid[0])
    count = 0
 
    def dfs(r: int, c: int) -> None:
        if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] != "1":
            return
        grid[r][c] = "0"  # mark visited
        dfs(r + 1, c)
        dfs(r - 1, c)
        dfs(r, c + 1)
        dfs(r, c - 1)
 
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == "1":
                dfs(r, c)
                count += 1
 
    return count

def climb_stairs(n: int) -> int:
    if n <= 2:
        return n
    prev, curr = 1, 2
    for _ in range(3, n + 1):
        prev, curr = curr, prev + curr
    return curr
 
print(climb_stairs(5))  # 8

def reverse_list(head: ListNode) -> ListNode:
    prev = None
    current = head
 
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
 
    return prev

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
 
def is_valid_bst(root: TreeNode) -> bool:
    def validate(node, min_val, max_val):
        if not node:
            return True
        if node.val <= min_val or node.val >= max_val:
            return False
        return (
            validate(node.left, min_val, node.val) and
            validate(node.right, node.val, max_val)
        )
 
    return validate(root, float("-inf"), float("inf"))

def coin_change(coins: list[int], amount: int) -> int:
    dp = [float("inf")] * (amount + 1)
    dp[0] = 0
 
    for coin in coins:
        for i in range(coin, amount + 1):
            dp[i] = min(dp[i], dp[i - coin] + 1)
 
    return dp[amount] if dp[amount] != float("inf") else -1
 
print(coin_change([1, 5, 11], 15))  # 3 (5+5+5)

def longest_common_subsequence(text1: str, text2: str) -> int:
    m, n = len(text1), len(text2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
 
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if text1[i - 1] == text2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
 
    return dp[m][n]
 
print(longest_common_subsequence("abcde", "ace"))  # 3

def exist(board: list[list[str]], word: str) -> bool:
    rows, cols = len(board), len(board[0])
 
    def dfs(r, c, idx):
        if idx == len(word):
            return True
        if (r < 0 or r >= rows or c < 0 or c >= cols
                or board[r][c] != word[idx]):
            return False
 
        temp = board[r][c]
        board[r][c] = "#"  # mark visited
 
        found = (dfs(r + 1, c, idx + 1) or
                 dfs(r - 1, c, idx + 1) or
                 dfs(r, c + 1, idx + 1) or
                 dfs(r, c - 1, idx + 1))
 
        board[r][c] = temp  # restore
        return found
 
    for r in range(rows):
        for c in range(cols):
            if dfs(r, c, 0):
                return True
 
    return False

def merge(intervals: list[list[int]]) -> list[list[int]]:
    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
 
print(merge([[1,3],[2,6],[8,10],[15,18]]))
# [[1, 6], [8, 10], [15, 18]]

import heapq
from collections import Counter
 
def top_k_frequent(nums: list[int], k: int) -> list[int]:
    count = Counter(nums)
    return heapq.nlargest(k, count.keys(), key=count.get)
 
print(top_k_frequent([1, 1, 1, 2, 2, 3], 2))  # [1, 2]

def top_k_frequent_bucket(nums: list[int], k: int) -> list[int]:
    count = Counter(nums)
    buckets = [[] for _ in range(len(nums) + 1)]
 
    for num, freq in count.items():
        buckets[freq].append(num)
 
    result = []
    for bucket in reversed(buckets):
        result.extend(bucket)
        if len(result) >= k:
            return result[:k]
 
    return result

def length_of_longest_substring(s: str) -> int:
    char_set = set()
    left = max_length = 0
 
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_length = max(max_length, right - left + 1)
 
    return max_length
 
print(length_of_longest_substring("abcabcbb"))  # 3 ("abc")

def can_finish(num_courses: int, prerequisites: list[list[int]]) -> bool:
    graph = [[] for _ in range(num_courses)]
    for a, b in prerequisites:
        graph[b].append(a)
 
    # 0 = unvisited, 1 = visiting, 2 = visited
    state = [0] * num_courses
 
    def dfs(node: int) -> bool:
        if state[node] == 1:  # cycle
            return False
        if state[node] == 2:  # already safe
            return True
 
        state[node] = 1
        for neighbor in graph[node]:
            if not dfs(neighbor):
                return False
        state[node] = 2
        return True
 
    return all(dfs(i) for i in range(num_courses))

from collections import OrderedDict
 
class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = OrderedDict()
 
    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]
 
    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

def trap(height: list[int]) -> int:
    left, right = 0, len(height) - 1
    left_max = right_max = water = 0
 
    while left < right:
        if height[left] < height[right]:
            if height[left] >= left_max:
                left_max = height[left]
            else:
                water += left_max - height[left]
            left += 1
        else:
            if height[right] >= right_max:
                right_max = height[right]
            else:
                water += right_max - height[right]
            right -= 1
 
    return water
 
print(trap([0,1,0,2,1,0,1,3,2,1,2,1]))  # 6

from collections import deque
 
class Codec:
    def serialize(self, root: TreeNode) -> str:
        if not root:
            return ""
        result = []
        queue = deque([root])
 
        while queue:
            node = queue.popleft()
            if node:
                result.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else:
                result.append("null")
 
        return ",".join(result)
 
    def deserialize(self, data: str) -> TreeNode:
        if not data:
            return None
        values = iter(data.split(","))
        root = TreeNode(int(next(values)))
        queue = deque([root])
 
        for val in values:
            node = queue.popleft()
            left_val = next(values, None)
 
            if val != "null":
                node.left = TreeNode(int(val))
                queue.append(node.left)
            if left_val and left_val != "null":
                node.right = TreeNode(int(left_val))
                queue.append(node.right)
 
        return root

20 Most Common Coding Interview Problems (With Python Solutions)

1. Two Sum

Related articles

Get new articles in your inbox

Practice what you just read

2. Valid Parentheses

3. Best Time to Buy and Sell Stock

4. Merge Two Sorted Lists

5. Maximum Subarray (Kadane's Algorithm)

6. Binary Search

7. Number of Islands

8. Climbing Stairs

9. Reverse a Linked List

10. Validate Binary Search Tree

11. Coin Change

12. Longest Common Subsequence

13. Word Search

14. Merge Intervals

15. Top K Frequent Elements

16. Longest Substring Without Repeating Characters

17. Course Schedule (Cycle Detection)

18. LRU Cache

19. Trapping Rain Water

20. Serialize and Deserialize Binary Tree

Interview Strategy Tips