Bilangan penyelesaian integer kepada persamaan x = b*(sumofdigit(x) ^ a)+c

Andaikan tiga integer a, b dan c diberikan, dan terdapat persamaan x = b* (sumofdigit(x)^a) +c . Di sini, sumofdigits(x ) ialah jumlah semua digit dalam x. Untuk mencari semua kemungkinan penyelesaian kamiran yang memenuhi persamaan, kami akan meneroka pelbagai kaedah dalam C++.

Senario input dan output

Diberikan di bawah adalah nilai a, b dan c. Penyelesaian kamiran berbeza yang memenuhi persamaan x = b* (sumofdigit(x)^a) +c diberikan sebagai output.

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

Dalam kes di atas, a mempunyai nilai 2, b mempunyai nilai 2, c mempunyai nilai -3, dan kemungkinan nilai x ialah 125, 447, dan 575.

Pertimbangkan nombor 125. Jumlah digitnya ialah 8. Jika anda menggantikan nilai ini ke dalam persamaan b*(jumlah(x)^a) +c, jawapannya ialah #🎜 🎜#125# 🎜🎜#, sama dengan x. Oleh itu, ia adalah penyelesaian yang mungkin untuk Persamaan.

NOTA

- Penyelesaian kamiran persamaan ini adalah dalam julat 1 hingga 109. Gunakan rekursi

Kita boleh menggunakan carian rekursif untuk mencari penyelesaian kamiran bagi persamaan yang diberikan.

Kita perlu mencipta fungsi yang dipanggil

sumOfDigits()

yang mengira jumlah digit bagi mana-mana nombor tertentu N.

Lelaran ke atas nombor
• N

  menggunakan operator modulo dan operator bahagian.

Pengendali modulo digunakan untuk mengekstrak digit terakhir N.
Selepas setiap lelaran, nombor yang disimpan dalam pembolehubah
• jumlah

  ditambah satu demi satu.

Kami mencipta fungsi integralSolutions() untuk mengira penyelesaian integral.

Ia menggunakan fungsi
• sumOfDigits

  untuk mengira jumlah digit bagi x.

Seterusnya, menggunakan gelung for kita naikkan jumlah kepada kuasa a.
Kami menilai bahagian kanan persamaan dengan mendarab
• b

  dengan kuasa dan menambah c#🎜.

  Jika nilai x sama dengan nilai di sebelah kanan, ia dianggap sebagai penyelesaian integer.

• Seterusnya, kami mempunyai fungsi rekursif untuk mencari penyelesaian integral dalam julat tertentu.

Contoh

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

Output

Integral solution: 11
Integral solution: 38

Segmentation Fault

Ralat ini berlaku apabila nilai akhir julat yang ditentukan dalam carian rekursif melebihi 100000. Jadi anda tidak boleh mempunyai nilai-x melebihi itu.

Gunakan lelaran mudah

Jika anda mahukan penyelesaian integer untuk x lebih daripada 100000, maka kami tidak menggunakan rekursi. Di sini kita akan menggunakan lelaran mudah x dari 1 hingga 109 dan membandingkannya dengan nilai di sebelah kanan persamaan.

Contoh

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

Output

Integral solution: 53248
Integral solution: 148963

KESIMPULAN

Kami meneroka kaedah mencari penyelesaian integral kepada persamaan

x = b* (sumofdigit(x)^a) +c

, termasuk menggunakan rekursi atau lelaran mudah. Kaedah rekursif membolehkan anda menentukan julat penyelesaian secara fleksibel. Walau bagaimanapun, ia meningkatkan kerumitan masa dan mungkin menunjukkan kesalahan pembahagian untuk julat nilai yang lebih besar, mengakibatkan limpahan tindanan.

Kaedah berulang adalah cekap dari segi kerumitan masa dan penggunaan ingatan. Walau bagaimanapun, ia menawarkan fleksibiliti terhad dan kod yang lebih kompleks. Oleh itu, kedua-dua kaedah mempunyai kelebihan dan kekurangannya sendiri. Bergantung pada keperluan anda, anda boleh memilih mana-mana kaedah.

Atas ialah kandungan terperinci Bilangan penyelesaian integer kepada persamaan x = b*(sumofdigit(x) ^ a)+c. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!