Programming Fundamentals in Python and Go Questions

Practical programming skills in Python and Go including implementation and reasoning about common data structures and algorithms, string manipulation, file input and output operations, and idiomatic error handling. Candidates should understand time and space complexity, write clear and maintainable code, and be comfortable with language specific constructs such as generator and comprehension patterns in Python and goroutines and channels in Go. Interviewers commonly assess these skills with short coding exercises, debugging tasks, and small design problems.

MediumTechnical

20 practiced

A report generator currently scans the same task records multiple times to answer different summary questions, and the runtime is starting to hurt as the team grows. How would you reason about the bottleneck, and what would you change in the data flow so repeated lookups get faster without making the codebase hard to maintain?

Sample Answer

**Bottleneck reasoning**

A bottleneck is the part of the system that dominates total runtime. If the report generator scans the same task records over and over, each new question forces another full pass through the data. That scales poorly as the team grows.

text

5 scans * 100000 rows = 500000 row visits
1 scan * 100000 rows = 100000 row visits

Intuition: one pass is 5x less work in this example.

**What I would change**I would switch the data flow from repeated scans to one ingestion pass that builds summary structures as it goes:- counters for totals by status, owner, or date- maps indexed by the fields used in reports- one reducer function that updates all needed aggregates together

Then each summary question reads from the precomputed aggregates instead of touching the raw records again. That keeps queries fast and the code maintainable because the aggregation logic lives in one place.

**Tradeoff**The main cost is a bit more memory for the summary maps. I would accept that tradeoff because it is much cheaper than rescanning the whole dataset repeatedly.

**Example**If ten report questions all need ticket counts by team, I would build that count once during ingestion, then reuse it for every report instead of looping over the task table ten times.

EasyTechnical

19 practiced

Your operations team gets weekly status items from different managers, but the same item can appear with different capitalization, extra spaces, or punctuation. In Python, write a function that normalizes the titles, removes duplicates while preserving the first occurrence, and returns the cleaned list. Assume a few thousand strings at most.

Sample Answer

**Approach**

I’d normalize by lowercasing, removing punctuation, and collapsing repeated spaces. Then I’d use a `set` of normalized keys to keep only the first occurrence. A set is a data structure that gives fast membership checks, so this stays simple and efficient for a few thousand strings.

python

import re
from typing import List


def normalize_title(title: str) -> str:
    cleaned = re.sub(r'[\W_]+', ' ', title.lower())
    return ' '.join(cleaned.split())


def dedupe_titles(titles: List[str]) -> List[str]:
    seen = set()
    result = []

    for title in titles:
        norm = normalize_title(title)
        if norm in seen:
            continue
        seen.add(norm)
        result.append(norm)

    return result

**Example**Input: `[' Weekly Update!', 'weekly update', 'Budget Review', 'Budget review ']`Output: `['weekly update', 'budget review']`

**Why this works**: the first `weekly update` is kept, and the later duplicate is skipped because it normalizes to the same key.

**Complexity**: O(n * m) time, where `m` is string length, and O(n) extra space for the set.

If the team wants to keep original casing, I would store the first original string in `result` instead of the normalized version.

MediumTechnical

16 practiced

A Python automation script was fine in local testing, but month-end runs are now slow and use much more memory. How would you debug whether the problem is caused by repeated file reads, string processing, or keeping too much data in memory, and what would you change first?

MediumTechnical

21 practiced

Your team wants one new automation tool that will be owned by a few engineers, run unattended every day, and occasionally do CPU-heavy parsing on large inputs. How would you choose between Python and Go for the implementation, and what factors would matter most beyond raw speed?

MediumTechnical

18 practiced

An overnight Python job reads a directory of daily status files. Some files are empty, one file has a malformed line, and another file may be missing. How would you structure the job so it keeps processing valid data, records which files failed, and still gives the operator a useful summary at the end?

Unlock Full Question Bank

Get access to hundreds of Programming Fundamentals in Python and Go interview questions and detailed answers.

Join thousands of developers preparing for their dream job.