Related Articles
Count the Arithmetic sequences in the Array of size at least 3
• Last Updated : 01 Jun, 2020

Given an array arr[] of size N, the task is to find the count of all arithmetic sequences in the array.

Examples:

Input: arr = [1, 2, 3, 4]
Output: 3
Explanation:
The arithmetic sequences in arr are [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.

Input: arr = [1, 3, 5, 6, 7, 8]
Output: 4
Explanation:
The arithmetic sequences in arr are [1, 3, 5], [5, 6, 7], [5, 6, 7, 8] and [6, 7, 8].

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive approach:

• Run two loops and check for each sequence of length at least 3.
• If the sequence is an arithmetic sequence, then increment the answer by 1.
• Finally, return the count of all the arithmetic subarray of size at least 3.

Time Complexity: O(N2)

Efficient approach: We will use a dynamic programming approach to maintain a count of all arithmetic sequences till any position.

• Initialize a variable, res with 0. It will store the count of sequences.
• Initialize a variable, count with 0. It will store the size of the sequence minus 2.
• Increase the value of count if the current element forms an arithmetic sequence else make it zero.
• If the current element L[i] is making an arithmetic sequence with L[i-1] and L[i-2], then the number of arithmetic sequences till the ith iteration is given by:

res = res + count

• Finally, return the res variable.

Below is the implementation of the above approach:

## C++

 `// C++ program to find all arithmetic``// sequences of size atleast 3`` ` `#include ``using` `namespace` `std;`` ` `// Function to find all arithmetic``// sequences of size atleast 3``int` `numberOfArithmeticSequences(``int` `L[], ``int` `N)``{`` ` `    ``// If array size is less than 3``    ``if` `(N <= 2)``        ``return` `0;`` ` `    ``// Finding arithmetic subarray length``    ``int` `count = 0;`` ` `    ``// To store all arithmetic subarray``    ``// of length at least 3``    ``int` `res = 0;`` ` `    ``for` `(``int` `i = 2; i < N; ++i) {`` ` `        ``// Check if current element makes``        ``// atithmetic sequence with``        ``// previous two elements``        ``if` `(L[i] - L[i - 1] == L[i - 1] - L[i - 2]) {``            ``++count;``        ``}`` ` `        ``// Begin with a new element for``        ``// new arithmetic sequences``        ``else` `{``            ``count = 0;``        ``}`` ` `        ``// Accumulate result in till i.``        ``res += count;``    ``}`` ` `    ``// Return final count``    ``return` `res;``}`` ` `// Driver code``int` `main()``{`` ` `    ``int` `L[] = { 1, 3, 5, 6, 7, 8 };``    ``int` `N = ``sizeof``(L) / ``sizeof``(L);`` ` `    ``// Function to find arithematic sequences``    ``cout << numberOfArithmeticSequences(L, N);`` ` `    ``return` `0;``}`

## Java

 `// Java program to find all arithmetic``// sequences of size atleast 3`` ` `class` `GFG{``  ` `// Function to find all arithmetic``// sequences of size atleast 3``static` `int` `numberOfArithmeticSequences(``int` `L[], ``int` `N)``{``  ` `    ``// If array size is less than 3``    ``if` `(N <= ``2``)``        ``return` `0``;``  ` `    ``// Finding arithmetic subarray length``    ``int` `count = ``0``;``  ` `    ``// To store all arithmetic subarray``    ``// of length at least 3``    ``int` `res = ``0``;``  ` `    ``for` `(``int` `i = ``2``; i < N; ++i) {`` ` `        ``// Check if current element makes``        ``// atithmetic sequence with``        ``// previous two elements``        ``if` `(L[i] - L[i - ``1``] == L[i - ``1``] - L[i - ``2``]) {``            ``++count;``        ``}``  ` `        ``// Begin with a new element for``        ``// new arithmetic sequences``        ``else` `{``            ``count = ``0``;``        ``}``  ` `        ``// Accumulate result in till i.``        ``res += count;``    ``}``  ` `    ``// Return final count``    ``return` `res;``}``  ` `// Driver code``public` `static` `void` `main(String[] args)``{``  ` `    ``int` `L[] = { ``1``, ``3``, ``5``, ``6``, ``7``, ``8` `};``    ``int` `N = L.length;``  ` `    ``// Function to find arithmetic sequences``    ``System.out.print(numberOfArithmeticSequences(L, N));``  ` `}``}`` ` `// This code contributed by sapnasingh4991`

## Python3

 `# Python3 program to find all arithmetic ``# sequences of size atleast 3 `` ` `# Function to find all arithmetic ``# sequences of size atleast 3 ``def` `numberOfArithmeticSequences(L, N) :`` ` `    ``# If array size is less than 3 ``    ``if` `(N <``=` `2``) :``        ``return` `0`` ` `    ``# Finding arithmetic subarray length ``    ``count ``=` `0`` ` `    ``# To store all arithmetic subarray ``    ``# of length at least 3 ``    ``res ``=` `0`` ` `    ``for` `i ``in` `range``(``2``,N): `` ` `        ``# Check if current element makes ``        ``# atithmetic sequence with ``        ``# previous two elements ``        ``if` `( (L[i] ``-` `L[i ``-` `1``]) ``=``=` `(L[i ``-` `1``] ``-` `L[i ``-` `2``])) :``            ``count ``+``=` `1`` ` `        ``# Begin with a new element for ``        ``# new arithmetic sequences ``        ``else` `:``            ``count ``=` `0`` ` `        ``# Accumulate result in till i. ``        ``res ``+``=` `count`` ` ` ` `    ``# Return final count ``    ``return` `res`` ` `# Driver code `` ` `L ``=` `[ ``1``, ``3``, ``5``, ``6``, ``7``, ``8` `]``N ``=` `len``(L)`` ` `# Function to find arithematic sequences ``print``(numberOfArithmeticSequences(L, N))`` ` `# This code is contributed by Sanjit_Prasad`

## C#

 `// C# program to find all arithmetic``// sequences of size atleast 3``using` `System;`` ` `class` `GFG{`` ` `// Function to find all arithmetic``// sequences of size atleast 3``static` `int` `numberOfArithmeticSequences(``int` `[]L, ``                                       ``int` `N)``{`` ` `    ``// If array size is less than 3``    ``if` `(N <= 2)``        ``return` `0;`` ` `    ``// Finding arithmetic subarray length``    ``int` `count = 0;`` ` `    ``// To store all arithmetic subarray``    ``// of length at least 3``    ``int` `res = 0;`` ` `    ``for``(``int` `i = 2; i < N; ++i)``    ``{``         ` `       ``// Check if current element makes``       ``// atithmetic sequence with``       ``// previous two elements``       ``if` `(L[i] - L[i - 1] ==``           ``L[i - 1] - L[i - 2])``       ``{``           ``++count;``       ``}``        ` `       ``// Begin with a new element for``       ``// new arithmetic sequences``       ``else``       ``{``           ``count = 0;``       ``}``        ` `       ``// Accumulate result in till i.``       ``res += count;``    ``}``     ` `    ``// Return readonly count``    ``return` `res;``}`` ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]L = { 1, 3, 5, 6, 7, 8 };``    ``int` `N = L.Length;`` ` `    ``// Function to find arithmetic sequences``    ``Console.Write(numberOfArithmeticSequences(L, N));``}``}`` ` `// This code is contributed by amal kumar choubey`
Output:
```4
```

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up