Questions: Array Indexing and Bounds

Question 1

A programmer writes a loop that runs while i <= arr.length and accesses arr[i] on each iteration. The array has 5 elements. What error will occur?

• A. A syntax error because the comparison operator is wrong for array iteration
• B. An out-of-bounds error because when i equals arr.length (5), arr[5] doesn't exist — the last valid index is 4
• C. No error; arr.length is always a valid index in this context
• D. A logic error because the loop runs one too few times

Answer: (B)

Zero-based indexing means a 5-element array has valid indices 0, 1, 2, 3, 4. When i reaches 5 (which equals arr.length), arr[5] is accessed — but no element exists there, causing an out-of-bounds error. The correct condition is i < arr.length (strictly less than), so i runs from 0 to 4. The off-by-one error of using <= instead of < is one of the most common bugs in programming, and it almost always stems from forgetting that the last valid index is length − 1.

Question 2

In a zero-based indexed array nums = [10, 20, 30, 40, 50], what does nums[nums.length - 1] return?

• A. 40 (the second-to-last element)
• B. 50 (the last element)
• C. An out-of-bounds error
• D. 10 (the first element)

Answer: (B)

nums.length is 5. nums.length - 1 is 4. nums[4] is 50 — the last element. This is the standard idiom for accessing the last element of an array without knowing its length in advance. Using nums[nums.length] would cause an out-of-bounds error because index 5 doesn't exist. The pattern length - 1 appears constantly in array iteration and is the direct consequence of zero-based indexing.

Question 3

In a zero-based indexed array of length 8, the valid indices are 0 through 7.

• T. True
• F. False

Answer: True

Zero-based indexing means the first element is at index 0 and the last is at index length − 1 = 8 − 1 = 7. Valid indices are 0, 1, 2, 3, 4, 5, 6, 7 — eight values total, matching the eight elements. Accessing index 8 would be out-of-bounds. Counting the valid indices by subtracting (7 − 0 + 1 = 8) confirms this matches the array length.

Question 4

In most programming languages, array indices start at 1, so an array of 5 elements has valid indices 1 through 5.

• T. True
• F. False

Answer: False

Most major programming languages (Python, JavaScript, Java, C, C++, Go, Rust) use zero-based indexing: indices start at 0, so a 5-element array has valid indices 0 through 4. A few languages (MATLAB, Lua, Fortran) use 1-based indexing, but they are exceptions. The off-by-one errors that result from assuming 1-based indexing in a 0-based language are extremely common bugs, which is why this distinction is fundamental to learn early.

Question 5

Explain why the last valid index of an array is length − 1 rather than length. Use a concrete example.

Model answer: Because indexing starts at 0, not 1. An array of 3 elements has elements at positions 0, 1, and 2 — three positions, but the highest is 2 = 3 − 1. If you think of the index as 'how many steps from the start,' the first element is 0 steps from the start, the second is 1 step, and the third is 2 steps. The index at position 'length' (3 in this case) would be one step past the last element — there's nothing there, so accessing it causes an out-of-bounds error.

For example: arr = ['a', 'b', 'c']. arr[0] = 'a', arr[1] = 'b', arr[2] = 'c'. arr.length = 3. arr[3] is out-of-bounds. The last valid index is arr.length − 1 = 2. Keeping this relationship (last valid index = length − 1) in mind is the key to writing correct array iteration and avoiding the most common type of runtime error.