Bilangan faktor hasil darab N nombor

Pembahagi nombor ialah nombor yang boleh membahagikannya kepada integer tanpa sebarang baki. Dalam erti kata lain, pembahagi nombor n ialah nombor yang memberikan n apabila didarab dengan sebarang integer lain. Ia juga boleh dipanggil faktor nombor.

Dividend ÷ Divisor = Quotient.

Sebagai contoh, jika kita membahagi 5 dengan 60, kita akan mendapat 12 dan sebaliknya, oleh itu, 12 dan 60 boleh dianggap sebagai pembahagi 60.

Bilangan faktor didarab dengan N nombor

Tugas yang diberikan ialah mencari bilangan pembahagi hasil darab nombor yang diberi. Marilah kita memahami masalah ini melalui contoh.

Andaikan kita diberi nombor 6, 6 dan 10. Hasil darab nombor ini ialah 120, dan pembahagi 120 ialah 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120. Oleh itu, output hendaklah 16.

Input: 6, 2, 10
Output: 16

Gunakan operator modulo

Salah satu cara untuk mencapai matlamat ini ialah menggunakan pengendali modulo(%) untuk mencari pembahagi dan mengiranya dengan mengulang dari 1 hingga produk.

Pengendali modulo operator (%) digunakan untuk mendapatkan baki operasi pembahagian. Jika baki bahagian adalah sifar, ini bermakna dividen boleh dibahagi oleh pembahagi. Contohnya, (30 % 5) ialah 0, jadi 30 boleh dibahagi dengan 5.

Kira bilangan pembahagi hasil darab semua nombor dalam tatasusunan.

• Darab semua nombor dalam tatasusunan menggunakan pengendali pendaraban dan simpan hasilnya dalam pembolehubah bernama produk.

• Gunakan pengendali modulo, dari 1 hingga Produk, bahagikan Produk dengan setiap nombor dan dapatkan bakinya.

• Buat kiraan pembolehubah, dan jika bakinya ialah 0, tambah pembolehubah kiraan.

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

Atur cara berikut mengira bilangan pembahagi hasil darab bagi nombor tertentu −

#include <iostream>
using namespace std;

// Define a function for finding the number
int findNumberOfDivisors(int arr[], int N) {

   // Multiply all the numbers in the array
   int product = 1;
   for (int x = 0; x < N; x++) {
      product *= arr[x];
   }

   // Count the divisors
   int count = 0;
   for (int x = 1; x <= product; x++) {
      if (product % x == 0) {
         count++;
      }
   }

   return count;
}
int main() {

   // Declaration of the numbers and N
   int numbers[] = { 12, 16, 40 };
   int N = sizeof(numbers) / sizeof(numbers[0]);
   int divisors = findNumberOfDivisors(numbers, N);
   std::cout << "Number of divisors: " << divisors;
   return 0;
}

Output

Number of divisors: 40

Nota− Kaedah ini sangat tidak cekap untuk nombor yang lebih besar. Oleh kerana bilangannya besar, produk juga akan menjadi besar. Ini akan menghasilkan sejumlah besar lelaran, meningkatkan kerumitan masa.

Gunakan pemfaktoran perdana

Jika N ialah nombor komposit, maka

N = x<sup>a</sup>  * y<sup>b</sup>  * z<sup>c</sup>

Di mana a, b dan c adalah faktor perdana, maka bilangan pembahagi N diberikan oleh formula berikut

(a + 1)(b + 1)(c + 1)

Kami akan menggunakan konsep di atas untuk mencari pembahagi hasil darab N nombor.

Algoritma/Langkah

• Darab semua nombor N dan simpan hasilnya dalam pembolehubah yang dipanggil produk.

• Lelaran gelung untuk daripada 2 hingga punca kuasa dua, produk.

• Dapatkan faktor utama produk. Untuk melakukan ini, kami menggunakan operator modulo untuk menyemak sama ada produk boleh dibahagikan dengan nilai semasa x. Jika boleh, x disimpan sebagai faktor perdana dan kira disimpan sebagai kuasa faktor perdana.

• Gunakan perpustakaan dan fungsi push_back() untuk menyimpan faktor perdana dan eksponennya dalam bekas vektor primeFactor dan kuasa.

• Jika ada baki faktor utama, simpan juga.

• Kira pembahagi dengan mengulang daripada 0 kepada bilangan faktor perdana dan menggunakan formula di atas.

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

Berikut ialah program untuk mencari bilangan faktor hasil darab nombor tertentu menggunakan kaedah pemfaktoran perdana -

#include <iostream>
#include <vector>
#include <cmath>

// Multiply all the N numbers
int findNumberOfDivisors(int arr[], int N) {
   int product = 1;
   for (int x = 0; x < N; x++) {
      product *= arr[x];
   }

   std::vector<int> primeFactor;
   std::vector<int> power;
    
   // Check if x is divisor of product

   // Store the prime factor and exponent in the vector container
   for (int x = 2; x <= sqrt(product); x++) {
      if (product % x == 0) {
         int count = 0;
         while (product % x == 0) {
            product /= x;
            count++;
         }
         primeFactor.push_back(x);
         power.push_back(count);
      }
   }
    
   // Store the remaining prime factor (if present)  
   if (product > 1) {
      primeFactor.push_back(product);
      power.push_back(1);
   }
    
   // Count the number of divisors
   int divisorsCount = 1;
   for (int x = 0; x < primeFactor.size(); x++) {
      divisorsCount *= (power[x] + 1);
   }

   return divisorsCount;
}

int main() {
   int numbers[] = {12, 16, 40};
   
   // Calculate the number of elements in the array
   int N = sizeof(numbers) / sizeof(numbers[0]);
   int divisors = findNumberOfDivisors(numbers, N);
   std::cout << "Number of divisors: " << divisors << std::endl;
   return 0;
}

Output

Number of divisors: 40

Gunakan gelung bersarang

Kami juga boleh mencari hasil darab semua nombor N melalui gelung bersarang. Dalam gelung luar, kita perlu mengulangi semua nombor dari 1 hingga produk. Dalam julat nombor ini kita akan menemui semua pembahagi yang mungkin. Dalam gelung bersarang, kami akan mengira bilangan pembahagi untuk setiap nombor dan gandaannya.

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

#include <iostream>
#include <vector>

int findNumberOfDivisors(int arr[], int N) {
   std::vector<int> divisorsCount(11000, 0);
    
   // Multiply all the N numbers
   int product = 1;
   for (int x = 0; x < N; x++) {
      product *= arr[x];
    }
    
   // Count of divisors
   for (int x = 1; x <= product; x++) {
      for (int y = x; y <= product; y += x) {
         divisorsCount[y]++;
      }
   }

   return divisorsCount[product];
}

int main() {
   int numbers[] = {12, 16, 40};
   int N = sizeof(numbers) / sizeof(numbers[0]);
   int divisors = findNumberOfDivisors(numbers, N);
   std::cout << "Number of divisors: " << divisors << std::endl;
   return 0;
}

Output

Number of divisors: 40

Kesimpulan

Kami telah membincangkan cara yang berbeza untuk mencari bilangan pembahagi hasil darab N, termasuk menggunakan operator modulo, pemfaktoran perdana, gelung bersarang dan banyak lagi. Untuk nombor yang lebih besar, kami tidak boleh menggunakan operator modulo dengan cekap. Untuk mendapatkan hasil yang dioptimumkan, kita boleh menggunakan pemfaktoran perdana dan gelung bersarang.

Atas ialah kandungan terperinci Bilangan faktor hasil darab N nombor. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!