算术级数

如果任意两个连续项之间的差始终相同，则数字序列称为算术级数。简而言之，这意味着该系列中的下一个数字是通过将固定数字添加到该系列中的前一个数字来计算的。例如，2、4、6、8、10是AP，因为该序列中任何两个连续项之间的差异(共同差异)是相同的(4 – 2 = 6 – 4 = 8 – 6 = 10 – 8 = 2) 。

关于算术级数的事实：

1. 初始项：在算术级数中，序列中的第一个数字称为初始项。
2. 共同差异：连续项增加或减少的值称为共同差异。
3. 算术级数的行为取决于共同的差异d。如果共同的区别是：正，则成员(项)将向正无穷或负负增长，然后成员(项)将向负无穷大。

AP^第n项的公式：
如果’a’是初始项，而’d’是共同点，则显式为

AP^第n项之和的公式：

我们如何检查序列是否为算术级数?

1. 天真的解决方案。
   这个想法是对给定的数组或序列进行排序。排序后，检查连续元素之间的差异是否相同。如果所有差异都相同，则可以进行算术级数运算。

   以下是此方法的实现：

   C++

   // C++ program to check if a given array
   // can form arithmetic progression
   #include 
   using namespace std;
     
   // Returns true if a permutation of arr[0..n-1]
   // can form arithmetic progression
   bool checkIsAP(int arr[], int n)
   {
       if (n == 1)
           return true;
     
       // Sort array
       sort(arr, arr + n);
     
       // After sorting, difference between
       // consecutive elements must be same.
       int d = arr[1] - arr[0];
       for (int i = 2; i < n; i++)
           if (arr[i] - arr[i - 1] != d)
               return false;
     
       return true;
   }
     
   // Driven Program
   int main()
   {
       int arr[] = { 20, 15, 5, 0, 10 };
       int n = sizeof(arr) / sizeof(arr[0]);
     
       (checkIsAP(arr, n)) ? (cout << "Yes" << endl) : (cout << "No" << endl);
     
       return 0;
   }

   Java

   // Java program to check if a given array
   // can form arithmetic progression
   import java.util.Arrays;
     
   class GFG {
     
       // Returns true if a permutation of
       // arr[0..n-1] can form arithmetic
       // progression
       static boolean checkIsAP(int arr[], int n)
       {
           if (n == 1)
               return true;
     
           // Sort array
           Arrays.sort(arr);
     
           // After sorting, difference between
           // consecutive elements must be same.
           int d = arr[1] - arr[0];
           for (int i = 2; i < n; i++)
               if (arr[i] - arr[i - 1] != d)
                   return false;
     
           return true;
       }
     
       // driver code
       public static void main(String[] args)
       {
           int arr[] = { 20, 15, 5, 0, 10 };
           int n = arr.length;
     
           if (checkIsAP(arr, n))
               System.out.println("Yes");
           else
               System.out.println("No");
       }
   }
     
   // This code is contributed by Anant Agarwal.

   Python3

   # Python3 program to check if a given 
   # array can form arithmetic progression
     
   # Returns true if a permutation of arr[0..n-1]
   # can form arithmetic progression
   def checkIsAP(arr, n):
       if (n == 1): return True
     
       # Sort array
       arr.sort()
     
       # After sorting, difference between
       # consecutive elements must be same.
       d = arr[1] - arr[0]
       for i in range(2, n):
           if (arr[i] - arr[i-1] != d):
               return False
     
       return True
     
   # Driver code
   arr = [ 20, 15, 5, 0, 10 ]
   n = len(arr)
   print("Yes") if(checkIsAP(arr, n)) else print("No")
     
   # This code is contributed by Anant Agarwal.

   C#

   // C# program to check if a given array
   // can form arithmetic progression
   using System;
     
   class GFG {
     
       // Returns true if a permutation of
       // arr[0..n-1] can form arithmetic
       // progression
       static bool checkIsAP(int[] arr, int n)
       {
           if (n == 1)
               return true;
     
           // Sort array
           Array.Sort(arr);
     
           // After sorting, difference between
           // consecutive elements must be same.
           int d = arr[1] - arr[0];
           for (int i = 2; i < n; i++)
               if (arr[i] - arr[i - 1] != d)
                   return false;
     
           return true;
       }
     
       // Driver Code
       public static void Main()
       {
           int[] arr = { 20, 15, 5, 0, 10 };
           int n = arr.Length;
     
           if (checkIsAP(arr, n))
               Console.WriteLine("Yes");
           else
               Console.WriteLine("No");
       }
   }
     
   // This code is contributed by vt_m.

   输出：

   Yes
   

   时间复杂度： O(n Log n)。

2. 高效的解决方案
   • 设置1(使用散列)
   • 设置2(使用计数排序)

与算术级数有关的基本程序

• 算术级数和的程序
• 程序打印算术级数系列
• 具有给定共同差异的最长算术级数
• 检查是否可以从给定数组形成算术级数
• 在算术级数中找到缺少的数字
• 在A和B之间找到N个算术平均值
• 最多可被2或5整除的N之和
• 在AP中查找第一个元素，该元素是给定素数的倍数

与算术级数有关的更多问题

• 给定级数3、6、11，…的前n个项的总和。
• 具有给定总和比例的AP的第m个和第n个项的比率
• AP中三个随机选择的数字的概率
• 将所有三胞胎打印成形成AP的有序阵列
• 算术级数系列第N项程序
• 算术几何序列之和
• 数组中的AP(算术级数)子序列的计数

关于算术级数的最新文章！