# First strictly smaller element in a sorted array in Java

Given a sorted array and a target value, find the first element that is strictly smaller than given element.

Examples:

Input : arr[] = {1, 2, 3, 5, 8, 12} Target = 5 Output : 2 (Index of 3) Input : {1, 2, 3, 5, 8, 12} Target = 8 Output : 3 (Index of 5) Input : {1, 2, 3, 5, 8, 12} Target = 15 Output : -1

A **simple solution **is to linearly traverse given array and find first element that is strictly greater. If no such element exists, then return -1.

An** efficient solution** is to use Binary Search. In a general binary search, we are looking for a value which appears in the array. Sometimes, however, we need to find the first element which is either greater than a target.

To see that this algorithm is correct, consider each comparison being made. If we find an element that’s greater than the target element, then it and everything above it can’t possibly match, so there’s no need to search that region. We can thus search the left half. If we find an element that is smaller than the element in question, then anything before it must also be larger, so they can’t be the first element that’s smaller and so we don’t need to search them. The middle element is thus the last possible place it could be.

Note that on each iteration we drop off at least half the remaining elements from consideration. If the top branch executes, then the elements in the range [low, (low + high) / 2] are all discarded, causing us to lose floor((low + high) / 2) – low + 1 >= (low + high) / 2 – low = (high – low) / 2 elements.

If the bottom branch executes, then the elements in the range [(low + high) / 2 + 1, high] are all discarded. This loses us high – floor(low + high) / 2 + 1 >= high – (low + high) / 2 = (high – low) / 2 elements.

Consequently, we’ll end up finding the first element smaller than the target in O(lg n) iterations of this process.

## C++

`// C++ program to find first element that` `// is strictly smaller than given target.` `#include<bits/stdc++.h>` `using` `namespace` `std;` `int` `next(` `int` `arr[], ` `int` `target, ` `int` `end)` `{` ` ` `// Minimum size of the array should be 1` ` ` `if` `(end == 0) ` `return` `-1;` ` ` `// If target lies beyond the max element, than the index of strictly smaller` ` ` `// value than target should be (end - 1)` ` ` `if` `(target > arr[end - 1]) ` `return` `end-1;` ` ` ` ` `int` `start = 0;` ` ` `int` `ans = -1;` ` ` `while` `(start <= end)` ` ` `{` ` ` `int` `mid = (start + end) / 2;` ` ` `// Move to the left side if the target is smaller` ` ` `if` `(arr[mid] >= target)` ` ` `{` ` ` `end = mid - 1;` ` ` `}` ` ` `// Move right side` ` ` `else` ` ` `{` ` ` `ans = mid;` ` ` `start = mid + 1;` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `arr[] = { 1, 2, 3, 5, 8, 12 };` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `cout << (next(arr, 5, n));` ` ` `return` `0;` `}` `// This code is contributed by d-dalal` |

## Java

`// Java program to find first element that` `// is strictly smaller than given target.` ` ` `class` `GfG {` ` ` ` ` `private` `static` `int` `next(` `int` `[] arr, ` `int` `target)` ` ` `{` ` ` ` ` `int` `start = ` `0` `, end = arr.length-` `1` `;` ` ` `// Minimum size of the array should be 1` ` ` `if` `(end == ` `0` `) ` `return` `-` `1` `;` ` ` `// If target lies beyond the max element, than the index of strictly smaller` ` ` `// value than target should be (end - 1)` ` ` `if` `(target > arr[end]) ` `return` `end;` ` ` ` ` `int` `ans = -` `1` `;` ` ` `while` `(start <= end) {` ` ` `int` `mid = (start + end) / ` `2` `;` ` ` ` ` `// Move to the left side if the target is smaller` ` ` `if` `(arr[mid] >= target) {` ` ` `end = mid - ` `1` `;` ` ` `}` ` ` ` ` `// Move right side` ` ` `else` `{` ` ` `ans = mid;` ` ` `start = mid + ` `1` `;` ` ` `}` ` ` `}` ` ` `return` `ans;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `[] arr = { ` `1` `, ` `2` `, ` `3` `, ` `5` `, ` `8` `, ` `12` `};` ` ` `System.out.println(next(arr, ` `5` `));` ` ` `}` `}` |

## Python3

`# Python3 program to find first element that` `# is strictly smaller than given target` `def` `next` `(arr, target):` ` ` `start ` `=` `0` `;` ` ` `end ` `=` `len` `(arr) ` `-` `1` `;` ` ` `# Minimum size of the array should be 1` ` ` `if` `(end ` `=` `=` `0` `):` ` ` `return` `-` `1` `;` ` ` `'''` ` ` `If target lies beyond the max element, than the index of strictly smaller` ` ` `value than target should be (end - 1)` ` ` `'''` ` ` `if` `(target > arr[end]):` ` ` `return` `end;` ` ` ` ` `ans ` `=` `-` `1` `;` ` ` `while` `(start <` `=` `end):` ` ` `mid ` `=` `(start ` `+` `end) ` `/` `/` `2` `;` ` ` ` ` `# Move to the left side if target is` ` ` `# smaller` ` ` `if` `(arr[mid] >` `=` `target):` ` ` `end ` `=` `mid ` `-` `1` `;` ` ` ` ` `# Move right side` ` ` `else` `:` ` ` `ans ` `=` `mid;` ` ` `start ` `=` `mid ` `+` `1` `;` ` ` `return` `ans;` ` ` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `arr ` `=` `[ ` `1` `, ` `2` `, ` `3` `, ` `5` `, ` `8` `, ` `12` `];` ` ` `print` `(` `next` `(arr, ` `5` `));` ` ` `# This code is contributed by d-dalal` |

## C#

`// C# program to find first element that` `// is strictly smaller than given target.` `using` `System;` `class` `GfG {` ` ` `private` `static` `int` `next(` `int` `[] arr, ` `int` `target)` ` ` `{` ` ` `int` `start = 0, end = arr.Length-1;` ` ` `// Minimum size of the array should be 1` ` ` `if` `(end == 0) ` `return` `-1;` ` ` `// If target lies beyond the max element, than the index of strictly smaller` ` ` `// value than target should be (end - 1)` ` ` `if` `(target > arr[end]) ` `return` `end;` ` ` `int` `ans = -1;` ` ` `while` `(start <= end) {` ` ` `int` `mid = (start + end) / 2;` ` ` `// Move to the left side if the target is smaller` ` ` `if` `(arr[mid] >= target) {` ` ` `end = mid - 1;` ` ` `}` ` ` `// Move right side` ` ` `else` `{` ` ` `ans = mid;` ` ` `start = mid + 1;` ` ` `}` ` ` `}` ` ` `return` `ans;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[] arr = { 1, 2, 3, 5, 8, 12 };` ` ` `Console.WriteLine(next(arr, 5));` ` ` `}` `}` `// This code is contributed by d-dalal.` |

## PHP

`<?php` `// PHP program to find first element that` `// is strictly smaller than given target.` ` ` `function` `next0(` `$arr` `, ` `$target` `)` ` ` `{` ` ` `$start` `= 0; ` `$end` `= sizeof(` `$arr` `)-1;` ` ` ` ` `// Minimum size of the array should be 1` ` ` `if` `(` `$end` `== 0) ` `return` `-1;` ` ` `// If target lies beyond the max element, than the index of strictly smaller` ` ` `// value than target should be (end - 1)` ` ` `if` `(` `$target` `> ` `$arr` `[` `$end` `]) ` `return` `$end` `;` ` ` `$ans` `= -1;` ` ` `while` `(` `$start` `<= ` `$end` `)` ` ` `{` ` ` `$mid` `=(int)((` `$start` `+ ` `$end` `) / 2);` ` ` `// Move to the left side if the target is smaller` ` ` `if` `(` `$arr` `[` `$mid` `] >= ` `$target` `)` ` ` `{` ` ` `$end` `= ` `$mid` `- 1;` ` ` `}` ` ` `// Move right side` ` ` `else` ` ` `{` ` ` `$ans` `= ` `$mid` `;` ` ` `$start` `= ` `$mid` `+ 1;` ` ` `}` ` ` `}` ` ` `return` `$ans` `;` ` ` `}` ` ` `// Driver code` ` ` `{` ` ` `$arr` `= ` `array` `(1, 2, 3, 5, 8, 12 );` ` ` `echo` `(next0(` `$arr` `, 5));` ` ` `}` `// This code is contributed by d-dalal.` |

**Output:**

2

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.