Php 循环中求素数的公式

我需要用for循环或while循环找到素数

这是我写的，但这是错的

<?php
$i = 1;
while($i<5)
{
    for($j=1; $j<=$i; $j++)
    {
        if ($j != 1 && $j != $i)
        {
            echo $i . "/" . $j . "=" . $i%$j . "<br />";
            if ($i%$j != 0)
            {
                echo $i . "<br />";
            }
        }
    }
    echo "<br />";
    $i += 1;
}
?>

---

有没有办法用数组除以一个数来找到剩余的数？

你可以使用这个PHP函数

我发现了一个小函数：（）似乎对我有用

function isPrime($num) {
    //1 is not prime. See: http://en.wikipedia.org/wiki/Prime_number#Primality_of_one
    if($num == 1)
        return false;

    //2 is prime (the only even number that is prime)
    if($num == 2)
        return true;

    /**
     * if the number is divisible by two, then it's not prime and it's no longer
     * needed to check other even numbers
     */
    if($num % 2 == 0) {
        return false;
    }

    /**
     * Checks the odd numbers. If any of them is a factor, then it returns false.
     * The sqrt can be an aproximation, hence just for the sake of
     * security, one rounds it to the next highest integer value.
     */
    $ceil = ceil(sqrt($num));
    for($i = 3; $i <= $ceil; $i = $i + 2) {
        if($num % $i == 0)
            return false;
    }

    return true;
}

函数isPrime（$num）{
//1不是素数。请参见：http://en.wikipedia.org/wiki/Prime_number#Primality_of_one
如果（$num==1）
返回false；
//2为素数（唯一为素数的偶数）
如果（$num==2）
返回true；
/**
*如果这个数可以被2整除，那么它就不是素数，也不再是素数
*需要检查其他偶数
*/
如果（$num%2==0）{
返回false；
}
/**
*检查奇数。如果其中任何一个是因子，则返回false。
*sqrt可以是近似值，因此只是为了
*安全性，将其舍入到下一个最高整数值。
*/
$ceil=ceil（sqrt（$num））；
对于（$i=3；$i来说，我相信这是一个非常有效的例程，它列出了最多1000个素数

它测试每个数字（$x），以查看它是否有任何因素（当然除了它本身和1）

从数学上讲，没有必要测试所有可能的较低的数字，只测试低至平方根$x的素数。这是通过存储在数组中找到的素数实现的（我认为这是OP所指的策略）

一旦找到第一个素数因子，我们就知道$x不是素数，因此不需要进一步测试$x的值，我们就可以打破foreach循环

$primes = array();
for ($x = 2; $x <= 1000; $x++) {
    $xIsPrime = TRUE;
    $sqrtX = sqrt($x);
    foreach ($primes as $prime) if ($prime > $sqrtX || ((!($x % $prime)) && (!$xIsPrime = FALSE))) break;
    if ($xIsPrime) echo ($primes[] = $x)  . "<br>";
}

$primes=array（）；
对于（$x=2；$x$sqrtX | |（！（$x%$prime））和（！$xIsPrime=FALSE））中断；
if（$xispreime）echo（$primes[]=$x）。“
”；
}
这是一个基本实现：

function prima($n){

  for($i=1;$i<=$n;$i++){  //numbers to be checked as prime

          $counter = 0; 
          for($j=1;$j<=$i;$j++){ //all divisible factors


                if($i % $j==0){ 

                      $counter++;
                }
          }

        //prime requires 2 rules ( divisible by 1 and divisible by itself)
        if($counter==2){

               print $i." is Prime <br/>";
        }
    }
} 

prima(20);  //find prime numbers from 1-20

在这里一步一步地完成逻辑和视觉类比：
我知道这有点晚了，但希望它能帮助别人

    function prime_number_finder($range)
    {
        $total_count=0;//intitialize the range keeper

        $i=1;//initialize the numbers to check

        while ($total_count<=$range)
        {
           $count=0;//initialize prime number inner count
           $k=$i;
           while ($k!=0)
           {

             if(($i%$k)==0)
             {
              $count++;
             }
              $k--;
           }
           //condition to check if a number is prime 
          if($count==2 || $count==1)
           {
            echo $i."</br>";//output the prime number;
            $total_count++;
            $i++;

           }
           //number is not prime
           if($count>2)
           {
             //$total_count++;
            $i++;
           }

        }
    }

函数素数查找器（$range）
{
$total_count=0；//初始化范围保持器
$i=1；//初始化要检查的数字
而（$total_count2）
{
//$total_count++；
$i++；
}
}
}

//范例
素数查找器（200）；
任何sqrt（）的值都是假的，或者任何浮点值都是素数
这是我不久前找到的一条用于检查素数的线性。它使用计数标记（一元数学）来确定：

function is_prime_via_preg_expanded($number) {
    return !preg_match('/^1?$|^(11+?)\1+$/x', str_repeat('1', $number));
}

按顺序检查素数的所有数字：

$i=2; // start here (2 is the first prime)
while (1) { // neverending loop
    if (is_prime_via_preg_expanded($i)) echo $i." <br />\n";
    $i++;
}

$i=2；//从这里开始（2是第一个素数）
而（1）{//neverending循环
如果（通过预处理扩展（$i））回显$i.“
\n”；
$i++；
}

要仅检查一系列素数，如提供的示例中所示：

$start = 2; // start here (2 is the first prime)
$end = 100;

$i=$start;
while ($i<=$end) {
    if (is_prime_via_preg_expanded($i)) echo $i." <br />\n";
    $i++;
}

$start=2；//从这里开始（2是第一个素数）
$end=100；
$i=$start；
而（$i
$n=7；
如果（$n==1）{
回音“不是一个基本的或复合的否”；
}
$set=0；
对于（$index=2；$index是查找素数的简单而快速的算法

function getPrimes($finish)
    {
        $number = 2;
        $range = range($number,$finish);
        $primes = array_combine($range,$range);
        while($number*$number < $finish){
            for($i=$number; $i<=$finish; $i+=$number){
                if($i==$number){
                    continue;
                }
                unset($primes[$i]);
            }
            $number = next($primes);
        }
        return $primes;
    }

函数getPrimes（$finish）
{
$number=2；
$range=范围（$number，$finish）；
$primes=array\u combine（$range，$range）；
而（$number*$number<$finish）{
对于不带数学函数的（$i=$number；$i）：

function isPrimeNumber($i) {
    $n = 2;
    while ($n < $i) {
        if ($i % $n) {
            $n++;
            continue;
        }

        return false;
    }

    return true;
}

函数isPrimeNumber（$i）{
$n=2；
而（$n<$i）{
如果（$i%$n）{
$n++；
继续；
}
返回false；
}
返回true；
}
使用数组_filter（）中的闭包查找1到10000之间的素数：

$start=2；
$step=10000；
$stop=$start+$step；
$candidates=范围（$start，$stop）；
对于（$num=2；$num检查一个数是否为素数的最好方法是查看它是否可被它前面的任何素数整除。Pi（x）是我一直在到处看到的一个……你可以看到更多关于素数计数的信息

因此，目前我能想到的最有效的方法是：

class prime
{
    public $primes = [ 2, 3, 5, 7 ];
    public $not_prime = [ 1, 4, 6, 8, 9 ];
    public function is_prime( int $n )
    {
        if ( $n <= 1 ) return false;
        if ( in_array( $n, $this->primes ) ) return true;
        if ( in_array( $n, $this->not_prime ) ) return false;
        for( $i = 0; $i < count( array_slice( $this->primes, 0, $this->prime_count( $n ) ) ) || $i == $n; $i++ )
        {
            if ( $n % $this->primes[ $i ] == 0 ) return false;
        }
        return true;
    }
    public function build_primes_to( int $n )
    {
        for ( $i = end( $this->primes ) + 1; $i <= $n; $i++ )
        {
            if ( $this->is_prime( $i ) )
            {
                $this->primes[] = $i;
            }
            else
            {
                $this->not_prime[] = $i;
            }
        }
    }
    public function prime_count( $n )
    {
        $ln = log( $n );
        if ( $ln == 0 ) return 1;
        return intval( ceil( $n / $ln ) );
    }
}

类素数
{
公共$primes=[2,3,5,7]；
公共$not_prime=[1,4,6,8,9]；
公共函数为素数（整数$n）
{
如果（$n个素数））返回true；
如果（在数组中（$n，$this->not_prime））返回false；
对于（$i=0；$iprimes，0，$this->prime_count（$n）））|$$i==n；$i++）
{
如果（$n%$this->primes[$i]==0）返回false；
}
返回true；
}
公共功能构建（整数$n）
{
对于（$i=end（$this->primes）+1；$i是_prime（$i））
{
$this->primes[]=$i；
}
其他的
{
$this->not_prime[]=$i；
}
}
}
公共函数素数（n美元）
{
$ln=对数（$n）；
如果（$ln==0）返回1；
返回intval（ceil（$n/$ln））；
}
}

这实际上不是很有效，好吧，当涉及到建立素数列表时就不是了……我一直在研究一种更好的建立列表的方法，尽管在网上找到一个列表并使用它同样容易而且效率更高

上述内容的使用应遵循以下原则：

$find_to = 1000;
$prime = new prime();
$prime->build_primes_to( $find_to );
print "<pre>";
for ( $i = 1; $i < $find_to; $i++ )
{
    print "$i is " . ( !$prime->is_prime( $i ) ? "not " : "" ) . "prime\n";
}

$find_to=1000；
$prime=新的prime（）；
$prime->build\u primes\u to（$find\u to）；
打印“”；
对于（$i=1；$i<$find_to；$i++）
{
打印“$i is.”（！$prime->is_prime（$i）？“not”：“）“prime\n”；
}
我知道为时已晚，但我发现这个解决方案更优雅

<?php

    $n = 11;
    $o = $_POST["maxprime"];
    echo 'The script calculated the next primenumbers:</br>';
    echo '2, 3, 5, 7, ';
    while (true) { 
        $t = 6;
        while (true) { 
            if ($n % ($t - 1) == 0) {
                break;
            } 
            if ($n % ($t + 1) == 0) {
                break;
            }
            if ($t > sqrt($n)) {
                echo("$n,  "); 
                break;
            } 
            $t += 6; 
        }
        if (($n + 1) % 6 == 0) {
            $n += 2;
        } else {
            $n += 4;
        } 
        if ($n > $o) {
            break;
        }
    }

?>

函数isPrime（$num）
{
如果（$num<2）{
返回false；
}
对于（$i=2；$i


我知道这有点晚了，但这里有一个简单的程序可以帮助您实现您的要求

<?php
function prime_number($num){
    for( $j = 2; $j <= $num; $j++ )
    {
        for( $k = 2; $k < $j; $k++ )
        {
            if( $j % $k == 0 )
            {
                break;
            }
        }
        if( $k == $j )
            echo "Prime Number : ".$j."<br>";
    }
}
prime_number(23);
?>


增强版@Farkie answer，专门用于检查循环中的素数

V1 (1 to 5,000,000): divisions=330 929 171; primes=348 513; time=21.243s
V2 (1 to 5,000,000): divisions=114 291 299; primes=348 513; time=10.357s

注意！
isPrime\u v2
功能仅在以下情况下适用
function isPrime($num)
{
    if ($num < 2) {
        return false;
    }
    for ($i = 2; $i <= $num / 2; $i++) {
        if ($num % $i == 0) {
            return false;
        }
    }

    return true;
}

<?php

    $n = 11;
    $o = $_POST["maxprime"];
    echo 'The script calculated the next primenumbers:</br>';
    echo '2, 3, 5, 7, ';
    while (true) { 
        $t = 6;
        while (true) { 
            if ($n % ($t - 1) == 0) {
                break;
            } 
            if ($n % ($t + 1) == 0) {
                break;
            }
            if ($t > sqrt($n)) {
                echo("$n,  "); 
                break;
            } 
            $t += 6; 
        }
        if (($n + 1) % 6 == 0) {
            $n += 2;
        } else {
            $n += 4;
        } 
        if ($n > $o) {
            break;
        }
    }

?>

<?php 
 //Prime Function
 function fn_prime($number) {
    $i = 2; $result = TRUE;
    while($i < $number) {
        if(!($number%$i)) {
            $result = FALSE;
        }
        $i++;
    }
    return $result;
 }

//Declare integer variable...
$k = 0;

//Start Loop up to any number of your choice for e.g. 200
while($k < 200) {
    if(fn_prime($k)) {
        echo "$k is a prime number<br/>";
    } else {
        echo "$k is not a prime number!<br/>";
    }
    $k++;
}

?>

<?php
function prime_number($num){
    for( $j = 2; $j <= $num; $j++ )
    {
        for( $k = 2; $k < $j; $k++ )
        {
            if( $j % $k == 0 )
            {
                break;
            }
        }
        if( $k == $j )
            echo "Prime Number : ".$j."<br>";
    }
}
prime_number(23);
?>

function isPrime_v2($num) {
    static $knownPrimes=[3]; // array to save known primes

    if($num == 1)
        return false;

    if($num == 2 || $num == 3) //added '3'
        return true;

    if($num % 2 == 0)
        return false;

    $ceil = ceil(sqrt($num)); //same purpose, good point from Farkie

    // Check against known primes to shorten operations
    // There is no sense to check agains numbers in between
    foreach($knownPrimesas $prime){
        if ($prime>$ceil)
            break;
        if($num===$prime)
            return true;
        if($num % $prime == 0)
            return false;
    }


    /**
     * end($knownPrimes) % 2 !==0 - mathematically guaranteed
     * start with latest known prime
     */
    for($i = end($knownPrimes)+2; $i <= $ceil; $i = $i + 2) {
        if($num % $i == 0)
            return false;
    }
    $knownPrimes[]=$num;
    return true;
}

V1 (1 to 5,000,000): divisions=330 929 171; primes=348 513; time=21.243s
V2 (1 to 5,000,000): divisions=114 291 299; primes=348 513; time=10.357s

function primes($n){

    $prime = range(2 , $n);

    foreach ($prime as $key => $value) {

        for ($i=2; $i < $value ; $i++) { 

            if (is_int($value / $i)) {

                unset($prime[$key]);
                break;
            }
        }
    }

    foreach ($prime as $value) {
        echo $value.'<br>';
    }
}

primes(1000);

<?php 
$limit=100;

$i=1;


outer:while($i<=$limit){
    $j=2;
    while($j<$i){
        if($i%$j==0){
            $i++;
            goto outer;
        }
        $j++;
    }
    echo $i;
    echo "<br/>";
    $i++;
}


?>

$num = 25;
echo "Value Hardcored ".$num."<br>";

for($i=2; $i<$num; $i++)
 {
  if($num%$i==0)
  {
   $Loop = true;
   echo "This is Composite Number";
   break; 
  }
  $Loop = false; 
 }

 if($Loop == false)
 {
  echo "Prime Number";
 }

    <form method="post" action="">
    <input type="number" name="demo" placeholder="Enter Any Number">
    <button type="submit" name="aqeela" > Prime or composite </button>
    </form>
    <br>
    <?php
      if(isset($_POST['aqeela']))
       {
         $nu=$_POST['demo'];
         if($nu==2)
       {
          echo "The Only Even Prime Number";
       }
       else
       {
         for($i=2; $i<$nu; $i++)
       {
         if($nu%$i==0)
       {    
         echo "This is Composite Number";
         break;  
       }
       else
       {    
         if($i==($nu-1))
       { 
         echo "Prime number";
       }    
      }  
     }
    }
   }