Nombre de solutions entières de l'équation x = b*(sumofdigits(x) ^ a)+c

Supposons que l'on vous donne trois entiers a, b et c, et qu'il existe une équation x = b* (somme des chiffres (x) ^ a) + c. Ici, sumofdigits(x ) est la somme de tous les chiffres de x. Afin de trouver toutes les solutions intégrales possibles qui satisfont à l’équation, nous explorerons diverses méthodes en C++.

Scénarios d'entrée et de sortie

Vous trouverez ci-dessous les valeurs de a, b et c. Différentes solutions intégrales satisfaisant l'équation x = b* (sumofdigits(x)^a) +c sont données en sortie.

Input: a = 2, b = 2, c = -3
Output: 125, 447, 575

Dans le cas ci-dessus, a a une valeur de 2, b a une valeur de 2, c a une valeur de -3 et les valeurs possibles de x sont 125, 447 et 575.

Considérons le nombre 125. La somme de ses chiffres est 8. Si vous branchez cette valeur dans l'équation b*(somme(x)^a) +c, la réponse est 125, qui est égale à x. C’est donc une solution possible à l’équation.

Remarque- La solution intégrale de cette équation est comprise entre 1 et 10⁹.

Utiliser la récursion

Nous pouvons utiliser la recherche récursive pour trouver la solution intégrale d'une équation donnée.

Nous devons créer une fonction appelée sumOfDigits() qui calculera la somme des chiffres d'un nombre donné N.

• Parcourez les nombres N en utilisant les opérateurs modulo et division.

• L'opérateur modulo est utilisé pour extraire le dernier chiffre de N.

• Après chaque itération, additionnez les nombres stockés dans la variable sum un par un.

Nous créons une fonction intégranteSolutions() pour calculer les solutions intégrales.

• Il utilise la fonction sumOfDigits pour calculer la somme des chiffres de x.

• Ensuite, en utilisant une boucle for, nous élevons la somme à la puissance a.

• Nous évaluons le côté droit de l'équation en multipliant b par puissance et en ajoutant c.

• Si la valeur de x est égale à la valeur du côté droit, elle est considérée comme une solution entière.

Ensuite, nous avons la fonction récursive pour rechercher des solutions intégrales dans une plage spécifiée.

Exemple

#include <iostream>
using namespace std;

int sumOfDigits(int N) {
   int sum = 0;
   while (N != 0) {
      sum += N % 10; // addition of the last digit of N
      N /= 10;
   }
   return sum;
}
void integralSolutions(int x, int a, int b, int c) {
   int sum = sumOfDigits(x);
   int power = 1;
   for (int j = 0; j < a; j++) {
      power *= sum;
   }
   int rightHandSide = b * power + c;
   if (x == rightHandSide) {
      std::cout << "Integral solution: " << x << std::endl;
   }
}
void recursion(int start, int end, int a, int b, int c) {
   if (start > end) {
      return;
   }
   integralSolutions(start, a, b, c);
   recursion(start + 1, end, a, b, c);
}
int main() {
   int a = 1, b = 3, c = 5;
   recursion(1, 100000, a, b, c);
   return 0;
}

Sortie

Integral solution: 11
Integral solution: 38

Défaut de segmentation Cette erreur se produit lorsque la valeur finale de la plage spécifiée dans une recherche récursive dépasse 100 000. Vous ne pouvez donc pas avoir de valeurs X au-delà de cela.

Utilisez une itération simple

Si vous voulez une solution entière pour x supérieur à 100 000, alors nous n'utilisons pas de récursivité. Ici, nous utiliserons une simple itération de x de 1 à 109 et la comparerons à la valeur du côté droit de l’équation.

Exemple

#include <iostream>
using namespace std;

int sumOfDigits(int N) {
   int sum = 0;
   while (N != 0) {
      sum += N % 10;
      N /= 10;
   }
   return sum;
}

bool integralSolution(int x, int a, int b, int c) {
   int sum = sumOfDigits(x);
   int power = 1;
   for (int i = 0; i < a; i++) {
      power *= sum;
   }
   int rightHandSide = b * power + c;
   return x == rightHandSide;
}

int main() {
   int a = 3, b = 5, c = 8;
   // x ranges from 1 to 109
   for (int x = 1; x <= 1000000000; x++) {
      if (integralSolution(x, a, b, c)) {
         std::cout << "Integral solution: " << x << std::endl;
      }
   }
   return 0;
}

Sortie

Integral solution: 53248
Integral solution: 148963

Conclusion

Nous avons exploré des moyens de trouver la solution intégrale de l'équation x = b* (sumofdigits(x)^a) +c, notamment en utilisant la récursion ou l'itération simple. Les méthodes récursives vous permettent de spécifier de manière flexible la gamme de solutions. Cependant, cela augmente la complexité temporelle et peut afficher une erreur de segmentation pour une plage de valeurs plus large, entraînant un débordement de pile.

Les méthodes itératives sont efficaces en termes de complexité temporelle et d'utilisation de la mémoire. Cependant, il offre une flexibilité limitée et un code plus complexe. Les deux méthodes présentent donc leurs propres avantages et inconvénients. En fonction de vos besoins, vous pouvez choisir l'une des méthodes.

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!