Skip to content
Related Articles

Related Articles

Find the Array which when sorted forms an AP and has minimum maximum

View Discussion
Improve Article
Save Article
  • Last Updated : 29 Nov, 2021
View Discussion
Improve Article
Save Article

Given three positive integers N, X, and Y(X<Y). The task is to find an array of length N containing both X and Y, and when sorted in increasing order, the array must form an arithmetic progression

Examples:

Input: N = 5, X = 20, Y = 50
Output: 20 30 40 50 10 
Explanation: The array when sorted in increasing order forms an arithmetic progression with common difference 10.

Input: N = 17, X = 23445, Y = 1000000
Output: 23445 218756 414067 609378 804689 1000000 1195311 1390622 1585933 1781244 1976555 2171866 2367177 2562488 2757799 2953110 3148421 
Explanation: The array when sorted in increasing order forms an arithmetic progression with common difference 195311.

 

Approach: In this problem, it can be observed that if the maximum element is to be minimized, then it can be assumed that Y should be the greatest element. If Y is the greatest, then each of the remaining elements will be less than or equal to Y. If Y is not the greatest element in the array, then elements greater than Y can be considered.

Follow the steps below to solve the given problem:

  • Check if some elements which have a common difference are present between X and Y. For this, check if (Y-X) is divisible by (N-1). If it is divisible, then decrease N and the common difference d is given by:

d = (Y-X)/(N-1)

  • If it is not divisible, then decrease (n-1) and repeat the above step in a loop till the denominator is non-zero.
  • If there don’t exist any such elements between X and Y, then the common difference d is given by:

d = (Y-X)

  • Let the resultant array be stored in vector ans. Push the elements found between X and Y in the vector ans to use a for loop.
  • If N is not equal to zero, insert the elements in ans starting from (X-d) with common difference d.
  • If N is equal to zero, output ans. Otherwise, insert the elements in ans starting from (Y+d) till the required array is obtained.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the array which when
// sorted forms an arithmetic progression
// and has the minimum possible maximum element
void findArray(int N, int X, int Y)
{
    // Stores the difference of Y and X
    int r = Y - X;
 
    // To indicate the absence of required
    // elements between X and Y
    int d = -1;
 
    // Stores the number of required elements
    // present between X and Y
    int num = 0;
 
    // Loop to find the number of required
    // elements between X and Y
    for (int i = (N - 1); i > 0; i--) {
 
        // If r is divisible by i
        if (r % i == 0) {
 
            // Stores the common difference
            // of the elements
            d = r / i;
 
            // Decrease num by 1
            num = i - 1;
 
            // Break from the loop
            break;
        }
    }
 
    // If the number of elements present
    // between X and Y is zero
    if (d == -1) {
 
        // Update common difference
        d = Y - X;
    }
 
    // Update N
    N = N - 2 - num;
 
    // Stores the resultant array
    vector<int> ans;
 
    // Loop to insert the found elements
    // in the resultant vector
    for (int i = X; i <= Y; i += d) {
        ans.push_back(i);
    }
 
    // Stores the element to be inserted in
    // the resultant vector
    int i = X;
 
    // Loop to insert elements less than X
    // in the resultant vector
    while (N > 0 && i > 0) {
        i = i - d;
 
        // i must be positive
        if (i > 0) {
            ans.push_back(i);
 
            // Update N
            N--;
        }
    }
 
    // Stores the element to be inserted in
    // the resultant vector
    i = Y;
 
    // Loop to insert elements greater than Y
    // in the resultant vector
    while (N > 0) {
        i = i + d;
        ans.push_back(i);
 
        // Update N
        N--;
    }
 
    // Output the required array
    for (int i = 0; i < ans.size(); ++i) {
        cout << ans[i] << " ";
    }
}
 
// Driver Code
int main()
{
    // Given N, X and Y
    int N = 5, X = 20, Y = 50;
 
    // Function Call
    findArray(N, X, Y);
 
    return 0;
}


Java




// Java program for the above approach
import java.util.ArrayList;
 
class GFG {
 
    // Function to find the array which when
    // sorted forms an arithmetic progression
    // and has the minimum possible maximum element
    static void findArray(int N, int X, int Y) {
 
        // Stores the difference of Y and X
        int r = Y - X;
 
        // To indicate the absence of required
        // elements between X and Y
        int d = -1;
 
        // Stores the number of required elements
        // present between X and Y
        int num = 0;
 
        // Loop to find the number of required
        // elements between X and Y
        for (int i = (N - 1); i > 0; i--) {
 
            // If r is divisible by i
            if (r % i == 0) {
 
                // Stores the common difference
                // of the elements
                d = r / i;
 
                // Decrease num by 1
                num = i - 1;
 
                // Break from the loop
                break;
            }
        }
 
        // If the number of elements present
        // between X and Y is zero
        if (d == -1) {
 
            // Update common difference
            d = Y - X;
        }
 
        // Update N
        N = N - 2 - num;
 
        // Stores the resultant array
        ArrayList<Integer> ans = new ArrayList<Integer>();
 
        // Loop to insert the found elements
        // in the resultant vector
        for (int i = X; i <= Y; i += d) {
            ans.add(i);
        }
 
        // Stores the element to be inserted in
        // the resultant vector
        int j = X;
 
        // Loop to insert elements less than X
        // in the resultant vector
        while (N > 0 && j > 0) {
            j = j - d;
 
            // i must be positive
            if (j > 0) {
                ans.add(j);
 
                // Update N
                N--;
            }
        }
 
        // Stores the element to be inserted in
        // the resultant vector
        j = Y;
 
        // Loop to insert elements greater than Y
        // in the resultant vector
        while (N > 0) {
            j = j + d;
            ans.add(j);
 
            // Update N
            N--;
        }
 
        // Output the required array
        for (int i = 0; i < ans.size(); ++i) {
            System.out.print(ans.get(i) + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
       
        // Given N, X and Y
        int N = 5, X = 20, Y = 50;
 
        // Function Call
        findArray(N, X, Y);
    }
}
 
 // This code is contributed by gfgking.


Python3




# python program for the above approach
 
# Function to find the array which when
# sorted forms an arithmetic progression
# and has the minimum possible maximum element
def findArray(N, X, Y):
 
    # Stores the difference of Y and X
    r = Y - X
 
    # To indicate the absence of required
    # elements between X and Y
    d = -1
 
    # Stores the number of required elements
    # present between X and Y
    num = 0
 
    # Loop to find the number of required
    # elements between X and Y
    for i in range(N - 1, 0, -1):
 
        # If r is divisible by i
        if (r % i == 0):
 
            # Stores the common difference
            # of the elements
            d = r // i
 
            # Decrease num by 1
            num = i - 1
 
            # Break from the loop
            break
 
    # If the number of elements present
    # between X and Y is zero
    if (d == -1):
 
        # Update common difference
        d = Y - X
 
    # Update N
    N = N - 2 - num
 
    # Stores the resultant array
    ans = []
 
    # Loop to insert the found elements
    # in the resultant vector
    for i in range(X, Y + 1, d):
        ans.append(i)
 
    # Stores the element to be inserted in
    # the resultant vector
    i = X
 
    # Loop to insert elements less than X
    # in the resultant vector
    while (N > 0 and i > 0):
        i = i - d
 
        # i must be positive
        if (i > 0):
            ans.append(i)
 
            # Update N
            N -= 1
 
    # Stores the element to be inserted in
    # the resultant vector
    i = Y
 
    # Loop to insert elements greater than Y
    # in the resultant vector
    while (N > 0):
        i = i + d
        ans.append(i)
 
        # Update N
        N -= 1
 
    # Output the required array
    for i in range(0, len(ans)):
        print(ans[i], end=" ")
 
# Driver Code
if __name__ == "__main__":
 
    # Given N, X and Y
    N = 5
    X = 20
    Y = 50
 
    # Function Call
    findArray(N, X, Y)
 
    # This code is contributed by rakeshsahni


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG
{
   
// Function to find the array which when
// sorted forms an arithmetic progression
// and has the minimum possible maximum element
static void findArray(int N, int X, int Y)
{
   
    // Stores the difference of Y and X
    int r = Y - X;
 
    // To indicate the absence of required
    // elements between X and Y
    int d = -1;
 
    // Stores the number of required elements
    // present between X and Y
    int num = 0;
 
    // Loop to find the number of required
    // elements between X and Y
    for (int i = (N - 1); i > 0; i--) {
 
        // If r is divisible by i
        if (r % i == 0) {
 
            // Stores the common difference
            // of the elements
            d = r / i;
 
            // Decrease num by 1
            num = i - 1;
 
            // Break from the loop
            break;
        }
    }
 
    // If the number of elements present
    // between X and Y is zero
    if (d == -1) {
 
        // Update common difference
        d = Y - X;
    }
 
    // Update N
    N = N - 2 - num;
 
    // Stores the resultant array
    List<int> ans = new List<int>();
 
    // Loop to insert the found elements
    // in the resultant vector
    for (int i = X; i <= Y; i += d) {
        ans.Add(i);
    }
 
    // Stores the element to be inserted in
    // the resultant vector
    int j = X;
 
    // Loop to insert elements less than X
    // in the resultant vector
    while (N > 0 && j > 0) {
        j = j - d;
 
        // i must be positive
        if (j > 0) {
            ans.Add(j);
 
            // Update N
            N--;
        }
    }
 
    // Stores the element to be inserted in
    // the resultant vector
    j = Y;
 
    // Loop to insert elements greater than Y
    // in the resultant vector
    while (N > 0) {
        j = j + d;
        ans.Add(j);
 
        // Update N
        N--;
    }
 
    // Output the required array
    for (int i = 0; i < ans.Count; ++i) {
        Console.Write( ans[i] + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    // Given N, X and Y
    int N = 5, X = 20, Y = 50;
 
    // Function Call
    findArray(N, X, Y);
}
}
 
// This code is contributed by code_hunt.


Javascript




<script>
 
       // JavaScript Program to implement
       // the above approach
 
       // Function to find the array which when
       // sorted forms an arithmetic progression
       // and has the minimum possible maximum element
       function findArray(N, X, Y)
       {
        
           // Stores the difference of Y and X
           let r = Y - X;
 
           // To indicate the absence of required
           // elements between X and Y
           let d = -1;
 
           // Stores the number of required elements
           // present between X and Y
           let num = 0;
 
           // Loop to find the number of required
           // elements between X and Y
           for (let i = (N - 1); i > 0; i--) {
 
               // If r is divisible by i
               if (r % i == 0) {
 
                   // Stores the common difference
                   // of the elements
                   d = r / i;
 
                   // Decrease num by 1
                   num = i - 1;
 
                   // Break from the loop
                   break;
               }
           }
 
           // If the number of elements present
           // between X and Y is zero
           if (d == -1) {
 
               // Update common difference
               d = Y - X;
           }
 
           // Update N
           N = N - 2 - num;
 
           // Stores the resultant array
           let ans = [];
 
           // Loop to insert the found elements
           // in the resultant vector
           for (let i = X; i <= Y; i += d) {
               ans.push(i);
           }
 
           // Stores the element to be inserted in
           // the resultant vector
           let i = X;
 
           // Loop to insert elements less than X
           // in the resultant vector
           while (N > 0 && i > 0) {
               i = i - d;
 
               // i must be positive
               if (i > 0) {
                   ans.push(i);
 
                   // Update N
                   N--;
               }
           }
 
           // Stores the element to be inserted in
           // the resultant vector
           i = Y;
 
           // Loop to insert elements greater than Y
           // in the resultant vector
           while (N > 0) {
               i = i + d;
               ans.push(i);
 
               // Update N
               N--;
           }
 
           // Output the required array
           for (let i = 0; i < ans.length; ++i) {
               document.write(ans[i] + " ");
           }
       }
 
       // Driver Code
 
       // Given N, X and Y
       let N = 5, X = 20, Y = 50;
 
       // Function Call
       findArray(N, X, Y);
 
   // This code is contributed by Potta Lokesh
   </script>


Output

20 30 40 50 10 

Time Complexity: O(N)
Auxiliary Space: O(N)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!