一般来说，这是可读性差的原因：

auto min = std::get<1>(
    std::ranges::min(
        std::views::zip(valid, percentages) | 
        std::views::filter([](const auto& vals) {return std::get<0>(vals);}), 
    [](const auto& vals0, const auto& vals1) {
    return std::get<1>(vals0) < std::get<1>(vals1);
}));

这是一个错误的算法--你想找到最小的 percentage，但是你现在的算法是按百分比找到最小的 * 对（valid，percentage）*。
简单地重构到正确的算法（最小百分比）是一个很大的改进：

auto min = 
    std::ranges::min(
        std::views::zip(valid, percentages)
        | std::views::filter([](const auto& vals) {return std::get<0>(vals);})
        | std::views::values);

现在有一个提议（P2769），让你把lambda写成std::ranges::get_key（或者std::ranges::get_element<0>）。
还要注意，传入min的 predicate 并不是绝对必要的--默认的<已经做了正确的事情，因为该范围内的所有元组现在都是(true, x)，所以根据定义，那里的最小值是x最小的值。
这是其中一种情况，就像我们缺少了一个算法：

ranges::min(
    views::zip(valid, percentages)
    | views::filter_map([](auto&& e) -> optional<int> {
        auto& [valid, perc] = e;
        if (valid) {
            return perc;
        } else {
            return nullopt;
        }
    })
);

其中，filter_map取T -> optional<U>，并生成范围U。
不过，在这种情况下，你可以作弊--你用for循环编写的算法可以用transform来完成：你把无效电池Map到100：

ranges::min(
    views::zip(valid, percentages)
    | views::transform([](auto&& e) {
        auto& [valid, perc] = e;
        return valid ? perc : 100;
    })
);

或者更直接地说：

ranges::min(
    views::zip_transform([](bool valid, int perc){
        return valid ? perc : 100;
    }, valid, percentages)
);

这在没有有效电池的情况下有不同的语义（你得到一个定义良好的100而不是UB）。尽管你的循环即使在没有电池的情况下也是定义良好的（你得到100），而在这里空的情况下仍然是UB。

我觉得如果你给这些羊起个名字的话是很容易理解的：

auto is_valid = [](auto const& zipped) { return std::get<0>(zipped); };

auto min = std::ranges::min(
    std::views::zip(valid, percentages) |
    std::views::filter(is_valid) |
    std::views::values
);

https://godbolt.org/z/95T8xsq68

关于：

namespace rv=std::views;
auto min = std::ranges::min(
    rv::zip(valid, percentages) | 
    rv::filter([](const auto& x)
        {return std::get<0>(x);}) |
    rv::values);

同样，您可以使用rv::elements<1>代替rv::values。

理想情况下，我们可以只传递std::get<0>作为过滤函数。
不幸的是，编译器无法推导出重载，所以我们必须用lambda来帮助它。由于这是一个常见的问题（How do I specify a pointer to an overloaded function?），在您的项目中为它提供一个帮助宏可能是合理的：

#define AS_LAMBDA(...) [&](auto&&... args)                          \
    -> decltype(__VA_ARGS__(std::forward<decltype(args)>(args)...)) \
{                                                                   \
    return __VA_ARGS__(std::forward<decltype(args)>(args)...);      \
}

这使得代码看起来如下所示：

auto min = std::ranges::min(
   std::views::zip(valid, percentages) |
   std::views::filter(AS_LAMBDA(std::get<0>)) |
   std::views::elements<1>
);

https://godbolt.org/z/Gaa1ErdGG