Le plus grand nombre n'excédant pas N et ne contenant aucun nombre dans S

Le défi de trouver le plus grand nombre ne dépassant pas un nombre N donné et ne contenant aucun des chiffres d'une chaîne S est un problème qui implique la manipulation des chaînes et la théorie des nombres. Le but est de déterminer le plus grand nombre possible. inférieur ou égal à N tout en excluant également tous les chiffres trouvés dans la chaîne S.

Par exemple, considérons un scénario où N est égal à 1000 et S est égal à « 42 ». Dans ce cas, le plus grand nombre qui ne dépasse pas N et ne contient aucun chiffre dans S est 999. En effet, 999 est le plus grand nombre possible formé à partir des chiffres 0, 1, 3, 5, 6, 7, 8 et 9, à l'exclusion des chiffres 4 et 2 dans la chaîne S.

Différentes approches peuvent être utilisées pour résoudre ce problème, comme parcourir tous les nombres jusqu'à N et vérifier si leurs chiffres ne sont pas présents dans S, ou en utilisant des méthodes plus complexes comme la programmation dynamique ou le retour en arrière.

Algorithme

Étape 1 - Nous déclarerons deux variables de chaîne nommées « N » et « S » dans la fonction main().

Étape 2 - Nous passerons ces deux variables en paramètres à la fonction LargestNumberFinder().

Étape 3 - Nous convertirons implicitement les numéros de chaîne N et S en entier pour effectuer des opérations mathématiques telles que la comparaison.

Étape 4 - Nous supprimerons les 0 non significatifs des nombres stockés dans N soit manuellement, soit en créant une fonction qui fera la même chose à chaque fois.

Étape 5 - Ensuite, nous commencerons à comparer les chiffres des deux chaînes et à découvrir quel est le plus grand nombre formé pas plus de « N » qui ne contient aucun chiffre de la chaîne « S ».

Approche 1 : - Approche naïve

La méthode de base pour trouver le plus grand nombre dans une chaîne donnée en utilisant tous les nombres dans une autre chaîne est la suivante. La fonction principale déclare les variables et appelle la fonction LargestNumberFinder. Cette fonction prend deux chaînes en entrée et vérifie chaque valeur inférieure à N contenant tous les chiffres de la chaîne S. Si la condition est remplie, la valeur est renvoyée sous forme de chaîne. La fonction de présence est utilisée pour déterminer si la valeur stockée dans « i » fait partie d'une chaîne S lors de la conversion de S en un type de données entier. La chaîne d'entrée est convertie en entier et une boucle est utilisée pour évaluer la condition. Le code génère la valeur maximale de tous les nombres d'une chaîne donnée qui est également présente dans une autre chaîne.

Exemple

se traduit par :

Exemple

Ce code est une solution qui trouve le plus grand nombre inférieur à N (chaîne d'entrée convertie en entier) composé des chiffres de la chaîne S. Le code utilise deux fonctions, « présence » et « LargestNumberFinder » pour déterminer et renvoyer le plus grand nombre. La fonction de présence prend en entrée un entier « i » et une chaîne « s », vérifie si la valeur stockée dans « i » fait partie de la chaîne « s » et convertit « s » en un type de données entier. La fonction LargestNumberFinder prend deux chaînes « x » et « s » en entrée, convertit « x » en un entier, puis utilise la fonction de présence pour vérifier toutes les valeurs inférieures à N et tous les nombres sont en « s ». La fonction principale déclare la variable et appelle la fonction LargestNumberFinder, qui renvoie le plus grand nombre sous forme de chaîne.

#include <iostream>
#include <string>
#include <vector>

// function to check whether value stored in ‘i’ is part of string S while also converting S into integer data type.
bool attendance(int i, std::string s) {
   while (i) {
      int first_digit = i % 10;
      i /= 10;
      int t = std::stoi(s);
      bool found = false;
      while (t) {
         int second_digit = t % 10;
         t /= 10;
         if (second_digit == first_digit) {
            found = true;
            break;
         }
      }
      if (!found)
         return false;
   }
   return true;
}

// function to input two strings and check for each value less than N with all digits present in S.
std::string LargestNumberFinder(std::string x, std::string s) {
   int N = std::stoi(x);
   for (int i = N; i >= 1; i--) {
      if (attendance(i, s)) {
         return std::to_string(i);
      }
   }
   return "-1";
}

// main function to declare the variables and call the function.
int main() {
   std::string N = "100709";
   std::string S = "70";
   std::cout << LargestNumberFinder(N, S);
}

Sortie

77777

Méthode 2 : Méthode efficace

La solution au problème 2, qui consiste à obtenir le plus grand nombre possible en remplaçant les chiffres de la chaîne numérique donnée N par les chiffres de la chaîne donnée S, est une approche efficace. La méthode vérifie d’abord si chaque nombre de N est présent dans S et remplace le premier nombre trouvé dans S par le plus grand nombre de S qui n’est pas dans N. Les nombres restants sont ensuite remplacés par le plus grand nombre de S qui ne se trouve pas dans N. Les zéros non significatifs sont ensuite supprimés et le résultat est renvoyé sous la forme du plus grand nombre possible. Cette méthode est plus efficace que la méthode précédente car elle ne nécessite pas de trier la chaîne.

Exemple

se traduit par :

Exemple

Le code résout le problème de trouver le nombre qui peut être formé à partir d'une chaîne "N" donnée en remplaçant le plus grand chiffre par le chiffre le plus élevé non présent dans la chaîne "S". Le code utilise une méthode efficace pour résoudre le problème. La fonction LargestNumberFinder prend deux entrées de chaîne, "num" et "s", et renvoie le plus grand nombre possible. Le vecteur "vis_s" est utilisé pour stocker les valeurs de la chaîne "s". chaîne " num" qui fait partie de la chaîne "s". Ensuite, il échange ce chiffre avec le chiffre le plus élevé non présent dans la chaîne "s". Le code trouve ensuite le chiffre le plus élevé non trouvé dans la chaîne "s" et remplace le reste du chiffre. chiffres dans la chaîne "num" avec ce chiffre. Les zéros non significatifs sont supprimés de la chaîne finale, et si la chaîne est vide, la fonction renvoie "0". Le code génère le résultat en appelant la fonction avec les entrées "N" et ". S".

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// function to check for all values of String N with String S and replacing the digit if found same with the largest possible digit not present in S.
string LargestNumberFinder(string num, string s) {
   vector<bool> vis_s(10, false);
   for (int i = 0; i < (int)s.size(); i++) {
      vis_s[int(s[i]) - 48] = true;
   }
   int n = num.size();
   int in = -1;
   for (int i = 0; i < n; i++) {
      if (vis_s[(int)num[i] - '0']) {
         in = i;
         break;
      }
   }
   if (in == -1) {
      return num;
   }
   for (char dig = num[in]; dig >= '0'; dig--) {
      if (vis_s[(int)dig - '0'] == 0) {
         num[in] = dig;
         break;
      }
   }
   char LargestDig = '0';
   for (char dig = '9'; dig >= '0'; dig--) {
      if (vis_s[dig - '0'] == false) {
         LargestDig = dig;
         break;
      }
   }
   for (int i = in + 1; i < n; i++) {
      num[i] = LargestDig;
   }
   int Count = 0;
   for (int i = 0; i < n; i++) {
      if (num[i] == '0')
         Count++;
      else
         break;
   }
   num.erase(0, Count);
   if ((int)num.size() == 0)
      return "0";
   return num;
}
int main() {
   string N = "161516";
   string S = "756";
   cout << LargestNumberFinder(N, S);
   return 0;
}

Output

149999

结论

通过这篇文章，我们更接近理解这些问题背后的原因，并理解了这些概念，这些概念将帮助我们在之前提到的重大实际问题中使用这些基本概念。就像在我们的代码中，我们分别解决每个问题，然后像制作美丽的手工品一样将代码缝合在一起，同样，我们将使用这个概念，尝试逐个解决问题。我们通常会从朴素的方法开始，但通过敏锐的眼光和努力，我们会找到更高效的方法。谁知道在阅读完这篇文章后，你会找到更好、更高效的方法，并进一步简化解决方案。所以，让我们坚持我们的信念和对思维和编码的信任，同时告别。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!