Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Build confidence with an intuition-first walkthrough focused on array fundamentals.
Given a 0-indexed integer array nums, find the leftmost middleIndex (i.e., the smallest amongst all the possible ones).
A middleIndex is an index where nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1].
If middleIndex == 0, the left side sum is considered to be 0. Similarly, if middleIndex == nums.length - 1, the right side sum is considered to be 0.
Return the leftmost middleIndex that satisfies the condition, or -1 if there is no such index.
Example 1:
Input: nums = [2,3,-1,8,4] Output: 3 Explanation: The sum of the numbers before index 3 is: 2 + 3 + -1 = 4 The sum of the numbers after index 3 is: 4 = 4
Example 2:
Input: nums = [1,-1,4] Output: 2 Explanation: The sum of the numbers before index 2 is: 1 + -1 = 0 The sum of the numbers after index 2 is: 0
Example 3:
Input: nums = [2,5] Output: -1 Explanation: There is no valid middleIndex.
Constraints:
1 <= nums.length <= 100-1000 <= nums[i] <= 1000Note: This question is the same as 724: https://leetcode.com/problems/find-pivot-index/
Problem summary: Given a 0-indexed integer array nums, find the leftmost middleIndex (i.e., the smallest amongst all the possible ones). A middleIndex is an index where nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1]. If middleIndex == 0, the left side sum is considered to be 0. Similarly, if middleIndex == nums.length - 1, the right side sum is considered to be 0. Return the leftmost middleIndex that satisfies the condition, or -1 if there is no such index.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array
[2,3,-1,8,4]
[1,-1,4]
[2,5]
find-pivot-index)partition-array-into-three-parts-with-equal-sum)number-of-ways-to-split-array)maximum-sum-score-of-array)left-and-right-sum-differences)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1991: Find the Middle Index in Array
class Solution {
public int findMiddleIndex(int[] nums) {
int l = 0, r = Arrays.stream(nums).sum();
for (int i = 0; i < nums.length; ++i) {
r -= nums[i];
if (l == r) {
return i;
}
l += nums[i];
}
return -1;
}
}
// Accepted solution for LeetCode #1991: Find the Middle Index in Array
func findMiddleIndex(nums []int) int {
l, r := 0, 0
for _, x := range nums {
r += x
}
for i, x := range nums {
r -= x
if l == r {
return i
}
l += x
}
return -1
}
# Accepted solution for LeetCode #1991: Find the Middle Index in Array
class Solution:
def findMiddleIndex(self, nums: List[int]) -> int:
l, r = 0, sum(nums)
for i, x in enumerate(nums):
r -= x
if l == r:
return i
l += x
return -1
// Accepted solution for LeetCode #1991: Find the Middle Index in Array
impl Solution {
pub fn find_middle_index(nums: Vec<i32>) -> i32 {
let mut l = 0;
let mut r: i32 = nums.iter().sum();
for (i, &x) in nums.iter().enumerate() {
r -= x;
if l == r {
return i as i32;
}
l += x;
}
-1
}
}
// Accepted solution for LeetCode #1991: Find the Middle Index in Array
function findMiddleIndex(nums: number[]): number {
let l = 0;
let r = nums.reduce((a, b) => a + b, 0);
for (let i = 0; i < nums.length; ++i) {
r -= nums[i];
if (l === r) {
return i;
}
l += nums[i];
}
return -1;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair or subarray. The outer loop fixes a starting point, the inner loop extends or searches. For n elements this gives up to n²/2 operations. No extra space, but the quadratic time is prohibitive for large inputs.
Most array problems have an O(n²) brute force (nested loops) and an O(n) optimal (single pass with clever state tracking). The key is identifying what information to maintain as you scan: a running max, a prefix sum, a hash map of seen values, or two pointers.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.