A sequence of number is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.

For example, these are arithmetic sequence:

1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9
The following sequence is not arithmetic.

1, 1, 2, 5, 7

A zero-indexed array A consisting of N numbers is given. A slice of that array is any pair of integers (P, Q) such that 0 <= P < Q < N.

A slice (P, Q) of array A is called arithmetic if the sequence:
A[P], A[p + 1], ..., A[Q - 1], A[Q] is arithmetic. In particular, this means that P + 1 < Q.

The function should return the number of arithmetic slices in the array A. 

Example:

A = [1, 2, 3, 4]

return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.

class Solution(object):
    class Solution(object):
        def numberOfArithmeticSlices(self, A):
            """
            :type A: List[int]
            :rtype: int
            """

            def is_sequence(a):
                if 2 * a[1] == a[0] + a[2]:
                    return True
                else:
                    return False

            def find_all_after(A, sequence):
                n = 0
                a, index = sequence
                tail = index + 2
                tail_number = a[2]
                intervel = a[2] - a[1]
                while True:
                    tail += 1
                    if tail >= len(A) or A[tail] - tail_number > intervel:
                        break
                    elif A[tail] - tail_number == intervel:
                        tail_number = A[tail]
                        n += 1
                return n
            # in this problem it's not necessary to sort
            # A.sort()
            seqs = [(A[i:i + 3], i)
                         for i in range(len(A) - 3 + 1) if is_sequence(A[i:i + 3])]
            n = len(seqs)
            for seq in seqs:
                n = n + find_all_after(A, seq)

            return n

class Solution(object):
    def numberOfArithmeticSlices(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        dp = [0]*len(A)
        sum = 0
        for i in range(2,len(A)):
            if A[i] - A[i-1] == A[i-1] -A[i-2]:
                dp[i] = 1 + dp[i-1]
                sum +=dp[i]
        return sum

Original text
Pros:
* Fast
* Powerfull
* Reliable
* Not user-friendlyCons:
* Portable
* Addictive
Commands
/Power/	Go to the first line containing the string ‘Power’
ddp	Swap the current line with the next one
:/user-friendly/m$	Move the next line containing the string ‘user-friendly’ to the end of the file
g;	Bring back cursor to the previous position
:/Cons/+1m-2	Move two lines up the line following ‘Cons’
Modified text
Pros:
* Fast
* Reliable
* Powerfull
* PortableCons:
* Addictive
* Not user-friendly