Almost increasing sequence in Go: how to loop avoiding index out of bound?

So I am trying to learn Go by doing some algorithm challenges, and the one I am currently on is called almost increasing sequence.

The instruction looks like:

>Given a sequence of integers as an array, determine whether it is possible to obtain a strictly increasing sequence by removing no more than one element from the array.

>- For sequence = [1, 3, 2, 1], the output should be
almostIncreasingSequence(sequence) = false;

>There is no one element in this array that can be removed in order to get a strictly increasing sequence.

>- For sequence = [1, 3, 2], the output should be
almostIncreasingSequence(sequence) = true.

>We can remove 3 from the array to get the strictly increasing sequence [1, 2]. Alternately, we can remove 2 to get the strictly increasing sequence [1, 3].

>The function must return true if it is possible to remove one element from the array in order to get a strictly increasing sequence, otherwise return false.

I have finished this in Typescript already, it was not hard. But I am trying to write it again in Go, but I found it is kinda tricky to avoid index out of range error in Go. Here is my code so far:

func almostIncreasingSequence(a []int) bool {
    var count int = 0

	for i := 0; i < len(a); i++ {
    	if a[i] <= a[i-1] {
	    	count++
		    if (a[i] <= a[i-2]) && (a[i+1] <= a[i-1]) {
			    return false
		    }
	    }
    }

    return count <= 1
}

This is what I literally converted what I wrote in Typescript and it works fine with Typescript, but as you can easily notice from my Go code index out of range error occurs when as it iterates, if a[i] <= a[i-1].

Are there any tricks to compare an element at index i and i - 1 or i + 1 avoiding index out of range error when write code in Go?

Thanks in advance!

It isn't a trick. You are looping from 0 (first element) through the length of the array minus one, or upper bounds. When i == len(a) - 1 then a[i+1] is going to exceed the length of the array. If there are only 3 items in it, their indexes will be 0, 1, 2. len(a) gives you 3. i < len(a) results in 0 through 2.

You are also subtracting from i on the first iteration which is basically asking the compiler if a[0] <= a[-1] which results in a[-1] being outside of the boundaries of the array. You do so again with a[i] <= a[i-2].

I'm fairly certain you just need something like:

func almostIncreasingSequence(a []int) bool {
	count := 0 // := is shorthand. So long as it is within a func it is basically equiv of var. It also infers the type.
	l :=  len(a) - 1
	for i := 0; i < l; i++ {
		if a[i] > a[i+1] {
			count++
		}
	}
	r := count <= 1
	fmt.Println(a, r)
	return r
}

Results in:

[1 3 2 1] false
[1 3 2] true

https://play.golang.org/p/8d_3a_PMM2C

If performance is important and the array could be large, add a check for count:

		if a[i] > a[i+1] {
			count = count + 1
            if(count > 1) {
            	return false;
			}
		}

The reason it worked in JavaScript is due to how Undefined is treated.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

console.log(1 < undefined)
console.log(0 < undefined)

const array = []

console.log(array[0] < 0)
console.log(array[-1] < 0)
console.log(array[9999] < 0)

<!-- end snippet -->

It is an incredibly forgiving language due to the terrain it was devised for.