Missing Number In Arithmetic Progression - Practice Coding Problems

Missing Number In Arithmetic Progression - Problem

Array Math Easy

Imagine you have a sequence of numbers that follow a perfect arithmetic pattern - like stepping stones placed at equal distances. But one stone has gone missing!

You're given an array arr that originally contained numbers in arithmetic progression, meaning the difference between consecutive numbers was constant. For example, in the sequence [2, 4, 6, 8, 10], the common difference is 2.

However, one number has been removed from somewhere in the middle (never the first or last element). Your task is to find this missing number.

Goal: Return the missing number that would complete the arithmetic progression.

Input: An array with one missing element from an arithmetic sequence
Output: The missing number as an integer

Example: If the original sequence was [1, 3, 5, 7, 9] and 5 was removed, you'd get [1, 3, 7, 9]. The answer would be 5.

Input & Output

example_1.py — Basic Case

$ Input: [1, 3, 7, 9]

› Output: 5

💡 Note: The original arithmetic progression was [1, 3, 5, 7, 9] with common difference 2. The number 5 was removed, so we return 5.

example_2.py — Negative Numbers

$ Input: [15, 13, 9, 7]

› Output: 11

💡 Note: The original sequence was [15, 13, 11, 9, 7] with common difference -2. The missing number 11 was removed.

example_3.py — Larger Differences

$ Input: [5, 15, 25, 45]

› Output: 35

💡 Note: Original sequence: [5, 15, 25, 35, 45] with common difference 10. The number 35 is missing.

Visualization

Tap to expand

Understanding the Visualization

Measure the Total Distance

Calculate the span from first to last stone: 9 - 1 = 8 units

Find Expected Step Size

With 4 stones visible, there should be 5 total with 4 gaps: 8 ÷ 4 = 2 units per step

Walk and Check Each Gap

Step 1→3: 2 units ✓, Step 3→7: 4 units ✗ (too big!), Step 7→9: 2 units ✓

Find the Missing Stone

The gap of 4 should be two steps of 2, so missing stone is at 3 + 2 = 5

Key Takeaway

🎯 Key Insight: In any arithmetic progression with one missing element, that missing element creates exactly one gap that's twice the normal step size. Use the mathematical formula to calculate the expected step, then find where this pattern breaks!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to find the position where the pattern breaks

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 1000
The missing element is never the first or last element
arr represents an arithmetic progression with one missing element
All elements in arr are unique integers
-10⁶ ≤ arr[i] ≤ 10⁶

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses the mathematical property of arithmetic progressions. Calculate the expected common difference as (last - first) / n and scan for where the pattern breaks. This gives us O(n) time and O(1) space complexity, making it much more efficient than brute force approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Formula (Optimal)	O(n)	O(1)	Use arithmetic progression formula to calculate expected common difference
Brute Force (Check All Pairs)	O(n²)	O(1)	Find the common difference by checking all consecutive pairs, then locate the gap

Mathematical Formula (Optimal) — Algorithm Steps

Calculate expected common difference using (last - first) / length
Scan through array to find where consecutive difference ≠ expected
The missing number is at the position where the gap is too large
Return first_element + expected_diff × position

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Expected Difference

Use formula: (last - first) / n where n is current length

Scan for Pattern Break

Find where consecutive difference doesn't match expected

Identify Missing Position

The gap indicates where the missing number should be

Calculate Missing Value

Add expected difference to the previous number

Code -

solution.c — C

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

int missingNumber(int* arr, int n) {
    // Calculate expected common difference
    int expectedDiff = (arr[n-1] - arr[0]) / n;
    
    // Find where pattern breaks
    for (int i = 0; i < n - 1; i++) {
        if (arr[i + 1] - arr[i] != expectedDiff) {
            return arr[i] + expectedDiff;
        }
    }
    
    return -1;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int arr[100];
    int n = 0;
    char* token = strtok(input, "[,]\n");
    while (token != NULL && n < 100) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[,]\n");
    }
    
    printf("%d\n", missingNumber(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to find the position where the pattern breaks

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 1000
The missing element is never the first or last element
arr represents an arithmetic progression with one missing element
All elements in arr are unique integers
-10⁶ ≤ arr[i] ≤ 10⁶

67.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Formula (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler