KLEINSTE NUMMER MET EEN GEGEVEN CIJFERS AANTAL EN SOM

Probeer het op GFG -oefening ' title=

Gegeven twee gehele getallen S En D vind de kleinste mogelijk nummer dat precies heeft D -cijfers en een som van cijfers gelijk aan S .
Retourneer het nummer als een snaar . Als er geen dergelijk nummer bestaat, retourneert '-1' .

beste hentai

Voorbeelden:

Invoer: S = 9 D = 2
Uitvoer: 18
Uitleg: 18 is het kleinste aantal mogelijk met de som van cijfers = 9 en totale cijfers = 2.
Invoer: S = 20 D = 3
Uitvoer: 299
Uitleg: 299 is het kleinste aantal mogelijk met de som van cijfers = 20 en totale cijfers = 3.
Invoer: S = 1 D = 1
Uitvoer: 1
Uitleg: 1 is het kleinste aantal mogelijk met de som van cijfers = 1 en totale cijfers = 1.

Tabel met inhoud

java dubbel naar string

[Brute -Force -benadering] Itereren opeenvolgend - O (d*(10^d)) tijd en o (1) ruimte
[Verwachte benadering] Gebruik van de hebzuchtige techniek - O (D) tijd en O (1) ruimte

[Brute -Force -benadering] Itereren opeenvolgend - O (d*(10^d)) tijd en o (1) ruimte

Omdat getallen opeenvolgend zijn Brute Force -benadering herhaalt van de kleinste d-cijfer nummer naar het het grootste het controleren van elk. Voor elk nummer berekenen we de som van zijn cijfers en retourneer de eerste geldige wedstrijd om ervoor te zorgen dat het kleinst mogelijke nummer is geselecteerd. Als er geen geldig nummer bestaat, keren we terug '-1' .
Java-arrays

C++

// C++ program to find the smallest d-digit // number with the given sum using  // a brute force approach #include    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));

Uitvoer

[Verwachte benadering] Gebruik van de hebzuchtige techniek - O (D) tijd en O (1) ruimte

De aanpak zorgt voor het meest linkse cijfer is niet nul Dus wij Reserve 1 voor het en de resterende som uitdistribueren van van rechts naar links Om het kleinst mogelijke nummer te vormen. De hebzuchtige aanpak helpt bij het plaatsen van de grootst mogelijke waarden (maximaal 9) bij de rechtsbovenposities Om het nummer klein te houden.

Stappen om het bovenstaande idee te implementeren:

Controleer beperkingen om een Geldige som s kan worden gevormd met behulp van D -cijfers Keer anders terug '-1' .
Initialiseren resultaat als een reeks van D '0's En Reserve 1 voor de Linksste cijfer door te verminderen S door 1 .
Doorkruisen van van rechts naar links en plaats de grootst mogelijke cijfer (<= 9) Tijdens het updaten S overeenkomstig.
Als S<= 9 Plaats zijn waarde op de huidige positie en stel in S = 0 om verdere updates te stoppen.
Wijs de Linksste cijfer door de resterende s om ervoor te zorgen dat het overblijft niet nul .
Bekeer de resultaat string naar het vereiste formaat en opbrengst het als de uiteindelijke uitvoer.

C++

// C++ program to find the smallest d-digit  // number with the given sum using // Greedy Technique #include    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; }