Related Articles
Represent K as sum of N-bonacci numbers
• Last Updated : 15 Sep, 2020

Given two numbers K and N. The task is to represent the given number K as a sum of several N-bonacci numbers.

Examples:

Input: K = 21, N = 5
Output: 3
The three numbers of the 5-bonacci numbers are: 16, 4, 1.
Explanation:
For N = 5, the series will be: 1, 1, 2, 4, 8, 16, 31, 61, 120, and so on. The three numbers 16, 4 and 1 add up to 21.

Input: K = 500, N = 43
Output: 6
The numbers of 43-bonacci that add up to 500 are: 256 128 64 32 16 4

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

Naive Approach:
The simplest approach is to generate the N-bonacci series upto 50 terms and store their values in an array. Find the subset of the array which has the given sum and print the size of the subset.

Time Complexity: O(2N)

Efficient Approach: This approach is based on the efficient approach on how to form N-bonacci numbers, discussed in this article.
Follow the steps below to solve the problem:

1. Generate the N-bonacci series and store the values in an array, say N_bonacci[]. (upto 50 terms)
2. Initialize another array, ans[], for saving the numbers from the series whose sum is K.
3. Traverse the N-bonacci array in the reverse order and keep checking if, K – N_bonacci[i] >= 0. If true, then push the N_bonacci[i] to the ans array, and reduce K to K – N_bonacci[i].
4. Continue decrementing K till it becomes 0, and then finally output the size and the elements of ans array.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above problem ``#include  ``using` `namespace` `std; `` ` `// array to store the N-Bonacci series ``long` `long` `N_bonacci; `` ` `// Function to express K as sum of ``// several N_bonacci numbers ``void` `N_bonacci_nums(``int` `n, ``int` `k) ``{ ``    ``N_bonacci = 1; `` ` `    ``for` `(``int` `i = 1; i <= 50; ++i) { ``        ``for` `(``int` `j = i - 1; ``            ``j >= i - k and j >= 0; ``            ``--j) ``            ``N_bonacci[i] ``                ``+= N_bonacci[j]; ``    ``} `` ` `    ``vector<``long` `long``> ans; ``    ``for` `(``int` `i = 50; i >= 0; --i) ``        ``if` `(n - N_bonacci[i] >= 0) { ``            ``ans.push_back(N_bonacci[i]); ``            ``n -= N_bonacci[i]; ``        ``} `` ` `    ``if` `(ans.size() == 1) ``        ``ans.push_back(0); `` ` `    ``cout << ans.size() << endl; ``    ``for` `(``int` `i = 0; i < ans.size(); ++i) ``        ``cout << ans[i] << ``", "``; ``} `` ` `// Driver code ``int` `main() ``{ ``    ``int` `n = 21, k = 5; ``    ``N_bonacci_nums(n, k); ``    ``return` `0; ``}  `

## Java

 `// Java program for the above problem ``import` `java.util.*; `` ` `class` `GFG{ ``     ` `// Array to store the N-Bonacci series ``public` `static` `long` `[]N_bonacci= ``new` `long` `[``100``]; `` ` `// Function to express K as sum of ``// several N_bonacci numbers ``@SuppressWarnings``(``"unchecked"``) ``public` `static` `void` `N_bonacci_nums(``int` `n, ``int` `k) ``{ ``    ``N_bonacci[``0``] = ``1``; `` ` `    ``for``(``int` `i = ``1``; i <= ``50``; ++i) ``    ``{ ``        ``for``(``int` `j = i - ``1``; ``                ``j >= i - k && j >= ``0` `;--j) ``            ``N_bonacci[i]+= N_bonacci[j]; ``    ``} `` ` `    ``Vector ans = ``new` `Vector(); ``    ``for``(``int` `i = ``50``; i >= ``0``; --i) ``        ``if` `(n - N_bonacci[i] >= ``0``) ``        ``{ ``            ``ans.add(N_bonacci[i]); ``            ``n -= N_bonacci[i]; ``        ``} `` ` `    ``if` `(ans.size() == ``1``) ``        ``ans.add(``0``); `` ` `    ``System.out.println(ans.size()); ``    ``for``(``int` `i = ``0``; i < ans.size(); ++i) ``        ``System.out.print(ans.get(i) + ``", "``); ``} `` ` `// Driver code ``public` `static` `void` `main(String args[]) ``{ ``    ``int` `n = ``21``, k = ``5``; ``    ``N_bonacci_nums(n, k); ``} ``} `` ` `// This code is contributed by SoumikMondal `

## Python3

 `# Python3 program for the above problem `` ` `# Array to store the N-Bonacci series ``N_bonacci ``=` `[``0``] ``*` `100`` ` `# Function to express K as sum of ``# several N_bonacci numbers ``def` `N_bonacci_nums(n, k): ``     ` `    ``N_bonacci[``0``] ``=` `1`` ` `    ``for` `i ``in` `range``(``1``, ``51``): ``        ``j ``=` `i ``-` `1``         ` `        ``while` `j >``=` `i ``-` `k ``and` `j >``=` `0``: ``            ``N_bonacci[i] ``+``=` `N_bonacci[j] ``            ``j ``-``=` `1``             ` `    ``ans ``=` `[] ``    ``for` `i ``in` `range``(``50``, ``-``1``, ``-``1``): ``        ``if` `(n ``-` `N_bonacci[i] >``=` `0``): ``            ``ans.append(N_bonacci[i]) ``            ``n ``-``=` `N_bonacci[i] `` ` `    ``if` `(``len``(ans) ``=``=` `1``): ``        ``ans.append(``0``) `` ` `    ``print``(``len``(ans)) ``    ``for` `i ``in` `ans: ``        ``print``(i, end ``=` `", "``) `` ` `# Driver code ``if` `__name__ ``=``=` `'__main__'``: ``     ` `    ``n ``=` `21``    ``k ``=` `5``     ` `    ``N_bonacci_nums(n, k) `` ` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above problem ``using` `System;``using` `System.Collections.Generic; `` ` `class` `GFG{`` ` `// Array to store the N-Bonacci series     ``public` `static` `long` `[]N_bonacci = ``new` `long` `; `` ` `// Function to express K as sum of ``// several N_bonacci numbers ``static` `void` `N_bonacci_nums(``long` `n, ``long` `k) ``{ ``    ``N_bonacci = 1; `` ` `    ``for``(``int` `i = 1; i <= 50; ++i) ``    ``{ ``        ``for``(``int` `j = i - 1; ``                ``j >= i - k && j >= 0; --j) ``            ``N_bonacci[i] += N_bonacci[j]; ``    ``} `` ` `    ``List<``long``> ans = ``new` `List<``long``>();``    ``for``(``int` `i = 50; i >= 0; --i) ``        ``if` `(n - N_bonacci[i] >= 0) ``        ``{ ``            ``ans.Add(N_bonacci[i]); ``            ``n -= N_bonacci[i]; ``        ``} `` ` `    ``if` `(ans.Count == 1) ``        ``ans.Add(0); `` ` `    ``Console.WriteLine(ans.Count);``    ``for``(``int` `i = 0; i < ans.Count; ++i) ``        ``Console.Write(ans[i] + ``", "``);``} `` ` `// Driver code``static` `void` `Main()``{``    ``long` `n = 21, k = 5; ``     ` `    ``N_bonacci_nums(n, k); ``}``}`` ` `// This code is contributed by divyeshrabadiya07`
Output:
```3
16, 4, 1,
```

Time Complexity: O(K * K)
Auxillary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up