The Practical Coding Round

clean_export.pyimport csv, io
from datetime import datetime

RAW = """customer_id,name,signup_date,plan,monthly_spend
C001,Acme Ltd,2026-03-14,pro,1200
C002, Bolt Inc ,14/03/2026,Basic,300
C001,Acme Ltd,2026-03-14,pro,1200
C003,Crane & Co,March 2 2026,PRO,
C004,,2026-04-01,basic,450
C005,Delta GmbH,2026/13/40,pro,980
"""

DATE_FORMATS = ["%Y-%m-%d", "%d/%m/%Y", "%B %d %Y"]

def parse_date(text):
    for fmt in DATE_FORMATS:
        try:
            return datetime.strptime(text.strip(), fmt).date().isoformat()
        except ValueError:
            continue
    return None                      # unparseable: flag it, don't guess

def clean(raw):
    rows, problems, seen = [], [], set()
    for line_no, row in enumerate(csv.DictReader(io.StringIO(raw)), start=2):
        row = {k: (v or "").strip() for k, v in row.items()}
        key = tuple(row.values())
        if key in seen:
            problems.append((line_no, "duplicate row dropped"))
            continue
        seen.add(key)
        date = parse_date(row["signup_date"])
        if date is None:
            problems.append((line_no, f"bad date {row['signup_date']!r}"))
        if not row["name"]:
            problems.append((line_no, "missing name"))
        spend = float(row["monthly_spend"]) if row["monthly_spend"] else None
        if spend is None:
            problems.append((line_no, "missing spend"))
        rows.append({"customer_id": row["customer_id"], "name": row["name"] or None,
                     "signup_date": date, "plan": row["plan"].lower(), "monthly_spend": spend})
    return rows, problems

rows, problems = clean(RAW)
for r in rows:
    print(r)
print("--- problems ---")
for line_no, msg in problems:
    print(f"line {line_no}: {msg}")

reconcile.pyERP = [
    {"order_id": "A-100", "amount": 250.00, "status": "shipped"},
    {"order_id": "A-101", "amount": 99.50,  "status": "open"},
    {"order_id": "A-102", "amount": 410.00, "status": "shipped"},
    {"order_id": "a-103 ", "amount": 75.00, "status": "cancelled"},
]
CRM = [
    {"id": "A-100", "total": "250.00", "stage": "Shipped"},
    {"id": "A-101", "total": "99.5",   "stage": "Shipped"},
    {"id": "A-103", "total": "75.00",  "stage": "Cancelled"},
    {"id": "A-104", "total": "120.00", "stage": "Open"},
]

def norm_id(value):
    return value.strip().upper()

def reconcile(erp, crm):
    left = {norm_id(r["order_id"]): (round(r["amount"], 2), r["status"].lower()) for r in erp}
    right = {norm_id(r["id"]): (round(float(r["total"]), 2), r["stage"].lower()) for r in crm}
    report = {
        "only_in_erp": sorted(left.keys() - right.keys()),
        "only_in_crm": sorted(right.keys() - left.keys()),
        "mismatched": [],
    }
    for oid in sorted(left.keys() & right.keys()):
        if left[oid] != right[oid]:
            report["mismatched"].append((oid, left[oid], right[oid]))
    return report

report = reconcile(ERP, CRM)
print("only in ERP:", report["only_in_erp"])
print("only in CRM:", report["only_in_crm"])
for oid, erp_val, crm_val in report["mismatched"]:
    print(f"mismatch {oid}: ERP={erp_val} CRM={crm_val}")

top_errors.pyimport re
from collections import Counter

LOG = """2026-10-30 09:00:01 INFO  request id=1 path=/search
2026-10-30 09:00:02 ERROR request id=2 timeout calling vector-db after 3000ms
2026-10-30 09:00:02 ERROR request id=3 timeout calling vector-db after 3012ms
2026-10-30 09:00:03 WARN  request id=4 slow response 2100ms
2026-10-30 09:00:04 ERROR request id=5 KeyError: 'customer_id'
garbled line with no structure
2026-10-30 09:00:05 ERROR request id=6 timeout calling llm-api after 30000ms
2026-10-30 09:00:06 error request id=7 KeyError: 'plan'
2026-10-30 09:00:07 ERROR request id=8 timeout calling vector-db after 2990ms
"""

LINE = re.compile(r"^\S+ \S+ (?P<level>\w+)\s+request id=(?P<id>\d+) (?P<msg>.*)$")

def signature(msg):
    msg = re.sub(r"\d+ms", "<N>ms", msg)        # numbers vary; the cause doesn't
    msg = re.sub(r"'[^']*'", "'<field>'", msg)
    return msg

def top_errors(log, n=3):
    counts, skipped = Counter(), 0
    for line in log.splitlines():
        m = LINE.match(line)
        if not m:
            skipped += 1
            continue
        if m["level"].upper() == "ERROR":
            counts[signature(m["msg"])] += 1
    return counts.most_common(n), skipped

top, skipped = top_errors(LOG)
for msg, count in top:
    print(f"{count}  {msg}")
print(f"(skipped {skipped} unparseable line)")

flaky_api.pyimport random

rng = random.Random(7)           # fixed seed: the same "flakiness" every run
processed = {}                   # server-side store keyed by idempotency key

class TransientError(Exception):
    pass

def create_invoice(payload, idempotency_key):
    """Simulated client API: fails ~50% of the time, sometimes AFTER doing the work."""
    roll = rng.random()
    if roll < 0.3:
        raise TransientError("503 Service Unavailable")
    if idempotency_key not in processed:
        processed[idempotency_key] = {"invoice": f"INV-{len(processed) + 1}", **payload}
    if roll < 0.5:
        raise TransientError("timeout (but the invoice was created)")
    return processed[idempotency_key]

def with_retries(fn, *args, attempts=5, base=0.1, cap=2.0, sleep=lambda s: None):
    for attempt in range(1, attempts + 1):
        try:
            return fn(*args)
        except TransientError as err:
            if attempt == attempts:
                raise
            delay = rng.uniform(0, min(cap, base * 2 ** attempt))   # full jitter
            print(f"  attempt {attempt} failed ({err}); retrying in {delay:.2f}s")
            sleep(delay)

for order in ["ORD-1", "ORD-2", "ORD-3"]:
    result = with_retries(create_invoice, {"order": order}, f"invoice-{order}")
    print(order, "->", result["invoice"])
print("invoices created:", len(processed))

debug_discount.py# Someone else's function. Reported bug: "big orders get the wrong discount".
def discount_buggy(total):
    if total > 100:
        return total * 0.05
    elif total > 500:
        return total * 0.10      # never reached: 600 > 100 already matched above
    return 0

# Fixed: check the most specific (largest) threshold first, and keep money exact.
from decimal import Decimal, ROUND_HALF_UP

def discount(total):
    total = Decimal(str(total))
    if total > 500:
        rate = Decimal("0.10")
    elif total > 100:
        rate = Decimal("0.05")
    else:
        rate = Decimal("0")
    return (total * rate).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

print("buggy 600 ->", discount_buggy(600))      # 30.0, expected 60
# Tests: the failing case first, then the edges either side of each threshold.
cases = [(600, "60.00"), (100, "0.00"), (100.01, "5.00"), (500, "25.00"), (500.01, "50.00"), (0, "0.00")]
for total, expected in cases:
    got = discount(total)
    assert got == Decimal(expected), (total, got, expected)
print("all", len(cases), "tests pass")

chunker.pydef chunk(text, size=40, overlap=10):
    """Split text into word-safe chunks of <= size chars, each sharing ~overlap chars with the last."""
    if size <= 0 or not 0 <= overlap < size:
        raise ValueError("need size > 0 and 0 <= overlap < size")
    words, chunks, current = text.split(), [], []
    for word in words:
        if len(word) > size:
            raise ValueError(f"word longer than chunk size: {word[:20]}...")
        if current and len(" ".join(current + [word])) > size:
            chunks.append(" ".join(current))
            tail = []                                # carry the last ~overlap chars forward
            for w in reversed(current):
                if len(" ".join([w] + tail)) > overlap:
                    break
                tail.insert(0, w)
            current = tail
            if current and len(" ".join(current + [word])) > size:
                current = []                         # overlap would overflow: drop it
        current.append(word)
    if current:
        chunks.append(" ".join(current))
    return chunks

DOC = ("Refunds are issued within 14 days of a return. Items must be unused "
       "and in their original packaging. Sale items cannot be refunded.")

SIZE = 40
parts = chunk(DOC, size=SIZE)
for i, p in enumerate(parts):
    print(i, repr(p))

# tests
assert all(len(p) <= SIZE for p in parts)                       # size limit holds
for a, b in zip(parts, parts[1:]):                              # neighbours share text
    assert a.split()[-1] in b.split()[:3], (a, b)
words_out = " ".join(parts).split()
assert all(w in words_out for w in DOC.split())                 # no words lost
assert chunk("") == []                                          # empty input
assert chunk("one two") == ["one two"]                          # short input = one chunk
try:
    chunk("x", size=10, overlap=10)
    raise AssertionError("expected ValueError")
except ValueError:
    pass
print("all tests pass")