Sort and Remove performance in Scala - scala

Question

I'm writing a program which determines whether an Array would be in strictly increasing order if one and only one element were removed. It works but apparently it does not pass the time limit set by codefights (To be clear it runs instantly on my local machine and on their servers fails the 30 second time limit (with 5000 numbers in the array)).
Which operation is the most performance consuming? Sort is only run once, the only operations that are run every iteration are patching the array, removing by value which is defined by array diff and distinct. Thanks.
def remove(num: Int, array: Array[Int]): Array[Int] = array diff Array(num)
def almostIncreasingSequence(sequence: Array[Int]): Boolean = {
var i = 0
val sortedSequence = sequence.sortWith(_ < _)
while (i < sequence.length) {
val patchedSequence = sequence.patch(i, Nil, 1)
if(patchedSequence.sameElements(remove(sequence(i), sortedSequence).distinct)) return true
i += 1
}
return false
}

Answer 1

So the trick with these things is usually avoid sorting (if possible) and traverse only once. Maybe something like this.
def almostIncreasingSequence(sequence: Array[Int]): Boolean = {
sequence.indices.tail.filter(x => sequence(x-1) >= sequence(x)) match {
case Seq(x) => x == 1 || //remove sequence.head
sequence(x-2) < sequence(x) || //remove sequence(x-1)
!sequence.isDefinedAt(x+1) || //remove sequence.last
sequence(x-1) < sequence(x+1) //remove sequence(x)
case Seq() => true //no dips in sequence
case _ => false //too many dips in sequence
}
}