chto-to_ochen_plooe

#pragma once
#include <cstdint>
#include <utility>
#include <type_traits>
#include <iterator>

template <class Iterator>
class IteratorRange {
public:
    IteratorRange(Iterator begin, Iterator end) : begin_(begin), end_(end) {
    }

    Iterator begin() const {  // NOLINT
        return begin_;
    }

    Iterator end() const {  // NOLINT
        return end_;
    }

private:
    Iterator begin_, end_;
};

template <class T>
class Range {
public:
    struct Iterator {
        Iterator(T value, T step = 1) : value_(value), step_(step) {
        }

        Iterator& operator++() {
            value_ += step_;
            return *this;
        }

        bool operator!=(const Iterator& other) {
            return value_ < other.value_;
        }

        T& operator*() {
            return value_;
        }

        T value_, step_;
    };
    Range(const T& begin, const T& end, T k = 1)
        : its(Iterator(begin, k), Iterator(end, k)) {
    }
    Range(T end) : its(Iterator(0), Iterator(end)) {
    }

    Iterator begin() const {
        return its.begin();
    }

    Iterator end() const {
        return its.end();
    }

    Iterator cbegin() const {
        return its.begin();
    }

    Iterator cend() const {
        return its.end();
    }

private:
    const IteratorRange<Iterator> its;
};

template <typename T1, typename T2>
class Zip {
public:
    using IteratorFirst = decltype(std::declval<T1>().cbegin());
    using IteratorSecond = decltype(std::declval<T2>().cbegin());

    struct Iterator {
        using ObjectFirst = decltype(*std::declval<IteratorFirst>());
        using ObjectSecond = decltype(*std::declval<IteratorSecond>());

        Iterator(IteratorFirst it1, IteratorSecond it2) : it1_(it1), it2_(it2) {}

        Iterator& operator++() {
            ++it1_;
            ++it2_;
            return *this;
        }

        bool operator!=(const Iterator& other) const {
            return it1_ != other.it1_ && it2_ != other.it2_;
        }

        std::pair<const ObjectFirst&, const ObjectSecond&> operator*() {
            return std::pair<const ObjectFirst&, const ObjectSecond&>(*it1_, *it2_);
        }

        IteratorFirst it1_;
        IteratorSecond it2_;
    };

    Zip(T1&& ft,T2&& sc) : its(
        Iterator(std::cbegin(std::forward<T1>(ft))), std::cbegin(std::forward<T2>(sc))),
        Iterator(std::cend(std::forward<T1>(ft)), std::cend(std::forward<T2>(sc)))
         {}

    Iterator begin() const {
        return its.begin();
    }

    Iterator end() const {
        return its.end();
    }

private:
    const IteratorRange<Iterator> its;
};