1class Solution {
2    public int smallestBalancedIndex(int[] nums) {
3        // leftSum tracks the sum of elements; it starts as the total sum,
4        // then gets reduced so it represents the sum to the LEFT of index i.
5        long leftSum = 0;
6        // rightProduct accumulates the product of elements to the RIGHT of index i.
7        long rightProduct = 1;
8
9        // Compute the total sum of all elements first.
10        for (int value : nums) {
11            leftSum += value;
12        }
13
14        // Traverse from right to left so we can find the smallest valid index.
15        for (int i = nums.length - 1; i >= 0; --i) {
16            // Remove the current element: leftSum now equals the sum of nums[0..i-1].
17            leftSum -= nums[i];
18
19            // If the left-side sum equals the right-side product, index i is balanced.
20            if (leftSum == rightProduct) {
21                return i;
22            }
23
24            // Include the current element into the right-side product
25            // for the next (smaller) index.
26            rightProduct *= nums[i];
27
28            // Early termination: once the product is no smaller than the remaining sum,
29            // it can only grow larger (assuming positive values), so no further
30            // index can satisfy leftSum == rightProduct.
31            if (rightProduct >= leftSum) {
32                break;
33            }
34        }
35
36        // No balanced index found.
37        return -1;
38    }
39}
40```
41
42## Notes on the logic & potential perspectives
43
44A few things worth highlighting:
45
461. **The early-break optimization assumes positive integers.** For arrays containing `0` or negatives, multiplying could keep the product small or shrink it, so the `break` might exit prematurely and miss a valid index. If the input can include such values, you would remove the early break and iterate fully.
47
482. **Overflow consideration.** Both `leftSum` and `rightProduct` use `long`. For large arrays of large values, the product can still overflow `long`. If that's a concern, an alternative is to compare against the sum incrementally and stop multiplying once the product clearly exceeds any achievable sum bound.
49
503. **Alternative without early break (safer, slightly slower):**
51
52```java
53class Solution {
54    public int smallestBalancedIndex(int[] nums) {
55        long total = 0;
56        for (int value : nums) {
57            total += value;
58        }
59
60        long leftSum = total;
61        long rightProduct = 1;
62        int answer = -1;
63
64        for (int i = nums.length - 1; i >= 0; --i) {
65            leftSum -= nums[i];
66            if (leftSum == rightProduct) {
67                answer = i; // keep updating; smallest index wins since we go right-to-left
68            }
69            rightProduct *= nums[i];
70        }
71        return answer;
72    }
73}
74

1class Solution {
2public:
3    int smallestBalancedIndex(vector<int>& nums) {
4        // prefixSum will hold the sum of elements strictly before the current index.
5        // We start with the total sum and subtract each element as we move left.
6        long long prefixSum = 0;
7
8        // suffixProduct accumulates the product of elements from the current index
9        // to the end of the array.
10        long long suffixProduct = 1;
11
12        // Compute the total sum of all elements first.
13        for (int value : nums) {
14            prefixSum += value;
15        }
16
17        // Traverse from right to left.
18        for (int i = static_cast<int>(nums.size()) - 1; i >= 0; --i) {
19            // Remove nums[i] so prefixSum becomes the sum of elements before index i.
20            prefixSum -= nums[i];
21
22            // If the prefix sum equals the suffix product, index i is balanced.
23            if (prefixSum == suffixProduct) {
24                return i;
25            }
26
27            // Include nums[i] into the suffix product for the next iteration.
28            suffixProduct *= nums[i];
29
30            // Optimization: products grow faster than sums for positive integers,
31            // so once the product reaches or exceeds the remaining sum,
32            // no smaller index can ever balance, and we can stop early.
33            if (suffixProduct >= prefixSum) {
34                break;
35            }
36        }
37
38        // No balanced index found.
39        return -1;
40    }
41};
42

1/**
2 * Finds the smallest index i such that the product of all elements to the
3 * right of i equals the sum of all elements to the left of i.
4 *
5 * @param nums - The input array of numbers.
6 * @returns The smallest balanced index, or -1 if none exists.
7 */
8function smallestBalancedIndex(nums: number[]): number {
9    // Compute the total sum of all elements in the array.
10    let prefixSum = 0;
11    for (const value of nums) {
12        prefixSum += value;
13    }
14
15    // Traverse from right to left.
16    // - prefixSum: maintained as the sum of elements strictly before index i.
17    // - suffixProduct: the product of elements strictly after index i.
18    for (let i = nums.length - 1, suffixProduct = 1; i >= 0; --i) {
19        // Remove nums[i] so prefixSum becomes the sum of elements before i.
20        prefixSum -= nums[i];
21
22        // Check whether the suffix product matches the prefix sum.
23        if (suffixProduct === prefixSum) {
24            return i;
25        }
26
27        // Include nums[i] into the suffix product for the next iteration.
28        suffixProduct *= nums[i];
29
30        // Optimization: with non-negative values, once the product reaches
31        // or exceeds the remaining sum, no smaller index can satisfy the
32        // balance condition, so we can stop early.
33        if (suffixProduct >= prefixSum) {
34            break;
35        }
36    }
37
38    // No balanced index found.
39    return -1;
40}
41