类似lower_bound（）的算法，但是另一个

Question

There is a upper_bound() , returns an iterator to the first element that is than val.

There is a lower_bound() , returns an iterator to the first element that is than val.

Is there an algorithm that returns an iterator to the first element that is than val, or I have to reinvent the wheel?

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    std::vector<int> data = { 1, 1, 2, 3, 3, 3, 3, 5, 5, 6 };

    auto lower = std::lower_bound(data.begin(), data.end(), 4, [](int x, int y) {return x > y;});

    cout << *lower ;
}

Output: 1, expexted 3

Note that another predicate like std::greater<> doesn't work.

Answer 1

只需在您的代码中使用谓词，但是使用rbegin和rend以相反的顺序遍历它

Answer 2

My two bits, you forgot to sort in descending order.

int main()
{
    vector<int> data = { 1, 1, 2, 3, 3, 3, 3, 5, 5, 6 };

    int wanted {4};
    sort(begin(data), end(data), greater<int>());
    auto bound =  upper_bound(begin(data), end(data), wanted, greater<int>());
    cout << "val with upper_bound: " << *bound << endl;


}

result:  val with upper_bound: 3

or one step below with partition_point:

template <typename T>
struct greater_than {
    T x;
    bool operator()(const T& y) { return y > x; }
};

int main() 
{
 ...
 auto p_point = partition_point(begin(data), end(data),
                               greater_than<int>{wanted});

 cout << "val with partition_point: " << *p_point << endl;
// val with partition_point: 3