在将给定的二进制数转换为L到R之间的进制后，计算质数的个数

标题“在 L 和 R 之间转换给定二进制数后的素数计数”是指一个数学问题，涉及将二进制数转换为 L 和 R 之间的基数，然后计算来自 L 和 R 之间的素数的个数。转换。在数学中，素数是大于 1 的整数，只能被 1 和它本身整除。

要将二进制数转换为不同基数的数，需要将该数写成不同的数制。数制的基数是唯一数字的数量，转换是通过在新基数中找到该数的等效表示来完成的。在转换之后计算质数是一个困难的数论问题，它在密码学、计算机科学和其他领域中有用途。要解决这个问题，你需要对数论、质数和数制有很多了解。

什么是素数？

只有当一个数能被 1 和该数本身整除时，该数才被称为素数。举个例子，数字 5 是素数，因为它只能被数字 1 和 5 整除，而 6 不是素数，因为它也能被 2 和 3 整除。

素数的数量仅仅是询问在给定的一组数字中有多少个素数。例如，取一组数字{1,2,3,4,5,6,7,8,9}，在这组数字中，素数的数量是4，它们是2、3、5、7。此外，1不是素数，因为它的唯一正因子是1本身。

方法

有两种主要方法来计算质数问题，如下所示−

• 暴力方法

• 质因数分解

算法

步骤 1 - 输入二进制数以及基数 L 和 R 的范围。

步骤 2 - 迭代 L 和 R（包括）之间的每个碱基。

第 3 步 - 将二进制数转换为当前基数。

步骤 4 − 检查转换后的数字是否为质数。

第5步 - 如果转换后的数字是质数，则将质数计数增加1。

步骤 6 - 重复步骤 3-5，针对范围 L 到 R 中的所有基数。

步骤 7 − 返回获得的质数的总数。

下面给出的是算法的伪代码 -

input: binary number b, range of bases L and R
output: count of prime numbers in the given range

Number_of_prime = 0
for base = L to R
convert b to base
if number_is_prime(converted_number)
   Number_of_prime ++
return Number_of_prime

number_is_prime() 是一个方法，它接受一个数字作为输入，并返回一个布尔值，显示该数字是否为质数。

方法一：暴力解决方法

Brute Force Approach（蛮力法）涉及将二进制数转换为从L到R之间的每个进制，并计算每个转换中的质数数量。对于较大的数字，需要检查所有可能的变化，这可能会耗费大量时间。

下面的代码包含三个函数。第一个函数是“isPrime”，如果输入数字是素数，则返回 1，否则返回 0。第二个函数“binaryToDecimal”将二进制数转换为十进制数。第三个函数“countPrimes”计算通过将输入范围之间的二进制数转换为十进制数获得的素数的数量。最后，主函数输入一个二进制数和一个数字范围，调用“countPrimes”函数并打印素数的计数。

Example

的中文翻译为：

示例

这段代码为二进制数和范围L和R提供了预定义的值。在这个例子中，我使用了二进制数1010和范围5到20。您可以根据需要在主函数中更改这些值。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Function to check if a number is prime or not
int isPrime(int n) {
   int i;
   for(i = 2; i <= sqrt(n); i++) {
      if(n%i == 0) {
         return 0;
      }
   }
   return 1;
}

// Function to convert binary to decimal
int binaryToDecimal(int n) {
   int decimal = 0, i = 0, remainder;
   while(n != 0) {
      remainder = n % 10;
      n /= 10;
      decimal += remainder * pow(2, i);
      ++i;
   }
   return decimal;
}

// Function to count primes in a given range
int countPrimes(int L, int R) {
   int count = 0, i;
   for(i = L; i <= R; i++) {
      int decimal = binaryToDecimal(i);
      if(isPrime(decimal)) {
         count++;
      }
   }
   return count;
}

// Main function
int main() {
   int binary = 1010; // Example binary number
   int L = 5;         // Example range lower limit
   int R = 20;        // Example range upper limit

   // Count primes and print result
   int count = countPrimes(L, R);
   printf("Number of primes after converting %d to base between %d and %d is: %d\n", binary, L, R, count);

   return 0;
}

输出

Number of primes after converting 1010 to base between 5 and 20 is: 7

方法 2：质因数分解

素数分解包括查找变换后的数的素数因子并检查它们是否在素数范围内。对于较小的数字来说，它可能是一种有效的方法，但对于较大的数字来说，计算成本可能会很高。

下面的代码定义了两个函数 isPrime() 和 countPrimes()，它们检查给定数字是否为素数或计算给定数字之前的素数个数。主函数接受用户输入的二进制数和基数限制，将二进制数转换为十进制，然后将其转换为给定限制内的不同基数。对于每次转换，程序都会查找质因数，如果它们在当前基本限制内，则增加计数器。最后，程序打印找到的素数的数量。该代码导入标准输入/输出和布尔库。

Code

的中文翻译为：

代码

#include <stdio.h>
#include <stdbool.h>
#include <math.h>

bool isPrime(int n) {
   if (n <= 1) {
      return false;
   }
   int i;
   for (i = 2; i <= sqrt(n); i++) {
      if (n % i == 0) {
         return false;
      }
   }
   return true;
}

int main() {
   int binaryNum = 110101; // Predefined binary number input
   int L = 3; // Predefined lower limit of base
   int R = 6; // Predefined upper limit of base

   int decimalNum = 0, base = 1;
   while (binaryNum > 0) {
      int digit = binaryNum % 10;
      decimalNum += digit * base;
      base *= 2;
      binaryNum <span>/</span>= 10;
   }

   int transformedNum, factor;
   int primeCount = 0;
   for (int baseNum = L; baseNum <= R; baseNum++) {
      transformedNum = decimalNum;
      while (transformedNum > 1) {
         for (int i = 2; i <= transformedNum; i++) {
            if (transformedNum % i == 0) {
               factor = i;
               break;
            }
         }
         transformedNum <span>/</span>= factor;
         if (isPrime(factor) && factor >= baseNum) {
            primeCount++;
         }
      }
   }
   printf("Count of primes after converting the given binary number in base between L to R is: %d", primeCount);
   return 0;
}

输出

Count of primes after converting the given binary number in base between L to R is: 4

结论

总而言之，我们可以通过先将给定的二进制数转换为 L 到 R 之间的基数，然后计算该范围内的素数个数，来确定素数的个数。

以上是在将给定的二进制数转换为L到R之间的进制后，计算质数的个数的详细内容。更多信息请关注PHP中文网其他相关文章！