Arithmetic Progression containing X and Y with least possible first term

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 = 15 
Output: 5 10 15 20 25 
Explanation: 
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 = 15 
Output: 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:

  1. Iterate from 1 to sqrt(abs(X-Y)) and consider only those common differences which are factors of abs(X-Y).
  2. For every possible common difference say diff which divides abs(X-Y), find the minimum first term greater than 0 using binary search algorithm.
  3. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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


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.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.