Find the Maximum Factor Score of Array - Practice Coding Problems

Find the Maximum Factor Score of Array - Problem

You're given an integer array nums and need to find the maximum factor score possible after removing at most one element.

The factor score of an array is calculated as: GCD × LCM of all elements in the array.

Key Rules:

For a single number, both GCD and LCM equal the number itself
For an empty array, the factor score is 0
You can remove at most one element (including removing none)

Example: For array [12, 6, 4]:
• Original: GCD(12,6,4) = 2, LCM(12,6,4) = 12, Score = 24
• Remove 4: GCD(12,6) = 6, LCM(12,6) = 12, Score = 72
• Remove 6: GCD(12,4) = 4, LCM(12,4) = 12, Score = 48
• Remove 12: GCD(6,4) = 2, LCM(6,4) = 12, Score = 24

The maximum factor score is 72.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 4, 8, 16]

› Output: 64

💡 Note: Original array: GCD=2, LCM=16, score=32. Remove 2: GCD=4, LCM=16, score=64. Remove 4: GCD=2, LCM=16, score=32. Remove 8: GCD=2, LCM=16, score=32. Remove 16: GCD=2, LCM=8, score=16. Maximum score is 64.

example_2.py — Single Element

$ Input: nums = [3]

› Output: 9

💡 Note: For a single element, both GCD and LCM equal the element itself. Factor score = 3 × 3 = 9. Removing the only element gives score 0, so maximum is 9.

example_3.py — All Same Elements

$ Input: nums = [5, 5, 5]

› Output: 25

💡 Note: When all elements are the same, GCD=LCM=5 regardless of removal. Original: 5×5=25. Remove any: 5×5=25. Remove two: 5×5=25. All scenarios give the same score of 25.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Assess Current Band

Calculate the harmony score of the full band: GCD × LCM of all members

Try Removing Each Member

For each member, calculate what the band's harmony would be without them

Optimize with Prefix-Suffix

Instead of recalculating from scratch, use precomputed harmony values from left and right segments

Find Maximum Harmony

Compare all scenarios (original band and each removal) to find the best configuration

Key Takeaway

🎯 Key Insight: Instead of recalculating GCD/LCM from scratch for each removal, use prefix-suffix arrays to combine precomputed segments in O(1) time, reducing overall complexity from O(n²) to O(n).

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses prefix-suffix precomputation to efficiently calculate factor scores. Build prefix and suffix GCD/LCM arrays in O(n) time, then combine them to evaluate each removal scenario in O(1). This avoids the O(n²) redundant calculations of the brute force approach while maintaining the same logic.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix-Suffix Precomputation	O(n × log(max))	O(n)	Precompute prefix and suffix GCD/LCM arrays, then calculate scores efficiently
Brute Force (Try All Removals)	O(n² × log(max))	O(n)	Try removing each element (and no element) and calculate factor score for each case

Prefix-Suffix Precomputation — Algorithm Steps

Compute prefix GCD and LCM arrays from left to right
Compute suffix GCD and LCM arrays from right to left
For each position, combine prefix and suffix to get GCD/LCM without that element
Calculate factor score for each removal scenario
Return the maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Arrays

Calculate GCD and LCM from start to each position

Build Suffix Arrays

Calculate GCD and LCM from each position to end

Combine for Removal

Use prefix[i-1] and suffix[i+1] to get result without element i

Calculate Scores

Compute factor score for each removal scenario

Code -

solution.c — C

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

long long gcd(long long a, long long b) {
    return b == 0 ? a : gcd(b, a % b);
}

long long lcm(long long a, long long b) {
    return a / gcd(a, b) * b;
}

long long maxScore(int* nums, int numsSize) {
    int n = numsSize;
    if (n == 1) return (long long)nums[0] * nums[0];
    
    long long* prefixGcd = malloc(n * sizeof(long long));
    long long* prefixLcm = malloc(n * sizeof(long long));
    long long* suffixGcd = malloc(n * sizeof(long long));
    long long* suffixLcm = malloc(n * sizeof(long long));
    
    // Build prefix arrays
    prefixGcd[0] = nums[0];
    prefixLcm[0] = nums[0];
    for (int i = 1; i < n; i++) {
        prefixGcd[i] = gcd(prefixGcd[i-1], nums[i]);
        prefixLcm[i] = lcm(prefixLcm[i-1], nums[i]);
    }
    
    // Build suffix arrays
    suffixGcd[n-1] = nums[n-1];
    suffixLcm[n-1] = nums[n-1];
    for (int i = n-2; i >= 0; i--) {
        suffixGcd[i] = gcd(suffixGcd[i+1], nums[i]);
        suffixLcm[i] = lcm(suffixLcm[i+1], nums[i]);
    }
    
    long long maxScore = prefixGcd[n-1] * prefixLcm[n-1];
    
    for (int i = 0; i < n; i++) {
        long long gcdVal, lcmVal;
        
        if (i == 0 && n > 1) {
            gcdVal = suffixGcd[1];
            lcmVal = suffixLcm[1];
        } else if (i == n-1) {
            gcdVal = prefixGcd[n-2];
            lcmVal = prefixLcm[n-2];
        } else {
            gcdVal = gcd(prefixGcd[i-1], suffixGcd[i+1]);
            lcmVal = lcm(prefixLcm[i-1], suffixLcm[i+1]);
        }
        
        long long score = n == 2 ? gcdVal * gcdVal : gcdVal * lcmVal;
        if (score > maxScore) {
            maxScore = score;
        }
    }
    
    free(prefixGcd);
    free(prefixLcm);
    free(suffixGcd);
    free(suffixLcm);
    
    return maxScore;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max))

Two O(n) passes to build prefix/suffix arrays, each GCD/LCM operation is O(log(max))

⚡ Linearithmic

Space Complexity

O(n)

Space for prefix and suffix GCD/LCM arrays

⚡ Linearithmic 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

Prefix-Suffix Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler