Find floor and ceil in an unsorted array

Last Updated : 08 Sep, 2023

Given an unsorted array arr[] and an element x, find floor and ceiling of x in arr[0..n-1].
Floor of x is the largest element which is smaller than or equal to x. Floor of x doesn’t exist if x is smaller than smallest element of arr[].
Ceil of x is the smallest element which is greater than or equal to x. Ceil of x doesn’t exist if x is greater than greatest element of arr[].

Examples:

Input : arr[] = {5, 6, 8, 9, 6, 5, 5, 6}                x = 7  Output : Floor = 6           Ceiling = 8    Input : arr[] = {5, 6, 8, 9, 6, 5, 5, 6}                x = 6  Output : Floor = 6           Ceiling = 6    Input : arr[] = {5, 6, 8, 9, 6, 5, 5, 6}                x = 10  Output : Floor = 9           Ceiling doesn't exist.

Method 1 (Use Sorting):

Sort input array.
Use binary search to find floor and ceiling of x. Refer this and this for implementation of floor and ceiling in a sorted array.

C++

   #include <bits/stdc++.h> 
using namespace std; 
  
// Solution 
vector<int> floorAndCeil(vector<int> arr, int n, int x) 
{ 
    vector<int> result(2); 
  
    int low = 0, high = n - 1; 
  
    while (low <= high) { 
        int mid = low + (high - low) / 2; 
        if (arr[mid] > x) { 
            high = mid - 1; 
        } 
        else if (arr[mid] < x) { 
            low = mid + 1; 
        } 
        else { 
            result[0] = arr[mid]; 
            result[1] = arr[mid]; 
            return result; 
        } 
    } 
  
    // if loop breaks 
    result[0] = (high == -1) ? -1 : arr[high]; 
    result[1] = (low == arr.size()) ? -1 : arr[low]; 
  
    return result; 
} 
  
// Driver 
int main() 
{ 
    vector<int> arr = { 5, 6, 8, 9, 6, 5, 5, 6 }; 
    int n = arr.size(); 
    int x = 7; 
  
    vector<int> result = floorAndCeil(arr, n, x); 
    cout << "floor is " << result[0] << endl; 
    cout << "ceil is " << result[1] << endl; 
    return 0; 
} // this code is contributed by devendradany
 
  

Java

   import java.util.*; 
  
public class Main { 
  
    // Solution 
    public static int[] floorAndCeil(int[] arr, int n, 
                                     int x) 
    { 
  
        int[] result = new int[2]; 
  
        int low = 0, high = n - 1; 
  
        while (low <= high) { 
            int mid = low + (high - low) / 2; 
            if (arr[mid] > x) { 
                high = mid - 1; 
            } 
            else if (arr[mid] < x) { 
                low = mid + 1; 
            } 
            else { 
                Arrays.fill(result, arr[mid]); 
                return result; 
            } 
        } 
  
        // if loop breaks 
        result[0] = (high == -1) ? -1 : arr[high]; 
        result[1] = (low == arr.length) ? -1 : arr[low]; 
  
        return result; 
    } 
  
    // Driver 
    public static void main(String[] args) 
    { 
  
        int[] arr = { 5, 6, 8, 9, 6, 5, 5, 6 }; 
        int n = arr.length; 
        int x = 7; 
  
        int[] result = floorAndCeil(arr, n, x); 
        System.out.println("floor is " + result[0]); 
        System.out.println("ceil is " + result[1]); 
    } 
}
 
  

Python3

   #Equivalent Python code for the given Java code 
  
#The binary search algorithm used in the code can be implemented similarly in Python 
  
def floor_and_ceil(arr, n, x): 
    result = [0, 0] 
  
    low = 0
    high = n - 1
  
    while low <= high: 
        mid = low + (high - low) // 2
        if arr[mid] > x: 
            high = mid - 1
        elif arr[mid] < x: 
            low = mid + 1
        else: 
            result = [arr[mid], arr[mid]] 
            return result 
  
    # if loop breaks 
    result[0] = -1 if high == -1 else arr[high] 
    result[1] = -1 if low == n else arr[low] 
  
    return result 
  
if __name__ == '__main__': 
    arr = [5, 6, 8, 9, 6, 5, 5, 6] 
    n = len(arr) 
    x = 7
      
    result = floor_and_ceil(arr, n, x) 
    print("floor is", result[0]) 
    print("ceil is", result[1]) 
 
  

C#

   using System; 
  
public class GFG { 
  
  // Solution 
  public static int[] floorAndCeil(int[] arr, int n, 
                                   int x) 
  { 
  
    int[] result = new int[2]; 
  
    int low = 0, high = n - 1; 
  
    while (low <= high) { 
      int mid = low + (high - low) / 2; 
      if (arr[mid] > x) { 
        high = mid - 1; 
      } 
      else if (arr[mid] < x) { 
        low = mid + 1; 
      } 
      else { 
        result[0] = arr[mid]; 
        result[1] = arr[mid]; 
        return result; 
      } 
    } 
  
    // if loop breaks 
    result[0] = (high == -1) ? -1 : arr[high]; 
    result[1] = (low == arr.Length) ? -1 : arr[low]; 
  
    return result; 
  } 
  
  static public void Main() 
  { 
  
    int[] arr = { 5, 6, 8, 9, 6, 5, 5, 6 }; 
    int n = arr.Length; 
    int x = 7; 
  
    int[] result = floorAndCeil(arr, n, x); 
    Console.WriteLine("floor is " + result[0]); 
    Console.WriteLine("ceil is " + result[1]); 
  } 
} 
  
// This code is contributed by akashish__
 
  

Javascript

   // JavaScript code equivalent to given Python code 
  
function floorAndCeil(arr, n, x) { 
let result = [0, 0]; 
let low = 0; 
let high = n - 1; 
  
while (low <= high) { 
    let mid = low + Math.floor((high - low) / 2); 
    if (arr[mid] > x) { 
        high = mid - 1; 
    } else if (arr[mid] < x) { 
        low = mid + 1; 
    } else { 
        result = [arr[mid], arr[mid]]; 
        return result; 
    } 
} 
  
// if loop breaks 
result[0] = (high == -1) ? -1 : arr[high]; 
result[1] = (low == n) ? -1 : arr[low]; 
  
return result; 
} 
  
let arr = [5, 6, 8, 9, 6, 5, 5, 6]; 
let n = arr.length; 
let x = 7; 
  
let result = floorAndCeil(arr, n, x); 
console.log('floor is '+result[0]); 
console.log('ceil is '+result[1]);
 
  

Output

floor is 6  ceil is 8

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

This solution is works well if there are multiple queries of floor and ceiling on a static array. We can sort the array once and answer the queries in O(Log n) time.

Method 2 (Use Linear Search:

The idea is to traverse array and keep track of two distances with respect to x.

Minimum distance of element greater than or equal to x.
Minimum distance of element smaller than or equal to x.

Finally print elements with minimum distances.

C++

   // C++ program to find floor and ceiling in an  
// unsorted array.  
#include<bits/stdc++.h>  
using namespace std;  
  
// Function to floor and ceiling of x in arr[]  
void floorAndCeil(int arr[], int n, int x)  
{  
    // Indexes of floor and ceiling  
    int fInd, cInd;  
  
    // Distances of current floor and ceiling  
    int fDist = INT_MAX, cDist = INT_MAX;  
  
    for (int i=0; i<n; i++)  
    {  
        // If current element is closer than  
        // previous ceiling.  
        if (arr[i] >= x && cDist > (arr[i] - x))  
        {  
        cInd = i;  
        cDist = arr[i] - x;  
        }  
  
        // If current element is closer than  
        // previous floor.  
        if (arr[i] <= x && fDist > (x - arr[i]))  
        {  
        fInd = i;  
        fDist = x - arr[i];  
        }  
    }  
  
    if (fDist == INT_MAX)  
    cout << "Floor doesn't exist " << endl;  
    else
    cout << "Floor is " << arr[fInd] << endl;  
  
    if (cDist == INT_MAX)  
    cout << "Ceil doesn't exist " << endl;  
    else
    cout << "Ceil is " << arr[cInd] << endl;  
}  
  
// Driver code  
int main()  
{  
    int arr[] = {5, 6, 8, 9, 6, 5, 5, 6};  
    int n = sizeof(arr)/sizeof(int);  
    int x = 7;  
    floorAndCeil(arr, n, x);  
    return 0;  
}  
 
  

Java

   // Java program to find floor and ceiling in an 
// unsorted array. 
import java.io.*; 
  
class GFG  
{ 
     // Function to floor and ceiling of x in arr[] 
    public static void floorAndCeil(int arr[], int x) 
    { 
        int n = arr.length; 
          
        // Indexes of floor and ceiling 
        int fInd = -1, cInd = -1; 
   
        // Distances of current floor and ceiling 
        int fDist = Integer.MAX_VALUE, cDist = Integer.MAX_VALUE; 
   
        for (int i = 0; i < n; i++) 
        { 
            // If current element is closer than 
            // previous ceiling. 
            if (arr[i] >= x && cDist > (arr[i] - x)) 
            { 
                cInd = i; 
                cDist = arr[i] - x; 
            } 
   
            // If current element is closer than 
            // previous floor. 
            if (arr[i] <= x && fDist > (x - arr[i])) 
            { 
                fInd = i; 
                fDist = x - arr[i]; 
            } 
        } 
   
        if(fDist == Integer.MAX_VALUE) 
            System.out.println("Floor doesn't exist " ); 
        else
            System.out.println("Floor is " +  arr[fInd]); 
   
        if(cDist == Integer.MAX_VALUE) 
            System.out.println("Ceil doesn't exist "); 
        else
            System.out.println("Ceil is  " + arr[cInd]); 
    } 
      
    public static void main (String[] args)  
    { 
        int arr[] = {5, 6, 8, 9, 6, 5, 5, 6}; 
        int x = 7; 
        floorAndCeil(arr, x); 
    } 
} 
 
  

Python 3

   # Python 3 program to find  
# floor and ceiling in an 
# unsorted array. 
  
import sys 
  
# Function to floor and 
# ceiling of x in arr[] 
def floorAndCeil(arr, n, x): 
  
    # Distances of current 
    # floor and ceiling 
    fDist = sys.maxsize 
    cDist = sys.maxsize 
  
    for i in range(n): 
      
        # If current element is closer  
        # than previous ceiling. 
        if (arr[i] >= x and 
            cDist > (arr[i] - x)): 
          
            cInd = i 
            cDist = arr[i] - x 
  
        # If current element is closer  
        # than previous floor. 
        if (arr[i] <= x and fDist > (x - arr[i])): 
          
            fInd = i 
            fDist = x - arr[i] 
  
    if (fDist == sys.maxsize): 
        print("Floor doesn't exist ") 
    else: 
        print("Floor is " + str(arr[fInd]))  
  
    if (cDist == sys.maxsize): 
        print( "Ceil doesn't exist ") 
    else: 
        print("Ceil is " + str(arr[cInd])) 
  
# Driver code 
if __name__ == "__main__": 
    arr = [5, 6, 8, 9, 6, 5, 5, 6] 
    n = len(arr) 
    x = 7
    floorAndCeil(arr, n, x) 
  
# This code is contributed  
# by ChitraNayal 
 
  

C#

   // C# program to find floor and ceiling in an 
// unsorted array. 
using System; 
  
class GFG { 
      
    // Function to floor and ceiling of x in arr[] 
    public static void floorAndCeil(int []arr, int x) 
    { 
        int n = arr.Length; 
          
        // Indexes of floor and ceiling 
        int fInd = -1, cInd = -1; 
  
        // Distances of current floor and ceiling 
        int fDist = int.MaxValue, 
            cDist =int.MaxValue; 
              
        for (int i = 0; i < n; i++) 
        { 
              
            // If current element is closer than 
            // previous ceiling. 
            if (arr[i] >= x && cDist > (arr[i] - x)) 
            { 
                cInd = i; 
                cDist = arr[i] - x; 
            } 
  
            // If current element is closer than 
            // previous floor. 
            if (arr[i] <= x && fDist > (x - arr[i])) 
            { 
                fInd = i; 
                fDist = x - arr[i]; 
            } 
        } 
  
        if(fDist == int.MaxValue) 
            Console.Write("Floor doesn't exist " ); 
        else
            Console.WriteLine("Floor is " + arr[fInd]); 
  
        if(cDist == int.MaxValue) 
        Console.Write("Ceil doesn't exist "); 
        else
            Console.Write("Ceil is " + arr[cInd]); 
    } 
      
    // Driver code 
    public static void Main ()  
    { 
        int []arr = {5, 6, 8, 9, 6, 5, 5, 6}; 
        int x = 7; 
          
        floorAndCeil(arr, x); 
    } 
} 
  
// This code is contributed by nitin mittal. 
 
  

PHP

   <?php 
// PHP program to find  
// floor and ceiling in  
// an unsorted array. 
  
// Function to floor and  
// ceiling of x in arr[] 
function floorAndCeil($arr, 
                      $n, $x) 
{ 
    // Indexes of floor 
    // and ceiling 
    $fInd = 0; 
    $cInd = 0; 
  
    // Distances of current 
    // floor and ceiling 
    $fDist = 999999; 
    $cDist = 999999; 
  
    for ($i = 0; $i < $n; $i++) 
    { 
        // If current element  
        // is closer than 
        // previous ceiling. 
        if ($arr[$i] >= $x &&  
            $cDist > ($arr[$i] - $x)) 
        { 
            $cInd = $i; 
            $cDist = $arr[$i] - $x; 
        } 
  
        // If current element  
        // is closer than 
        // previous floor. 
        if ($arr[$i] <= $x &&  
            $fDist > ($x - $arr[$i])) 
        { 
            $fInd = $i; 
            $fDist = $x - $arr[$i]; 
        } 
    } 
  
    if ($fDist == 999999) 
        echo "Floor doesn't ".  
             "exist " . "\n" ; 
    else
        echo "Floor is " .  
              $arr[$fInd] . "\n"; 
  
    if ($cDist == 999999) 
        echo "Ceil doesn't " . 
             "exist " . "\n"; 
    else
        echo "Ceil is " .  
             $arr[$cInd] . "\n"; 
} 
  
// Driver code 
$arr = array(5, 6, 8, 9, 
             6, 5, 5, 6); 
$n = count($arr); 
$x = 7; 
floorAndCeil($arr, $n, $x); 
  
// This code is contributed 
// by Sam007 
?> 
 
  

Javascript

   <script> 
// Javascript program to find floor and ceiling in an 
// unsorted array. 
      
    // Function to floor and ceiling of x in arr[] 
    function floorAndCeil(arr,x) 
    { 
        let n = arr.length; 
            
        // Indexes of floor and ceiling 
        let fInd = -1, cInd = -1; 
     
        // Distances of current floor and ceiling 
        let fDist = Number.MAX_VALUE, cDist = Number.MAX_VALUE; 
     
        for (let i = 0; i < n; i++) 
        { 
            // If current element is closer than 
            // previous ceiling. 
            if (arr[i] >= x && cDist > (arr[i] - x)) 
            { 
                cInd = i; 
                cDist = arr[i] - x; 
            } 
     
            // If current element is closer than 
            // previous floor. 
            if (arr[i] <= x && fDist > (x - arr[i])) 
            { 
                fInd = i; 
                fDist = x - arr[i]; 
            } 
        } 
     
        if(fDist == Number.MAX_VALUE) 
            document.write("Floor doesn't exist <br>" ); 
        else
            document.write("Floor is " +  arr[fInd]+"<br>"); 
     
        if(cDist == Number.MAX_VALUE) 
            document.write("Ceil doesn't exist <br>"); 
        else
            document.write("Ceil is  " + arr[cInd]+"<br>"); 
    } 
      
    let arr=[5, 6, 8, 9, 6, 5, 5, 6]; 
    let x = 7; 
    floorAndCeil(arr, x); 
      
    // This code is contributed by rag2127 
</script>
 
  

Output

Floor is 6  Ceil is 8

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

Related Articles :
Ceiling in a sorted array
Floor in a sorted array

Finding Floor and Ceil of a Sorted Array using C++ STL

DANISH_RAZA

Improve

Article Tags :

Practice Tags :

Find floor and ceil in an unsorted array

C++

Java

Python3

C#

Javascript

C++

Java

Python 3

C#

PHP

Javascript

Similar Reads