C++ 确定一个数是否为素数

我已经阅读了很多关于这个主题的代码，但是大多数代码都会生成素数，一直到输入数。然而，我需要只检查给定输入数是否为素数的代码

以下是我能够写的，但它不起作用：

void primenumber(int number)
{
    if(number%2!=0)
      cout<<"Number is prime:"<<endl;
    else 
      cout<<"number is NOt prime"<<endl;
}

void素数（整数）
{
如果（编号%2！=0）
cout您需要做更多的检查。现在，您只检查数字是否可以被2整除。对2、3、4、5、6……执行相同的操作，直到
数字
。提示：使用循环

解决此问题后，请尝试寻找优化。
提示：您只需检查所有数字的平方根，如果（输入%number！=0）返回false，我猜使用sqrt并将每个frpm 2运行到sqrt+1；
一旦你达到sqrt+1，你就可以确定它的素数。
这段代码只检查这个数字是否可以被2整除。对于一个素数，它不能被所有小于自身的整数整除。这可以通过检查它是否可以被小于
下限（sqrt（n））的所有整数整除来实现
在循环中。如果您感兴趣，存在大量输入。
如果您知道输入的范围（因为您的函数取
int
），您可以预先计算一个小于或等于最大输入平方根的素数表（在本例中为2^31-1），然后测试表中每个素数小于或等于给定数字平方根的整除性。
有几种不同的方法解决这个问题。

“天真”方法：尝试所有（奇数）数字，直到数字的根。

改进的“天真”方法：仅每6n±1次尝试一次。

概率测试：Miller Rabin、Solovay Strasse等

哪种方法适合您，取决于您使用prime做了什么。

您至少应该阅读。
我自己的IsPrime（）函数，它是基于著名的Rabin Miller算法的确定性变体编写的，结合优化的步长暴力强制，为您提供了最快的素数测试函数之一

__int64 power(int a, int n, int mod)
{
 __int64 power=a,result=1;

 while(n)
 {
  if(n&1) 
   result=(result*power)%mod;
  power=(power*power)%mod;
  n>>=1;
 }
 return result;
}

bool witness(int a, int n)
{
 int t,u,i;
 __int64 prev,curr;

 u=n/2;
 t=1;
 while(!(u&1))
 {
  u/=2;
  ++t;
 }

 prev=power(a,u,n);
 for(i=1;i<=t;++i)
 {
  curr=(prev*prev)%n;
  if((curr==1)&&(prev!=1)&&(prev!=n-1)) 
   return true;
  prev=curr;
 }
 if(curr!=1) 
  return true;
 return false;
}

inline bool IsPrime( int number )
{
 if ( ( (!(number & 1)) && number != 2 ) || (number < 2) || (number % 3 == 0 && number != 3) )
  return (false);

 if(number<1373653)
 {
  for( int k = 1; 36*k*k-12*k < number;++k)
  if ( (number % (6*k+1) == 0) || (number % (6*k-1) == 0) )
   return (false);

  return true;
 }

 if(number < 9080191)
 {
  if(witness(31,number)) return false;
  if(witness(73,number)) return false;
  return true;
 }


 if(witness(2,number)) return false;
 if(witness(7,number)) return false;
 if(witness(61,number)) return false;
 return true;

 /*WARNING: Algorithm deterministic only for numbers < 4,759,123,141 (unsigned int's max is 4294967296)
   if n < 1,373,653, it is enough to test a = 2 and 3.
   if n < 9,080,191, it is enough to test a = 31 and 73.
   if n < 4,759,123,141, it is enough to test a = 2, 7, and 61.
   if n < 2,152,302,898,747, it is enough to test a = 2, 3, 5, 7, and 11.
   if n < 3,474,749,660,383, it is enough to test a = 2, 3, 5, 7, 11, and 13.
   if n < 341,550,071,728,321, it is enough to test a = 2, 3, 5, 7, 11, 13, and 17.*/
}

\uuuu int64电源（int a、int n、int mod）
{
__int64功率=a，结果=1；
while（n）
{
如果（n&1）
结果=（结果*功率）%mod；
功率=（功率*功率）%mod；
n> >=1；
}
返回结果；
}
布尔证人（内部a、内部n）
{
int t，u，i；
__int64上一版本，当前版本；
u=n/2；
t=1；
而（！（u&1））
{
u/=2；
++t；
}
prev=功率（a、u、n）；
对于（i=1；i如果你很懒，并且有很多RAM，那么创建一个实际上是一个巨大的数组，你可以从中踢出所有不是素数的数字。
从那时起，每一个主要的“概率”测试都会非常快。
此快速结果解决方案的上限是RAM的数量。此超低结果解决方案的上限是硬盘的容量。
我遵循相同的算法，但不同的实现循环到sqrt（n）对于第2步，只使用奇数，因为我检查它是否可以被2或2*k整除，这是错误的。这是我的代码

public class PrimeTest {

    public static boolean isPrime(int i) {
        if (i < 2) {
            return false;
        } else if (i % 2 == 0 && i != 2) {
            return false;
        } else {
            for (int j = 3; j <= Math.sqrt(i); j = j + 2) {
                if (i % j == 0) {
                    return false;
                }
            }
            return true;
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        for (int i = 1; i < 100; i++) {
            if (isPrime(i)) {
                System.out.println(i);
            }
        }
    }

}

公共类PrimeTest{
公共静态布尔iPrime（int i）{
如果（i<2）{
返回false；
}else if（i%2==0&&i！=2）{
返回false；
}否则{
对于（int j=3；j
#定义真1
#定义FALSE-1
int main（）
{
/*局部变量声明*/
int num=0；
int结果=0；
/*从用户处获取最大素数四重态值为的编号
被发现*/
printf（“\n输入数字：”）；
scanf（“%d”和&num）；
结果=是素数（num）；
/*将结果打印到标准输出*/
if（TRUE==结果）
printf（“\n%d是一个素数\n”，num）；
其他的
printf（“\n%d不是质数\n”，num）；
返回0；
}
int是_素数（int num）
{
int i=0；
/*检查数字是否为负数。如果num为负数，则生成
这是肯定的*/
如果（0>num）
num=-num；
/*检查数字是否小于2*/
如果（2>num）
返回FALSE；
/*检查数字是否为2*/
如果（2==num）
返回TRUE；
/*检查数字是否为偶数。偶数
不是质数*/
如果（0==（数值%2））
返回FALSE；
/*检查该数字是否可被较小的数字整除
1+=2，用于跳过对偶数整除性的检查。
迭代减少到一半*/
对于（i=3；i
bool isPrime（整数）{
如果（数字<2）返回false；
if（number==2）返回true；
if（数字%2==0）返回false；
对于（inti=3；（i*i）使用数学，首先找到数字的平方根，然后开始循环，直到数字结束，这是平方根之后得到的结果。
检查每个值的给定数字是否可被迭代值整除。如果任何值将给定数字整除，则它不是素数，否则为素数。
这是密码

 bool is_Prime(int n)
 {

   int square_root = sqrt(n); // use math.h
   int toggle = 1;
   for(int i = 2; i <= square_root; i++)
   {
     if(n%i==0)
     { 
        toggle = 0;
        break;
     }
   }

   if(toggle)
     return true;
   else
     return false;

 } 

bool是素数（int n）
{
int square_root=sqrt（n）；//使用math.h
int-toggle=1；
对于（int i=2；i
if（数字%2！=0）
库特
检查是否有素数
C++

bool isPrime(int number){
    if (number != 2){
        if (number < 2 || number % 2 == 0) {
            return false;
        }
        for(int i=3; (i*i)<=number; i+=2){
            if(number % i == 0 ){
                return false;
            }
        }
    }
    return true;
}

bool isPrime（整数）{
如果（数字！=2）{
如果（数字<2 | |数字%2==0）{
返回false；
}
对于（inti=3；（i*i）如果n是2，它就是素数

如果n是1，它不是素数

如果n是偶数，它就不是素数

如果n是奇数，大于2，我们必须检查所有奇数3..sqrt（n）+1，如果这些数字中的任何一个可以除n，n不是素数，否则，n是素数

为了获得更好的性能，我推荐使用埃拉托斯烯筛

以下是代码示例：

bool是素数（int n）
{
如果（n==2），则返回true；
如果（n==1 | | n%2==0）返回false；
对于（int i=3；i*i

我想到了这个：

int counter = 0;

bool checkPrime(int x) {
   for (int y = x; y > 0; y--){
      if (x%y == 0) {
         counter++;
      }
   }
   if (counter == 2) {
      counter = 0; //resets counter for next input
      return true; //if its only divisible by two numbers (itself and one) its a prime
   }
   else counter = 0;
        return false;
}

我使用这个想法来确定编号是否为素数：

#include <conio.h> 
#include <iostream>
using namespace std;
int main() {
  int x, a;
  cout << "Enter The No. :";
  cin >> x;
  int prime(unsigned int);
  a = prime(x);
  if (a == 1)
    cout << "It Is A Prime No." << endl;
  else
  if (a == 0)
    cout << "It Is Composite No." << endl;
  getch();
}

int prime(unsigned int x) {
  if (x == 1) {
    cout << "It Is Neither Prime Nor Composite";
    return 2;
  }
  if (x == 2 || x == 3 || x == 5 || x == 7)
    return 1;
  if (x % 2 != 0 && x % 3 != 0 && x % 5 != 0 && x % 7 != 0)
    return 1;
  else
    return 0;
}

#在
bool isPrime(int number){

    if(number < 2) return false;
    if(number == 2) return true;
    if(number % 2 == 0) return false;
    for(int i=3; (i*i)<=number; i+=2){
        if(number % i == 0 ) return false;
    }
    return true;

}

 bool is_Prime(int n)
 {

   int square_root = sqrt(n); // use math.h
   int toggle = 1;
   for(int i = 2; i <= square_root; i++)
   {
     if(n%i==0)
     { 
        toggle = 0;
        break;
     }
   }

   if(toggle)
     return true;
   else
     return false;

 } 

if(number%2!=0)
      cout<<"Number is prime:"<<endl;

bool check_prime(int num) {
    for (int i = num - 1; i > 1; i--) {
        if ((num % i) == 0)
            return false;
    }
    return true;
}

bool isPrime(int number){
    if (number != 2){
        if (number < 2 || number % 2 == 0) {
            return false;
        }
        for(int i=3; (i*i)<=number; i+=2){
            if(number % i == 0 ){
                return false;
            }
        }
    }
    return true;
}

function isPrime(number)
{
    if (number !== 2) {
        if (number < 2 || number % 2 === 0) {
            return false;
        }
        for (var i=3; (i*i)<=number; i+=2)
        {
            if (number % 2 === 0){
                return false;
            }
        }
    }
    return true;
}

def isPrime(number):
    if (number != 2):
        if (number < 2 or number % 2 == 0):
            return False
        i = 3
        while (i*i) <= number:
            if(number % i == 0 ):
                return False;
            i += 2
    return True;

bool is_prime(int n)
{
  if (n == 2) return true;
  if (n == 1 || n % 2 == 0) return false;

  for (int i = 3; i*i < n+1; i += 2) {
      if (n % i == 0) return false;
  }

  return true;
}

int counter = 0;

bool checkPrime(int x) {
   for (int y = x; y > 0; y--){
      if (x%y == 0) {
         counter++;
      }
   }
   if (counter == 2) {
      counter = 0; //resets counter for next input
      return true; //if its only divisible by two numbers (itself and one) its a prime
   }
   else counter = 0;
        return false;
}

#include <conio.h> 
#include <iostream>
using namespace std;
int main() {
  int x, a;
  cout << "Enter The No. :";
  cin >> x;
  int prime(unsigned int);
  a = prime(x);
  if (a == 1)
    cout << "It Is A Prime No." << endl;
  else
  if (a == 0)
    cout << "It Is Composite No." << endl;
  getch();
}

int prime(unsigned int x) {
  if (x == 1) {
    cout << "It Is Neither Prime Nor Composite";
    return 2;
  }
  if (x == 2 || x == 3 || x == 5 || x == 7)
    return 1;
  if (x % 2 != 0 && x % 3 != 0 && x % 5 != 0 && x % 7 != 0)
    return 1;
  else
    return 0;
}

bool check_prime(int num) {
for (int i = num - 1; i > 1; i--) {
    if ((num % i) == 0)
        return false;
}
return true;
}

bool check_prime(int number)
{
    if (number > 1)
    {
        for (int i = number - 1; i > 1; i--)
        {
            if ((number % i) == 0)
                return false;
        }
        return true;
    }
    return false;
}

bool isPrimeNumber(int n) {
    int divider = 2;
    while (n % divider != 0) {
        divider++;
    }
    if (n == divider) {
        return true;
    }
    else {
        return false;
    }
}

//simple function to determine if a number is a prime number
//to state if it is a prime number


#include <iostream>

using namespace std;


int isPrime(int x);  //functioned defined after int main()


int main()
{
 int y;
    cout<<"enter value"<<endl;

    cin>>y;

    isPrime(y);    

  return 0;

 } //end of main function


//-------------function

  int isPrime(int x)
 {
   int counter =0;
     cout<<"factors of "<<x<<" are "<<"\n\n";    //print factors of the number

     for (int i =0; i<=x; i++)

     {
       for (int j =0; j<=x; j++)

         {
           if (i * j == x)      //check if the number has multiples;
                {

                  cout<<i<<" ,  ";  //output provided for the reader to see the
                                    // muliples
                  ++counter;        //counts the number of factors

                 }


          }


    }
  cout<<"\n\n";

  if(counter>2) 
     { 
      cout<<"value is not a prime number"<<"\n\n";
     }

  if(counter<=2)
     {
       cout<<"value is a prime number"<<endl;
     }
 }

   bool isPrime(int n)
   {
       if(n==1) return false;
       if(n==2 || n==3) return true;
       if(n%2==0 || n%3==0) return false;
       for(int i=5;i*i<=n;i=i+6)
           if(n%i==0 || n%(i+2)==0)
               return false;
       return true;        
      
    }