Anzahl der ganzzahligen Lösungen der Gleichung x = b*(sumofdigits(x) ^ a)+c

Angenommen, Sie erhalten drei ganze Zahlen a, b und c und es gibt eine Gleichung x = b* (sumofdigits(x)^a) +c. Hier ist sumofdigits(x ) die Summe aller Ziffern in x. Um alle möglichen Integrallösungen zu finden, die die Gleichung erfüllen, werden wir verschiedene Methoden in C++ untersuchen.

Eingabe- und Ausgabeszenarien

Unten sind die Werte von a, b und c angegeben. Als Ausgabe werden verschiedene Integrallösungen ausgegeben, die die Gleichung x = b* (sumofdigits(x)^a) +c erfüllen.

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

Im obigen Fall hat a einen Wert von 2, b hat einen Wert von 2, c hat einen Wert von -3 und die möglichen Werte von x sind 125, 447 und 575.

Betrachten Sie die Zahl 125. Die Summe ihrer Ziffern ist 8. Wenn Sie diesen Wert in die Gleichung b*(sum(x)^a) +c einsetzen, lautet die Antwort 125, was gleich x ist. Daher ist es eine mögliche Lösung für Gl.

Hinweis – Die Integrallösung dieser Gleichung liegt im Bereich 1 bis 10⁹.

Rekursion verwenden

Wir können die rekursive Suche verwenden, um die Integrallösung einer gegebenen Gleichung zu finden.

Wir müssen eine Funktion namens sumOfDigits() erstellen, die die Summe der Ziffern einer beliebigen Zahl N berechnet.

• Iterieren Sie über N Zahlen mit den Modulo- und Divisionsoperatoren.

• Der Modulo-Operator wird verwendet, um die letzte Ziffer von N zu extrahieren.

• Fügen Sie nach jeder Iteration die in der Variablen sum gespeicherten Zahlen nacheinander hinzu.

Wir erstellen eine Funktion integralSolutions(), um die Integrallösungen zu berechnen.

• Es verwendet die Funktion sumOfDigits, um die Summe der Ziffern von x zu berechnen.

• Als nächstes erhöhen wir die Summe mithilfe einer for-Schleife hoch a.

• Wir bewerten die rechte Seite der Gleichung, indem wir b mit Leistung multiplizieren und c hinzufügen.

• Wenn der Wert von x gleich dem Wert auf der rechten Seite ist, wird es als ganzzahlige Lösung betrachtet.

Als nächstes haben wir die rekursive Funktion, um nach Integrallösungen innerhalb eines bestimmten Bereichs zu suchen.

Beispiel

#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;
}

Ausgabe

Integral solution: 11
Integral solution: 38

Segmentierungsfehler Dieser Fehler tritt auf, wenn der Endwert des angegebenen Bereichs in einer rekursiven Suche 100000 überschreitet. Darüber hinaus kann man also keine x-Werte haben.

Verwenden Sie eine einfache Iteration

Wenn Sie eine ganzzahlige Lösung für x größer als 100.000 wünschen, verwenden wir keine Rekursion. Hier verwenden wir eine einfache Iteration von x von 1 bis 109 und vergleichen sie mit dem Wert auf der rechten Seite der Gleichung.

Beispiel

#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;
}

Ausgabe

Integral solution: 53248
Integral solution: 148963

Fazit

Wir haben Möglichkeiten untersucht, integrale Lösungen für die Gleichung x = b* (sumofdigits(x)^a) +c zu finden, einschließlich der Verwendung von Rekursion oder einfacher Iteration. Rekursive Methoden ermöglichen eine flexible Spezifizierung des Lösungsspektrums. Dies erhöht jedoch die zeitliche Komplexität und kann bei einem größeren Wertebereich zu Segmentierungsfehlern führen, was zu einem Stapelüberlauf führt.

Iterative Methoden sind hinsichtlich Zeitkomplexität und Speicherverbrauch effizient. Es bietet jedoch begrenzte Flexibilität und komplexeren Code. Daher haben beide Methoden ihre eigenen Vor- und Nachteile. Je nach Bedarf können Sie eine der Methoden wählen.

Das obige ist der detaillierte Inhalt vonAnzahl der ganzzahligen Lösungen der Gleichung x = b*(sumofdigits(x) ^ a)+c. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!