Sum of Largest Prime Substrings - Practice Coding Problems

Sum of Largest Prime Substrings - Problem

Hash Table Math String Sorting Number Theory Medium

You're a cryptographer tasked with finding the most valuable prime codes hidden within an encrypted message string!

Given a string s, your mission is to:

Extract all possible substrings from the string
Convert each substring to an integer (ignoring leading zeros)
Identify which of these integers are prime numbers
Find the 3 largest unique primes and return their sum

Special Rules:

Each prime is counted only once, even if it appears multiple times
Leading zeros are ignored when converting substrings to integers
If fewer than 3 unique primes exist, return the sum of all available primes
If no primes can be formed, return 0

Example: For string "2311", substrings include "2", "23", "231", "2311", "3", "31", "311", "1", "11", "1". The unique primes are: 2, 23, 3, 31, 311. The 3 largest are 311, 31, 23, so return 311 + 31 + 23 = 365.

Input & Output

example_1.py — Basic Case

$ Input: s = "2311"

› Output: 365

💡 Note: Substrings: "2"(2), "23"(23), "231"(231), "2311"(2311), "3"(3), "31"(31), "311"(311), "1"(1), "11"(11), "1"(1). Primes found: 2, 23, 3, 31, 311 (231=3×7×11, 2311=non-prime, 1=non-prime, 11=prime but smaller). Unique primes sorted: [311, 31, 23, 11, 3, 2]. Top 3: 311+31+23=365.

example_2.py — With Leading Zeros

$ Input: s = "0123"

› Output: 26

💡 Note: Substrings include "01"(1), "012"(12), "0123"(123), "12"(12), "123"(123), "23"(23), "3"(3), etc. After removing leading zeros: 1, 12, 123, 12, 123, 23, 3. Unique numbers: {1, 12, 123, 23, 3}. Primes: 23, 3. Only 2 primes found, so return 23+3=26.

example_3.py — No Primes

$ Input: s = "1469"

› Output: 0

💡 Note: All possible substrings convert to composite numbers or 1. Numbers like 1(not prime), 4(2²), 6(2×3), 9(3²), 14(2×7), 46(2×23), 69(3×23), 146(2×73), 469(7×67), 1469(non-prime). No prime numbers can be formed, so return 0.

Constraints

1 ≤ s.length ≤ 1000
s consists only of digits ('0' to '9')
All numbers formed will fit in a 64-bit signed integer
Leading zeros in substrings are ignored when converting to integers
At most 10⁶ substrings to check for primality

Visualization

Tap to expand

Understanding the Visualization

Map Exploration

Systematically explore all possible routes (substrings) on the treasure map

Coordinate Conversion

Convert each route into treasure coordinates (string to integer, handling leading zeros)

Treasure Verification

Use advanced detection equipment (optimized prime testing) to verify if coordinates contain real treasure

Unique Collection

Store verified treasures in a secure vault (hash set) to avoid counting duplicates

Value Assessment

Sort treasures by value and select the 3 most valuable ones

Final Reward

Calculate the total value of the top 3 treasures found

Key Takeaway

🎯 Key Insight: Use a hash set for automatic uniqueness and optimize prime checking with the 6k±1 method to efficiently find the most valuable prime treasures hidden in the string!

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 35 f Meta 28

The optimal approach uses a hash set for automatic uniqueness handling and implements optimized primality testing using the 6k±1 method. Key insights: skip substrings starting with '0' to avoid unnecessary processing, use efficient prime checking with early termination, and leverage set operations for clean duplicate management. Time complexity is O(n² × √m) where n is string length and m is the largest number formed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Substrings)	O(n³ × √m)	O(k)	Generate all substrings, check each for primality, collect unique primes, and return sum of 3 largest
Optimized with Set and Early Optimization	O(n² × √m)	O(k)	Use a set for unique primes and optimize prime checking with early termination

Brute Force (Generate All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
Convert each substring to integer, ignoring leading zeros
Check if each number is prime using trial division
Store unique primes in a set to avoid duplicates
Sort primes in descending order
Return sum of top 3 (or fewer if available)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Use nested loops to create all possible substrings from the input string

Convert to Integer

Remove leading zeros and convert each substring to a number

Prime Check

Test each number for primality using trial division

Store Unique

Add unique primes to a set to avoid duplicates

Sort and Sum

Sort primes in descending order and sum the top 3

Code -

solution.c — C

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

bool isPrime(long long n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    for (long long i = 3; i <= (long long)sqrt(n); i += 2) {
        if (n % i == 0) return false;
    }
    return true;
}

long long stringToInt(char* substr) {
    // Remove leading zeros
    while (*substr == '0' && *(substr + 1) != '\0') {
        substr++;
    }
    if (*substr == '0') return 0;
    return atoll(substr);
}

int compare(const void* a, const void* b) {
    long long ia = *(const long long*)a;
    long long ib = *(const long long*)b;
    return (ib > ia) - (ib < ia); // Descending order
}

long long largestPrimeSum(char* s) {
    long long primes[10000];
    int primeCount = 0;
    int n = strlen(s);
    
    // Generate all substrings
    for (int i = 0; i < n; i++) {
        char substring[1000];
        for (int j = i + 1; j <= n; j++) {
            strncpy(substring, s + i, j - i);
            substring[j - i] = '\0';
            
            long long num = stringToInt(substring);
            if (num > 0 && isPrime(num)) {
                // Check if already exists
                bool exists = false;
                for (int k = 0; k < primeCount; k++) {
                    if (primes[k] == num) {
                        exists = true;
                        break;
                    }
                }
                if (!exists) {
                    primes[primeCount++] = num;
                }
            }
        }
    }
    
    // Sort primes in descending order
    qsort(primes, primeCount, sizeof(long long), compare);
    
    // Return sum of top 3 or all available
    long long sum = 0;
    int limit = (primeCount < 3) ? primeCount : 3;
    for (int i = 0; i < limit; i++) {
        sum += primes[i];
    }
    return sum;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        printf("%lld\n", largestPrimeSum(start));
    } else {
        // Remove newline
        s[strcspn(s, "\n")] = 0;
        printf("%lld\n", largestPrimeSum(s));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × √m)

O(n²) substrings, each taking O(n) to process, and O(√m) prime checking where m is the largest number

⚠ Quadratic Growth

Space Complexity

O(k)

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

✓ Linear Space

43.7K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 (Generate All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler