如何获取属于某个范围的向量中的最大元素？

Question

虽然有一个明确的 for 循环解决方案，但我一直在寻找一种解决方案来获得给定范围内向量中的最大值。

例如假设一个向量有3,5,7,9,5,1,6,7,4,2，给定的范围是[4,8]，那么最大元素应该是7。

我一直在寻找一种使用一些内置标准库函数的单行/短解决方案。

数组包含所有正数。

这是我尝试过的：

int max = -1;
for (i = 0; i < n; i++)
    if (arr[i] > max && arr[i] >= low && arr[i] <= high)
        max = arr[i];

我只是在寻找一个简单的标准库矢量解决方案。

Answer 1

这是一个利用两个标准库函数std::sort 和std::find_first_of：

#include <iostream>
#include <vector>
#include <tuple>
#include <algorithm>

// Find max element of sample vector within range of val_range.
using namespace std;

int main()
{
    vector<int> sample = { 3,5,7,9,5,1,6,7,4,2 };
    vector<int> val_range = { 4,8 };

    // Sort in reverse order
    sort(sample.begin(), sample.end(), greater<int>());
    vector<int>::iterator it = find_first_of(sample.begin(), sample.end(), val_range.begin(), val_range.end(), [](int value, int max_val) {return value <= max_val;} );
    cout << (*it) << endl;
}

See Live Demo

Answer 2

类似于@Yksisarvinen's answer，但使用std::tuple 的< 来缩短它。

前提条件是输入的范围内至少有一个元素。

#include <cassert>
#include <algorithm>
#include <tuple>
#include <vector>

int main() {
    std::vector<int> arr {3,5,7,9,5,1,6,7,4,2};
    int lowerLimit = 4;
    int upperLimit = 8;
    
    auto inRange = [lowerLimit, upperLimit](int value)
    {
        return value >= lowerLimit && value <= upperLimit;
    };
    auto compare = [inRange](int lhs, int rhs) {
        return std::tuple(inRange(lhs), lhs) < std::tuple(inRange(rhs), rhs);
    };
    
    assert(!arr.empty());
    assert(std::any_of(arr.begin(), arr.end(), inRange));
    auto it = std::max_element(arr.begin(), arr.end(), compare);
    int max = *it;
}

Answer 3

虽然其他人已经展示了使用标准算法的可行解决方案，但我想建议一种类似于 std::max_element 实现的解决方案。在这里，当您为算法函数提供无效范围时，您将获得更大的灵活性。

#include <iterator> std::iterator_traits

template<typename Iterator>
using EleType = typename std::iterator_traits<Iterator>::value_type;

template< class Iterator>
auto my_max_element(Iterator first, const Iterator last,
    EleType<Iterator> minValue, EleType<Iterator> maxValue)
{
    Iterator largest = first;
    for (; first != last; ++first)
        if (minValue <= *first && *first <= maxValue && *largest < *first)
            largest = first;
    // final range check for the largest element
    return (minValue <= *largest && *largest <= maxValue) ? largest : last;
}

(See a Live Demo)

Answer 4

在一行中压缩太多或总是使用算法并不总是值得的，尤其是当循环清晰易读时。无论如何，如果您愿意，可以使用std::accumulate。二进制操作与您的原始代码非常接近，我只是使用条件运算符而不是 if：

auto x = std::accumulate(arr.begin(),arr.end(),-1,[high,low](int accu,int elem){
    return (elem > accu && elem >= low && elem <= high ) ? elem : accu;
});

Live Demo

Answer 5

这远非单行（除非您认为辅助函数不是代码的一部分，那么它肯定是一行），但是如果您真的想使用标准算法，您需要一个比较函数，它将符合严格的弱序。

bool inRange(int value, int lowerLimit, int upperLimit)
{
    return value >= lowerLimit && value <= upperLimit;
}

std::vector<int> arr {3,5,7,9,5,1,6,7,4,2};
    
int lowerLimit = 4;
int upperLimit = 8;
auto compare = [lowerLimit, upperLimit](int l, int r){
    if(inRange(l, lowerLimit, upperLimit) && inRange(r, lowerLimit, upperLimit)) {
        // both values are in range, so compare them
        return l < r;
    } else if (inRange(r, lowerLimit, upperLimit)) {
        // r is in range, l is not, l should compare smaller
        return true;
    } else if (inRange(l, lowerLimit, upperLimit)) {
        // l is in range, r is not, r should compare smaller
        return false;
    } else {
        // both are out of range, compare them normally to keep strict weak ordering requirements
        return l < r;
    }
};

auto maxIter = std::max_element(std::begin(arr), std::end(arr), compare);
std::cout << "Max value is " << *maxIter;