413. Arithmetic Slices

Description

A sequence of numbers 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 sequences:

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 the 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.

Constraints

Approach

Links

• GeeksforGeeks

• Leetcode

• ProgramCreek

• YouTube

Examples

Example 1

Input: A = [1, 2, 3, 4]

Output: 3

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

Example 2

Input: A = [1, 2, 3, 4, 5, 5, 7, 8, 9, 10]

Output: 9

Solutions

Solution 1

/**
 * Time complexity : O(n^2), Two for loops are used.
 * Space complexity : O(1)
 */

public class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        int count = 0;
        for (int s = 0; s < A.length - 2; s++) {
            int d = A[s + 1] - A[s];
            for (int e = s + 2; e < A.length; e++) {
                if (A[e] - A[e - 1] == d)
                    count++;
                else
                    break;
            }
        }
        return count;
    }
}

Solution 2

/**
 * Time complexity : O(n). The recursive function is called at most n-2 times.
 * Space complexity : O(n). The depth of the recursion tree goes upto n-2.
 */
 
 public class Solution {
    int sum = 0;
    public int numberOfArithmeticSlices(int[] A) {
        slices(A, A.length - 1);
        return sum;
    }
    public int slices(int[] A, int i) {
        if (i < 2)
            return 0;
        int ap = 0;
        if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
            ap = 1 + slices(A, i - 1);
            sum += ap;
        } else
            slices(A, i - 1);
        return ap;
    }
}

Solution 3

/**
 * Time complexity : O(n). We traverse over the given A array with n elements once only.
 * Space complexity : O(n). 1D dp of size n is used.
 */
 
 public class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        int[] dp = new int[A.length];
        int sum = 0;
        for (int i = 2; i < dp.length; i++) {
            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
                dp[i] = 1 + dp[i - 1];
                sum += dp[i];
            }
        }
        return sum;
    }
}

Solution 4

/**
 * Time complexity : O(n). We traverse over the given A array with n elements once only.
 * Space complexity : O(1). Constant extra space is used.
 */
 
public class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        int dp = 0;
        int sum = 0;
        for (int i = 2; i < A.length; i++) {
            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
                dp = 1 + dp;
                sum += dp;
            } else
                dp = 0;
        }
        return sum;
    }
}

Solution 5

/**
 * Time complexity : O(n). We iterate over A with n elements exactly once.
 * Space complexity : O(1)
 */
 
 class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        if(A == null || A.length < 3) {
            return 0;
        }
        int n = A.length;
        int numOfSlices = 0, count = 0;
        
        for(int i = 0; i+2 < n; i++) {
            if(A[i+1]-A[i] == A[i+2]-A[i+1]) {
                count++;
            } else {
                numOfSlices += (count+1)*count/2;
                count = 0;
            }
        }
        numOfSlices += (count+1)*count/2;
        
        return numOfSlices;
    }
}

Follow up