# Check if given Array can be rearranged as increasing, decreasing or a hill sequence

• Last Updated : 10 Feb, 2022

Given an array arr[] of size N. The task is to find the number of sequences in which any one of the following conditions is met:

• The given sequence can be re-arranged into strictly increasing order, or
• The given sequence can be re-arranged into strictly decreasing order, or
• The given sequence can be re-arranged into Hill sequence order.

The task is to check if the favourable Hill sequence is possible then print the possible sequence.

Examples:

Input: arr[] = {5, 7, 2, 1, 2}
Output: 1 2 5 7 2
Explanation: Here one such sequences is as follows
– s1 = {1, 2, 5, 7, 2}

Input: arr[] = {2, 4, 1, 2, 5, 6, 3}
Output: 1, 2, 3, 4, 5, 6, 2
Explanation: Here two such sequences are as follows
– s1 ={1, 2, 3, 4, 5, 6, 2} or,
– s2 ={1, 2, 3, 6, 5, 4, 2}

Approach: The idea is to use hashing and sorting to solve the problem. Check if there are elements whose frequency is greater than 2 then it’s not possible. Follow the steps below to solve the problem:

• Initialize the variable flag as 0.
• Initialize the map<int, int> freq[].
• Initialize the vector<int> a[].
• Iterate over the range [0, n) using the variable i and perform the following tasks:
• Push the value of arr[i] into the array a[].
• Increase the count of freq[arr[i]] by 1.
• Initialize the variable max as the maximum element in the array a[].
• Initialize the variable freqsum as 0.
• Traverse over the map freq[] using the variable x and perform the following tasks:
• If x.second greater than equal to 3 then set flag as -1.
• Traverse over the map freq[] using the variable x and perform the following tasks:
• Count all the distinct elements in the variable freqsum.
• If freq[max] equals 2 then set flag as -1 else set flag as 1.
• If flag equals 1 then perform the following tasks:
• Traverse over the map freq[] using the variable x and perform the following tasks:
• If x.second equals 1 then push into the vector descending[] otherwise push it into the ascending[] also.
• Sort the vector descending[] in ascending order and ascending[] in descending order.
• After performing the above steps, print the result.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `void` `find(``int` `arr[], ``int` `n)` `{`   `    ``// Flag will indicate whether` `    ``// sequence is possible or not` `    ``int` `flag = 0;`   `    ``map<``int``, ``int``> freq;`   `    ``vector<``int``> a;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``a.push_back(arr[i]);` `        ``freq[arr[i]]++;` `    ``}`   `    ``// Max element in ` `    ``int` `max = *max_element(a.begin(), a.end());`   `    ``// Store only unique elements count` `    ``int` `freqsum = 0;`   `    ``// If any element having freq more than 2` `    ``for` `(``auto``& x : freq) {`   `        ``// Hill sequence isn't possible` `        ``if` `(x.second >= 3)` `            ``flag = -1;` `    ``}`   `    ``vector<``int``> ascending, descending;`   `    ``// Counting all distinct elements only` `    ``for` `(``auto``& x : freq) {`   `        ``// Having freq more than 1 should` `        ``// be count only 1'nce` `        ``if` `(x.second > 1)` `            ``freqsum += 1;` `        ``else` `            ``freqsum += x.second;` `    ``}`   `    ``// All elements are distinct` `    ``// Hill sequence is possible` `    ``if` `(a.size() == freqsum)` `        ``flag = 1;` `    ``else` `{`   `        ``// Max element appeared morethan 1nce` `        ``// Hill sequence isn't possible` `        ``if` `(freq[max] >= 2)` `            ``flag = -1;`   `        ``// Hill sequence is possible` `        ``else` `            ``flag = 1;` `    ``}`   `    ``// Print favourable sequence if flag==1` `    ``// Hill sequence is possible` `    ``if` `(flag == 1) {`   `        ``for` `(``auto``& x : freq) {`   `            ``// If an element's freq==1` `            ``if` `(x.second == 1)` `                ``descending.push_back(x.first);` `            ``else` `{`   `                ``// If an element's freq==2` `                ``descending.push_back(x.first);` `                ``ascending.push_back(x.first);` `            ``}` `        ``}`   `        ``sort(descending.begin(), descending.end());` `        ``sort(ascending.begin(), ascending.end(),` `             ``greater<``int``>());`   `        ``for` `(``auto``& x : descending)` `            ``cout << x << ``" "``;`   `        ``for` `(``auto``& x : ascending)` `            ``cout << x << ``" "``;` `    ``}` `    ``else` `{` `        ``cout << ``"Not Possible!\n"``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 5;` `    ``int` `arr[n] = { 5, 7, 2, 1, 2 };`   `    ``find(arr, n);`   `    ``return` `0;` `}`

## Java

 `// JAVA program for the above approach` `import` `java.util.*;` `class` `GFG {` `  ``public` `static` `void` `find(``int` `arr[], ``int` `n)` `  ``{`   `    ``// Flag will indicate whether` `    ``// sequence is possible or not` `    ``int` `flag = ``0``;`   `    ``HashMap freq = ``new` `HashMap<>();` `    ``ArrayList a = ``new` `ArrayList();`   `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``a.add(arr[i]);` `      ``if` `(freq.containsKey(arr[i])) {` `        ``freq.put(arr[i], freq.get(arr[i]) + ``1``);` `      ``}` `      ``else` `{` `        ``freq.put(arr[i], ``1``);` `      ``}` `    ``}`   `    ``// Max element in ` `    ``int` `max = Collections.max(a);`   `    ``// Store only unique elements count` `    ``int` `freqsum = ``0``;`   `    ``// If any element having freq more than 2` `    ``for` `(Map.Entry i :` `         ``freq.entrySet()) {`   `      ``// Hill sequence isn't possible` `      ``if` `(i.getValue() >= ``3``)` `        ``flag = -``1``;` `    ``}`   `    ``ArrayList ascending` `      ``= ``new` `ArrayList();` `    ``ArrayList descending` `      ``= ``new` `ArrayList();`   `    ``// Counting all distinct elements only` `    ``for` `(Map.Entry i :` `         ``freq.entrySet()) {`   `      ``// Having freq more than 1 should` `      ``// be count only 1'nce` `      ``if` `(i.getValue() > ``1``)` `        ``freqsum += ``1``;` `      ``else` `        ``freqsum += i.getValue();` `    ``}`   `    ``// All elements are distinct` `    ``// Hill sequence is possible` `    ``if` `(a.size() == freqsum)` `      ``flag = ``1``;` `    ``else` `{`   `      ``// Max element appeared morethan 1nce` `      ``// Hill sequence isn't possible` `      ``if` `(freq.get(max) >= ``2``)` `        ``flag = -``1``;`   `      ``// Hill sequence is possible` `      ``else` `        ``flag = ``1``;` `    ``}`   `    ``// Print favourable sequence if flag==1` `    ``// Hill sequence is possible` `    ``if` `(flag == ``1``) {`   `      ``for` `(Map.Entry i :` `           ``freq.entrySet()) {`   `        ``// If an element's freq==1` `        ``if` `(i.getValue() == ``1``)` `          ``descending.add(i.getKey());` `        ``else` `{`   `          ``// If an element's freq==2` `          ``descending.add(i.getKey());` `          ``ascending.add(i.getKey());` `        ``}` `      ``}`   `      ``Collections.sort(descending);` `      ``Collections.sort(ascending,` `                       ``Collections.reverseOrder());`   `      ``for` `(``int` `i = ``0``; i < descending.size(); i++)` `        ``System.out.print(descending.get(i) + ``" "``);`   `      ``for` `(``int` `i = ``0``; i < ascending.size(); i++)` `        ``System.out.print(ascending.get(i) + ``" "``);` `    ``}` `    ``else` `{` `      ``System.out.println(``"Not Possible!"``);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `n = ``5``;` `    ``int``[] arr = ``new` `int``[n];` `    ``arr[``0``] = ``5``;` `    ``arr[``1``] = ``7``;` `    ``arr[``2``] = ``2``;` `    ``arr[``3``] = ``1``;` `    ``arr[``4``] = ``2``;`   `    ``find(arr, n);` `  ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python code for the above approach` `def` `find(arr, n):`   `    ``# Flag will indicate whether` `    ``# sequence is possible or not` `    ``flag ``=` `0`   `    ``freq ``=` `{}`   `    ``a ``=` `[]`   `    ``for` `i ``in` `range``(n):` `        ``a.append(arr[i])` `        ``if` `(arr[i] ``in` `freq):` `            ``freq[arr[i]] ``+``=` `1` `        ``else``:` `            ``freq[arr[i]] ``=` `1`   `    ``# Max element in ` `    ``_max ``=` `max``(a)`   `    ``# Store only unique elements count` `    ``freqsum ``=` `0`   `    ``# If any element having freq more than 2` `    ``for` `k ``in` `freq.keys():`   `        ``# Hill sequence isn't possible` `        ``if` `(freq[k] >``=` `3``):` `            ``flag ``=` `-``1`   `    ``ascending ``=` `[]` `    ``descending ``=` `[]`   `    ``# Counting all distinct elements only` `    ``for` `k ``in` `freq:`   `        ``# Having freq more than 1 should` `        ``# be count only 1'nce` `        ``if` `(freq[k] > ``1``):` `            ``freqsum ``+``=` `1` `        ``else``:` `            ``freqsum ``+``=` `freq[k]`   `    ``# All elements are distinct` `    ``# Hill sequence is possible` `    ``if` `(``len``(a) ``=``=` `freqsum):` `        ``flag ``=` `1` `    ``else``:`   `        ``# Max element appeared morethan 1nce` `        ``# Hill sequence isn't possible` `        ``if` `(freq[_max] >``=` `2``):` `            ``flag ``=` `-``1`   `        ``# Hill sequence is possible` `        ``else``:` `            ``flag ``=` `1`   `    ``# Print favourable sequence if flag==1` `    ``# Hill sequence is possible` `    ``if` `(flag ``=``=` `1``):`   `        ``for` `k ``in` `freq.keys():`   `            ``# If an element's freq==1` `            ``if` `(freq[k] ``=``=` `1``):` `                ``descending.append(k)` `            ``else``:`   `                ``# If an element's freq==2` `                ``descending.append(k)` `                ``ascending.append(k)`   `        ``descending.sort()` `        ``ascending.sort()` `        ``for` `x ``in` `descending:` `            ``print``(x, end``=``" "``)`   `        ``for` `x ``in` `ascending:` `            ``print``(x, end``=``" "``)`   `    ``else``:` `        ``print``(``"Not Possible!"` `+` `'
'``)`   `# Driver Code` `n ``=` `5` `arr ``=` `[``5``, ``7``, ``2``, ``1``, ``2``]`   `find(arr, n)`   `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;` `public` `class` `GFG {` `  ``public` `static` `void` `find(``int` `[]arr, ``int` `n)` `  ``{`   `    ``// Flag will indicate whether` `    ``// sequence is possible or not` `    ``int` `flag = 0;`   `    ``Dictionary<``int``, ``int``> freq = ``new` `Dictionary<``int``, ``int``>();` `    ``List<``int``> a = ``new` `List<``int``>();`   `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``a.Add(arr[i]);` `      ``if` `(freq.ContainsKey(arr[i])) {` `        ``freq[arr[i]] = freq[arr[i]] + 1;` `      ``}` `      ``else` `{` `        ``freq.Add(arr[i], 1);` `      ``}` `    ``}`   `    ``// Max element in ` `    ``int` `max = a.Max();`   `    ``// Store only unique elements count` `    ``int` `freqsum = 0;`   `    ``// If any element having freq more than 2` `    ``foreach` `(KeyValuePair<``int``, ``int``> i ``in` `             ``freq) {`   `      ``// Hill sequence isn't possible` `      ``if` `(i.Value >= 3)` `        ``flag = -1;` `    ``}`   `    ``List<``int``> ``ascending` `      ``= ``new` `List<``int``>();` `    ``List<``int``> ``descending` `      ``= ``new` `List<``int``>();`   `    ``// Counting all distinct elements only` `    ``foreach` `(KeyValuePair<``int``, ``int``> i ``in` `             ``freq) {`   `      ``// Having freq more than 1 should` `      ``// be count only 1'nce` `      ``if` `(i.Value > 1)` `        ``freqsum += 1;` `      ``else` `        ``freqsum += i.Value;` `    ``}`   `    ``// All elements are distinct` `    ``// Hill sequence is possible` `    ``if` `(a.Count == freqsum)` `      ``flag = 1;` `    ``else` `{`   `      ``// Max element appeared morethan 1nce` `      ``// Hill sequence isn't possible` `      ``if` `(freq[max] >= 2)` `        ``flag = -1;`   `      ``// Hill sequence is possible` `      ``else` `        ``flag = 1;` `    ``}`   `    ``// Print favourable sequence if flag==1` `    ``// Hill sequence is possible` `    ``if` `(flag == 1) {`   `      ``foreach` `(KeyValuePair<``int``, ``int``> i ``in` `               ``freq) {`   `        ``// If an element's freq==1` `        ``if` `(i.Value == 1)` `          ``descending``.Add(i.Key);` `        ``else` `{`   `          ``// If an element's freq==2` `          ``descending``.Add(i.Key);` `          ``ascending``.Add(i.Key);` `        ``}` `      ``}`   `      ``descending``.Sort();` `      ``ascending``.Sort();` `      ``ascending``.Reverse();`   `      ``for` `(``int` `i = 0; i < ``descending``.Count; i++)` `        ``Console.Write(``descending``[i] + ``" "``);`   `      ``for` `(``int` `i = 0; i < ``ascending``.Count; i++)` `        ``Console.Write(``ascending``[i] + ``" "``);` `    ``}` `    ``else` `{` `      ``Console.WriteLine(``"Not Possible!"``);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `n = 5;` `    ``int``[] arr = ``new` `int``[n];` `    ``arr[0] = 5;` `    ``arr[1] = 7;` `    ``arr[2] = 2;` `    ``arr[3] = 1;` `    ``arr[4] = 2;`   `    ``find(arr, n);` `  ``}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

`1 2 5 7 2`

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

My Personal Notes arrow_drop_up
Related Articles