2090. K Radius Subarray Averages LeetCode Solution
In this guide, you will get 2090. K Radius Subarray Averages LeetCode Solution with the best time and space complexity. The solution to K Radius Subarray Averages problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.
You are given a 0-indexed array nums of n integers, and an integer k.
The k-radius average for a subarray of nums centered at some index i with the radius k is the average of all elements in nums between the indices i – k and i + k (inclusive). If there are less than k elements before or after the index i, then the k-radius average is -1.
Build and return an array avgs of length n where avgs[i] is the k-radius average for the subarray centered at index i.
The average of x elements is the sum of the x elements divided by x, using integer division. The integer division truncates toward zero, which means losing its fractional part.
For example, the average of four elements 2, 3, 1, and 5 is (2 + 3 + 1 + 5) / 4 = 11 / 4 = 2.75, which truncates to 2.
Example 1:
Input: nums = [7,4,3,9,1,8,5,2,6], k = 3
Output: [-1,-1,-1,5,4,4,-1,-1,-1]
Explanation:
– avg[0], avg[1], and avg[2] are -1 because there are less than k elements before each index.
– The sum of the subarray centered at index 3 with radius 3 is: 7 + 4 + 3 + 9 + 1 + 8 + 5 = 37.
Using integer division, avg[3] = 37 / 7 = 5.
– For the subarray centered at index 4, avg[4] = (4 + 3 + 9 + 1 + 8 + 5 + 2) / 7 = 4.
– For the subarray centered at index 5, avg[5] = (3 + 9 + 1 + 8 + 5 + 2 + 6) / 7 = 4.
– avg[6], avg[7], and avg[8] are -1 because there are less than k elements after each index.
Input: nums = [100000], k = 0
Output: [100000]
Explanation:
– The sum of the subarray centered at index 0 with radius 0 is: 100000.
avg[0] = 100000 / 1 = 100000.
Example 3:
Input: nums = [8], k = 100000
Output: [-1]
Explanation:
– avg[0] is -1 because there are less than k elements before and after index 0.
Constraints:
n == nums.length
1 <= n <= 105
0 <= nums[i], k <= 105
Complexity Analysis
Time Complexity: O(n)
Space Complexity: O(1)
2090. K Radius Subarray Averages LeetCode Solution in C++
class Solution {
public:
vector<int> getAverages(vector<int>& nums, int k) {
const int n = nums.size();
const int size = 2 * k + 1;
vector<int> ans(n, -1);
if (size > n)
return ans;
long sum = accumulate(nums.begin(), nums.begin() + size, 0L);
for (int i = k; i + k < n; ++i) {
ans[i] = sum / size;
if (i + k + 1 < n)
sum += nums[i + k + 1] - nums[i - k];
}
return ans;
}
}; /* code provided by PROGIEZ */
2090. K Radius Subarray Averages LeetCode Solution in Java
class Solution {
public int[] getAverages(int[] nums, int k) {
final int n = nums.length;
final int size = 2 * k + 1;
int[] ans = new int[n];
Arrays.fill(ans, -1);
if (size > n)
return ans;
long sum = 0;
for (int i = 0; i < size; ++i)
sum += nums[i];
for (int i = k; i + k < n; ++i) {
ans[i] = (int) (sum / size);
if (i + k + 1 < n)
sum += nums[i + k + 1] - nums[i - k];
}
return ans;
}
} // code provided by PROGIEZ
2090. K Radius Subarray Averages LeetCode Solution in Python
class Solution:
def getAverages(self, nums: list[int], k: int) -> list[int]:
n = len(nums)
size = 2 * k + 1
ans = [-1] * n
if size > n:
return ans
summ = sum(nums[:size])
for i in range(k, n - k):
ans[i] = summ // size
if i + k + 1 < n:
summ += nums[i + k + 1] - nums[i - k]
return ans # code by PROGIEZ
