# Arrange numbers to form a valid sequence

Last Updated : 01 Feb, 2022

Given an array arr[] with N distinct numbers and another array arr1[] with N-1 operators (either < or >), the task is to organize the numbers to form a valid sequence which obeys relational operator rules with respect to provided operators.

Examples:

Input: arr[] = {3, 12, 7, 8, 5}; arr1= {‘<‘, ‘>’, ‘>’, ‘<‘}
Output: {3, 12, 8, 5, 7}
Explanation:
3 < 12 > 8 > 5 < 7
There can be more such combinations. The task is to return one of the combinations.

Input: arr[] = {8, 2, 7, 1, 5, 9}; arr1[] = {‘>’, ‘>’, ‘<‘, ‘>’, ‘<‘}
Output:{9, 8, 1, 7, 2, 5}
Explanation:
9 > 8 > 1 < 7 > 2 < 5

Naive Approach:
A naive approach is to try all different possible arrangement of numbers and check if the sequence is valid.
Time Complexity: O(2N).

Efficient Approach: The idea is to first sort the given array of numbers in ascending order. Then solve the problem using two pointers technique: one pointing at the front and other pointing at the end.

1. Take one resultant array of size same as given array.
2. If the current operator is ‘<‘ then include the element which the top pointer is pointing to in resultant array and increment it by 1.
3. If the current operator is ‘>’ then include the element which the last pointer is pointing to in resultant array and decrement it by 1.

Below is the implementation of the above approach.

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `// Function to organize the given numbers` `// to form a valid sequence.` `vector<``int``> orgazineInOrder(vector<``int``> vec,` `                            ``vector<``int``> op, ``int` `n)` `{` `    ``vector<``int``> result(n);` `    ``// Sorting the array` `    ``sort(vec.begin(), vec.end());`   `    ``int` `i = 0, j = n - 1, k = 0;` `    ``while` `(i <= j && k <= n - 2) {` `        ``// Two pointer technique` `        ``// to organize the numbers` `        ``if` `(op[k] == ``'<'``) {` `            ``result[k] = vec[i++];` `        ``}` `        ``else` `{` `            ``result[k] = vec[j--];` `        ``}` `        ``k++;` `    ``}` `    ``result[n - 1] = vec[i];`   `    ``return` `result;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> vec({ 8, 2, 7, 1, 5, 9 });`   `    ``vector<``int``> op({ ``'>'``, ``'>'``, ``'<'``,` `                     ``'>'``, ``'<'` `});`   `    ``vector<``int``> result` `        ``= orgazineInOrder(vec,` `                          ``op, vec.size());`   `    ``for` `(``int` `i = 0; i < result.size(); i++) {` `        ``cout << result[i] << ``" "``;` `    ``}` `    ``return` `0;` `}`

## Java

 `// Java implementation of the above approach` `import` `java.util.*;`   `class` `GFG` `{`   `// Function to organize the given numbers` `// to form a valid sequence.` `static` `int``[] orgazineInOrder(``int` `[]vec,``int``[] op, ``int` `n)` `{` `    ``int` `[]result = ``new` `int``[n];` `    `  `    ``// Sorting the array` `    ``Arrays.sort(vec);`   `    ``int` `i = ``0``, j = n - ``1``, k = ``0``;` `    ``while` `(i <= j && k <= n - ``2``) ` `    ``{` `        ``// Two pointer technique` `        ``// to organize the numbers` `        ``if` `(op[k] == ``'<'``) ` `        ``{` `            ``result[k] = vec[i++];` `        ``}` `        ``else` `        ``{` `            ``result[k] = vec[j--];` `        ``}` `        ``k++;` `    ``}` `    ``result[n - ``1``] = vec[i];`   `    ``return` `result;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `[]vec ={ ``8``, ``2``, ``7``, ``1``, ``5``, ``9` `};`   `    ``int``[] op ={ ``'>'``, ``'>'``, ``'<'``,` `                    ``'>'``, ``'<'` `};`   `    ``int` `[]result = orgazineInOrder(vec,` `                        ``op, vec.length);`   `    ``for` `(``int` `i = ``0``; i < result.length; i++) ` `    ``{` `        ``System.out.print(result[i]+ ``" "``);` `    ``}` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the above approach `   `# Function to organize the given numbers ` `# to form a valid sequence. ` `def` `orgazineInOrder(vec, op, n) : `   `    ``result ``=` `[``0``] ``*` `n;` `    `  `    ``# Sorting the array` `    ``vec.sort();` `    ``i ``=` `0``;` `    ``j ``=` `n ``-` `1``;` `    ``k ``=` `0``; ` `    `  `    ``while` `(i <``=` `j ``and` `k <``=` `n ``-` `2``) :` `        `  `        ``# Two pointer technique ` `        ``# to organize the numbers ` `        ``if` `(op[k] ``=``=` `'<'``) :` `            ``result[k] ``=` `vec[i]; ` `            ``i ``+``=` `1``;` `        `  `        ``else` `:` `            ``result[k] ``=` `vec[j]; ` `            ``j ``-``=` `1``;` `        `  `        ``k ``+``=` `1``; `   `    ``result[n ``-` `1``] ``=` `vec[i]; `   `    ``return` `result; `   `# Driver code ` `if` `__name__ ``=``=` `"__main__"` `: `   `    ``vec ``=` `[ ``8``, ``2``, ``7``, ``1``, ``5``, ``9` `];` `    ``op ``=` `[ ``'>'``, ``'>'``, ``'<'``, ``'>'``, ``'<'` `]; `   `    ``result ``=` `orgazineInOrder(vec, op, ``len``(vec)); `   `    ``for` `i ``in` `range``(``len``(result)) :` `        ``print``(result[i], end ``=` `" "``); `   `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach ` `using` `System;`   `class` `GFG ` `{ ` `    `  `    ``// Function to organize the given numbers ` `    ``// to form a valid sequence. ` `    ``static` `int``[] orgazineInOrder(``int` `[]vec,``int``[] op, ``int` `n) ` `    ``{ ` `        ``int` `[]result = ``new` `int``[n]; ` `        `  `        ``// Sorting the array ` `        ``Array.Sort(vec); ` `    `  `        ``int` `i = 0, j = n - 1, k = 0; ` `        ``while` `(i <= j && k <= n - 2) ` `        ``{ ` `            ``// Two pointer technique ` `            ``// to organize the numbers ` `            ``if` `(op[k] == ``'<'``) ` `            ``{ ` `                ``result[k] = vec[i++]; ` `            ``} ` `            ``else` `            ``{ ` `                ``result[k] = vec[j--]; ` `            ``} ` `            ``k++; ` `        ``} ` `        ``result[n - 1] = vec[i]; ` `    `  `        ``return` `result; ` `    ``} ` `    `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]vec ={ 8, 2, 7, 1, 5, 9 }; ` `    `  `        ``int``[] op ={ ``'>'``, ``'>'``, ``'<'``, ` `                        ``'>'``, ``'<'` `}; ` `    `  `        ``int` `[]result = orgazineInOrder(vec, ` `                            ``op, vec.Length); ` `    `  `        ``for` `(``int` `i = 0; i < result.Length; i++) ` `        ``{ ` `            ``Console.Write(result[i] + ``" "``); ` `        ``} ` `    ``} ` `} `   `// This code is contributed by AnkitRai01 `

## Javascript

 ``

Output:

`9 8 1 7 2 5`

Time Complexity: O(NlogN)

Auxiliary Space: O(N)

Previous
Next