Count Tested Devices After Test Operations

Count Tested Devices After Test Operations - Problem

You are given a 0-indexed integer array batteryPercentages having length n, denoting the battery percentages of n 0-indexed devices.

Your task is to test each device i in order from 0 to n - 1, by performing the following test operations:

If batteryPercentages[i] is greater than 0:
- Increment the count of tested devices.
- Decrease the battery percentage of all devices with indices j in the range [i + 1, n - 1] by 1, ensuring their battery percentage never goes below 0, i.e, batteryPercentages[j] = max(0, batteryPercentages[j] - 1).
- Move to the next device.
Otherwise, move to the next device without performing any test.

Return an integer denoting the number of devices that will be tested after performing the test operations in order.

Input & Output

Example 1 — Basic Testing Sequence

$ Input: batteryPercentages = [1,1,2,1,3]

› Output: 3

💡 Note: Device 0: battery=1>0, test it (count=1), drain others → [1,0,1,0,2]. Device 1: battery=0, skip. Device 2: battery=1>0, test it (count=2), drain others → [1,0,1,0,1]. Device 3: battery=0, skip. Device 4: battery=1>0, test it (count=3). Total tested = 3.

Example 2 — All Zeros

$ Input: batteryPercentages = [0,0,0]

› Output: 0

💡 Note: All devices start with 0 battery, so none can be tested. Return 0.

Example 3 — Single Device

$ Input: batteryPercentages = [5]

› Output: 1

💡 Note: Only one device with battery=5>0, test it. No other devices to drain. Return 1.

Constraints

1 ≤ batteryPercentages.length ≤ 100
0 ≤ batteryPercentages[i] ≤ 100

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 8

The key insight is that each test operation drains all future devices by 1. We can optimize by tracking cumulative drain instead of updating all devices. Best approach uses cumulative drain optimization with Time: O(n), Space: O(1).

Common Approaches

✓ Cumulative Drain Optimization

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

Instead of modifying all future devices after each test, keep track of how much total drain has been applied and subtract it from each device's battery when checking.

Direct Simulation

⏱️ Time: O(n²) Space: O(1)

Iterate through each device, test if battery > 0, then decrease all remaining devices' batteries by 1. Count successful tests.

Cumulative Drain Optimization — Algorithm Steps

Initialize tested count and cumulative drain counter
For each device, check if (original battery - cumulative drain) > 0
If yes, increment test count and increase cumulative drain
Continue to next device

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Drain

Keep running total of battery drain from all previous tests

Check Effective Battery

For each device, check if (original - cumulative drain) > 0

Update Counter

If testable, increment both test count and cumulative drain

Code -

solution.c — C

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

int solution(int* batteryPercentages, int n) {
    int tested = 0;
    int cumulativeDrain = 0;
    
    for (int i = 0; i < n; i++) {
        // Check if current device has enough battery after all previous drains
        if (batteryPercentages[i] - cumulativeDrain > 0) {
            tested++;
            cumulativeDrain++; // This test will drain all future devices
        }
    }
    
    return tested;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int batteryPercentages[100];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int val = atoi(token);
        if (val != 0 || token[0] == '0') {
            batteryPercentages[n++] = val;
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(batteryPercentages, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per device

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters, no additional data structures

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 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

Cumulative Drain Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler