Minimum number of Coins (original) (raw)

Last Updated : 6 Oct, 2025

Given an amount of **n rupees and an unlimited supply of coins or notes of denominations {1, 2, 5, 10}. we have to find the minimum number of coins required to make up the given amount.

**Examples:

**Input: n= 39
**Output: 6
**Explanation: 39 can be formed using 3 coins of 10 rupees ,1 coin of 5 rupees and 2 coins of 2 rupees so minimum coins required are 6.

**Input: n = 121
**Output: 13
**Explanation: 121 can be formed using 12 coins of 10 rupees and 1 coin of 1 rupees.

Try It Yourself

Table of Content

• [Approach 1] Using iterative Way - O(n) Time and O(1) Space
• [Approach 2] Using Recursion - O(n) Time and O(n) Space

[Approach 1] Using Iterative Way - O(1) Time and O(1) Space

To minimize the number of coins required, we should always pick the largest possible denomination first and then move to smaller ones. This ensures that the total coins used are minimum.

C++ `

#include #include using namespace std;

int findMin(int n) { int count=0; vector denomination = { 1, 2, 5, 10 };

// Traverse through all denomination
for (int i = denomination.size() - 1; i >= 0; i--) {
  count+=n/denomination[i];
  n=n%denomination[i];

}
return count; 

}

int main() {

int n = 39;
cout<<findMin(n);
return 0;

}

Java

import java.util.List;

public class GfG {

public static int findMin(int n) {
    
    // Traverse through all denominations in reverse order
    int count = 0; 
    int[] denomination = {1, 2, 5, 10}; 
    
    for (int i = denomination.length - 1; i >= 0; i--) {
        
        // Find denominations
        count+=n/denomination[i];
        n=n%denomination[i];
    }
    return count; 
}

public static void main(String[] args) {
    int n = 39;
    System.out.println(findMin(n));
}

}

Python

def findMin(n): count =0 denomination = [1, 2, 5, 10]

# Traverse through all denomination
for i in range(len(denomination) - 1, -1, -1):
    # Find denominations
        count+=n/denomination[i];
        n=n%denomination[i];
return count

if name == 'main': n = 39 print(findMin(n))

C#

using System; using System.Collections.Generic;

class GfG { static int findMin(int n) {

    // Traverse through all denomination
    int count = 0;
    int[] denomination = {1, 2, 5, 10};
    for (int i = denomination.Length - 1; i >= 0; i--) {
        
        // Find denominations
        count+=n/denomination[i];
        n=n%denomination[i];
    }
    return count;
}

static void Main() {
    int n = 39;
    Console.Write(findMin(n));
}

}

JavaScript

function findMin(n) {

// Traverse through all denomination
const denomination = [1, 2, 5, 10];
let count =0;
for (let i = denomination.length - 1; i >= 0; i--) {
   
    // Find denominations
        count+= Math.floor(n/denomination[i]);
        n=n%denomination[i];
}
return count;

} // Driver Code const n = 39; console.log(findMin(n));

`

[Approach 2] Using Recursion - O(1) Time and O(1) Space

The idea is to minimize the number of coins recursively by always starting with the highest denomination. To get how many coins of a particular denomination are needed, we divide the amount by that denomination (amount / coin). The remaining amount is then found using the modulo operator (amount % coin), and the same process continues for the smaller denominations until the amount becomes zero.

C++ `

#include #include using namespace std;

int getMin(int n, vector denomination, int i) { // Base case: if amount becomes 0 or i<0 if(n==0 || i<0) return 0; return n/denomination[i] + getMin(n%denomination[i],denomination,i-1); } int findMin(int n) { vector denomination = { 1, 2, 5, 10 }; return getMin(n, denomination, denomination.size() - 1); }

int main() { int n = 39; cout << findMin(n); return 0; }

Java

import java.util.Arrays;

public class Main {

public static int getMin(int n, int[] denomination, int i) {
    
    // Base case: if amount becomes 0 or i<0
if(n==0 || i<0)
return 0;
return n/denomination[i] + getMin(n%denomination[i],denomination,i-1);
}

public static int findMin(int n) {
    int[] denomination = { 1, 2, 5, 10 };
    return getMin(n, denomination, denomination.length - 1);
}

public static void main(String[] args) {
    int n = 39;
    System.out.println(findMin(n));
}

}

Python

from typing import List

def getMin(n: int, denomination: List[int], i: int) -> int:

#   Base case: if amount becomes 0 or i<0
if(n==0 or i<0):
     return 0
return n/denomination[i] + getMin(n%denomination[i],denomination,i-1)

def findMin(n: int) -> int: denomination = [1, 2, 5, 10] return getMin(n, denomination, len(denomination) - 1)

if name == 'main': n = 39 print(findMin(n))

C#

using System;

class Program { static int getMin(int n, int[] denomination, int i) { // Base case: if amount becomes 0 or i<0 if(n==0 || i<0) return 0; return n/denomination[i] + getMin(n%denomination[i],denomination,i-1); }

static int FindMin(int n)
{
    int[] denomination = { 1, 2, 5, 10 };
    return getMin(n, denomination, denomination.Length - 1);
}

static void Main()
{
    int n = 39;
    Console.WriteLine(FindMin(n));
}

}

JavaScript

function getMin(n, denomination, i) {

// Base case: if amount becomes 0 or i<0
if(n==0 || i<0)
return 0;
return Math.floor(n/denomination[i]) + getMin(n%denomination[i],denomination,i-1);

} function findMin(n) { const denomination = [1, 2, 5, 10]; return getMin(n, denomination, denomination.length - 1); }

function main() { const n = 39; console.log(findMin(n)); }

main();

`