Après avoir converti le nombre binaire donné en une base comprise entre L et R, calculez le nombre de nombres premiers

Le titre "Compte de nombres premiers après conversion d'un nombre binaire donné entre L et R" fait référence à un problème mathématique qui consiste à convertir un nombre binaire en une base entre L et R puis à compter les nombres compris entre L et R. Le nombre de nombres premiers. Convertir. En mathématiques, un nombre premier est un nombre entier supérieur à 1 qui n'est divisible que par 1 et par lui-même.

Pour convertir un nombre binaire en un nombre dans une base différente, vous devez écrire le nombre dans un système numérique différent. La base d'un système numérique est le nombre de nombres uniques, et la conversion s'effectue en trouvant une représentation équivalente de ce nombre dans la nouvelle base. Le calcul des nombres premiers après transformation est un problème difficile de théorie des nombres qui est utilisé en cryptographie, en informatique et dans d’autres domaines. Pour résoudre ce problème, vous devez en savoir beaucoup sur la théorie des nombres, les nombres premiers et les systèmes numériques.

Que sont les nombres premiers ?

Un nombre est dit premier uniquement s'il est divisible par 1 et le nombre lui-même. Par exemple, le nombre 5 est premier car il n’est divisible que par les nombres 1 et 5, mais 6 n’est pas premier car il est également divisible par 2 et 3.

Le nombre de nombres premiers consiste simplement à demander combien il y a de nombres premiers dans un ensemble de nombres donnés. Par exemple, prenons un ensemble de nombres {1,2,3,4,5,6,7,8,9} Dans cet ensemble de nombres, le nombre de nombres premiers est 4 et ils sont 2, 3, 5. , et 7. De plus, 1 n’est pas un nombre premier car son seul facteur positif est 1 lui-même.

Méthode

Il existe deux manières principales de calculer le problème des nombres premiers, comme indiqué ci-dessous −

• Méthode violente

• Factorisation Prime

Algorithme

Étape 1 - Entrez le nombre binaire et la plage pour les bases L et R.

Étape 2 - Parcourez chaque base entre L et R (inclus).

Étape 3 - Convertissez le nombre binaire en base actuelle.

Étape 4 - Vérifiez si le nombre converti est un nombre premier.

Étape 5 - Si le nombre converti est un nombre premier, augmentez le nombre de nombres premiers de 1.

Étape 6 - Répétez les étapes 3 à 5 pour toutes les bases comprises entre L et R.

Étape 7 - Renvoyez le nombre total de nombres premiers obtenus.

Vous trouverez ci-dessous le pseudocode de l'algorithme -

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() est une méthode qui accepte un nombre en entrée et renvoie une valeur booléenne indiquant si le nombre est premier.

Méthode 1 : Solution violente

L'approche par force brute consiste à convertir des nombres binaires dans chaque base de L à R et à compter le nombre de nombres premiers dans chaque conversion. Pour des nombres plus importants, toutes les variations possibles doivent être vérifiées, ce qui peut prendre du temps.

Le code ci-dessous contient trois fonctions. La première fonction est "isPrime" qui renvoie 1 si le nombre d'entrée est premier et 0 sinon. La deuxième fonction "binaryToDecimal" convertit un nombre binaire en nombre décimal. La troisième fonction "countPrimes" compte le nombre de nombres premiers obtenus en convertissant les nombres binaires entre les plages d'entrée en nombres décimaux. Enfin, la fonction principale prend un nombre binaire et une plage de nombres, appelle la fonction "countPrimes" et imprime le nombre de nombres premiers.

Exemple

Exemple

Ce code fournit des valeurs prédéfinies pour les nombres binaires et les plages L et R. Dans cet exemple, j'ai utilisé le nombre binaire 1010 et la plage de 5 à 20. Vous pouvez modifier ces valeurs dans la fonction principale selon vos besoins.

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

Sortie

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

Méthode 2 : Factorisation première

La factorisation première consiste à trouver les facteurs premiers d'un nombre transformé et à vérifier s'ils se situent dans la plage première. Cela peut être une méthode efficace pour des nombres plus petits, mais peut être coûteuse en termes de calcul pour des nombres plus grands.

Le code ci-dessous définit deux fonctions isPrime() et countPrimes(), qui vérifient si un nombre donné est un nombre premier ou comptent le nombre de nombres premiers avant un nombre donné. La fonction principale accepte un nombre binaire et une limite de base saisie par l'utilisateur, convertit le nombre binaire en décimal, puis le convertit en une base différente dans les limites données. Pour chaque conversion, le programme recherche des facteurs premiers et, s'ils se situent dans les limites de base actuelles, incrémente un compteur. Enfin, le programme imprime le nombre de nombres premiers trouvés. Le code importe les bibliothèques d'entrée/sortie standard et booléennes.

Code

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

Sortie

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

Conclusion

Pour résumer, nous pouvons déterminer le nombre de nombres premiers en convertissant d'abord un nombre binaire donné en une base comprise entre L et R, puis en comptant le nombre de nombres premiers dans cette plage.

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!