Emirp Number Explained: How to Identify and Code Them

Wondering what an Emirp number is and how to identify one? This guide breaks down the definition of Emirp numbers, provides clear examples, and walks you through various code implementations to check if a given number fits the criteria. If you're into number theory and coding, this is for you!

What Exactly is an Emirp Number? (Definition & Examples)

An Emirp number is a prime number that, when its digits are reversed, results in a different prime number. Think of it as a prime that leads to another prime when flipped! It's "prime" spelled backward, highlighting its connection to prime numbers.

Crucially, palindromic primes (like 11, 101) are excluded from being Emirp numbers.
Example: 13 is an Emirp because 13 is prime, and its reverse, 31, is also prime.
Non-Example: 27 is not an Emirp because 27 is not a prime number.

How to Determine if a Number is Emirp: A Step-by-Step Approach

The process is straightforward:

Check for Primality: First, confirm that the original number is a prime number.
Reverse the Digits: If it's prime, reverse the digits of the original number.
Check Reversed Number for Primality: Check if the reversed number is also a prime number.
Confirm Not a Palindrome: Ensure the original number and its reverse are different.
Conclude: If both the original and reversed numbers are prime and not the same, you've found an Emirp number!

Code Implementation: Checking for Emirp Numbers in C++

#include <iostream>
#include <algorithm> // For std::reverse

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

int reverseNumber(int n) {
    std::string str_n = std::to_string(n);
    std::reverse(str_n.begin(), str_n.end());
    return std::stoi(str_n);
}

bool isEmirp(int n) {
    if (!isPrime(n)) return false;
    int reversed_n = reverseNumber(n);
    return (isPrime(reversed_n) && (n != reversed_n));
}

int main() {
    int num = 13;
    if (isEmirp(num)) {
        std::cout << num << " is an Emirp number." << std::endl;
    } else {
        std::cout << num << " is not an Emirp number." << std::endl;
    }
    return 0;
}

Code Implementation: Checking for Emirp Numbers in Java

class EmirpChecker {

    public static boolean isPrime(int n) {
        if (n <= 1) return false;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) return false;
        }
        return true;
    }

    public static int reverseNumber(int n) {
        return Integer.parseInt(new StringBuilder(String.valueOf(n)).reverse().toString());
    }

    public static boolean isEmirp(int n) {
        if (!isPrime(n)) return false;
        int reversedN = reverseNumber(n);
        return isPrime(reversedN) && (n != reversedN);
    }

    public static void main(String[] args) {
        int number = 13;
        if (isEmirp(number)) {
            System.out.println(number + " is an Emirp number.");
        } else {
            System.out.println(number + " is not an Emirp number.");
        }
    }
}

Code Implementation: Checking for Emirp Numbers in Python

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def reverse_number(n):
    return int(str(n)[::-1])

def is_emirp(n):
    if not is_prime(n):
        return False
    reversed_n = reverse_number(n)
    return is_prime(reversed_n) and (n != reversed_n)

number = 13
if is_emirp(number):
    print(f"{number} is an Emirp number.")
else:
    print(f"{number} is not an Emirp number.")

Code Implementation: Checking for Emirp Numbers in C#

using System;

public class EmirpChecker
{
    public static bool IsPrime(int n)
    {
        if (n <= 1) return false;
        for (int i = 2; i * i <= n; i++)
        {
            if (n % i == 0) return false;
        }
        return true;
    }

    public static int ReverseNumber(int n)
    {
        char[] numberChars = n.ToString().ToCharArray();
        Array.Reverse(numberChars);
        return int.Parse(new string(numberChars));
    }

    public static bool IsEmirp(int n)
    {
        if (!IsPrime(n)) return false;
        int reversedN = ReverseNumber(n);
        return IsPrime(reversedN) && (n != reversedN);
    }

    public static void Main(string[] args)
    {
        int number = 13;
        if (IsEmirp(number))
        {
            Console.WriteLine($"{number} is an Emirp number.");
        }
        else
        {
            Console.WriteLine($"{number} is not an Emirp number.");
        }
    }
}

Code Implementation: Checking for Emirp Numbers in Javascript

function isPrime(n) {
    if (n <= 1) return false;
    for (let i = 2; i * i <= n; i++) {
        if (n % i === 0) return false;
    }
    return true;
}

function reverseNumber(n) {
    return parseInt(n.toString().split('').reverse().join(''));
}

function isEmirp(n) {
    if (!isPrime(n)) return false;
    const reversedN = reverseNumber(n);
    return isPrime(reversedN) && (n !== reversedN);
}

let number = 13;
if (isEmirp(number)) {
    console.log(`${number} is an Emirp number.`);
} else {
    console.log(`${number} is not an Emirp number.`);
}

Code Implementation: Checking for Emirp Numbers in PHP

<?php

function isPrime(int $n): bool {
    if ($n <= 1) return false;
    for ($i = 2; $i * $i <= $n; $i++) {
        if ($n % $i == 0) return false;
    }
    return true;
}

function reverseNumber(int $n): int {
    return intval(strrev(strval($n)));
}

function isEmirp(int $n): bool {
    if (!isPrime($n)) return false;
    $reversedN = reverseNumber($n);
    return isPrime($reversedN) && ($n != $reversedN);
}

$number = 13;
if (isEmirp($number)) {
    echo "$number is an Emirp number.\n";
} else {
    echo "$number is not an Emirp number.\n";
}

?>

Efficiency Considerations

Primality Test: The efficiency of the isPrime function is critical. The provided implementations iterate up to the square root of the number, which provides a good balance between simplicity and performance.
Reversal: Reversing the number typically involves converting it to a string, reversing the string, and then converting it back to an integer. This is generally efficient for practical purposes.

Why are Emirp Numbers Interesting?

Emirp numbers offer an intriguing glimpse into number theory, combining the properties of prime numbers with the concept of digit reversal. They illustrate that even within well-defined mathematical concepts like prime numbers, there are still interesting patterns and relationships to explore. They also make fun coding challenges!

Emirp Number Explained: How to Identify and Code Them

What Exactly is an Emirp Number? (Definition & Examples)

Crucially, palindromic primes (like 11, 101) are excluded from being Emirp numbers.

Example: 13 is an Emirp because 13 is prime, and its reverse, 31, is also prime.

Non-Example: 27 is not an Emirp because 27 is not a prime number.

How to Determine if a Number is Emirp: A Step-by-Step Approach

The process is straightforward:

Check for Primality: First, confirm that the original number is a prime number.

Reverse the Digits: If it's prime, reverse the digits of the original number.

Check Reversed Number for Primality: Check if the reversed number is also a prime number.

Confirm Not a Palindrome: Ensure the original number and its reverse are different.

Conclude: If both the original and reversed numbers are prime and not the same, you've found an Emirp number!