Count Tested Devices After Test Operations

Count Tested Devices After Test Operations - Problem

You are working as a quality assurance engineer for a tech company that manufactures smart devices. Your task is to test a batch of n devices in a specific order to determine how many are functional.

Given a 0-indexed integer array batteryPercentages of length n, where each element represents the battery percentage of a device, you need to test each device sequentially from index 0 to n-1.

Testing Process:

If a device has batteryPercentages[i] > 0:
- ✅ Count it as tested (increment your counter)
- ⚡ The testing process drains 1% battery from all remaining untested devices (indices i+1 to n-1)
- 🛡️ Battery percentages cannot go below 0
If a device has batteryPercentages[i] = 0:
- ❌ Skip it (dead battery, can't be tested)

Goal: Return the total number of devices that will be successfully tested.

Input & Output

example_1.py — Basic Testing Sequence

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

› Output: 3

💡 Note: Device 0 (battery 1): Tested ✓, drain others → [_, 0, 1, 0, 2]. Device 1 (battery 0): Skip. Device 2 (battery 1): Tested ✓, drain others → [_, _, _, 0, 1]. Device 3 (battery 0): Skip. Device 4 (battery 1): Tested ✓. Total: 3 devices tested.

example_2.py — All Dead Batteries

$ Input: [0, 0, 0]

› Output: 0

💡 Note: All devices have 0% battery from the start, so none can be tested. Every device is skipped, resulting in 0 tested devices.

example_3.py — High Battery Devices

$ Input: [2, 1, 3]

› Output: 2

💡 Note: Device 0 (battery 2): Tested ✓, drain others → [_, 0, 2]. Device 1 (battery 0): Skip. Device 2 (battery 2): Tested ✓. Total: 2 devices tested.

Constraints

1 ≤ n ≤ 50
0 ≤ batteryPercentages[i] ≤ 100
Each device must be tested in sequential order from index 0 to n-1

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

All devices lined up with their initial battery percentages

Sequential Testing

Test each device in order, successful tests drain future devices by 1%

Optimization Insight

Instead of updating arrays, calculate effective battery = original - previous_tests

Key Takeaway

🎯 Key Insight: Instead of simulating each battery drain operation (O(n²)), we can mathematically calculate the cumulative effect in a single pass (O(n)).

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 Apple 12

The optimal solution uses mathematical insight instead of array modification. Rather than actually draining batteries after each test, we calculate each device's effective battery as original_battery - tests_completed_so_far. This transforms an O(n²) simulation into an O(n) single-pass algorithm with O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass (Optimal)	O(n)	O(1)	Track cumulative drain effect instead of modifying array elements
Brute Force Simulation	O(n²)	O(1)	Simulate the exact process: test each device and reduce all subsequent batteries

Optimized Single Pass (Optimal) — Algorithm Steps

Initialize tested counter to 0
For each device i from 0 to n-1:
Calculate effective battery = original_battery[i] - tested_count
If effective battery > 0, increment tested_count
Return the total tested count

Visualization

Tap to expand

Step-by-Step Walkthrough

Key Insight

Each device's effective battery = original - previous_tests

Single Pass

Check each device once, update counter when effective > 0

No Array Updates

Mathematical calculation replaces expensive array modifications

Code -

solution.c — C

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

int countTestedDevices(int* batteryPercentages, int n) {
    int testedCount = 0;
    
    for (int i = 0; i < n; i++) {
        // Effective battery = original - drain from previous tests
        int effectiveBattery = batteryPercentages[i] - testedCount;
        if (effectiveBattery > 0) {
            testedCount++;
        }
    }
    
    return testedCount;
}

int main() {
    int n = 0;
    int arr[1000];
    char ch;
    
    scanf("%c", &ch); // Read '['
    while (scanf("%d%c", &arr[n], &ch) == 2) {
        n++;
        if (ch == ']') break;
    }
    
    printf("%d\n", countTestedDevices(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant time operations for each element

✓ Linear Growth

Space Complexity

O(1)

Only using one variable to track the count of tested devices

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Optimized Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler