A substring exists only after every target character matches

A substring is found only when every target character matches consecutively

Treat "bananaba" as the text and "naba" as the target. A candidate start is an index in the text where you try to place the target. The target has four characters, so a complete match requires text[i + 0] to equal target[0], text[i + 1] to equal target[1], text[i + 2] to equal target[2], and text[i + 3] to equal target[3]. Matching only the first few characters proves only that the alignment is still possible, not that the substring has been found.

At candidate start 2, the text characters are n, a, n, a. The first two comparisons succeed: text[2] equals target[0], and text[3] equals target[1]. The third comparison fails because text[4] is 'n' while target[2] is 'b'. The alignment "na" is therefore a partial match, not a complete match. At candidate start 4, the text characters are n, a, b, a, which match every character of the target.

The last valid starting index is n - m, not n - m - 1

Here n is 8 and m is 4. A candidate start must leave room for four text characters, so the valid starts are 0 through n - m, which is 4. The search must therefore test starts 0, 1, 2, 3, and 4.

Start 4 is the boundary case: indices 4, 5, 6, and 7 provide exactly four characters for "naba". A start of 5 would need indices 5, 6, 7, and 8, but index 8 is outside the text. Testing only while i < n - m means i < 4, so it stops at start 3 and skips the valid match at start 4. The inclusive condition i <= n - m includes the final alignment.

A mismatch moves the candidate start and resets the target index

Use an outer loop for candidate starts and an inner loop for target characters. The target index j begins at 0 for every new candidate. If a comparison fails, abandon that alignment and move to the next candidate start. Do not continue with the old j, because j describes progress inside one alignment and has no meaning for the next one.

At start 2, j reaches 2 before the mismatch, but that value must not carry into start 3. Start 3 compares text[3] with target[0], not target[2]. At start 4, every comparison succeeds, so j advances from 0 to 4. Reaching j = m is the evidence that the entire target matched.

for (int i = 0; i < n - m; i++) {

Returning only after m matches separates success from the -1 failure path

A candidate succeeds only when the inner loop has compared all m target characters. In this example, start 4 succeeds when j reaches 4, which equals m, so the search returns 4. A partial match such as the two characters found at start 2 must not return its start, because the target still has unmatched characters.

for (int i = 0; i <= n - m; i++) {
    int j = 0;
    while (j < m && text[i + j] == target[j]) {
        j++;
    }
    if (j == m) {
        return i;
    }
}
return -1;

If every candidate reaches a mismatch before j becomes m, the outer loop ends and execution reaches return -1. That value means no complete alignment was found. For the running example, the search returns 4 because the candidate at start 4 passes all four comparisons, not because an earlier candidate matched a prefix.

There are n - m + 1 candidate starts, and each can compare up to m characters. The worst-case work is therefore O((n - m + 1) * m), commonly written O(n * m). The extra variables i and j use O(1) additional space, apart from the text and target already provided.