# 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: First term of the series is 1 and 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 = 1
a = 1 + 0 + 0 = 1
a = 1 + 1 + 0 = 2
a = 2 + 1 + 1 = 4
a = 4 + 2 + 1 = 7
a = 7 + 4 + 2 = 13
a = 13 + 7 + 4 = 24
a = 24 + 13 + 7 = 44

Input: N = 10, K = 4
Output: 1 1 2 4 8 15 29 56 108 208

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 = 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 = 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 `

Performance analysis:

• Time Complexity: O(N * K)
• Space Complexity: O(N)

Efficient Approach: The idea is to store the current sum in a variable and in every step subtract the last Kth term 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++

 `// 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], prevsum = 0; ` `    ``arr = 1; ` ` `  `    ``// Pick a starting point ` `    ``for` `(``int` `i = 0; i < N - 1; i++) { ` ` `  `        ``// Computing the previous sum ` `        ``if` `(i <= K) { ` `            ``arr[i + 1] = arr[i] + prevsum; ` `            ``prevsum = arr[i + 1]; ` `        ``} ` `        ``else` `{ ` `            ``arr[i + 1] = arr[i] + prevsum ` `                         ``- arr[i + 1 - K]; ` `            ``prevsum = arr[i] + prevsum; ` `        ``} ` `    ``} ` ` `  `    ``// Loop to print the series ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``cout << arr[i] << ``" "``; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 8, K = 3; ` `    ``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]; ` `        ``int` `prevsum = ``0``; ` `        ``arr[``0``] = ``1``; ` ` `  `        ``// Pick a starting point ` `        ``for` `(``int` `i = ``0``; i < N - ``1``; i++) { ` ` `  `            ``// Computing the previous sum ` `            ``if` `(i <= K) { ` `                ``arr[i + ``1``] = arr[i] + prevsum; ` `                ``prevsum = arr[i + ``1``]; ` `            ``} ` `            ``else` `{ ` `                ``arr[i + ``1``] = arr[i] + prevsum ` `                             ``- arr[i + ``1` `- K]; ` `                ``prevsum = arr[i] + prevsum; ` `            ``} ` `        ``} ` ` `  `        ``// Loop to print the series ` `        ``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 = ``8``, K = ``3``; ` `        ``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``]``*``N; ` `    ``prevsum ``=` `0``; ` `    ``arr[``0``] ``=` `1``; ` ` `  `    ``# Pick a starting point ` `    ``for` `i ``in` `range``(N``-``1``): ` ` `  `        ``# Computing the previous sum ` `        ``if` `(i <``=` `K): ` `            ``arr[i ``+` `1``] ``=` `arr[i] ``+` `prevsum; ` `            ``prevsum ``=` `arr[i ``+` `1``]; ` `        ``else``: ` `            ``arr[i ``+` `1``] ``=` `arr[i] ``+` `prevsum ``-` `arr[i ``+` `1` `-` `K]; ` `            ``prevsum ``=` `arr[i] ``+` `prevsum; ` ` `  `    ``# Loop to print the series ` `    ``for` `i ``in` `range``(N): ` `        ``print``(arr[i], end``=``" "``); ` `     `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``N ``=` `8``; ` `    ``K ``=` `3``; ` `    ``sumOfPrevK(N, K); ` `         `  `# This code is contributed by 29AjayKumar `

## C#

 `// C# implementation to find the ` `// series in which every term is ` `// sum of previous K terms ` `using` `System; ` `public` `class` `Sum { ` `    ``// Function to generate the ` `    ``// series in the form of array ` `    ``void` `sumOfPrevK(``int` `N, ``int` `K) ` `    ``{ ` `        ``int` `[]arr = ``new` `int``[N]; ` `        ``int` `prevsum = 0; ` `        ``arr = 1; ` `  `  `        ``// Pick a starting point ` `        ``for` `(``int` `i = 0; i < N - 1; i++) { ` `  `  `            ``// Computing the previous sum ` `            ``if` `(i <= K) { ` `                ``arr[i + 1] = arr[i] + prevsum; ` `                ``prevsum = arr[i + 1]; ` `            ``} ` `            ``else` `{ ` `                ``arr[i + 1] = arr[i] + prevsum ` `                             ``- arr[i + 1 - K]; ` `                ``prevsum = arr[i] + prevsum; ` `            ``} ` `        ``} ` `  `  `        ``// Loop to print the series ` `        ``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 = 8, K = 3; ` `        ``s.sumOfPrevK(N, K); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Complexity analysis:

• Time Complexity: O(N)
• Space Complexity: O(N) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.