Find the Maximum Factor Score of Array

Find the Maximum Factor Score of Array - Problem

You are given an integer array nums. The factor score of an array is defined as the product of the LCM (Least Common Multiple) and GCD (Greatest Common Divisor) of all elements of that array.

Return the maximum factor score of nums after removing at most one element from it.

Note:

Both the LCM and GCD of a single number are the number itself
The factor score of an empty array is 0

Input & Output

Example 1 — Powers of 2

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

› Output: 64

💡 Note: Removing the first element (2) gives us [4,8,16]. GCD(4,8,16) = 4, LCM(4,8,16) = 16, so factor score = 4 × 16 = 64. This is the maximum possible.

Example 2 — Small Array

$ Input: nums = [1,2]

› Output: 4

💡 Note: Original array: GCD(1,2) = 1, LCM(1,2) = 2, score = 2. Remove 1: [2] gives score = 2×2 = 4. Remove 2: [1] gives score = 1×1 = 1. Maximum is 4.

Example 3 — Single Element

$ Input: nums = [3]

› Output: 9

💡 Note: Single element: GCD(3) = 3, LCM(3) = 3, factor score = 3 × 3 = 9. Removing the element gives an empty array with score 0. Maximum is 9.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 35 f Meta 28 ⊞ Microsoft 22 a Amazon 18

The key insight is that the factor score (GCD × LCM) can be maximized by strategically removing one element. The optimized approach uses prefix/suffix arrays to avoid redundant GCD/LCM calculations. Time: O(n log max), Space: O(n).

Common Approaches

✓ Brute Force - Try All Removals

⏱️ Time: O(n² × log(max(nums))) Space: O(1)

For each possible removal (including no removal), compute the GCD and LCM of the remaining elements, then find their product. Return the maximum factor score found.

Optimized with Prefix/Suffix Arrays

⏱️ Time: O(n × log(max(nums))) Space: O(n)

Instead of recalculating GCD and LCM from scratch for each removal, we pre-compute prefix and suffix arrays. This allows us to quickly combine the GCD/LCM of elements before and after the removed element.

Brute Force - Try All Removals — Algorithm Steps

Step 1: Calculate factor score of original array (no removal)
Step 2: For each element, calculate factor score after removing it
Step 3: Return the maximum factor score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Calculate GCD×LCM of [2,4,8,16]

Remove Each

Try removing each element one by one

Maximum

Return the highest factor score found

Code -

solution.c — C

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

long long gcd(long long a, long long b) {
    while (b != 0) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

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

long long arrayGcd(int* arr, int size) {
    if (size == 0) return 0;
    long long result = arr[0];
    for (int i = 1; i < size; i++) {
        result = gcd(result, arr[i]);
    }
    return result;
}

long long arrayLcm(int* arr, int size) {
    if (size == 0) return 0;
    long long result = arr[0];
    for (int i = 1; i < size; i++) {
        result = lcm(result, arr[i]);
    }
    return result;
}

long long solution(int* nums, int size) {
    if (size == 0) return 0;
    
    long long maxScore = 0;
    
    // Try original array
    if (size > 0) {
        long long g = arrayGcd(nums, size);
        long long l = arrayLcm(nums, size);
        if (g * l > maxScore) {
            maxScore = g * l;
        }
    }
    
    // Try removing each element
    for (int i = 0; i < size; i++) {
        int remaining[1000];
        int remainingSize = 0;
        for (int j = 0; j < size; j++) {
            if (j != i) {
                remaining[remainingSize++] = nums[j];
            }
        }
        if (remainingSize > 0) {
            long long g = arrayGcd(remaining, remainingSize);
            long long l = arrayLcm(remaining, remainingSize);
            if (g * l > maxScore) {
                maxScore = g * l;
            }
        }
    }
    
    return maxScore;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int size = 0;
    
    // Parse JSON array
    char* ptr = line + 1; // Skip [
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%lld\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × log(max(nums)))

For each of n+1 scenarios, we calculate GCD/LCM of up to n numbers, each taking O(log(max)) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to store current GCD, LCM, and maximum score

✓ Linear Space

23.4K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Removals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler