Skip to content
Related Articles

Related Articles

Improve Article
Minimum number of coins that can generate all the values in the given range
  • Difficulty Level : Easy
  • Last Updated : 21 Apr, 2021

Given an integer N, the task is to find the minimum number of coins required to create all the values in the range [1, N].

Examples: 

Input: N = 5
Output: 3
The coins {1, 2, 4} can be used to generate 
all the values in the range [1, 5].
1 = 1
2 = 2
3 = 1 + 2
4 = 4
5 = 1 + 4

Input: N = 10
Output: 4

Approach: The problem is a variation of coin change problem, it can be solved with the help of binary numbers. In the above example, it can be seen that to create all the values between 1 to 10, denominator {1, 2, 4, 8} are required which can be rewritten as {20, 21, 22, 23}. The minimum number of coins to create all the values for a value N can be computed using the below algorithm. 

// A list which contains the sum of all previous 
// bit values including that bit value
list = [ 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023]
    // range = N
    for value in  list:
        if(value >= N):
            print(list.index(value) + 1)
            break

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
int index(vector<int> vec, int value)
{
    vector<int>::iterator it;
    it = find(vec.begin(), vec.end(), value);
    return (it - vec.begin());
}
 
// Function to return the count
// of minimum coins required
int findCount(int N)
{
 
    // To store the required sequence
    vector<int> list;
    int sum = 0;
    int i;
 
    // Creating list of the sum of all
    // previous bit values including
    // that bit value
    for (i = 0; i < 20; i++) {
        sum += pow(2, i);
        list.push_back(sum);
    }
 
    for (i = 0; i < 20; i++) {
        if (list[i] >= N) {
            return (index(list, list[i]) + 1);
        }
    }
}
 
// Driver Code
int main()
{
    int N = 10;
    cout << findCount(N) << endl;
    return 0;
}
 
// This code is contributed by kanugargng

Java




// Java implementation of the approach
import java.util.*;
 
class GFG {
 
    // Function to return the count
    // of minimum coins required
    static int findCount(int N)
    {
        Vector list = new Vector();
        int sum = 0;
        int i;
 
        // Creating list of the sum of all
        // previous bit values including
        // that bit value
        for (i = 0; i < 20; i++) {
            sum += Math.pow(2, i);
            list.add(sum);
        }
 
        for (i = 0; i < 20; i++) {
            if ((int)list.get(i) >= N)
                return (list.indexOf(list.get(i)) + 1);
        }
        return 0;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 10;
 
        // Function Call to find count
        System.out.println(findCount(N));
    }
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of the approach
 
# Function to return the count
# of minimum coins required
 
 
def findCount(N):
 
    # To store the required sequence
    list = []
    sum = 0
 
    # Creating list of the sum of all
    # previous bit values including
    # that bit value
    for i in range(0, 20):
        sum += 2**i
        list.append(sum)
 
    for value in list:
        if(value >= N):
            return (list.index(value) + 1)
 
 
# Driver code
N = 10
print(findCount(N))

C#




// C# implementation of the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function to return the count
    // of minimum coins required
    static int findCount(int N)
    {
        List<int> list = new List<int>();
        int sum = 0;
        int i;
 
        // Creating list of the sum of all
        // previous bit values including
        // that bit value
 
        for (i = 0; i < 20; i++) {
            sum += (int)Math.Pow(2, i);
            list.Add(sum);
        }
 
        for (i = 0; i < 20; i++) {
            if ((int)list[i] >= N)
                return (i + 1);
        }
        return 0;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int N = 10;
        Console.WriteLine(findCount(N));
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
    // Javascript implementation of the above approach
     
    // Function to return the count
    // of minimum coins required
    function findCount(N)
    {
        let list = [];
        let sum = 0;
        let i;
  
        // Creating list of the sum of all
        // previous bit values including
        // that bit value
  
        for (i = 0; i < 20; i++) {
            sum += parseInt(Math.pow(2, i), 10);
            list.push(sum);
        }
  
        for (i = 0; i < 20; i++) {
            if (list[i] >= N)
                return (i + 1);
        }
        return 0;
    }
     
    let N = 10;
      document.write(findCount(N));
     
    // This code is contributed by rameshtravel07.
</script>
Output



4

Time Complexity: O(n)

Efficient approach: The minimum number of coins required to create all the values in the range [1, N] will be log(N)/log(2) + 1.

Below is the implementation of the above approach:

C++14




// C++ progarm to find minimum number of coins
#include<bits/stdc++.h>
using namespace std;
 
// Function to find minimum number of coins
int findCount(int n)
{
    return log(n)/log(2)+1;
}
 
// Driver code
int main()
{
    int N = 10;
    cout << findCount(N) << endl;
    return 0;
}

Java




// Java progarm to find minimum number of coins
class GFG{
     
// Function to find minimum number of coins
static int findCount(int n)
{
    return (int)(Math.log(n) /
                 Math.log(2)) + 1;
}
 
// Driver code
public static void main(String[] args)
{
    int N = 10;
     
    System.out.println(findCount(N));
}
}
 
// This code is contributed by divyeshrabadiya07

Python3




# Python3 progarm to find minimum number of coins
import math
 
# Function to find minimum number of coins
def findCount(n):
     
    return int(math.log(n, 2)) + 1
     
# Driver code
N = 10
 
print(findCount(N))
 
# This code is contributed by divyesh072019

C#




// C# progarm to find minimum number of coins
using System;
 
class GFG{
 
  // Function to find minimum number of coins
  static int findCount(int n)
  {
    return (int)(Math.Log(n) /
                 Math.Log(2)) + 1;
  }
 
  // Driver code
  public static void Main()
  {
    int N = 10;
 
    Console.Write(findCount(N));
  }
}
 
// This code is contributed by rutvik_56.

Javascript




<script>
    // Javascript progarm to find minimum number of coins
     
    // Function to find minimum number of coins
    function findCount(n)
    {
        return parseInt(Math.log(n)/Math.log(2), 10)+1;
    }
     
    let N = 10;
    document.write(findCount(N));
         
</script>
Output
4

Time complexity : O(log(n))
 

Attention reader! Don’t stop learning now. Get hold of all the important Comcompetitivepetitve Programming concepts with the Competitive Programming Live  course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :