web-dev-qa-db-fra.com

Une formule pour trouver des nombres premiers dans une boucle

J'ai besoin de trouver des nombres premiers avec boucle for ou loop

J'ai écrit ça mais c'est faux

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

Existe-t-il un moyen de diviser un nombre avec un tableau pour trouver le reste?

phparraysmathprimes
9
Mohammad Masoudian

Voici une petite fonction que j'ai trouvée: ( http://icdif.com/computing/2011/09/15/check-number-prime-number/ ) m'a semblé travailler pour moi!

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

Vous pouvez utiliser cette fonction PHP gmp_nextprime()

12
happy

Ceci est une implémentation de base:

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

Cela produira

 2 is Prime 
 3 is Prime 
 5 is Prime 
 7 is Prime 
 11 is Prime 
 13 is Prime 
 17 is Prime 
 19 is Prime

Complétez la logique étape par étape et analogie visuelle ici: ici

7
ngakak

Voici un one-liner que j'ai trouvé il y a un certain temps pour vérifier les primes. Il utilise des marques de pointage (mathématiques unaires) pour déterminer:

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

Vérifiez tous les nombres de manière séquentielle pour les nombres premiers:

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

Pour ne vérifier que les nombres premiers dans une plage de nombres, comme dans l'exemple fourni:

$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++;
}
7
Jeff Clayton

Sans fonction mathématique:

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

        return false;
    }

    return true;
}
3
ghaliano

Tout ce qui est sqrt () est faux ou toute valeur flottante est un nombre premier

2
Nikba

Je sais que c'est trop tard, mais j'ai trouvé que cette solution est plus élégante.

function isPrime($num)
{
    if ($num < 2) {
        return false;
    }
    for ($i = 2; $i <= $num / 2; $i++) {
        if ($num % $i == 0) {
            return false;
        }
    }

    return true;
}
2
Nik Latkin

Sieve_of_Eratosthenes est un algorithme simple et plus rapide pour trouver des nombres premiers.

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

Je pense que ceci est une routine assez efficace, qui liste tous les nombres premiers jusqu’à 1000.

Il teste chaque nombre ($ x) pour voir s’il contient des facteurs (autres que lui-même et 1, bien sûr).

Mathématiquement, il n'est pas nécessaire de tester tous les nombres inférieurs comme facteurs possibles, mais uniquement les nombres premiers inférieurs à la racine carrée de $ x. Cela est possible en stockant les nombres premiers tels qu'ils se trouvent dans un tableau (ce qui, je pense, est la stratégie à laquelle faisait référence le PO).

Dès que le premier facteur premier est trouvé, nous savons que $ x n'est pas premier, et aucun test supplémentaire de cette valeur de $ x n'est nécessaire et nous pouvons sortir de la boucle 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>";
}
1
WebSmithery
<?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;
        }
    }

?>

http://www.primenumbergenerator.com/

1
user7232036
<?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++;
}


?>
0
Rishi

Voici une autre approche efficace très simple mais silencieuse:

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);
0
Rmy5

Le meilleur moyen de vérifier si un nombre est premier est de voir s'il est divisible par un nombre premier le précédant. Pi (x) est celui que je vois partout ... Vous pouvez voir un peu plus d’informations sur Premier comptage sur wikipedia .

Donc, la façon la plus efficace que je puisse penser pour le moment est la suivante:

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

Ce qui n’est pas vraiment très efficace, eh bien, pas quand il s’agit de construire la liste des nombres premiers ... J'ai travaillé sur un meilleur moyen de construire la liste ici , bien que ce soit tout aussi facile et beaucoup plus efficace pour trouver une liste en ligne et l'utiliser.

L'utilisation de ce qui précède serait dans les lignes de:

$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";
}
0
Alexander Holman
$n = 7;

if ($n == 1) {
    echo 'Not a Prime or Composite No.';
}

$set = 0;
for ($index = 2; $index <= $n/2; $index++) {

    if ($n % $index === 0) {
        $set = 1;
        break;
    }
}

if ($set) {
    echo 'Composite';
} else {
    echo 'Prime';
}
0
Ashish
<?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);
?>
0
Ajaz Alam

Recherchez des nombres premiers compris entre 1 et 10000 en utilisant une fermeture dans array_filter ():

$start = 2;
$step = 10000;

$stop = $start + $step;
$candidates = range($start, $stop);    
for($num = 2; $num <= sqrt($stop); ++$num){                        
    $candidates = array_filter($candidates,
        function ($v) use (&$num){
             return ($v % $num) != 0 || $v == $num ;
        }
    );
}
print_r($candidates);

Edit: 1 n'est pas un nombre premier

0
user3396065

Je sais que cela arrive un peu tard, mais voici un programme simple pour vous aider à faire exactement ce que vous demandez ...

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

?>
0
Chigozie Orunta

je sais que cela arrive un peu tard, mais j'espère que cela aidera quelqu'un.

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

        }
    }

//Exemple prime_number_Finder (200);

0
lukkystunt

La version enchantée de @Farkie answer est spécialement conçue pour vérifier les nombres premiers dans les boucles.

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

Benchmark avec phpfiddle.org. V1 - Farkie answer, V2 - Version enchantée

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

REMARQUE! La fonctionisPrime_v2 est applicable UNIQUEMENT en cas de bouclage à partir de 3. Sinon, le tableau sauvegardé $ knownPrimes aura un historique insuffisant.

0
iXCray