形成算术级数(AP)的子数组数

给定大小为N的数组arr [] ，任务是查找至少长度为2的子数组的数量，以使这些子数组的连续元素之间的差异始终保持相同，即子数组的元素形成一个AP。
例子：

Input: arr[] = {8, 7, 4, 1, 0} 
Output: 5 
Explanation: 
All subarrays of size greater than 1 which form an AP are [8, 7], [7, 4], [4, 1], [1, 0], [7, 4, 1]

Input: arr[] = {4, 2} 
Output: 1

方法：想法是从给定的数组中生成所有可能的子数组，并针对每个子数组检查相邻元素之间的差异对于生成的子数组是否相同。步骤如下：

1. 使用两个循环在长度至少为2的每个子数组上进行迭代。
2. 设i为子数组的开始索引， j为子数组的结束索引。
3. 如果从索引i到j的数组的每对相邻元素之间的差相同，则增加总计数。
4. 否则，对下一个子数组重复上述过程。

下面是上述方法的实现：

C++

// C++ implementation of
// the above approach
#include 
using namespace std;
 
// Function to find the
// total count of subarrays
int calcSubarray(int A[], int N)
{
 
    int count = 0;
 
    // Iterate over each subarray
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
 
            bool flag = true;
 
            // Difference between first
            // two terms of subarray
            int comm_diff = A[i + 1] - A[i];
 
            // Iterate over the subarray
            // from i to j
            for (int k = i; k < j; k++) {
 
                // Check if the difference
                // of all adjacent elements
                // is same
                if (A[k + 1] - A[k] == comm_diff) {
                    continue;
                }
                else {
                    flag = false;
                    break;
                }
            }
 
            if (flag) {
                count++;
            }
        }
    }
 
    return count;
}
 
// Driver Code
int main()
{
    // Given array
    int A[5] = { 8, 7, 4, 1, 0 };
    int N = sizeof(A) / sizeof(int);
 
    // Function Call
    cout << calcSubarray(A, N);
}

Java

// Java implementation of
// the above approach
import java.util.*;
class GFG{
 
// Function to find the
// total count of subarrays
static int calcSubarray(int A[],
                        int N)
{
  int count = 0;
 
  // Iterate over each subarray
  for (int i = 0; i < N; i++)
  {
    for (int j = i + 1; j < N; j++)
    {
      boolean flag = true;
 
      // Difference between first
      // two terms of subarray
      int comm_diff = A[i + 1] - A[i];
 
      // Iterate over the subarray
      // from i to j
      for (int k = i; k < j; k++)
      {
        // Check if the difference
        // of all adjacent elements
        // is same
        if (A[k + 1] - A[k] == comm_diff)
        {
          continue;
        }
        else
        {
          flag = false;
          break;
        }
      }
 
      if (flag)
      {
        count++;
      }
    }
  }
 
  return count;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array
  int []A = {8, 7, 4, 1, 0};
  int N = A.length;
 
  // Function Call
  System.out.print(calcSubarray(A, N));
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python3 implementation of
# the above approach
 
# Function to find the
# total count of subarrays
def calcSubarray(A, N):
 
    count = 0
 
    # Iterate over each subarray
    for i in range(N):
        for j in range(i + 1, N):
            flag = True
 
            # Difference between first
            # two terms of subarray
            comm_diff = A[i + 1] - A[i]
 
            # Iterate over the subarray
            # from i to j
            for k in range(i, j):
 
                # Check if the difference
                # of all adjacent elements
                # is same
                if (A[k + 1] - A[k] == comm_diff):
                    continue
                else:
                    flag = False
                    break
                     
            if (flag):
                count += 1
                 
    return count
 
# Driver Code
if __name__ == '__main__':
 
    # Given array
    A = [ 8, 7, 4, 1, 0 ]
    N = len(A)
 
    # Function call
    print(calcSubarray(A, N))
 
# This code is contributed by mohit kumar 29

C#

// C# implementation of
// the above approach
using System;
class GFG{
 
// Function to find the
// total count of subarrays
static int calcSubarray(int []A,
                        int N)
{
  int count = 0;
 
  // Iterate over each subarray
  for (int i = 0; i < N; i++)
  {
    for (int j = i + 1; j < N; j++)
    {
      bool flag = true;
 
      // Difference between first
      // two terms of subarray
      int comm_diff = A[i + 1] - A[i];
 
      // Iterate over the subarray
      // from i to j
      for (int k = i; k < j; k++)
      {
        // Check if the difference
        // of all adjacent elements
        // is same
        if (A[k + 1] - A[k] == comm_diff)
        {
          continue;
        }
        else
        {
          flag = false;
          break;
        }
      }
 
      if (flag)
      {
        count++;
      }
    }
  }
 
  return count;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array
  int []A = {8, 7, 4, 1, 0};
  int N = A.Length;
 
  // Function Call
  Console.Write(calcSubarray(A, N));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript implementation of
// the above approach
 
// Function to find the
// total count of subarrays
function calcSubarray(A, N)
{
 
    let count = 0;
 
    // Iterate over each subarray
    for (let i = 0; i < N; i++) {
        for (let j = i + 1; j < N; j++) {
 
            let flag = true;
 
            // Difference between first
            // two terms of subarray
            let comm_diff = A[i + 1] - A[i];
 
            // Iterate over the subarray
            // from i to j
            for (let k = i; k < j; k++) {
 
                // Check if the difference
                // of all adjacent elements
                // is same
                if (A[k + 1] - A[k] == comm_diff) {
                    continue;
                }
                else {
                    flag = false;
                    break;
                }
            }
 
            if (flag) {
                count++;
            }
        }
    }
 
    return count;
}
 
// Driver Code
 
    // Given array
    let A = [ 8, 7, 4, 1, 0 ];
    let N = A.length;
 
    // Function Call
    document.write(calcSubarray(A, N));
 
// This code is contributed by Mayank Tyagi
 

输出：

5

时间复杂度： O(N ³ )
辅助空间： O(1)