Ways To Make Coin Change
You are given an infinite supply of coins of each of denominations D = {D0, D1, D2, D3, ...... Dn-1}. You need to figure out the total number of ways W, in which you can make a change for value V using coins of denominations from D. Print 0, if a change isn't possible.

Input Format

The first line of input contains an integer N, representing the total number of denominations. The second line of input contains N integers values separated by a single space. Each integer value represents the denomination value. The third line of input contains the value of V, representing the value for which the change needs to be generated.

Output Format:

For each test case, print an integer denoting the total number of ways W, in which a change for V is possible.

Note:

You do not need to print anything, it has already been taken care of. Just implement the given function.

Constraints :

1

Question

Ways To Make Coin Change

You are given an infinite supply of coins of each of denominations D = {D0, D1, D2, D3, ...... Dn-1}. You need to figure out the total number of ways W, in which you can make a change for value V using coins of denominations from D. Print 0, if a change isn't possible.

Input Format

The first line of input contains an integer N, representing the total number of denominations.

The second line of input contains N integers values separated by a single space. Each integer value represents the denomination value.

The third line of input contains the value of V, representing the value for which the change needs to be generated.

Output Format:

For each test case, print an integer denoting the total number of ways W, in which a change for V is possible.

Note:

You do not need to print anything, it has already been taken care of. Just implement the given function.

Constraints :

1 <= N <= 10
1 <= D[i] <=10^5
1 <= V <= 2 * 10^3

Where 'D[i]' represent the value of ith denomination. 

Time Limit: 1sec

Accepted Answer

Recursion

The idea is to use recursion.
For a particular coin, we have two options either include it or exclude it.
If we include that coin, then calculate the remaining number that we have to generate so recur for that remaining number.
If we exclude that coin, then recur for the same amount that we have to make.
Our final answer would be the total number of ways either by including or excluding.
There will be two edge cases in recursion that are: if the total amount we have is zero then return 1 (solution found) and if the total amount we have become negative or no elements are left then return zero that is if (n < 0 || value < 0) then return 0.

Space Complexity: O(n)Explanation:

O(N), where N is the total number of coins.

As we are not using any memory to store anything, but we are recurring, so stack space will get considered.

Time Complexity: O(2^n)Explanation:

O(2^N), where N is the total number of coins.

Because for every coin we are making two recursion calls.

Accepted Answer

Recursion And Memoization

The idea is to use recursion and memoization. So first create a 2D array 'memo' that will store the answer of all subproblems that we compute.
For a particular coin, if the answer is already present in the map, then just return it.
Otherwise, we have two options either include it or exclude it.
If we include that coin, then calculate the remaining number that we have to generate so recur for that remaining number.
If we exclude that coin, then recur for the same amount that we have to make.
Our final answer would be the total number of ways either by including or excluding.
Store the answer on the map before returning.

Space Complexity: O(m*n) - For 2d arraysExplanation:

O(N*V), where N is the total number of coins and V is the value

As we are creating a 2D array memo to store answers.

Time Complexity: O(m*n) - For 2d arraysExplanation:

O(N*V), where N is the total number of coins and V is the value

As there are total N*V unique subproblems. So overall time complexity will be O(N*V).

Accepted Answer

Iterative DP

The idea is to use dynamic programming.
Create a two-dimensional array, ‘ways’, where ‘ways[i][j]’ will denote the total number of ways to make j value by using i coins.
Fill dp array by the recurrence relation as follows:

ways[i][j] = ways[i-1][j] + ways[i][j-denominations[i]]

Where first term represents that we have excluded that coin and,

Second term represents that we have included that coin.

Space Complexity: O(m*n) - For 2d arraysExplanation:

O(N*V), where N is the total number of coins and V is the value.

As we are creating a ‘ways’ array to store answers. So, overall space complexity will be O(N*V).

Time Complexity: O(m*n) - For 2d arraysExplanation:

O(N*V), where N is the total number of coins and V is the value.

Since we are constructing the array ‘ways’ which take O(N*V) time. Therefore, overall time complexity will be O(N*V).

Accepted Answer

Space Optimised Iterative Approach

The idea is to use dynamic programming
As by recurrence relation of previous approach, we can easily see that it is only dependent on previous row, so we can optimise the space complexity
Create a one-dimensional array and run a nested loop
So dp[i] will be storing the number of solutions for value i

Space Complexity: O(n)Explanation:

O(V), where V is the value.

As we are creating a one-dimensional ‘dp’ array to store answers. So, overall space complexity will be O(V).

Time Complexity: O(m*n) - For 2d arraysExplanation:

O(N * V), where N is the total number of coins and V is the value.

Since each state of ‘dp’ array will be storing the number of solutions for each value present in the denomination array which take O(N*V) time. So overall time complexity will be O(N*V).

Accepted Answer

public class CoinChangeWays {

public static void main(String[] args) {

int[] denominations = {1, 2, 5};

int value = 5;

int ways = countWaysToMakeChange(denominations, value);

System.out.println("Total number of ways to make change: " + ways);

}

public static int countWaysToMakeChange(int[] denominations, int value) {

int[] dp = new int[value + 1];

dp[0] = 1; // There is one way to make change for 0

for (int coin : denominations) {

for (int i = coin; i <= value; i++) {

dp[i] += dp[i - coin];

}

return dp[value];

}

Accepted Answer

Thank you it is use full for me

You are given an infinite supply of coins of each of denominations D = {D0, D1, D2, D3, ...... Dn-1}. You need to figure out the total number of ways W, in which you can make a change for value V using coins of denominations from D. Print 0, if a change isn't possible.

Input Format

Output Format:

Note:

Constraints :

Top Cloud Analogy Software Developer interview questions & answers

Popular interview questions of Software Developer

Top HR questions asked in Cloud Analogy Software Developer