Greedy Algorithm to find Minimum number of Coins

Difficulty Level : Easy
Last Updated : 28 Sep, 2021

Given a value V, if we want to make a change for V Rs, and we have an infinite supply of each of the denominations in Indian currency, i.e., we have an infinite supply of { 1, 2, 5, 10, 20, 50, 100, 500, 1000} valued coins/notes, what is the minimum number of coins and/or notes needed to make the change?

Examples:

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

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

Solution: Greedy Approach.
Approach: A common 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.

Algorithm:

Sort the array of coins in decreasing order.
Initialize result as empty.
Find the largest denomination that is smaller than current amount.
Add found denomination to result. Subtract value of found denomination from amount.
If amount becomes 0, then print result.
Else repeat steps 3 and 4 for new value of V.

C++

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

C

// C program to find minimum
// number of denominations
#include <stdio.h>
#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<Integer> 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

<script>
// Javascript program to find minimum
// number of denominations
  
// All denominations of Indian Currency
let deno=[1, 2, 5, 10, 20,
    50, 100, 500, 1000];
let n = deno.length;
  
function findMin(V)
{
    // Initialize result
        let ans = [];
   
        // Traverse through all denomination
        for (let i = n - 1; i >= 0; i--)
        {
            // Find denominations
            while (V >= deno[i])
            {
                V -= deno[i];
                ans.push(deno[i]);
            }
        }
   
        // Print result
        for (let i = 0; i < ans.length; i++)
        {
            document.write(
                " " + ans[i]);
        }
}
  
// Driver code
n = 93;
document.write(
"Following is minimal number "
+"of change for " + n + ": ");
findMin(n);
  
  
// This code is contributed by rag2127
</script>

Output:

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

Complexity Analysis:

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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes