1. FizzBang chuẩn Omnissa

Đề: Nhận start, end. In từng số theo format n: EVEN/ODD, thêm BANG nếu chia hết cho 7. Viết unit tests.

def fizz_bang(start: int, end: int) -> list[str]:
    if start > end:
        return []

    lines = []
    for number in range(start, end + 1):
        parity = "EVEN" if number % 2 == 0 else "ODD"
        suffix = " BANG" if number % 7 == 0 else ""
        lines.append(f"{number}: {parity}{suffix}")
    return lines

import unittest

class TestFizzBang(unittest.TestCase):
    def test_even_bang(self):
        self.assertEqual(fizz_bang(14, 14), ["14: EVEN BANG"])

    def test_empty_when_start_after_end(self):
        self.assertEqual(fizz_bang(5, 3), [])

Nói khi làm: “I’ll return a list first because it makes the function testable. If the interviewer wants printing, I can print the returned lines afterward.”

2. CSV threshold analyzer

Đề: Đọc file CSV rất lớn có cột timestamp và cpu_usage. Trả dòng đầu tiên có CPU vượt threshold, kèm line number.

import csv
from pathlib import Path


def find_first_cpu_peak(path: str, threshold: float) -> dict | None:
    with Path(path).open(newline="", encoding="utf-8") as file:
        reader = csv.DictReader(file)
        for line_number, row in enumerate(reader, start=2):
            try:
                cpu_usage = float(row["cpu_usage"])
            except (KeyError, ValueError):
                continue

            if cpu_usage >= threshold:
                return {
                    "line_number": line_number,
                    "timestamp": row.get("timestamp", ""),
                    "cpu_usage": cpu_usage,
                }
    return None

class TestCsvAnalyzer(unittest.TestCase):
    def test_find_first_peak(self):
        path = "sample.csv"
        with open(path, "w", encoding="utf-8") as f:
            f.write("timestamp,cpu_usage\n10:00,30\n10:01,95\n")
        self.assertEqual(
            find_first_cpu_peak(path, 90),
            {"line_number": 3, "timestamp": "10:01", "cpu_usage": 95.0},
        )

Nói khi làm: “For a multi-million-row file, I will not use readlines or pandas. This scans one row at a time, so memory stays constant.”

3. CPU peak sampler theo cửa sổ 60 giây

Đề: Cho list sample CPU mỗi giây. Gom theo window 60 giây, trả max và average của từng window.

def summarize_cpu_windows(samples: list[float], window_size: int = 60) -> list[dict]:
    summaries = []

    for start in range(0, len(samples), window_size):
        window = samples[start:start + window_size]
        if not window:
            continue
        summaries.append({
            "start_index": start,
            "end_index": start + len(window) - 1,
            "max_cpu": max(window),
            "avg_cpu": sum(window) / len(window),
        })

    return summaries

class TestCpuWindows(unittest.TestCase):
    def test_partial_window(self):
        result = summarize_cpu_windows([10, 20, 99, 30], window_size=3)
        self.assertEqual(result[0]["max_cpu"], 99)
        self.assertEqual(result[1]["avg_cpu"], 30)

Nói khi làm: “The key idea is to sample more frequently than the reporting interval, then report the maximum observed value in that interval.”

4. Tail log errors

Đề: Theo dõi file log như tail -f, in dòng mới chứa ERROR.

import os
import time


def follow_errors(path: str, sleep_seconds: float = 0.1):
    with open(path, "r", encoding="utf-8") as file:
        file.seek(0, os.SEEK_END)

        while True:
            line = file.readline()
            if not line:
                time.sleep(sleep_seconds)
                continue
            if "ERROR" in line:
                yield line.rstrip("\n")

Nói khi làm: “Without the sleep, the loop would continuously poll the file and waste CPU while waiting for new lines.”

5. Sliding window rate limiter

Đề: Cho mỗi user tối đa N request trong W giây. Viết is_allowed(user_id, now).

from collections import defaultdict, deque


class RateLimiter:
    def __init__(self, limit: int, window_seconds: float):
        self.limit = limit
        self.window_seconds = window_seconds
        self.requests = defaultdict(deque)

    def is_allowed(self, user_id: str, now: float) -> bool:
        queue = self.requests[user_id]

        while queue and now - queue[0] >= self.window_seconds:
            queue.popleft()

        if len(queue) >= self.limit:
            return False

        queue.append(now)
        return True

class TestRateLimiter(unittest.TestCase):
    def test_blocks_after_limit(self):
        limiter = RateLimiter(limit=2, window_seconds=10)
        self.assertTrue(limiter.is_allowed("u1", 0))
        self.assertTrue(limiter.is_allowed("u1", 1))
        self.assertFalse(limiter.is_allowed("u1", 2))
        self.assertTrue(limiter.is_allowed("u1", 11))

Nói khi làm: “I inject the current time as a parameter because it makes the logic deterministic and easy to unit test.”

6. Top K error IPs từ JSON logs

Đề: Đọc JSON lines, đếm IP có status >= 500, trả top K.

import json
from collections import Counter


def top_error_ips(lines: list[str], k: int) -> list[tuple[str, int]]:
    counts = Counter()

    for line in lines:
        try:
            record = json.loads(line)
        except json.JSONDecodeError:
            continue

        ip = record.get("ip")
        status = int(record.get("status", 0))
        if ip and status >= 500:
            counts[ip] += 1

    return counts.most_common(k)

Nói khi làm: “I’m making the parser tolerant of bad log lines because production logs are often messy.”

7. Dependency boot order

Đề: Cho dependency map, trả thứ tự khởi động service. Nếu có cycle thì báo lỗi.

def boot_order(dependencies: dict[str, list[str]]) -> list[str]:
    order = []
    visiting = set()
    visited = set()

    def visit(service: str):
        if service in visited:
            return
        if service in visiting:
            raise ValueError(f"Cycle detected at {service}")

        visiting.add(service)
        for dependency in dependencies.get(service, []):
            visit(dependency)
        visiting.remove(service)

        visited.add(service)
        order.append(service)

    for service in dependencies:
        visit(service)

    return order

class TestBootOrder(unittest.TestCase):
    def test_dependencies_first(self):
        deps = {"api": ["db", "cache"], "db": [], "cache": []}
        self.assertEqual(boot_order(deps), ["db", "cache", "api"])

    def test_cycle(self):
        with self.assertRaises(ValueError):
            boot_order({"a": ["b"], "b": ["a"]})

Nói khi làm: “I use two sets: visiting for the current recursion path to detect cycles, and visited for completed nodes.”

8. SQL device report

Đề: Hai bảng device và user. Tổng số device theo state, platform, model. Sort state alphabetically, count giảm dần trong mỗi state.

SELECT
  u.state,
  d.platform,
  d.model,
  COUNT(*) AS total_device_count
FROM device AS d
JOIN user AS u
  ON u.user_id = d.user_id
GROUP BY
  u.state,
  d.platform,
  d.model
ORDER BY
  u.state ASC,
  total_device_count DESC;

Nói khi làm: “The grouping columns define the report granularity: state plus platform plus model. Then I sort by state ascending and count descending inside each state.”