1class Solution {
2    /**
3     * Calculates the alternating sum of the given array.
4     * Elements at even indices are added, while elements at odd indices are subtracted.
5     *
6     * @param nums the input array of integers
7     * @return the alternating sum of the array
8     */
9    public int alternatingSum(int[] nums) {
10        // Initialize the result to store the alternating sum
11        int result = 0;
12
13        // Iterate through each element of the array
14        for (int index = 0; index < nums.length; index++) {
15            if (index % 2 == 0) {
16                // Add the element if its index is even
17                result += nums[index];
18            } else {
19                // Subtract the element if its index is odd
20                result -= nums[index];
21            }
22        }
23
24        // Return the final alternating sum
25        return result;
26    }
27}
28

1class Solution {
2public:
3    int alternatingSum(vector<int>& nums) {
4        // Initialize the result accumulator
5        int result = 0;
6
7        // Traverse the array, tracking each element's index
8        for (int index = 0; index < nums.size(); ++index) {
9            // Elements at even indices are added,
10            // while elements at odd indices are subtracted
11            if (index % 2 == 0) {
12                result += nums[index];
13            } else {
14                result -= nums[index];
15            }
16        }
17
18        // Return the final alternating sum
19        return result;
20    }
21};
22```
23
24**Explanation of changes:**
25
261. **Naming standardization**: Renamed `ans` to `result` and `i` to `index` for clarity, while keeping the method name `alternatingSum` unchanged.
27
282. **Readability improvement**: Replaced the ternary expression with an explicit `if-else` branch, making the add/subtract logic easier to follow at a glance.
29
303. **Comments**: Added English comments describing the accumulator initialization, the alternating add/subtract rule based on index parity, and the return value.
31
32**Alternative perspective**: If you prefer a more compact style, the original ternary form is equally valid:
33
34```cpp
35class Solution {
36public:
37    int alternatingSum(vector<int>& nums) {
38        int result = 0;
39        // Add values at even indices, subtract values at odd indices
40        for (int index = 0; index < nums.size(); ++index) {
41            result += (index % 2 == 0) ? nums[index] : -nums[index];
42        }
43        return result;
44    }
45};
46

1/**
2 * Calculates the alternating sum of an array.
3 * Elements at even indices are added, while elements at odd indices are subtracted.
4 *
5 * @param nums - The input array of numbers
6 * @returns The alternating sum of the array
7 */
8function alternatingSum(nums: number[]): number {
9    // Initialize the result accumulator
10    let ans: number = 0;
11
12    // Iterate through each element of the array
13    for (let i = 0; i < nums.length; ++i) {
14        // Add the element if its index is even, otherwise subtract it
15        ans += i % 2 === 0 ? nums[i] : -nums[i];
16    }
17
18    // Return the final alternating sum
19    return ans;
20}
21```
22
23**Explanation of the approach:**
24
251. **Initialization**: A variable `ans` starts at `0` to accumulate the result.
262. **Iteration**: A standard `for` loop traverses every index of the input array.
273. **Sign determination**: The ternary expression `i % 2 === 0 ? nums[i] : -nums[i]` checks the parity of the index — even indices contribute positively, odd indices contribute negatively.
284. **Return**: After processing all elements, the accumulated alternating sum is returned.
29
30**Complexity analysis:**
31
32- **Time complexity**: `O(n)`, where `n` is the length of `nums`, since each element is visited exactly once.
33- **Space complexity**: `O(1)`, as only a constant amount of extra space is used.
34
35**Alternative perspective** — the same logic can be expressed functionally using `reduce`:
36
37```typescript
38/**
39 * Functional variant: computes the alternating sum using Array.prototype.reduce.
40 *
41 * @param nums - The input array of numbers
42 * @returns The alternating sum of the array
43 */
44function alternatingSum(nums: number[]): number {
45    // Accumulate values, flipping the sign based on index parity
46    return nums.reduce((acc, val, i) => acc + (i % 2 === 0 ? val : -val), 0);
47}
48