# How to compose generators with STL algorithms

Here's how I would write the function in c++20, using range views and algorithms so that there isn't a separate container that stores the intermediate results:

```
double get_minimum_cost(auto const & inp)
{
namespace rs = std::ranges;
namespace rv = std::ranges::views;
// for each i compute the minimum cost for all j's
auto min_cost_from_i = [&](auto i)
{
auto costs_from_i = rv::iota(i + 1, inp.size())
| rv::transform([&](auto j)
{
return cost(inp[i], inp[j]);
});
return *rs::min_element(costs_from_i);
};
// compute min costs for all i's
auto all_costs = rv::iota(0u, inp.size())
| rv::transform(min_cost_from_i);
return *rs::min_element(all_costs);
}
```

Here's a demo.

Note that the solution doesn't compare the cost between same elements, since the `cost`

function example you showed would have a trivial result of 0. For a cost function that doesn't return 0, you can adapt the solution to generate a range from `i`

instead of `i + 1`

. Also, if the `cost`

function is not symmetric, make that range start from 0 instead of `i`

.

Also, this function has UB if you call it with an empty range, so you should check for that as well.