# Ceiling in a sorted array

• Difficulty Level : Easy
• Last Updated : 29 Jul, 2022

Given a sorted array and a value x, the ceiling of x is the smallest element in an array greater than or equal to x, and the floor is the greatest element smaller than or equal to x. Assume that the array is sorted in non-decreasing order. Write efficient functions to find the floor and ceiling of x.
Examples :

```For example, let the input array be {1, 2, 8, 10, 10, 12, 19}
For x = 0:    floor doesn't exist in array,  ceil  = 1
For x = 1:    floor  = 1,  ceil  = 1
For x = 5:    floor  = 2,  ceil  = 8
For x = 20:   floor  = 19,  ceil doesn't exist in array```

In the below methods, we have implemented only ceiling search functions. Floor search can be implemented in the same way.

Method 1 (Linear Search)
Algorithm to search ceiling of x:

1. If x is smaller than or equal to the first element in the array then return 0(index of the first element).
2. Else linearly search for an index i such that x lies between arr[i] and arr[i+1].
3. If we do not find an index i in step 2, then return -1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach` `#include ` `using` `namespace` `std;`   `/* Function to get index of ceiling of x in arr[low..high] */` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x) ` `{ ` `    `  `    ``int` `i; ` `    `  `    ``/* If x is smaller than or equal to first element, ` `        ``then return the first element */` `    ``if``(x <= arr[low]) ` `        ``return` `low; ` `    `  `    ``/* Otherwise, linearly search for ceil value */` `    ``for``(i = low; i < high; i++) ` `    ``{ ` `        ``if``(arr[i] == x) ` `        ``return` `i; ` `    `  `        ``/* if x lies between arr[i] and arr[i+1] including ` `        ``arr[i+1], then return arr[i+1] */` `        ``if``(arr[i] < x && arr[i+1] >= x) ` `        ``return` `i+1; ` `    ``}     ` `    `  `    ``/* If we reach here then x is greater than the last element ` `        ``of the array, return -1 in this case */` `    ``return` `-1; ` `} `     `/* Driver code*/` `int` `main() ` `{ ` `    ``int` `arr[] = {1, 2, 8, 10, 10, 12, 19}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `    ``int` `x = 3; ` `    ``int` `index = ceilSearch(arr, 0, n-1, x); ` `    ``if``(index == -1) ` `        ``cout << ``"Ceiling of "` `<< x << ``" doesn't exist in array "``; ` `    ``else` `        ``cout << ``"ceiling of "` `<< x << ``" is "` `<< arr[index]; ` `    `  `    ``return` `0; ` `} `   `// This is code is contributed by rathbhupendra`

## C

 `#include`   `/* Function to get index of ceiling of x in arr[low..high] */` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x)` `{` `  ``int` `i;    `   `  ``/* If x is smaller than or equal to first element,` `    ``then return the first element */` `  ``if``(x <= arr[low])` `    ``return` `low;  `   `  ``/* Otherwise, linearly search for ceil value */` `  ``for``(i = low; i < high; i++)` `  ``{` `    ``if``(arr[i] == x)` `      ``return` `i;`   `    ``/* if x lies between arr[i] and arr[i+1] including` `       ``arr[i+1], then return arr[i+1] */` `    ``if``(arr[i] < x && arr[i+1] >= x)` `       ``return` `i+1;` `  ``}         `   `  ``/* If we reach here then x is greater than the last element ` `    ``of the array,  return -1 in this case */` `  ``return` `-1;` `}`     `/* Driver program to check above functions */` `int` `main()` `{` `   ``int` `arr[] = {1, 2, 8, 10, 10, 12, 19};` `   ``int` `n = ``sizeof``(arr)/``sizeof``(arr);` `   ``int` `x = 3;` `   ``int` `index = ceilSearch(arr, 0, n-1, x);` `   ``if``(index == -1)` `     ``printf``(``"Ceiling of %d doesn't exist in array "``, x);` `   ``else` `     ``printf``(``"ceiling of %d is %d"``, x, arr[index]);` `   ``getchar``();` `   ``return` `0;` `}`

## Java

 `class` `Main` `{` `    ``/* Function to get index of ceiling ` `       ``of x in arr[low..high] */` `    ``static` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x)` `    ``{` `      ``int` `i;    ` `     `  `      ``/* If x is smaller than or equal to first ` `         ``element,then return the first element */` `      ``if``(x <= arr[low])` `        ``return` `low;  ` `     `  `      ``/* Otherwise, linearly search for ceil value */` `      ``for``(i = low; i < high; i++)` `      ``{` `        ``if``(arr[i] == x)` `          ``return` `i;` `     `  `        ``/* if x lies between arr[i] and arr[i+1] ` `        ``including arr[i+1], then return arr[i+1] */` `        ``if``(arr[i] < x && arr[i+``1``] >= x)` `           ``return` `i+``1``;` `      ``}         ` `     `  `      ``/* If we reach here then x is greater than the ` `      ``last element of the array,  return -1 in this case */` `      ``return` `-``1``;` `    ``}` `     `  `     `  `    ``/* Driver program to check above functions */` `    ``public` `static` `void` `main (String[] args)` `    ``{` `       ``int` `arr[] = {``1``, ``2``, ``8``, ``10``, ``10``, ``12``, ``19``};` `       ``int` `n = arr.length;` `       ``int` `x = ``3``;` `       ``int` `index = ceilSearch(arr, ``0``, n-``1``, x);` `       ``if``(index == -``1``)` `         ``System.out.println(``"Ceiling of "``+x+``" doesn't exist in array"``);` `       ``else` `         ``System.out.println(``"ceiling of "``+x+``" is "``+arr[index]);` `    ``}  ` `}`

## Python3

 `# Function to get index of ceiling of x in arr[low..high] */` `def` `ceilSearch(arr, low, high, x):`   `    ``# If x is smaller than or equal to first element,` `    ``# then return the first element */` `    ``if` `x <``=` `arr[low]:` `        ``return` `low`   `    ``# Otherwise, linearly search for ceil value */` `    ``i ``=` `low` `    ``for` `i ``in` `range``(high):` `        ``if` `arr[i] ``=``=` `x:` `            ``return` `i`   `        ``# if x lies between arr[i] and arr[i+1] including` `        ``# arr[i+1], then return arr[i+1] */` `        ``if` `arr[i] < x ``and` `arr[i``+``1``] >``=` `x:` `            ``return` `i``+``1` `        `  `    ``# If we reach here then x is greater than the last element ` `    ``# of the array,  return -1 in this case */` `    ``return` `-``1`   `# Driver program to check above functions */` `arr ``=` `[``1``, ``2``, ``8``, ``10``, ``10``, ``12``, ``19``]` `n ``=` `len``(arr)` `x ``=` `3` `index ``=` `ceilSearch(arr, ``0``, n``-``1``, x);`   `if` `index ``=``=` `-``1``:` `    ``print` `(``"Ceiling of %d doesn't exist in array "``%` `x)` `else``:` `    ``print` `(``"ceiling of %d is %d"``%``(x, arr[index]))`   `# This code is contributed by Shreyanshi Arun`

## C#

 `// C# program to find ceiling` `// in a sorted array` `using` `System;`   `class` `GFG {` `    `  `    ``// Function to get index of ceiling ` `    ``// of x in arr[low..high] ` `    ``static` `int` `ceilSearch(``int``[] arr, ``int` `low, ` `                           ``int` `high, ``int` `x)` `    ``{` `        ``int` `i;`   `        ``// If x is smaller than or equal` `        ``// to first element, then return` `        ``// the first element ` `        ``if` `(x <= arr[low])` `            ``return` `low;`   `        ``// Otherwise, linearly search ` `        ``// for ceil value ` `        ``for` `(i = low; i < high; i++) {` `            ``if` `(arr[i] == x)` `                ``return` `i;`   `            ``/* if x lies between arr[i] and ` `            ``arr[i+1] including arr[i+1], ` `            ``then return arr[i+1] */` `            ``if` `(arr[i] < x && arr[i + 1] >= x)` `                ``return` `i + 1;` `        ``}`   `        ``/* If we reach here then x is ` `        ``greater than the last element ` `        ``of the array, return -1 in ` `        ``this case */` `        ``return` `-1;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 1, 2, 8, 10, 10, 12, 19 };` `        ``int` `n = arr.Length;` `        ``int` `x = 3;` `        ``int` `index = ceilSearch(arr, 0, n - 1, x);` `        `  `        ``if` `(index == -1)` `            ``Console.Write(``"Ceiling of "` `+ x +` `                     ``" doesn't exist in array"``);` `        ``else` `            ``Console.Write(``"ceiling of "` `+ x +` `                         ``" is "` `+ arr[index]);` `    ``}` `}`   `// This code is contributed by Sam007.`

## PHP

 `= ``\$x``)` `            ``return` `\$i` `+ 1;` `    ``}     ` `    `  `    ``// If we reach here then x is greater ` `    ``// than the last element of the array,` `    ``// return -1 in this case ` `    ``return` `-1;` `}`   `// Driver Code` `\$arr` `= ``array``(1, 2, 8, 10, 10, 12, 19);` `\$n` `= sizeof(``\$arr``);` `\$x` `= 3;` `\$index` `= ceilSearch(``\$arr``, 0, ``\$n` `- 1, ``\$x``);` `if``(``\$index` `== -1)` `    ``echo``(``"Ceiling of "` `. ``\$x` `. ` `         ``" doesn't exist in array "``);` `else` `    ``echo``(``"ceiling of "` `. ``\$x` `. ``" is "` `. ` `                        ``\$arr``[``\$index``]);`   `// This code is contributed by Ajit.` `?>`

## Javascript

 ``

Output

`ceiling of 3 is 8`

Time Complexity: O(n), Auxiliary Space: O(1)

Method 2 (Binary Search)

Instead of using linear search, binary search is used here to find out the index. Binary search reduces the time complexity to O(Logn).

## C++

 `#include ` `using` `namespace` `std;`   `/* Function to get index of` `   ``ceiling of x in arr[low..high]*/` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x)` `{` `    ``int` `mid;`   `    ``/* If x is smaller than` `       ``or equal to the first element,` `       ``then return the first element */` `    ``if` `(x <= arr[low])` `        ``return` `low;`   `    ``/* If x is greater than the last element,` `       ``then return -1 */` `    ``if` `(x > arr[high])` `        ``return` `-1;`   `    ``/* get the index of middle element of arr[low..high]*/` `    ``mid = (low + high) / 2; ``/* low + (high - low)/2 */`   `    ``/* If x is same as middle element,` `       ``then return mid */` `    ``if` `(arr[mid] == x)` `        ``return` `mid;`   `    ``/* If x is greater than arr[mid],` `       ``then either arr[mid + 1] is ceiling of x` `       ``or ceiling lies in arr[mid+1...high] */` `    ``else` `if` `(arr[mid] < x) {` `        ``if` `(mid + 1 <= high && x <= arr[mid + 1])` `            ``return` `mid + 1;` `        ``else` `            ``return` `ceilSearch(arr, mid + 1, high, x);` `    ``}`   `    ``/* If x is smaller than arr[mid],` `       ``then either arr[mid] is ceiling of x` `       ``or ceiling lies in arr[low...mid-1] */` `    ``else` `{` `        ``if` `(mid - 1 >= low && x > arr[mid - 1])` `            ``return` `mid;` `        ``else` `            ``return` `ceilSearch(arr, low, mid - 1, x);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 8, 10, 10, 12, 19 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `x = 20;` `    ``int` `index = ceilSearch(arr, 0, n - 1, x);` `    ``if` `(index == -1)` `        ``cout << ``"Ceiling of "` `<< x` `             ``<< ``" doesn't exist in array "``;` `    ``else` `        ``cout << ``"ceiling of "` `<< x << ``" is "` `<< arr[index];`   `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `#include `   `/* Function to get index of ceiling of x in arr[low..high]*/` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x)` `{` `    ``int` `mid;`   `    ``/* If x is smaller than or equal to the first element,` `      ``then return the first element */` `    ``if` `(x <= arr[low])` `        ``return` `low;`   `    ``/* If x is greater than the last element, then return -1` `     ``*/` `    ``if` `(x > arr[high])` `        ``return` `-1;`   `    ``/* get the index of middle element of arr[low..high]*/` `    ``mid = (low + high) / 2; ``/* low + (high - low)/2 */`   `    ``/* If x is same as middle element, then return mid */` `    ``if` `(arr[mid] == x)` `        ``return` `mid;`   `    ``/* If x is greater than arr[mid], then either arr[mid +` `      ``1] is ceiling of x or ceiling lies in` `      ``arr[mid+1...high] */` `    ``else` `if` `(arr[mid] < x) {` `        ``if` `(mid + 1 <= high && x <= arr[mid + 1])` `            ``return` `mid + 1;` `        ``else` `            ``return` `ceilSearch(arr, mid + 1, high, x);` `    ``}`   `    ``/* If x is smaller than arr[mid], then either arr[mid]` `       ``is ceiling of x or ceiling lies in arr[low...mid-1]` `     ``*/` `    ``else` `{` `        ``if` `(mid - 1 >= low && x > arr[mid - 1])` `            ``return` `mid;` `        ``else` `            ``return` `ceilSearch(arr, low, mid - 1, x);` `    ``}` `}`   `/* Driver program to check above functions */` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 8, 10, 10, 12, 19 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `x = 20;` `    ``int` `index = ceilSearch(arr, 0, n - 1, x);` `    ``if` `(index == -1)` `        ``printf``(``"Ceiling of %d doesn't exist in array "``, x);` `    ``else` `        ``printf``(``"ceiling of %d is %d"``, x, arr[index]);` `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `class` `Main {` `    ``/* Function to get index of` `       ``ceiling of x in arr[low..high]*/` `    ``static` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high,` `                          ``int` `x)` `    ``{` `        ``// base condition if length of arr == 0 then return` `        ``// -1` `        ``if` `(high == ``0``) {` `            ``return` `-``1``;` `        ``}` `        ``/* this while loop function will run until condition` `         ``not break once condition break loop will return` `         ``start and ans is low which will be next smallest` `         ``greater than target which is ceiling*/` `        ``while` `(low <= high) {` `            ``int` `mid` `                ``= low + (high - low) / ``2``; ``// calculate mid`   `            ``if` `(x == arr[mid]) {` `                ``return` `mid;` `            ``}` `            ``if` `(x < arr[mid]) {` `                ``high = mid - ``1``;` `            ``}`   `            ``else` `{` `                ``low = mid + ``1``;` `            ``}` `        ``}` `        ``return` `low;` `    ``}` `    ``/* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};` `              ``if( x < mid) yes set high = mid -1;` `    ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};` `              ``if( x < mid) no set low = mid + 1;` `    ``step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};` `               ``if( x == mid ) yes return mid` `               ``if(x < mid ) no low = mid + 1` `    ``step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};` `              ``check while(low < = high)` `               ``condition break and return low which will` `    ``next greater of target */`   `    ``/* Driver program to check above functions */` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``1``, ``2``, ``8``, ``10``, ``10``, ``12``, ``19` `};` `        ``int` `n = arr.length;` `        ``int` `x = ``8``;` `        ``int` `index = ceilSearch(arr, ``0``, n - ``1``, x);` `        ``if` `(index == -``1``)` `            ``System.out.println(``"Ceiling of "` `+ x` `                               ``+ ``" doesn't exist in array"``);` `        ``else` `            ``System.out.println(``"ceiling of "` `+ x + ``" is "` `                               ``+ arr[index]);` `    ``}` `}`

## Python3

 `# Function to get index of ceiling of x in arr[low..high]*/` `def` `ceilSearch(arr, low, high, x):`   `    ``# If x is smaller than or equal to the first element,` `    ``# then return the first element */` `    ``if` `x <``=` `arr[low]:` `        ``return` `low `   `    ``# If x is greater than the last element, then return -1 */` `    ``if` `x > arr[high]:` `        ``return` `-``1`  ` `  `    ``# get the index of middle element of arr[low..high]*/` `    ``mid ``=` `(low ``+` `high)``/``2``;  ``# low + (high - low)/2 */` ` `  `    ``# If x is same as middle element, then return mid */` `    ``if` `arr[mid] ``=``=` `x:` `        ``return` `mid`   `    ``# If x is greater than arr[mid], then either arr[mid + 1]` `    ``# is ceiling of x or ceiling lies in arr[mid+1...high] */ ` `    ``elif` `arr[mid] < x:` `        ``if` `mid ``+` `1` `<``=` `high ``and` `x <``=` `arr[mid``+``1``]:` `            ``return` `mid ``+` `1` `        ``else``:` `            ``return` `ceilSearch(arr, mid``+``1``, high, x)` ` `  `    ``# If x is smaller than arr[mid], then either arr[mid] ` `    ``# is ceiling of x or ceiling lies in arr[low...mid-1] */   ` `    ``else``:` `        ``if` `mid ``-` `1` `>``=` `low ``and` `x > arr[mid``-``1``]:` `            ``return` `mid` `        ``else``:` `            ``return` `ceilSearch(arr, low, mid ``-` `1``, x)` ` `  `# Driver program to check above functions` `arr ``=` `[``1``, ``2``, ``8``, ``10``, ``10``, ``12``, ``19``]` `n ``=` `len``(arr)` `x ``=` `20` `index ``=` `ceilSearch(arr, ``0``, n``-``1``, x);`   `if` `index ``=``=` `-``1``:` `    ``print` `(``"Ceiling of %d doesn't exist in array "``%` `x)` `else``:` `    ``print` `(``"ceiling of %d is %d"``%``(x, arr[index]))`   `# This code is contributed by Shreyanshi Arun`

## C#

 `// C# program to find ceiling` `// in a sorted array`   `using` `System;`   `class` `GFG {`   `    ``// Function to get index of ceiling` `    ``// of x in arr[low..high]` `    ``static` `int` `ceilSearch(``int``[] arr, ``int` `low, ``int` `high,` `                          ``int` `x)` `    ``{` `        ``int` `mid;`   `        ``// If x is smaller than or equal` `        ``// to the first element, then` `        ``// return the first element.` `        ``if` `(x <= arr[low])` `            ``return` `low;`   `        ``// If x is greater than the last` `        ``// element, then return -1` `        ``if` `(x > arr[high])` `            ``return` `-1;`   `        ``// get the index of middle` `        ``// element of arr[low..high]` `        ``mid = (low + high) / 2;` `        ``// low + (high - low)/2`   `        ``// If x is same as middle` `        ``// element then return mid` `        ``if` `(arr[mid] == x)` `            ``return` `mid;`   `        ``// If x is greater than arr[mid],` `        ``// then either arr[mid + 1] is` `        ``// ceiling of x or ceiling lies` `        ``// in arr[mid+1...high]` `        ``else` `if` `(arr[mid] < x) {` `            ``if` `(mid + 1 <= high && x <= arr[mid + 1])` `                ``return` `mid + 1;` `            ``else` `                ``return` `ceilSearch(arr, mid + 1, high, x);` `        ``}`   `        ``// If x is smaller than arr[mid],` `        ``// then either arr[mid] is ceiling` `        ``// of x  or ceiling lies in` `        ``// arr[low...mid-1]` `        ``else` `{` `            ``if` `(mid - 1 >= low && x > arr[mid - 1])` `                ``return` `mid;` `            ``else` `                ``return` `ceilSearch(arr, low, mid - 1, x);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 1, 2, 8, 10, 10, 12, 19 };` `        ``int` `n = arr.Length;` `        ``int` `x = 8;` `        ``int` `index = ceilSearch(arr, 0, n - 1, x);` `        ``if` `(index == -1)` `            ``Console.Write(``"Ceiling of "` `+ x` `                          ``+ ``" doesn't exist in array"``);` `        ``else` `            ``Console.Write(``"ceiling of "` `+ x + ``" is "` `                          ``+ arr[index]);` `    ``}` `}`   `// This code is contributed by Sam007.`

## PHP

 ` ``\$arr``[``\$high``])` `        ``return` `-1; ` `    `  `    ``/* get the index of middle` `       ``element of arr[low..high] */` `    ``// low + (high - low)/2` `    ``\$mid` `= (``\$low` `+ ``\$high``)/2; ` `    `  `    ``/* If x is same as middle element,` `       ``then return mid */` `    ``if``(``\$arr``[``\$mid``] == ``\$x``)` `        ``return` `\$mid``;` `        `  `    ``/* If x is greater than arr[mid],` `       ``then either arr[mid + 1]    is ` `       ``ceiling of x or ceiling lies ` `       ``in arr[mid+1...high] */` `    ``else` `if``(``\$arr``[``\$mid``] < ``\$x``)` `    ``{` `        ``if``(``\$mid` `+ 1 <= ``\$high` `&& ` `           ``\$x` `<= ``\$arr``[``\$mid` `+ 1])` `            ``return` `\$mid` `+ 1;` `        ``else` `            ``return` `ceilSearch(``\$arr``, ``\$mid` `+ 1, ` `                              ``\$high``, ``\$x``);` `    ``}` `    `  `    ``/* If x is smaller than arr[mid],` `       ``then either arr[mid] is ceiling` `       ``of x or ceiling lies in ` `       ``arr[low....mid-1] */` `    ``else` `    ``{` `        ``if``(``\$mid` `- 1 >= ``\$low` `&& ` `           ``\$x` `> ``\$arr``[``\$mid` `- 1])` `            ``return` `\$mid``;` `        ``else` `         ``return` `ceilSearch(``\$arr``, ``\$low``, ` `                           ``\$mid` `- 1, ``\$x``);` `    ``}` `}`   `// Driver Code` `\$arr` `= ``array``(1, 2, 8, 10, 10, 12, 19);` `\$n` `= sizeof(``\$arr``);` `\$x` `= 20;` `\$index` `= ceilSearch(``\$arr``, 0, ``\$n` `- 1, ``\$x``);` `if``(``\$index` `== -1)` `    ``echo``(``"Ceiling of \$x doesn't exist in array "``);` `else` `    ``echo``(``"ceiling of \$x is"``); ` `    ``echo``(isset(``\$arr``[``\$index``]));`   `// This code is contributed by nitin mittal.` `?>`

## Javascript

 ``

Output

`Ceiling of 20 doesn't exist in array `

Time Complexity: O(log(n)), Auxiliary Space: O(1)

Another Implementation of Method 2 :

As like previous method here also binary search is being used but the code logic is different instead of lots of if else check i will simply return and lets understand through below steps :

Step 1 : { low->1, 2, 8, 10<-mid, 10, 12, 19<-high};

`if( x < mid) yes set high = mid -1;`

Step 2 : { low ->1, 2 <-mid, 8 <-high, 10, 10, 12, 19};

`if( x < mid) no set low = mid + 1;`

Step 3 : {1, 2, 8<-high,low,mid,  10, 10, 12, 19};

```if( x == mid ) yes return mid
if(x < mid ) no low = mid + 1```

Step 4  : {1, 2, 8<-high,mid, 10<-low, 10, 12, 19};

`check while(low =<  high)`

condition break and return low which is my ceiling of  target.

## C++

 `#include ` `using` `namespace` `std;`   `/* Function to get index of` `       ``ceiling of x in arr[low..high]*/` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x)` `{`   `    ``// base condition if length of arr == 0 then return -1` `    ``if` `(x == 0) {` `        ``return` `-1;` `    ``}` `    ``int` `mid;`   `    ``// this while loop function will run until condition not` `    ``// break once condition break loop will return start and` `    ``// ans is low which will be next smallest greater than` `    ``// target which is ceiling` `    ``while` `(low <= high) {` `        ``mid = low + (high - low) / 2;` `        ``if` `(arr[mid] == x)` `            ``return` `mid;` `        ``else` `if` `(x < arr[mid])` `            ``high = mid - 1;` `        ``else` `            ``low = mid + 1;` `    ``}` `    ``return` `low;` `}`   `/* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};` `                ``if( x < mid) yes set high = mid -1;` `   ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12,` `   ``19}; if( x < mid) no set low = mid + 1; step 3 : {1, 2, 8` `   ``= high,low,low,  10, 10, 12, 19}; if( x == mid ) yes` `   ``return mid if(x < mid ) no low = mid + 1 step 4  : {1, 2,` `   ``8 = high,mid, 10 = low, 10, 12, 19}; check while(low < =` `   ``high) condition break and return low which will next` `   ``greater of target */`   `/* Driver program to check above functions */` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 8, 10, 10, 12, 19 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `x = 8;` `    ``int` `index = ceilSearch(arr, 0, n - 1, x);` `    ``if` `(index == -1)` `        ``printf``(``"Ceiling of %d does not exist in an array"``, x);` `    ``else` `        ``printf``(``"Ceiling of %d is %d"``, x, arr[index]);` `    ``return` `0;` `}`

## C

 `#include `   `// Function to get index of ceiling of x in arr[low..high]` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high, ``int` `x)` `{`   `    ``// base condition if length of arr == 0 then return -1` `    ``if` `(x == 0) {` `        ``return` `-1;` `    ``}` `    ``int` `mid;`   `    ``// this while loop function will run until condition not` `    ``// break once condition break loop will return start and` `    ``// ans is low which will be next smallest greater than` `    ``// target which is ceiling` `    ``while` `(low <= high) {` `        ``mid = low + (high - low) / 2;` `        ``if` `(arr[mid] == x)` `            ``return` `mid;` `        ``else` `if` `(x < arr[mid])` `            ``high = mid - 1;` `        ``else` `            ``low = mid + 1;` `    ``}` `    ``return` `low;` `}`   `/* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};` `                ``if( x < mid) yes set high = mid -1;` `   ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12,` `   ``19}; if( x < mid) no set low = mid + 1; step 3 : {1, 2, 8` `   ``= high,low,low,  10, 10, 12, 19}; if( x == mid ) yes` `   ``return mid if(x < mid ) no low = mid + 1 step 4  : {1, 2,` `   ``8 = high,mid, 10 = low, 10, 12, 19}; check while(low < =` `   ``high) condition break and return low which will next` `   ``greater of target */`   `/* Driver program to check above functions */` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 8, 10, 10, 12, 19 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `x = 8;` `    ``int` `index = ceilSearch(arr, 0, n - 1, x);` `    ``if` `(index == -1)` `        ``printf``(``"Ceiling of %d does not exist in an array"``, x);` `    ``else` `        ``printf``(``"Ceiling of %d is %d"``, x, arr[index]);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `class` `Main {` `    ``/* Function to get index of` `       ``ceiling of x in arr[low..high]*/` `    ``static` `int` `ceilSearch(``int` `arr[], ``int` `low, ``int` `high,` `                          ``int` `x)` `    ``{` `        ``// base condition if length of arr == 0 then return` `        ``// -1` `        ``if` `(x == ``0``) {` `            ``return` `-``1``;` `        ``}` `        ``/* this while loop function will run until condition` `         ``not break once condition break loop will return` `         ``start and ans is low which will be next smallest` `         ``greater than target which is ceiling*/` `        ``while` `(low <= high) {` `            ``int` `mid` `                ``= low + (high - low) / ``2``; ``// calculate mid`   `            ``if` `(x == arr[mid]) {` `                ``return` `mid;` `            ``}` `            ``if` `(x < arr[mid]) {` `                ``high = mid - ``1``;` `            ``}`   `            ``else` `{` `                ``low = mid + ``1``;` `            ``}` `        ``}` `        ``return` `low;` `    ``}` `    ``/* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};` `              ``if( x < mid) yes set high = mid -1;` `    ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};` `              ``if( x < mid) no set low = mid + 1;` `    ``step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};` `               ``if( x == mid ) yes return mid` `               ``if(x < mid ) no low = mid + 1` `    ``step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};` `              ``check while(low < = high)` `               ``condition break and return low which will` `    ``next greater of target */`   `    ``/* Driver program to check above functions */` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``1``, ``2``, ``8``, ``10``, ``10``, ``12``, ``19` `};` `        ``int` `n = arr.length;` `        ``int` `x = ``8``;` `        ``int` `index = ceilSearch(arr, ``0``, n - ``1``, x);` `        ``if` `(index == -``1``)` `            ``System.out.println(``"Ceiling of "` `+ x` `                               ``+ ``" doesn't exist in array"``);` `        ``else` `            ``System.out.println(``"ceiling of "` `+ x + ``" is "` `                               ``+ arr[index]);` `    ``}` `}`

## C#

 `// C# program for the above approach`   `using` `System;` `class` `GFG` `{` `  ``/* Function to get index of ` `       ``ceiling of x in arr[low..high]*/` `  ``static` `int` `ceilSearch(``int``[] arr, ``int` `low, ``int` `high, ``int` `x)` `  ``{` `    ``// base condition if length of arr == 0 then return -1` `    ``if` `(x == 0)` `    ``{` `      ``return` `-1;` `    ``}` `    ``/* this while loop function will run until condition not break once condition break` `         ``loop will return start and ans is low which will be next smallest greater than target` `         ``which is ceiling*/` `    ``while` `(low <= high)` `    ``{` `      ``int` `mid = low + (high - low) / 2;``//calculate mid`   `      ``if` `(x == arr[mid])` `      ``{` `        ``return` `mid;` `      ``}` `      ``if` `(x < arr[mid])` `      ``{` `        ``high = mid - 1;` `      ``}`   `      ``else` `      ``{` `        ``low = mid + 1;` `      ``}` `    ``}` `    ``return` `low;` `    ``/* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high}; ` `                  ``if( x < mid) yes set high = mid -1;` `        ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};` `                  ``if( x < mid) no set low = mid + 1;` `        ``step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};` `                   ``if( x == mid ) yes return mid ` `                   ``if(x < mid ) no low = mid + 1` `        ``step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};` `                  ``check while(low < = high)` `                   ``condition break and return low which will next greater of target */`   `  ``}` `  `  `  ``/* Driver program to check above functions */` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 1, 2, 8, 10, 10, 12, 19 };` `    ``int` `n = arr.Length;` `    ``int` `x = 8;` `    ``int` `index = ceilSearch(arr, 0, n - 1, x);` `    ``if` `(index == -1)` `      ``Console.WriteLine(``"Ceiling of "` `+ x + ``" doesn't exist in array"``);` `    ``else` `      ``Console.WriteLine(``"ceiling of "` `+ x + ``" is "` `+ arr[index]);` `  ``}` `}`

## Javascript

 `//JS program to implement the approach`   `/* Function to get index of ` `       ``ceiling of x in arr[low..high]*/` `function` `ceilSearch(arr, low, high, x)` `{`   `  ``// base condition if length of arr == 0 then return -1` `  ``if` `(x == 0)` `  ``{` `    ``return` `-1;` `  ``}` `  ``var` `mid;`   `  ``/* this while loop function will run until ` `  ``condition not break once condition break` `       ``loop will return start and ans is low ` `       ``which will be next smallest greater than target` `       ``which is ceiling*/` `  ``while` `(low <= high)` `  ``{` `    ``mid = low + (high - low) / 2;` `    ``if` `(arr[mid] == x)` `    ``{` `      ``return` `mid;` `    ``}` `    ``else` `if` `(x < arr[mid])` `    ``{`   `      ``high = mid - 1;` `    ``}` `    ``else` `    ``{`   `      ``low = mid + 1;` `    ``}`   `  ``}` `  ``return` `low;` `}`   `/* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high}; ` `                ``if( x < mid) yes set high = mid -1;` `      ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};` `                ``if( x < mid) no set low = mid + 1;` `      ``step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};` `                 ``if( x == mid ) yes return mid ` `                 ``if(x < mid ) no low = mid + 1` `      ``step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};` `                ``check while(low < = high)` `                 ``condition break and return low which will next greater of target */`   `/* Driver program to check above functions */` `var` `arr = [1, 2, 8, 10, 10, 12, 19];` `var` `n = arr.length;` `var` `x = 8;` `var` `index = ceilSearch(arr, 0, n - 1, x);` `  ``if` `(index == -1)` `  ``{` `    ``console.log(``"Ceiling of "` `+ x + ``" does not exist in an array"``);` `  ``}` `  ``else` `  ``{` `    ``console.log(``"Ceiling of "` `+ x + ``" is "` `+ arr[index]);` `  ``}`

## Python3

 `# Function to get index of ceiling of x in arr[low..high]` `def` `ceilSearch(arr, low, high, x):`   `  ``# base condition if length of arr == 0 then return -1` `    ``if` `(x ``=``=` `0``):` `        ``return` `-``1`   `    ``"""this while loop function will run until` `  ``condition not break once condition break` `       ``loop will return start and ans is low` `       ``which will be next smallest greater than target` `       ``which is ceiling"""` `    ``while` `(low <``=` `high):` `        ``mid ``=` `low ``+` `(high ``-` `low) ``/` `2` `        ``mid ``=` `int``(mid)` `        ``if` `(arr[mid] ``=``=` `x):` `            ``return` `mid` `        ``elif` `(x < arr[mid]):` `            ``high ``=` `mid ``-` `1` `        ``else``:` `            ``low ``=` `mid ``+` `1`   `    ``return` `low`     `""" step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high}; ` `                ``if( x < mid) yes set high = mid -1;` `      ``step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};` `                ``if( x < mid) no set low = mid + 1;` `      ``step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};` `                 ``if( x == mid ) yes return mid ` `                 ``if(x < mid ) no low = mid + 1` `      ``step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};` `                ``check while(low < = high)` `                 ``condition break and return low which will next greater of target """`   `# Driver program to check above functions` `arr ``=` `[``1``, ``2``, ``8``, ``10``, ``10``, ``12``, ``19``]` `n ``=` `len``(arr)` `x ``=` `8` `index ``=` `ceilSearch(arr, ``0``, n ``-` `1``, x)` `if` `(index ``=``=` `-``1``):` `    ``print``(``"Ceiling of"``, x, ``"does not exist in an array"``)` `else``:` `    ``print``(``"Ceiling of"``, x, ``"is"``, arr[index])`

Output

`Ceiling of 8 is 8`

Time Complexity: O(log(n)), where n is the length of the given array, Auxiliary Space: O(1)