# Find a sorted subsequence of size 3 in linear time

• Difficulty Level : Medium
• Last Updated : 15 Feb, 2022

Given an array of n integers, find the 3 elements such that a[i] < a[j] < a[k] and i < j < k in 0(n) time. If there are multiple such triplets, then print any one of them.

Examples:

```Input: arr[] = {12, 11, 10, 5, 6, 2, 30}
Output: 5, 6, 30
Explanation: As 5 < 6 < 30, and they
appear in the same sequence in the array

Input: arr[] = {1, 2, 3, 4}
Output: 1, 2, 3 OR 1, 2, 4 OR 2, 3, 4
Explanation: As the array is sorted, for every i, j, k,
where i < j < k, arr[i] < arr[j] < arr[k]

Input: arr[] = {4, 3, 2, 1}
Output: No such triplet exists.```

METHOD 1:

Hint: Use Auxiliary Space.
Solution: So, the main motive is to find an element which has an element smaller than itself on the left side of the array and an element greater than itself on the right side of the array, if there is any such element then there exists a triplet that satisfies the criteria.

Approach: This can be solved in a very simple way. To find an element which has an element smaller than itself on its left side of the array, check if that element is the smallest element while traversing the array from the starting index i.e., (0), and to check if there is an element greater than itself on its right side of the array check whether that element is the largest element while traversing from the end of the array i.e., (n-1). If the element is not the smallest element from 0 to that index then it has an element smaller than itself on its left side, and similarly, if the element is not the largest element from that index to the last index then there is a larger element on its right side.

Algorithm

1. Create an auxiliary array smaller[0..n-1]. smaller[i] stores the index of a number which is smaller than arr[i] and is on the left side. The array contains -1 if there is no such element.
2. Create another auxiliary array greater[0..n-1]. greater[i] stores the index of a number which is greater than arr[i] and is on the right side of arr[i]. The array contains -1 if there is no such element.
3. Finally traverse both smaller[] and greater[] and find the index [i] for which both smaller[i] and greater[i] are not equal to -1.

## C++

 `// C++ program to find a sorted``// sub-sequence of size 3``#include ``using` `namespace` `std;`` ` `// A function to fund a sorted``// sub-sequence of size 3``void` `find3Numbers(``int` `arr[], ``int` `n)``{``    ``// Index of maximum element``    ``// from right side``    ``int` `max = n - 1;`` ` `    ``// Index of minimum element``    ``// from left side``    ``int` `min = 0;``    ``int` `i;`` ` `    ``// Create an array that will store``    ``// index of a smaller element on left side.``    ``// If there is no smaller element on left``    ``// side, then smaller[i] will be -1.``    ``int``* smaller = ``new` `int``[n];`` ` `    ``// first entry will always be -1``    ``smaller = -1;``    ``for` `(i = 1; i < n; i++) {``        ``if` `(arr[i] <= arr[min]) {``            ``min = i;``            ``smaller[i] = -1;``        ``}``        ``else``            ``smaller[i] = min;``    ``}`` ` `    ``// Create another array that will``    ``// store index of a greater element``    ``// on right side. If there is no greater``    ``// element on right side, then``    ``// greater[i] will be -1.``    ``int``* greater = ``new` `int``[n];`` ` `    ``// last entry will always be -1``    ``greater[n - 1] = -1;``    ``for` `(i = n - 2; i >= 0; i--) {``        ``if` `(arr[i] >= arr[max]) {``            ``max = i;``            ``greater[i] = -1;``        ``}``        ``else``            ``greater[i] = max;``    ``}`` ` `    ``// Now find a number which has both``    ``// a greater number on right side and``    ``// smaller number on left side``    ``for` `(i = 0; i < n; i++) {``        ``if` `(smaller[i] != -1 && greater[i] != -1) {``            ``cout << arr[smaller[i]]``                 ``<< ``" "` `<< arr[i] << ``" "``                 ``<< arr[greater[i]];``            ``return``;``        ``}``    ``}`` ` `    ``// If we reach number, then there are``    ``// no such 3 numbers``    ``cout << ``"No such triplet found"``;`` ` `    ``// Free the dynamically allocated memory``    ``// to avoid memory leak``    ``delete``[] smaller;``    ``delete``[] greater;`` ` `    ``return``;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 12, 11, 10, 5, 6, 2, 30 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``find3Numbers(arr, n);``    ``return` `0;``    ``a greater number on``}`` ` `// This is code is contributed by rathbhupendra`

## C

 `// C program to find a sorted``// sub-sequence of size 3``#include `` ` `// A function to fund a sorted``// sub-sequence of size 3``void` `find3Numbers(``int` `arr[], ``int` `n)``{``    ``// Index of maximum element``    ``// from right side``    ``int` `max = n - 1;`` ` `    ``// Index of minimum element``    ``// from left side``    ``int` `min = 0;``    ``int` `i;`` ` `    ``// Create an array that will store``    ``// index of a smaller element on left side.``    ``// If there is no smaller element on left side,``    ``// then smaller[i] will be -1.``    ``int``* smaller = ``new` `int``[n];`` ` `    ``// first entry will always be -1``    ``smaller = -1;``    ``for` `(i = 1; i < n; i++) {``        ``if` `(arr[i] <= arr[min]) {``            ``min = i;``            ``smaller[i] = -1;``        ``}``        ``else``            ``smaller[i] = min;``    ``}`` ` `    ``// Create another array that will``    ``// store index of a greater element``    ``// on right side. If there is no greater``    ``// element on right side, then``    ``// greater[i] will be -1.``    ``int``* greater = ``new` `int``[n];`` ` `    ``// last entry will always be -1``    ``greater[n - 1] = -1;``    ``for` `(i = n - 2; i >= 0; i--) {``        ``if` `(arr[i] >= arr[max]) {``            ``max = i;``            ``greater[i] = -1;``        ``}``        ``else``            ``greater[i] = max;``    ``}`` ` `    ``// Now find a number which has``    ``// both a greater number on right``    ``// side and smaller number on left side``    ``for` `(i = 0; i < n; i++) {``        ``if` `(smaller[i] != -1 && greater[i] != -1) {``            ``printf``(``"%d %d %d"``, arr[smaller[i]],``                   ``arr[i], arr[greater[i]]);``            ``return``;``        ``}``    ``}`` ` `    ``// If we reach number, then``    ``// there are no such 3 numbers``    ``printf``(``"No such triplet found"``);`` ` `    ``// Free the dynamically allocated memory``    ``// to avoid memory leak``    ``delete``[] smaller;``    ``delete``[] greater;`` ` `    ``return``;``}`` ` `// Driver program to test above function``int` `main()``{``    ``int` `arr[] = { 12, 11, 10, 5, 6, 2, 30 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``find3Numbers(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to find a sorted``// sub-sequence of size 3``import` `java.io.*;`` ` `class` `SortedSubsequence {``    ``// A function to find a sorted``    ``// sub-sequence of size 3``    ``static` `void` `find3Numbers(``int` `arr[])``    ``{``        ``int` `n = arr.length;`` ` `        ``// Index of maximum element``        ``// from right side``        ``int` `max = n - ``1``;`` ` `        ``// Index of minimum element``        ``// from left side``        ``int` `min = ``0``;``        ``int` `i;`` ` `        ``// Create an array that will store``        ``// index of a smaller element on left side.``        ``// If there is no smaller element on left``        ``// side, then smaller[i] will be -1.``        ``int``[] smaller = ``new` `int``[n];`` ` `        ``// first entry will always be -1``        ``smaller[``0``] = -``1``;``        ``for` `(i = ``1``; i < n; i++) {``            ``if` `(arr[i] <= arr[min]) {``                ``min = i;``                ``smaller[i] = -``1``;``            ``}``            ``else``                ``smaller[i] = min;``        ``}`` ` `        ``// Create another array that will``        ``// store index of a greater element``        ``// on right side. If there is no greater``        ``// element on right side, then greater[i]``        ``// will be -1.``        ``int``[] greater = ``new` `int``[n];`` ` `        ``// last entry will always be -1``        ``greater[n - ``1``] = -``1``;``        ``for` `(i = n - ``2``; i >= ``0``; i--) {``            ``if` `(arr[i] >= arr[max]) {``                ``max = i;``                ``greater[i] = -``1``;``            ``}``            ``else``                ``greater[i] = max;``        ``}`` ` `        ``// Now find a number which has``        ``// both greater number on right``        ``// side and smaller number on left side``        ``for` `(i = ``0``; i < n; i++) {``            ``if` `(``                ``smaller[i] != -``1` `&& greater[i] != -``1``) {``                ``System.out.print(``                    ``arr[smaller[i]] + ``" "` `+ arr[i]``                    ``+ ``" "` `+ arr[greater[i]]);``                ``return``;``            ``}``        ``}`` ` `        ``// If we reach number, then there``        ``// are no such 3 numbers``        ``System.out.println(``"No such triplet found"``);``        ``return``;``    ``}`` ` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``12``, ``11``, ``10``, ``5``, ``6``, ``2``, ``30` `};``        ``find3Numbers(arr);``    ``}``}``/* This code is contributed by Devesh Agrawal*/`

## Python

 `# Python program to fund a sorted``# sub-sequence of size 3`` ` `def` `find3numbers(arr):``    ``n ``=` `len``(arr)`` ` `# Index of maximum element from right side``    ``max` `=` `n``-``1`` ` `# Index of minimum element from left side ``    ``min` `=` `0`` ` `    ``# Create an array that will store ``    ``# index of a smaller element on left side. ``    ``# If there is no smaller element on left side,``# then smaller[i] will be -1.``    ``smaller ``=` `[``0``]``*``10000``    ``smaller[``0``] ``=` `-``1``    ``for` `i ``in` `range``(``1``, n):``        ``if` `(arr[i] <``=` `arr[``min``]):``            ``min` `=` `i``            ``smaller[i] ``=` `-``1``        ``else``:``            ``smaller[i] ``=` `min`` ` `    ``# Create another array that will ``    ``# store index of a greater element ``    ``# on right side. If there is no greater ``# element on right side, then greater[i] ``# will be -1.``    ``greater ``=` `[``0``]``*``10000``    ``greater[n``-``1``] ``=` `-``1`` ` `    ``for` `i ``in` `range``(n``-``2``, ``-``1``, ``-``1``):``        ``if` `(arr[i] >``=` `arr[``max``]):``            ``max` `=` `i``            ``greater[i] ``=` `-``1`` ` `        ``else``:``            ``greater[i] ``=` `max`` ` `    ``# Now find a number which has ``    ``# both a greater number on right ``# side and smaller number on left side``    ``for` `i ``in` `range``(``0``, n):``        ``if` `smaller[i] !``=` `-``1` `and` `greater[i] !``=` `-``1``:``            ``print` `arr[smaller[i]], arr[i], arr[greater[i]]``            ``return`` ` `    ``# If we reach here, then there are no such 3 numbers``    ``print` `"No triplet found"``    ``return`` ` ` ` `# Driver function to test above function``arr ``=` `[``12``, ``11``, ``10``, ``5``, ``6``, ``2``, ``30``]``find3numbers(arr)`` ` `# This code is contributed by Devesh Agrawal`

## C#

 `// C# program to find a sorted``// subsequence of size 3``using` `System;`` ` `class` `SortedSubsequence {`` ` `    ``// A function to find a sorted``    ``// subsequence of size 3``    ``static` `void` `find3Numbers(``int``[] arr)``    ``{``        ``int` `n = arr.Length;`` ` `        ``// Index of maximum element from right side``        ``int` `max = n - 1;`` ` `        ``// Index of minimum element from left side``        ``int` `min = 0;``        ``int` `i;`` ` `        ``// Create an array that will store index``        ``// of a smaller element on left side.``        ``// If there is no smaller element``        ``// on left side, then smaller[i] will be -1.``        ``int``[] smaller = ``new` `int``[n];`` ` `        ``// first entry will always be -1``        ``smaller = -1;``        ``for` `(i = 1; i < n; i++) {``            ``if` `(arr[i] <= arr[min]) {``                ``min = i;``                ``smaller[i] = -1;``            ``}``            ``else``                ``smaller[i] = min;``        ``}`` ` `        ``// Create another array that will store``        ``// index of a greater element on right side.``        ``// If there is no greater element on``        ``// right side, then greater[i] will be -1.``        ``int``[] greater = ``new` `int``[n];`` ` `        ``// last entry will always be -1``        ``greater[n - 1] = -1;``        ``for` `(i = n - 2; i >= 0; i--) {``            ``if` `(arr[i] >= arr[max]) {``                ``max = i;``                ``greater[i] = -1;``            ``}``            ``else``                ``greater[i] = max;``        ``}`` ` `        ``// Now find a number which has``        ``// both a greater number on right side``        ``// and smaller number on left side``        ``for` `(i = 0; i < n; i++) {``            ``if` `(smaller[i] != -1 && greater[i] != -1) {``                ``Console.Write(``                    ``arr[smaller[i]] + ``" "` `+ arr[i]``                    ``+ ``" "` `+ arr[greater[i]]);``                ``return``;``            ``}``        ``}`` ` `        ``// If we reach number, then there``        ``// are no such 3 numbers``        ``Console.Write(``"No such triplet found"``);``        ``return``;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 12, 11, 10, 5, 6, 2, 30 };``        ``find3Numbers(arr);``    ``}``}`` ` `/* This code is contributed by vt_m*/`

## PHP

 `= 0; ``\$i``--)``    ``{``        ``if` `(``\$arr``[``\$i``] >= ``\$arr``[``\$max``])``        ``{``            ``\$max` `= ``\$i``;``            ``\$greater``[``\$i``] = -1;``        ``}``        ``else``            ``\$greater``[``\$i``] = ``\$max``;``    ``}``     ` `    ``// Now find a number which has both ``    ``// a greater number on right side ``    ``// and smaller number on left side``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``    ``{``        ``if` `(``\$smaller``[``\$i``] != -1 && ``            ``\$greater``[``\$i``] != -1)``        ``{``            ``echo` `\$arr``[``\$smaller``[``\$i``]].``" "``.``                      ``\$arr``[``\$i``] . ``" "` `. ``                      ``\$arr``[``\$greater``[``\$i``]];``            ``return``;``        ``}``    ``}``     ` `    ``// If we reach number, then there``    ``// are no such 3 numbers``    ``printf(``"No such triplet found"``);``     ` `    ``return``;``}`` ` `// Driver Code``\$arr` `= ``array``(12, 11, 10, 5, 6, 2, 30);``\$n` `= sizeof(``\$arr``);``find3Numbers(``\$arr``, ``\$n``);`` ` `// This code is contributed ``// by ChitraNayal``?>`

## Javascript

 ``

Complexity Analysis

• Time Complexity: O(n). As the array is traveled only once and there are no nested loops, the time complexity will be in the order of n.
• Auxiliary Space: O(n). Since two extra array is needed to store the index of the previous lesser element and next greater element so the space required will also be in the order of n

METHOD 2:

Solution: First find two elements arr[i] & arr[j] such that arr[i] < arr[j]. Then find a third element arr[k] greater than arr[j].
Approach: We can think of the problem in three simple terms.

1. First we only need to find two elements arr[i] < arr[j] and i < j. This can be done in linear time with just 1 loop over the range of the array. For instance, while keeping track of the min element, its easy to find any subsequent element that is greater than it. Thus we have our arr[i] & arr[j].
2. Secondly, consider this sequence – {3, 4, -1, 0, 2}. Initially min is 3, arr[i] is 3 and arr[j] is 4. While iterating over the array we can easily keep track of min and eventually update it to -1. And we can also update arr[i] & arr[j] to lower values i.e. -1 & 0 respectively.
3. Thirdly, as soon as we have arr[i] & arr[j] values, we can immediately start monitoring the subsequent elements in the same loop for an arr[k] > arr[j]. Thus we can find all three values arr[i] < arr[j] < arr[k] in a single pass over the array.

Algorithm: Iterate over the length of the array. Keep track of the min. As soon as the next iteration has an element greater than min, we have found our arr[j] and the min will be saved as arr[i]. Continue iterating until we find an element arr[k] which is greater than arr[j]. In case the next elements are of lower value, then we update min, arr[i] and arr[j] to these lower values, so as to give us the best chance to find arr[k].

## C++

 `// C++ Program for above approach``#include ``using` `namespace` `std;`` ` `// Function to find the triplet``void` `find3Numbers(vector<``int``>& nums) ``{``   ` `  ``// If number of elements < 3``  ``// then no triplets are possible``  ``if` `(nums.size() < 3){``    ``cout << ``"No such triplet found"``;``    ``return``;``  ``}``   ` `  ``// track best sequence length ``  ``// (not current sequence length)``  ``int` `seq = 1;        ``   ` `  ``// min number in array``  ``int` `min_num = nums;  ``   ` `  ``// least max number in best sequence ``  ``// i.e. track arr[j] (e.g. in ``  ``// array {1, 5, 3} our best sequence ``  ``// would be {1, 3} with arr[j] = 3)``  ``int` `max_seq = INT_MAX;      ``   ` `  ``// save arr[i]``  ``int` `store_min = min_num;   ``   ` `  ``// Iterate from 1 to nums.size()``  ``for` `(``int` `i = 1; i < nums.size(); i++) ``  ``{``    ``if` `(nums[i] == min_num)``      ``continue``;``     ` `    ``else` `if` `(nums[i] < min_num) ``    ``{``      ``min_num = nums[i];``      ``continue``;``    ``} ``     ` `    ``// this condition is only hit ``    ``// when current sequence size is 2``    ``else` `if` `(nums[i] < max_seq) {    ``       ` `      ``// update best sequence max number ``      ``// to a smaller value ``      ``// (i.e. we've found a ``      ``// smaller value for arr[j])``      ``max_seq = nums[i];       ``       ` `      ``// store best sequence start value ``      ``// i.e. arr[i]``      ``store_min = min_num;            ``    ``} ``     ` `    ``// Increase best sequence length & ``    ``// save next number in our triplet``    ``else` `if` `(nums[i] > max_seq) ``    ``{``      ``// We've found our arr[k]!``      ``// Print the output        ``        ``cout << ``"Triplet: "` `<< store_min << ``                 ``", "` `<< max_seq << ``", "` `<< ``                           ``nums[i] << endl;``        ``return``;``    ``}``  ``}``   ` `  ``// No triplet found``  ``cout << ``"No such triplet found"``;``}`` ` `// Driver Code``int` `main() {``  ``vector<``int``> nums {1,2,-1,7,5};``   ` `  ``// Function Call``  ``find3Numbers(nums);``}`

## Java

 `// Java Program for above approach``class` `Main ``{ ``    ``// Function to find the triplet``    ``public` `static` `void` `find3Numbers(``int``[] nums) ``    ``{``        ` `      ``// If number of elements < 3``      ``// then no triplets are possible``      ``if` `(nums.length < ``3``){``        ``System.out.print(``"No such triplet found"``);``        ``return``;``      ``}``        ` `      ``// track best sequence length ``      ``// (not current sequence length)``      ``int` `seq = ``1``;        ``        ` `      ``// min number in array``      ``int` `min_num = nums[``0``];  ``        ` `      ``// least max number in best sequence ``      ``// i.e. track arr[j] (e.g. in ``      ``// array {1, 5, 3} our best sequence ``      ``// would be {1, 3} with arr[j] = 3)``      ``int` `max_seq = Integer.MIN_VALUE;      ``        ` `      ``// save arr[i]``      ``int` `store_min = min_num;   ``        ` `      ``// Iterate from 1 to nums.size()``      ``for` `(``int` `i = ``1``; i < nums.length; i++) ``      ``{``        ``if` `(nums[i] == min_num)``          ``continue``;``          ` `        ``else` `if` `(nums[i] < min_num) ``        ``{``          ``min_num = nums[i];``          ``continue``;``        ``} ``          ` `        ``// this condition is only hit ``        ``// when current sequence size is 2``        ``else` `if` `(nums[i] < max_seq) {    ``            ` `          ``// update best sequence max number ``          ``// to a smaller value ``          ``// (i.e. we've found a ``          ``// smaller value for arr[j])``          ``max_seq = nums[i];       ``            ` `          ``// store best sequence start value ``          ``// i.e. arr[i]``          ``store_min = min_num;            ``        ``} ``          ` `        ``// Increase best sequence length & ``        ``// save next number in our triplet``        ``else` `if` `(nums[i] > max_seq) ``        ``{    ``          ``seq++;``            ` `          ``// We've found our arr[k]!``          ``// Print the output``          ``if` `(seq == ``3``) ``          ``{            ``            ``System.out.println(``"Triplet: "` `+ store_min +``                               ``", "` `+ max_seq + ``", "` `+ nums[i]);``            ``return``;``          ``}``          ``max_seq = nums[i];``        ``}``      ``}``        ` `      ``// No triplet found``      ``System.out.print(``"No such triplet found"``);``    ``}``     ` `    ``// Driver program ``    ``public` `static` `void` `main(String[] args) ``    ``{ ``        ``int``[] nums = {``1``,``2``,-``1``,``7``,``5``};``    ` `        ``// Function Call``        ``find3Numbers(nums); ``    ``} ``} `` ` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 Program for above approach``import` `sys`` ` `# Function to find the triplet``def` `find3Numbers(nums):``   ` `  ``# If number of elements < 3``  ``# then no triplets are possible``  ``if` `(``len``(nums) < ``3``):``    ``print``(``"No such triplet found"``, end ``=` `'')``    ``return``   ` `  ``# Track best sequence length ``  ``# (not current sequence length)``  ``seq ``=` `1`    `   ` `  ``# min number in array``  ``min_num ``=` `nums[``0``]``   ` `  ``# Least max number in best sequence ``  ``# i.e. track arr[j] (e.g. in ``  ``# array {1, 5, 3} our best sequence ``  ``# would be {1, 3} with arr[j] = 3)``  ``max_seq ``=` `-``sys.maxsize ``-` `1`   `   ` `  ``# Save arr[i]``  ``store_min ``=` `min_num   ``   ` `  ``# Iterate from 1 to nums.size()``  ``for` `i ``in` `range``(``1``, ``len``(nums)):``    ``if` `(nums[i] ``=``=` `min_num):``      ``continue``    ``elif` `(nums[i] < min_num):``      ``min_num ``=` `nums[i]``      ``continue``       ` `    ``# This condition is only hit ``    ``# when current sequence size is 2``    ``elif` `(nums[i] < max_seq):``       ` `      ``# Update best sequence max number ``      ``# to a smaller value ``      ``# (i.e. we've found a ``      ``# smaller value for arr[j])``      ``max_seq ``=` `nums[i]    ``       ` `      ``# Store best sequence start value ``      ``# i.e. arr[i]``      ``store_min ``=` `min_num           ``       ` `    ``# Increase best sequence length & ``    ``# save next number in our triplet``    ``elif` `(nums[i] > max_seq):``      ``if` `seq ``=``=` `1``:``        ``store_min ``=` `min_num``      ``seq ``+``=` `1``       ` `      ``# We've found our arr[k]!``      ``# Print the output``      ``if` `(seq ``=``=` `3``):``        ``print``(``"Triplet: "` `+` `str``(store_min) ``+``              ``", "` `+` `str``(max_seq) ``+` `", "` `+``                     ``str``(nums[i]))``         ` `        ``return``       ` `      ``max_seq ``=` `nums[i]``    ` `  ``# No triplet found``  ``print``(``"No such triplet found"``, end ``=` `'')``   ` `# Driver Code``if` `__name__``=``=``'__main__'``:``   ` `  ``nums ``=` `[ ``1``, ``2``, ``-``1``, ``7``, ``5` `]``   ` `  ``# Function Call``  ``find3Numbers(nums)`` ` `# This code is contributed by rutvik_56`

## C#

 `// C# Program for above approach``using` `System;``class` `GFG {``     ` `    ``// Function to find the triplet``    ``static` `void` `find3Numbers(``int``[] nums) ``    ``{``         ` `      ``// If number of elements < 3``      ``// then no triplets are possible``      ``if` `(nums.Length < 3){``        ``Console.Write(``"No such triplet found"``);``        ``return``;``      ``}``         ` `      ``// track best sequence length ``      ``// (not current sequence length)``      ``int` `seq = 1;        ``         ` `      ``// min number in array``      ``int` `min_num = nums;  ``         ` `      ``// least max number in best sequence ``      ``// i.e. track arr[j] (e.g. in ``      ``// array {1, 5, 3} our best sequence ``      ``// would be {1, 3} with arr[j] = 3)``      ``int` `max_seq = Int32.MinValue;      ``         ` `      ``// save arr[i]``      ``int` `store_min = min_num;   ``         ` `      ``// Iterate from 1 to nums.size()``      ``for` `(``int` `i = 1; i < nums.Length; i++) ``      ``{``        ``if` `(nums[i] == min_num)``          ``continue``;``           ` `        ``else` `if` `(nums[i] < min_num) ``        ``{``          ``min_num = nums[i];``          ``continue``;``        ``} ``           ` `        ``// this condition is only hit ``        ``// when current sequence size is 2``        ``else` `if` `(nums[i] < max_seq) {    ``             ` `          ``// update best sequence max number ``          ``// to a smaller value ``          ``// (i.e. we've found a ``          ``// smaller value for arr[j])``          ``max_seq = nums[i];       ``             ` `          ``// store best sequence start value ``          ``// i.e. arr[i]``          ``store_min = min_num;            ``        ``} ``           ` `        ``// Increase best sequence length & ``        ``// save next number in our triplet``        ``else` `if` `(nums[i] > max_seq) ``        ``{    ``          ``seq++;``             ` `          ``// We've found our arr[k]!``          ``// Print the output``          ``if` `(seq == 3) ``          ``{            ``            ``Console.WriteLine(``"Triplet: "` `+ store_min +``                               ``", "` `+ max_seq + ``", "` `+ nums[i]);``            ``return``;``          ``}``          ``max_seq = nums[i];``        ``}``      ``}``         ` `      ``// No triplet found``      ``Console.Write(``"No such triplet found"``);``    ``}``     ` `  ``static` `void` `Main() {``    ``int``[] nums = {1,2,-1,7,5};`` ` `    ``// Function Call``    ``find3Numbers(nums); ``  ``}``}`` ` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output

`Triplet: 1, 2, 7`

Complexity Analysis:

Time Complexity: O(n). As the array is traveled only once and there are no nested loops, the time complexity will be in the order of n.
Auxiliary Space: O(1).

Exercise:

1. Find a sub-sequence of size 3 such that arr[i] < arr[j] > arr[k].
2. Find a sorted sub-sequence of size 4 in linear time