Find Missing Observations

Find Missing Observations - Problem

You have observations of n + m 6-sided dice rolls with each face numbered from 1 to 6. n of the observations went missing, and you only have the observations of m rolls. Fortunately, you have also calculated the average value of the n + m rolls.

You are given an integer array rolls of length m where rolls[i] is the value of the i-th observation. You are also given the two integers mean and n.

Return an array of length n containing the missing observations such that the average value of the n + m rolls is exactly mean. If there are multiple valid answers, return any of them. If no such array exists, return an empty array.

The average value of a set of k numbers is the sum of the numbers divided by k.

Note: mean is an integer, so the sum of the n + m rolls should be divisible by n + m.

Input & Output

Example 1 — Valid Distribution

$ Input: rolls = [3,2,4], mean = 4, n = 2

› Output: [6,5]

💡 Note: Total sum needed is 4 × (3+2) = 20. Current sum is 3+2+4 = 9. Missing sum is 20-9 = 11. We can achieve this with [6,5] since 6+5 = 11, and final mean is (9+11)/5 = 4.

Example 2 — Impossible Case

$ Input: rolls = [1,5,6], mean = 3, n = 4

› Output: [6,1,1,1]

💡 Note: Total sum needed is 3 × (3+4) = 21. Current sum is 1+5+6 = 12. Missing sum is 21-12 = 9. With 4 dice needing sum 9, we can use [6,1,1,1] since 6+1+1+1 = 9, and final mean is (12+9)/7 = 3.

Example 3 — Minimum Values

$ Input: rolls = [1,2,3], mean = 2, n = 3

› Output: [1,1,2]

💡 Note: Total sum needed is 2 × (3+3) = 12. Current sum is 1+2+3 = 6. Missing sum is 12-6 = 6. We can achieve this with [1,1,4] or [2,2,2] or [1,1,4]. One valid solution is [1,1,4].

Constraints

m == rolls.length
1 ≤ n, m ≤ 10⁵
1 ≤ rolls[i], mean ≤ 6

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8

The key insight is to use mathematics to calculate the exact sum needed for missing observations, then distribute this sum optimally across n dice rolls. Check if solution exists by verifying n ≤ missing_sum ≤ 6n. Best approach is Mathematical Distribution with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(6^n) Space: O(n)

Try every possible combination of dice values (1-6) for the n missing observations. For each combination, calculate if it produces the desired mean when combined with existing rolls.

Mathematical Distribution

⏱️ Time: O(n) Space: O(n)

Use arithmetic to determine the exact sum needed for missing observations, then distribute this sum across n dice rolls ensuring each value is between 1-6.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 6^n possible combinations of missing rolls
For each combination, calculate total sum with existing rolls
Check if average equals target mean
Return first valid combination found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Target

Find required sum for missing observations

Generate Combinations

Try all 6^n possible dice combinations

Validate

Check if combination gives target sum

Code -

solution.c — C

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

static int result[100001];

int* solution(int* rolls, int rollsSize, int mean, int n, int* returnSize) {
    long long totalSum = (long long)mean * (n + rollsSize);
    long long currentSum = 0;
    for (int i = 0; i < rollsSize; i++) {
        currentSum += rolls[i];
    }
    long long missingSum = totalSum - currentSum;
    
    // Check if it's possible
    if (missingSum < n || missingSum > 6LL * n) {
        *returnSize = 0;
        return NULL;
    }
    
    // Start with all 1s, then distribute the remaining sum
    for (int i = 0; i < n; i++) {
        result[i] = 1;
    }
    long long remaining = missingSum - n;
    
    // Distribute remaining sum by adding to each die (max 5 more per die)
    for (int i = 0; i < n && remaining > 0; i++) {
        long long addToThis = (remaining > 5) ? 5 : remaining;
        result[i] += (int)addToThis;
        remaining -= addToThis;
    }
    
    *returnSize = n;
    return result;
}

int main() {
    char rollsStr[1000000];
    int mean, n;
    fgets(rollsStr, sizeof(rollsStr), stdin);
    scanf("%d", &mean);
    scanf("%d", &n);
    
    // Parse rolls array
    static int rolls[100000];
    int rollsSize = 0;
    
    // Remove brackets and parse
    char* ptr = rollsStr;
    // Skip whitespace and opening bracket
    while (*ptr && (*ptr == '[' || *ptr == ' ' || *ptr == '\n' || *ptr == '\t')) ptr++;
    
    // Handle empty array case
    if (*ptr == ']') {
        rollsSize = 0;
    } else {
        // Parse numbers
        while (*ptr && *ptr != ']' && *ptr != '\0') {
            // Skip whitespace
            while (*ptr == ' ' || *ptr == '\t') ptr++;
            if (*ptr == ']' || *ptr == '\0') break;
            
            // Parse number
            char* endPtr;
            int num = (int)strtol(ptr, &endPtr, 10);
            if (endPtr != ptr) {
                rolls[rollsSize++] = num;
                ptr = endPtr;
            }
            
            // Skip comma and whitespace
            while (*ptr && (*ptr == ',' || *ptr == ' ' || *ptr == '\t')) ptr++;
        }
    }
    
    int returnSize;
    int* result = solution(rolls, rollsSize, mean, n, &returnSize);
    
    if (returnSize > 0) {
        printf("[");
        for (int i = 0; i < returnSize; i++) {
            if (i > 0) printf(", ");
            printf("%d", result[i]);
        }
        printf("]\n");
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(6^n)

Generate 6^n combinations, each taking O(n) time to validate

✓ Linear Growth

Space Complexity

O(n)

Store current combination and result array

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler