Batch reporting in SCADA systems - Time & Space Complexity

Time Complexity: Batch reporting

O(n)

Understanding Time Complexity

When a SCADA system creates batch reports, it processes many data points together. Understanding how the time to create these reports grows helps us plan for bigger data sets.

We want to know: How does the time needed change as the number of data points increases?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

// Batch reporting process
function generateBatchReport(dataPoints) {
  let report = []
  for (let i = 0; i < dataPoints.length; i++) {
    let processed = processData(dataPoints[i])
    report.push(processed)
  }
  return report
}

function processData(point) {
  // Simulate data processing
  return point * 2
}
    

This code takes a list of data points and processes each one to create a batch report.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that goes through each data point once.
• How many times: Exactly once for each data point in the input list.

How Execution Grows With Input

As the number of data points grows, the time to process them grows in a straight line.

Input Size (n)	Approx. Operations
10	10 processing steps
100	100 processing steps
1000	1000 processing steps

Pattern observation: Doubling the data points roughly doubles the work needed.

Final Time Complexity

Time Complexity: O(n)

This means the time to create the batch report grows directly with the number of data points.

Common Mistake

[X] Wrong: "Processing one data point takes the same time no matter how many points there are, so total time stays constant."

[OK] Correct: Each data point adds extra work, so total time grows as more points are added.

Interview Connect

Knowing how batch report time grows helps you explain system limits and plan for scaling. This skill shows you understand how data size affects processing time.

Self-Check

"What if the processData function itself had a loop over a fixed number of steps? How would that affect the time complexity?"