Maximum Strength of a Group - Practice Coding Problems

Maximum Strength of a Group - Problem

Array Dynamic Programming Backtracking Greedy Bit Manipulation Sorting Enumeration Medium

A teacher wants to form the strongest possible study group from students based on their exam scores! 📚

Given a 0-indexed integer array nums representing student scores, you need to select any non-empty subset of students to maximize the group's strength.

The strength of a group is calculated by multiplying all selected scores together. For example, if you select students with scores [2, -3, 4], the strength would be 2 × (-3) × 4 = -24.

Goal: Return the maximum possible strength you can achieve by selecting the optimal group of students.

Key Insight: Since we're dealing with multiplication, negative numbers can become positive when paired together, and we want to maximize the final product!

Input & Output

example_1.py — Basic positive case

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

› Output: 6

💡 Note: We can select all elements: 3 × (-1) × (-2) = 6. The two negatives multiply to positive.

example_2.py — Mixed with zero

$ Input: [-4, -5, -4]

› Output: 20

💡 Note: Select [-4, -5] to get (-4) × (-5) = 20. Avoid the third -4 to keep result positive.

example_3.py — All negative

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

› Output: 6

💡 Note: Select [-2, -3] to get (-2) × (-3) = 6. Exclude -1 to avoid negative result.

Constraints

1 ≤ nums.length ≤ 13
-9 ≤ nums[i] ≤ 9
Note: Small constraints allow for brute force solutions

Visualization

Tap to expand

24✅ All positives included✅ Even number of negatives✅ No zeros needed

Understanding the Visualization

Sort by Type

Categorize team members by power type (positive/negative/zero)

Include Positives

All positive powers boost the team strength

Pair Negatives

Two negative powers cancel out to become positive

Strategic Zeros

Use zero-power members to prevent negative team strength

Key Takeaway

🎯 Key Insight: Multiplication allows us to turn negatives into positives by pairing them up, while zeros act as a safety net to prevent negative results.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25

The optimal solution uses a greedy approach to maximize the product: separate numbers into positive, negative, and zero categories, include all positives, pair negatives optimally (even count gives positive result), and use zeros strategically to avoid negative outcomes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsets)	O(n × 2^n)	O(1)	Generate all possible non-empty subsets and find maximum product
Greedy Approach (Optimal)	O(n log n)	O(n)	Use mathematical properties to greedily select optimal elements

Brute Force (Try All Subsets) — Algorithm Steps

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

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with mask = 1 (first subset)

Generate Subset

Use bits in mask to select elements

Calculate Product

Multiply all selected elements

Update Maximum

Keep track of best result so far

Code -

solution.c — C

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

long long maximumStrength(int* nums, int n) {
    long long maxStrength = LLONG_MIN;
    
    // Try all possible non-empty subsets
    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;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

We generate 2^n subsets and for each subset calculate product in O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

42.3K Views

Medium Frequency

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

Brute Force (Try All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler