 Open in App
Not now

# Greedy Algorithm to find Minimum number of Coins

• Difficulty Level : Easy
• Last Updated : 08 Feb, 2023

Given a value of V Rs and an infinite supply of each of the denominations {1, 2, 5, 10, 20, 50, 100, 500, 1000} valued coins/notes, The task is to find the minimum number of coins and/or notes needed to make the change?

Examples:

Input: V = 70
Output: 2
Explanation: We need a 50 Rs note and a 20 Rs note.

Input: V = 121
Output: 3
Explanation: We need a 100 Rs note, a 20 Rs note, and a 1 Rs coin.

Recommended Practice

Approach:

The intuition would be to take coins with greater value first. This can reduce the total number of coins needed. Start from the largest possible denomination and keep adding denominations while the remaining value is greater than 0.

Follow the steps below to implement the idea:

• Sort the array of coins in decreasing order.
• Initialize ans vector as empty.
• Find the largest denomination that is smaller than remaining amount and while it is smaller than the remaining amount:
• Add found denomination to ans. Subtract value of found denomination from amount.
• If amount becomes 0, then print ans.

Below is the implementation of above approach.

## C++

 `// C++ program to find minimum` `// number of denominations` `#include ` `using` `namespace` `std;`   `// All denominations of Indian Currency` `int` `denomination[]` `    ``= { 1, 2, 5, 10, 20, 50, 100, 500, 1000 };` `int` `n = ``sizeof``(denomination) / ``sizeof``(denomination);`   `void` `findMin(``int` `V)` `{` `    ``sort(denomination, denomination + n);`   `    ``// Initialize result` `    ``vector<``int``> ans;`   `    ``// Traverse through all denomination` `    ``for` `(``int` `i = n - 1; i >= 0; i--) {`   `        ``// Find denominations` `        ``while` `(V >= denomination[i]) {` `            ``V -= denomination[i];` `            ``ans.push_back(denomination[i]);` `        ``}` `    ``}`   `    ``// Print result` `    ``for` `(``int` `i = 0; i < ans.size(); i++)` `        ``cout << ans[i] << ``" "``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 93;` `    ``cout << ``"Following is minimal"` `         ``<< ``" number of change for "` `<< n << ``": "``;`   `    ``// Function Call` `    ``findMin(n);` `    ``return` `0;` `}`

## C

 `// C program to find minimum` `// number of denominations` `#include ` `#define COINS 9` `#define MAX 20`   `// All denominations of Indian Currency` `int` `coins[COINS] = { 1, 2, 5, 10, 20,` `                     ``50, 100, 200, 2000 };`   `void` `findMin(``int` `cost)` `{` `    ``int` `coinList[MAX] = { 0 };` `    ``int` `i, k = 0;`   `    ``for` `(i = COINS - 1; i >= 0; i--) {` `        ``while` `(cost >= coins[i]) {` `            ``cost -= coins[i];` `            ``// Add coin in the list` `            ``coinList[k++] = coins[i];` `        ``}` `    ``}`   `    ``for` `(i = 0; i < k; i++) {` `        ``// Print` `        ``printf``(``"%d "``, coinList[i]);` `    ``}` `    ``return``;` `}`   `int` `main(``void``)` `{` `    ``// input value` `    ``int` `n = 93;`   `    ``printf``(``"Following is minimal number"` `           ``"of change for %d: "``,` `           ``n);` `    ``findMin(n);` `    ``return` `0;` `}` `// Code by Munish Bhardwaj`

## Java

 `// Java program to find minimum` `// number of denominations` `import` `java.util.Vector;`   `class` `GFG ` `{`   `    ``// All denominations of Indian Currency ` `    ``static` `int` `deno[] = {``1``, ``2``, ``5``, ``10``, ``20``, ` `    ``50``, ``100``, ``500``, ``1000``};` `    ``static` `int` `n = deno.length;`   `    ``static` `void` `findMin(``int` `V)` `    ``{` `        ``// Initialize result ` `        ``Vector ans = ``new` `Vector<>();`   `        ``// Traverse through all denomination ` `        ``for` `(``int` `i = n - ``1``; i >= ``0``; i--)` `        ``{` `            ``// Find denominations ` `            ``while` `(V >= deno[i]) ` `            ``{` `                ``V -= deno[i];` `                ``ans.add(deno[i]);` `            ``}` `        ``}`   `        ``// Print result ` `        ``for` `(``int` `i = ``0``; i < ans.size(); i++)` `        ``{` `            ``System.out.print(` `                ``" "` `+ ans.elementAt(i));` `        ``}` `    ``}`   `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `n = ``93``;` `        ``System.out.print(` `            ``"Following is minimal number "` `            ``+``"of change for "` `+ n + ``": "``);` `        ``findMin(n);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find minimum ` `# number of denominations`   `def` `findMin(V):` `    `  `    ``# All denominations of Indian Currency` `    ``deno ``=` `[``1``, ``2``, ``5``, ``10``, ``20``, ``50``, ` `            ``100``, ``500``, ``1000``]` `    ``n ``=` `len``(deno)` `    `  `    ``# Initialize Result` `    ``ans ``=` `[]`   `    ``# Traverse through all denomination` `    ``i ``=` `n ``-` `1` `    ``while``(i >``=` `0``):` `        `  `        ``# Find denominations` `        ``while` `(V >``=` `deno[i]):` `            ``V ``-``=` `deno[i]` `            ``ans.append(deno[i])`   `        ``i ``-``=` `1`   `    ``# Print result` `    ``for` `i ``in` `range``(``len``(ans)):` `        ``print``(ans[i], end ``=` `" "``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``n ``=` `93` `    ``print``(``"Following is minimal number"``,` `          ``"of change for"``, n, ``": "``, end ``=` `"")` `    ``findMin(n)` `    `  `# This code is contributed by` `# Surendra_Gangwar`

## C#

 `// C# program to find minimum` `// number of denominations` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// All denominations of Indian Currency ` `static` `int` `[]deno = { 1, 2, 5, 10, 20, ` `                      ``50, 100, 500, 1000 };` `static` `int` `n = deno.Length;`   `static` `void` `findMin(``int` `V)` `{` `    `  `    ``// Initialize result ` `    ``List<``int``> ans = ``new` `List<``int``>();`   `    ``// Traverse through all denomination ` `    ``for``(``int` `i = n - 1; i >= 0; i--)` `    ``{` `        `  `        ``// Find denominations ` `        ``while` `(V >= deno[i]) ` `        ``{` `            ``V -= deno[i];` `            ``ans.Add(deno[i]);` `        ``}` `    ``}`   `    ``// Print result ` `    ``for``(``int` `i = 0; i < ans.Count; i++)` `    ``{` `        ``Console.Write(``" "` `+ ans[i]);` `    ``}` `}`   `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{` `    ``int` `n = 93;` `    ``Console.Write(``"Following is minimal number "` `+` `                  ``"of change for "` `+ n + ``": "``);` `                  `  `    ``findMin(n);` `}` `}`   `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output

`Following is minimal number of change for 93: 50 20 20 2 1 `

Time Complexity: O(V).
Auxiliary Space: O(V).

Note: The above approach may not work for all denominations.

For example, it doesn’t work for denominations {9, 6, 5, 1} and V = 11. The above approach would print 9, 1 and 1. But we can use 2 denominations 5 and 6.

For general input, below dynamic programming approach can be used: Find minimum number of coins that make a given value

Thanks to Utkarsh for providing the above solution here.

## Minimum number of Coins using Ladder If-Else approach:

In this approach, we will simply iterate through the greater to smaller coins until the n is greater to that coin and decrement that value from n afterward using ladder if-else and will push back that coin value in the vector.

Follow the steps below to implement the idea:

1. Declare a vector that store the coins.
2.  while n is greater than 0 iterate through greater to smaller coins:
1. if n is greater than equal to 2000 than push 2000 into the vector and decrement its value from n.
2. else if n is greater than equal to 500 than push 500 into the vector and decrement its value from n.
3. And so on till the last coin using ladder if else.
3.  return the vector/array

## C++

 `// C++ program to find minimum` `// number of coins` `#include ` `using` `namespace` `std;`   `vector<``int``> findMin(``int` `n)` `{` `    ``// initialize vector to store the coins` `    ``vector<``int``> v;` `    ``// iterate till n>0 and check condition according to the` `    ``// greatest coin possible` `    ``while` `(n > 0) {` `        ``if` `(n >= 2000) {` `            ``v.push_back(2000);` `            ``n -= 2000;` `        ``}` `        ``else` `if` `(n >= 500) {` `            ``v.push_back(500);` `            ``n -= 500;` `        ``}` `        ``else` `if` `(n >= 200) {` `            ``v.push_back(200);` `            ``n -= 200;` `        ``}` `        ``else` `if` `(n >= 100) {` `            ``v.push_back(100);` `            ``n -= 100;` `        ``}` `        ``else` `if` `(n >= 50) {` `            ``v.push_back(50);` `            ``n -= 50;` `        ``}` `        ``else` `if` `(n >= 20) {` `            ``v.push_back(20);` `            ``n -= 20;` `        ``}` `        ``else` `if` `(n >= 10) {` `            ``v.push_back(10);` `            ``n -= 10;` `        ``}` `        ``else` `if` `(n >= 5) {` `            ``v.push_back(5);` `            ``n -= 5;` `        ``}` `        ``else` `if` `(n >= 2) {` `            ``v.push_back(2);` `            ``n -= 2;` `        ``}` `        ``else` `if` `(n >= 1) {` `            ``v.push_back(1);` `            ``n -= 1;` `        ``}` `    ``}` `    ``// return the ans that stores in the vector` `    ``return` `v;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `v = 93;` `    ``cout << ``"Following is minimal"` `         ``<< ``" number of change for "` `<< v << ``": "``;`   `    ``// Function Call` `    ``vector<``int``> vec = findMin(v);` `    ``// print the vector` `    ``for` `(``auto` `it : vec)` `        ``cout << it << ``" "``;` `    ``return` `0;` `}` `// this code is contributed by Prateek Kumar Singh`

## Java

 `// Java program to find minimum` `import` `java.util.Vector;` ` `  `class` `GFG` `{` `    ``static` `Vector findMin(``int` `n){` `      ``// initialize vector to store the coins` `       ``Vector vec = ``new` `Vector<>();` `      ``// iterate till n>0 and check condition according to the` `    ``// greatest coin possible` `       ``while` `(n > ``0``) {` `        ``if` `(n >= ``2000``) {` `            ``vec.addElement(``2000``);` `            ``n -= ``2000``;` `        ``}` `        ``else` `if` `(n >= ``500``) {` `            ``vec.addElement(``500``);` `            ``n -= ``500``;` `        ``}` `        ``else` `if` `(n >= ``200``) {` `            ``vec.addElement(``200``);` `            ``n -= ``200``;` `        ``}` `        ``else` `if` `(n >= ``100``) {` `            ``vec.addElement(``100``);` `            ``n -= ``100``;` `        ``}` `        ``else` `if` `(n >= ``50``) {` `            ``vec.addElement(``50``);` `            ``n -= ``50``;` `        ``}` `        ``else` `if` `(n >= ``20``) {` `            ``vec.addElement(``20``);` `            ``n -= ``20``;` `        ``}` `        ``else` `if` `(n >= ``10``) {` `            ``vec.addElement(``10``);` `            ``n -= ``10``;` `        ``}` `        ``else` `if` `(n >= ``5``) {` `           ``vec.addElement(``5``);` `            ``n -= ``5``;` `        ``}` `        ``else` `if` `(n >= ``2``) {` `            ``vec.addElement(``2``);` `            ``n -= ``2``;` `        ``}` `        ``else` `if` `(n >= ``1``) {` `            ``vec.addElement(``1``);` `            ``n -= ``1``;` `        ``}` `    ``}` `    ``// return the ans that stores in the vector` `    ``return` `vec;` `}` ` `  `// Driver Code` `   ``public` `static` `void` `main(String[] args)` `    ``{` `    ``int` `n = ``93``;` `   ``System.out.print(` `            ``"Following is minimal number "` `            ``+``"of change for "` `+ n + ``": "``);` ` `  `    ``// Function Call` `    ``Vector vec = findMin(n);` `    ``// print the vector` `     ``for` `(Integer i = ``0``; i < vec.size(); i++)` `        ``{` `        ``System.out.print(vec.get(i) + ``" "``);` `     ``}` `}` `}` `// this code is contributed by Shivam Miglani`

Output

`Following is minimal number of change for 93: 50 20 20 2 1 `

Time Complexity: O(N) that is equal to the amount v.
Auxiliary Space: O(1) that is optimized

My Personal Notes arrow_drop_up
Related Articles