Smallest Value After Replacing With Sum of Prime Factors

Smallest Value After Replacing With Sum of Prime Factors - Problem

You are given a positive integer n. Your task is to repeatedly replace n with the sum of its prime factors until you reach the smallest possible value.

Important note: If a prime factor divides n multiple times, it should be included in the sum as many times as it divides n. For example, if n = 12 = 2² × 3, then the sum of prime factors is 2 + 2 + 3 = 7.

The process continues until n becomes a prime number (which cannot be reduced further) or reaches a stable value. Return the smallest value that n will eventually reach.

Example: Starting with n = 15:
• 15 = 3 × 5 → sum = 3 + 5 = 8
• 8 = 2³ → sum = 2 + 2 + 2 = 6
• 6 = 2 × 3 → sum = 2 + 3 = 5
• 5 is prime, so we stop.
The answer is 5.

Input & Output

example_1.py — Small Composite Number

$ Input: n = 15

› Output: 5

💡 Note: 15 = 3 × 5, sum = 8. Then 8 = 2³, sum = 6. Then 6 = 2 × 3, sum = 5. Since 5 is prime, we stop.

example_2.py — Perfect Square

$ Input: n = 4

› Output: 4

💡 Note: 4 = 2², sum = 2 + 2 = 4. Since we get the same number, we've reached a fixed point and stop.

example_3.py — Prime Number

$ Input: n = 2

› Output: 2

💡 Note: 2 is already prime, so no transformation is needed. The answer is 2.

Visualization

Tap to expand

Understanding the Visualization

Start with n = 15

Our input number ready for decomposition

Find prime factors

15 = 3 × 5, so we get factors [3, 5]

Sum factors: 3 + 5 = 8

Replace n with the sum of its prime factors

Continue: 8 = 2³

8 breaks down to [2, 2, 2], sum = 6

Final step: 6 = 2 × 3

6 becomes [2, 3], sum = 5

Stop at prime

5 is prime, so we've reached our answer

Key Takeaway

🎯 Key Insight: The process always terminates because the sum of prime factors is always less than the original number (except for primes and special cases like 4).

Time & Space Complexity

Time Complexity

⏱️

O(n√n)

For each iteration, we check divisors up to √n, and we might have multiple iterations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store the current number and sum

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
n is a positive integer
The process will always terminate in a finite number of steps

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

The optimal approach uses efficient prime factorization by checking divisors only up to √n, significantly reducing time complexity from O(n²) to O(n√n). The key insight is that after checking factors up to √n, any remaining number must be prime.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Prime Factorization	O(n√n)	O(1)	Check divisors only up to √n for efficient factorization
Brute Force Factorization	O(n²)	O(1)	Check every number from 2 to n to find prime factors

Optimized Prime Factorization — Algorithm Steps

Start with the given number n
For factorization, check divisors only from 2 to √n
For each divisor found, divide it out completely and add to sum
If any number remains after factorization, it's prime - add it to sum
Replace n with the sum and repeat until n becomes prime
Return the final value

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with n = 15

Begin with the input number

Check divisors 2 to √15 ≈ 3.87

Only check up to square root

Find factors: 3, 5

3 divides 15, leaving 5 which is > √15 so it's prime

Sum: 3 + 5 = 8

Replace n with sum of prime factors

Code -

solution.c — C

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

bool isPrime(int num) {
    if (num < 2) return false;
    if (num == 2) return true;
    if (num % 2 == 0) return false;
    for (int i = 3; i * i <= num; i += 2) {
        if (num % i == 0) return false;
    }
    return true;
}

int sumPrimeFactors(int num) {
    int total = 0;
    
    // Check for factor of 2
    while (num % 2 == 0) {
        total += 2;
        num /= 2;
    }
    
    // Check for odd factors from 3 to √num
    for (int i = 3; i * i <= num; i += 2) {
        while (num % i == 0) {
            total += i;
            num /= i;
        }
    }
    
    // If num is still > 1, then it's a prime
    if (num > 1) {
        total += num;
    }
    
    return total;
}

int smallestValue(int n) {
    while (!isPrime(n)) {
        int newN = sumPrimeFactors(n);
        if (newN == n) break;
        n = newN;
    }
    return n;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", smallestValue(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n√n)

For each iteration, we check divisors up to √n, and we might have multiple iterations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store the current number and sum

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
n is a positive integer
The process will always terminate in a finite number of steps

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Prime Factorization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler