Maximum Strength of a Group

Maximum Strength of a Group - Problem

Array Dynamic Programming Backtracking Greedy Bit Manipulation Sorting Enumeration Medium

You are given a 0-indexed integer array nums representing the score of students in an exam. The teacher would like to form one non-empty group of students with maximal strength.

The strength of a group of students at indices i₀, i₁, i₂, ..., iₖ is defined as:

nums[i₀] × nums[i₁] × nums[i₂] × ... × nums[iₖ]

Return the maximum strength of a group the teacher can create.

Input & Output

Example 1 — Mixed Positive and Negative

$ Input: nums = [3,-1,-5,2]

› Output: 30

💡 Note: We can form the group [3,-1,-5,2]. The strength is 3 × (-1) × (-5) × 2 = 30. This is optimal since all elements can be included.

Example 2 — Single Element

$ Input: nums = [-4]

› Output: -4

💡 Note: Since we must form a non-empty group and there's only one element, we must choose [-4] with strength -4.

Example 3 — All Negative with Odd Count

$ Input: nums = [-1,-2,-3]

› Output: 6

💡 Note: The best group is [-2,-3] with strength (-2) × (-3) = 6. Including -1 would make the product negative.

Constraints

1 ≤ nums.length ≤ 13
-9 ≤ nums[i] ≤ 9

Visualization

Tap to expand

Asked in

f Meta 3 G Google 2

The key insight is that we want to maximize the absolute value of the product while controlling the sign. The optimal approach uses a greedy strategy: include all positive numbers, pair negative numbers (since two negatives make a positive), and handle edge cases like zeros and single elements. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Subsets

⏱️ Time: O(2^n × n) Space: O(1)

Use bit manipulation to generate all 2^n - 1 non-empty subsets, calculate the product for each subset, and track the maximum product found.

Greedy Approach

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

Separate elements by sign, sort negatives and positives by absolute value, then greedily select to maximize the product considering sign rules.

Brute Force - Try All Subsets — Algorithm Steps

Generate all non-empty subsets using bit manipulation
For each subset, calculate the product of all elements
Keep track of the maximum product encountered

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to create all possible subsets

Calculate Products

Multiply elements in each subset

Find Maximum

Track the highest product found

Code -

solution.c — C

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

long long solution(int* nums, int n) {
    long long maxStrength = LLONG_MIN;
    
    // Try all non-empty subsets using bit manipulation
    for (int mask = 1; mask < (1 << n); mask++) {
        long long product = 1;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                product *= nums[i];
            }
        }
        if (product > maxStrength) {
            maxStrength = product;
        }
    }
    
    return maxStrength;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsets to check, each requiring O(n) time to calculate product

⚡ Linearithmic

Space Complexity

O(1)

Only using variables to track current and maximum product

⚡ Linearithmic Space

8.9K Views

Medium Frequency

~15 min Avg. Time

245 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 Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler