Different ways to represent N as the sum of K non-zero integers

The problem “Different ways to represent N as the sum of K non-zero integers” has many real-world use cases.

Cryptography − In cryptography, specific cryptographic methods are designed using the concept of encoding a number N as the sum of K non-zero integers.

Representing an integer N as the sum of K non-zero integers might appear as a subproblem in different optimization issues in the context of optimization methods.

Machine learning − In machine learning, feature vectors that depict the distribution of data points can be created by using the problem of representing an integer N as the sum of K non-zero integers.

Explanation

Now let’s decode the problem.

Suppose, we are given two positive integers N and K, and we need to find K non-zero integers whose sum is equal to N. For example, if N=10 and K=3, we need to find three non-zero integers whose sum equals 10. Some possible solutions in this case are −

1 + 4 + 5
2 + 3 + 5
2 + 4 + 4

Note that in each of these solutions, we have K=3 non-zero integers that add up to N=10.

There are different ways to solve this problem, let’s discuss each one of them.

Recursive Approach

Step-by-step algorithm using the recursive approach to find Different ways to represent N as the sum of K non-zero integers.

• Take the value of N and K as input in the main function.

• Create the function f(N, K), which returns the total number of ways N may be represented as the sum of K non-zero integers.

• Return 1 if N exceeds 0 and 0 otherwise if K = 1. (base case).

• Return 0 if N == 0 or K > N. (base case).

• Create a variable count which stores the result.

• Set the value of the variable count to 0.

• From 1 to min(N-K+1, N-1) for each integer I

• Recursively calculate f (N-i, K-1).

• Add the outcome to the count.

• Return count.

Example

Implementation of the above algorithm

#include <iostream>
using namespace std;

int f(int N, int K) {
   if (K == 1) {
      return (N > 0) ? 1 : 0; // base case
   }
   if (N <= 0 || K > N) {
      return 0; // base case
   }
   int count = 0;
   for (int i = 1; i <= min(N-K+1, N-1); i++) {
      count += f(N-i, K-1);
   }
   return count;
}

int main() {
   int N = 5, K = 2;
   
   int ways = f(N, K);
   cout << "Number of ways to represent " << N << " as the sum of " << K << " non-zero integers: " << ways << endl;
   return 0;
}

Output

Number of ways to represent 5 as the sum of 2 non-zero integers: 4

Complexities

Time complexity: O(N ^ K).

Space complexity: O(K)

Binomial Coefficient Formula

The stars and bars combinatorial approach can be used to get the formula for the number of ways to express a positive integer N as the sum of K non-zero integers.

Imagine a row of N stars (*), which stand in for the N partitioning units of the given integer. K-1 bars (|), which divide the row of stars into K segments, can be used to represent the partition's K non-zero integers.

Take the division of 10 into 3 non-zero integers as an example. The row of stars and bars below can be used to symbolize this −

* * | * * * | * * * * *

The first part of this illustration depicts the number 2, the second segment the number 3, and the third segment the number 5.

The number of ways to arrange K-1 bars in the row of N stars is consequently equal to the number of ways to represent N as the sum of K non-zero integers. To calculate this we use the formula: $\mathrm{C(N\:+\:K\:-\:1,\:K\:-\:1)}$.

Here as per binomial coefficient formula $\mathrm{C(n,k)\:=\:n!\:/(k!*(n-k)!)}$.

But in our case, we need to eliminate the possibilities which include 0. To exclude the partitions that include 0 as one of the summands, we can use the following approach −

• Subtract 1 from N to get N-1.

• Partition N-1 into K-1 non-negative integers.

• Add 1 to each of the K-1 non-negative integers obtained in step 2 to get K non-zero integers that sum to N.

The reason this approach works is that the smallest possible value of each summand is 1 (since we want non-zero integers), and so we subtract 1 from N to ensure that there are enough units left over to distribute among the K summands.

Therefore, we reach the formula: ways = C(N-1, K-1)

Let's say we want to find the number of ways to represent 6 as the sum of 4 non-zero integers. We can use the formula we derived earlier, which is −

C(N-1, K-1) = C(6-1, 4-1) = C(5, 3) = 10

This tells us that there are 10 ways to partition 6 into 4 non-zero integers.

They are −

• 1 + 1 + 1 + 3

• 1 + 1 + 2 + 2

• 1 + 1 + 3 + 1

• 1 + 2 + 1 + 2

• 1 + 2 + 2 + 1

• 1 + 3 + 1 + 1

• 2 + 1 + 1 + 2

• 2 + 1 + 2 + 1

• 2 + 2 + 1 + 1

• 3 + 1 + 1 + 1

Approach

Let’s discuss the step-by-step algorithm to implement the above approach −

• Take the value of N and K as input in the main function.

• Use the above formula to calculate the number of ways.

• Print the value of ways.

Now let’s do some code.

Example

Code Implementation using the Binomial Coefficient approach

#include <iostream>
using namespace std;

int binomial(int n, int k) {
   int res = 1;
   if (k > n - k) {
      k = n - k;
   }
   for (int i = 0; i < k; ++i) {
      res *= (n - i);
      res /= (i + 1);
   }
   return res;
}

int main() {
   int N = 7, K = 2;
   
   int ways = binomial(N - 1, K - 1);
   cout << "Number of ways to represent " << N << " as the sum of " << K << " non-zero integers: " << ways << endl;
   return 0;
}

Output

Number of ways to represent 7 as the sum of 2 non-zero integers: 6

Complexities

Time complexity: O( K).

Space complexity: O(1)

Conclusion

In this article, we have tried to explain the approach to find out different ways to represent N as sum of K non-zero integers. I hope this article helps you to learn the concept in a better way.