Python Coding Questions With Solutions 2026: 25 Solved

Last Updated: June 2026 | Level: Freshers to Mid-Level | Read Time: ~17 min

Coding rounds are where Python interviews are won or lost. Candidates report a consistent set of screening-level problems: string manipulation, frequency counting, two-sum, and recursion classics. This guide gives 25 problems with full working solutions, complexity analysis, and the edge cases interviewers probe. Every solution is written in idiomatic Python and traced for correctness; confirm any standard-library detail on the official docs.

Pair this with Python Interview Questions 2026 and Python Output Prediction Questions 2026.

---

Table of Contents

1. Strings (Q1 to Q8)
2. Arrays and Numbers (Q9 to Q17)
3. Dicts and Sets (Q18 to Q21)
4. Recursion (Q22 to Q25)
5. Complexity Summary
6. Frequently Asked Questions

---

Strings

Q1. Reverse a string. Easy

def reverse(s):
    return s[::-1]
# manual:
def reverse_manual(s):
    chars = list(s)
    i, j = 0, len(chars) - 1
    while i < j:
        chars[i], chars[j] = chars[j], chars[i]
        i += 1; j -= 1
    return "".join(chars)

Complexity: O(n) time, O(n) space. Show the slice first, then the two-pointer version if asked to avoid built-ins.

---

Q2. Check if a string is a palindrome. Easy

def is_palindrome(s):
    s = "".join(c.lower() for c in s if c.isalnum())
    return s == s[::-1]

Edge cases: empty string is a palindrome; the cleanup line handles case and punctuation, a common follow-up.

---

Q3. Check if two strings are anagrams. Medium

from collections import Counter
def is_anagram(a, b):
    return Counter(a) == Counter(b)

Complexity: O(n). Mention the O(n log n) sort alternative sorted(a) == sorted(b).

---

Q4. Count vowels in a string. Easy

def count_vowels(s):
    return sum(1 for c in s.lower() if c in "aeiou")

Complexity: O(n).

---

Q5. Find the first non-repeating character. Medium

from collections import Counter
def first_unique(s):
    counts = Counter(s)
    for c in s:
        if counts[c] == 1:
            return c
    return None

Why two passes: the first builds counts, the second preserves original order to find the first unique.

---

Q6. Find the most frequent word. Medium

from collections import Counter
def most_frequent(text):
    words = text.lower().split()
    return Counter(words).most_common(1)[0][0]

Edge case: empty text returns no result, guard before indexing.

---

Q7. Check if a string has all unique characters. Easy

def all_unique(s):
    return len(set(s)) == len(s)

Complexity: O(n). The set drops duplicates so a length change reveals them.

---

Q8. Capitalise the first letter of each word. Easy

def title_case(s):
    return " ".join(w.capitalize() for w in s.split())

Note: str.title() exists but mishandles apostrophes, hence the manual version.

---

Arrays and Numbers

Q9. Two-sum: indices of two numbers adding to target. Medium

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

Complexity: O(n) with a dict for O(1) lookup, versus the naive O(n squared) double loop. This trade-off is the whole point of the question.

---

Q10. Find the maximum subarray sum (Kadane). Medium

def max_subarray(nums):
    best = cur = nums[0]
    for n in nums[1:]:
        cur = max(n, cur + n)
        best = max(best, cur)
    return best

Complexity: O(n). Handles all-negative arrays correctly by starting from the first element.

---

Q11. Remove duplicates preserving order. Easy

def dedupe(lst):
    return list(dict.fromkeys(lst))

Why: dict.fromkeys keeps first-seen order, unlike a plain set.

---

Q12. Find the second largest number. Medium

def second_largest(nums):
    first = second = float("-inf")
    for n in nums:
        if n > first:
            first, second = n, first
        elif first > n > second:
            second = n
    return second if second != float("-inf") else None

Edge case: fewer than two distinct values returns None.

---

Q13. Move all zeros to the end. Medium

def move_zeros(nums):
    pos = 0
    for n in nums:
        if n != 0:
            nums[pos] = n; pos += 1
    for i in range(pos, len(nums)):
        nums[i] = 0
    return nums

Complexity: O(n) in place.

---

Q14. Rotate a list by k positions. Medium

def rotate(nums, k):
    k %= len(nums)
    return nums[-k:] + nums[:-k]

Edge case: k %= len handles k larger than the list length.

---

Q15. Check if a number is prime. Easy

def is_prime(n):
    if n < 2: return False
    i = 2
    while i * i <= n:
        if n % i == 0: return False
        i += 1
    return True

Complexity: O(square root of n) by checking up to the square root only.

---

Q16. FizzBuzz. Easy

def fizzbuzz(n):
    for i in range(1, n + 1):
        out = ("Fizz" if i % 3 == 0 else "") + ("Buzz" if i % 5 == 0 else "")
        print(out or i)

Why this form: concatenation handles the 15 case automatically, cleaner than nested ifs.

---

Q17. Find missing number in 1..n. Medium

def missing(nums, n):
    return n * (n + 1) // 2 - sum(nums)

Complexity: O(n), O(1) extra space using the arithmetic-series formula.

---

Dicts and Sets

Q18. Group anagrams together. Medium

from collections import defaultdict
def group_anagrams(words):
    groups = defaultdict(list)
    for w in words:
        groups["".join(sorted(w))].append(w)
    return list(groups.values())

Key idea: the sorted-letter signature is the same for anagrams.

---

Q19. Find intersection of two lists. Easy

def intersection(a, b):
    return list(set(a) & set(b))

Complexity: O(n + m) using set intersection.

---

Q20. Count frequency of elements. Easy

from collections import Counter
def frequency(lst):
    return dict(Counter(lst))

---

Q21. Find pairs with a given difference. Medium

def pairs_with_diff(nums, k):
    s = set(nums)
    return [(n, n + k) for n in s if n + k in s]

Complexity: O(n) with a set for membership.

---

Recursion

Q22. Factorial. Easy

def factorial(n):
    return 1 if n <= 1 else n * factorial(n - 1)

Edge case: define 0! as 1. Mention recursion depth limits for very large n.

---

Q23. Fibonacci with memoization. Medium

from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

Complexity: O(n) with memoization versus O(2 to the n) naive recursion. This contrast is the point.

---

Q24. Sum of digits recursively. Easy

def digit_sum(n):
    return n if n < 10 else n % 10 + digit_sum(n // 10)

---

Q25. Generate all subsets (power set). Hard

def subsets(nums):
    result = [[]]
    for n in nums:
        result += [cur + [n] for cur in result]
    return result

Complexity: O(n times 2 to the n) since there are 2 to the n subsets. The iterative doubling builds them cleanly.

---

Complexity Summary

Problem type	Best approach	Complexity
Two-sum	hash map	O(n)
Max subarray	Kadane	O(n)
Anagram check	Counter	O(n)
Prime check	sqrt loop	O(sqrt n)
Fibonacci	memoization	O(n)
Power set	iterative doubling	O(n 2^n)
Dedupe ordered	dict.fromkeys	O(n)

---

Frequently Asked Questions

What coding questions are most common in Python interviews in 2026?

Candidates report string reversal and palindrome checks, anagram detection, frequency counting, the two-sum problem, and FizzBuzz as the most repeated screening-level Python coding questions.

Should I solve coding questions the Pythonic way or the manual way?

Know both. Show the Pythonic one-liner to prove you know the standard library, then be ready to implement the underlying algorithm manually if the interviewer asks you to avoid built-ins.

Do interviewers ask for time complexity in Python coding rounds?

Yes. State the big-O of your solution and the trade-offs, for example using a set for O(1) lookup to turn an O(n squared) search into O(n).

How do I handle edge cases in a coding interview?

Call them out before coding: empty input, single element, duplicates, negatives, and very large inputs. Mentioning them unprompted signals maturity even when the happy path is simple.

Is recursion or iteration preferred in interviews?

Whichever is clearer for the problem, but always note recursion depth limits in Python and offer an iterative or memoized version when naive recursion would be exponential or hit the stack limit.

---

Related Articles

• Python Interview Questions 2026, the master set
• Python Output Prediction Questions 2026, tricky snippets
• Python Data Structures Interview Questions 2026, choosing the right structure
• Data Structures Interview Questions 2026, language-agnostic DSA

---

Confirm any standard-library detail on the official Python documentation before your interview. This guide reflects candidate-reported patterns and public preparation resources as of June 2026.