Improvement: Removed main function and increased usability of PalindromePrime utility class

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)

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
+ * <a href="https://en.wikipedia.org/wiki/Palindromic_prime">Palindromic prime</a> Wikipedia page.
+ *
+ * <b>Example usage:</b>
+ * <pre>
+ * 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
+ * </pre>
+ */
 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;
     }
 }

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);
+    }
+}