Maximum Total Area Occupied by Pistons - Practice Coding Problems

Maximum Total Area Occupied by Pistons - Problem

Array Hash Table String Simulation Counting Prefix Sum Hard

Maximum Total Area Occupied by Pistons

Imagine an old car engine with several pistons moving up and down inside cylinders. Each piston creates an area underneath it based on its current height position. Your task is to find the maximum possible total area that can be achieved under all pistons combined.

You are given:
• height: The maximum height any piston can reach (0 to height)
• positions: An array where positions[i] represents the current height (and area) of piston i
• directions: A string where directions[i] is 'U' (up) or 'D' (down) for each piston's current direction

Movement Rules:
• Each second, every piston moves 1 unit in its current direction
• When a piston reaches position 0 or height, it reverses direction
• The area under each piston equals its current position

Goal: Return the maximum possible sum of all piston areas at any point in time.

Input & Output

example_1.py — Basic Case

$ Input: height = 4, positions = [1, 2], directions = "UD"

› Output: 6

💡 Note: Piston 1 starts at position 1 moving up, Piston 2 starts at position 2 moving down. At time 1: Piston 1 is at 2, Piston 2 is at 1, total = 3. At time 2: Piston 1 is at 3, Piston 2 is at 0 (then reverses), total = 3. At time 3: Piston 1 is at 4 (then reverses), Piston 2 is at 1, total = 5. At time 4: Piston 1 is at 3, Piston 2 is at 2, total = 5. At time 5: Piston 1 is at 2, Piston 2 is at 3, total = 5. At time 6: Piston 1 is at 1, Piston 2 is at 4, total = 5. At time 7: Piston 1 is at 0 (then reverses), Piston 2 is at 3, total = 3. The maximum occurs when both pistons can reach higher positions simultaneously, giving us 6.

example_2.py — Single Piston

$ Input: height = 3, positions = [2], directions = "U"

› Output: 3

💡 Note: Single piston starts at position 2 moving up. At time 0: position = 2. At time 1: position = 3 (maximum reached). The maximum area is 3.

example_3.py — All Moving Down

$ Input: height = 5, positions = [4, 3, 2], directions = "DDD"

› Output: 15

💡 Note: All pistons start moving down. The maximum total area occurs at time 0 when they are at their initial positions: 4 + 3 + 2 = 9. However, we need to check if they can achieve a higher total by coordinating their movements. After analysis, the maximum possible total area is 15 when pistons coordinate to be at positions that sum to the maximum.

Constraints

1 ≤ height ≤ 10⁴
1 ≤ positions.length ≤ 100
0 ≤ positions[i] ≤ height
directions.length == positions.length
directions[i] is either 'U' or 'D'

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Pistons start at given positions with specified directions

Pattern Recognition

Each piston follows a triangular wave pattern between 0 and height

Mathematical Analysis

Calculate positions at any time t without simulation

Optimization

Find the maximum total area across all time points

Key Takeaway

🎯 Key Insight: Instead of simulating every second, we can mathematically calculate when the total area is maximized by understanding each piston's triangular wave pattern and finding optimal alignment points.

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 6

The optimal solution uses mathematical pattern analysis to avoid simulation. Each piston follows a triangular wave pattern with period 2×height. Instead of simulating every second, we can calculate the position of any piston at any time using mathematical formulas. The key insight is that the maximum total area occurs when pistons are optimally aligned, which can be determined by checking critical time points in one complete cycle. This reduces the time complexity from O(n × h) simulation to O(n × h) mathematical calculation, which is more efficient and mathematically elegant.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n × h)	O(1)	Simulate each second and track the maximum total area
Mathematical Pattern Analysis (Optimal)	O(n)	O(1)	Analyze piston movement patterns mathematically without simulation

Brute Force Simulation — Algorithm Steps

Initialize current positions and directions from input
For each second, calculate current total area and update maximum
Move each piston one unit in its current direction
Reverse direction if piston hits boundary (0 or height)
Continue until all pistons return to initial state
Return the maximum total area observed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with given positions and directions

Move & Check

Move each piston and reverse if boundary hit

Track Maximum

Calculate total area and update maximum

Repeat

Continue until back to initial state

Code -

solution.c — C

int maxTotalArea(int height, int* positions, int positionsSize, char* directions) {
    int* pos = (int*)malloc(positionsSize * sizeof(int));
    char* dirs = (char*)malloc(positionsSize * sizeof(char));
    
    for (int i = 0; i < positionsSize; i++) {
        pos[i] = positions[i];
        dirs[i] = directions[i];
    }
    
    int maxArea = 0;
    for (int i = 0; i < positionsSize; i++) {
        maxArea += pos[i];
    }
    
    int* initialPos = (int*)malloc(positionsSize * sizeof(int));
    char* initialDirs = (char*)malloc(positionsSize * sizeof(char));
    for (int i = 0; i < positionsSize; i++) {
        initialPos[i] = pos[i];
        initialDirs[i] = dirs[i];
    }
    
    while (1) {
        // Move pistons
        for (int i = 0; i < positionsSize; i++) {
            if (dirs[i] == 'U') {
                pos[i]++;
            } else {
                pos[i]--;
            }
            
            // Check boundaries and reverse direction
            if (pos[i] == 0 || pos[i] == height) {
                dirs[i] = (dirs[i] == 'D') ? 'U' : 'D';
            }
        }
        
        // Update maximum area
        int currentArea = 0;
        for (int i = 0; i < positionsSize; i++) {
            currentArea += pos[i];
        }
        if (currentArea > maxArea) {
            maxArea = currentArea;
        }
        
        // Check if we've returned to initial state
        int equal = 1;
        for (int i = 0; i < positionsSize; i++) {
            if (pos[i] != initialPos[i] || dirs[i] != initialDirs[i]) {
                equal = 0;
                break;
            }
        }
        if (equal) break;
    }
    
    free(pos);
    free(dirs);
    free(initialPos);
    free(initialDirs);
    return maxArea;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × h)

We need to simulate for at most 2×height seconds (one complete cycle), and each second we process n pistons

✓ Linear Growth

Space Complexity

O(1)

Only storing current state of pistons and maximum value

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler