Print the sequence of size N in which every term is sum of previous K terms
Last Updated :
15 Sep, 2022
Given two integers N and K, the task is to generate a series of N terms in which every term is sum of the previous K terms.
Note: The first term of the series is 1. if there are not enough previous terms, then other terms are supposed to be 0.
Examples:
Input: N = 8, K = 3
Output: 1 1 2 4 7 13 24 44
Explanation:
Series is generated as follows:
a[0] = 1
a[1] = 1 + 0 + 0 = 1
a[2] = 1 + 1 + 0 = 2
a[3] = 2 + 1 + 1 = 4
a[4] = 4 + 2 + 1 = 7
a[5] = 7 + 4 + 2 = 13
a[6] = 13 + 7 + 4 = 24
a[7] = 24 + 13 + 7 = 44
Input: N = 10, K = 4
Output: 1 1 2 4 8 15 29 56 108 208
Naive Approach: The idea is to run two loops to generate N terms of series. Below is the illustration of the steps:
- Traverse the first loop from 0 to N – 1, to generate every term of the series.
- Run a loop from max(0, i – K) to i to compute the sum of the previous K terms.
- Update the sum to the current index of series as the current term.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
void sumOfPrevK( int N, int K)
{
int arr[N];
arr[0] = 1;
for ( int i = 1; i < N; i++) {
int j = i - 1, count = 0,
sum = 0;
while (j >= 0 && count < K) {
sum += arr[j];
j--;
count++;
}
arr[i] = sum;
}
for ( int i = 0; i < N; i++) {
cout << arr[i] << " " ;
}
}
int main()
{
int N = 10, K = 4;
sumOfPrevK(N, K);
return 0;
}
|
Java
class Sum {
void sumOfPrevK( int N, int K)
{
int arr[] = new int [N];
arr[ 0 ] = 1 ;
for ( int i = 1 ; i < N; i++) {
int j = i - 1 , count = 0 ,
sum = 0 ;
while (j >= 0 && count < K) {
sum += arr[j];
j--;
count++;
}
arr[i] = sum;
}
for ( int i = 0 ; i < N; i++) {
System.out.print(arr[i] + " " );
}
}
public static void main(String args[])
{
Sum s = new Sum();
int N = 10 , K = 4 ;
s.sumOfPrevK(N, K);
}
}
|
Python3
def sumOfPrevK(N, K):
arr = [ 0 for i in range (N)]
arr[ 0 ] = 1
for i in range ( 1 ,N):
j = i - 1
count = 0
sum = 0
while (j > = 0 and count < K):
sum = sum + arr[j]
j = j - 1
count = count + 1
arr[i] = sum
for i in range ( 0 , N):
print (arr[i])
N = 10
K = 4
sumOfPrevK(N, K)
|
C#
using System;
class Sum {
void sumOfPrevK( int N, int K)
{
int []arr = new int [N];
arr[0] = 1;
for ( int i = 1; i < N; i++) {
int j = i - 1, count = 0,
sum = 0;
while (j >= 0 && count < K) {
sum += arr[j];
j--;
count++;
}
arr[i] = sum;
}
for ( int i = 0; i < N; i++) {
Console.Write(arr[i] + " " );
}
}
public static void Main(String []args)
{
Sum s = new Sum();
int N = 10, K = 4;
s.sumOfPrevK(N, K);
}
}
|
Javascript
<script>
function sumOfPrevK(N, K)
{
let arr = new Array(N);
arr[0] = 1;
for (let i = 1; i < N; i++) {
let j = i - 1, count = 0, sum = 0;
while (j >= 0 && count < K) {
sum += arr[j];
j--;
count++;
}
arr[i] = sum;
}
for (let i = 0; i < N; i++) {
document.write(arr[i] + " " );
}
}
let N = 10, K = 4;
sumOfPrevK(N, K);
</script>
|
Output:
1 1 2 4 8 15 29 56 108 208
Performance analysis:
- Time Complexity: O(N * K)
- Space Complexity: O(N)
Improved Approach: The idea is to store the current sum in a variable and subtract the last Kth term in every step and add the last term into the pre-sum to compute every term of the series.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <vector>
using namespace std;
void sumOfPrevK( int N, int K)
{
vector< int > arr(N);
arr[0] = 1;
int start = 0, end = 1, sum = 1;
while (end < N) {
if (end - start > K) {
sum -= arr[start];
++start;
}
arr[end] = sum;
sum += arr[end];
++end;
}
for ( int i = 0; i < N; ++i) {
cout << arr[i] << " " ;
}
cout << endl;
}
int main()
{
int N = 10, K = 4;
sumOfPrevK(N, K);
return 0;
}
|
Java
import java.util.*;
class GFG {
static void sumOfPrevK( int N, int K)
{
ArrayList<Integer> arr = new ArrayList<Integer>();
for ( int i = 0 ; i < N; i++)
arr.add( 0 );
arr.set( 0 , 1 );
int start = 0 , end = 1 , sum = 1 ;
while (end < N) {
if (end - start > K) {
sum -= arr.get(start);
++start;
}
arr.set(end, sum);
sum += arr.get(end);
++end;
}
for ( int i = 0 ; i < N; ++i) {
System.out.print(arr.get(i) + " " );
}
System.out.print( "\n" );
}
public static void main(String[] args)
{
int N = 10 , K = 4 ;
sumOfPrevK(N, K);
}
}
|
Python3
def sumsOfPrevK(N, K):
arr = [ 0 for _ in range (N)]
arr[ 0 ] = 1
start = 0
end = 1
sums = 1
while (end < N):
if (end - start > K):
sums - = arr[start]
start + = 1
arr[end] = sums
sums + = arr[end]
end + = 1
print ( * arr)
N = 10
K = 4
sumsOfPrevK(N, K)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void sumOfPrevK( int N, int K)
{
List< int > arr = new List< int >() ;
for ( int i = 0; i < N; i++)
arr.Add(0);
arr[0] = 1;
int start = 0, end = 1, sum = 1;
while (end < N) {
if (end - start > K) {
sum -= arr[start];
++start;
}
arr[end] = sum;
sum += arr[end];
++end;
}
for ( int i = 0; i < N; ++i) {
Console.Write(arr[i] + " " );
}
Console.Write( "\n" );
}
public static void Main( string [] args)
{
int N = 10, K = 4;
sumOfPrevK(N, K);
}
}
|
Javascript
function sumOfPrevK(N, K)
{
let arr = new Array(N);
arr[0] = 1;
let start = 0, end = 1, sum = 1;
while (end < N) {
if (end - start > K) {
sum -= arr[start];
++start;
}
arr[end] = sum;
sum += arr[end];
++end;
}
console.log(arr.join( " " ))
}
let N = 10, K = 4;
sumOfPrevK(N, K);
|
Complexity analysis:
- Time Complexity: O(N)
- Space Complexity: O(N)
Another Approach: Sliding Window
The idea is to use a fixed-size sliding window of size K to get the sum of previous K elements.
- Initialize the answer array with arr[0] = 1 and a variable sum = 1, representing the sum of the last K elements. Initially, the previous sum = 1. (If there are less than K elements in the last window, then the sum will store the sum of all the elements in the window)
- The sliding window is initialized by making start = 0 and end = 1.
- If the window size exceeds K, then decrement arr[start] from sum and increment start to update the window size and sum.
- Make arr[end] = sum, which will be the sum of the previous K elements, and increment sum by arr[end] for the next iteration. Increment end by 1.
Output
1 1 2 4 8 15 29 56 108 208
Complexity analysis:
- Time Complexity: O(N)
- Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...