Given an array which is an original arithmetic progression with one element changed. The task is to make it an arithmetic progression again. If there are many such possible sequences, return any one of them. The length of the array will always be greater than 2.

**Examples:**

Input :arr = [1, 3, 4, 7]

Output :arr = [1, 3, 5, 7]

The common difference for the arithmetic progression is 2, so the resulting

arithmetic progression is [1, 3, 5, 7].

Input :arr = [1, 3, 7]

Output :arr = [-1, 3, 7]

The common difference can be either 2 or 3 or 4.

Hence the resulting array can be either [1, 3, 5], [-1, 3, 7] or [1, 4, 7].

As any one can be chosen, [-1, 3, 7] is returned as the output.

**Approach:**

The key components of an Arithmetic Progression are initial term and the common difference. So our task is to find these two values to know the actual Arithmetic Progression.

- If the length of the array is 3, take the common difference as the difference between any two elements.
- Otherwise, try to find the common difference using the first four elements.
- Check if the first three elements are in arithmetic progression using the formula a[1] – a[0] = a[2] – a[1]. If they are in arithmetic progression, the common difference d = a[1] – a[0] and the initial term would be a[0]
- Check if the 2nd, 3rd and 4th elements are in arithmetic progression using the formula a[2] – a[1] = a[3] – a[2]. If they are in arithmetic progression, the common difference d = a[2] – a[1], which means that the first element has been changed, so initial term is a[0] = a[1] – d
- In both of the above cases, we have checked if the first element or fourth element has been changed. If both the cases are false, then it means that first or fourth element was not changed. So the common difference can be taken as d = (a[3] – a[0])/3 and the initial term = a[0]

- Print all the elements using the initial term and common difference.

Below is the implementation of the above approach:

## C/C++

`// C++ program to change one element of an array such ` `// that the resulting array is in arithmetic progression. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Finds the initial term and common difference and ` `// prints the resulting sequence. ` `void` `makeAP(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `int` `initial_term, common_difference; ` ` ` ` ` `if` `(n == 3) { ` ` ` `common_difference = arr[2] - arr[1]; ` ` ` `initial_term = arr[1] - common_difference; ` ` ` `} ` ` ` ` ` `else` `if` `((arr[1] - arr[0]) == arr[2] - arr[1]) { ` ` ` ` ` `// Check if the first three elements are in ` ` ` `// arithmetic progression ` ` ` `initial_term = arr[0]; ` ` ` `common_difference = arr[1] - arr[0]; ` ` ` `} ` ` ` `else` `if` `((arr[2] - arr[1]) == (arr[3] - arr[2])) { ` ` ` ` ` `// Check if the first element is not ` ` ` `// in arithmetic progression ` ` ` `common_difference = arr[2] - arr[1]; ` ` ` `initial_term = arr[1] - common_difference; ` ` ` `} ` ` ` `else` `{ ` ` ` ` ` `// The first and fourth element are ` ` ` `// in arithmetic progression ` ` ` `common_difference = (arr[3] - arr[0]) / 3; ` ` ` `initial_term = arr[0]; ` ` ` `} ` ` ` ` ` `// Print the arithmetic progression ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `cout << initial_term + (i * common_difference) << ` `" "` `; ` ` ` `cout << endl; ` `} ` ` ` `// Driver Program ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 3, 7 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `makeAP(arr, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to change one element of an array such ` `// that the resulting array is in arithmetic progression. ` `import` `java.util.Arrays; ` ` ` `class` `AP { ` ` ` `static` `void` `makeAP(` `int` `arr[], ` `int` `n) ` ` ` `{ ` ` ` `int` `initial_term, common_difference; ` ` ` ` ` `// Finds the initial term and common difference and ` ` ` `// prints the resulting array. ` ` ` `if` `(n == ` `3` `) { ` ` ` `common_difference = arr[` `2` `] - arr[` `1` `]; ` ` ` `initial_term = arr[` `1` `] - common_difference; ` ` ` `} ` ` ` `else` `if` `((arr[` `1` `] - arr[` `0` `]) == arr[` `2` `] - arr[` `1` `]) { ` ` ` ` ` `// Check if the first three elements are in ` ` ` `// arithmetic progression ` ` ` `initial_term = arr[` `0` `]; ` ` ` `common_difference = arr[` `1` `] - arr[` `0` `]; ` ` ` `} ` ` ` `else` `if` `((arr[` `2` `] - arr[` `1` `]) == (arr[` `3` `] - arr[` `2` `])) { ` ` ` `// Check if the first element is not ` ` ` `// in arithmetic progression ` ` ` `common_difference = arr[` `2` `] - arr[` `1` `]; ` ` ` `initial_term = arr[` `1` `] - common_difference; ` ` ` `} ` ` ` `else` `{ ` ` ` `// The first and fourth element are ` ` ` `// in arithmetic progression ` ` ` `common_difference = (arr[` `3` `] - arr[` `0` `]) / ` `3` `; ` ` ` `initial_term = arr[` `0` `]; ` ` ` `} ` ` ` ` ` `// Print the arithmetic progression ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `System.out.print(initial_term + ` ` ` `(i * common_difference) + ` `" "` `); ` ` ` `System.out.println(); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `arr[] = { ` `1` `, ` `3` `, ` `7` `}; ` ` ` `int` `n = arr.length; ` ` ` `makeAP(arr, n); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python program to change one element of an array such ` `# that the resulting array is in arithmetic progression. ` `def` `makeAP(arr, n): ` ` ` `initial_term, common_difference ` `=` `0` `, ` `0` ` ` `if` `(n ` `=` `=` `3` `): ` ` ` `common_difference ` `=` `arr[` `2` `] ` `-` `arr[` `1` `] ` ` ` `initial_term ` `=` `arr[` `1` `] ` `-` `common_difference ` ` ` `elif` `((arr[` `1` `] ` `-` `arr[` `0` `]) ` `=` `=` `arr[` `2` `] ` `-` `arr[` `1` `]): ` ` ` ` ` `# Check if the first three elements are in ` ` ` `# arithmetic progression ` ` ` `initial_term ` `=` `arr[` `0` `] ` ` ` `common_difference ` `=` `arr[` `1` `] ` `-` `arr[` `0` `] ` ` ` ` ` `elif` `((arr[` `2` `] ` `-` `arr[` `1` `]) ` `=` `=` `(arr[` `3` `] ` `-` `arr[` `2` `])): ` ` ` ` ` `# Check if the first element is not ` ` ` `# in arithmetic progression ` ` ` `common_difference ` `=` `arr[` `2` `] ` `-` `arr[` `1` `] ` ` ` `initial_term ` `=` `arr[` `1` `] ` `-` `common_difference ` ` ` ` ` `else` `: ` ` ` `# The first and fourth element are ` ` ` `# in arithmetic progression ` ` ` `common_difference ` `=` `(arr[` `3` `] ` `-` `arr[` `0` `]) ` `/` `3` ` ` `initial_term ` `=` `arr[` `0` `] ` ` ` ` ` `# Print the arithmetic progression ` ` ` `for` `i ` `in` `range` `(n): ` ` ` `print` `(` `int` `(initial_term` `+` ` ` `(i ` `*` `common_difference)), end ` `=` `" "` `) ` ` ` `print` `() ` ` ` `# Driver code ` `arr ` `=` `[` `1` `, ` `3` `, ` `7` `] ` `n ` `=` `len` `(arr) ` `makeAP(arr, n) ` |

*chevron_right*

*filter_none*

## C#

`// C# program to change one element of an array such ` `// that the resulting array is in arithmetic progression. ` `using` `System; ` ` ` `public` `class` `AP ` `{ ` ` ` `static` `void` `makeAP(` `int` `[]arr, ` `int` `n) ` ` ` `{ ` ` ` `int` `initial_term, common_difference; ` ` ` ` ` `// Finds the initial term and common difference and ` ` ` `// prints the resulting array. ` ` ` `if` `(n == 3) ` ` ` `{ ` ` ` `common_difference = arr[2] - arr[1]; ` ` ` `initial_term = arr[1] - common_difference; ` ` ` `} ` ` ` `else` `if` `((arr[1] - arr[0]) == arr[2] - arr[1]) ` ` ` `{ ` ` ` ` ` `// Check if the first three elements are in ` ` ` `// arithmetic progression ` ` ` `initial_term = arr[0]; ` ` ` `common_difference = arr[1] - arr[0]; ` ` ` `} ` ` ` `else` `if` `((arr[2] - arr[1]) == (arr[3] - arr[2])) ` ` ` `{ ` ` ` `// Check if the first element is not ` ` ` `// in arithmetic progression ` ` ` `common_difference = arr[2] - arr[1]; ` ` ` `initial_term = arr[1] - common_difference; ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `// The first and fourth element are ` ` ` `// in arithmetic progression ` ` ` `common_difference = (arr[3] - arr[0]) / 3; ` ` ` `initial_term = arr[0]; ` ` ` `} ` ` ` ` ` `// Print the arithmetic progression ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `Console.Write(initial_term + ` ` ` `(i * common_difference) + ` `" "` `); ` ` ` `Console.WriteLine(); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main(String[] args) ` ` ` `{ ` ` ` `int` `[]arr = { 1, 3, 7 }; ` ` ` `int` `n = arr.Length; ` ` ` `makeAP(arr, n); ` ` ` `} ` `} ` ` ` `// This code contributed by Rajput-Ji ` |

*chevron_right*

*filter_none*

**Output:**

-1 3 7

**Time Complexity**: O(N), where N is the number of elements in the array.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Convert given array to Arithmetic Progression by adding an element
- Check whether Arithmetic Progression can be formed from the given array
- Longest arithmetic progression with the given common difference
- Count of AP (Arithmetic Progression) Subsequences in an array
- Minimum De-arrangements present in array of AP (Arithmetic Progression)
- Minimum elements inserted in a sorted array to form an Arithmetic progression
- Longest Arithmetic Progression | DP-35
- Find the missing number in Arithmetic Progression
- Program for N-th term of Arithmetic Progression series
- Program to print Arithmetic Progression series
- PHP program to print an arithmetic progression series using inbuilt functions
- Longest string in non-decreasing order of ASCII code and in arithmetic progression
- Ratio of mth and nth term in an Arithmetic Progression (AP)
- Arithmetic Progression
- Check whether nodes of Binary Tree form Arithmetic, Geometric or Harmonic Progression
- Count common elements in two arrays which are in Arithmetic Progression
- Find the missing number in unordered Arithmetic Progression
- Count of subarrays forming an Arithmetic Progression (AP)
- Longest subarray forming an Arithmetic Progression (AP)
- Arithmetic Progression containing X and Y with least possible first term

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.