Given the three integers **N**, **X**, and **Y **the task is to find an **N** length arithmetic progression series with the least possible first term containing **X** and **Y**.

**Examples:**

Input:N = 5, X = 10, Y = 15Output:5 10 15 20 25Explanation:

The least possible first term of the AP is 5. Common difference of AP = 5

The given AP contains 10 and 15.

Input:N = 10, X = 5, Y = 15Output:1 3 5 7 9 11 13 15 17 19

**Naive Approach: **The simplest approach is to iterate for all the values of possible common differences from 1 to **abs(X-Y)** and check if there exists an **N** length AP with the first term greater than 0 and containing both **X** and **Y**.

**Time Complexity: **O(N * abs(X-Y)) **Auxiliary Space:** O(1)

**Efficient Approach: **The approach is based on the idea that to include both X and Y in the series, the common difference of the AP must be a factor of **abs(X-Y)**. Below are the steps to solve the problem:

- Iterate from
**1**to**sqrt(abs(X-Y))**and consider only those common differences which are factors of**abs(X-Y)**. - For every possible common difference say
**diff**which divides**abs(X-Y)**, find the minimum first term greater than 0 using binary search algorithm. - Store the minimum first term and the corresponding common difference to print the
**N**length Arithmetic Progression.

Below is the implementation of the above approach:

## C++

`// C++ program for the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function that finds the minimum` `// positive first term including X with given` `// common difference and the number of terms` `int` `minFirstTerm(` `int` `X, ` `int` `diff, ` `int` `N)` `{` ` ` `// Stores the first term` ` ` `int` `first_term;` ` ` `// Initialize the low and high` ` ` `int` `low = 0, high = N;` ` ` `// Perform binary search` ` ` `while` `(low <= high) {` ` ` `// Find the mid` ` ` `int` `mid = (low + high) / 2;` ` ` `// Check if first term is` ` ` `// greater than 0` ` ` `if` `(X - mid * diff > 0) {` ` ` `// Store the possible first term` ` ` `first_term = X - mid * diff;` ` ` `// Search between mid + 1 to high` ` ` `low = mid + 1;` ` ` `}` ` ` `else` ` ` `// Search between low to mid-1` ` ` `high = mid - 1;` ` ` `}` ` ` `// Return the minimum first term` ` ` `return` `first_term;` `}` `// Function that finds the Arithmetic` `// Progression with minimum possible` `// first term containing X and Y` `void` `printAP(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` `// Considering X to be` ` ` `// smaller than Y always` ` ` `if` `(X > Y)` ` ` `swap(X, Y);` ` ` `// Stores the max common difference` ` ` `int` `maxDiff = Y - X;` ` ` `// Stores the minimum first term` ` ` `// and the corresponding common` ` ` `// difference of the resultant AP` ` ` `int` `first_term = INT_MAX, diff;` ` ` `// Iterate over all the common difference` ` ` `for` `(` `int` `i = 1; i * i <= maxDiff; i++) {` ` ` `// Check if X and Y is included` ` ` `// for current common difference` ` ` `if` `(maxDiff % i == 0) {` ` ` `// Store the possible` ` ` `// common difference` ` ` `int` `diff1 = i;` ` ` `int` `diff2 = maxDiff / diff1;` ` ` `// Number of terms from` ` ` `// X to Y with diff1` ` ` `// common difference` ` ` `int` `terms1 = diff2 + 1;` ` ` `// Number of terms from` ` ` `// X to Y with diff2` ` ` `// common difference` ` ` `int` `terms2 = diff1 + 1;` ` ` `// Find the corresponding first` ` ` `// terms with diff1 and diff2` ` ` `int` `first_term1` ` ` `= minFirstTerm(X, diff1, N - terms1);` ` ` `int` `first_term2` ` ` `= minFirstTerm(X, diff2, N - terms2);` ` ` `// Store the minimum first term` ` ` `// and the corresponding` ` ` `// common difference` ` ` `if` `(first_term1 < first_term) {` ` ` `first_term = first_term1;` ` ` `diff = diff1;` ` ` `}` ` ` `if` `(first_term2 < first_term) {` ` ` `first_term = first_term2;` ` ` `diff = diff2;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the resultant AP` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `cout << first_term << ` `" "` `;` ` ` `first_term += diff;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given length of AP` ` ` `// and the two terms` ` ` `int` `N = 5, X = 10, Y = 15;` ` ` `// Function Call` ` ` `printAP(N, X, Y);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program for the approach` `import` `java.util.*;` `class` `GFG{` `// Function that finds the minimum` `// positive first term including X ` `// with given common difference and ` `// the number of terms` `static` `int` `minFirstTerm(` `int` `X, ` `int` `diff, ` `int` `N)` `{` ` ` `// Stores the first term` ` ` `int` `first_term = Integer.MAX_VALUE;` ` ` `// Initialize the low and high` ` ` `int` `low = ` `0` `, high = N;` ` ` `// Perform binary search` ` ` `while` `(low <= high)` ` ` `{` ` ` `// Find the mid` ` ` `int` `mid = (low + high) / ` `2` `;` ` ` `// Check if first term is` ` ` `// greater than 0` ` ` `if` `(X - mid * diff > ` `0` `)` ` ` `{` ` ` `// Store the possible first term` ` ` `first_term = X - mid * diff;` ` ` `// Search between mid + 1 to high` ` ` `low = mid + ` `1` `;` ` ` `}` ` ` `else` ` ` `// Search between low to mid-1` ` ` `high = mid - ` `1` `;` ` ` `}` ` ` `// Return the minimum first term` ` ` `return` `first_term;` `}` `// Function that finds the Arithmetic` `// Progression with minimum possible` `// first term containing X and Y` `static` `void` `printAP(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` ` ` `// Considering X to be` ` ` `// smaller than Y always` ` ` `if` `(X > Y) ` ` ` `{` ` ` `X = X + Y;` ` ` `Y = X - Y;` ` ` `X = X - Y;` ` ` `}` ` ` `// Stores the max common difference` ` ` `int` `maxDiff = Y - X;` ` ` `// Stores the minimum first term` ` ` `// and the corresponding common` ` ` `// difference of the resultant AP` ` ` `int` `first_term = Integer.MAX_VALUE, diff = ` `0` `;` ` ` `// Iterate over all the common difference` ` ` `for` `(` `int` `i = ` `1` `; i * i <= maxDiff; i++)` ` ` `{` ` ` ` ` `// Check if X and Y is included` ` ` `// for current common difference` ` ` `if` `(maxDiff % i == ` `0` `) ` ` ` `{` ` ` `// Store the possible` ` ` `// common difference` ` ` `int` `diff1 = i;` ` ` `int` `diff2 = maxDiff / diff1;` ` ` `// Number of terms from` ` ` `// X to Y with diff1` ` ` `// common difference` ` ` `int` `terms1 = diff2 + ` `1` `;` ` ` `// Number of terms from` ` ` `// X to Y with diff2` ` ` `// common difference` ` ` `int` `terms2 = diff1 + ` `1` `;` ` ` `// Find the corresponding first` ` ` `// terms with diff1 and diff2` ` ` `int` `first_term1 = minFirstTerm(X, diff1,` ` ` `N - terms1);` ` ` `int` `first_term2 = minFirstTerm(X, diff2,` ` ` `N - terms2);` ` ` `// Store the minimum first term` ` ` `// and the corresponding` ` ` `// common difference` ` ` `if` `(first_term1 < first_term)` ` ` `{` ` ` `first_term = first_term1;` ` ` `diff = diff1;` ` ` `}` ` ` `if` `(first_term2 < first_term) ` ` ` `{` ` ` `first_term = first_term2;` ` ` `diff = diff2;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the resultant AP` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++)` ` ` `{` ` ` `System.out.print(first_term + ` `" "` `);` ` ` `first_term += diff;` ` ` `}` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` ` ` `// Given length of AP` ` ` `// and the two terms` ` ` `int` `N = ` `5` `, X = ` `10` `, Y = ` `15` `;` ` ` `// Function call` ` ` `printAP(N, X, Y);` `}` `}` `// This code is contributed by Amit Katiyar` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program for the approach` `import` `sys` `# Function that finds the minimum` `# positive first term including X with given` `# common difference and the number of terms` `def` `minFirstTerm(X, diff, N):` ` ` `# Stores the first term` ` ` `first_term_1 ` `=` `sys.maxsize` ` ` `# Initialize the low and high` ` ` `low ` `=` `0` ` ` `high ` `=` `N` ` ` `# Perform binary search` ` ` `while` `(low <` `=` `high):` ` ` `# Find the mid` ` ` `mid ` `=` `(low ` `+` `high) ` `/` `/` `2` ` ` `# Check if first term is` ` ` `# greater than 0` ` ` `if` `(X ` `-` `mid ` `*` `diff > ` `0` `):` ` ` `# Store the possible first term` ` ` `first_term_1 ` `=` `X ` `-` `mid ` `*` `diff` ` ` `# Search between mid + 1 to high` ` ` `low ` `=` `mid ` `+` `1` ` ` `else` `:` ` ` `# Search between low to mid-1` ` ` `high ` `=` `mid ` `-` `1` ` ` `# Return the minimum first term` ` ` `return` `first_term_1` `# Function that finds the Arithmetic` `# Progression with minimum possible` `# first term containing X and Y` `def` `printAP(N, X, Y):` ` ` ` ` `# Considering X to be` ` ` `# smaller than Y always` ` ` `if` `(X > Y):` ` ` `X ` `=` `X ` `+` `Y` ` ` `Y ` `=` `X ` `-` `Y` ` ` `X ` `=` `X ` `-` `Y` ` ` `# Stores the max common difference` ` ` `maxDiff ` `=` `Y ` `-` `X` ` ` `# Stores the minimum first term` ` ` `# and the corresponding common` ` ` `# difference of the resultant AP` ` ` `first_term ` `=` `sys.maxsize` ` ` `diff ` `=` `0` ` ` `# Iterate over all the common difference` ` ` `for` `i ` `in` `range` `(` `1` `, maxDiff ` `+` `1` `):` ` ` `if` `i ` `*` `i > maxDiff:` ` ` `break` ` ` `# Check if X and Y is included` ` ` `# for current common difference` ` ` `if` `(maxDiff ` `%` `i ` `=` `=` `0` `):` ` ` `# Store the possible` ` ` `# common difference` ` ` `diff1 ` `=` `i` ` ` `diff2 ` `=` `maxDiff ` `/` `/` `diff1` ` ` `# Number of terms from` ` ` `# X to Y with diff1` ` ` `# common difference` ` ` `terms1 ` `=` `diff2 ` `+` `1` ` ` `# Number of terms from` ` ` `# X to Y with diff2` ` ` `# common difference` ` ` `terms2 ` `=` `diff1 ` `+` `1` ` ` `# Find the corresponding first` ` ` `# terms with diff1 and diff2` ` ` `first_term1 ` `=` `minFirstTerm(X, diff1,` ` ` `N ` `-` `terms1)` ` ` `first_term2 ` `=` `minFirstTerm(X, diff2, ` ` ` `N ` `-` `terms2)` ` ` `# Store the minimum first term` ` ` `# and the corresponding` ` ` `# common difference` ` ` `if` `(first_term1 < first_term):` ` ` `first_term ` `=` `first_term1` ` ` `diff ` `=` `diff1` ` ` `if` `(first_term2 < first_term):` ` ` `first_term ` `=` `first_term2` ` ` `diff ` `=` `diff2` ` ` `# Print the resultant AP` ` ` `for` `i ` `in` `range` `(N):` ` ` `print` `(first_term, end ` `=` `" "` `)` ` ` `first_term ` `+` `=` `diff` ` ` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Given length of AP` ` ` `# and the two terms` ` ` `N ` `=` `5` ` ` `X ` `=` `10` ` ` `Y ` `=` `15` ` ` `# Function call` ` ` `printAP(N, X, Y)` `# This code is contributed by mohit kumar 29` |

*chevron_right*

*filter_none*

## C#

`// C# program for the approach` `using` `System;` `class` `GFG{` `// Function that finds the minimum` `// positive first term including X ` `// with given common difference and ` `// the number of terms` `static` `int` `minFirstTerm(` `int` `X, ` `int` `diff, ` ` ` `int` `N)` `{` ` ` `// Stores the first term` ` ` `int` `first_term = ` `int` `.MaxValue;` ` ` `// Initialize the low and high` ` ` `int` `low = 0, high = N;` ` ` `// Perform binary search` ` ` `while` `(low <= high)` ` ` `{` ` ` `// Find the mid` ` ` `int` `mid = (low + high) / 2;` ` ` `// Check if first term is` ` ` `// greater than 0` ` ` `if` `(X - mid * diff > 0)` ` ` `{` ` ` `// Store the possible first term` ` ` `first_term = X - mid * diff;` ` ` `// Search between mid + 1 to high` ` ` `low = mid + 1;` ` ` `}` ` ` `else` ` ` `// Search between low to mid-1` ` ` `high = mid - 1;` ` ` `}` ` ` `// Return the minimum first term` ` ` `return` `first_term;` `}` `// Function that finds the Arithmetic` `// Progression with minimum possible` `// first term containing X and Y` `static` `void` `printAP(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` ` ` `// Considering X to be` ` ` `// smaller than Y always` ` ` `if` `(X > Y) ` ` ` `{` ` ` `X = X + Y;` ` ` `Y = X - Y;` ` ` `X = X - Y;` ` ` `}` ` ` `// Stores the max common difference` ` ` `int` `maxDiff = Y - X;` ` ` `// Stores the minimum first term` ` ` `// and the corresponding common` ` ` `// difference of the resultant AP` ` ` `int` `first_term = ` `int` `.MaxValue, diff = 0;` ` ` `// Iterate over all the common difference` ` ` `for` `(` `int` `i = 1; i * i <= maxDiff; i++)` ` ` `{` ` ` ` ` `// Check if X and Y is included` ` ` `// for current common difference` ` ` `if` `(maxDiff % i == 0) ` ` ` `{` ` ` `// Store the possible` ` ` `// common difference` ` ` `int` `diff1 = i;` ` ` `int` `diff2 = maxDiff / diff1;` ` ` `// Number of terms from` ` ` `// X to Y with diff1` ` ` `// common difference` ` ` `int` `terms1 = diff2 + 1;` ` ` `// Number of terms from` ` ` `// X to Y with diff2` ` ` `// common difference` ` ` `int` `terms2 = diff1 + 1;` ` ` `// Find the corresponding first` ` ` `// terms with diff1 and diff2` ` ` `int` `first_term1 = minFirstTerm(X, diff1,` ` ` `N - terms1);` ` ` `int` `first_term2 = minFirstTerm(X, diff2,` ` ` `N - terms2);` ` ` `// Store the minimum first term` ` ` `// and the corresponding` ` ` `// common difference` ` ` `if` `(first_term1 < first_term)` ` ` `{` ` ` `first_term = first_term1;` ` ` `diff = diff1;` ` ` `}` ` ` `if` `(first_term2 < first_term) ` ` ` `{` ` ` `first_term = first_term2;` ` ` `diff = diff2;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print the resultant AP` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `{` ` ` `Console.Write(first_term + ` `" "` `);` ` ` `first_term += diff;` ` ` `}` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` ` ` `// Given length of AP` ` ` `// and the two terms` ` ` `int` `N = 5, X = 10, Y = 15;` ` ` `// Function call` ` ` `printAP(N, X, Y);` `}` `}` `// This code is contributed by Amit Katiyar` |

*chevron_right*

*filter_none*

**Output:**

5 10 15 20 25

**Time complexity: **O(sqrt(abs(X-Y)) * log(N)) **Auxiliary space: **O(1)

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:

- Nth term where K+1th term is product of Kth term with difference of max and min digit of Kth term
- Ratio of mth and nth term in an Arithmetic Progression (AP)
- Program for N-th term of Arithmetic Progression series
- Minimize Nth term of an Arithmetic progression (AP)
- First term from given Nth term of the equation F(N) = (2 * F(N - 1)) % 10^9 + 7
- Longest string in non-decreasing order of ASCII code and in arithmetic progression
- Program for N-th term of Geometric Progression series
- Longest Arithmetic Progression | DP-35
- Check whether Arithmetic Progression can be formed from the given array
- Count of AP (Arithmetic Progression) Subsequences in an array
- Minimum De-arrangements present in array of AP (Arithmetic Progression)
- Program to print Arithmetic Progression series
- PHP program to print an arithmetic progression series using inbuilt functions
- Longest arithmetic progression with the given common difference
- Convert given array to Arithmetic Progression by adding an element
- Arithmetic Progression
- Change one element in the given array to make it an Arithmetic Progression
- Check whether nodes of Binary Tree form Arithmetic, Geometric or Harmonic Progression
- Minimum elements inserted in a sorted array to form an Arithmetic progression
- Count common elements in two arrays which are in Arithmetic Progression

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.