Skip to content
Related Articles

Related Articles

Find the Largest number with given number of digits and sum of digits

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 23 Sep, 2022
Improve Article
Save Article

Given an integer s and d, The task is to find the largest number with given digit sum s and the number of digits d.

Examples: 

Input: s = 9, d = 2
Output: 90

Input: s = 20, d = 3
Output: 992

Recommended Practice

Naive Approach:

Consider all m digit numbers and keep a max variable to store the maximum number with m digits and digit sum as s

Time complexity: O(10m).
Auxiliary Space: O(1)

Find the Largest number with the given number of digits and sum of digits Greedy approach 

Below is the idea to solve the problem:

The idea is to one by one fill all digits from leftmost to rightmost compare the remaining sum with 9 if the remaining sum is more than or equal to 9, 9 at the current position, else put the remaining sum. Since digits are filled from left to right, the highest digits will be placed on the left side, hence get the largest number y.

Illustration: 

Follow the below steps to Implement the idea:

  • If s is zero 
    • if m=1 print 0
    • Else no such number is possible.
  • If s > 9*m then no such number is possible.
  • Run a for loop from 0 to m-1
    • If s>=9 subtract 9 from s and print 9.
    • Else print s and set s to 0.

Below is the Implementation of the above approach:

C++




// C++ program to find the largest number that can be
// formed from given sum of digits and number of digits.
#include <iostream>
using namespace std;
 
// Prints the smallest possible number with digit sum 's'
// and 'm' number of digits.
void findLargest(int m, int s)
{
    // If sum of digits is 0, then a number is possible
    // only if number of digits is 1.
    if (s == 0) {
        (m == 1) ? cout << "Largest number is " << 0
                 : cout << "Not possible";
        return;
    }
 
    // Sum greater than the maximum possible sum.
    if (s > 9 * m) {
        cout << "Not possible";
        return;
    }
 
    // Create an array to store digits of result
    int res[m];
 
    // Fill from most significant digit to least
    // significant digit.
    for (int i = 0; i < m; i++) {
        // Fill 9 first to make the number largest
        if (s >= 9) {
            res[i] = 9;
            s -= 9;
        }
 
        // If remaining sum becomes less than 9, then
        // fill the remaining sum
        else {
            res[i] = s;
            s = 0;
        }
    }
 
    cout << "Largest number is ";
    for (int i = 0; i < m; i++)
        cout << res[i];
}
 
// Driver code
int main()
{
    int s = 9, m = 2;
    findLargest(m, s);
    return 0;
}

C




// C program to find the largest number that can be
// formed from given sum of digits and number of digits.
#include <stdio.h>
 
// Prints the smallest possible number with digit sum 's'
// and 'm' number of digits.
void findLargest(int m, int s)
{
    // If sum of digits is 0, then a number is possible
    // only if number of digits is 1.
    if (s == 0) {
        (m == 1) ? printf("Largest number is 0")
                 : printf("Not possible");
        return;
    }
 
    // Sum greater than the maximum possible sum.
    if (s > 9 * m) {
        printf("Not possible");
        return;
    }
 
    // Create an array to store digits of result
    int res[m];
 
    // Fill from most significant digit to least
    // significant digit.
    for (int i = 0; i < m; i++) {
        // Fill 9 first to make the number largest
        if (s >= 9) {
            res[i] = 9;
            s -= 9;
        }
 
        // If remaining sum becomes less than 9, then
        // fill the remaining sum
        else {
            res[i] = s;
            s = 0;
        }
    }
 
    printf("Largest number is ");
    for (int i = 0; i < m; i++)
        printf("%d", res[i]);
}
 
// Driver code
int main()
{
    int s = 9, m = 2;
    findLargest(m, s);
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta

Java




// Java program to find the largest number that can be
// formed from given sum of digits and number of digits
 
class GFG
{
    // Function to print the largest possible number with digit sum 's'
    // and 'm' number of digits
    static void findLargest(int m, int s)
    {
        // If sum of digits is 0, then a number is possible
        // only if number of digits is 1
        if (s == 0)
        {
            System.out.print(m == 1 ? "Largest number is 0" : "Not possible");
             
            return ;
        }
  
        // Sum greater than the maximum possible sum
        if (s > 9*m)
        {
            System.out.println("Not possible");
            return ;
        }
  
        // Create an array to store digits of result
        int[] res = new int[m];
  
        // Fill from most significant digit to least
        // significant digit
        for (int i=0; i<m; i++)
        {
            // Fill 9 first to make the number largest
            if (s >= 9)
            {
                res[i] = 9;
                s -= 9;
            }
  
            // If remaining sum becomes less than 9, then
            // fill the remaining sum
            else
            {
                res[i] = s;
                s = 0;
            }
        }
  
        System.out.print("Largest number is ");
        for (int i=0; i<m; i++)
            System.out.print(res[i]);
    }
     
    // driver program
    public static void main (String[] args)
    {
        int s = 9, m = 2;
        findLargest(m, s);
    }
}
 
// Contributed by Pramod Kumar

Python3




# Python 3 program to find
# the largest number that
# can be formed from given
# sum of digits and number
# of digits.
 
 
# Prints the smallest
# possible number with digit
# sum 's' and 'm' number of
# digits.
def findLargest( m, s) :
 
    # If sum of digits is 0,
    # then a number is possible
    # only if number of digits
    # is 1.
    if (s == 0) :
     
        if(m == 1) :
            print("Largest number is " , "0",end = "")
        else :
            print("Not possible",end = "")
     
        return
 
    # Sum greater than the
    # maximum possible sum.
    if (s > 9 * m) :
        print("Not possible",end = "")
        return
     
    # Create an array to
    # store digits of
    # result
    res = [0] * m
 
    # Fill from most significant
    # digit to least significant
    # digit.
    for i in range(0, m) :
         
        # Fill 9 first to make
        # the number largest
        if (s >= 9) :
            res[i] = 9
            s = s - 9
         
        # If remaining sum
        # becomes less than
        # 9, then fill the
        # remaining sum
        else :
            res[i] = s
            s = 0
         
         
    print( "Largest number is ",end = "")
     
    for i in range(0, m) :
        print(res[i],end = "")
 
# Driver code
s = 9
m = 2
findLargest(m, s)
 
# This code is contributed by Nikita Tiwari.

C#




// C# program to find the
// largest number that can
// be formed from given sum
// of digits and number of digits
using System;
 
class GFG
{
     
    // Function to print the 
    // largest possible number
    // with digit sum 's' and
    // 'm' number of digits
    static void findLargest(int m, int s)
    {
        // If sum of digits is 0,
        // then a number is possible
        // only if number of digits is 1
        if (s == 0)
        {
            Console.Write(m == 1 ?
                   "Largest number is 0" :
                          "Not possible");
             
            return ;
        }
 
        // Sum greater than the
        // maximum possible sum
        if (s > 9 * m)
        {
            Console.WriteLine("Not possible");
            return ;
        }
 
        // Create an array to
        // store digits of result
        int []res = new int[m];
 
        // Fill from most significant
        // digit to least significant digit
        for (int i = 0; i < m; i++)
        {
            // Fill 9 first to make
            // the number largest
            if (s >= 9)
            {
                res[i] = 9;
                s -= 9;
            }
 
            // If remaining sum becomes
            // less than 9, then
            // fill the remaining sum
            else
            {
                res[i] = s;
                s = 0;
            }
        }
 
        Console.Write("Largest number is ");
        for (int i = 0; i < m; i++)
            Console.Write(res[i]);
    }
     
    // Driver Code
    static public void Main ()
    {
        int s = 9, m = 2;
        findLargest(m, s);
    }
}
 
// This code is Contributed by ajit

PHP




<?php
// PHP program to find the largest
// number that can be formed from
// given sum of digits and number
// of digits.
 
// Prints the smallest possible
// number with digit sum 's'
// and 'm' number of digits.
function findLargest($m, $s)
{
    // If sum of digits is 0, then
    // a number is possible only if
    // number of digits is 1.
    if ($s == 0)
    {
        if(($m == 1) == true)
            echo "Largest number is " , 0;
        else
            echo "Not possible";
        return ;
    }
 
    // Sum greater than the
    // maximum possible sum.
    if ($s > 9 * $m)
    {
        echo "Not possible";
        return ;
    }
 
    // Create an array to store
    // digits of result Fill from
    // most significant digit to
    // least significant digit.
    for ($i = 0; $i < $m; $i++)
    {
        // Fill 9 first to make
        // the number largest
        if ($s >= 9)
        {
            $res[$i] = 9;
            $s -= 9;
        }
 
        // If remaining sum becomes
        // less than 9, then fill
        // the remaining sum
        else
        {
            $res[$i] = $s;
            $s = 0;
        }
    }
 
    echo "Largest number is ";
    for ($i = 0; $i < $m; $i++)
        echo $res[$i];
}
 
// Driver code
$s = 9; $m = 2;
findLargest($m, $s);
 
// This code is contributed by m_kit
?>

Javascript




<script>
// Javascript program to find the largest number that can be
// formed from given sum of digits and number of digits.
 
// Prints the smallest possible number with digit sum 's'
// and 'm' number of digits.
function findLargest(m, s)
{
    // If sum of digits is 0, then a number is possible
    // only if number of digits is 1.
    if (s == 0)
    {
        (m == 1)? document.write("Largest number is " + 0)
                    : document.write("Not possible");
        return ;
    }
 
    // Sum greater than the maximum possible sum.
    if (s > 9*m)
    {
        document.write("Not possible");
        return ;
    }
 
    // Create an array to store digits of result
    let res = new Array(m);
 
    // Fill from most significant digit to least
    // significant digit.
    for (let i=0; i<m; i++)
    {
        // Fill 9 first to make the number largest
        if (s >= 9)
        {
            res[i] = 9;
            s -= 9;
        }
 
        // If remaining sum becomes less than 9, then
        // fill the remaining sum
        else
        {
            res[i] = s;
            s = 0;
        }
    }
 
    document.write("Largest number is ");
    for (let i=0; i<m; i++)
        document.write(res[i]);
}
 
// Driver code
    let s = 9, m = 2;
    findLargest(m, s);
 
// This code is contributed by Mayank Tyagi
 
</script>

Output

Largest number is 90

Time Complexity of this solution is O(m).
Auxiliary Space: O(m), where m is the given integer.

This article is contributed by Vaibhav Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!