Skip to content
Related Articles

Related Articles

Improve Article
Minimum number of single digit primes required whose sum is equal to N
  • Last Updated : 21 May, 2021

Find the minimum number of single-digit prime numbers required whose sum will be equal to N. 
Examples: 
 

Input: 11
Output: 3
Explanation: 5 + 3 + 3.
Another possibility is 3 + 3 + 3 + 2, but it is not
the minimal

Input: 12
Output: 2
Explanation: 7 + 5

 

Approach: Dynamic Programming can be used to solve the above problem. The observations are: 
 

  • There are only 4 single digit primes {2, 3, 5, 7}.
  • If it is possible to make N from summing up single digit primes, then at least one of N-2, N-3, N-5 or N-7, is also reachable.
  • The minimum number of single-digit prime numbers needed will be one more than the minimum number of prime digits needed to make one of {N-2, N-3, N-5, N-7}.

Using these observations, built a recurrence to solve this problem. The recurrence will be: 
 

dp[i] = 1 + min(dp[i-2], dp[i-3], dp[i-5], dp[i-7])



 
For {2, 3, 5, 7}, the answer would be 1. For each other number, using Observation 3, try to find the minimum value possible, if possible. 
Below is the implementation of the above approach. 
 

C++




// CPP program to find the minimum number of single
// digit prime numbers required which when summed
// equals to a given number N.
#include <bits/stdc++.h>
using namespace std;
 
// function to check if i-th
// index is valid or not
bool check(int i, int val)
{
    if (i - val < 0)
        return false;
    return true;
}
 
// function to find the minimum number of single
// digit prime numbers required which when summed up
// equals to a given number N.
int MinimumPrimes(int n)
{
    int dp[n + 1];
 
    for (int i = 1; i <= n; i++)
        dp[i] = 1e9;
 
    dp[0] = dp[2] = dp[3] = dp[5] = dp[7] = 1;
    for (int i = 1; i <= n; i++) {
 
        if (check(i, 2))
            dp[i] = min(dp[i], 1 + dp[i - 2]);
 
        if (check(i, 3))
            dp[i] = min(dp[i], 1 + dp[i - 3]);
 
        if (check(i, 5))
            dp[i] = min(dp[i], 1 + dp[i - 5]);
 
        if (check(i, 7))
            dp[i] = min(dp[i], 1 + dp[i - 7]);
    }
 
    // Not possible
    if (dp[n] == (1e9))
        return -1;
    else
        return dp[n];
}
 
// Driver Code
int main()
{
 
    int n = 12;
 
    int minimal = MinimumPrimes(n);
    if (minimal != -1)
        cout << "Minimum number of single"
             << " digit primes required : "
             << minimal << endl;
 
    else
        cout << "Not possible";
 
    return 0;
}

Java




// Java program to find the minimum number
// of single digit prime numbers required
// which when summed equals to a given
// number N.
 
class Geeks {
     
// function to check if i-th
// index is valid or not
static boolean check(int i, int val)
{
    if (i - val < 0)
        return false;
    else
        return true;
}
 
// function to find the minimum number
// of single digit prime numbers required
// which when summed up equals to a given
// number N.
static double MinimumPrimes(int n)
{
    double[] dp;
    dp = new double[n+1];
 
    for (int i = 1; i <= n; i++)
        dp[i] = 1e9;
 
    dp[0] = dp[2] = dp[3] = dp[5] = dp[7] = 1;
    for (int i = 1; i <= n; i++) {
 
        if (check(i, 2))
            dp[i] = Math.min(dp[i], 1 + dp[i - 2]);
 
        if (check(i, 3))
            dp[i] = Math.min(dp[i], 1 + dp[i - 3]);
 
        if (check(i, 5))
            dp[i] = Math.min(dp[i], 1 + dp[i - 5]);
 
        if (check(i, 7))
            dp[i] = Math.min(dp[i], 1 + dp[i - 7]);
    }
 
    // Not possible
    if (dp[n] == (1e9))
        return -1;
    else
        return dp[n];
}
 
    // Driver Code
    public static void main(String args[])
    {
     
        int n = 12;
        int minimal = (int)MinimumPrimes(n);
         
        if (minimal != -1)
            System.out.println("Minimum number of single "+
                        "digit primes required: "+minimal);
     
        else
            System.out.println("Not Possible");
     
    }
}
 
// This code is contributed ankita_saini

Python 3




# Python3 program to find the minimum number
# of single digit prime numbers required 
# which when summed equals to a given 
# number N.
 
# function to check if i-th
# index is valid or not
 
def check(i,val):
    if i-val<0:
        return False
    return True
 
# function to find the minimum number of single
# digit prime numbers required which when summed up
# equals to a given number N.
 
def MinimumPrimes(n):
    dp=[10**9]*(n+1)
    dp[0]=dp[2]=dp[3]=dp[5]=dp[7]=1
    for i in range(1,n+1):
        if check(i,2):
            dp[i]=min(dp[i],1+dp[i-2])
        if check(i,3):
            dp[i]=min(dp[i],1+dp[i-3])
        if check(i,5):
            dp[i]=min(dp[i],1+dp[i-5])
        if check(i,7):
            dp[i]=min(dp[i],1+dp[i-7])
 
    # Not possible
    if dp[n]==10**9:
        return -1
    else:
        return dp[n]
 
 
# Driver Code
if __name__ == "__main__":
    n=12
    minimal=MinimumPrimes(n)
    if minimal!=-1:
        print("Minimum number of single digit primes required : ",minimal)
    else:
        print("Not possible")
#This code is contributed Saurabh Shukla

C#




// C# program to find the
// minimum number of single
// digit prime numbers required
// which when summed equals to
// a given number N.
using System;
 
class GFG
{
     
// function to check if i-th
// index is valid or not
static Boolean check(int i,
                     int val)
{
    if (i - val < 0)
        return false;
    else
        return true;
}
 
// function to find the
// minimum number of single
// digit prime numbers
// required which when summed
// up equals to a given
// number N.
static double MinimumPrimes(int n)
{
    double[] dp;
    dp = new double[n + 1];
 
    for (int i = 1; i <= n; i++)
        dp[i] = 1e9;
 
    dp[0] = dp[2] = dp[3] = dp[5] = dp[7] = 1;
    for (int i = 1; i <= n; i++)
    {
        if (check(i, 2))
            dp[i] = Math.Min(dp[i], 1 +
                             dp[i - 2]);
 
        if (check(i, 3))
            dp[i] = Math.Min(dp[i], 1 +
                             dp[i - 3]);
 
        if (check(i, 5))
            dp[i] = Math.Min(dp[i], 1 +
                             dp[i - 5]);
 
        if (check(i, 7))
            dp[i] = Math.Min(dp[i], 1 +
                             dp[i - 7]);
    }
 
    // Not possible
    if (dp[n] == (1e9))
        return -1;
    else
        return dp[n];
}
 
// Driver Code
public static void Main(String []args)
{
    int n = 12;
    int minimal = (int)MinimumPrimes(n);
     
    if (minimal != -1)
        Console.WriteLine("Minimum number of single " +
                            "digit primes required: " +
                                              minimal);
    else
        Console.WriteLine("Not Possible");
 
}
}
 
// This code is contributed
// by Ankita_Saini

PHP




<?php
// PHP program to find the minimum
// number of single digit prime
// numbers required which when summed
// equals to a given number N.
 
// function to check if i-th
// index is valid or not
function check($i, $val)
{
    if ($i - $val < 0)
        return false;
    return true;
}
 
// function to find the minimum
// number of single digit prime
// numbers required which when
// summed up equals to a given
// number N.
function MinimumPrimes($n)
{
 
    for ($i = 1; $i<= $n; $i++)
        $dp[$i] = 1e9;
 
    $dp[0] = $dp[2] = $dp[3] = $dp[5] = $dp[7] = 1;
    for ($i = 1; $i <= $n; $i++)
    {
 
        if (check($i, 2))
            $dp[$i] = min($dp[$i], 1 +
                          $dp[$i - 2]);
 
        if (check($i, 3))
            $dp[$i] = min($dp[$i], 1 +
                          $dp[$i - 3]);
 
        if (check($i, 5))
            $dp[$i] = min($dp[$i], 1 +
                          $dp[$i - 5]);
 
        if (check($i, 7))
            $dp[$i] = min($dp[$i], 1 +
                          $dp[$i - 7]);
    }
 
    // Not possible
    if ($dp[$n] == (1e9))
        return -1;
    else
        return $dp[$n];
}
 
// Driver Code
$n = 12;
 
$minimal = MinimumPrimes($n);
if ($minimal != -1)
{
    echo("Minimum number of single " .
           "digit primes required :");
    echo( $minimal );
}
else
{
    echo("Not possible");
}
 
// This code is contributed
// by Shivi_Aggarwal
?>

Javascript




<script>
// Javascript program to find the minimum
// number of single digit prime
// numbers required which when summed
// equals to a given number N.
 
// function to check if i-th
// index is valid or not
function check(i, val)
{
    if (i - val < 0)
        return false;
    return true;
}
 
// function to find the minimum
// number of single digit prime
// numbers required which when
// summed up equals to a given
// number N.
function MinimumPrimes(n)
{
    let dp = new Array(n + 1)
 
    for (let i = 1; i<= n; i++)
        dp[i] = 1e9;
 
    dp[0] = dp[2] = dp[3] = dp[5] = dp[7] = 1;
    for (let i = 1; i <= n; i++)
    {
 
        if (check(i, 2))
            dp[i] = Math.min(dp[i], 1 +
                          dp[i - 2]);
 
        if (check(i, 3))
            dp[i] = Math.min(dp[i], 1 +
                          dp[i - 3]);
 
        if (check(i, 5))
            dp[i] = Math.min(dp[i], 1 +
                          dp[i - 5]);
 
        if (check(i, 7))
            dp[i] = Math.min(dp[i], 1 +
                          dp[i - 7]);
    }
 
    // Not possible
    if (dp[n] == (1e9))
        return -1;
    else
        return dp[n];
}
 
// Driver Code
let n = 12;
 
let minimal = MinimumPrimes(n);
if (minimal != -1)
{
    document.write("Minimum number of single "  + "digit primes required :");
    document.write( minimal );
}
else
{
    document.write("Not possible");
}
 
// This code is contributed
// by gfgking
 
</script>
Output: 
Minimum number of single digit primes required : 2

 

Time Complexity: O(N)
Note: In case of multiple queries, the dp[] array can be pre-computed and we can answer every query in O(1). 
 

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 industry experts, please refer Geeks Classes Live




My Personal Notes arrow_drop_up
Recommended Articles
Page :