Program to Check Arithmetic Progression

Try it on GfG Practice

A sequence of numbers is called an Arithmetic progression if the difference between any two consecutive terms is always the same. In simple terms, it means that the next number in the series is calculated by adding a fixed number to the previous number in the series.

Example: 

Input : arr[] = {4, 1, 7, 10]
Output : Yes
The given array can become arithmetic progression. After sorting elements, we get [1, 4, 7, 10]
The difference between 2nd and 1st term 4 - 1 = 3
The difference between 3rd and 2nd term 7 - 4 = 3
The difference between 4th and 3rd term10 - 7 = 3

From the above example, we can conclude that there is some common difference between any two consecutive elements.

Input : arr[] = {1, 20, 10]
Output : No
If we arrange elements in increasing order, we get 1, 10 and 20. The common difference between 1 and 10, and 20 and 10 is not same.

Notation in Arithmetic Progression

In AP, there are some main terms that are generally used, which are denoted as:

• Initial term (a): In an arithmetic progression, the first number in the series is called the initial term.
• Common difference (d): The value by which consecutive terms increase or decrease is called the common difference. The behavior of the arithmetic progression depends on the common difference d. If the common difference is: positive, then the members (terms) will grow towards positive infinity or negative, then the members (terms) will grow towards negative infinity.
• nth Term (a_n): The nth term of the AP series
• Sum of the first n terms (S_n): The sum of the first n terms of the AP series.

How do we check whether a series is an arithmetic progression or not?

1. Naive Approach. 

The idea is to sort the given array or series. After sorting, check if the differences between consecutive elements are the same or not. If all differences are the same, Arithmetic Progression is possible. 

Example: 

Given the array [6, 2, 8, 4], check if it can form an Arithmetic Progression (AP).

Steps:

1. Sort the Array
Sorted Array: [2, 4, 6, 8]

2. Find the Common Difference (d)
The common difference d is the difference between the first two elements of the sorted array.
d = arr[1] - arr[0] = 4 - 2 = 2

3. Check the Differences Between Consecutive Elements
Now, we check if the difference between each consecutive pair of elements in the sorted array is the same as the common difference d.
arr[2] - arr[1] = 6 - 4 = 2 (same as d)
arr[3] - arr[2] = 8 - 6 = 2 (same as d)

Since all the differences are the same, the array [6, 2, 8, 4] can form an Arithmetic Progression (AP) with a common difference of 2.

Below is the implementation of this approach: 

// C++ program to check if a given array
// can form arithmetic progression
#include <bits/stdc++.h>
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;
}

#include <stdio.h>
#include <stdlib.h>

// Returns true if a permutation of arr[0..n-1]
// can form arithmetic progression
int checkIsAP(int arr[], int n)
{
    if (n == 1)
        return 1;

    // Sort array
    qsort(arr, n, sizeof(int), cmp);

    // 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 0;

    return 1;
}

// Comparison function for qsort
int cmp(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// Driven Program
int main()
{
    int arr[] = { 20, 15, 5, 0, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);

    (checkIsAP(arr, n)) ? (printf("Yes\n")) : (printf("No\n"));

    return 0;
}

// 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 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# 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.

<script>
// Javascript 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
function compare(a, b) {
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else {
        return 0;
    }
}
function checkIsAP( arr, n){
    if (n == 1)
        return true;

    // Sort array
    arr.sort(compare);

    // After sorting, difference between
    // consecutive elements must be same.
    let d = arr[1] - arr[0];
    for (let i = 2; i < n; i++)
        if (arr[i] - arr[i - 1] != d)
            return false;

    return true;
}

// Driven Program
let arr = [ 20, 15, 5, 0, 10 ];
let n = arr.length;
(checkIsAP(arr, n)) ? document.write("Yes <br>") : document.write("No <br>");

</script>

<?php
// PHP 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
function checkIsAP($arr, $n)
{
    if ($n == 1)
        return true;
    
    // Sort array
    sort($arr);
    
    // After sorting, difference
    // between consecutive elements
    // must be same.
    $d = $arr[1] - $arr[0];
    for ($i = 2; $i < $n; $i++)
        if ($arr[$i] - 
            $arr[$i - 1] != $d)
        return false;
    
    return true;
}

// Driver Code
$arr = array(20, 15, 5, 0, 10);
$n = count($arr);

if(checkIsAP($arr, $n))
echo "Yes"; 
else
echo "No";
                        
// This code is contributed 
// by Sam007
?>

Yes

Time Complexity: O(n Log n). 
Auxiliary Space: O(1)

2. Efficient Approaches 

Efficient Solutions can include approaches like - Hashing, Counting Sort, Hashing with simple pass. For implementation of the efficient approaches, please refer - Check whether Arithmetic Progression can be formed from the given array

Basic Program related to Arithmetic Progression 

• Program for sum of arithmetic series
• Program to print Arithmetic Progression series
• Longest arithmetic progression with the given common difference
• Check whether Arithmetic Progression can be formed from the given array
• Find the missing number in Arithmetic Progression
• Find N Arithmetic Means between A and B
• Sum of the numbers upto N that are divisible by 2 or 5
• Find First element in AP which is multiple of given prime

More problems related to Arithmetic Progression 

• Sum of first n terms of a given series 3, 6, 11, …..
• Ratio of mth and nth terms of an A. P. with given ratio of sums
• Probability for three randomly chosen numbers to be in AP
• Print all triplets in sorted array that form AP
• Program for N-th term of Arithmetic Progression series
• Sum of Arithmetic Geometric Sequence
• Count of AP (Arithmetic Progression) Subsequences in an array

Recent Articles on Arithmetic Progression!