Sum of Good Numbers - Practice Coding Problems

Sum of Good Numbers - Problem

Array Easy

In this problem, you need to identify "good" numbers in an array based on their position and neighboring elements.

Given an array of integers nums and an integer k, an element nums[i] is considered good if:

It is strictly greater than the element at index i - k (if that index exists)
AND it is strictly greater than the element at index i + k (if that index exists)
If neither of these indices exist (i.e., the element is within k positions from both ends), the element is automatically considered good

Goal: Return the sum of all good elements in the array.

Example: For nums = [1, 2, 3, 4, 5] and k = 2:

nums[0] = 1 is good (no element at index -2)
nums[1] = 2 is good (no element at index -1)
nums[2] = 3 is good if 3 > nums[0] and 3 > nums[4]

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 3, 4, 5], k = 2

› Output: 4

💡 Note: Elements 1 and 3 are good. nums[0]=1 (no i-k, no i+k within bounds), nums[2]=3 (3>1 and 3<5, but since one condition fails, it's not good). Actually, nums[0]=1 and nums[1]=2 are good because they don't have valid i-k indices.

example_2.py — All Good Case

$ Input: nums = [5, 4, 3, 2, 1], k = 1

› Output: 12

💡 Note: nums[0]=5 (no i-k, 5>4), nums[2]=3 (3>4 false), nums[4]=1 (1>2 false, no i+k). Only boundary elements and elements greater than both neighbors are good.

example_3.py — Edge Case

$ Input: nums = [10], k = 1

› Output: 10

💡 Note: Single element with no neighbors at distance k, so it's automatically good.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
-10⁹ ≤ nums[i] ≤ 10⁹
nums[i] must be strictly greater than neighbors

Visualization

Tap to expand

Understanding the Visualization

Survey Position

Stand at current mountain position and look k steps back and forward

Compare Heights

Check if current peak is taller than both distant neighbors

Handle Boundaries

If you can't see k steps away (edge of range), consider condition satisfied

Record Peak

If all conditions met, add this peak's height to your total

Key Takeaway

🎯 Key Insight: We only need one pass through the array, directly accessing k-distance neighbors in O(1) time, making this an optimal O(n) solution.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses a single pass through the array, checking each element against its k-distance neighbors. For each position i, we verify if nums[i] is strictly greater than both nums[i-k] and nums[i+k] (when these indices exist). Elements near boundaries are automatically considered good if their distant neighbors don't exist. This gives us O(n) time complexity with O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Single Pass)	O(n)	O(1)	Check each element against its k-distance neighbors in one pass

Brute Force (Single Pass) — Algorithm Steps

Iterate through each element in the array
For each element at index i, check if index i-k exists and if nums[i] > nums[i-k]
Check if index i+k exists and if nums[i] > nums[i+k]
If both conditions are satisfied (or indices don't exist), add the element to the sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the first element and check its neighbors

Check Left

Verify if current element > element at position i-k

Check Right

Verify if current element > element at position i+k

Add to Sum

If both conditions pass, add element to running sum

Code -

solution.c — C

#include <stdio.h>

int sumOfGoodNumbers(int* nums, int numsSize, int k) {
    int totalSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int isGood = 1;
        
        // Check left neighbor (i - k)
        if (i - k >= 0 && nums[i] <= nums[i - k]) {
            isGood = 0;
        }
        
        // Check right neighbor (i + k)
        if (i + k < numsSize && nums[i] <= nums[i + k]) {
            isGood = 0;
        }
        
        if (isGood) {
            totalSum += nums[i];
        }
    }
    
    return totalSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant time operations per element

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for sum and loop counter

✓ Linear Space

28.5K Views

Medium Frequency

~12 min Avg. Time

890 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 (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler