Core Data Structures Questions

Fundamental built-in data structures used in everyday programming and coding interviews: arrays/lists, strings, and hash maps (dictionaries). For array-like sequences, cover indexing, slicing or sub-ranging, iteration, common mutation operations (appending, inserting, removing elements), common algorithms such as sorting and reversing, and the memory and performance implications of each. For strings, cover indexing, slicing or substring extraction, common operations such as splitting, joining, trimming, and replacing, and general approaches to string manipulation and pattern processing. For hash maps and dictionaries, cover key value semantics, insertion and lookup, iteration patterns, safe access idioms (defaults, existence checks), and using hash tables for counting and grouping. Candidates should know the time complexity of common operations in plain terms (constant time, linear time, quadratic time) and be able to choose the appropriate structure for a problem and reason about space and performance tradeoffs. Practice should include implementation level manipulation exercises and classic interview problems such as two sum and frequency counting, written clearly in whatever language the candidate is most comfortable with (a specific language may be used for concrete code examples without the underlying concept being tied to it).

EasyTechnical

50 practiced

List common Python operations on core data structures and state their typical time complexity in plain English: list index access, list append, list insert at start, list pop last, list pop(0), list slicing (copy), membership check 'x in list', dict insertion, dict lookup, dict deletion, and string concatenation with '+' inside a loop vs using join(). Briefly explain why.

MediumTechnical

58 practiced

Implement length_of_longest_unique_substring(s: str) -> int in Python using the sliding-window technique to find the longest substring without repeating characters. Aim for O(n) time and explain the data structures you use and why they make the algorithm linear.

Sample Answer

To solve this, use a sliding window with two pointers (left, right) and a hashmap (dict) that stores the last index where each character was seen. The dict lets you jump the left pointer past duplicates in O(1), ensuring each character is processed at most twice (once by right, once by left) — hence O(n).

python

def length_of_longest_unique_substring(s: str) -> int:
    """
    Returns the length of the longest substring without repeating characters.
    Sliding-window with a dict storing last seen index for each character.
    Time: O(n), Space: O(min(n, alphabet_size))
    """
    last_index = {}  # char -> last index where it appeared
    left = 0         # window start (inclusive)
    max_len = 0

    for right, ch in enumerate(s):
        # If ch was seen and is inside current window, move left past its last occurrence
        if ch in last_index and last_index[ch] >= left:
            left = last_index[ch] + 1
        last_index[ch] = right  # update last seen index
        # window is [left, right], length = right - left + 1
        max_len = max(max_len, right - left + 1)

    return max_len

Key points:- Data structure: dict for O(1) lookup/update of last seen indices.- Why linear: right increments each iteration; left only moves forward (never back). Each index is considered a constant number of times.- Space: O(min(n, character_set_size)).

Edge cases:- Empty string -> 0- All unique -> len(s)- All same char -> 1

Alternative: use an array of size 128/256 for ASCII/byte strings for slightly faster access.

MediumTechnical

54 practiced

Group anagrams: given a list of lowercase words like ['eat','tea','tan','ate','nat','bat'], group them into lists of anagrams. Implement group_anagrams(words: List[str]) -> List[List[str]] in Python and explain the time complexity. Discuss an alternative key representation to sorting each word.

Sample Answer

Approach: Use a hashmap mapping a canonical key for each word to a list of words that share that key. The canonical key can be the sorted characters of the word (simple) or a 26-length character count tuple (faster for long words / many words). Return the grouped anagrams.

python

from typing import List, Dict, Tuple
from collections import defaultdict

def group_anagrams(words: List[str]) -> List[List[str]]:
    """
    Group anagrams using sorted-string keys.
    """
    groups: Dict[str, List[str]] = defaultdict(list)
    for w in words:
        # Key: sorted characters joined back to a string
        key = ''.join(sorted(w))
        groups[key].append(w)
    return list(groups.values())

Key points:- Using sorted(w) makes key creation O(k log k) per word (k = word length).- Total time: O(n * k log k) where n = number of words, k = avg word length.- Space: O(n * k) for storing keys and grouped words.

Alternative key (character count tuple):- Build a 26-element tuple of counts for 'a'..'z' — O(k) per word.- Example:

python

def group_anagrams_count(words: List[str]) -> List[List[str]]:
    groups = defaultdict(list)
    for w in words:
        cnt = [0]*26
        for ch in w:
            cnt[ord(ch)-97] += 1
        groups[tuple(cnt)].append(w)
    return list(groups.values())

- Time: O(n * k), better than sorting when k is large.- Trade-offs: count-tuple uses fixed additional space (26 ints) but is slightly more code; sorted-key is simpler and fine when words are short. Edge cases: empty input, single-letter words, and preserving original order within groups if needed (stable appends do this).

MediumTechnical

57 practiced

Implement a function two_sum(nums: List[int], target: int) -> Tuple[int, int] in Python that returns indices of two numbers adding to target. Your solution should run in O(n) time and O(n) extra space. Provide example input/output and handle negative numbers and duplicates.

Sample Answer

Approach: Use a hash map to record seen values and their indices while scanning the list once. For each number, check whether target - num is already in the map; if so, return the stored index and current index. This is O(n) time and O(n) extra space and correctly handles negatives and duplicates.

python

from typing import List, Tuple

def two_sum(nums: List[int], target: int) -> Tuple[int, int]:
    """
    Return indices (i, j) such that nums[i] + nums[j] == target.
    Raises ValueError if no valid pair exists.
    """
    seen = {}  # value -> index
    for i, num in enumerate(nums):
        comp = target - num
        if comp in seen:
            return (seen[comp], i)
        # store index of current number for future complements
        seen[num] = i
    raise ValueError("No two sum solution")

Example:Input: nums = [2, 7, 11, 15], target = 9Output: (0, 1)

Handles negatives and duplicates:Input: nums = [3, 3], target = 6 -> returns (0, 1)Input: nums = [-1, 4, 2], target = 1 -> returns (0, 2)

Time Complexity: O(n). Space Complexity: O(n).Edge cases: empty list, single element (raises ValueError), multiple valid pairs (returns first found).

EasyTechnical

51 practiced

Demonstrate using a Python dict as a dispatch table to replace a switch/case. Given operations 'sum','mean','median' mapping to functions, show how to call the appropriate function based on a string key and handle unknown keys safely (provide fallback).

Sample Answer

Using a dict as a dispatch table is a clean way to replace switch/case in Python. Map string keys to callables, then look up and call the function; use dict.get to provide a safe fallback.

python

from statistics import mean, median
from typing import Callable, List

def sum_op(nums: List[float]) -> float:
    return sum(nums)

# dispatch table: mapping operation name -> function
DISPATCH = {
    "sum": sum_op,
    "mean": mean,
    "median": median,
}

def apply_op(op_name: str, nums: List[float], fallback: Callable = lambda x: None):
    """
    Calls the function for op_name with nums.
    If op_name is unknown, calls fallback(op_name).
    """
    func = DISPATCH.get(op_name, None)
    if func is None:
        return fallback(op_name)
    return func(nums)

# Examples
print(apply_op("sum", [1, 2, 3]))        # 6
print(apply_op("mean", [1, 2, 3]))       # 2
print(apply_op("unknown", [1,2], fallback=lambda k: f"Unknown op: {k}"))

Key points:- Lookup is O(1); overall cost depends on the chosen operation.- Use dict.get for safe fallback or handle KeyError if indexing.- Validate inputs (empty lists, non-numeric values) inside each op or before dispatch.- Alternative: class-based or strategy pattern if stateful behavior is needed.

Unlock Full Question Bank

Get access to hundreds of Core Data Structures interview questions and detailed answers.

Join thousands of developers preparing for their dream job.