Prime Factorization - Problem

Write a function that takes a positive integer and returns its prime factorization as a list of prime factors.

Prime factorization breaks down a number into its constituent prime numbers. For example, 12 = 2 × 2 × 3, so the prime factors are [2, 2, 3].

Requirements:

Return factors in ascending order
Include repeated factors (e.g., for 12, include both 2's)
Handle edge cases like prime numbers and small inputs

Input & Output

Example 1 — Basic Composite Number

$ Input: n = 12

› Output: [2, 2, 3]

💡 Note: 12 = 2 × 2 × 3, so the prime factors are [2, 2, 3] in ascending order

Example 2 — Prime Number

$ Input: n = 17

› Output: [17]

💡 Note: 17 is already prime, so it has only itself as a prime factor

Example 3 — Large Factors

$ Input: n = 60

› Output: [2, 2, 3, 5]

💡 Note: 60 = 2 × 2 × 3 × 5, breaking down: 60 → 30 → 15 → 5 → 1

Constraints

1 ≤ n ≤ 10⁶
n is a positive integer

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is that we only need to test divisors up to √n since any factor larger than √n must be paired with a smaller factor we already found. The optimal approach handles 2 separately, then tests odd numbers only up to √n. Time: O(√n), Space: O(log n)

Common Approaches

✓ Brute Force Trial Division

⏱️ Time: O(n) Space: O(log n)

Iterate through every number from 2 up to n, checking if it divides the current number. When found, add to factors and divide the number.

Square Root Optimization

⏱️ Time: O(√n) Space: O(log n)

Optimize by testing divisors only up to √n, since any factor larger than √n must be paired with a factor smaller than √n that we already found.

Brute Force Trial Division — Algorithm Steps

Start with divisor = 2
While divisor ≤ n: if n % divisor == 0, add divisor to factors and set n = n / divisor
Otherwise increment divisor
Continue until n becomes 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Testing

Begin with divisor = 2, test if it divides n

Divide & Collect

If divisible, add to factors and update n

Continue

Increment divisor and repeat until n = 1

Code -

solution.c — C

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

int* solution(int n, int* returnSize) {
    int* factors = (int*)malloc(32 * sizeof(int));
    int count = 0;
    int divisor = 2;
    
    while (n > 1) {
        while (n % divisor == 0) {
            factors[count++] = divisor;
            n /= divisor;
        }
        divisor++;
        if (divisor > n) break;
    }
    
    *returnSize = count;
    return factors;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    int* result = solution(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case (prime number), we test every number from 2 to n

✓ Linear Growth

Space Complexity

O(log n)

Result array stores at most log n prime factors

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Prime Factorization - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Trial Division — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler