#include <iostream>
#include <vector>
#include <algorithm>
#include <array>

//1
template <typename T>
const T& get_min_element(const std::vector<T>& v) {
    return *min_element(v.begin(), v.end());
}

//2
template <typename T>
std::vector<T> get_min_max(const std::vector<T>& vec) {
    int min1 = vec[0];
    int min2 = vec[1];

    if (min1 > min2) {
        min1 = vec[1];
        min2 = vec[0];
    }

    for (int i = 2; i < vec.size(); i++) {
        if (min1 > vec[i]) {
            min2 = min1;
            min1 = vec[i];
        }
        else if (min2 > vec[i]) {
            min2 = vec[i];
        }
    }


    int max1 = vec[0];
    int max2 = vec[1];

    if (max2 > max1) {
        max1 = vec[1];
        max2 = vec[0];
    }

    for (int i = 2; i < vec.size(); i++) {
        if (vec[i] > max1) {
            max2 = max1;
            max1 = vec[i];
        }
        else if (vec[i] > max2 && vec[i] != max1) {
            max2 = vec[i];
        }
    }


    std::vector<T> returned = {min1, min2, max2, max1};
    return returned;
}

//3
template <typename T, template <typename> typename U>
T get_max(const U<T>& vec) {
    return *std::max_element(vec.begin(), vec.end());
}

//5
template <typename T>
void add_element(std::vector<T>& vec, T element) {
    bool is_added = false;

    for (int i = 0; i < vec.size() - 1; i++) {
        if (element <= vec[i+1] && element >= vec[i]) {
            auto index = vec.begin() + i + 1;
            vec.insert(index, element);

            is_added = true;
        }
    }

    if (!is_added) {
        vec.push_back(element);
    }
}

//6
template <typename T>
std::ostream& operator <<(std::ostream& text, const std::vector<T>& vec) {
    if (vec.empty()) {
        text << "ERROR";
        return text;
    }
    else if (vec.size() == 1) {
        text << "[" << vec[0] << "]";
    }
    else {
        for (int i = 0; i < vec.size(); i++) {
            if (i == 0) {
                text << "[" << vec[i] << ", ";
            }
            else if (i == vec.size() - 1) {
                text << vec[i] << "]";
            }
            else {
                text << vec[i] << ", ";
            }
        }
    }

    return text;
}

/*7
template <typename T, typename U>
struct Pair {
    T first;
    U second;

    Pair(T a, U b) {
        first = a;
        second = b;
    }
};*/

//8
template <typename T, const std::size_t N>
struct array {
    T tab[N];

    T& operator[](std::size_t i) {
        return tab[i];
    }

    const T& operator[](std::size_t i) const {
        return tab[i];
    }

    T* begin() {
        T *pointer = &tab[0];
        return pointer;
    }

    T* end() {
        T *pointer = &tab[N-1];
        return (pointer + 1);
    }

    int size() {
        return N;
    }
};

//9
template <typename T, const std::size_t N>
std::array<T, N> generate_array() {
    std::array<T, N> arr;
    return arr;
}

int main() {


}