#include <iostream>
#include <cmath>
#include <limits>
#include <string>
#include <vector>
#include <algorithm>
#include <cassert>
#include <random>
namespace detail {
void clear_bad_input(std::istream &in) {
in.clear();
in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
template<typename T, typename MessageF, typename Pred>
T read_if(MessageF messagef, Pred pred, std::istream &in) {
T result {};
while(in.good()) {
messagef();
if((std::cin >> result) && pred(result)) {
break;
}
clear_bad_input(in);
}
return result;
}
}
template<typename T, typename Pred>
T read_if(std::string const &msg, Pred pred, std::ostream &out = std::cout, std::istream &in = std::cin) {
auto msgf = [&msg, &out] { return static_cast<bool>(out << msg << '\n'); };
return detail::read_if<T>(msgf, pred, in);
}
template<typename Cont>
auto read_one_of(std::string const &msg, Cont const &container) {
auto pred = [&container](auto &&item) {
return std::find(std::begin(container), std::end(container), item) != std::end(container);
};
return read_if<typename Cont::value_type>(msg, pred);
}
double nth_root(double num, double n) {
return std::pow(num, 1./n);
}
using namespace std;
namespace handy {
int random_int_from_range(int min, int max) {
assert(min <= max);
static std::default_random_engine gen;
return std::uniform_int_distribution<>{min, max}(gen);
}
auto read_even_size() {
return read_if<size_t>("enter even size", [](auto num) {
return (num % 2) == 0;
});
}
auto read_decision() {
return read_one_of("enter [values] or [range]", vector<string> {
"values", "range"
});
}
auto read_elements(size_t size) {
vector<int> result;
while(size --> 0) {
int num;
cin >> num;
result.emplace_back(num);
}
return result;
}
auto gen_elements(size_t size) {
vector<int> result;
int a, b;
while((cin >> a >> b) && ((b-a) == size));
while(size --> 0) {
result.emplace_back(random_int_from_range(a, b));
}
return result;
}
auto read_or_gen_elements(size_t size, string const &decision) {
if(!(decision == "values" || decision == "range")) {
cerr << "decision: " << decision << '\n';
assert(false);
}
return decision == "values"?
read_elements(size) :
gen_elements(size);
}
}
int main() {
auto size = handy::read_even_size();
auto decision = handy::read_decision();
auto elements = handy::read_or_gen_elements(size, decision);
return 0;
}
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