Print the sequence of size N in which every term is sum of previous K terms

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++

 `// C++ implementation to find the``// series in which every term is``// sum of previous K terms` `#include ` `using` `namespace` `std;` `// Function to generate the``// series in the form of array``void` `sumOfPrevK(``int` `N, ``int` `K)``{``    ``int` `arr[N];``    ``arr[0] = 1;` `    ``// Pick a starting point``    ``for` `(``int` `i = 1; i < N; i++) {``        ``int` `j = i - 1, count = 0,``            ``sum = 0;``        ``// Find the sum of all``        ``// elements till count < K``        ``while` `(j >= 0 && count < K) {``            ``sum += arr[j];``            ``j--;``            ``count++;``        ``}``        ``// Find the value of``        ``// sum at i position``        ``arr[i] = sum;``    ``}``    ``for` `(``int` `i = 0; i < N; i++) {``        ``cout << arr[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 10, K = 4;``    ``sumOfPrevK(N, K);``    ``return` `0;``}`

Java

 `// Java implementation to find the``// series in which every term is``// sum of previous K terms` `class` `Sum {``    ``// Function to generate the``    ``// series in the form of array``    ``void` `sumOfPrevK(``int` `N, ``int` `K)``    ``{``        ``int` `arr[] = ``new` `int``[N];``        ``arr[``0``] = ``1``;` `        ``// Pick a starting point``        ``for` `(``int` `i = ``1``; i < N; i++) {``            ``int` `j = i - ``1``, count = ``0``,``                ``sum = ``0``;``            ``// Find the sum of all``            ``// elements till count < K``            ``while` `(j >= ``0` `&& count < K) {``                ``sum += arr[j];``                ``j--;``                ``count++;``            ``}``            ``// Find the value of``            ``// sum at i position``            ``arr[i] = sum;``        ``}``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``System.out.print(arr[i] + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``Sum s = ``new` `Sum();``        ``int` `N = ``10``, K = ``4``;``        ``s.sumOfPrevK(N, K);``    ``}``}`

Python3

 `# Python3 implementation to find the ``# series in which every term is ``# sum of previous K terms ` `# Function to generate the ``# series in the form of array ``def` `sumOfPrevK(N, K): ``    ``arr ``=` `[``0` `for` `i ``in` `range``(N)] ``    ``arr[``0``] ``=` `1` `    ``# Pick a starting point``    ``for` `i ``in` `range``(``1``,N): ``        ``j ``=` `i ``-` `1``        ``count ``=` `0``        ``sum` `=` `0``        ` `        ``# Find the sum of all ``        ``# elements till count < K ``        ``while` `(j >``=` `0` `and` `count < K):``            ``sum` `=` `sum` `+` `arr[j]``            ``j ``=` `j ``-` `1``            ``count ``=` `count ``+` `1` `        ``# Find the value of ``        ``# sum at i position ``        ``arr[i] ``=` `sum` `    ``for` `i ``in` `range``(``0``, N): ``        ``print``(arr[i])` `# Driver Code ``N ``=` `10``K ``=` `4``sumOfPrevK(N, K)` `# This code is contributed by Sanjit_Prasad`

C#

 `// C# implementation to find the``// series in which every term is``// sum of previous K terms``using` `System;` `class` `Sum {``    ``// Function to generate the``    ``// series in the form of array``    ``void` `sumOfPrevK(``int` `N, ``int` `K)``    ``{``        ``int` `[]arr = ``new` `int``[N];``        ``arr[0] = 1;`` ` `        ``// Pick a starting point``        ``for` `(``int` `i = 1; i < N; i++) {``            ``int` `j = i - 1, count = 0,``                ``sum = 0;` `            ``// Find the sum of all``            ``// elements till count < K``            ``while` `(j >= 0 && count < K) {``                ``sum += arr[j];``                ``j--;``                ``count++;``            ``}` `            ``// Find the value of``            ``// sum at i position``            ``arr[i] = sum;``        ``}``        ``for` `(``int` `i = 0; i < N; i++) {``            ``Console.Write(arr[i] + ``" "``);``        ``}``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `Main(String []args)``    ``{``        ``Sum s = ``new` `Sum();``        ``int` `N = 10, K = 4;``        ``s.sumOfPrevK(N, K);``    ``}``}` `// This code is contributed by 29AjayKumar`

Javascript

 ``

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 ``#include ``using` `namespace` `std;` `void` `sumOfPrevK(``int` `N, ``int` `K)``{``    ``vector<``int``> arr(N);``    ``// initialize the 0th index with 1``    ``arr[0] = 1;` `    ``// initialize sliding window and sum``    ``// the sum stores the sum of the previous window``    ``int` `start = 0, end = 1, sum = 1;` `    ``while` `(end < N) {``        ``// if size of the sliding window exceeds K``        ``if` `(end - start > K) {``            ``// decrease the window size and update the sum``            ``sum -= arr[start];``            ``++start;``        ``}``        ``// update the current element by sum of the previous``        ``// K elements``        ``arr[end] = sum;``        ``// Update the sum by adding the current element``        ``sum += arr[end];``        ``// increase the window size``        ``++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

 `// Java code to implement the approach``import` `java.util.*;` `class` `GFG {``  ``static` `void` `sumOfPrevK(``int` `N, ``int` `K)``  ``{``    ``ArrayList arr = ``new` `ArrayList();``    ``for` `(``int` `i = ``0``; i < N; i++)``      ``arr.add(``0``);` `    ``// initialize the 0th index with 1``    ``arr.set(``0``, ``1``);` `    ``// initialize sliding window and sum``    ``// the sum stores the sum of the previous window``    ``int` `start = ``0``, end = ``1``, sum = ``1``;` `    ``while` `(end < N) {``      ``// if size of the sliding window exceeds K``      ``if` `(end - start > K) {``        ``// decrease the window size and update the``        ``// sum``        ``sum -= arr.get(start);``        ``++start;``      ``}` `      ``// update the current element by sum of the``      ``// previous K elements``      ``arr.set(end, sum);``      ``// Update the sum by adding the current element``      ``sum += arr.get(end);` `      ``// increase the window size``      ``++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);``  ``}``}` `// This code is contributed by phasing17`

Python3

 `# Python3 code to implement the approach``def` `sumsOfPrevK(N, K):` `    ``arr ``=` `[``0` `for` `_ ``in` `range``(N)]``    ``# initialize the 0th index with 1``    ``arr[``0``] ``=` `1` `    ``# initialize sliding window and sums``    ``# the sums stores the sums of the previous window``    ``start ``=` `0``    ``end ``=` `1``    ``sums ``=` `1` `    ``while` `(end < N):``        ``# if size of the sliding window exceeds K``        ``if` `(end ``-` `start > K):``          ` `            ``# decrease the window size and update the sums``            ``sums ``-``=` `arr[start]``            ``start ``+``=` `1` `        ``# update the current element by sums of the previous``        ``# K elements``        ``arr[end] ``=` `sums``        ` `        ``# Update the sums by adding the current element``        ``sums ``+``=` `arr[end]``        ` `        ``# increase the window size``        ``end ``+``=` `1` `    ``print``(``*``arr)` `# Driver Code``N ``=` `10``K ``=` `4``sumsOfPrevK(N, K)` `# This code is contributed by phasing17`

C#

 `// C# code to implement the approach` `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);` `    ``// initialize the 0th index with 1``    ``arr[0] = 1;` `    ``// initialize sliding window and sum``    ``// the sum stores the sum of the previous window``    ``int` `start = 0, end = 1, sum = 1;` `    ``while` `(end < N) {``      ``// if size of the sliding window exceeds K``      ``if` `(end - start > K) {``        ``// decrease the window size and update the sum``        ``sum -= arr[start];``        ``++start;``      ``}` `      ``// update the current element by sum of the previous``      ``// K elements``      ``arr[end] = sum;``      ``// Update the sum by adding the current element``      ``sum += arr[end];` `      ``// increase the window size``      ``++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);``  ``}``}`  `// This code is contributed by phasing17`

Javascript

 `// JavaScript code to implement the approach`  `function` `sumOfPrevK(N, K)``{``    ``let arr = ``new` `Array(N);``    ``// initialize the 0th index with 1``    ``arr[0] = 1;` `    ``// initialize sliding window and sum``    ``// the sum stores the sum of the previous window``    ``let start = 0, end = 1, sum = 1;` `    ``while` `(end < N) {``        ``// if size of the sliding window exceeds K``        ``if` `(end - start > K) {``            ``// decrease the window size and update the sum``            ``sum -= arr[start];``            ``++start;``        ``}``        ``// update the current element by sum of the previous``        ``// K elements``        ``arr[end] = sum;``        ``// Update the sum by adding the current element``        ``sum += arr[end];``        ``// increase the window size``        ``++end;``    ``}` `    ``console.log(arr.join(``" "``))``   ` `}`  `// Driver Code` `let N = 10, K = 4;``sumOfPrevK(N, K);`   `// This code is contributed by phasing17`

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)

Previous
Next