Payout for cabbies

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
#include <cassert>
#include <numeric>

template <typename TCont>
void print(const TCont& s, std::string delim = " ")
{
    std::ranges::copy(s, std::ostream_iterator<typename TCont::value_type>(std::cout, delim.c_str()));
    std::cout << std::endl;
}

template <template <typename> class TCont, typename TType>
TCont<TType> fill_from(int count, std::istream& from)
{
    TCont<TType> seq;
    seq.reserve(count);

    std::ranges::copy(
        std::ranges::istream_view<TType>(from),
        std::inserter(seq, seq.end()));

    return seq;
}

int get_minimum_cash(const std::vector<int>& rankings)
{
    constexpr int BaseSum = 500;

    std::vector<int> bonuses(rankings.size());

    auto find_not_payed_min = [&rankings, &bonuses]() -> int
    {
        int min_idx = -1;
        for (auto i = 0; i < rankings.size(); ++i)
        {
            if (bonuses[i] != 0)
            {
                continue;
            }

            if (min_idx == -1 || rankings[i] < rankings[min_idx])
            {
                min_idx = i;
            }
        }
        return min_idx;
    };

    for (int min_idx = find_not_payed_min(); min_idx != -1; min_idx = find_not_payed_min())
    {
        bonuses[min_idx] = BaseSum;

        for (auto i = min_idx - 1; i >= 0 && rankings[i] > rankings[i + 1] && bonuses[i] == 0; --i)
        {
            bonuses[i] = bonuses[i + 1] + BaseSum;
        }
        for (auto i = min_idx + 1; i < rankings.size() && rankings[i] > rankings[i - 1] && bonuses[i] == 0; ++i)
        {
            bonuses[i] = bonuses[i - 1] + BaseSum;
        }
    }
    int result = std::accumulate(bonuses.begin(), bonuses.end(), 0);
    return result;
}

void run_tests()
{
    {
        std::vector<int> ratings = {1, 2, 3, 4};
        assert(get_minimum_cash(ratings) == 5000);
    }
    {
        std::vector<int> ratings = {5, 5, 5, 5};
        assert(get_minimum_cash(ratings) == 2000);
    }
    {
        std::vector<int> ratings = {4, 2, 3, 3};
        assert(get_minimum_cash(ratings) == 3000);
    }
    {
        std::vector<int> ratings = {1};
        assert(get_minimum_cash(ratings) == 500);
    }
    {
        std::vector<int> ratings = {0};
        assert(get_minimum_cash(ratings) == 500);
    }
    {
        std::vector<int> ratings = {4, 3, 2, 1};
        assert(get_minimum_cash(ratings) == 5000);
    }
    {
        std::vector<int> ratings = {1, 1, 2, 3};
        assert(get_minimum_cash(ratings) == 3500);
    }
    {
        std::vector<int> ratings = {1, 4, 1, 3};
        assert(get_minimum_cash(ratings) == 3000);
    }
    {
        std::vector<int> ratings = {1, 4, 4, 1};
        assert(get_minimum_cash(ratings) == 3000);
    }
    {
        std::vector<int> ratings = {1, 4, 4, 5};
        assert(get_minimum_cash(ratings) == 3000);
    }
    {
        std::vector<int> ratings = {4, 4, 5, 5};
        assert(get_minimum_cash(ratings) == 2500);
    }
    {
        std::vector<int> ratings = {4, 3, 2, 1, 2, 3, 4};
        assert(get_minimum_cash(ratings) == 9500);
    }
    {
        std::vector<int> ratings = {4, 3, 2, 1, 1, 2, 3, 4};
        assert(get_minimum_cash(ratings) == 10000);
    }
    {
        std::vector<int> ratings = {1, 2, 3, 4, 4, 3, 2, 1};
        assert(get_minimum_cash(ratings) == 10000);
    }
    {
        std::vector<int> ratings = {1, 2, 3, 4, 3, 2, 1};
        assert(get_minimum_cash(ratings) == 8000);
    }
    {
        std::vector<int> ratings = {2, 3, 5, 4, 1, 5, 1, 3, 1};
        assert(get_minimum_cash(ratings) == 7500);
    }
    {
        std::vector<int> ratings = {4, 1, 5, 1, 3, 1};
        assert(get_minimum_cash(ratings) == 4500);
    }
    {
        std::vector<int> ratings = {4, 1, 2, 4, 4, 2, 1, 3};
        assert(get_minimum_cash(ratings) == 8000);
    }
}

int main()
{
    run_tests();
//    int n;
//    std::cin >> n;
//
//    std::vector<int> rankings = fill_from<std::vector, int>(n, std::cin);
//    std::cout << get_minimum_cash(rankings) << std::endl;
}