(def v1 (list (list 3 4 5 1 7)
              (list 1 3 6 3 8)))

(-> v1
    flatten
    distinct
    sort
    (#(take 3 %)))

std::vector<std::vector<size_t>> v1 = { { 3, 4, 5, 1, 7 }, { 1, 3, 6, 3, 8 } };

std::vector<size_t> joined = v1 | ranges::views::join | ranges::views::unique |
                                 ranges::to<std::vector<size_t>> | ranges::actions::sort;
std::vector<size_t> res( joined.begin(), joined.begin() + 3 );

KP>Пока что у меня на C++ вышла вот такая хреновина, которая, почему-то, отказывается убирать дубликаты

  std::vector<size_t> res = v1 | ranges::views::join
                               | ranges::to_vector
                               | ranges::actions::sort
                               | ranges::actions::unique
                               | ranges::actions::take (3);

F>  std::vector<size_t> res = v1 | ranges::views::join
F>                               | ranges::to_vector
F>                               | ranges::actions::sort
F>                               | ranges::actions::unique
F>                               | ranges::actions::take (3);

F>

views::unique
Given a range, return a new range where all consecutive elements that compare equal save the first have been filtered out.

views::unique
Given a range, return a new range where all consecutive elements that compare equal save the first have been filtered out.

template <typename T>
std::vector<std::vector<T>> transpose( const std::vector<std::vector<T>> &inputs )
{
    assert( !inputs.empty() );
    size_t                      line_len  = inputs[0].size();
    size_t                      input_len = inputs.size();
    std::vector<std::vector<T>> res( line_len );
    for( size_t n = 0; n < input_len; n++ )
    {
        const auto &in_line = inputs[n];
        assert( line_len == in_line.size() );
        for( size_t m = 0; m < line_len; m++ )
        {
            res[m].emplace_back( in_line[m] );
        }
    }

    return res;
}

(defn transpose [v]
  (apply mapv vector v))

Преждевременная оптимизация — корень всех (или большинства) проблем в программировании.

Дональд Кнут

Ш>Не для этого С+ создан!

Ш>Поделись рецептиком!

(distinct [2 2 1 5 4 4 4 ])
=>; (2 1 5 4)

(distinct [2 2 1 5 4 4 4 ])
=> (2 1 5 4)

(-> [2 2 1 5 4 4 4 ]
    distinct
    sort)
=> (1 2 4 5)

iex(5)> [2, 2, 1, 5, 4, 4, 4] |> Enum.uniq
[2, 1, 5, 4]
iex(6)> [2, 2, 1, 5, 4, 4, 4] |> Enum.uniq |> Enum.sort
[1, 2, 4, 5]

EP> Но, даже если не знать про std::unique, а только про uniq — то существование такого интерфейса (отличного от distinct) должно натолкнуть на мысль таки заглянуть в документацию, и прочитать что именно делает используемая команда, а не строить догадки. В то что ты не знал ни про uniq, ни про std::unique — верится с трудом

EP>Это странный пример в обсуждаемом контексте, так как unique/uniq выдаст такой же результат

(distinct [2 4 1 2 5 4 4 ])
=> (2 4 1 5)

def kth(a, n):
    m = a.shape[0]
    perc = (np.arange(m-n,m)+1.0)/m*100
    return np.percentile(a, perc)