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++ program for the above approach #include <bits/stdc++.h> using namespace std;
#define pb push_back // Function to find the sum of next // or previous k array elements vector< int > sumOfKelementsUtil(
vector< int >& a, int x)
{ // Size of the array
int n = a.size();
int count, k, temp;
// Stores the result
vector< int > ans;
// Iterate the given array
for ( int i = 0; i < n; i++) {
count = 0;
k = i + 1;
temp = 0;
// Traverse the k elements
while (count < x) {
temp += a[k % n];
count++;
k++;
}
// Push the K elements sum
ans.pb(temp);
}
// Return the resultant vector
return ans;
} // Function that prints the sum of next // K element for each index in the array void sumOfKelements(vector< int >& arr,
int K)
{ // Size of the array
int N = ( int )arr.size();
// Stores the result
vector< int > ans;
// If key is negative,
// reverse the array
if (K < 0) {
K = K * (-1);
// Reverse the array
reverse(arr.begin(),
arr.end());
// Find the resultant vector
ans = sumOfKelementsUtil(arr, K);
// Reverse the array again to
// get the original sequence
reverse(ans.begin(), ans.end());
}
// If K is positive
else {
ans = sumOfKelementsUtil(arr, K);
}
// Print the answer
for ( int i = 0; i < N; i++) {
cout << ans[i] << " " ;
}
} // Driver Code int main()
{ // Given array arr[]
vector< int > arr = { 4, 2, -5, 11 };
int K = 3;
// Function Call
sumOfKelements(arr, K);
return 0;
} |
// Java program for // the above approach import java.util.*;
class GFG{
//reverse array 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;
} // Function to find the sum of next // or previous k array elements static Vector<Integer> sumOfKelementsUtil(
Vector<Integer>a, int x)
{ // Size of the array
int n = a.size();
int count, k, temp;
// Stores the result
Vector<Integer> ans = new Vector<>();
// Iterate the given array
for ( int i = 0 ; i < n; i++)
{
count = 0 ;
k = i + 1 ;
temp = 0 ;
// Traverse the k elements
while (count < x)
{
temp += a.elementAt(k % n);
count++;
k++;
}
// Push the K elements sum
ans.add(temp);
}
// Return the resultant vector
return ans;
} // Function that prints the sum of next // K element for each index in the array static void sumOfKelements(Vector<Integer> arr,
int K)
{ // Size of the array
int N = ( int )arr.size();
// Stores the result
Vector<Integer> ans = new Vector<>();
// If key is negative,
// reverse the array
if (K < 0 )
{
K = K * (- 1 );
// Reverse the array
arr = reverse(arr);
// Find the resultant vector
ans = sumOfKelementsUtil(arr, K);
// Reverse the array again to
// get the original sequence
ans = reverse(ans);
}
// If K is positive
else
{
ans = sumOfKelementsUtil(arr, K);
}
// Print the answer
for ( int i = 0 ; i < N; i++)
{
System.out.print(ans.elementAt(i) + " " );
}
} // Driver Code public static void main(String[] args)
{ // Given array arr[]
Vector<Integer> arr = new Vector<>();
arr.add( 4 );
arr.add( 2 );
arr.add(- 5 );
arr.add( 11 );
int K = 3 ;
// Function Call
sumOfKelements(arr, K);
} } // This code is contributed by gauravrajput1 |
# Python3 program for # the above approach # Function to find the sum of next # or previous k array elements def sumOfKelementsUtil(a, x):
# Size of the array
n = len (a)
# Stores the result
ans = []
# Iterate the given array
for i in range (n):
count = 0
k = i + 1
temp = 0
# Traverse the k elements
while (count < x):
temp + = a[k % n]
count + = 1
k + = 1
# Push the K elements sum
ans.append(temp)
# Return the resultant vector
return ans
# Function that prints the # sum of next K element for # each index in the array def sumOfKelements(arr, K):
# Size of the array
N = len (arr)
#Stores the result
ans = []
# If key is negative,
# reverse the array
if (K < 0 ):
K = K * ( - 1 )
# Reverse the array
arr.reverse()
# Find the resultant vector
ans = sumOfKelementsUtil(arr, K)
#Reverse the array again to
# get the original sequence
ans.reverse()
# If K is positive
else :
ans = sumOfKelementsUtil(arr, K)
# Print the answer
for i in range (N):
print (ans[i], end = " " )
# Driver Code if __name__ = = "__main__" :
# Given array arr[]
arr = [ 4 , 2 , - 5 , 11 ]
K = 3
# Function Call
sumOfKelements(arr, K)
# This code is contributed by Chitranayal |
// C# program for // the above approach using System;
using System.Collections.Generic;
class GFG{
// Reverse array 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;
} // Function to find the sum of next // or previous k array elements static List< int > sumOfKelementsUtil(
List< int >a, int x)
{ // Size of the array
int n = a.Count;
int count, k, temp;
// Stores the result
List< int > ans = new List< int >();
// Iterate the given array
for ( int i = 0; i < n; i++)
{
count = 0;
k = i + 1;
temp = 0;
// Traverse the k elements
while (count < x)
{
temp += a[k % n];
count++;
k++;
}
// Push the K elements sum
ans.Add(temp);
}
// Return the resultant vector
return ans;
} // Function that prints the sum of next // K element for each index in the array static void sumOfKelements(List< int > arr,
int K)
{ // Size of the array
int N = ( int )arr.Count;
// Stores the result
List< int > ans = new List< int >();
// If key is negative,
// reverse the array
if (K < 0)
{
K = K * (-1);
// Reverse the array
arr = reverse(arr);
// Find the resultant vector
ans = sumOfKelementsUtil(arr, K);
// Reverse the array again to
// get the original sequence
ans = reverse(ans);
}
// If K is positive
else
{
ans = sumOfKelementsUtil(arr, K);
}
// Print the answer
for ( int i = 0; i < N; i++)
{
Console.Write(ans[i] + " " );
}
} // Driver Code public static void Main(String[] args)
{ // Given array []arr
List< int > arr = new List< int >();
arr.Add(4);
arr.Add(2);
arr.Add(-5);
arr.Add(11);
int K = 3;
// Function Call
sumOfKelements(arr, K);
} } // This code is contributed by Rajput-Ji |
<script> // JavaScript program for the above approach // Function to print the
// required resultant array
function sumOfKElements(
arr, n, k)
{
// Reverse the array
let rev = false ;
if (k < 0) {
rev = true ;
k *= -1;
let l = 0, r = n - 1;
// Traverse the range
while (l < r) {
let tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
// Store prefix sum
let dp = Array.from({length: n}, (_, i) => 0);
dp[0] = arr[0];
// Find the prefix sum
for (let i = 1; i < n; i++) {
dp[i] += dp[i - 1] + arr[i];
}
// Store the answer
let ans = Array.from({length: n}, (_, i) => 0);
// Calculate the answers
for (let i = 0; i < n; i++) {
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else {
// Count of remaining elements
let x = k - (n - 1 - i);
// Add the sum of all elements
// y times
let y = Math.floor(x / n);
// Add the remaining elements
let rem = x % n;
// Update ans[i]
ans[i] = dp[n - 1]
- dp[i]
+ y * dp[n - 1]
+ (rem - 1 >= 0 ? dp[rem - 1] : 0);
}
}
// If array is reversed print
// ans[] in reverse
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] + " " );
}
}
}
// Driver Code // Given array arr[]
let arr = [ 4, 2, -5, 11 ];
let N = arr.length;
// Given K
let K = 3;
// Function
sumOfKElements(arr, N, K);
// This code is contributed by souravghosh0416. </script> |
8 10 17 1
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++ program for the above approach #include<bits/stdc++.h> using namespace std;
// Function to print the // required resultant array void sumOfKElements( int arr[], int n,
int k)
{ // Reverse the array
bool rev = false ;
if (k < 0)
{
rev = true ;
k *= -1;
int l = 0, r = n - 1;
// Traverse the range
while (l < r)
{
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
// Store prefix sum
int dp[n] = {0};
dp[0] = arr[0];
// Find the prefix sum
for ( int i = 1; i < n; i++)
{
dp[i] += dp[i - 1] + arr[i];
}
// Store the answer
int ans[n] = {0};
// Calculate the answers
for ( int i = 0; i < n; i++)
{
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else
{
// Count of remaining elements
int x = k - (n - 1 - i);
// Add the sum of all elements
// y times
int y = x / n;
// Add the remaining elements
int rem = x % n;
// Update ans[i]
ans[i] = dp[n - 1] - dp[i] +
y * dp[n - 1] + (rem - 1 >= 0 ?
dp[rem - 1] : 0);
}
}
// If array is reversed print
// ans[] in reverse
if (rev)
{
for ( int i = n - 1; i >= 0; i--)
{
cout << ans[i] << " " ;
}
}
else
{
for ( int i = 0; i < n; i++)
{
cout << ans[i] << " " ;
}
}
} // Driver Code int main()
{ // Given array arr[]
int arr[] = { 4, 2, -5, 11 };
int N = sizeof (arr) / sizeof (arr[0]);
// Given K
int K = 3;
// Function
sumOfKElements(arr, N, K);
} // This code is contributed by SURENDRA_GANGWAR |
// Java program for the above approach import java.io.*;
class GFG {
// Function to print the
// required resultant array
static void sumOfKElements(
int arr[], int n, int k)
{
// Reverse the array
boolean rev = false ;
if (k < 0 ) {
rev = true ;
k *= - 1 ;
int l = 0 , r = n - 1 ;
// Traverse the range
while (l < r) {
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
// Store prefix sum
int dp[] = new int [n];
dp[ 0 ] = arr[ 0 ];
// Find the prefix sum
for ( int i = 1 ; i < n; i++) {
dp[i] += dp[i - 1 ] + arr[i];
}
// Store the answer
int ans[] = new int [n];
// Calculate the answers
for ( int i = 0 ; i < n; i++) {
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else {
// Count of remaining elements
int x = k - (n - 1 - i);
// Add the sum of all elements
// y times
int y = x / n;
// Add the remaining elements
int rem = x % n;
// Update ans[i]
ans[i] = dp[n - 1 ]
- dp[i]
+ y * dp[n - 1 ]
+ (rem - 1 >= 0 ? dp[rem - 1 ] : 0 );
}
}
// If array is reversed print
// ans[] in reverse
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] + " " );
}
}
}
// Driver Code
public static void main(String[] args)
{
// Given array arr[]
int arr[] = { 4 , 2 , - 5 , 11 };
int N = arr.length;
// Given K
int K = 3 ;
// Function
sumOfKElements(arr, N, K);
}
} |
# Python3 program for # the above approach # Function to print # required resultant array def sumOfKElements(arr, n, k):
# Reverse the array
rev = False ;
if (k < 0 ):
rev = True ;
k * = - 1 ;
l = 0 ;
r = n - 1 ;
# Traverse the range
while (l < r):
tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l + = 1 ;
r - = 1 ;
# Store prefix sum
dp = [ 0 ] * n;
dp[ 0 ] = arr[ 0 ];
# Find the prefix sum
for i in range ( 1 , n):
dp[i] + = dp[i - 1 ] + arr[i];
# Store the answer
ans = [ 0 ] * n;
# Calculate the answers
for i in range (n):
if (i + k < n):
ans[i] = dp[i + k] - dp[i];
else :
# Count of remaining
# elements
x = k - (n - 1 - i);
# Add the sum of
# all elements y times
y = x / / n;
# Add the remaining
# elements
rem = x % n;
# Update ans[i]
ans[i] = (dp[n - 1 ] - dp[i] +
y * dp[n - 1 ] +
(dp[rem - 1 ]
if rem - 1 > = 0
else 0 ));
# If array is reversed
# print ans in reverse
if (rev):
for i in range (n - 1 , - 1 , - 1 ):
print (ans[i], end = " " );
else :
for i in range (n):
print (ans[i], end = " " );
# Driver Code if __name__ = = '__main__' :
# Given array arr
arr = [ 4 , 2 , - 5 , 11 ];
N = len (arr);
# Given K
K = 3 ;
# Function
sumOfKElements(arr, N, K);
# This code is contributed by 29AjayKumar |
// C# program for // the above approach using System;
class GFG {
// Function to print the // required resultant array static void sumOfKElements( int []arr,
int n, int k)
{ // Reverse the array
bool rev = false ;
if (k < 0)
{
rev = true ;
k *= -1;
int l = 0, r = n - 1;
// Traverse the range
while (l < r)
{
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
// Store prefix sum
int []dp = new int [n];
dp[0] = arr[0];
// Find the prefix sum
for ( int i = 1; i < n; i++)
{
dp[i] += dp[i - 1] + arr[i];
}
// Store the answer
int []ans = new int [n];
// Calculate the answers
for ( int i = 0; i < n; i++)
{
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else
{
// Count of remaining elements
int x = k - (n - 1 - i);
// Add the sum of all elements
// y times
int y = x / n;
// Add the remaining elements
int rem = x % n;
// Update ans[i]
ans[i] = dp[n - 1] - dp[i] +
y * dp[n - 1] +
(rem - 1 >= 0 ?
dp[rem - 1] : 0);
}
}
// If array is reversed print
// ans[] in reverse
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] + " " );
}
}
} // Driver Code public static void Main(String[] args)
{ // Given array []arr
int []arr = {4, 2, -5, 11};
int N = arr.Length;
// Given K
int K = 3;
// Function
sumOfKElements(arr, N, K);
} } // This code is contributed by Princi Singh |
<script> // Javascript program for the above approach // Function to print the // required resultant array function sumOfKElements(arr, n,
k)
{ // Reverse the array
let rev = false ;
if (k < 0)
{
rev = true ;
k *= -1;
let l = 0, r = n - 1;
// Traverse the range
while (l < r)
{
let tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
// Store prefix sum
let dp = new Uint8Array(n);
dp[0] = arr[0];
// Find the prefix sum
for (let i = 1; i < n; i++)
{
dp[i] += dp[i - 1] + arr[i];
}
// Store the answer
let ans = new Uint8Array(n);
// Calculate the answers
for (let i = 0; i < n; i++)
{
if (i + k < n)
ans[i] = dp[i + k] - dp[i];
else
{
// Count of remaining elements
let x = k - (n - 1 - i);
// Add the sum of all elements
// y times
let y = Math.floor(x / n);
// Add the remaining elements
let rem = x % n;
// Update ans[i]
ans[i] = dp[n - 1] - dp[i] +
y * dp[n - 1] + (rem - 1 >= 0 ?
dp[rem - 1] : 0);
}
}
// If array is reversed print
// ans[] in reverse
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] + " " );
}
}
} // Driver Code // Given array arr[]
let arr = [ 4, 2, -5, 11 ];
let N = arr.length;
// Given K
let K = 3;
// Function
sumOfKElements(arr, N, K);
//This code is contributed by Mayank Tyagi </script> |
8 10 17 1
Time Complexity: O(N)
Auxiliary Space: O(N)