Greedy Algorithm to find Minimum number of Coins

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.

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 <bits/stdc++.h>
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[0]);

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

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.

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 <bits/stdc++.h>
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<Integer> findMin(int n){
      // initialize vector to store the coins
       Vector<Integer> 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<Integer> 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

Python3

# Python Code

# Function to find minimal number of coins


def findMin(n):

    # Vector to store the coins
    v = []

    # Iterate till n > 0
    while(n > 0):

        # check condition
        if(n >= 2000):
            v.append(2000)
            n -= 2000
        elif(n >= 500):
            v.append(500)
            n -= 500
        elif(n >= 200):
            v.append(200)
            n -= 200
        elif(n >= 100):
            v.append(100)
            n -= 100
        elif(n >= 50):
            v.append(50)
            n -= 50
        elif(n >= 20):
            v.append(20)
            n -= 20
        elif(n >= 10):
            v.append(10)
            n -= 10
        elif(n >= 5):
            v.append(5)
            n -= 5
        elif(n >= 2):
            v.append(2)
            n -= 2
        elif(n >= 1):
            v.append(1)
            n -= 1

    # Return the ans
    return v


# Driver Code
v = 93
print("Following is minimal number of change for ", v, ":")

# Function Call
vec = findMin(v)

# print the vector
for it in vec:
    print(it, end=" ")

C#

// C# program to find minimum
using System;
using System.Collections.Generic;

class GFG {
    static List<int> findMin(int n)
    {
        // initialize list to store the coins
        List<int> lst = new List<int>();

        // iterate till n>0 and check condition according to
        // the greatest coin possible
        while (n > 0) {
            if (n >= 2000) {
                lst.Add(2000);
                n -= 2000;
            }
            else if (n >= 500) {
                lst.Add(500);
                n -= 500;
            }
            else if (n >= 200) {
                lst.Add(200);
                n -= 200;
            }
            else if (n >= 100) {
                lst.Add(100);
                n -= 100;
            }
            else if (n >= 50) {
                lst.Add(50);
                n -= 50;
            }
            else if (n >= 20) {
                lst.Add(20);
                n -= 20;
            }
            else if (n >= 10) {
                lst.Add(10);
                n -= 10;
            }
            else if (n >= 5) {
                lst.Add(5);
                n -= 5;
            }
            else if (n >= 2) {
                lst.Add(2);
                n -= 2;
            }
            else if (n >= 1) {
                lst.Add(1);
                n -= 1;
            }
        }
        // return the ans that stores in the list
        return lst;
    }

    // Driver Code
    public static void Main()
    {
        int n = 93;
        Console.Write("Following is minimal number "
                      + "of change for " + n + ": ");

        // Function Call
        List<int> lst = findMin(n);
        // print the list
        for (int i = 0; i < lst.Count; i++) {
            Console.Write(lst[i] + " ");
        }
    }
}

// This code is contributed by phasing17

Javascript

// Function to find minimal number of coins
function findMin(n) {
  // Array to store the coins
  let v = [];

  // Iterate till n > 0
  while (n > 0) {
    // Check condition
    if (n >= 2000) {
      v.push(2000);
      n -= 2000;
    } else if (n >= 500) {
      v.push(500);
      n -= 500;
    } else if (n >= 200) {
      v.push(200);
      n -= 200;
    } else if (n >= 100) {
      v.push(100);
      n -= 100;
    } else if (n >= 50) {
      v.push(50);
      n -= 50;
    } else if (n >= 20) {
      v.push(20);
      n -= 20;
    } else if (n >= 10) {
      v.push(10);
      n -= 10;
    } else if (n >= 5) {
      v.push(5);
      n -= 5;
    } else if (n >= 2) {
      v.push(2);
      n -= 2;
    } else if (n >= 1) {
      v.push(1);
      n -= 1;
    }
  }

  // Return the array
  return v;
}

// Driver code
let v = 93;
console.log("Following is minimal number of change for " + v + " :");

// Function call
let vec = findMin(v);

// Print the array
console.log(vec.join(" "));

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