1class Solution {
2    // Main method to compute the sum of the 3 largest unique prime substrings in s
3    public long sumOfLargestPrimes(String s) {
4        Set<Long> uniquePrimes = new HashSet<>();
5        int length = s.length();
6
7        // Generate all possible numeric substrings
8        for (int startIndex = 0; startIndex < length; startIndex++) {
9            long number = 0;
10            // Extend substring from startIndex to end of string
11            for (int endIndex = startIndex; endIndex < length; endIndex++) {
12                // Form the number incrementally
13                number = number * 10 + (s.charAt(endIndex) - '0');
14                // Check if number is prime and add to set
15                if (is_prime(number)) {
16                    uniquePrimes.add(number);
17                }
18            }
19        }
20
21        // Sort the unique primes in ascending order
22        List<Long> sortedPrimes = new ArrayList<>(uniquePrimes);
23        Collections.sort(sortedPrimes);
24
25        // Sum the 3 largest primes (or less if insufficient primes)
26        long sum = 0;
27        int count = sortedPrimes.size();
28        int fromIndex = Math.max(0, count - 3);
29        for (int i = fromIndex; i < count; i++) {
30            sum += sortedPrimes.get(i);
31        }
32        return sum;
33    }
34
35    // Helper method to check if a number is prime
36    private boolean is_prime(long number) {
37        if (number < 2) return false;
38        for (long divisor = 2; divisor * divisor <= number; divisor++) {
39            if (number % divisor == 0) return false;
40        }
41        return true;
42    }
43}
44

1#include <unordered_set>
2#include <vector>
3#include <algorithm>
4#include <string>
5
6class Solution {
7public:
8    // Calculates the sum of the 3 largest unique prime numbers
9    // extracted from all possible substrings of s.
10    long long sumOfLargestPrimes(std::string s) {
11        std::unordered_set<long long> uniquePrimes;
12        int n = s.size();
13
14        // Extract all possible substrings as numbers and check if they are prime
15        for (int i = 0; i < n; ++i) {
16            long long number = 0;
17            for (int j = i; j < n; ++j) {
18                // Form the number by appending the digit
19                number = number * 10 + (s[j] - '0');
20                if (is_prime(number)) {
21                    uniquePrimes.insert(number);
22                }
23            }
24        }
25
26        // Copy the primes into a vector and sort in ascending order
27        std::vector<long long> sortedPrimes(uniquePrimes.begin(), uniquePrimes.end());
28        std::sort(sortedPrimes.begin(), sortedPrimes.end());
29
30        long long sum = 0;
31        int count = 0;
32        // Add the largest 3 primes to the sum
33        for (int i = static_cast<int>(sortedPrimes.size()) - 1; i >= 0 && count < 3; --i, ++count) {
34            sum += sortedPrimes[i];
35        }
36        return sum;
37    }
38
39private:
40    // Checks if a number is prime
41    bool is_prime(long long x) {
42        if (x < 2) return false;
43        for (long long i = 2; i * i <= x; ++i) {
44            if (x % i == 0) return false;
45        }
46        return true;
47    }
48};
49

1/**
2 * Returns the sum of the three largest unique prime numbers
3 * that can be formed by any contiguous substring of the input string.
4 * @param s The input string consisting of digits
5 * @returns The sum of the three largest unique prime numbers
6 */
7function sumOfLargestPrimes(s: string): number {
8    // Set to store unique prime numbers found from all substrings
9    const primesSet = new Set<number>();
10    const strLen = s.length;
11
12    // Iterate over all possible starting indices of substrings
13    for (let start = 0; start < strLen; start++) {
14        let currentNum = 0;
15        // Build substring numbers one digit at a time
16        for (let end = start; end < strLen; end++) {
17            currentNum = currentNum * 10 + Number(s[end]);
18            // If this number is prime, add to set
19            if (isPrime(currentNum)) {
20                primesSet.add(currentNum);
21            }
22        }
23    }
24
25    // Convert set to array and sort in ascending order
26    const sortedPrimes = Array.from(primesSet).sort((a, b) => a - b);
27    // Get the last three (the largest three primes)
28    const largestThree = sortedPrimes.slice(-3);
29    // Sum and return
30    return largestThree.reduce((sum, value) => sum + value, 0);
31}
32
33/**
34 * Checks if a given number is a prime.
35 * @param num The number to check for primality
36 * @returns True if the number is prime, false otherwise
37 */
38function isPrime(num: number): boolean {
39    if (num < 2) return false;
40    for (let factor = 2; factor * factor <= num; factor++) {
41        if (num % factor === 0) return false;
42    }
43    return true;
44}
45