Sum of Largest Prime Substrings

Sum of Largest Prime Substrings - Problem

Hash Table Math String Sorting Number Theory Medium

Given a string s, find the sum of the 3 largest unique prime numbers that can be formed using any of its substrings.

Return the sum of the three largest unique prime numbers that can be formed. If fewer than three exist, return the sum of all available primes. If no prime numbers can be formed, return 0.

Note: Each prime number should be counted only once, even if it appears in multiple substrings. Additionally, when converting a substring to an integer, any leading zeros are ignored.

Input & Output

Example 1 — Basic Case

$ Input: s = "1237"

› Output: 67

💡 Note: Substrings: 1, 12, 123, 1237, 2, 23, 237, 3, 37, 7. Prime numbers: 2, 3, 7, 23, 37. Top 3 largest: 37, 23, 7. Sum: 37 + 23 + 7 = 67

Example 2 — With Leading Zeros

$ Input: s = "0023"

› Output: 28

💡 Note: Substrings after converting (ignoring leading zeros): 0, 2, 23, 3. Prime numbers: 2, 3, 23. Top 3: 23 + 3 + 2 = 28

Example 3 — No Primes

$ Input: s = "4689"

› Output: 0

💡 Note: All possible substrings result in composite numbers or 1. No prime numbers can be formed, so return 0

Constraints

1 ≤ s.length ≤ 1000
s consists of digits only ('0'-'9')

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to generate all possible substrings, check each for primality, store unique primes, and return sum of the 3 largest. Best approach uses optimized prime checking with early pruning. Time: O(n² × √m), Space: O(k)

Common Approaches

✓ Brute Force

⏱️ Time: O(n³ × √m) Space: O(k)

Generate every possible substring, convert to integer (ignoring leading zeros), check if it's prime, store unique primes, and return sum of largest 3.

Optimized Prime Generation

⏱️ Time: O(n² × √m) Space: O(k)

Use optimized prime checking and avoid redundant substring operations. Skip substrings that start with 0 early and use more efficient prime testing.

Brute Force — Algorithm Steps

Generate all possible substrings
Convert each substring to integer
Check if number is prime
Store unique primes in set
Sort and return sum of top 3

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Extract all possible substrings from the input

Prime Check

Test each number for primality

Top 3 Sum

Sort unique primes and sum largest 3

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int isPrime(int n) {
    if (n < 2) return 0;
    if (n == 2) return 1;
    if (n % 2 == 0) return 0;
    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0) return 0;
    }
    return 1;
}

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

static int primes[10000];
static char substring[1000];

int solution(char *s) {
    int primeCount = 0;
    int n = strlen(s);
    
    // Generate all substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            strncpy(substring, s + i, j - i);
            substring[j - i] = '\0';
            
            // Convert to int (handles leading zeros automatically)
            if (strlen(substring) > 0) {
                int num = atoi(substring);
                if (isPrime(num)) {
                    // Check if already exists
                    int exists = 0;
                    for (int k = 0; k < primeCount; k++) {
                        if (primes[k] == num) {
                            exists = 1;
                            break;
                        }
                    }
                    if (!exists) {
                        primes[primeCount++] = num;
                    }
                }
            }
        }
    }
    
    // Sort primes in descending order
    qsort(primes, primeCount, sizeof(int), compare);
    
    // Get top 3 largest primes
    int sum = 0;
    for (int i = 0; i < primeCount && i < 3; i++) {
        sum += primes[i];
    }
    return sum;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × √m)

O(n²) substrings, O(n) to process each, O(√m) prime check where m is max number

⚠ Quadratic Growth

Space Complexity

O(k)

O(k) space for storing unique primes, where k is number of unique primes found

✓ Linear Space

5.7K Views

Medium Frequency

~25 min Avg. Time

234 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler