Find Missing Observations - Practice Coding Problems

Find Missing Observations - Problem

The Mystery of the Missing Dice Rolls 🎲

Imagine you're analyzing data from n + m six-sided dice rolls, but disaster strikes - you've lost the records for n of them! 😱

Here's what you still have:
• An array rolls containing the values of the m dice rolls you didn't lose
• The average value of ALL n + m dice rolls (called mean)
• The number n representing how many dice rolls went missing

Your mission: Reconstruct the missing n dice roll values such that when combined with your existing m rolls, the average equals exactly mean. Each die shows a value between 1 and 6.

If it's possible to find such values, return any valid array of length n. If it's mathematically impossible, return an empty array.

Key insight: Since we know the average, we can calculate the total sum needed, then figure out how to distribute the missing values!

Input & Output

example_1.py — Basic Case

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

› Output: [6,6]

💡 Note: Current sum: 3+2+4+3 = 12. Total needed: 4×(4+2) = 24. Missing sum: 24-12 = 12. With n=2 dice, we need 12÷2 = 6 each. Since 6 is valid (1≤6≤6), return [6,6].

example_2.py — Distribution Case

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

› Output: [2,3,2,2]

💡 Note: Current sum: 1+5+6 = 12. Total needed: 3×(3+4) = 21. Missing sum: 21-12 = 9. With n=4, base = 9÷4 = 2, remainder = 1. So we get [3,2,2,2] (first die gets 2+1=3).

example_3.py — Impossible Case

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

› Output: []

💡 Note: Current sum: 1+2+3+4 = 10. Total needed: 6×(4+4) = 48. Missing sum: 48-10 = 38. But with n=4 dice, max possible is 6×4 = 24. Since 38 > 24, it's impossible.

Constraints

m == rolls.length
1 ≤ n, m ≤ 10⁵
1 ≤ rolls[i], mean ≤ 6
Each die shows a value between 1 and 6 inclusive
The solution array (if exists) should have exactly n elements

Visualization

Tap to expand

Understanding the Visualization

Calculate Missing Amount

Figure out total coins needed minus what we already have

Check Feasibility

Verify we can distribute coins with box constraints (1-6 per box)

Equal Distribution

Give each box the same base amount (missing_sum ÷ n)

Handle Leftovers

Distribute remaining coins one per box until exhausted

Key Takeaway

🎯 Key Insight: Use mathematics instead of brute force - calculate the exact sum needed, then distribute it optimally among the dice!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses mathematical calculation instead of brute force. We calculate the required sum for missing dice: missing_sum = mean × (n + m) - current_sum. Then check feasibility: n ≤ missing_sum ≤ 6n. Finally, distribute optimally using division: base value plus remainder distribution. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Distribution (Optimal)	O(n)	O(1)	Calculate required sum mathematically, then distribute values optimally among dice

Mathematical Distribution (Optimal) — Algorithm Steps

Calculate total sum needed: mean × (n + m)
Calculate current sum of existing rolls
Find required sum for missing rolls: total - current
Check if solution is possible: n ≤ required ≤ 6n
Distribute required sum optimally among n dice
Start with base value (required ÷ n), then distribute remainder

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Missing Sum

total_needed - current_sum = missing_sum

Check Feasibility

Verify n ≤ missing_sum ≤ 6n

Distribute Evenly

base = missing_sum ÷ n, remainder = missing_sum % n

Handle Remainder

First 'remainder' dice get base+1, rest get base

Code -

solution.c — C

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

int* missingRolls(int* rolls, int rollsSize, int mean, int n, int* returnSize) {
    int totalSum = mean * (n + rollsSize);
    int currentSum = 0;
    for (int i = 0; i < rollsSize; i++) {
        currentSum += rolls[i];
    }
    int missingSum = totalSum - currentSum;
    
    // Check if solution is possible
    if (missingSum < n || missingSum > 6 * n) {
        *returnSize = 0;
        return NULL;
    }
    
    // Distribute the missing sum among n dice
    int* result = (int*)malloc(n * sizeof(int));
    int baseValue = missingSum / n;
    int remainder = missingSum % n;
    
    // First 'remainder' dice get baseValue + 1
    for (int i = 0; i < remainder; i++) {
        result[i] = baseValue + 1;
    }
    
    // Remaining dice get baseValue
    for (int i = remainder; i < n; i++) {
        result[i] = baseValue;
    }
    
    *returnSize = n;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through n dice once to distribute values

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space (not counting output array)

✓ Linear Space

18.2K Views

Medium Frequency

~15 min Avg. Time

856 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

Mathematical Distribution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler