48 Meta Python Developer Interview Questions & Answers

I would consume the stream through an iterator or generator, keep running counts in a dictionary, use a set for duplicate checks, and store the recent window in a deque with a fixed maximum length. This processes records one at a time instead of loading the full stream. The deque stays bounded, but the dictionary and set can still grow as new categories and record identifiers arrive.

I would process each record as it arrives instead of first building a list. An iterator or generator supplies one record at a time, so the consumer does not need to retain the complete input. This saves memory only when the upstream source also produces records incrementally.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

I would use a dictionary for running counts by category. Dictionary lookup and update are usually constant time. I would use a set for duplicate identifiers because membership checks are also usually constant time. These are average costs, not strict guarantees. An unusual hash collision pattern can make an operation slower.

For a recent record window, I would use collections.deque with maxlen. Appending is constant time. When the deque is full, appending a new record automatically removes the oldest record. Its memory is bounded by the chosen window size.

The dictionary grows with the number of distinct categories. The set grows with the number of retained identifiers. For an endless stream, I would add expiry rules, periodic cleanup, or external state storage. I would also define how to handle malformed records, missing keys, and identifiers that arrive again after their expiry period.

The example reads records from a generator. Each record contains a record identifier and a category. The seen_ids set skips an identifier that was already accepted. The category_counts dictionary stores the running count for each category. The recent_records deque has maxlen set to three, so it stores only the three most recent accepted records. Four unique records are accepted and one repeated identifier is skipped. The final counts are payment two, search one, and order one. The final recent window contains record identifiers two, three, and four. Processing n records takes O(n) expected time. The dictionary uses O(c) memory for c categories. The set uses O(u) memory for u retained unique identifiers. The deque and the final list copy use O(w) memory for window size w, which is three in this example.

A common mistake is converting the incoming stream to a list, which stores every record before processing begins. Another mistake is using a list for duplicate checks. List membership scans elements and takes linear time, while set membership is usually constant time. Some candidates assume that maxlen bounds the memory of the whole process, but it bounds only the deque. The dictionary and set may still grow. It is also incorrect to say that dictionary and set operations are always constant time. Their expected behavior is constant time, but worst case operations can be linear. Another mistake is removing the first element of a list for every new record, because Python must shift the remaining references.

Start with the operation, then name the structure. Use an iterator for incremental input, a dictionary for keyed state, a set for membership checks, and a bounded deque for the recent window. State clearly which structures have bounded memory and which structures require cleanup.

I would iterate through the offices dictionary and create a new dictionary for offices whose IDs are not in the closed office set. For each open office, I would use len on its employee list. Using a set makes each closed office check take average constant time.

The practical solution is to create a new dictionary that contains only open offices. The code iterates through offices.items(), which gives each office ID and its employee list. It checks whether the office ID is absent from closed_office_ids. If the office is open, len(employees) gives the number of employees in that list. An open office with an empty list is included with a count of zero. A closed office is not included at all. The solution assumes every office value is a list of employees and every office ID is hashable. Integer office IDs satisfy that requirement. Python sets use hashing, so membership checks take average constant time. The function visits each office once, so its average running time is proportional to the number of offices. It creates a new result dictionary, so extra memory is proportional to the number of open offices. The original offices dictionary and its employee lists are not copied or changed. In production, invalid values such as None should be rejected or normalized before calling this function because len(None) raises TypeError.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

The function reads each office ID and employee list from the offices dictionary. It excludes office IDs found in the closed office set. For every remaining office, it stores len(employees) in a new dictionary. In the example, office 102 is closed, office 101 has three employees, and office 103 has an empty employee list. The returned result is {101: 3, 103: 0}. The input dictionary and employee lists are not modified.

Common mistakes include returning closed offices with a count of zero instead of excluding them, using the number of office IDs instead of the length of each employee list, using a list for closed office membership when a set is available, changing the original dictionary during iteration, and passing None or another value that does not support len.

State the filtering rule first. Then explain that the set provides average constant time membership checks, len counts each employee list, open offices with empty lists return zero, and the function creates a new dictionary without changing the input.

I would convert each shop's comments to a set and update one Counter with those unique comments. This gives each comment at most one count per shop. I would then return any comment with the highest count. If no shop contains a comment, I would return None.

Use a set for each shop, then count those unique values with collections.Counter. A set removes repeated comments inside one shop. This matters because the goal is to count distinct shops, not total comment entries.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

For example, Shop A contains clean, clean, and friendly. Shop B contains clean and fast. Shop A contributes one count for clean and one for friendly. Shop B contributes one count for clean and one for fast. The final counts are clean two, friendly one, and fast one, so the function returns clean.

Python sets and Counter use hashing for membership and counting. The comments must therefore be hashable. Strings are hashable and work well here. If no comments exist, there is no valid result, so the function returns None. If several comments share the highest count, returning any one of them satisfies the question.

The code examines every input comment once on average. Its average time cost is O(n), where n is the total number of comment entries. Its extra memory cost is O(u), where u is the total number of distinct comments.

The function creates one Counter for all shops. For each shop, set(comments) creates a temporary set that contains each comment once. Counter.update then adds one count for every unique comment from that shop. After all shops are processed, max with shop_counts.get returns a comment whose count is highest. The function returns None when the Counter is empty. In the example, clean appears in Shop A and Shop B, so the result is clean.

A common mistake is updating the Counter with each original shop list. That makes duplicate comments inside one shop count several times. Another mistake is creating one set from all shops, because that removes the information about how many distinct shops contained each comment. Candidates may also forget to define the result for empty input. Another mistake is promising a specific winner during a tie even though the question allows any tied comment.

State the counting rule first: one count per comment per shop. Then explain that a set enforces the rule inside each shop and a Counter combines the counts across shops. Mention empty input, ties, hashable comments, average O(n) time, and O(u) extra memory.

I would first confirm the input type, expected result, case rules, treatment of spaces, and behavior when no answer exists. I will assume the function must return the first character that appears exactly once in a string. I would count characters with a dictionary, then scan the original string again to preserve order. The function returns None when the string is empty or every character is repeated, and it raises TypeError for a non string input.

I will assume the function receives a Python string and returns the first character that appears exactly once. Before coding, I would ask whether matching is case sensitive, whether spaces count, what to return when no unique character exists, and how invalid input should be handled. In this implementation, matching is case sensitive, every string character counts, no result returns None, and a non string value raises TypeError.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

The first loop counts each character in a dictionary. The second loop reads the original string in order and returns the first character whose count is one. Two loops are needed because the result depends on both frequency and original position.

An empty string returns None. A one character string returns that character. The string aabb returns None. Spaces, newline characters, and Unicode code points are treated like other characters. Python strings contain Unicode code points, so a visible symbol made from multiple code points may be processed as multiple characters.

The expected time cost is O n because the function scans the string twice. Extra memory is O k, where k is the number of distinct characters. Production code should document these rules and test invalid, empty, repeated, case sensitive, whitespace, and Unicode input.

The function first checks that the input is a string. It then stores the frequency of each character in a dictionary. A second loop scans the original string so the original order is preserved. The first character with a count of one is returned. If the string is empty or every character is repeated, the function returns None. The expected time cost is O n because there are two full scans. The extra memory cost is O k, where k is the number of distinct characters stored in the dictionary.

Common mistakes include returning any unique character instead of the first one, calling text.count inside a loop and repeatedly scanning the full string, using a set and losing the required order, ignoring empty input, changing letter case without permission, removing spaces without permission, returning different no result values in different cases, and claiming constant memory even though the dictionary can store one entry for every distinct character.

State the assumptions before writing code. Then explain why one pass counts frequencies and the second pass preserves order. Finish with boundary cases, expected O n time, O k extra memory, and a few focused tests.

I would scan the scores once and keep two running totals. For each score, I either skip it and keep the current best total, or select it and add it to the best total from before the adjacent position. I keep the larger result. This takes linear time, uses constant auxiliary memory, and does not modify the input list.

The practical solution uses dynamic programming with two variables. Dynamic programming means reusing results from smaller parts of the problem. Let previous_two store the best total before the previous position. Let previous_one store the best total through the previous position.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

For each score, there are two valid choices. We can skip it, so the total remains previous_one. Or we can select it and add it to previous_two, because selecting the previous score would break the adjacency rule. The larger value becomes the new best total.

For [2, 7, 9, 3, 1], the function returns 12 by selecting 2, 9, and 1. An empty list returns 0. A list with one score returns that score. The input must contain non negative integers, so the implementation rejects negative values, Boolean values, and other types.

The loop reads every score once. It does not copy or modify the list. It uses constant auxiliary memory because it stores only two running totals. Python integers can grow as totals increase, so very large integers require additional processing time and storage even though the number of stored totals remains constant.

The function keeps two earlier results. previous_two is the best total available before the previous position. previous_one is the best total through the previous position. For each score, the function compares skipping the score with selecting it and adding it to previous_two. It then moves the saved totals forward. For [2, 7, 9, 3, 1], it returns 12. The function performs one loop over the list, takes linear time, uses constant auxiliary memory, and leaves the input unchanged.

A common mistake is selecting large scores without checking whether their positions are adjacent. Another mistake is changing previous_two before calculating the current result, which removes a value still needed for the decision. Some candidates create a full result list even though only two earlier totals are required. Other mistakes include returning the largest single score, failing to handle an empty list, modifying the input, or silently accepting values that violate the non negative integer contract.

Start by stating the two choices for each score. Either skip it or select it with the best total from before the adjacent position. Then define both running variables, walk through [2, 7, 9, 3, 1], and finish by stating linear time and constant auxiliary memory.

I would store only nonzero values in a Python dictionary, with each index as the key. For the dot product, I would iterate through the dictionary with fewer stored entries and look up the same indexes in the other dictionary. This avoids scanning every zero position, so the dot product depends on the smaller number of nonzero entries rather than the full vector length.

I would represent each sparse vector with a dictionary that maps an index to its nonzero value. Zero values are not stored. The object also keeps the full vector length so it can reject a dot product between vectors with different dimensions.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

To compute the dot product, I choose the dictionary with fewer entries. For each stored index and value, I call get on the other dictionary. If that index is absent, get returns zero, so the position contributes nothing. Otherwise, I multiply the two values and add the product to the result.

Python dictionaries provide average constant time lookup. Therefore, the dot product takes average O(min(k1, k2)) time, where k1 and k2 are the numbers of stored entries. It uses O(1) additional space. Building a vector from a dense list still takes O(n) time because every input value must be inspected, and the dictionary uses O(k) memory.

This design is useful when most positions are zero. For dense vectors, a list can have lower overhead and better sequential access. Production code should validate dimensions and choose numeric types that provide the required precision.

The SparseVector class stores the full vector length and a dictionary containing only nonzero values. The dot method first verifies that both vectors have the same length. It then iterates through the dictionary with fewer entries and uses get to find the value at the same index in the other dictionary. A missing index contributes zero. Creating one vector from a dense list takes O(n) time and O(k) memory, where n is the full length and k is the number of nonzero values. The dot product takes average O(min(k1, k2)) time and O(1) additional space.

Common mistakes include storing zero values in the dictionary, scanning the full vector length during every dot product, iterating through the larger dictionary without reason, and using direct dictionary indexing for positions that may be absent. Another mistake is failing to compare vector lengths, which can allow an invalid dot product to return a misleading result. Candidates should also avoid claiming worst case constant lookup because dictionary lookup is constant time only on average.

Start with the dictionary representation. Explain that missing indexes mean zero. Then describe why iterating through the smaller dictionary reduces work. Finish with dimension validation, construction cost, dot product cost, and memory cost.

I would keep one current value from each nonempty list in a min heap. Each call to next removes the smallest value, returns it, and adds the following value from the same source list. This produces sorted output lazily and uses O of k extra memory instead of storing all N values.

I would use a min heap from Python's heapq module. I assume every input list is sorted in ascending order and all stored values can be compared with each other. During initialization, I add the first value from every nonempty list and call heapify. Each heap entry stores the value, its source list index, and its position in that list.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

When the iterator removes the smallest entry, that value is the next result. It then adds the following value from the same source list, when one exists. Therefore, the heap keeps at most one pending value from each list.

The class implements __iter__ and __next__, so Python's next function and for loops work normally. It also provides the requested has_next and next methods. After all values are consumed, __next__ and next raise StopIteration.

Empty lists are skipped and duplicate values are preserved. Initialization takes O of k time with heapify. Returning all N values takes O of N log k time. Extra memory is O of k because the class stores only heap entries and references to the original lists. The source lists should not be modified during iteration because changes could break ordering or indexed access.

The class keeps references to the original sorted lists and stores at most one pending value from each nonempty list in a min heap. Every heap entry contains the value, the source list index, and the position inside that list. The source index also gives Python a stable integer comparison when equal values occur. Initialization collects the first entries and uses heapify. The __next__ method removes the smallest entry, adds the following value from the same list when available, and returns the removed value. The next method delegates to __next__, so both methods use the same exhaustion behavior. For the lists [1, 4, 7], [2, 2, 8], [], and [3, 6], the output is [1, 2, 2, 3, 4, 6, 7, 8].

A common mistake is inserting every input value into the heap, which uses O of N extra memory instead of O of k. Another mistake is joining and sorting all lists, which creates a full merged result and is not lazy. Candidates may forget empty lists, duplicate values, or StopIteration. They may also store only the value and lose the source position needed to advance the correct list. The implementation also fails to guarantee sorted output when an input list is unsorted, when values are not mutually comparable, or when a source list is modified during iteration.

Explain the heap invariant first: it contains the smallest value not yet returned from each active list. Then show that after removing one entry, only the next value from that same list is added. Finish with O of N log k total time, O of k extra memory, duplicate preservation, and StopIteration after exhaustion.

I would use collections.OrderedDict. It provides average constant time key lookup and keeps entries in a defined order. A successful get moves the key to the most recently used end. A put updates or inserts the key, then removes the least recently used entry when capacity is exceeded. I would reject a nonpositive capacity and add a lock if several threads share the cache.

The practical Python solution is collections.OrderedDict. It combines a mapping with maintained key order. In this implementation, the first entry is the least recently used item, and the last entry is the most recently used item.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

For get, the code checks whether the key exists. A missing key returns negative one. This answer assumes negative one is reserved as the missing value. A found key is moved to the end with move_to_end, then its value is returned. For put, an existing key is deleted and inserted again with its new value. This makes it the most recently used entry. If the cache grows beyond capacity, popitem with last set to false removes the oldest entry.

Lookup, insertion, deletion, movement, and eviction take average constant time. Memory use is proportional to capacity because each cached item requires mapping storage and ordering metadata. Stored objects are not copied. The cache keeps references to them.

This design is suitable for a bounded cache inside one Python process. It is not safe for compound concurrent operations without synchronization. A positive capacity is required, and cached values should not use negative one when callers must distinguish a hit from a miss.

The implementation uses OrderedDict for both key lookup and usage order. The oldest entry stays at the beginning, and the newest entry stays at the end. get returns negative one for a missing key. A successful get moves the key to the end. put deletes an existing key before inserting its new value so that the key becomes most recently used. When the number of entries exceeds capacity, popitem with last set to false removes the least recently used entry. The constructor rejects capacities less than one.

Common mistakes include using a normal dictionary without explicitly maintaining access order, evicting the newest entry instead of the oldest entry, forgetting that a successful get must refresh recency, and allowing the cache to grow beyond capacity. Another mistake is checking the returned value to decide whether a key exists. This fails when negative one can be stored as a valid value. Candidates may also claim guaranteed constant time instead of average constant time, or assume that several cache steps are automatically safe when threads run them concurrently.

Start with the two requirements: fast key lookup and fast access ordering. Explain that OrderedDict provides both. Then walk through one successful get, one update, and one eviction. Finish with average constant time operations, memory proportional to capacity, the reserved missing value, and the need for synchronization during shared access.

I would build cumulative weights once, generate a random integer from zero up to but not including the total weight, and manually find the first cumulative weight greater than that target. This reproduces the behavior needed instead of bisect_right. Preparation takes linear time, while each selection takes logarithmic time.

The practical solution is to turn the mapping into cumulative weights and search them manually. Suppose Ada has weight 2, Ben has weight 3, and Chen has weight 5. The cumulative values are 2, 5, and 10. I generate a random integer from 0 through 9. Targets 0 and 1 select Ada. Targets 2 through 4 select Ben. Targets 5 through 9 select Chen.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

The binary search finds the first cumulative value strictly greater than the target. When the middle value is greater, I save that position and continue searching left. Otherwise, I search right. This is the same boundary behavior that bisect_right would provide for this cumulative list and target.

The code requires a nonempty mapping with positive integer weights. It rejects Boolean values because bool is a subclass of int in Python. Zero and negative weights are rejected because cumulative values must increase strictly.

Building the selector takes linear time and linear memory. Each later selection takes logarithmic time and constant extra memory. If weights change, the cumulative list must be rebuilt before another correct selection.

The code reads the mapping in its iteration order and stores the names and running weight totals in matching lists. For weights 2, 3, and 5, the cumulative list becomes 2, 5, and 10. It then generates a target with randrange using the total weight, so the possible targets are 0 through 9. The manual binary search returns the first cumulative value that is strictly greater than the target. That index identifies the selected name. The cumulative data is prepared once, so repeated selections only need random target generation and logarithmic binary search.

A common mistake is using greater than or equal to with a target generated from zero through total minus one. That gives the wrong ranges at cumulative boundaries. Another mistake is generating a target that can equal the total weight, which creates an invalid position. Candidates may also rebuild cumulative weights for every selection, accept zero or negative weights, forget that Boolean values pass an int check, or stop at the first valid middle position without continuing left to find the earliest cumulative value greater than the target.

Explain the target ranges first. Then state the exact binary search rule: find the first cumulative weight strictly greater than the target. Finish by separating the linear preparation cost from the logarithmic cost of each selection.