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:3Explanation:

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:4Explanation:

The arithmetic sequences in arr are [1, 3, 5], [5, 6, 7], [5, 6, 7, 8] and [6, 7, 8].

**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(N ^{2})**

**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 <bits/stdc++.h>` `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[0]);` ` ` ` ` `// 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****.**