Number of arrays of size N whose elements are positive integers and sum is K
Given two positive integers N and K. The task is to find the number of arrays of size N that can be formed such that elements of the array should be positive integers and the sum of elements is equal to K.
Examples:
Input : N = 2, K = 3
Output : 2
Explanation: [1, 2] and [2, 1] are the only arrays of size 2 whose sum is 3.
Input : n = 3, k = 7
Output : 15
Prerequisite: Stars and Bars
Suppose there are K identical objects which needs to be placed in N bins (N indices of the array) such that each bin have at least one object. Instead of starting to place objects into bins, we start placing the objects on a line, where the object for the first bin will be taken from the left, followed by the objects for the second bin, and so forth. Thus, the configuration will be determined once one knows what is the first object going to the second bin, and the first object going to the third bin, and so on. We can indicate this by placing N X 1 separating bars at some places between two objects; since no bin is allowed to be empty, there can be at most one bar between a given pair of objects. So, we have K objects in a line with K – 1 gaps. Now we have to choose N – 1 gaps to place bars from K – 1 gaps. This can be chosen by K – 1CN – 1.
Below is implementation of this approach:
C++
#include <bits/stdc++.h>
using namespace std;
int binomialCoeff( int n, int k)
{
int C[k + 1];
memset (C, 0, sizeof (C));
C[0] = 1;
for ( int i = 1; i <= n; i++) {
for ( int j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
int countArray( int N, int K)
{
return binomialCoeff(K - 1, N - 1);
}
int main()
{
int N = 2, K = 3;
cout << countArray(N, K) << endl;
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int binomialCoeff( int n,
int k)
{
int []C = new int [k + 1 ];
C[ 0 ] = 1 ;
for ( int i = 1 ; i <= n; i++)
{
for ( int j = Math.min(i, k); j > 0 ; j--)
C[j] = C[j] + C[j - 1 ];
}
return C[k];
}
static int countArray( int N, int K)
{
return binomialCoeff(K - 1 , N - 1 );
}
public static void main (String[] args)
{
int N = 2 , K = 3 ;
System.out.println( countArray(N, K));
}
}
|
Python3
def binomialCoeff(n, k):
C = [ 0 ] * (k + 1 );
C[ 0 ] = 1 ;
for i in range ( 1 , n + 1 ):
for j in range ( min (i, k), 0 , - 1 ):
C[j] = C[j] + C[j - 1 ];
return C[k];
def countArray(N, K):
return binomialCoeff(K - 1 , N - 1 );
N = 2 ;
K = 3 ;
print (countArray(N, K));
|
C#
using System;
class GFG
{
static int binomialCoeff( int n,
int k)
{
int []C = new int [k + 1];
C[0] = 1;
for ( int i = 1; i <= n; i++)
{
for ( int j = Math.Min(i, k);
j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
static int countArray( int N,
int K)
{
return binomialCoeff(K - 1,
N - 1);
}
static public void Main ()
{
int N = 2, K = 3;
Console.WriteLine(
countArray(N, K));
}
}
|
PHP
<?php
function binomialCoeff( $n , $k )
{
$C = array_fill (0, ( $k + 1), 0);
$C [0] = 1;
for ( $i = 1; $i <= $n ; $i ++)
{
for ( $j = min( $i , $k );
$j > 0; $j --)
$C [ $j ] = $C [ $j ] +
$C [ $j - 1];
}
return $C [ $k ];
}
function countArray( $N , $K )
{
return binomialCoeff( $K - 1,
$N - 1);
}
$N = 2;
$K = 3;
echo countArray( $N , $K );
?>
|
Javascript
<script>
function binomialCoeff(n, k)
{
var C = Array(k+1).fill(0);
C[0] = 1;
for ( var i = 1; i <= n; i++) {
for ( var j = Math.min(i, k); j > 0; j--)
C[j] = C[j] + C[j - 1];
}
return C[k];
}
function countArray(N, K)
{
return binomialCoeff(K - 1, N - 1);
}
var N = 2, K = 3;
document.write( countArray(N, K));
</script>
|
Time Complexity : O(N*K).
Auxiliary Space: O(K)
Last Updated :
07 Jan, 2024
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...