diff --git a/DIRECTORY.md b/DIRECTORY.md index 265d1aeeb893..64c756426218 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -1021,6 +1021,7 @@ * [MedianOfMatrixtest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/MedianOfMatrixtest.java) * [MedianOfRunningArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/MedianOfRunningArrayTest.java) * [MirrorOfMatrixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/MirrorOfMatrixTest.java) + * [PalindromePrimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/PalindromePrimeTest.java) * [PalindromeSinglyLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/PalindromeSinglyLinkedListTest.java) * [RangeInSortedArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/RangeInSortedArrayTest.java) * [ThreeSumProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/ThreeSumProblemTest.java) diff --git a/src/main/java/com/thealgorithms/misc/PalindromePrime.java b/src/main/java/com/thealgorithms/misc/PalindromePrime.java index e1cbf3ff839a..d7b74fa6e277 100644 --- a/src/main/java/com/thealgorithms/misc/PalindromePrime.java +++ b/src/main/java/com/thealgorithms/misc/PalindromePrime.java @@ -1,51 +1,114 @@ package com.thealgorithms.misc; -import java.util.Scanner; - +/** + * Utility class for finding palindromic prime numbers. + * + * Palindromic primes are prime numbers that remain the same when their digits are reversed. + * + * For more information, refer to the + * Palindromic prime Wikipedia page. + * + * Example usage: + * 
+ * int[] palindromicPrimes = PalindromePrime.findPalindromicPrimes(5);
+ * System.out.println(Arrays.toString(palindromicPrimes)); // Output: [2, 3, 5, 7, 11]
+ *
+ * int nthPalindromicPrime = PalindromePrime.findNthPalindromicPrime(5);
+ * System.out.println(nthPalindromicPrime); // Output: 11
+ *
+ */ public final class PalindromePrime { - private PalindromePrime() { - } - public static void main(String[] args) { // Main function - Scanner in = new Scanner(System.in); - System.out.println("Enter the quantity of First Palindromic Primes you want"); - int n = in.nextInt(); // Input of how many first palindromic prime we want - functioning(n); // calling function - functioning - in.close(); + private PalindromePrime() { + // Private constructor to prevent instantiation } - public static boolean prime(int num) { // checking if number is prime or not - for (int divisor = 3; divisor <= Math.sqrt(num); divisor += 2) { - if (num % divisor == 0) { - return false; // false if not prime + /** + * Finds the first n palindromic prime numbers. + * + * @param n The number of palindromic primes to find + * @return An array containing the first n palindromic prime numbers + */ + public static int[] findPalindromicPrimes(int n) { + if (n == 0) { + return new int[0]; + } + int[] result = new int[n]; + result[0] = 2; // The first palindromic prime + int count = 1; + int num = 3; + while (count < n) { + if (num == reverse(num) && isPrime(num)) { // number is prime and its reverse is the same + result[count] = num; + count++; // counts check when to terminate while loop } + num += 2; // increase iterator value by two } - return true; // True if prime + return result; } - public static int reverse(int n) { // Returns the reverse of the number - int reverse = 0; - while (n != 0) { - reverse *= 10; - reverse += n % 10; - n /= 10; - } - return reverse; - } - - public static void functioning(int y) { - if (y == 0) { - return; + /** + * Finds the nth palindromic prime number. + * + * @param n The position of the palindromic prime to find + * @return The nth palindromic prime number + */ + public static int findNthPalindromicPrime(int n) { + if (n <= 0) { + throw new IllegalArgumentException("n must be greater than 0"); + } + if (n == 1) { + return 2; // The first palindromic prime } - System.out.print(2 + "\n"); // print the first Palindromic Prime int count = 1; int num = 3; - while (count < y) { - if (num == reverse(num) && prime(num)) { // number is prime and it's reverse is same + while (count < n) { + if (num == reverse(num) && isPrime(num)) { // number is prime and its reverse is the same count++; // counts check when to terminate while loop - System.out.print(num + "\n"); // print the Palindromic Prime } - num += 2; // inrease iterator value by two + if (count < n) { + num += 2; // increase iterator value by two + } + } + return num; + } + + /** + * Checks if a number is prime. + * + * @param num The number to check + * @return true if the number is prime, false otherwise + */ + private static boolean isPrime(int num) { + if (num < 2) { + return false; + } + if (num == 2) { + return true; + } + if (num % 2 == 0) { + return false; + } + for (int divisor = 3; divisor <= Math.sqrt(num); divisor += 2) { + if (num % divisor == 0) { + return false; // false if not prime + } + } + return true; // true if prime + } + + /** + * Reverses the digits of a number. + * + * @param num The number to reverse + * @return The reversed number + */ + private static int reverse(int num) { + int reversed = 0; + while (num != 0) { + reversed = reversed * 10 + num % 10; + num /= 10; } + return reversed; } } diff --git a/src/test/java/com/thealgorithms/misc/PalindromePrimeTest.java b/src/test/java/com/thealgorithms/misc/PalindromePrimeTest.java new file mode 100644 index 000000000000..747634fb775b --- /dev/null +++ b/src/test/java/com/thealgorithms/misc/PalindromePrimeTest.java @@ -0,0 +1,83 @@ +package com.thealgorithms.misc; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +/** + * Unit tests for the PalindromePrime class. + */ +public class PalindromePrimeTest { + + /** + * Test the findPalindromicPrimes method with a positive number. + */ + @Test + public void testFindPalindromicPrimesPositive() { + int[] result = PalindromePrime.findPalindromicPrimes(5); + assertArrayEquals(new int[] {2, 3, 5, 7, 11}, result); + } + + /** + * Test the findPalindromicPrimes method with zero. + */ + @Test + public void testFindPalindromicPrimesZero() { + int[] result = PalindromePrime.findPalindromicPrimes(0); + assertArrayEquals(new int[] {}, result); + } + + /** + * Test the findNthPalindromicPrime method with a positive number. + */ + @Test + public void testFindNthPalindromicPrimePositive() { + int result = PalindromePrime.findNthPalindromicPrime(5); + assertEquals(11, result); + } + + /** + * Test the findNthPalindromicPrime method with one. + */ + @Test + public void testFindNthPalindromicPrimeOne() { + int result = PalindromePrime.findNthPalindromicPrime(1); + assertEquals(2, result); + } + + /** + * Test the findNthPalindromicPrime method with zero. + */ + @Test + public void testFindNthPalindromicPrimeZero() { + assertThrows(IllegalArgumentException.class, () -> PalindromePrime.findNthPalindromicPrime(0)); + } + + /** + * Test the findNthPalindromicPrime method with a negative number. + */ + @Test + public void testFindNthPalindromicPrimeNegative() { + assertThrows(IllegalArgumentException.class, () -> PalindromePrime.findNthPalindromicPrime(-1)); + } + + /** + * Test the findPalindromicPrimes method with a large number. + */ + @Test + public void testFindPalindromicPrimesLarge() { + int[] result = PalindromePrime.findPalindromicPrimes(10); + assertArrayEquals(new int[] {2, 3, 5, 7, 11, 101, 131, 151, 181, 191}, result); + } + + /** + * Test the findNthPalindromicPrime method with a large number. + */ + @Test + public void testFindNthPalindromicPrimeLarge() { + int result = PalindromePrime.findNthPalindromicPrime(10); + assertEquals(191, result); + } +}