Q:

c++ max_element every n element

Is there a way to find the max element in a container comparing every N elements and return the index. Using STL, BOOST, or... another lib?
with every N, I mean use the std::max_element, but change the increase in the for, from ++first, to first += n;
// based on std::max_element

#ifndef NEWTON_ALGORITHM_SEARCH_MAX_INDEX_HPP
#define NEWTON_ALGORITHM_SEARCH_MAX_INDEX_HPP

#include <iterator>

#include <newton/functional.hpp>

namespace newton {

  // SAME THAT STD::MAX_ELEMENT
  template<class ForwardIt, class Compare>
  const ForwardIt max_index(ForwardIt first, ForwardIt last, Compare comp)
  {

    if ( newton::equal(first, last) ) // newton::equal is basically equivalent to std::equal_to
      return last;

    ForwardIt largest = first;
    while ( newton::not_equal(++first, last) )
      if (comp(*largest, *first))
        largest = first;

    return largest;

  }

  // possible names
  // max_index_some
  // max_index_every_n
  // max_index__n

  template<class ForwardIt, class Size, class Compare>
  const ForwardIt max_index_every_n(ForwardIt first, ForwardIt last, Size n, Compare comp)
  {

    if ( newton::equal(first, last) )
      return last;

    ForwardIt largest = first;
    Size blocks = std::distance(first, last) / n; // integer blocks

    if ( newton::greater_equal(blocks, 1) ) {

      // if there are exacly N elements, can't sum example
      // v.size() = 10, first start in 0, so "0 += 10" is "10", but last index is "9"
      // but if mod >= 1, then index is at least 10, so can sum

      if ( newton::greater_equal( std::distance(first, last) % n, 1) ) {
        for (size_t i = 1; newton::less_equal(i, blocks); ++i, first += n) {

          if (comp(*largest, *first))
            largest = first;
        }
      }
      else {

        for (size_t i = 1; newton::less(i, blocks); ++i, first += n) {

          if (comp(*largest, *first))
            largest = first;
        }

      }

    }

    return largest;

  }

  template<class ForwardIt>
  const ForwardIt max_index(ForwardIt first, ForwardIt last)
  {
    return max_index(first, last, newton::structure::less());
  }
} // newton

if there is not, whats your solution to try to include it in a next STL version. remember

A:

With range-v3, it would be:
auto r = v | ranges::view::stride(n);
auto it = ranges::max_element(r);

A:

Using just Boost ("Range V2" so to speak):
Live On Coliru
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/range/algorithm_ext.hpp>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v(100);
    boost::iota(v, 0);

    int n = 17;
    auto it = boost::max_element(v | boost::adaptors::strided(n));

    std::cout << "max: " << *it << "\n";
}

Prints
max: 85

Alternative Usage
You don't have to use range algorithms and all. You can also pick as you require:
Live On Coliru
#include <boost/range/adaptor/strided.hpp>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v { 1,2,3,4,5,6,7,8,9,10 };

    auto v_ = boost::adaptors::stride(v, 7);
    auto it = std::max_element(v_.begin(), v_.end());

    std::cout << "max: " << *it << "\n";
}

Prints
max: 8

