Incorrect Absolute Difference Usage

First, recall what the problem (Leetcode #413) is asking for:

We need to find the number of arithmetic subarrays (subarrays of length ≥ 3) in the given array. An arithmetic subarray is one where the difference between consecutive elements is the same (including its sign), for example: $3, 5, 7, 9$ has consecutive differences +2, +2, +2.

Now, let’s look at the provided solution and see what goes wrong:

go
func numberOfArithmeticSlices(nums []int) int {
    res := 0
    if len(nums) < 3 {
        return 0
    }

    start := 0
    diff := math.Abs(float64(nums[0] - nums[1]))
    for i, j := 1, 0; i <= len(nums); i, j = i+1, j+1 {
        if i == len(nums) {
            n := i - start - 2
            res += n * (n + 1) / 2
            break
        }
        if math.Abs(float64(nums[i] - nums[j])) != diff {
            if i < len(nums)-1 {
                diff = math.Abs(float64(nums[i] - nums[i+1]))
            }
            n := i - start - 2
            res += n * (n + 1) / 2
            start = i
        }
    }
    return res
}

1. Using the absolute difference is incorrect

The primary mistake is doing:

go
diff := math.Abs(float64(nums[0] - nums[1]))

and then checking:

go
if math.Abs(float64(nums[i] - nums[j])) != diff {
    // ...
}

Leetcode #413 does not define an arithmetic subarray based on the absolute value of the difference. Instead, the difference including its sign must remain constant for the subarray to be arithmetic. For example:

• $1, 3, 5$ has consecutive differences +2, +2 — it’s arithmetic with diff = 2.
• $5, 3, 1$ has consecutive differences -2, -2 — it’s arithmetic with diff = -2.
• $3, 5, 1$, however, has consecutive differences +2, -4, which are not the same even if you took absolute values.

By using the absolute value, this code would incorrectly conclude that, for instance, $3, 5, 1$ is an arithmetic slice if all it looks at is |3-5| = 2 and |5-1| = 4—these are not the same, but we never should use absolute differences in the first place. And if they accidentally matched in absolute value, that would also be incorrect. The sign does matter for valid arithmetic subarrays.

2. Correct approach for the difference

The correct approach is to keep track of the signed difference:

go
diff := nums[1] - nums[0]

Then, while iterating, check whether the next consecutive difference is exactly the same nums[i] - nums[i-1] == diff.

3. Counting arithmetic slices properly

The usual approach is:

• Keep track of how many consecutive indices are forming an arithmetic progression so far.
• Once you detect a difference mismatch, you compute how many sub-slices that run can produce, then reset.

A common clean approach (in pseudo-code or Go) is:

go
count := 0         // how many arithmetic slices so far
currentLen := 2    // length of the current arithmetic run
diff := nums[1] - nums[0]

for i from 2 to len(nums)-1:
    if (nums[i] - nums[i-1]) == diff:
        currentLen++
    else:
        // currentLen means you have currentLen >= 2 consecutive arithmetic
        // subarray of length `currentLen` yields (currentLen - 2)*(currentLen - 1)/2 slices
        if currentLen >= 2 {
            count += (currentLen - 2)*(currentLen - 1)/2
        }
        // reset
        diff = nums[i] - nums[i-1]
        currentLen = 2
// loop ends

// need to add slices from the last run if currentLen >= 3
if currentLen >= 3 {
   count += (currentLen - 2)*(currentLen - 1)/2
}
return count

This way:

• We do not use absolute values.
• We correctly handle the arithmetic run lengths.
• We accumulate the count of all arithmetic sub-slices in each run.

Summary of why the given code is incorrect

1. It uses absolute differences (math.Abs), whereas arithmetic slices require matching signed differences.
2. Even if you wanted to keep track of negative and positive runs, the logic in the code never actually checks the real (signed) difference.
3. Using the absolute difference can lead to counting invalid subarrays or missing valid ones where the sign of the difference is important.

Below is a clean and concise Go implementation that solves Leetcode #413 (Arithmetic Slices) correctly by tracking the signed difference and summing up the counts of arithmetic runs:

go
func numberOfArithmeticSlices(nums []int) int {
    n := len(nums)
    if n < 3 {
        return 0
    }

    // 'count' will store the total number of arithmetic sub-slices
    count := 0

    // 'currentLen' will track the length of the current arithmetic run
    currentLen := 2

    // Initialize the difference using the first two elements
    diff := nums[1] - nums[0]

    for i := 2; i < n; i++ {
        currentDiff := nums[i] - nums[i-1]
        if currentDiff == diff {
            // Continue the arithmetic run
            currentLen++
        } else {
            // We ended the previous run, so count how many arithmetic 
            // sub-slices it contributed: the formula is (currentLen-2)*(currentLen-1)/2
            if currentLen >= 3 {
                count += (currentLen - 2) * (currentLen - 1) / 2
            }
            // Reset for the new run
            diff = currentDiff
            currentLen = 2
        }
    }

    // If we ended with a run of length >= 3, we need to count its sub-slices as well
    if currentLen >= 3 {
        count += (currentLen - 2) * (currentLen - 1) / 2
    }

    return count
}

Explanation

1. We track the signed difference: diff := nums[1] - nums[0].
2. If the difference is consistent, we extend the current arithmetic run: currentLen++.
3. If the difference breaks, we first compute how many sub-slices the previous run contributed using the formula: $$\text{number of sub-slices} = \frac{( \text{currentLen} - 2) \times (\text{currentLen} - 1)}{2}$$ Then reset to a new run starting at length 2.
4. At the end, we might have a run still going, so we again count its sub-slices if currentLen >= 3.

This ensures we only treat arithmetic slices where the signed difference is identical (e.g., +2 vs. -2 are distinct differences) and correctly sum all arithmetic sub-slices of length ≥ 3.