 Open in App
Not now

# Lexicographically largest N-length Bitonic sequence made up of elements from given range

• Last Updated : 01 Jun, 2021

Given three integers N, low and high, the task is to find the lexicographically largest bitonic sequence consisting of N elements lying in the range [low, high]. If it is not possible to generate such a sequence, then print “Not Possible”.

Examples:

Input: N = 5, low = 2, high = 6
Output: 5 6 5 4 3
Explanation:
The sequence {arr, arr} is strictly increasing followed by strictly decreasing sequence of the remaining elements. This sequence is the lexicographically largest possible having all elements in the range [2, 6] and length of this sequence is 5.

Input: N = 10, low = 4, high = 10
Output: 7 8 9 10 9 8 7 6 5 4

Approach: The idea is to find the suitable index of high in the resultant sequence and then maintain a difference of 1 between adjacent elements in the sequence such that the bitonic sequence formed is the lexicographically largest possible. Follow the steps below to solve the problem:

• Initialize an array A[] of size N to store the resultant sequence.
• Initialize a variable high_index = -1 to store the index of high in A[] and set high_index = N – (high – low + 1).
• If high_index > (N – 1) / 2, then the remaining N/2 elements cannot be placed in strictly increasing order. So, print “Not Possible”.
• Otherwise, perform the following steps:
• If high_index ≤ 0, then set high_index = 1 as there has to be a strictly increasing sequence at the beginning.
• Maintain a strictly decreasing sequence with a difference of 1 from the range [high_index, 0], starting with a value high.
• Maintain a strictly decreasing sequence with a difference of 1 from the range[high_index + 1, N – 1] starting with a value (high – 1).
• After completing the above steps, print all the elements in array A[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the lexicographically``// largest bitonic sequence of size N``// elements lies in the range[low, high]``void` `LargestArray(``int` `N, ``int` `low, ``int` `high)``{``    ``// Store index of highest element``    ``int` `high_index = N - (high - low + 1);` `    ``// If high_index > (N-1)/2, then``    ``// remaining N/2 elements cannot``    ``// be placed in bitonic order``    ``if` `(high_index > (N - 1) / 2) {``        ``cout << ``"Not Possible"``;``        ``return``;``    ``}` `    ``// If high_index <= 0, then``    ``// set high_index as 1``    ``if` `(high_index <= 0)``        ``high_index = 1;` `    ``// Stores the resultant sequence``    ``int` `A[N];` `    ``// Store the high value``    ``int` `temp = high;` `    ``// Maintain strictly decreasing``    ``// sequence from index high_index``    ``// to 0 starting with temp``    ``for` `(``int` `i = high_index; i >= 0; i--) {` `        ``// Store the value and decrement``        ``// the temp variable by 1``        ``A[i] = temp--;``    ``}` `    ``// Maintain the strictly decreasing``    ``// sequence from index high_index + 1``    ``// to N - 1 starting with high - 1``    ``high -= 1;` `    ``for` `(``int` `i = high_index + 1; i < N; i++)` `        ``// Store the value and decrement``        ``// high by 1``        ``A[i] = high--;` `    ``// Print the resultant sequence``    ``for` `(``int` `i = 0; i < N; i++) {``        ``cout << A[i] << ``' '``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 5, low = 2, high = 6;` `    ``// Function Call``    ``LargestArray(N, low, high);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``  ` `class` `GFG{``    ` `// Function to find the lexicographically``// largest bitonic sequence of size N``// elements lies in the range[low, high]``static` `void` `LargestArray(``int` `N, ``int` `low,``                         ``int` `high)``{``    ` `    ``// Store index of highest element``    ``int` `high_index = N - (high - low + ``1``);``    ` `    ``// If high_index > (N-1)/2, then``    ``// remaining N/2 elements cannot``    ``// be placed in bitonic order``    ``if` `(high_index > (N - ``1``) / ``2``)``    ``{``        ``System.out.print(``"Not Possible"``);``        ``return``;``    ``}``    ` `    ``// If high_index <= 0, then``    ``// set high_index as 1``    ``if` `(high_index <= ``0``)``        ``high_index = ``1``;``        ` `    ``// Stores the resultant sequence``    ``int``[] A = ``new` `int``[N];`` ` `    ``// Store the high value``    ``int` `temp = high;`` ` `    ``// Maintain strictly decreasing``    ``// sequence from index high_index``    ``// to 0 starting with temp``    ``for``(``int` `i = high_index; i >= ``0``; i--)``    ``{``        ` `        ``// Store the value and decrement``        ``// the temp variable by 1``        ``A[i] = temp--;``    ``}`` ` `    ``// Maintain the strictly decreasing``    ``// sequence from index high_index + 1``    ``// to N - 1 starting with high - 1``    ``high -= ``1``;`` ` `    ``for``(``int` `i = high_index + ``1``; i < N; i++)``    ` `        ``// Store the value and decrement``        ``// high by 1``        ``A[i] = high--;`` ` `    ``// Print the resultant sequence``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``System.out.print(A[i] + ``" "``);``    ``}``}``  ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``5``, low = ``2``, high = ``6``;``    ` `    ``// Function Call``    ``LargestArray(N, low, high);``}``}` `// This code is contributed by susmitakundugoaldanga`

## Python3

 `# Python3 program for the above approach`` ` `# Function to find the lexicographically``# largest bitonic sequence of size N``# elements lies in the range[low, high]``def` `LargestArray(N, low, high):``    ` `    ``# Store index of highest element``    ``high_index ``=` `N ``-` `(high ``-` `low ``+` `1``)``    ` `    ``# If high_index > (N-1)/2, then``    ``# remaining N/2 elements cannot``    ``# be placed in bitonic order``    ``if` `(high_index > (N ``-` `1``) ``/``/` `2``):``        ``print``(``"Not Possible"``)``        ``return``    ` `    ``# If high_index <= 0, then``    ``# set high_index as 1``    ``if` `(high_index <``=` `0``):``        ``high_index ``=` `1`` ` `    ``# Stores the resultant sequence``    ``A ``=` `[``0``] ``*` `N`` ` `    ``# Store the high value``    ``temp ``=` `high`` ` `    ``# Maintain strictly decreasing``    ``# sequence from index high_index``    ``# to 0 starting with temp``    ``for` `i ``in` `range``(high_index, ``-``1``, ``-``1``):`` ` `        ``# Store the value and decrement``        ``# the temp variable by 1``        ``A[i] ``=` `temp``        ``temp ``=` `temp ``-` `1``    ` `    ``# Maintain the strictly decreasing``    ``# sequence from index high_index + 1``    ``# to N - 1 starting with high - 1``    ``high ``-``=` `1`` ` `    ``for` `i ``in` `range``(high_index ``+` `1``, N):``        ` `        ``# Store the value and decrement``        ``# high by 1``        ``A[i] ``=` `high``        ``high ``=` `high ``-` `1`` ` `    ``# Print the resultant sequence``    ``for` `i ``in` `range``(N):``        ``print``(A[i], end ``=` `" "``)` `# Driver Code``N ``=` `5``low ``=` `2``high ``=` `6`` ` `# Function Call``LargestArray(N, low, high)` `# This code is contributed by code_hunt`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to find the lexicographically``// largest bitonic sequence of size N``// elements lies in the range[low, high]``static` `void` `LargestArray(``int` `N, ``int` `low,``                        ``int` `high)``{``    ` `    ``// Store index of highest element``    ``int` `high_index = N - (high - low + 1);``    ` `    ``// If high_index > (N-1)/2, then``    ``// remaining N/2 elements cannot``    ``// be placed in bitonic order``    ``if` `(high_index > (N - 1) / 2)``    ``{``        ``Console.Write(``"Not Possible"``);``        ``return``;``    ``}``    ` `    ``// If high_index <= 0, then``    ``// set high_index as 1``    ``if` `(high_index <= 0)``        ``high_index = 1;``        ` `    ``// Stores the resultant sequence``    ``int``[] A = ``new` `int``[N];` `    ``// Store the high value``    ``int` `temp = high;` `    ``// Maintain strictly decreasing``    ``// sequence from index high_index``    ``// to 0 starting with temp``    ``for``(``int` `i = high_index; i >= 0; i--)``    ``{``        ` `        ``// Store the value and decrement``        ``// the temp variable by 1``        ``A[i] = temp--;``    ``}` `    ``// Maintain the strictly decreasing``    ``// sequence from index high_index + 1``    ``// to N - 1 starting with high - 1``    ``high -= 1;` `    ``for``(``int` `i = high_index + 1; i < N; i++)``    ` `        ``// Store the value and decrement``        ``// high by 1``        ``A[i] = high--;` `    ``// Print the resultant sequence``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``Console.Write(A[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `N = 5, low = 2, high = 6;``    ` `    ``// Function Call``    ``LargestArray(N, low, high);``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:

`5 6 5 4 3`

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

My Personal Notes arrow_drop_up