# Floor of every element in same array

Given an array of integers, find the closest smaller or same element for every element. If all elements are greater for an element, then print -1. We may assume that the array has at least two elements.

**Examples:**

Input : arr[] = {10, 5, 11, 10, 20, 12}

Output : 10 -1 10 10 12 11

Note that there are multiple occurrences of 10, so floor of 10 is 10 itself.Input : arr[] = {6, 11, 7, 8, 20, 12}

Output : -1 8 6 7 12 11

A **simple solution** is to run two nested loops. We pick an outer element one by one. For every picked element, we traverse remaining array and find closest greater element. Time complexity of this solution is O(n*n)

An **better solution **is to sort the array and create a sorted copy, then do binary search for floor. We traverse the array, for every element we search for the first occurrence of an element that is greater than or equal to given element. Once we find such an element, we check if next of it is also same, if yes, then there are multiple occurrences of the element, so we print the same element as output. Otherwise we print previous element in the sorted array. In C++, lower_bound() returns iterator to the first greater or equal element in a sorted array.

## C++

`// C++ implementation of efficient algorithm to find ` `// floor of every element ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Prints greater elements on left side of every element ` `void` `printPrevGreater(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// Create a sorted copy of arr[] ` ` ` `vector<` `int` `> v(arr, arr + n); ` ` ` `sort(v.begin(), v.end()); ` ` ` ` ` `// Traverse through arr[] and do binary search for ` ` ` `// every element. ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// Floor of first element is -1 if there is only ` ` ` `// one occurrence of it. ` ` ` `if` `(arr[i] == v[0]) { ` ` ` `(arr[i] == v[1]) ? cout << arr[i] : cout << -1; ` ` ` `cout << ` `" "` `; ` ` ` `continue` `; ` ` ` `} ` ` ` ` ` `// Find the first element that is greater than or ` ` ` `// or equal to given element ` ` ` `auto` `it = lower_bound(v.begin(), v.end(), arr[i]); ` ` ` ` ` `// If next element is also same, then there ` ` ` `// are multiple occurrences, so print it ` ` ` `if` `(it != v.end() && *(it + 1) == arr[i]) ` ` ` `cout << arr[i] << ` `" "` `; ` ` ` ` ` `// Otherwise print previous element ` ` ` `else` ` ` `cout << *(it - 1) << ` `" "` `; ` ` ` `} ` `} ` ` ` `/* Driver program to test insertion sort */` `int` `main() ` `{ ` ` ` `int` `arr[] = { 6, 11, 7, 8, 20, 12 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` `printPrevGreater(arr, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of efficient ` `# algorithm to find floor of every element ` ` ` `# Prints greater elements on left ` `# side of every element ` `def` `printPrevGreater(arr, n) : ` ` ` ` ` `# Create a sorted copy of arr ` ` ` `v ` `=` `arr.copy() ` ` ` `v.sort() ` ` ` ` ` ` ` `# Traverse through arr[] and do ` ` ` `# binary search for every element. ` ` ` `for` `i ` `in` `range` `(n) : ` ` ` ` ` `# Floor of first element is -1 if ` ` ` `# there is only one occurrence of it. ` ` ` `if` `(arr[i] ` `=` `=` `v[` `0` `]) : ` ` ` `if` `(arr[i] ` `=` `=` `v[` `1` `]) : ` ` ` `print` `(arr[i], end ` `=` `" "` `) ` ` ` ` ` `else` `: ` ` ` `print` `(` `-` `1` `, end ` `=` `" "` `) ` ` ` ` ` `continue` ` ` ` ` `# Find the first element that is greater ` ` ` `# than or or equal to given element ` ` ` `if` `v.count(arr[i]) > ` `0` `: ` ` ` `it ` `=` `v[v.index(arr[i])] ` ` ` `else` `: ` ` ` `it ` `=` `v[n ` `-` `1` `] ` ` ` ` ` `# If next element is also same, then there ` ` ` `# are multiple occurrences, so print it ` ` ` `if` `(it !` `=` `v[n ` `-` `1` `] ` `and` ` ` `v[v.index(it) ` `+` `1` `] ` `=` `=` `arr[i]) : ` ` ` `print` `(arr[i], end ` `=` `" "` `) ` ` ` ` ` `# Otherwise print previous element ` ` ` `else` `: ` ` ` `print` `(v[v.index(it) ` `-` `1` `], end ` `=` `" "` `) ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `arr ` `=` `[ ` `6` `, ` `11` `, ` `7` `, ` `8` `, ` `20` `, ` `12` `] ` ` ` `n ` `=` `len` `(arr) ` ` ` `printPrevGreater(arr, n) ` ` ` `# This code is contributed by Ryuga ` |

*chevron_right*

*filter_none*

**Output:**

-1 8 6 7 12 11

Time Complexity : O(n Log n)

Auxiliary Space : O(n)

## Recommended Posts:

- Floor in a Sorted Array
- Finding Floor and Ceil of a Sorted Array using C++ STL
- Find floor and ceil in an unsorted array
- Closest greater element for every array element from another array
- Replace each element by the difference of the total size of the array and frequency of that element
- Range Query on array whose each element is XOR of index value and previous element
- Find last element after deleting every second element in array of n integers
- Sum of (maximum element - minimum element) for all the subsets of an array.
- Replace every array element by Bitwise Xor of previous and next element
- Replace every element of the array by its previous element
- Find an element in array such that sum of left array is equal to sum of right array
- Replace every element of the array by its next element
- Find element in array that divides all array elements
- For each element in 1st array count elements less than or equal to it in 2nd array
- Construct an array from XOR of all elements of array except element at same index

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.