Detect Stable Sensor Readings Using do-while

Title: Stability Detection with Minimum Consecutive Samples (Using do-while)
Level: Difficult
Concepts: do-while loop (at least one iteration), loop termination conditions, absolute difference, counters, bounds checking, input validation

Scenario

A sensor produces integer readings at fixed intervals. You want to detect when the signal becomes stable, defined as having at least K consecutive samples whose absolute difference from the current reference value is within a given delta. The reference value is the first sample processed in this call. The function must attempt detection even if there is only one sample available—hence you must use a do-while loop to ensure at least one iteration.

Problem Statement

Implement a function that scans samples[start..n) and determines whether there exists a run of K consecutive values such that for each sample s, abs(s - ref) ≤ delta, where ref = samples[start]. The scan must process samples using a do-while loop and stop when:

• Stability is detected (K consecutive within delta),
• Input is exhausted (index == n),
• Or an optional limit on examined samples (max_to_check) is reached.

Report whether stability was found, how many samples were examined, and the end index of the stable window (if found).

Requirements

• Allowed C types only: int, long, double, char, bool, and enum (and their pointers/arrays).
• Inputs:
  • const int *samples — input array
  • int n — number of elements in samples (≥ 0)
  • int start — starting index (0 ≤ start < n when n > 0)
  • int delta — inclusive tolerance for stability (≥ 0)
  • int k_consecutive — required consecutive count for stability (≥ 1)
  • int max_to_check — maximum number of samples to examine (≥ 1)
• Outputs:
  • bool *out_stable — true if stability detected, else false
  • int *out_examined — number of samples examined in this call (≥ 1 if inputs valid)
  • int *out_end_index — index of the last sample in the first detected stable window; undefined if not stable (caller uses only when out_stable==true)
• Behavior:
  • Use a do-while loop so the first sample at start is always processed.
  • Set ref = samples[start] before entering the loop.
  • Maintain a streak counter. For each sample x:
    • If abs(x - ref) ≤ delta: increment streak.
    • Else: reset streak = 0.
  • Declare stability as soon as streak == k_consecutive; record the current index as *out_end_index.
  • Stop when stability is found, or when i == n, or when examined == max_to_check.
  • On invalid inputs, return -1 and do not modify any outputs.
  • Time O(m) where m = min(n - start, max_to_check); space O(1).

Function Details

• Name: detect_stability_do_while
• Arguments:
  • const int *samples
  • int n
  • int start
  • int delta
  • int k_consecutive
  • int max_to_check
  • bool *out_stable
  • int *out_examined
  • int *out_end_index
• Return Value:
  • int — 0 on success; -1 on invalid input.
• Description:
  The function checks for a stable window relative to the first sample (ref = samples[start]) using a do-while loop:

  // Pseudocode shape (not full code)
  ref = samples[start];
  i = start;
  examined = 0;
  streak = 0;
  do {
      x = samples[i];
      if (abs(x - ref) <= delta) streak++; else streak = 0;
      examined++;
      if (streak == k_consecutive) { *out_stable = true; *out_end_index = i; break; }
      i++;
  } while (i < n && examined < max_to_check);
  *out_examined = examined;
  if (streak < k_consecutive) *out_stable = false;
  

  The do-while guarantees at least one processed sample, which is important when start == n-1 or max_to_check == 1.

Solution Approach

• Validate:
  • samples, out_stable, out_examined, out_end_index are not NULL.
  • n ≥ 0, max_to_check ≥ 1, delta ≥ 0, k_consecutive ≥ 1.
  • If n == 0, start must be 0 is invalid; in general ensure 0 ≤ start < n.
• Initialize local variables: int i = start; int examined = 0; int streak = 0; int ref = samples[start];
• Use a do-while loop:
  • Load x = samples[i].
  • Update streak based on abs(x - ref) ≤ delta.
  • Increment examined.
  • If streak == k_consecutive, set outputs and finish.
  • Increment i.
• Loop condition: while (i < n && examined < max_to_check);
• On exit without stability: set *out_stable = false, *out_examined = examined. Do not write *out_end_index (or write a sentinel like -1 if you prefer in your implementation spec).

Tasks to Perform

1. Input validation:
   • Check pointers (samples, out_stable, out_examined, out_end_index) are non-NULL.
   • Check numeric ranges: n ≥ 0, delta ≥ 0, k_consecutive ≥ 1, max_to_check ≥ 1.
   • Check 0 ≤ start < n (and ensure n > 0).
   • On any failure: return -1 without modifying outputs.
2. Initialize state:
   • int i = start;
   • int ref = samples[start];
   • int streak = 0;
   • int examined = 0;
3. Process using do-while:
   • Read int x = samples[i];
   • If x within [ref - delta, ref + delta] → streak++; else streak = 0;
   • examined++;
   • If streak == k_consecutive:
     • *out_stable = true; *out_end_index = i;
     • *out_examined = examined; return 0;
   • i++;
   • Continue while i < n && examined < max_to_check.
4. No stability found:
   • *out_stable = false;
   • *out_examined = examined;
   • (Leave *out_end_index for caller to ignore or write -1 in your implementation spec.)
   • return 0;

Test Cases