Coding Fundamentals and Problem Solving Questions

Focuses on algorithmic thinking, data structures, and the process of solving coding problems under time constraints. Topics include core data structures such as arrays, linked lists, hash tables, trees, and graphs, common algorithms for searching and sorting, basics of dynamic programming and graph traversal, complexity analysis for time and space, and standard coding patterns. Emphasis on a disciplined problem solving approach: understanding the problem, identifying edge cases, proposing solutions with trade offs, implementing clean and readable code, and testing or reasoning about correctness and performance. Includes debugging strategies, writing maintainable code, and practicing medium difficulty interview style problems.

MediumTechnical

38 practiced

Implement a Python function that checks whether a signed integer n is a power of two without using loops over bits. The function should return False for non-positive numbers and handle edge cases. Explain the bitwise trick and why it works.

Sample Answer

Approach: A positive integer is a power of two iff exactly one bit is 1 in its binary representation. We can test that with a constant-time bitwise trick: n & (n - 1) clears the lowest set bit; for powers of two that yields 0.

python

def is_power_of_two(n: int) -> bool:
    """
    Return True if n is a positive power of two, else False.
    Handles Python's arbitrary-size integers. Runs in O(1) time.
    """
    if n <= 0:
        return False
    return (n & (n - 1)) == 0

# Alternative using two's complement:
# return n > 0 and (n & -n) == n

Why it works:- A power-of-two n has binary form 1000...0 (one 1 and trailing zeros).- n-1 becomes 0111...1 (all lower bits flipped).- Bitwise AND: 1000...0 & 0111...1 == 0 only for numbers with a single 1-bit.- For numbers with multiple 1-bits, at least one bit remains set and result ≠ 0.

Complexity: Time O(1) (single machine integer ops), Space O(1).Edge cases: n ≤ 0 -> False; large integers supported by Python; works with typical signed ints. Alternative: use (n & -n) == n which isolates lowest set bit.

MediumTechnical

43 practiced

You're reviewing a colleague's Python function that sometimes produces incorrect outputs on edge inputs. Describe a systematic debugging approach: how to reproduce the bug, design unit tests (including property-based testing), add logging and assertions, use debuggers and profilers, and ensure your fix doesn't introduce regressions.

Sample Answer

Start by reproducing the bug reliably- Gather failing inputs from logs, upstream, or ask the colleague for examples.- If none exist, create a minimized input by binary-searching input size/parameters until you can trigger the incorrect output consistently.

Write deterministic unit tests- Capture a failing example as a unit test (pytest).- Add edge-case tests (empty arrays, NaNs, extreme values, categorical corners).

Property-based tests- Use Hypothesis to assert invariants (e.g., output shape, monotonicity, sum-preservation).

python

from hypothesis import given, strategies as st

@given(st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=0, max_size=100))
def test_properties(xs):
    out = my_func(xs)
    assert isinstance(out, list)
    assert len(out) == len(xs)
    # domain-specific invariant
    assert all(x >= 0 for x in out)

Add logging and assertions- Log inputs, intermediate shapes, summary statistics (min/max/mean) and model parameters.- Add defensive assertions for preconditions (no NaNs, expected dtype/shape) close to the function entry.

Use debuggers and profilers- Use pdb or VSCode/pycharm breakpoint to step through failing input and inspect variables.- Use cProfile or line_profiler if performance could be causing numeric instability (e.g., timeouts, truncation).

Fixing and avoiding regressions- Implement fix with small, focused change and document reasoning.- Add the failing unit test and property tests to the test suite.- Run full test suite and CI; include randomized seeds to surface flaky behavior.- Consider fuzzing or adding continuous property tests for critical code paths.

Explain to colleague and create a short postmortem describing root cause, fix, and prevention (e.g., input validation or contracts).

EasyTechnical

39 practiced

Implement a level-order traversal (BFS) of a binary tree in Python that returns a list of lists of node values, one list per depth level. Define TreeNode with 'val', 'left', and 'right'. Aim for O(n) time and O(w) space where w is the maximum width. Include an example input and output and describe tests for skewed and empty trees.

Sample Answer

We can perform level-order traversal using a queue (collections.deque). At each step, process all nodes currently in the queue (one level), collect their values, and enqueue children. This is O(n) time and O(w) space where w is max width.

python

from collections import deque
from typing import Optional, List

class TreeNode:
    def __init__(self, val: int, left: 'Optional[TreeNode]'=None, right: 'Optional[TreeNode]'=None):
        self.val = val
        self.left = left
        self.right = right

def level_order(root: Optional[TreeNode]) -> List[List[int]]:
    if not root:
        return []
    q = deque([root])
    result = []
    while q:
        level_size = len(q)
        level_vals = []
        for _ in range(level_size):
            node = q.popleft()
            level_vals.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        result.append(level_vals)
    return result

Example:- Input tree: root=TreeNode(1, TreeNode(2, TreeNode(4)), TreeNode(3))- Output: [[1], [2, 3], [4]]

Complexity:- Time: O(n) — each node visited once- Space: O(w) — queue stores up to maximum width

Tests to include:- Empty tree -> [].- Single node -> [[val]].- Left-skewed (chain) -> each level one element, e.g. [ [1],[2],[3] ].- Right-skewed similarly.- Balanced tree with multiple nodes per level.- Large tree to validate performance and memory usage.

MediumTechnical

33 practiced

Implement in Python a function that returns the length of the longest substring without repeating characters for a given ASCII string. Your solution should run in O(n) time and O(min(n, charset)) space. Provide an example and discuss edge cases like empty string and full ASCII set.

Sample Answer

Use a sliding-window with two pointers and a hash map recording last-seen indices for ASCII characters. Move the right pointer scanning characters; if a character was seen inside the current window, move left to last_seen + 1. This yields O(n) time and O(min(n, charset)) space.

python

def length_of_longest_substring(s: str) -> int:
    """
    Return length of longest substring without repeating characters.
    O(n) time, O(min(n, charset)) space. Assumes ASCII input.
    """
    last = {}           # char -> last index seen
    start = 0           # window start index
    max_len = 0
    for i, ch in enumerate(s):
        if ch in last and last[ch] >= start:
            # repeat inside current window -> move start
            start = last[ch] + 1
        last[ch] = i
        max_len = max(max_len, i - start + 1)
    return max_len

Key points:- Sliding window tracks a substring [start..i] with unique chars.- last stores most recent index; updating start avoids scanning.- Time: O(n) single pass. Space: O(min(n, charset)) — for ASCII charset ≤ 128.

Example:- s = "abcabcbb" -> returns 3 ("abc")- s = "" -> returns 0 (empty string)- s contains all 128 unique ASCII chars -> returns up to 128.

Edge cases:- Empty string -> 0.- All identical chars -> 1.- Full ASCII set (≥128 unique) -> bounded by charset size.- Non-ASCII input: algorithm still works but space depends on unique codepoints; to enforce ASCII-only, validate or restrict input.

MediumTechnical

35 practiced

Given a sorted array that may contain duplicates, implement in Python two functions: first_occurrence(arr, target) and last_occurrence(arr, target), each running in O(log n) time. If target is not present return -1. Explain how you avoid infinite loops and off-by-one errors.

Sample Answer

To find the first and last occurrence in O(log n), use modified binary search that moves the boundaries even when you find target: for first, continue searching left (r = mid - 1); for last, continue searching right (l = mid + 1). Use l <= r and compute mid = l + (r - l) // 2 to avoid overflow (Python safe but good practice). Update an index variable when you find target. This avoids infinite loops because mid progresses and bounds strictly shrink; off-by-one errors are prevented by the inclusive l/r convention and adjusting by +/-1.

python

def first_occurrence(arr, target):
    l, r = 0, len(arr) - 1
    res = -1
    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] == target:
            res = mid         # record and keep searching left
            r = mid - 1
        elif arr[mid] < target:
            l = mid + 1
        else:
            r = mid - 1
    return res

def last_occurrence(arr, target):
    l, r = 0, len(arr) - 1
    res = -1
    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] == target:
            res = mid         # record and keep searching right
            l = mid + 1
        elif arr[mid] < target:
            l = mid + 1
        else:
            r = mid - 1
    return res

Key points:- Time: O(log n), Space: O(1).- Edge cases: empty array, target absent (returns -1), all elements equal, single-element arrays.- Avoid infinite loops by ensuring l or r moves on every branch; using mid = l + (r-l)//2 and l<=r prevents off-by-one.

Unlock Full Question Bank

Get access to hundreds of Coding Fundamentals and Problem Solving interview questions and detailed answers.

Join thousands of developers preparing for their dream job.