How to find backward primes within a range of integers?

Question

I'm trying to solve a backward prime question.

Following is the question:

Find all Backwards Read Primes between two positive given numbers (both inclusive), the second one being greater than the first one. The resulting array or the resulting string will be ordered following the natural order of the prime numbers.

Example

backwardsPrime(2, 100) => [13, 17, 31, 37, 71, 73, 79, 97] 
backwardsPrime(9900, 10000) => [9923, 9931, 9941, 9967]

I tried doing something like this:

public function backwardPrime()
{
    $start = 7000;
    $stop = 7100;

    $ans = [];

    while($start <= $stop)
    {
        if($start > 10)
        {
            if($start !== $this->reverse($start))
            {
                if($this->isPrime($start) && $this->isPrime($this->reverse($start)))
                {
                    array_push($ans, $start);
                }
            }
        }
        $start++;
    }
    return $ans;
}

public function reverse($num)
{
    $reverse = 0;
    while($num > 0)
    {
        $reverse = $reverse * 10;
        $reverse = $reverse + $num%10;
        $num = (int)($num/10);
    }
    return $reverse;
}

public function isPrime($num)
{
    if($num == 1 || $num == 2 || $num == 3)
        return true;
    elseif ($num%2 == 0 || $num%3 == 0)
        return false;
    else
    {
        $i=5;
        while($i<=$num/2)
        {
            if($num%$i===0)
            {
                return false;
            }
            $i++;
        }
    }
    return true;
}

I'm able to get the appropriate answer but while doing the same in single function I'm not able to get it:

public function backwardPrimes()
{
    $start = 7000;
    $stop = 7100;
    $ans = [];
    while($start <= $stop)
    {
        $isStartPrime = true;
        $isReversePrime = true;
        if($start > 10)
        {
            $reverse = 0;
            $num = $start;
            while($num > 0)
            {
                $reverse = $reverse * 10;
                $reverse = $reverse + $num%10;
                $num = (int)($num/10);
            }
            if($start !== $reverse)
            {
                if($start%2 != 0 && $start%3 != 0)
                {
                    $i =5;
                    while($i<=$start/2)
                    {
                        if($start%$i === 0)
                        {
                            $isStartPrime = false;
                            break;
                        }
                        $i++;
                    }
                }
                if($reverse%2 != 0 && $reverse%3 != 0)
                {
                    $i =5;
                    while($i<=$reverse/2)
                    {
                        if($reverse%$i === 0)
                        {
                            $isReversePrime = false;
                            break;
                        }
                        $i++;
                    }
                }
                if($isStartPrime && $isReversePrime)
                {
                    array_push($ans, $start);
                }
            }
        }
        $start++;
    }
    return $ans;
}

I don't know where I'm having mistake, guide me.

Thanks.

Answer 1

An emirp ("prime" spelled backwards) is a prime whose (base 10) reversal is also prime, but which is not a palindromic prime. in other words Backwards Read Primes are primes that when read backwards in base 10 (from right to left) are a different prime. (This rules out primes which are palindromes.)

try this short solution in which I use two helper function reverse and isPrime :

1. isPrime: Thanks to @Jeff Clayton for his method to test prime numbers, for more information click the link below https://stackoverflow.com/a/24769490/4369087
2. reverse: that use the php function [strrev()][1], this method take a string a reverse it, we'll use this trick to reverse a number by converting it to a string reverse it and converting back to an integer.
3. backwardsPrime: this last function's job is itterating over a range of numbers from $min value to $max value and test if the number if a prime number and it's reverse is a prime number as well and it's not a palindrome number if all of those conditions are true then we addit to the result array.

implementation

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

function reverse($n) 
{
    return (int) strrev((string) $n);
}

function backwardsPrime($min, $max)
{
    $result = [];

    foreach(range($min, $max) as $number) {
        $reverse = reverse($number);
        if($reverse !== $number  && isPrime($number) && isPrime($reverse)) {    
           $result[] = $number;
        }
    }

    return $result;
}

echo "<pre>";          
print_r(backwardsPrime(2, 100));
print_r(backwardsPrime(9900, 10000));

output :

Array
(
    [0] => 13
    [1] => 17
    [2] => 31
    [3] => 37
    [4] => 71
    [5] => 73
    [6] => 79
    [7] => 97
)



   Array
(
    [0] => 9923
    [1] => 9931
    [2] => 9941
    [3] => 9967
)

you can even optimize the backwardsPrime function like this :

function backwardsPrime($min, $max)
{
    $result = [];

    foreach(range($min, $max) as $number) {
        $reverse = reverse($number);
        if($reverse !== $number && !in_array($number, $result) && isPrime($number) && isPrime($reverse)) {  
           $result[] = $number;
        }
    }

    return $result;
}