Are allocations balanced?

Challenge

Decide whether a sequence of allocate/free operations is perfectly balanced — every allocation eventually freed, and never a free with nothing live. This models leak-freedom as a depth counter that must never go negative and must end at zero.

Task

Implement int balanced_allocs(const char *ops) over a trace string where 'a' means allocate and 'f' means free. Return 1 if the trace is balanced, else 0. No main — the grader calls it.

Input

ops — a NUL-terminated string of 'a' and 'f' characters (may be empty).

Output

Returns 1 if the running depth never goes below 0 and ends at exactly 0; otherwise 0.

Example

balanced_allocs("af")     ->   1
balanced_allocs("aaff")   ->   1
balanced_allocs("aff")    ->   0   (extra free / underflow)
balanced_allocs("fa")     ->   0   (free before any alloc)
balanced_allocs("")       ->   1

Edge cases

• Empty string: balanced (returns 1).
• Depth goes negative at any point: returns 0.
• Depth positive at the end (a leak): returns 0.

Why this matters

Drill: practice one contract before combining it with other skills.

Input format

ops — a NUL-terminated string of 'a' and 'f' characters (may be empty).

Output format

Returns 1 if the running depth never goes below 0 and ends at exactly 0; otherwise 0.

Constraints

ops is a non-NULL terminated trace. Count a as allocation and f as free; other characters are ignored. Running count must fit int. This counter model does not track object identity or execute allocations.

Starter code

int balanced_allocs(const char *ops) {
    /* TODO */
    return 0;
}

Common mistakes

Checking only final counts and accepting a free before its allocation.

Edge cases to handle

Empty trace is balanced; reject any negative prefix even if final count is zero; reject a positive final count.

Up next

• Count leaked allocations