Welcome to Subscribe On Youtube

3452. Sum of Good Numbers

Description

Given an array of integers nums and an integer k, an element nums[i] is considered good if it is strictly greater than the elements at indices i - k and i + k (if those indices exist). If neither of these indices exists, nums[i] is still considered good.

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

 

Example 1:

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

Output: 12

Explanation:

The good numbers are nums[1] = 3, nums[4] = 5, and nums[5] = 4 because they are strictly greater than the numbers at indices i - k and i + k.

Example 2:

Input: nums = [2,1], k = 1

Output: 2

Explanation:

The only good number is nums[0] = 2 because it is strictly greater than nums[1].

 

Constraints:

• 2 <= nums.length <= 100
• 1 <= nums[i] <= 1000
• 1 <= k <= floor(nums.length / 2)

Solutions

Solution 1: Traversal

We can traverse the array $\textit{nums}$ and check each element $\textit{nums}[i]$ to see if it meets the conditions:

• If $i \ge k$ and $\textit{nums}[i] \le \textit{nums}[i - k]$, then $\textit{nums}[i]$ is not a good number.
• If $i + k < \textit{len}(\textit{nums})$ and $\textit{nums}[i] \le \textit{nums}[i + k]$, then $\textit{nums}[i]$ is not a good number.
• Otherwise, $\textit{nums}[i]$ is a good number, and we add it to the answer.

After traversing, we return the answer.

The time complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$. The space complexity is $O(1)$.

• Java
• C++
• Python
• Go
• TypeScript

• class Solution {
      public int sumOfGoodNumbers(int[] nums, int k) {
          int ans = 0;
          int n = nums.length;
          for (int i = 0; i < n; ++i) {
              if (i >= k && nums[i] <= nums[i - k]) {
                  continue;
              }
              if (i + k < n && nums[i] <= nums[i + k]) {
                  continue;
              }
              ans += nums[i];
          }
          return ans;
      }
  }
  
  

• class Solution {
  public:
      int sumOfGoodNumbers(vector<int>& nums, int k) {
          int ans = 0;
          int n = nums.size();
          for (int i = 0; i < n; ++i) {
              if (i >= k && nums[i] <= nums[i - k]) {
                  continue;
              }
              if (i + k < n && nums[i] <= nums[i + k]) {
                  continue;
              }
              ans += nums[i];
          }
          return ans;
      }
  };
  
  

• class Solution:
      def sumOfGoodNumbers(self, nums: List[int], k: int) -> int:
          ans = 0
          for i, x in enumerate(nums):
              if i >= k and x <= nums[i - k]:
                  continue
              if i + k < len(nums) and x <= nums[i + k]:
                  continue
              ans += x
          return ans
  
  

• func sumOfGoodNumbers(nums []int, k int) (ans int) {
  	for i, x := range nums {
  		if i >= k && x <= nums[i-k] {
  			continue
  		}
  		if i+k < len(nums) && x <= nums[i+k] {
  			continue
  		}
  		ans += x
  	}
  	return
  }
  
  

• function sumOfGoodNumbers(nums: number[], k: number): number {
      const n = nums.length;
      let ans = 0;
      for (let i = 0; i < n; ++i) {
          if (i >= k && nums[i] <= nums[i - k]) {
              continue;
          }
          if (i + k < n && nums[i] <= nums[i + k]) {
              continue;
          }
          ans += nums[i];
      }
      return ans;
  }
  
  

All Problems

All Solutions