1class Solution {
2    /**
3     * Determines whether the given number is a "complete prime".
4     * A number qualifies only if:
5     *   1. Every prefix (read left to right) is prime.
6     *   2. Every suffix (read left to right within the number) is prime.
7     *
8     * @param num the number to validate
9     * @return true if all prefixes and suffixes are prime, false otherwise
10     */
11    public boolean completePrime(int num) {
12        // Convert the number into its individual digit characters.
13        char[] digits = String.valueOf(num).toCharArray();
14
15        // ---- Check every prefix (built from left to right). ----
16        int prefixValue = 0;
17        for (int i = 0; i < digits.length; i++) {
18            // Append the current digit to the growing prefix.
19            prefixValue = prefixValue * 10 + (digits[i] - '0');
20            // If any prefix is not prime, the number fails immediately.
21            if (!isPrime(prefixValue)) {
22                return false;
23            }
24        }
25
26        // ---- Check every suffix (built from right to left). ----
27        int suffixValue = 0;
28        int placeValue = 1; // Tracks the positional weight (1, 10, 100, ...).
29        for (int i = digits.length - 1; i >= 0; i--) {
30            // Add the current digit at its correct positional weight.
31            suffixValue = placeValue * (digits[i] - '0') + suffixValue;
32            placeValue *= 10;
33            // If any suffix is not prime, the number fails immediately.
34            if (!isPrime(suffixValue)) {
35                return false;
36            }
37        }
38
39        // All prefixes and suffixes are prime.
40        return true;
41    }
42
43    /**
44     * Checks whether a given value is a prime number.
45     *
46     * @param value the value to test
47     * @return true if value is prime, false otherwise
48     */
49    private boolean isPrime(int value) {
50        // Numbers less than 2 are not prime by definition.
51        if (value < 2) {
52            return false;
53        }
54        // Test divisibility up to the square root of value.
55        for (int i = 2; i * i <= value; i++) {
56            if (value % i == 0) {
57                return false;
58            }
59        }
60        return true;
61    }
62}
63

1class Solution {
2public:
3    bool completePrime(int num) {
4        // Helper lambda to check whether a given value is a prime number.
5        auto isPrime = [&](int value) {
6            // Any number less than 2 is not prime.
7            if (value < 2) {
8                return false;
9            }
10            // Trial division up to sqrt(value) to detect factors.
11            for (int i = 2; i * i <= value; ++i) {
12                if (value % i == 0) {
13                    return false;
14                }
15            }
16            return true;
17        };
18
19        // Convert the number to its string representation for digit-wise processing.
20        string digits = to_string(num);
21
22        // Check every prefix (left-to-right) of the number for primality.
23        int prefix = 0;
24        for (char c : digits) {
25            // Append the current digit to build the next prefix value.
26            prefix = prefix * 10 + (c - '0');
27            if (!isPrime(prefix)) {
28                return false;
29            }
30        }
31
32        // Check every suffix (right-to-left) of the number for primality.
33        int suffix = 0;
34        int placeValue = 1;
35        for (int i = (int) digits.size() - 1; i >= 0; --i) {
36            // Prepend the current digit using the running place value.
37            suffix = placeValue * (digits[i] - '0') + suffix;
38            placeValue *= 10;
39            if (!isPrime(suffix)) {
40                return false;
41            }
42        }
43
44        // All prefixes and suffixes are prime, so the number is a "complete prime".
45        return true;
46    }
47};
48

1/**
2 * Determines whether a number is a "complete prime", meaning every prefix
3 * (read left-to-right) and every suffix (read right-to-left) of the number is prime.
4 *
5 * @param num - The number to evaluate.
6 * @returns True if all prefixes and suffixes are prime, otherwise false.
7 */
8function completePrime(num: number): boolean {
9    /**
10     * Checks whether a given value is a prime number.
11     *
12     * @param value - The candidate number to test for primality.
13     * @returns True if the value is prime, otherwise false.
14     */
15    const isPrime = (value: number): boolean => {
16        // Any value below 2 cannot be prime.
17        if (value < 2) {
18            return false;
19        }
20        // Trial division up to the square root of the value.
21        for (let divisor = 2; divisor * divisor <= value; divisor++) {
22            if (value % divisor === 0) {
23                return false;
24            }
25        }
26        return true;
27    };
28
29    // Convert the number to its string representation to iterate over digits.
30    const digits = String(num);
31
32    // ----- Check every prefix (left to right) -----
33    let prefixValue = 0;
34    for (let i = 0; i < digits.length; i++) {
35        // Append the current digit to the accumulated prefix value.
36        // (charCodeAt - 48) converts the character to its numeric value.
37        prefixValue = prefixValue * 10 + (digits.charCodeAt(i) - 48);
38        if (!isPrime(prefixValue)) {
39            return false;
40        }
41    }
42
43    // ----- Check every suffix (right to left) -----
44    let suffixValue = 0;
45    let placeValue = 1; // Tracks the current digit's positional weight (1, 10, 100, ...).
46    for (let i = digits.length - 1; i >= 0; i--) {
47        // Add the current digit, scaled by its place value, to the suffix.
48        suffixValue = placeValue * (digits.charCodeAt(i) - 48) + suffixValue;
49        placeValue *= 10;
50        if (!isPrime(suffixValue)) {
51            return false;
52        }
53    }
54
55    // All prefixes and suffixes are prime.
56    return true;
57}
58