How to find minimum value from vector with some condition? - c++

Question

I need to get the min element value (x) in a vector.
Given the index i of x, I need to check if flag[i] == 0 to return i.
I don't want to sort or discard any value because I need its ordinal number, I need the vector to hold its "structure".
How can I get the index of that minimum element?
A = {1, 2, 3, 4, 0, -1}
flag = {0, 0, 1, 0, 1, 1}
min_element = -1, but flag[5] = 1, same for element 0, so min_element should be 1 at index 0.
Ps: I want to shortest solution

Answer 1

You can have a filter view of A with only the elements where flag is 0, and pass that to std::ranges::min.
With C++23 range views:
namespace views = std::ranges::views;
// min is undefined if passed an empty range
assert(std::ranges::any_of(flag, [](auto f){ return f == 0; });
auto value = std::ranges::min(views::zip(A, flag)
| views::filter([](auto && item){ return std::get<1>(item) == 0; })
| views::transform([](auto && item){ return std::get<0>(item); }));
See it on godbolt

Answer 2

If you store both arrays in a single std::vector<std::pair<int,int>> you can use std::min_element directly:
#include <vector>
#include <iostream>
#include <algorithm>
int main() {
std::vector<int> A = {1, 2, 3, 4, 0, -1};
std::vector<int> flag = {0, 0, 1, 0, 1, 1};
std::vector<std::pair<int,int>> flag_and_A;
for (int i=0;i<A.size();++i){
flag_and_A.push_back({flag[i],A[i]});
}
auto it = std::min_element(flag_and_A.begin(),flag_and_A.end());
std::cout << it->second;
}
Live Demo
std::pair::operator< induces a lexicographical odering, ie first first (the flag) is compared then second (A). In other words, entries with flag == 0 are considered smaller than entries with flag == 1.
If you do not want to construct the vector<pair<int,int>> you can still use std::pair::operator< (more precisely the following uses std::tuple<int,int>::operator< which is basically the same):
#include <vector>
#include <iostream>
#include <algorithm>
#include <tuple>
int main() {
std::vector<int> A = {1, 2, 3, 4, 0, -1};
std::vector<int> flag = {0, 0, 1, 0, 1, 1};
auto it = std::min_element(A.begin(),A.end(),[&](const int& a,const int& b){
unsigned index_a = &a - &A[0];
unsigned index_b = &b - &A[0];
return std::tie(flag[index_a],a) < std::tie(flag[index_b],b);
});
std::cout << *it;
}
Live Demo

Answer 3

I think you can make a copy of the vector, to sort, record the min-element,and then clear the copy vector.

Answer 4

#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> A = {1, 2, 3, 4, 0, -1};
vector<int> flag = {0, 0, 1, 0, 1, 1};
size_t index = -1;
int min_value = 0;
for(size_t i = 0; i < A.size(); ++i) {
if ((flag[i] == 0) && (index == -1 || A[i] < min_value)) {
index = i;
min_value = A[i];
}
}
if (index == -1) {
cout << "not found";
}
else {
cout << "min is A[" << index << "]: " << A[index];
}
return 0;
}
Online demo