Models — index & reproduction guide

int atoi_strict(const char *s, int *out) {
    const char *p = s;
    int sign = 1, val = 0;
    if (*p == '-') {
        sign = -1;
        p++;
    }
    if (!*p) return -1;   /* empty or lone "-" */
    for (; *p; p++) {
        if (*p < '0' || *p > '9') return -1;
        val = val * 10 + (*p - '0');
    }
    *out = sign * val;
    return 0;
}

int binary_search(const int *a, int n, int key) {
    int lo = 0, hi = n - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;
        if (a[mid] == key) return mid;
        if (a[mid] < key) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

#include <stdint.h>

uint32_t bswap32(uint32_t x) {
    return ((x & 0x000000FFu) << 24)
         | ((x & 0x0000FF00u) << 8)
         | ((x & 0x00FF0000u) >> 8)
         | ((x & 0xFF000000u) >> 24);
}

int cmp_desc(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    /* Overflow-safe: no subtraction. */
    return (x < y) - (x > y);
}

int count_words(const char *s) {
    int count = 0, in_word = 0;
    for (; *s; s++) {
        if (*s == ' ') {
            in_word = 0;
        } else if (!in_word) {
            in_word = 1;
            count++;
        }
    }
    return count;
}

#include <stddef.h>

int csv_field(const char *line, int idx, char *out, size_t cap) {
    const char *p = line;
    for (int field = 0; ; field++) {
        int quoted = (*p == '"');
        const char *s = p + quoted;
        const char *q = s;
        const char *end = s;
        int len = 0;
        for (;;) {
            if (quoted) {
                if (*q == 0) { end = q; break; }
                if (*q == '"') {
                    if (q[1] == '"') { len++; q += 2; }
                    else { end = q; q++; break; }
                } else { len++; q++; }
            } else {
                if (*q == 0 || *q == ',') { end = q; break; }
                len++; q++;
            }
        }
        if (field == idx) {
            int o = 0;
            for (const char *r = s; r < end && o < (int)cap - 1; ) {
                char ch = *r++;
                if (quoted && ch == '"' && *r == '"') r++;
                out[o++] = ch;
            }
            out[o] = 0;
            return len;
        }
        if (*q == 0) break;
        p = q + 1;
    }
    return -1;
}

#include <stdio.h>

const char *fizzbuzz(int n) {
    static char buf[16];
    if (n % 15 == 0) return "FizzBuzz";
    if (n % 3 == 0) return "Fizz";
    if (n % 5 == 0) return "Buzz";
    snprintf(buf, sizeof buf, "%d", n);
    return buf;
}

int glob_match(const char *pat, const char *str) {
    const char *star = 0, *ss = 0;
    while (*str) {
        if (*pat == '?' || *pat == *str) { pat++; str++; }
        else if (*pat == '*') { star = pat++; ss = str; }
        else if (star) { pat = star + 1; str = ++ss; }
        else return 0;
    }
    while (*pat == '*') pat++;
    return *pat == 0;
}

int is_prime(int n) {
    if (n <= 1) return 0;
    if (n <= 3) return 1;
    if (n % 2 == 0 || n % 3 == 0) return 0;
    for (int i = 5; i <= n / i; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return 0;
    }
    return 1;
}

void itoa(int value, char *buf) {
    char tmp[12];
    int i = 0, j = 0;
    int neg = value < 0;
    /* Unsigned arithmetic handles INT_MIN safely. */
    unsigned int u = neg ? 0u - (unsigned int)value : (unsigned int)value;
    do {
        tmp[i++] = (char)('0' + u % 10);
        u /= 10;
    } while (u);
    if (neg) buf[j++] = '-';
    while (i > 0) buf[j++] = tmp[--i];
    buf[j] = '\0';
}

int max_subarray(const int *a, int n) {
    int best = a[0], cur = a[0];
    for (int i = 1; i < n; i++) {
        cur = cur > 0 ? cur + a[i] : a[i];
        if (cur > best) best = cur;
    }
    return best;
}

int parse_csv_ints(const char *s, int *out, int max) {
    int count = 0;
    while (*s && count < max) {
        int sign = 1, val = 0;
        if (*s == '-') {
            sign = -1;
            s++;
        }
        while (*s >= '0' && *s <= '9') {
            val = val * 10 + (*s - '0');
            s++;
        }
        out[count++] = sign * val;
        if (*s == ',') s++;
    }
    return count;
}

unsigned popcount(unsigned x) {
    unsigned n = 0;
    while (x) {
        x &= x - 1;   /* clear lowest set bit */
        n++;
    }
    return n;
}

#include <stddef.h>
#include <stdlib.h>

void range_sums(const int *a, size_t n, const size_t *lo, const size_t *hi,
                size_t q, long long *out) {
    long long *pre = malloc((n + 1) * sizeof *pre);
    pre[0] = 0;
    for (size_t i = 0; i < n; i++)
        pre[i + 1] = pre[i] + a[i];
    for (size_t i = 0; i < q; i++)
        out[i] = pre[hi[i] + 1] - pre[lo[i]];
    free(pre);
}

#include <string.h>

void reverse_string(char *s) {
    size_t n = strlen(s);
    for (size_t i = 0, j = n ? n - 1 : 0; i < j; i++, j--) {
        char tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
    }
}

typedef struct { int data[8]; int head; int count; } Ring;

void ring_init(Ring *r) {
    r->head = 0;
    r->count = 0;
}

int ring_push(Ring *r, int v) {
    if (r->count == 8) return -1;
    r->data[(r->head + r->count) % 8] = v;
    r->count++;
    return 0;
}

int ring_pop(Ring *r, int *out) {
    if (r->count == 0) return -1;
    *out = r->data[r->head];
    r->head = (r->head + 1) % 8;
    r->count--;
    return 0;
}

void rot13(char *s) {
    for (; *s; s++) {
        if (*s >= 'a' && *s <= 'z') *s = (char)('a' + (*s - 'a' + 13) % 26);
        else if (*s >= 'A' && *s <= 'Z') *s = (char)('A' + (*s - 'A' + 13) % 26);
    }
}

#include <stdlib.h>
#include <string.h>

double rpn_eval(const char *expr) {
    double st[256];
    int n = 0;
    char buf[1024];
    strncpy(buf, expr, sizeof buf - 1);
    buf[sizeof buf - 1] = 0;
    for (char *tok = strtok(buf, " "); tok; tok = strtok(0, " ")) {
        char c = tok[0];
        if (tok[1] == 0 && (c == '+' || c == '-' || c == '*' || c == '/')) {
            double b = st[--n], a = st[--n];
            st[n++] = c == '+' ? a + b : c == '-' ? a - b : c == '*' ? a * b : a / b;
        } else {
            st[n++] = strtod(tok, 0);
        }
    }
    return st[0];
}

typedef struct { int data[16]; int top; } Stack;

void stack_init(Stack *s) {
    s->top = 0;
}

int stack_push(Stack *s, int v) {
    if (s->top == 16) return -1;
    s->data[s->top++] = v;
    return 0;
}

int stack_pop(Stack *s, int *out) {
    if (s->top == 0) return -1;
    *out = s->data[--s->top];
    return 0;
}

#include <string.h>

static int is_ws(char c) {
    return c == ' ' || c == '\t' || c == '\n';
}

void trim(char *s) {
    char *start = s;
    while (*start && is_ws(*start)) start++;
    char *end = start + strlen(start);
    while (end > start && is_ws(end[-1])) end--;
    size_t len = (size_t)(end - start);
    if (start != s) memmove(s, start, len);
    s[len] = '\0';
}

import csv


def csv_column_sum(path, col):
    total = 0.0
    with open(path, newline="") as f:
        for row in csv.DictReader(f):
            total += float(row[col])
    return total

def dedupe(items):
    seen = set()
    out = []
    append = out.append
    for x in items:
        if x not in seen:
            seen.add(x)
            append(x)
    return out

def deep_get(d, path, default=None):
    cur = d
    for key in path.split("."):
        if not isinstance(cur, dict) or key not in cur:
            return default
        cur = cur[key]
    return cur

def flatten(lst):
    return [x for sub in lst for x in sub]

def is_valid_ipv4(s):
    parts = s.split(".")
    if len(parts) != 4:
        return False
    for p in parts:
        if not p or not p.isdigit():
            return False
        if len(p) > 1 and p[0] == "0":
            return False
        if int(p) > 255:
            return False
    return True

def json_diff(a, b):
    out = []

    def rec(x, y, path):
        if isinstance(x, dict) and isinstance(y, dict):
            for k in sorted(set(x) | set(y)):
                p = f"{path}.{k}" if path else k
                if k not in x or k not in y:
                    out.append(p)
                else:
                    rec(x[k], y[k], p)
        elif x != y:
            out.append(path)

    rec(a, b, "")
    return sorted(out)

class LRUCache:
    def __init__(self, capacity):
        self.cap = capacity
        self.d = {}
        self.order = []  # oldest first

    def _touch(self, key):
        self.order.remove(key)
        self.order.append(key)

    def get(self, key, default=None):
        if key not in self.d:
            return default
        self._touch(key)
        return self.d[key]

    def put(self, key, value):
        if key in self.d:
            self._touch(key)
        else:
            self.order.append(key)
            if len(self.order) > self.cap:
                del self.d[self.order.pop(0)]
        self.d[key] = value

def merge_intervals(intervals):
    merged = []
    for start, end in sorted(intervals):
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

import json


def parse_json_safely(s):
    try:
        return json.loads(s)
    except (json.JSONDecodeError, TypeError):
        return None

def run_length_encode(s):
    out = []
    for ch in s:
        if out and out[-1][0] == ch:
            out[-1] = (ch, out[-1][1] + 1)
        else:
            out.append((ch, 1))
    return out

import re
from collections import Counter


def top_k_words(text, k):
    words = re.findall(r"[A-Za-z]+", text.lower())
    counts = Counter(words)
    best = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))[:k]
    return best

def topological_sort(deps):
    nodes = set(deps)
    for ds in deps.values():
        nodes.update(ds)
    remaining = {n: set(deps.get(n, [])) for n in nodes}
    order = []
    ready = [n for n in nodes if not remaining[n]]
    while ready:
        n = ready.pop()
        order.append(n)
        for m in nodes:
            if n in remaining[m]:
                remaining[m].discard(n)
                if not remaining[m]:
                    ready.append(m)
    return order if len(order) == len(nodes) else None

backup_rotate() {
  ls "$1"/backup-*.tar.gz 2>/dev/null | sort -r | tail -n +"$(( $2 + 1 ))" | sort \
    | while read -r f; do
        rm -f "$f" && basename "$f"
      done
}

count_matches() {
    grep -c -F "$1" "$2" || true
}

csv_col() {
    awk -F, -v col="$1" 'NR==1 { for (i=1; i<=NF; i++) if ($i==col) c=i; next } { print $c }'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]",)]+' | sed 's/[.,;:!?]$//'
}

find_dupes() {
  find "$1" -type f -exec md5 -r {} + | sort | awk '
    { h=$1; $1=""; sub(/^ /, ""); files[h] = files[h] " " $0; cnt[h]++ }
    END { for (h in files) if (cnt[h] > 1) print substr(files[h], 2) }
  ' | sort
}

json_get() {
    python3 -c "import json,sys; print(json.load(sys.stdin)[sys.argv[1]])" "$1"
}

largest_file() {
    find "$1" -type f -exec stat -f '%z %N' {} + | sort -rn | head -1 | cut -d' ' -f2-
}

retry3() {
    local i
    for i in 1 2 3; do
        "$@" && return 0
    done
    return 1
}

rotate() {
    [ -e "$1.1" ] && mv "$1.1" "$1.2"
    mv "$1" "$1.1"
}

sum_stdin() {
    awk 'NF { s += $1 } END { print s + 0 }'
}

top_errors() {
  grep 'ERROR: ' "$1" | sed -e 's/.*ERROR: //' -e 's/[0-9][0-9]*/#/g' \
    | sort | uniq -c | sort -k1,1nr -k2 | sed 's/^ *//' | head -n "$2"
}

top_freq() {
    sort "$1" | uniq -c | sort -k1,1nr -k2,2 | head -10 | awk '{print $1, $2}'
}