Smallest number with given digit count and sum

Last Updated : 24 Mar, 2025

Given two integers s and d, find the smallest possible number that has exactly d digits and a sum of digits equal to s.
Return the number as a string. If no such number exists, return "-1".

Examples :

Input: s = 9, d = 2
Output: 18
Explanation: 18 is the smallest number possible with the sum of digits = 9 and total digits = 2.
Input: s = 20, d = 3
Output: 299
Explanation: 299 is the smallest number possible with the sum of digits = 20 and total digits = 3.
Input: s = 1, d = 1
Output: 1
Explanation: 1 is the smallest number possible with the sum of digits = 1 and total digits = 1.

Table of Content

[Brute-Force Approach] Iterate Sequentially - O(d*(10^d)) time and O(1) Space

Since numbers are sequential, the brute force approach iterates from the smallest d-digit number to the largest, checking each one. For every number, we compute the sum of its digits and return the first valid match, ensuring the smallest possible number is selected. If no valid number exists, we return "-1".

C++

// C++ program to find the smallest d-digit
// number with the given sum using 
// a brute force approach
#include <bits/stdc++.h>
using namespace std;

string smallestNumber(int s, int d) {
    
    // The smallest d-digit number is 10^(d-1)
    int start = pow(10, d - 1);
    
    // The largest d-digit number is 10^d - 1
    int end = pow(10, d) - 1;

    // Iterate through all d-digit numbers
    for (int num = start; num <= end; num++) {
        
        int sum = 0, x = num;

        // Calculate sum of digits
        while (x > 0) {
            sum += x % 10;
            x /= 10;
        }

        // If sum matches, return the number
        // as a string
        if (sum == s) {
            return to_string(num);
        }
    }

    // If no valid number is found, return "-1"
    return "-1";
}

// Driver Code
int main() {
    
    int s = 9, d = 2;
    
    cout << smallestNumber(s, d) << endl;
    return 0;
}

Java

// Java program to find the smallest d-digit
// number with the given sum using 
// a brute force approach
import java.util.*;

class GfG {
    
    static String smallestNumber(int s, int d) {
        
        // The smallest d-digit number is 10^(d-1)
        int start = (int) Math.pow(10, d - 1);
        
        // The largest d-digit number is 10^d - 1
        int end = (int) Math.pow(10, d) - 1;

        // Iterate through all d-digit numbers
        for (int num = start; num <= end; num++) {
            
            int sum = 0, x = num;

            // Calculate sum of digits
            while (x > 0) {
                sum += x % 10;
                x /= 10;
            }

            // If sum matches, return the number
            // as a string
            if (sum == s) {
                return Integer.toString(num);
            }
        }

        // If no valid number is found, return "-1"
        return "-1";
    }

    // Driver Code
    public static void main(String[] args) {
        
        int s = 9, d = 2;
        
        System.out.println(smallestNumber(s, d));
    }
}

Python

# Python program to find the smallest d-digit
# number with the given sum using 
# a brute force approach

def smallestNumber(s, d):
    
    # The smallest d-digit number is 10^(d-1)
    start = 10**(d - 1)
    
    # The largest d-digit number is 10^d - 1
    end = 10**d - 1

    # Iterate through all d-digit numbers
    for num in range(start, end + 1):
        
        sum_digits = 0
        x = num

        # Calculate sum of digits
        while x > 0:
            sum_digits += x % 10
            x //= 10

        # If sum matches, return the number
        # as a string
        if sum_digits == s:
            return str(num)

    # If no valid number is found, return "-1"
    return "-1"

# Driver Code
if __name__ == "__main__":
    
    s, d = 9, 2
    
    print(smallestNumber(s, d))

// C# program to find the smallest d-digit
// number with the given sum using 
// a brute force approach
using System;

class GfG {
    
    static string smallestNumber(int s, int d) {
        
        // The smallest d-digit number is 10^(d-1)
        int start = (int)Math.Pow(10, d - 1);
        
        // The largest d-digit number is 10^d - 1
        int end = (int)Math.Pow(10, d) - 1;

        // Iterate through all d-digit numbers
        for (int num = start; num <= end; num++) {
            
            int sum = 0, x = num;

            // Calculate sum of digits
            while (x > 0) {
                sum += x % 10;
                x /= 10;
            }

            // If sum matches, return the number
            // as a string
            if (sum == s) {
                return num.ToString();
            }
        }

        // If no valid number is found, return "-1"
        return "-1";
    }

    // Driver Code
    public static void Main() {
        
        int s = 9, d = 2;
        
        Console.WriteLine(smallestNumber(s, d));
    }
}

JavaScript

// JavaScript program to find the smallest d-digit
// number with the given sum using 
// a brute force approach

function smallestNumber(s, d) {
    
    // The smallest d-digit number is 10^(d-1)
    let start = Math.pow(10, d - 1);
    
    // The largest d-digit number is 10^d - 1
    let end = Math.pow(10, d) - 1;

    // Iterate through all d-digit numbers
    for (let num = start; num <= end; num++) {
        
        let sum = 0, x = num;

        // Calculate sum of digits
        while (x > 0) {
            sum += x % 10;
            x = Math.floor(x / 10);
        }

        // If sum matches, return the number
        // as a string
        if (sum === s) {
            return num.toString();
        }
    }

    // If no valid number is found, return "-1"
    return "-1";
}

// Driver Code
let s = 9, d = 2;

console.log(smallestNumber(s, d));

Output

[Expected Approach] Using Greedy Technique - O(d) Time and O(1) Space

The approach ensures the leftmost digit is non-zero, so we reserve 1 for it and distribute the remaining sum from right to left to form the smallest possible number. The greedy approach helps in placing the largest possible values (up to 9) at the rightmost positions to keep the number small.

Steps to implement the above idea:

Check constraints to ensure a valid sum s can be formed using d digits, otherwise return "-1".
Initialize result as a string of d '0's and reserve 1 for the leftmost digit by reducing s by 1.
Traverse from right to left and place the largest possible digit (<= 9) while updating s accordingly.
If s <= 9, place its value at the current position and set s = 0 to stop further updates.
Assign the leftmost digit by adding the remaining s to ensure it remains non-zero.
Convert the result string to the required format and return it as the final output.

C++

// C++ program to find the smallest d-digit 
// number with the given sum using
// Greedy Technique
#include <bits/stdc++.h>
using namespace std;

string smallestNumber(int s, int d) {
    
    // If sum is too small or too large 
    // for d digits
    if (s < 1 || s > 9 * d) {
        return "-1";
    }

    string result(d, '0'); 
    
    // Reserve 1 for the leftmost digit
    s--; 

    // Fill digits from right to left
    for (int i = d - 1; i > 0; i--) {
        
        // Place the largest possible value <= 9
        if (s > 9) {
            result[i] = '9';
            s -= 9;
        } else {
            result[i] = '0' + s;
            s = 0;
        }
    }

    // Place the leftmost digit ensuring
    // it's non-zero
    result[0] = '1' + s;
    
    return result;
}

// Driver Code
int main() {
    
    int s = 9, d = 2;
    
    cout << smallestNumber(s, d) << endl;
    return 0;
}

Java

// Java program to find the smallest d-digit 
// number with the given sum using
// Greedy Technique
import java.util.*;

class GfG {
    
    static String smallestNumber(int s, int d) {
        
        // If sum is too small or too large 
        // for d digits
        if (s < 1 || s > 9 * d) {
            return "-1";
        }

        char[] result = new char[d];
        Arrays.fill(result, '0');
        
        // Reserve 1 for the leftmost digit
        s--;

        // Fill digits from right to left
        for (int i = d - 1; i > 0; i--) {
            
            // Place the largest possible value <= 9
            if (s > 9) {
                result[i] = '9';
                s -= 9;
            } else {
                result[i] = (char) ('0' + s);
                s = 0;
            }
        }

        // Place the leftmost digit ensuring
        // it's non-zero
        result[0] = (char) ('1' + s);
        
        return new String(result);
    }

    // Driver Code
    public static void main(String[] args) {
        
        int s = 9, d = 2;
        
        System.out.println(smallestNumber(s, d));
    }
}

Python

# Python program to find the smallest d-digit 
# number with the given sum using
# Greedy Technique

def smallestNumber(s, d):
    
    # If sum is too small or too large 
    # for d digits
    if s < 1 or s > 9 * d:
        return "-1"

    result = ['0'] * d 

    # Reserve 1 for the leftmost digit
    s -= 1

    # Fill digits from right to left
    for i in range(d - 1, 0, -1):
        
        # Place the largest possible value <= 9
        if s > 9:
            result[i] = '9'
            s -= 9
        else:
            result[i] = str(s)
            s = 0

    # Place the leftmost digit ensuring
    # it's non-zero
    result[0] = str(1 + s)
    
    return ''.join(result)

# Driver Code
if __name__ == "__main__":
    
    s, d = 9, 2
    print(smallestNumber(s, d))

// C# program to find the smallest d-digit 
// number with the given sum using
// Greedy Technique
using System;

class GfG {

    static string smallestNumber(int s, int d) {
        
        // If sum is too small or too large 
        // for d digits
        if (s < 1 || s > 9 * d) {
            return "-1";
        }

        char[] result = new char[d];
        Array.Fill(result, '0');

        // Reserve 1 for the leftmost digit
        s--;

        // Fill digits from right to left
        for (int i = d - 1; i > 0; i--) {
            
            // Place the largest possible value <= 9
            if (s > 9) {
                result[i] = '9';
                s -= 9;
            } else {
                result[i] = (char) ('0' + s);
                s = 0;
            }
        }

        // Place the leftmost digit ensuring
        // it's non-zero
        result[0] = (char) ('1' + s);
        
        return new string(result);
    }

    // Driver Code
    static void Main() {
        
        int s = 9, d = 2;
        
        Console.WriteLine(smallestNumber(s, d));
    }
}

JavaScript

// JavaScript program to find the smallest d-digit 
// number with the given sum using
// Greedy Technique

function smallestNumber(s, d) {
    
    // If sum is too small or too large 
    // for d digits
    if (s < 1 || s > 9 * d) {
        return "-1";
    }

    let result = Array(d).fill('0'); 

    // Reserve 1 for the leftmost digit
    s--;

    // Fill digits from right to left
    for (let i = d - 1; i > 0; i--) {
        
        // Place the largest possible value <= 9
        if (s > 9) {
            result[i] = '9';
            s -= 9;
        } else {
            result[i] = String(s);
            s = 0;
        }
    }

    // Place the leftmost digit ensuring
    // it's non-zero
    result[0] = String(1 + s);
    
    return result.join('');
}

// Driver Code
let s = 9, d = 2;
console.log(smallestNumber(s, d));