Coin change
Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = { S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins doesn’t matter.

Question

Coin change

Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = { S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins doesn’t matter.

Accepted Answer

First I thought of the recursion approach but the complexity of that approach was exponential and that solution was not passing any test case, then I thought of DP approach and use the concept of include and exclude current coin to find total number of ways and that passed all test cases. This was just submitted one minute before the deadline of the test.

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).

Top Barclays Software Developer interview questions & answers

Popular interview questions of Software Developer

Top HR questions asked in Barclays Software Developer