Count of all possible combinations of K numbers that sums to N
Last Updated :
03 Jan, 2022
Given a number N, the task is to count the combinations of K numbers from 1 to N having a sum equal to N, with duplicates allowed.
Example:
Input: N = 7, K = 3
Output:15
Explanation:The combinations which lead to the sum N = 7 are: {1, 1, 5}, {1, 5, 1}, {5, 1, 1}, {2, 1, 4}, {1, 2, 4}, {1, 4, 2}, {2, 4, 1}, {4, 1, 2}, {4, 2, 1}, {3, 1, 3}, {1, 3, 3}, {3, 3, 1}, {2, 2, 3}, {2, 3, 2}, {3, 2, 2}
Input: N = 5, K = 5
Output: 1
Explanation: {1, 1, 1, 1, 1} is the only combination.
Naive Approach: This problem can be solved using recursion and then memoising the result to improve time complexity. To solve this problem, follow the below steps:
- Create a function, say countWaysUtil which will accept four parameters that are N, K, sum, and dp. Here N is the sum that K elements are required to have, K is the number of elements consumed, sum is the sum accumulated till now and dp is the matrix to memoise the result. This function will give the number of ways to get the sum in K numbers.
- Now initially call countWaysUtil with arguments N, K, sum=0 and dp as a matrix filled with all -1.
- In each recursive call:
- Check for the base cases:
- If the sum is equal to N and K become 0, then return 1.
- If the sum exceeds N and K is still greater than 0, then return 0.
- Now, run a for loop from 1 to N, to check the result for each outcome.
- Sum all the results in a variable cnt and return cnt after memoising.
- Print the answer according to the above observation.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
int countWaysUtil(int N, int K, int sum,
vector<vector<int> >& dp)
{
// Base Cases
if (sum == N and K == 0) {
return 1;
}
if (sum >= N and K >= 0) {
return 0;
}
if (K < 0) {
return 0;
}
// If the result is already memoised
if (dp[sum][K] != -1) {
return dp[sum][K];
}
// Recursive Calls
int cnt = 0;
for (int i = 1; i <= N; i++) {
cnt += countWaysUtil(
N, K - 1,
sum + i, dp);
}
// Returning answer
return dp[sum][K] = cnt;
}
void countWays(int N, int K)
{
vector<vector<int> > dp(N + 1,
vector<int>(
K + 1, -1));
cout << countWaysUtil(N, K, 0, dp);
}
// Driver Code
int main()
{
int N = 7, K = 3;
countWays(N, K);
}
// Java implementation for the above approach
class GFG {
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
static int countWaysUtil(int N, int K, int sum,
int[][] dp)
{
// Base Cases
if (sum == N && K == 0) {
return 1;
}
if (sum >= N && K >= 0) {
return 0;
}
if (K < 0) {
return 0;
}
// If the result is already memoised
if (dp[sum][K] != -1) {
return dp[sum][K];
}
// Recursive Calls
int cnt = 0;
for (int i = 1; i <= N; i++) {
cnt += countWaysUtil(N, K - 1, sum + i, dp);
}
// Returning answer
return dp[sum][K] = cnt;
}
static void countWays(int N, int K)
{
int[][] dp = new int[N + 1][K + 1];
for (int i = 0; i < N + 1; i++) {
for (int j = 0; j < K + 1; j++) {
dp[i][j] = -1;
}
}
System.out.print(countWaysUtil(N, K, 0, dp));
}
// Driver Code
public static void main(String[] args)
{
int N = 7, K = 3;
countWays(N, K);
}
}
// This code is contributed by ukasp.
# Python3 program for the above approach
# Function to count all the possible
# combinations of K numbers having
# sum equals to N
def countWaysUtil(N, K, sum, dp):
# Base Cases
if (sum == N and K == 0):
return 1
if (sum >= N and K >= 0):
return 0
if (K < 0):
return 0
# If the result is already memoised
if (dp[sum][K] != -1):
return dp[sum][K]
# Recursive Calls
cnt = 0
for i in range(1, N+1):
cnt += countWaysUtil(N, K - 1, sum + i, dp)
# Returning answer
dp[sum][K] = cnt
return dp[sum][K]
def countWays(N, K):
dp = [[-1 for _ in range(K + 1)]
for _ in range(N + 1)]
print(countWaysUtil(N, K, 0, dp))
# Driver Code
if __name__ == "__main__":
N = 7
K = 3
countWays(N, K)
# This code is contributed by rakeshsahni
// C# implementation for the above approach
using System;
class GFG
{
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
static int countWaysUtil(int N, int K, int sum,
int [,]dp)
{
// Base Cases
if (sum == N && K == 0) {
return 1;
}
if (sum >= N && K >= 0) {
return 0;
}
if (K < 0) {
return 0;
}
// If the result is already memoised
if (dp[sum, K] != -1) {
return dp[sum, K];
}
// Recursive Calls
int cnt = 0;
for (int i = 1; i <= N; i++) {
cnt += countWaysUtil(
N, K - 1,
sum + i, dp);
}
// Returning answer
return dp[sum, K] = cnt;
}
static void countWays(int N, int K)
{
int [,]dp = new int[N + 1, K + 1];
for(int i = 0; i < N + 1; i++) {
for(int j = 0; j < K + 1; j++) {
dp[i, j] = -1;
}
}
Console.Write(countWaysUtil(N, K, 0, dp));
}
// Driver Code
public static void Main()
{
int N = 7, K = 3;
countWays(N, K);
}
}
// This code is contributed by Samim Hossain Mondal.
<script>
// Javascript program for the above approach
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
function countWaysUtil(N, K, sum, dp) {
// Base Cases
if (sum == N && K == 0) {
return 1;
}
if (sum >= N && K >= 0) {
return 0;
}
if (K < 0) {
return 0;
}
// If the result is already memoised
if (dp[sum][K] != -1) {
return dp[sum][K];
}
// Recursive Calls
let cnt = 0;
for (let i = 1; i <= N; i++) {
cnt += countWaysUtil(
N, K - 1,
sum + i, dp);
}
// Returning answer
return dp[sum][K] = cnt;
}
function countWays(N, K) {
let dp = new Array(N + 1).fill(0).map(() => new Array(K + 1).fill(-1))
document.write(countWaysUtil(N, K, 0, dp));
}
// Driver Code
let N = 7, K = 3;
countWays(N, K);
// This code is contributed by saurabh_jaiswal.
</script>
Time Complexity: O(N*K)
Space Complexity: O(N*K)
Efficient Approach: This problem can also be solved using the binomial theorem. As the required sum is N with K elements, so suppose the K numbers are:
a1 + a2 + a3 + a4 + ........ + aK = N
According to the standard principle of partitioning in the binomial theorem, the above equation has a solution which is N+K-1CK-1, where K>=0.
But in our case, K>=1.
So, therefore N should be substituted with N-K and the equation becomes N-1CK-1
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <iostream>
using namespace std;
// Method to find factorial of given number
int factorial(int n)
{
if (n == 0)
return 1;
return n * factorial(n - 1);
}
// Function to count all the possible
// combinations of K numbers having
// sum equals to N
int totalWays(int N, int K)
{
// If N<K
if (N < K)
return 0;
// Storing numerator
int n1 = factorial(N - 1);
// Storing denominator
int n2 = factorial(K - 1) * factorial(N - K);
int ans = (n1 / n2);
// Returning answer
return ans;
}
// Driver code
int main()
{
int N = 7;
int K = 3;
int ans = totalWays(N, K);
cout << ans;
return 0;
}
// This code is contributed by Shubham Singh
// C Program for the above approach
#include <stdio.h>
// method to find factorial of given number
int factorial(int n)
{
if (n == 0)
return 1;
return n*factorial(n - 1);
}
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
int totalWays(int N, int K) {
// If N<K
if (N < K)
return 0;
// Storing numerator
int n1 = factorial(N - 1);
// Storing denominator
int n2 = factorial(K - 1)*factorial(N - K);
int ans = (n1/n2);
// Returning answer
return ans;
}
// Driver method
int main()
{
int N = 7;
int K = 3;
int ans = totalWays(N, K);
printf("%d",ans);
return 0;
}
// This code is contributed by Shubham Singh
// Java Program for the above approach
class Solution{
// method to find factorial of given number
static int factorial(int n)
{
if (n == 0)
return 1;
return n*factorial(n - 1);
}
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
static int totalWays(int N, int K) {
// If N<K
if (N < K)
return 0;
// Storing numerator
int n1 = factorial(N - 1);
// Storing denominator
int n2 = factorial(K - 1)*factorial(N - K);
int ans = (n1/n2);
// Returning answer
return ans;
}
// Driver method
public static void main(String[] args)
{
int N = 7;
int K = 3;
int ans = totalWays(N, K);
System.out.println(ans);
}
}
// This code is contributed by umadevi9616
# Python Program for the above approach
from math import factorial
class Solution:
# Function to count
# all the possible combinations
# of K numbers having sum equals to N
def totalWays(self, N, K):
# If N<K
if (N < K):
return 0
# Storing numerator
n1 = factorial(N-1)
# Storing denominator
n2 = factorial(K-1)*factorial(N-K)
ans = (n1//n2)
# Returning answer
return ans
# Driver Code
if __name__ == '__main__':
N = 7
K = 3
ob = Solution()
ans = ob.totalWays(N, K)
print(ans)
// C# Program for the above approach
using System;
public class Solution {
// method to find factorial of given number
static int factorial(int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
// Function to count
// all the possible combinations
// of K numbers having sum equals to N
static int totalWays(int N, int K) {
// If N<K
if (N < K)
return 0;
// Storing numerator
int n1 = factorial(N - 1);
// Storing denominator
int n2 = factorial(K - 1) * factorial(N - K);
int ans = (n1 / n2);
// Returning answer
return ans;
}
// Driver method
public static void Main(String[] args) {
int N = 7;
int K = 3;
int ans = totalWays(N, K);
Console.WriteLine(ans);
}
}
// This code is contributed by umadevi9616
<script>
// Javascript program for the above approach
// Method to find factorial of given number
function factorial(n)
{
if (n == 0)
return 1;
return n * factorial(n - 1);
}
// Function to count all the possible
// combinations of K numbers having
// sum equals to N
function totalWays( N, K)
{
// If N<K
if (N < K)
return 0;
// Storing numerator
let n1 = factorial(N - 1);
// Storing denominator
let n2 = factorial(K - 1) * factorial(N - K);
let ans = (n1 / n2);
// Returning answer
return ans;
}
// Driver code
let N = 7;
let K = 3;
let ans = totalWays(N, K);
document.write(ans);
// This code is contributed by Shubham Singh
</script>
Time complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
Count of all valid combinations of at most K numbers that sum up to N Given two numbers N and K, the task is to find the count of all valid combinations of at most K numbers that sum up to N such that the following conditions are true: Only numbers 1 through 9 are used.Each number is used at most once. Examples: Input: K = 3, N = 7Output: 5Explanation:1 2 41 62 53 47
7 min read
Find all valid combinations of at most K numbers that sum up to N Given two numbers N and K, the task is to find all valid combinations of at most K numbers that sum up to N such that the following conditions are true: Only numbers 1 through 9 are used.Each number is used at most once. Return a list of all possible valid combinations Examples: Input: K = 3, N = 7O
8 min read
Print combinations of distinct numbers which add up to give sum N Given a positive integer N, the task is to find out all the combinations of positive integers that add upto the given integer N. The program should print only combinations, not permutations and all the integers in a combination must be distinct. For example, for input 3, either 1, 2 or 2, 1 should b
8 min read
Find all combinations that add upto given number Given a positive number, find out all combinations of positive numbers that adds upto that number. The program should print only combinations, not permutations. For example, for input 3, either 1, 2 or 2, 1 should be printed.Examples : Input: N = 3Output:1 1 11 23Input: N = 5Output:1 1 1 1 11 1 1 21
9 min read
Sum of products of all combination taken (1 to n) at a time Given N, we have to find the sum of products of all combinations taken 1 to N at a time. In simple words, we have to find the sum of products of all combinations taken 1 at a time, then 2 at a time, then 3 at a time till N at a time. If you think closely about the problem, a large value of N could r
15+ min read