it-swarm.com.de

Eine Formel, um Primzahlen in einer Schleife zu finden

Ich muss Primzahlen mit for-Schleife oder while-Schleife finden

Ich habe das geschrieben, aber das ist falsch

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

Gibt es eine Möglichkeit, eine Zahl mit einem Array zu teilen, um die restlichen zu finden?

9

Hier ist eine kleine Funktion, die ich gefunden habe: ( http://icdif.com/computing/2011/09/15/check-number-prime-number/ ) Scheint für mich zu arbeiten!

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

Sie können diese PHP -Funktion verwenden gmp_nextprime()

12
happy

Dies ist eine grundlegende Implementierung:

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

Dies wird ausgegeben

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

Komplette Logik Schritt für Schritt und visuelle Analogie hier: Hier

7
ngakak

Hier ist ein One-Liner, den ich vor einiger Zeit gefunden habe, um nach Primzahlen zu suchen. Es verwendet Zählmarken (unäre Mathematik), um Folgendes zu bestimmen:

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

Überprüfen Sie alle Zahlen nacheinander auf Primzahlen:

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

So prüfen Sie nur einen Zahlenbereich für Primzahlen wie im angegebenen Beispiel:

$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

Ohne mathematische Funktion:

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

        return false;
    }

    return true;
}
3
ghaliano

Jeder, dessen sqrt () falsch ist, oder jeder Float-Wert ist eine Primzahl

2
Nikba

Ich weiß, dass es zu spät ist, aber ich habe festgestellt, dass diese Lösung eleganter ist.

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

Unter Programme ist einfach mit zwei for-Schleifen und ignoriert 1 und Selbstwerte in Iteration. Es wird die Primzahlen drucken,

function get_primenumbers($length) {
    //Ignore 1
    for($i = 2; $i <= $length; $i++){
        $prime = true;
        for($j = 2; $j <= $i; $j++){
            //Ignore same number
            if(($i != $j) && ($i % $j == 0)){
                $prime = false;
                break;
            }
        }

        if(!$prime){
            echo "$i is not prime <br />";
        }else{
            echo "$i is prime <br />";
        }
    }
}
1
Naveen

Sieve_of_Eratosthenes ist ein einfacher und schneller Algorithmus, um Primzahlen zu finden.

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

Ich glaube, das ist eine ziemlich effiziente Routine, die alle Primzahlen bis zu 1000 auflistet.

Es testet jede Zahl ($ x), um zu sehen, ob sie irgendwelche Faktoren hat (außer sich und 1 natürlich).

Mathematisch ist es nicht notwendig, alle niedrigeren Zahlen als mögliche Faktoren zu testen, nur niedrigere Primzahlen bis zur Quadratwurzel von $ x. Dies wird ermöglicht, indem Primzahlen gespeichert werden, wie sie in einem Array gefunden werden (was meiner Meinung nach die Strategie ist, auf die sich das OP bezogen hat).

Sobald der erste Primfaktor gefunden wird, wissen wir, dass $ x keine Primzahl ist. Daher ist keine weitere Prüfung des Werts von $ x erforderlich, und wir können die Foreach-Schleife durchbrechen.

$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

Hier ist ein weiterer sehr einfacher, aber leiser Ansatz:

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

Der beste Weg, um zu überprüfen, ob eine Zahl eine Primzahl ist, besteht darin, zu sehen, ob sie durch eine Primzahl vor der Zahl teilbar ist. Pi (x) ist der, den ich immer wieder sehe ... Weitere Informationen zu Prime Counting finden Sie auf wikipedia .

Der effizienteste Weg, den ich im Moment vorstellen kann, ist wie folgt:

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

Was nicht wirklich sehr effizient ist, gut, nicht wenn es darum geht, die Liste der Primzahlen zu erstellen ... Ich habe an einem besseren Weg gearbeitet, die Liste hier zu erstellen, obwohl es genauso einfach wäre und weitaus effizienter, eine Liste online zu finden und diese zu verwenden.

Die Verwendung der oben genannten wäre in der Richtung von:

$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
$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

Finden Sie Primzahlen zwischen 1 und 10000, indem Sie in array_filter () eine Schließung verwenden:

$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 ist keine Primzahl

0
user3396065

Ich weiß, das kommt etwas spät, aber hier ist ein einfaches Programm, das Ihnen hilft, genau das zu tun, wonach Sie fragen ...

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

ich weiß, das kommt ziemlich spät, aber ich hoffe, es hilft jemandem.

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

        }
    }

// Beispiel prime_number_Finder (200);

0
lukkystunt

Die verbesserte Version von @Farkie wurde speziell für das Prüfen von Primzahlen in Schleifen entwickelt.

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 mit phpfiddle.org. V1 - Antwort von Farkie, V2 - Verbesserte Version

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

HINWEIS! Die FunktionisPrime_v2 ist NUR bei einer Schleife von 3 anwendbar. Andernfalls hat das gespeicherte $ knownPrimes-Array einen unzureichenden Verlauf.

0
iXCray