Constraints

• 0 <= len(rows) <= 200000
• -10^15 <= actual_revenue, predicted_revenue <= 10^15
• Weights may be omitted; missing countries default to weight 1.0
• Rows with actual_revenue <= 0, predicted_revenue < 0, or weight <= 0 must be ignored

Examples

Solution

def solution(rows, weights=None):
    import math

    if weights is None:
        weights = {}

    weighted_sq_errors = []
    weight_values = []

    for country, actual, predicted in rows:
        w = float(weights.get(country, 1.0))
        actual = float(actual)
        predicted = float(predicted)

        if actual <= 0.0 or predicted < 0.0 or w <= 0.0:
            continue

        rel = (predicted - actual) / actual
        weighted_sq_errors.append(w * rel * rel)
        weight_values.append(w)

    total_weight = math.fsum(weight_values)
    if total_weight == 0.0:
        return None

    mean_sq = math.fsum(weighted_sq_errors) / total_weight
    return round(math.sqrt(mean_sq), 12)

Time complexity: O(n). Space complexity: O(n).

Hints

1. The expression predicted / actual - 1 is algebraically equal to (predicted - actual) / actual, but the second form is numerically safer when predicted is very close to actual.
2. Filter invalid rows first, then compute a weighted mean of squared relative errors.

Constraints

• 0 <= len(rows) <= 5000
• 1 <= B <= 5000
• 0 <= seed <= 10^9
• Use n-of-n resampling, where n is the count of valid rows after filtering
• Rows with actual_revenue <= 0, predicted_revenue < 0, or weight <= 0 must be ignored before bootstrapping

Examples

Solution

def solution(rows, B, seed, weights=None):
    import math

    if weights is None:
        weights = {}

    valid = []
    for country, actual, predicted in rows:
        w = float(weights.get(country, 1.0))
        actual = float(actual)
        predicted = float(predicted)
        if actual > 0.0 and predicted >= 0.0 and w > 0.0:
            valid.append((country, actual, predicted, w))

    n = len(valid)
    if n == 0 or B <= 0:
        return None

    def prmse(sample):
        weighted_sq_errors = []
        weight_values = []
        for _, actual, predicted, w in sample:
            rel = (predicted - actual) / actual
            weighted_sq_errors.append(w * rel * rel)
            weight_values.append(w)
        total_weight = math.fsum(weight_values)
        return math.sqrt(math.fsum(weighted_sq_errors) / total_weight)

    estimate = prmse(valid)

    state = seed % 97
    boot = []
    for _ in range(B):
        sample = []
        for _ in range(n):
            state = (17 * state + 43) % 97
            idx = state % n
            sample.append(valid[idx])
        boot.append(prmse(sample))

    boot.sort()
    low_idx = max(0, int(math.floor(0.025 * B)))
    high_idx = min(B - 1, int(math.ceil(0.975 * B)) - 1)

    return (round(estimate, 6), round(boot[low_idx], 6), round(boot[high_idx], 6))

Time complexity: O(B * n). Space complexity: O(B + n).

Hints

1. Resample from the filtered valid rows, not from the raw input.
2. Store all bootstrap estimates, sort them, then pick the two required order-statistic positions.

Constraints

• 0 <= n <= 100
• For n > 0, the exact probability is 1 / n^n
• The fraction should be reduced

Examples

Solution

def solution(n):
    if n < 0:
        return None
    if n == 0:
        return (1, 1)
    return (1, pow(n, n))

Time complexity: O(log n) arithmetic operations for exponentiation. Space complexity: O(1) auxiliary space.

Hints

1. Each of the n positions in the resample must pick one specific original item.
2. There is exactly one successful ordered resample out of n^n equally likely ordered resamples when n > 0.

Constraints

• 0 <= len(rows) <= 200000
• Use only valid rows with actual_revenue > 0 and predicted_revenue >= 0
• Recommendation labels must be unique and sorted lexicographically
• Median is the middle value after sorting, or the average of the two middle values for an even number of items

Examples

Solution

def solution(rows, min_valid=5, tail_ratio=25.0, imbalance_threshold=0.6):
    valid = []
    for country, region, actual, predicted in rows:
        actual = float(actual)
        predicted = float(predicted)
        if actual > 0.0 and predicted >= 0.0:
            valid.append((country, region, actual, predicted))

    if not valid:
        return ['insufficient_data']

    recommendations = set()
    n = len(valid)

    if n < min_valid:
        recommendations.add('collect_more_data')

    errors = []
    region_counts = {}
    region_countries = {}

    for country, region, actual, predicted in valid:
        rel = (predicted - actual) / actual
        errors.append(rel * rel)
        region_counts[region] = region_counts.get(region, 0) + 1
        region_countries.setdefault(region, set()).add(country)

    errors.sort()
    m = len(errors)
    if m % 2 == 1:
        median = errors[m // 2]
    else:
        median = (errors[m // 2 - 1] + errors[m // 2]) / 2.0
    max_error = errors[-1]

    if (median == 0.0 and max_error > 0.0) or (median > 0.0 and max_error / median >= tail_ratio):
        recommendations.add('winsorize_or_log_transform')
        recommendations.add('report_robust_metric')

    for region, countries in region_countries.items():
        if region_counts[region] >= 2 and len(countries) >= 2:
            recommendations.add('cluster_bootstrap_by_region')
            break

    if len(region_counts) >= 2:
        max_share = max(region_counts.values()) / n
        if max_share > imbalance_threshold:
            recommendations.add('stratified_bootstrap_by_region')

    return sorted(recommendations)

Time complexity: O(n log n). Space complexity: O(n).

Hints

1. Start by filtering valid rows; every later rule should use the filtered data only.
2. Heavy tails can be detected by comparing the largest squared relative error against the median, while dependence and imbalance come from region counts and distinct country counts.