Programming Fundamentals and Code Quality Questions

from collections import defaultdict
from math import fsum
from typing import List, Dict

def weighted_avg_by_label(rows: List[Dict]) -> Dict[str, float]:
    """
    rows: list of dicts with keys 'label', 'value', 'count'
    returns: dict mapping label -> weighted average value
    """
    weighted = defaultdict(lambda: [0.0, 0.0])  # label -> [weighted_sum, total_count]

    for r in rows:
        label = r.get('label')
        try:
            value = float(r.get('value', 0.0))
            count = float(r.get('count', 0.0))
        except (TypeError, ValueError):
            # skip malformed rows or handle as needed
            continue

        if count <= 0:
            continue  # ignore zero/negative sample counts

        weighted[label][0] += value * count
        weighted[label][1] += count

    # compute averages; handle labels with zero total count defensively
    result = {}
    for label, (w_sum, tot) in weighted.items():
        result[label] = (fsum([w_sum]) / tot) if tot else float('nan')

    return result

# Example:
# rows = [{'label':'cat','value':10,'count':3}, {'label':'cat','value':20,'count':2}, {'label':'dog','value':5,'count':4}]
# weighted_avg_by_label(rows) -> {'cat': 14.0, 'dog': 5.0}

// cpp
#include <atomic>

class AtomicCounter {
public:
    AtomicCounter(long initial = 0) : value(initial) {}
    // Increment and return new value
    long increment() noexcept { return value.fetch_add(1, std::memory_order_relaxed) + 1; }
    // Read current value
    long get() const noexcept { return value.load(std::memory_order_relaxed); }
private:
    std::atomic<long> value;
};

// cpp
#include <mutex>

class MutexCounter {
public:
    MutexCounter(long initial = 0) : value(initial) {}
    long increment() {
        std::lock_guard<std::mutex> lk(m);
        return ++value;
    }
    long get() {
        std::lock_guard<std::mutex> lk(m);
        return value;
    }
private:
    long value;
    mutable std::mutex m;
};

def normalize_token(token):
    """Trim and lowercase a single token; return None for empty or None."""
    if token is None:
        return None
    token = token.strip().lower()
    return token if token else None

def clean_and_normalize(data):
    """Validate input and return a new list of normalized tokens (None removed)."""
    if not isinstance(data, (list, tuple)):
        raise TypeError("data must be a list or tuple of strings")
    return [t for t in (normalize_token(x) for x in data) if t is not None]

def unique_preserve_order(items):
    """Return unique items preserving original order using a set for O(n) behavior."""
    seen = set()
    result = []
    for it in items:
        if it not in seen:
            seen.add(it)
            result.append(it)
    return result

def process(data):
    """Public API: clean, normalize, and deduplicate a sequence of strings."""
    normalized = clean_and_normalize(data)
    return unique_preserve_order(normalized)

import heapq
import os
import tempfile
import struct

def create_runs(input_path, mem_bytes):
    runs=[]
    buf=[]
    cur_size=0
    with open(input_path,'rb') as f:
        while True:
            chunk=f.read(4096)
            if not chunk: break
            # example assumes newline-separated integers as text for clarity
            for line in chunk.decode().splitlines():
                if not line: continue
                v=int(line)
                buf.append(v)
                cur_size+=v.__sizeof__()
                if cur_size>=mem_bytes*0.8:
                    buf.sort()
                    p=tempfile.NamedTemporaryFile(delete=False, mode='wb')
                    for x in buf:
                        p.write((str(x)+"\n").encode())
                    p.close()
                    runs.append(p.name)
                    buf=[]; cur_size=0
        if buf:
            buf.sort()
            p=tempfile.NamedTemporaryFile(delete=False, mode='wb')
            for x in buf: p.write((str(x)+"\n").encode())
            p.close(); runs.append(p.name)
    return runs

def k_way_merge(run_files, out_path, buf_size=1<<20):
    # open all runs and create iterators that yield batches
    files=[open(r,'rb') for r in run_files]
    def gen(f):
        while True:
            data=f.readline()
            if not data: break
            yield int(data.decode().strip())
    iterators=[gen(f) for f in files]
    heap=[]
    for i,it in enumerate(iterators):
        try:
            v=next(it)
            heap.append((v,i))
        except StopIteration:
            pass
    heapq.heapify(heap)
    with open(out_path,'wb') as out:
        while heap:
            v,i = heapq.heappop(heap)
            out.write((str(v)+"\n").encode())
            try:
                nv = next(iterators[i])
                heapq.heappush(heap,(nv,i))
            except StopIteration:
                pass
    for f in files: f.close()