Partial success handling in Rest API - Time & Space Complexity
When handling partial success in REST APIs, some operations succeed while others fail. We want to understand how the time to process these results grows as the number of operations increases.
How does the processing time change when more items are involved?
Analyze the time complexity of the following code snippet.
// Assume responses is a list of results from multiple API calls
for (let i = 0; i < responses.length; i++) {
if (responses[i].status === 'success') {
processSuccess(responses[i].data);
} else {
processFailure(responses[i].error);
}
}
This code loops through each response and processes it based on success or failure.
Identify the loops, recursion, array traversals that repeat.
- Primary operation: Looping through each response item once.
- How many times: Exactly once per response, so as many times as the number of responses.
As the number of responses grows, the code processes each one individually.
| Input Size (n) | Approx. Operations |
|---|---|
| 10 | 10 processing steps |
| 100 | 100 processing steps |
| 1000 | 1000 processing steps |
Pattern observation: The work grows directly with the number of responses; doubling responses doubles the work.
Time Complexity: O(n)
This means the time to handle partial success grows linearly with the number of responses.
[X] Wrong: "Partial success handling is faster because it skips failed items."
[OK] Correct: Even failed items must be checked and processed, so the code still touches every item once.
Understanding how partial success handling scales helps you explain API response processing clearly and confidently in interviews.
"What if processSuccess or processFailure themselves loop over data inside each response? How would that affect the time complexity?"