How can the function also report where the best run starts and ends?

Lean on multiple return values: func maxSubarray(nums []int) (sum, start, end int). Seed sum with nums[0], range with both index and value, and keep runStart. When n on its own beats current+n, write current, runStart = n, i; whenever current climbs above sum, record sum, start, end = current, runStart, i. Printed with fmt.Println, the first example gives 12 2 5 and the all-negative one gives -3 1 1.

What should happen with an empty or nil slice?

Both have length 0, and reading nums[0] from either panics with index out of range [0] with length 0. Idiomatic Go reports this through an extra result instead: guard with if len(nums) == 0 { return 0, false } and let the caller test the bool, so missing input is never confused with a genuine total of 0. Since len of a nil slice is 0, the one check covers both cases.

Can the total overflow an int in Go?

On the engine int is 64 bits, so a total would have to pass roughly 9.2 quintillion, far beyond what 100,000 values of 32-bit size can add up to. Go never panics on integer overflow, though; it wraps silently. If the code must also build for 32-bit targets, where int shrinks to 32 bits, declare best and current as int64 to keep the headroom.

What changes if an empty run counts as an answer?

The result can no longer drop below 0, and zero values do the setup: var best, current int starts both at 0, then current = max(0, current+n) clamps a falling total back to nothing. The all-negative input []int{-7, -3, -8, -5} then yields 0 instead of -3, while []int{4, -6, 3, 5, -2, 6, -9, 1} still yields 12.

Which Go versions have the built-in max?

Go 1.21 added min and max as built-ins. They accept one or more arguments of any ordered type, which is why the divide-and-conquer version compares three candidates in a single max call. On an older toolchain you write a two-argument helper such as func maxInt(a, b int) int with an if, since Go has no ternary operator; math.Max is no shortcut because it only takes float64.

Maximum Subarray in Go: Brute Force to Kadane's Algorithm

max_subarray.go

Go 1.26

Not run yet

+ 7 hidden

Input

nums = [4, -6, 3, 5, -2, 6, -9, 1]

Expected

The run [3, 5, -2, 6] sums to 12. The -2 is worth carrying because the 6 after it more than pays it back.