Number of ways to sum up a total of N from limited denominations
Given a number N and two arrays arr1[] and arr2[] of length 4. The array arr1[] denotes the denomination of 1, 5, 10, and 20 and arr2[] denotes the count of denominations of 1, 5, 10, and 20 respectively. The task is to find the number of ways in which we can sum them up to a total of N with a limited number of denominations.
Examples:
Input: arr1[] = {1, 5, 10, 20}, arr2[] = {6, 4, 3, 5}, N = 123
Output: 5
Explanation:
There are 5 ways to sum up to 123 with the given denomination of coins.
Input: arr1[] = {1, 5, 10, 20}, arr2[] = {1, 3, 2, 1}, N = 50
Output: 1
Explanation:
There is only 1 way to sum up to 50 with the given denomination of coins.
Naive Approach: Let the count of denominations be represented by A, B, C, and D. The naive approach is to run nested loops. Each loop will refer to the number of coins of each denomination. Find the number of coins of each denomination required to make N by the equation:
(a * 1) + (b * 5) + (c * 10) + (d * 20)) == N
where 0 <= a <= A, 0 &<= b <= B, 0 <= c <= C, 0 <= d <= D and N is the total amount.
Time Complexity: O(N4)
Auxiliary Space: O(1)
Better Approach: We can optimize the above naive approach by adding some extra bounds to the loops which will reduce some computations. By observing, we can easily reduce the complexity by discarding one loop by removing coin with denomination 1 from N and check if the below inequality holds true or not:
(N – A) <= (b * 5 + c * 10 + d * 20) <= N
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int calculateWays( int arr1[], int arr2[],
int N)
{
int A = arr2[0], B = arr2[1];
int C = arr2[2], D = arr2[3];
int ans = 0;
for ( int b = 0;
b <= B && b * 5 <= (N); b++)
for ( int c = 0;
c <= C
&& b * 5 + c * 10 <= (N);
c++)
for ( int d = 0;
d <= D
&& b * 5 + c * 10 + d * 20 <= (N);
d++)
if ((b * 5) + (c * 10)
+ (d * 20)
>= (N - A))
ans++;
return ans;
}
int main()
{
int N = 123;
int arr1[] = { 1, 5, 10, 20 };
int arr2[] = { 6, 4, 3, 5 };
cout << calculateWays(arr1, arr2, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int calculateWays( int arr1[], int arr2[],
int N)
{
int A = arr2[ 0 ], B = arr2[ 1 ];
int C = arr2[ 2 ], D = arr2[ 3 ];
int ans = 0 ;
for ( int b = 0 ;
b <= B && b * 5 <= (N); b++)
for ( int c = 0 ;
c <= C && b * 5 + c * 10 <= (N);
c++)
for ( int d = 0 ;
d <= D &&
b * 5 + c * 10 + d * 20 <= (N);
d++)
if ((b * 5 ) + (c * 10 ) +
(d * 20 ) >= (N - A))
ans++;
return ans;
}
public static void main(String[] args)
{
int N = 123 ;
int arr1[] = { 1 , 5 , 10 , 20 };
int arr2[] = { 6 , 4 , 3 , 5 };
System.out.print(calculateWays(arr1, arr2, N));
}
}
|
Python3
def calculateWays(arr1, arr2, N):
A = arr2[ 0 ]
B = arr2[ 1 ]
C = arr2[ 2 ]
D = arr2[ 3 ]
ans, b, c, d = 0 , 0 , 0 , 0
while b < = B and b * 5 < = (N):
c = 0
while (c < = C and
b * 5 + c * 10 < = (N)):
d = 0
while (d < = D and
b * 5 + c * 10 +
d * 20 < = (N)):
if ((b * 5 ) + (c * 10 ) +
(d * 20 ) > = (N - A)):
ans + = 1
d + = 1
c + = 1
b + = 1
return ans
if __name__ = = '__main__' :
N = 123
arr1 = [ 1 , 5 , 10 , 20 ]
arr2 = [ 6 , 4 , 3 , 5 ]
print (calculateWays(arr1, arr2, N))
|
C#
using System;
class GFG{
static int calculateWays( int []arr1, int []arr2,
int N)
{
int A = arr2[0], B = arr2[1];
int C = arr2[2], D = arr2[3];
int ans = 0;
for ( int b = 0;
b <= B && b * 5 <= (N); b++)
for ( int c = 0;
c <= C && b * 5 + c * 10 <= (N);
c++)
for ( int d = 0;
d <= D &&
b * 5 + c * 10 + d * 20 <= (N);
d++)
if ((b * 5) + (c * 10) +
(d * 20) >= (N - A))
ans++;
return ans;
}
public static void Main(String[] args)
{
int N = 123;
int []arr1 = { 1, 5, 10, 20 };
int []arr2 = { 6, 4, 3, 5 };
Console.Write(calculateWays(arr1, arr2, N));
}
}
|
Javascript
<script>
function calculateWays(arr1, arr2,
N)
{
let A = arr2[0], B = arr2[1];
let C = arr2[2], D = arr2[3];
let ans = 0;
for (let b = 0;
b <= B && b * 5 <= (N); b++)
for (let c = 0;
c <= C && b * 5 + c * 10 <= (N);
c++)
for (let d = 0;
d <= D &&
b * 5 + c * 10 + d * 20 <= (N);
d++)
if ((b * 5) + (c * 10) +
(d * 20) >= (N - A))
ans++;
return ans;
}
let N = 123;
let arr1 = [ 1, 5, 10, 20 ];
let arr2 = [ 6, 4, 3, 5 ];
document.write(calculateWays(arr1, arr2, N));
</script>
|
Time Complexity: O(N3)
Auxiliary Space: O(1)
Efficient Approach: Let the count of denominations be represented by A, B, C, and D. The efficient approach for solving the above problem is to count the possible number of denominations formed using C and D. Then we will find the remaining value with denominations of A and B. Below are the steps:
- Initialize the array ways[] to store the precomputed sum of denominations of A and B.
- Iterate two nested loops to store the combination of values formed by denominations of A and B in ways[].
- Iterate two nested loops to find all the combinations of values formed by denominations of C and D and add all the possible combinations of the value N – (C*10 + D*20), which is equivalent to (A * 1) + (B * 5).
- The sum of all values in the above step is the required result.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int ways[1010];
int calculateWays( int arr1[], int arr2[],
int N)
{
int A = arr2[0], B = arr2[1];
int C = arr2[2], D = arr2[3];
int ans = 0;
for ( int b = 0;
b <= B && b * 5 <= N; b++) {
for ( int a = 0;
a <= A
&& a * 1 + b * 5 <= N;
a++) {
ways[a + b * 5]++;
}
}
for ( int c = 0;
c <= C && c * 10 <= (N); c++) {
for ( int d = 0;
d <= D
&& c * 10 + d * 20 <= (N);
d++) {
ans += ways[N - c * 10 - d * 20];
}
}
return ans;
}
int main()
{
int N = 123;
int arr1[] = { 1, 5, 10, 20 };
int arr2[] = { 6, 4, 3, 5 };
cout << calculateWays(arr1, arr2, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int []ways = new int [ 1010 ];
static int calculateWays( int arr1[], int arr2[],
int N)
{
int A = arr2[ 0 ], B = arr2[ 1 ];
int C = arr2[ 2 ], D = arr2[ 3 ];
int ans = 0 ;
for ( int b = 0 ;
b <= B && b * 5 <= N; b++)
{
for ( int a = 0 ;
a <= A && a * 1 + b * 5 <= N;
a++)
{
ways[a + b * 5 ]++;
}
}
for ( int c = 0 ;
c <= C && c * 10 <= (N); c++)
{
for ( int d = 0 ;
d <= D && c * 10 + d * 20 <= (N);
d++)
{
ans += ways[N - c * 10 - d * 20 ];
}
}
return ans;
}
public static void main(String[] args)
{
int N = 123 ;
int arr1[] = { 1 , 5 , 10 , 20 };
int arr2[] = { 6 , 4 , 3 , 5 };
System.out.print(calculateWays(arr1, arr2, N));
}
}
|
Python3
ways = [ 0 for i in range ( 1010 )];
def calculateWays(arr1, arr2, N):
A = arr2[ 0 ]; B = arr2[ 1 ];
C = arr2[ 2 ]; D = arr2[ 3 ];
ans = 0 ;
for b in range ( 0 , B + 1 ):
if (b * 5 > N):
break ;
for a in range ( 0 , A + 1 ):
if (a + b * 5 > N):
break ;
ways[a + b * 5 ] + = 5 ;
for c in range ( 0 , C):
if (c * 10 > N):
break ;
for d in range ( 0 , D):
if (c * 10 + d * 20 > N):
break ;
ans + = ways[N - c * 10 - d * 20 ];
return ans;
if __name__ = = '__main__' :
N = 123 ;
arr1 = [ 1 , 5 , 10 , 20 ];
arr2 = [ 6 , 4 , 3 , 5 ];
print (calculateWays(arr1, arr2, N));
|
C#
using System;
class GFG{
static int []ways = new int [1010];
static int calculateWays( int []arr1, int []arr2,
int N)
{
int A = arr2[0], B = arr2[1];
int C = arr2[2], D = arr2[3];
int ans = 0;
for ( int b = 0;
b <= B && b * 5 <= N; b++)
{
for ( int a = 0;
a <= A && a * 1 + b * 5 <= N;
a++)
{
ways[a + b * 5]++;
}
}
for ( int c = 0;
c <= C && c * 10 <= (N); c++)
{
for ( int d = 0;
d <= D && c * 10 + d * 20 <= (N);
d++)
{
ans += ways[N - c * 10 - d * 20];
}
}
return ans;
}
public static void Main(String[] args)
{
int N = 123;
int []arr1 = { 1, 5, 10, 20 };
int []arr2 = { 6, 4, 3, 5 };
Console.Write(calculateWays(arr1, arr2, N));
}
}
|
Javascript
<script>
var ways = Array(1010).fill(0);
function calculateWays(arr1, arr2, N)
{
var A = arr2[0], B = arr2[1];
var C = arr2[2], D = arr2[3];
var ans = 0;
for ( var b = 0;
b <= B && b * 5 <= N; b++) {
for ( var a = 0;
a <= A
&& a * 1 + b * 5 <= N;
a++) {
ways[a + b * 5]++;
}
}
for ( var c = 0;
c <= C && c * 10 <= (N); c++) {
for ( var d = 0;
d <= D
&& c * 10 + d * 20 <= (N);
d++) {
ans += ways[N - c * 10 - d * 20];
}
}
return ans;
}
var N = 123;
var arr1 = [1, 5, 10, 20];
var arr2 = [6, 4, 3, 5];
document.write( calculateWays(arr1, arr2, N));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(1)
Last Updated :
14 Jun, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...