N-bonacci Numbers

You are given two integers N and M, and print all the terms of the series up to M-terms of the N-bonacci Numbers. For example, when N = 2, the sequence becomes Fibonacci, when n = 3, sequence becomes Tribonacci.

In general, in N-bonacci sequence, we use sum of preceding N numbers from the next term. For example, a 3-bonacci sequence is the following: 
0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81

The Fibonacci sequence is a set of numbers that starts with one or zero, followed by a one, and proceeds based on the rule that each number is equal to the sum of preceding two numbers 0, 1, 1, 2, 3, 5, 8.....

Examples :  

Input : N = 3, M = 8
Output : 0, 0, 1, 1, 2, 4, 7, 13
We need to print first M terms.
First three terms are 0, 0 and 1.
Fourth term is 0 + 0 + 1 = 1
Fifth term is 0 + 1 + 1 = 2
Sixth terms is 1 + 1 + 2 = 4
Seventh term is 7 (1 + 2 + 4) 
and eighth term is 13 (7 + 4 + 2).

Input : N = 4, M = 10
Output : 0 0 0 1 1 2 4 8 15 29 

Method 1 (Simple) 

Initialize first N-1 terms as 0 and N-th term as 1. Now to find terms from (N+1)-th to M-th, we simply compute sum of previous N terms. 

Example : N = 4, M = 10

First three terms are 0, 0, 0 

Fourth term is 1. 

Remaining terms are computed by adding 

previous 4 terms. 
0 0 0 1 
0 0 0 1 1 
0 0 0 1 1 2 
0 0 0 1 1 2 4 
0 0 0 1 1 2 4 8
0 0 0 1 1 2 4 8 15
0 0 0 1 1 2 4 8 15 29

0 0 0 0 1 1 2 4 8 16 31 61 120 236 464

Time Complexity: O(M * N) 
Auxiliary Space: O(M)

Method 2 (Optimized) 

We can optimize for large values of N. The idea is based on sliding window. The current term a[i] can be computed as a[i-1] + a[i-1] - a[i-n-1] 

0 0 0 0 1 1 2 4 8 16 31 61 120 236 464

Time Complexity: O(M) 
Auxiliary Space: O(M) 

Method 3: Using Queue

We can use queue to easily and efficiently calculate every terms of N-bonacci numbers by using less space than above method.

Algorithm:

1. First we push N element inside the queue whose values will be '0' for 1 to N-1 elements and '1' for Nth element.
2. Now, we take another variable (let's say su) to calculate N-bonacci numbers. and set its value to 1, which is the sum of all the elements, currently inside the queue.
3. Then, using a for loop iterate the queue M times:
   • Inside for loop, we pop the front element of the queue and store it.
   • Then, we push an element whose value will be sum of all the elements, currently inside the queue.
     • Push su into the queue.
     • Before popping, the sum of all the elements is su, and then we push su inside queue.
     • So, now the sum is 2*su.
     • And, then we pop front element of the queue, so sum will be (2*su - popped_front_element).
     • So, su will now become (2*su - popped_front_element), which we will be pushed inside the queue in next iteration.
   • And then we print the popped element.

Below is the implementation of the above approach:

0 0 0 0 1 1 2 4 8 16 31 61 120 236 464 

Time Complexity: O(M), To iterate M times.
Auxiliary Space: O(N), because at every time queue has N elements.