Checking Whether N Is A Dihedral Prime Number In C++

Introduction

A Dihedral Prime Number is an extraordinary prime number that remains prime even after undergoing a dihedral transformation, which may involve rotation and reflection based on dihedral symmetry, often resembling a digital clock-like appearance.

Numbers such as 11, 13, and 17 are prime examples that will remain prime regardless of being rotated or reflected on a seven-segment digital display.

In this tutorial, we will discuss dihedral prime numbers and demonstrate how to write a C++ program to determine if a given number N is a dihedral prime.

Understanding Dihedral Prime Numbers

To determine whether a number qualifies as a Dihedral Prime, two conditions must be met:

1. The number must be a prime number itself.
2. All potential transformations of the number through reflection and rotation must also be prime numbers.

Important Things to Remember:

• ✅ The numbers 0, 1, and 8 remain the same even after rotation.
• ✅ The digits 6 and 9 are their reflections.
• ✅ The digits 2, 3, 4, 5, and 7 do not possess any valid rotation version and therefore are not dihedral transformable.

Therefore, the numeral must not contain the numbers {2, 3, 4, 5, 7} and should be a prime number in each mirrored iteration for it to qualify as a dihedral prime.

Additionally, the concept of dihedral prime numbers holds intriguing implications in the field of cryptography, where their unique characteristics can be employed in ensuring the security of numerical systems. This prompts an exploration into the role of number manipulations in shaping various mathematical and computational attributes.

Steps to Check for a Dihedral Prime:

• ✅ Check if the number is prime.
• ✅ Validate whether all digits allow rotation/reflection.
• ✅ Transform the number based on valid rotations and reflections.
• ✅ Check if each transformed number is prime.
• ✅ If all conditions are met, the number is a dihedral prime.

C++ Implementation:

Here is a meticulously organized C++ code to ascertain if a specified number N qualifies as a Dihedral Prime Number:

#include <iostream>
#include <cmath>
#include <unordered_map>
#include <algorithm>

using namespace std;

// Function to check if a number is prime
bool isPrime(int num) {
    if (num < 2) return false;
    for (int i = 2; i <= sqrt(num); i++) {
        if (num % i == 0) return false;
    }
    return true;
}

// Function to check if a number can be rotated and still be valid
bool isDihedralValid(string num) {
    string allowedDigits = "01689";
    for (char digit : num) {
        if (allowedDigits.find(digit) == string::npos) return false;
    }
    return true;
}

// Function to get the rotated reflection of a number
string getRotatedReflection(string num) {
    unordered_map<char, char> flipMap = {
        {'0', '0'}, {'1', '1'}, {'6', '9'}, {'8', '8'}, {'9', '6'}
    };
    reverse(num.begin(), num.end());
    for (char &digit : num) {
        digit = flipMap[digit];
    }
    return num;
}

// Function to check if a number is a dihedral prime
bool isDihedralPrime(int N) {
    if (!isPrime(N)) return false;
    
    string numStr = to_string(N);
    if (!isDihedralValid(numStr)) return false;
    
    string rotatedStr = getRotatedReflection(numStr);
    int rotatedNum = stoi(rotatedStr);
    
    return isPrime(rotatedNum);
}

// Driver function
int main() {
    int N;
    cout << "Enter a number: ";
    cin >> N;
    
    if (isDihedralPrime(N)) {
        cout << N << " is a Dihedral Prime Number." << endl;
    } else {
        cout << N << " is NOT a Dihedral Prime Number." << endl;
    }
    
    return 0;
}

Output:

Explanation of the Code:

• ✅ isPrime(int num): It checks if a given number is prime.
• ✅ isDihedralValid(string num): It ensures that all digits in the number allow rotation.
• ✅ getRotatedReflection(string num): It generates the rotated version of the number.
• ✅ isDihedralPrime(int N): It combines all the checks to determine if N is a dihedral prime.
• ✅ Main function : It accepts input from the user and outputs the result.

Example Runs

Input 1:

Enter a number: 11

Output:

11 is a Dihedral Prime Number.

Input 2:

Enter a number: 23

Output:

23 is NOT a Dihedral Prime Number.

Complexity Analysis:

• ✅ Prime Check (isPrime): O(√N)
• ✅ String Manipulations (Reversals & Mapping): O(K) (K = number of digits)
• ✅ Overall Complexity: O(√N + K) (Efficient for moderate values of N)

Edge Cases Considered:

• ✅ Numbers with invalid digits (e.g., 2345, 773)
• ✅ Single-digit numbers (e.g., 1, 6, 9)
• ✅ Numbers that remain prime after rotation
• ✅ Large prime numbers for performance testing

Conclusion:

In summary, dihedral prime numbers form a fascinating group of primes that retain their prime characteristics when subjected to rotation and reflection operations. By leveraging mathematical attributes and string manipulations, we can develop a proficient C++ application to verify dihedral prime numbers.

The topic pertains to cryptography, numerical theory, and digital conversions, making it a promising area for further investigation.

Key Takeaways:

Important key takeaways of Dihedral Prime Numbers are as follows:

• ✅ A Dihedral Prime Number is still prime after rotation/reflection.
• ✅ Numbers {2, 3, 4, 5, 7} eliminate a number as a dihedral transformable one.
• ✅ The solution correctly checks prime conditions and transformations.
• ✅ The C++ program implemented presents a designed, efficient approach.