Comment vérifier si un nombre est un nombre Emirp ? Un guide complet

Vous êtes-vous déjà demandé ce qu'est un nombre Emirp et comment en identifier un ? Dans ce guide complet, nous allons explorer le concept de nombres Emirp et fournir des méthodes simples pour déterminer si un nombre donné correspond à cette classification spéciale. Préparez-vous à plonger dans le monde fascinant des nombres premiers inversés !

Qu'est-ce qu'un nombre Emirp et pourquoi devriez-vous vous en soucier ?

Un nombre Emirp (anagramme de premier) est un nombre premier qui, lorsque ses chiffres décimaux sont inversés, donne un nombre premier différent. Cette définition exclut les nombres premiers palindromiques (ceux qui se lisent de la même façon à l'endroit et à l'envers).

Pourquoi s'en soucier ? Les nombres Emirp mettent en évidence les relations intéressantes et les modèles cachés au sein des nombres premiers, offrant un aperçu unique de la théorie des nombres. De plus, la compréhension des nombres Emirp peut améliorer vos compétences en résolution de problèmes et votre raisonnement logique.

Vérifiez facilement si un nombre est Emirp en quelques étapes

Voici une approche simple pour vérifier si un nombre donné est un nombre Emirp :

1. Vérifiez le caractère premier : Déterminez si le nombre initial est un nombre premier. Si ce n'est pas le cas, ce n'est pas un nombre Emirp.
2. Inversez le nombre : Inversez l'ordre des chiffres du nombre d'origine.
3. Vérifiez le caractère premier inversé : Déterminez si le nombre inversé est également un nombre premier.
4. Conclusion : Si le nombre d'origine et le nombre inversé sont tous deux des nombres premiers et qu'ils ne sont pas égaux, alors le nombre d'origine est un nombre Emirp.

Exemple :

Considérons le nombre 13.

• 13 est un nombre premier.
• L'inverse de 13 est 31.
• 31 est également un nombre premier.

Par conséquent, 13 est un nombre Emirp.

Deux approches puissantes pour identifier les nombres Emirp

Explorons deux approches pour identifier les nombres Emirp, avec des exemples de code dans divers langages de programmation.

Approche 1 : méthode directe

Cette approche consiste à implémenter directement les étapes décrites ci-dessus.

1. Définissez une fonction isPrime(n) qui vérifie si un nombre n est premier.
2. Définissez une fonction isEmirp(n) qui vérifie si un nombre n est Emirp en :
   • Vérifiant que n est premier à l'aide de isPrime(n).
   • Inversant n.
   • Vérifiant que le nombre inversé est premier à l'aide de isPrime().

Exemple de code (C++) :

#include <iostream>
using namespace std;

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

bool isEmirp(int n) {
    if (isPrime(n) == false)
        return false;
    int rev = 0;
    while (n != 0) {
        int d = n % 10;
        rev = rev * 10 + d;
        n /= 10;
    }
    return isPrime(rev);
}

int main() {
    int n = 13;
    if (isEmirp(n) == true)
        cout << "Yes";
    else
        cout << "No";
    return 0;
}

Exemple de code (Java) :

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

    public static boolean isEmirp(int n) {
        if (isPrime(n) == false)
            return false;
        int rev = 0;
        while (n != 0) {
            int d = n % 10;
            rev = rev * 10 + d;
            n /= 10;
        }
        return isPrime(rev);
    }

    public static void main(String args[]) {
        int n = 13;
        if (isEmirp(n) == true)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

Exemple de code (Python) :

def isPrime(n):
    if n <= 1:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

def isEmirp(n):
    n = int(n)
    if isPrime(n) == False:
        return False
    rev = 0
    while n != 0:
        d = n % 10
        rev = rev * 10 + d
        n = int(n / 10)
    return isPrime(rev)

n = 13
if isEmirp(n):
    print("Yes")
else:
    print("No")

Complexité temporelle : O(n)

Espace auxiliaire : O(1)

Approche 2 : Utilisation de la récursion

Cette approche utilise la récursion pour vérifier le caractère premier et inverser le nombre.

1. Définissez une fonction is_prime(num) pour vérifier si un nombre est premier.
2. Définissez une fonction reverse_number(num) pour inverser un nombre donné.
3. Définissez une fonction is_emirp(num) qui :
   • Vérifie si le nombre donné est premier à l'aide de la fonction is_prime().
   • Si ce n'est pas le nombre premier, renvoie “Not Emirp”.
   • Inverse le nombre donné à l'aide de la fonction reverse_number().
   • Vérifie si le nombre inversé est premier à l'aide de la fonction is_prime().
   • Si les nombres d'origine et inversé sont premiers, renvoie “Emirp”, sinon renvoie “Not Emirp”.

Exemple de code (C++) :

#include <iostream>
#include <cmath>
#include <string>

using namespace std;

bool is_prime(int num) {
    if (num < 2) {
        return false;
    }
    for (int i = 2; i <= sqrt(num); i++) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

int reverse_number(int num) {
    string str_num = to_string(num);
    string rev_str_num = "";
    for (int i = str_num.length() - 1; i >= 0; i--) {
        rev_str_num += str_num[i];
    }
    return stoi(rev_str_num);
}

string is_emirp(int num) {
    if (!is_prime(num)) {
        return "Not Emirp";
    }
    int rev_num = reverse_number(num);
    if (is_prime(rev_num) && num != rev_num) {
        return "Emirp";
    } else {
        return "Not Emirp";
    }
}

int main() {
    int num = 27;
    cout << is_emirp(num) << endl;
    return 0;
}

Exemple de code (Java) :

import java.lang.Math;

public class Emirp {
    public static boolean isPrime(int num) {
        if (num < 2) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static int reverseNumber(int num) {
        String strNum = Integer.toString(num);
        String revStrNum = "";
        for (int i = strNum.length() - 1; i >= 0; i--) {
            revStrNum += strNum.charAt(i);
        }
        return Integer.parseInt(revStrNum);
    }

    public static String isEmirp(int num) {
        if (!isPrime(num)) {
            return "Not Emirp";
        }
        int revNum = reverseNumber(num);
        if (isPrime(revNum) && num != revNum) {
            return "Emirp";
        } else {
            return "Not Emirp";
        }
    }

    public static void main(String[] args) {
        int num = 27;
        System.out.println(isEmirp(num));
    }
}

Exemple de code (Python) :

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

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

def is_emirp(num):
    if not is_prime(num):
        return "Not Emirp"
    rev_num = reverse_number(num)
    if is_prime(rev_num) and num != rev_num:
        return "Emirp"
    else:
        return "Not Emirp"

num = 27
print(is_emirp(num))

Complexité temporelle : O(sqrt(n))

Espace auxiliaire : O(log n)

Profitez de quelques enseignements clés sur les nombres Emirp

Voici quelques éléments clés à retenir concernant les nombres Emirp :

• Un nombre Emirp est un nombre premier qui donne un nombre premier différent lorsqu'il est inversé.
• Les nombres premiers palindromiques ne sont pas des nombres Emirp.
• Pour vérifier si un nombre est Emirp, vérifiez si le nombre et son inverse sont premiers.
• Il existe différentes approches pour identifier les nombres Emirp, notamment la méthode directe et la récursion.

Conclusion

Félicitations ! Vous avez maintenant une solide compréhension de ce que sont les nombres Emirp et comment les identifier. Que vous soyez un passionné de mathématiques ou que vous souhaitiez simplement perfectionner vos compétences en résolution de problèmes, l'exploration des nombres Emirp offre un aperçu fascinant de la théorie des nombres. Alors, allez-y, mettez vos nouvelles connaissances à l'épreuve et découvrez le monde fascinant des nombres premiers inversés !