Find Minimum Number Of Coins
Dora, the explorer, visits India and decides to try the famous Indian food. However, the restaurant accepts only Indian currency i.e. [1, 2, 5, 10, 20, 50, 100, 500, 1000] valued coins.

So, Dora goes to a bank that has an infinite supply of each of the denominations to make a change for a given ‘Amount’ of money. As a cashier at the bank, your task is to provide Dora the minimum number of coins that add up to the given ‘Amount’.

For Example

For Amount = 70, the minimum number of coins required is 2 i.e an Rs. 50 coin and a Rs. 20 coin.

Note

It is always possible to find the minimum number of coins for the given amount. So, the answer will always exist.

Input Format

The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows. The only line of each test case contains a single integer ‘Amount’ representing the amount Dora wishes to change to Indian currency.

Output Format

For each test case, print the minimum number of coins needed to make the change. Print the output of each test case in a separate line.

Note

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

Constraints

1

Question

Find Minimum Number Of Coins

Dora, the explorer, visits India and decides to try the famous Indian food. However, the restaurant accepts only Indian currency i.e. [1, 2, 5, 10, 20, 50, 100, 500, 1000] valued coins.

So, Dora goes to a bank that has an infinite supply of each of the denominations to make a change for a given ‘Amount’ of money. As a cashier at the bank, your task is to provide Dora the minimum number of coins that add up to the given ‘Amount’.

For Example

For Amount = 70, the minimum number of coins required is 2 i.e an Rs. 50 coin and a Rs. 20 coin.

Note

It is always possible to find the minimum number of coins for the given amount. So, the answer will always exist.

Input Format

The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows.

The only line of each test case contains a single integer ‘Amount’ representing the amount Dora wishes to change to Indian currency.

Output Format

For each test case, print the minimum number of coins needed to make the change.

Print the output of each test case in a separate line.

Note

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

Constraints

1 <= T <= 100
1 <= Amount <= 10^5
Where 'T' is the number of test-cases
Time Limit: 1sec

Accepted Answer

Dynamic Programming

We can use dynamic programming to solve this problem.

We maintain a vector ‘dp’ of size AMOUNT+1 and initialize it to a maximum value (say AMOUNT + 1). Here, dp[i] stores the minimum number of coins needed to change an amount ‘i’.

Algorithm

We set dp[0] to 0 as minimum coins to change an amount of ‘0’ is 0.
We then traverse denominations from beginning to end (loop variable i).
- We loop from denominations[i] to amount (loop variable j).
  - Now, if we pick the i-th coin, we will be interested in minimum coins needed to make a change of amount j - denominations[i].
  - So, we set dp[j] to the minimum of dp[j] and dp[j - denominations[i]] + 1.
Finally, we return dp[amount] as answer.

Space Complexity: OtherExplanation:

O(Amount), where 'Amount; represents the given amount to be changed.

We are making a ‘dp’ array/list of size Amount + 1 to store the minimum coins required for amounts from 1 to Amount. So, the overall space complexity is O(Amount).

Time Complexity: OtherExplanation:

O(N * Amount), where ‘N’ denotes the size of the denomination array and ‘Amount’ represents the amount to be changed.

For every denomination value, we are filling the ‘dp’ array. In the worst case, the time complexity will be O(N*AMOUNT).

Java (SE 1.8)

/*

    Time Complexity: O(Amount*N)

    Space Complexity: O(Amount)



    where 'Amount' is the given amount to be changed

    and N is the nuber of denominations given.

*/



import java.util.ArrayList;

import java.util.Arrays;



public class Solution

{

public static int findMinimumCoins(int amount)

    {

        // Array to store denominations.

        ArrayList denominations = new ArrayList();

        denominations.add(1);

        denominations.add(2);

        denominations.add(5);

        denominations.add(10);

        denominations.add(20);

        denominations.add(50);

        denominations.add(100);

        denominations.add(500);

        denominations.add(1000);

        int n = denominations.size();



        int maxVal = amount + 1;



        // Initialize all values of 'dp' array with 'maxVal'.

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

        Arrays.fill(dp, maxVal);



        dp[0] = 0;



        // Pick each coin

        for (int i = 0; i < n; i++)

        {

            for (int j = denominations.get(i); j <= amount; j++)

            {

                int x = Math.min(dp[j], dp[j - (denominations.get(i))] + 1);

                dp[j] = x;

            }

        }



        return dp[amount];

    }

}

C++ (g++ 5.4)

/*

    Time Complexity: O(Amount*N)

    Space Complexity: O(Amount)



    where 'Amount' is the given amount to be changed

    and N is the nuber of denominations given.

*/



int findMinimumCoins(int amount) 

{

	// Array to store denominations.

	vector denominations = {1, 2, 5, 10, 20, 50, 100, 500, 1000};

    int n = denominations.size();

   

    int maxVal = amount + 1;

    

    // Initialize all values of 'dp' array with 'maxVal'.

    vector dp(amount + 1, maxVal);



    dp[0] = 0;



    // Pick each coin

    for (int i = 0; i < n; i++)

    {

        for (int j = denominations[i]; j <= amount; j++)

        {

                dp[j] = min(dp[j], dp[j - denominations[i]] + 1);

        }

    }

   

    return dp[amount];

}

Python (3.5)

'''

    Time Complexity: O(AMOUNT * N)

    Space Complexity: O(AMOUNT)



    where AMOUNT is the given amount to be changed

    and N is the size of DENOMINATIONS array/list.

'''





denominations = [1, 2, 5, 10, 20, 50, 100, 500, 1000]





def findMinimumCoins(amount):

    n = len(denominations)



    maxVal = amount + 1



    dp =  [maxVal] * (amount + 1)



    dp[0] = 0



    # Pick each coin

    for i in range(n):

        for j in range(denominations[i], amount + 1):

                dp[j] = min(dp[j], dp[j - denominations[i]] + 1)



    return dp[amount]

Accepted Answer

Greedy Approach

We will use the greedy approach to solve our problem. The intuition behind this idea is that since we need to minimize the total number of coins needed to make the change, taking coins with large denominations (i.e. the best available option) in each iteration can yield the best overall result.

Algorithm

We will first sort the ‘denominations’ array, if not sorted.
We initialize ‘coinsCount’ to 0 and traverse ‘denominations’ from the end to the beginning.
- While denominations[i] is greater than or equal to ‘amount’-
  - We increment ‘coinsCount’ by one.
  - We subtract denominations[i] from ‘amount’.
- If ‘amount’ becomes 0, it means we have found a solution. So, we simply break from the loop.
Finally, we return ‘coinsCount’ as our result.

Space Complexity: O(1)Explanation:

O(1)

Constant space is used.

Time Complexity: OtherExplanation:

O(Amount), where ‘Amount’ represents the amount to be changed.

In the worst case, we will end up removing the highest denomination coin most of the times. Note that the coins with a lesser denomination will not get picked by more than two times because there always exists a higher denomination for equivalent value.

Java (SE 1.8)

/*

    Time Complexity: O(Amount)

    Space Complexity: O(1)



    where 'Amount' is the given amount to be changed.

*/



import java.util.ArrayList;



public class Solution

{

public static int findMinimumCoins(int amount)

    {

        // Array to store denominations.

        ArrayList denominations = new ArrayList();

        denominations.add(1);

        denominations.add(2);

        denominations.add(5);

        denominations.add(10);

        denominations.add(20);

        denominations.add(50);

        denominations.add(100);

        denominations.add(500);

        denominations.add(1000);



        int coinsCount = 0;

        int n = denominations.size();



        // Pick coins in decreasing order of their values

        for (int i = n - 1; i >= 0; i--)

        {

            while (amount >= denominations.get(i))

            {

                amount = amount - denominations.get(i);

                coinsCount++;

            }

        }



        return coinsCount;

    }

}

C++ (g++ 5.4)

/*

    Time Complexity: O(Amount)

    Space Complexity: O(1)



    where 'Amount' is the given amount to be changed.

*/



int findMinimumCoins(int amount) 

{

	// Array to store denominations.

	vector denominations = {1, 2, 5, 10, 20, 50, 100, 500, 1000};

    int coinsCount = 0; 

    int n = denominations.size();



    // Pick coins in decreasing order of their values

    for (int i = n - 1; i >= 0; i--) 

    { 

        while (amount >= denominations[i]) 

        { 

            amount = amount - denominations[i]; 

            coinsCount++; 

        } 

    } 



    return coinsCount; 

}

Python (3.5)

'''

    Time Complexity: O(AMOUNT/1000)

    Space Complexity: O(1)



    where AMOUNT is the given amount to be changed.

'''





denominations = [1, 2, 5, 10, 20, 50, 100, 500, 1000]





def findMinimumCoins(amount):

    coinsCount = 0

    n = len(denominations)



    # Pick coins in decreasing order of their values

    for i in range(n - 1, -1, -1):

        

        while amount >= denominations[i]:  

            amount -= denominations[i]

            coinsCount += 1



    return coinsCount

Accepted Answer

Optimized Greedy Approach

We know that if we have an amount of X and a certain type of coin, say Y, then we can make a change of int(X/Y) coins and an amount of X%Y will remain unchanged. So, we can use this idea to further optimize our previous approach in which we were counting a coin again and again.

Algorithm

We will first sort the ‘denominations’ array/list, if not sorted.
We initialize ‘coinsCount’ to 0 and traverse ‘denominations’ from the end to the beginning.
- Increment ‘coinsCount’ by int(AMOUNT / denominations[i]).
- Set ‘AMOUNT’ to AMOUNT % denominations[i].
Finally, we return ‘coinsCount’ as our result.

Space Complexity: O(1)Explanation:

O(1)

Constant space is used.

Time Complexity: O(n)Explanation:

O(N), where N denotes the size of denomination array/list.

In the worst case, we might end up picking every coin in our change.

C++ (g++ 5.4)

/*

    Time Complexity: O(N)

    Space Complexity: O(1)



    where 'N' is the number of denominations given.

*/



int findMinimumCoins(int amount) 

{

	// Array to store denominations.

	vector denominations = {1, 2, 5, 10, 20, 50, 100, 500, 1000};

	

	// Variable to store result.

    int coinsCount = 0; 

    int n = denominations.size();



    // Pick coins in decreasing order of their values

    for (int i = n - 1; i >= 0; i--) 

    {

        coinsCount += amount / denominations[i];

        amount %= denominations[i];

    }



    return coinsCount; 

}

Python (3.5)

'''

    Time Complexity: O(N)

    Space Complexity: O(1)



    where N is the size of DENOMINATIONS array/list.

'''





denominations = [1, 2, 5, 10, 20, 50, 100, 500, 1000]





def findMinimumCoins(amount):

    coinsCount = 0

    n = len(denominations)



    # Pick coins in decreasing order of their values

    for i in range(n - 1, -1, -1):

        

        coinsCount += amount // denominations[i]

        amount %= denominations[i]



    return coinsCount

Java (SE 1.8)

/*

    Time Complexity: O(N)

    Space Complexity: O(1)



    where 'N' is the number of denominations given.

*/



import java.util.ArrayList;



public class Solution

{

public static int findMinimumCoins(int amount)

    {

        // Array to store denominations.

        ArrayList denominations = new ArrayList();

        denominations.add(1);

        denominations.add(2);

        denominations.add(5);

        denominations.add(10);

        denominations.add(20);

        denominations.add(50);

        denominations.add(100);

        denominations.add(500);

        denominations.add(1000);



        int coinsCount = 0;

        int n = denominations.size();



        // Pick coins in decreasing order of their values

        for (int i = n - 1; i >= 0; i--)

        {

            coinsCount = coinsCount + (amount / denominations.get(i));

            amount %= denominations.get(i);

        }



        return coinsCount;

    }

}

Dora, the explorer, visits India and decides to try the famous Indian food. However, the restaurant accepts only Indian currency i.e. [1, 2, 5, 10, 20, 50, 100, 500, 1000] valued coins.

So, Dora goes to a bank that has an infinite supply of each of the denominations to make a change for a given ‘Amount’ of money. As a cashier at the bank, your task is to provide Dora the minimum number of coins that add up to the given ‘Amount’.

For Example

Note

Input Format

Output Format

Note

Constraints

Top Paytm Software Engineer interview questions & answers

Popular interview questions of Software Engineer

Top HR questions asked in Paytm Software Engineer