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

• Last Updated : 29 Nov, 2021

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 ` `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 ans = ``new` `ArrayList();`   `        ``// 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

 ``

Output

`20 30 40 50 10 `

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :