Given a circular array arr[] of N integers and an integer K, the task is to print the array after the following operations:
- If K is non-negative, then replace A[i] with the sum of the next K elements.
- If K is negative, then replace it with the sum of previous K elements.
A cyclic array means the next element of the last element of the array is the first element and the previous element of the first element is the last element.
Examples:
Input: arr[] = {4, 2, -5, 11}, K = 3
Output: 8 10 17 1
Explanation:
Step 1: For index 0, replace arr[0] = arr[1] + arr[2] + arr[3] = 2 + (-5) + 11 = 8
Step 2: For index 1, replace arr[1] = arr[2] + arr[3] + arr[0] = (-5) + 11 + 4 = 10
Step 3: For index 2, replace arr[2] = arr[3] + arr[0] + arr[1] = 11 + 4 + 2 = 17
Step 4: For index 3, replace arr[3] = arr[0] + arr[1] + arr[2] = 4 + 2 + -5 = 1
Therefore, the resultant array is {8, 10, 17, 1}
Input: arr[] = {2, 5, 7, 9}, K = -2
Output: 16 11 7 12
Explanation:
Step 1: For index 0, replace arr[0] = arr[3] + arr[2] = 9 + 7 = 16
Step 2: For index 1, replace arr[1] = arr[0] + arr[3] = 2 + 9 = 11
Step 3: For index 2, replace arr[2] = arr[1] + arr[0] = 5 + 2 = 7
Step 4: For index 3, replace arr[3] = arr[2] + arr[1] = 7 + 5 = 12
Therefore, the resultant array is {16, 11, 7, 12}
Naive Approach: The simplest approach to solve the problem is to traverse the array and traverse the next or previous K elements, based on the value of K, for every array element and print their sum. Follow the steps below to solve the problem:
- If the value of K is negative, then reverse the array and find the sum of the next K elements.
- If the value of K is non-negative, then simply find the sum of the next K elements for each element.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
vector<int> sumOfKelementsUtil(
vector<int>& a, int x)
{
int n = a.size();
int count, k, temp;
vector<int> ans;
for (int i = 0; i < n; i++) {
count = 0;
k = i + 1;
temp = 0;
while (count < x) {
temp += a[k % n];
count++;
k++;
}
ans.pb(temp);
}
return ans;
}
void sumOfKelements(vector<int>& arr,
int K)
{
int N = (int)arr.size();
vector<int> ans;
if (K < 0) {
K = K * (-1);
reverse(arr.begin(),
arr.end());
ans = sumOfKelementsUtil(arr, K);
reverse(ans.begin(), ans.end());
}
else {
ans = sumOfKelementsUtil(arr, K);
}
for (int i = 0; i < N; i++) {
cout << ans[i] << " ";
}
}
int main()
{
vector<int> arr = { 4, 2, -5, 11 };
int K = 3;
sumOfKelements(arr, K);
return 0;
}
|
Java
import java.util.*;
class GFG{
static Vector<Integer> reverse(Vector<Integer> a)
{
int i, n = a.size(), t;
for (i = 0; i < n / 2; i++)
{
t = a.elementAt(i);
a.set(i, a.elementAt(n - i - 1));
a.set(n - i - 1, t);
}
return a;
}
static Vector<Integer> sumOfKelementsUtil(
Vector<Integer>a, int x)
{
int n = a.size();
int count, k, temp;
Vector<Integer> ans = new Vector<>();
for (int i = 0; i < n; i++)
{
count = 0;
k = i + 1;
temp = 0;
while (count < x)
{
temp += a.elementAt(k % n);
count++;
k++;
}
ans.add(temp);
}
return ans;
}
static void sumOfKelements(Vector<Integer> arr,
int K)
{
int N = (int)arr.size();
Vector<Integer> ans = new Vector<>();
if (K < 0)
{
K = K * (-1);
arr = reverse(arr);
ans = sumOfKelementsUtil(arr, K);
ans = reverse(ans);
}
else
{
ans = sumOfKelementsUtil(arr, K);
}
for (int i = 0; i < N; i++)
{
System.out.print(ans.elementAt(i) + " ");
}
}
public static void main(String[] args)
{
Vector<Integer> arr = new Vector<>();
arr.add(4);
arr.add(2);
arr.add(-5);
arr.add(11);
int K = 3;
sumOfKelements(arr, K);
}
}
|
Python3
def sumOfKelementsUtil(a, x):
n = len(a)
ans = []
for i in range(n):
count = 0
k = i + 1
temp = 0
while (count < x):
temp += a[k % n]
count += 1
k += 1
ans.append(temp)
return ans
def sumOfKelements(arr, K):
N = len(arr)
ans = []
if (K < 0):
K = K * (-1)
arr.reverse()
ans = sumOfKelementsUtil(arr, K)
ans.reverse()
else:
ans = sumOfKelementsUtil(arr, K)
for i in range(N):
print (ans[i], end = " ")
if __name__ == "__main__":
arr = [4, 2, -5, 11]
K = 3
sumOfKelements(arr, K)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static List<int> reverse(List<int> a)
{
int i, n = a.Count, t;
for (i = 0; i < n / 2; i++)
{
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
return a;
}
static List<int> sumOfKelementsUtil(
List<int>a, int x)
{
int n = a.Count;
int count, k, temp;
List<int> ans = new List<int>();
for (int i = 0; i < n; i++)
{
count = 0;
k = i + 1;
temp = 0;
while (count < x)
{
temp += a[k % n];
count++;
k++;
}
ans.Add(temp);
}
return ans;
}
static void sumOfKelements(List<int> arr,
int K)
{
int N = (int)arr.Count;
List<int> ans = new List<int>();
if (K < 0)
{
K = K * (-1);
arr = reverse(arr);
ans = sumOfKelementsUtil(arr, K);
ans = reverse(ans);
}
else
{
ans = sumOfKelementsUtil(arr, K);
}
for (int i = 0; i < N; i++)
{
Console.Write(ans[i] + " ");
}
}
public static void Main(String[] args)
{
List<int> arr = new List<int>();
arr.Add(4);
arr.Add(2);
arr.Add(-5);
arr.Add(11);
int K = 3;
sumOfKelements(arr, K);
}
}
|
Javascript
<script>
function sumOfKElements(
arr, n, k)
{
let rev = false;
if (k < 0) {
rev = true;
k *= -1;
let l = 0, r = n - 1;
while (l < r) {
let tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
let dp = Array.from({length: n}, (_, i) => 0);
dp[0] = arr[0];
for (let i = 1; i < n; i++) {
dp[i] += dp[i - 1] + arr[i];
}
let ans = Array.from({length: n}, (_, i) => 0);
for (let i = 0; i < n; i++) {
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else {
let x = k - (n - 1 - i);
let y = Math.floor(x / n);
let rem = x % n;
ans[i] = dp[n - 1]
- dp[i]
+ y * dp[n - 1]
+ (rem - 1 >= 0 ? dp[rem - 1] : 0);
}
}
if (rev) {
for (let i = n - 1; i >= 0; i--) {
document.write(ans[i] + " ");
}
}
else {
for (let i = 0; i < n; i++) {
document.write(ans[i] + " ");
}
}
}
let arr = [ 4, 2, -5, 11 ];
let N = arr.length;
let K = 3;
sumOfKElements(arr, N, K);
</script>
|
Time Complexity: O(N*K), where N is the length of the given array and K is the given integer.
Auxiliary Space: O(N)
Efficient Approach: To optimize the above approach, the idea is to use prefix sum. Follow the steps below to solve the problem:
- If K is negative, reverse the given array and multiply K with -1.
- Compute and store the prefix sum of the given array in pre[].
- Create the array ans[] to store the answer for each element.
- For every index i, if i + K is smaller than N, then update ans[i] = pre[i + k] – pre[i]
- Otherwise, add the sum of all the elements from index i to N – 1, find remaining K – (N – 1 – i) elements because (N – 1 – i) elements are already added in the above step.
- Add the sum of all elements floor((K – N – 1 – i)/N) times and the sum of remaining elements of the given array from 0 to ((K – (N – 1 – i)) % N) – 1.
- After calculating the answer for each element of the array, check if the array was reversed previously. If yes, reverse the ans[] array.
- Print all the elements stored in the array ans[] after the above steps.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
void sumOfKElements(int arr[], int n,
int k)
{
bool rev = false;
if (k < 0)
{
rev = true;
k *= -1;
int l = 0, r = n - 1;
while (l < r)
{
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
int dp[n] = {0};
dp[0] = arr[0];
for(int i = 1; i < n; i++)
{
dp[i] += dp[i - 1] + arr[i];
}
int ans[n] = {0};
for(int i = 0; i < n; i++)
{
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else
{
int x = k - (n - 1 - i);
int y = x / n;
int rem = x % n;
ans[i] = dp[n - 1] - dp[i] +
y * dp[n - 1] + (rem - 1 >= 0 ?
dp[rem - 1] : 0);
}
}
if (rev)
{
for(int i = n - 1; i >= 0; i--)
{
cout << ans[i] << " ";
}
}
else
{
for(int i = 0; i < n; i++)
{
cout << ans[i] << " ";
}
}
}
int main()
{
int arr[] = { 4, 2, -5, 11 };
int N = sizeof(arr) / sizeof(arr[0]);
int K = 3;
sumOfKElements(arr, N, K);
}
|
Java
import java.io.*;
class GFG {
static void sumOfKElements(
int arr[], int n, int k)
{
boolean rev = false;
if (k < 0) {
rev = true;
k *= -1;
int l = 0, r = n - 1;
while (l < r) {
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
int dp[] = new int[n];
dp[0] = arr[0];
for (int i = 1; i < n; i++) {
dp[i] += dp[i - 1] + arr[i];
}
int ans[] = new int[n];
for (int i = 0; i < n; i++) {
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else {
int x = k - (n - 1 - i);
int y = x / n;
int rem = x % n;
ans[i] = dp[n - 1]
- dp[i]
+ y * dp[n - 1]
+ (rem - 1 >= 0 ? dp[rem - 1] : 0);
}
}
if (rev) {
for (int i = n - 1; i >= 0; i--) {
System.out.print(ans[i] + " ");
}
}
else {
for (int i = 0; i < n; i++) {
System.out.print(ans[i] + " ");
}
}
}
public static void main(String[] args)
{
int arr[] = { 4, 2, -5, 11 };
int N = arr.length;
int K = 3;
sumOfKElements(arr, N, K);
}
}
|
Python3
def sumOfKElements(arr, n, k):
rev = False;
if (k < 0):
rev = True;
k *= -1;
l = 0;
r = n - 1;
while (l < r):
tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l += 1;
r -= 1;
dp = [0] * n;
dp[0] = arr[0];
for i in range(1, n):
dp[i] += dp[i - 1] + arr[i];
ans = [0] * n;
for i in range(n):
if (i + k < n):
ans[i] = dp[i + k] - dp[i];
else:
x = k - (n - 1 - i);
y = x // n;
rem = x % n;
ans[i] = (dp[n - 1] - dp[i] +
y * dp[n - 1] +
(dp[rem - 1]
if rem - 1 >= 0
else 0));
if (rev):
for i in range(n - 1, -1, -1):
print(ans[i], end = " ");
else:
for i in range(n):
print(ans[i], end = " ");
if __name__ == '__main__':
arr = [4, 2, -5, 11];
N = len(arr);
K = 3;
sumOfKElements(arr, N, K);
|
C#
using System;
class GFG {
static void sumOfKElements(int []arr,
int n, int k)
{
bool rev = false;
if (k < 0)
{
rev = true;
k *= -1;
int l = 0, r = n - 1;
while (l < r)
{
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
int []dp = new int[n];
dp[0] = arr[0];
for (int i = 1; i < n; i++)
{
dp[i] += dp[i - 1] + arr[i];
}
int []ans = new int[n];
for (int i = 0; i < n; i++)
{
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else
{
int x = k - (n - 1 - i);
int y = x / n;
int rem = x % n;
ans[i] = dp[n - 1] - dp[i] +
y * dp[n - 1] +
(rem - 1 >= 0 ?
dp[rem - 1] : 0);
}
}
if (rev)
{
for (int i = n - 1; i >= 0; i--)
{
Console.Write(ans[i] + " ");
}
}
else
{
for (int i = 0; i < n; i++)
{
Console.Write(ans[i] + " ");
}
}
}
public static void Main(String[] args)
{
int []arr = {4, 2, -5, 11};
int N = arr.Length;
int K = 3;
sumOfKElements(arr, N, K);
}
}
|
Javascript
<script>
function sumOfKElements(arr, n,
k)
{
let rev = false;
if (k < 0)
{
rev = true;
k *= -1;
let l = 0, r = n - 1;
while (l < r)
{
let tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
let dp = new Uint8Array(n);
dp[0] = arr[0];
for(let i = 1; i < n; i++)
{
dp[i] += dp[i - 1] + arr[i];
}
let ans = new Uint8Array(n);
for(let i = 0; i < n; i++)
{
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else
{
let x = k - (n - 1 - i);
let y = Math.floor(x / n);
let rem = x % n;
ans[i] = dp[n - 1] - dp[i] +
y * dp[n - 1] + (rem - 1 >= 0 ?
dp[rem - 1] : 0);
}
}
if (rev)
{
for(let i = n - 1; i >= 0; i--)
{
document.write(ans[i] + " ");
}
}
else
{
for(let i = 0; i < n; i++)
{
document.write(ans[i] + " ");
}
}
}
let arr = [ 4, 2, -5, 11 ];
let N = arr.length;
let K = 3;
sumOfKElements(arr, N, K);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)