1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
| #include <bits/stdc++.h>
#define endl "\n"
#define fastio std::ios::sync_with_stdio(false), std::cin.tie(nullptr)
#define let auto
using i64 = long long;
template <typename... Args> void inpm(Args &...args) { ((std::cin >> args), ...); }
class Range {
int start_, end_, step_;
int current_;
public:
Range(int end) : start_(0), end_(end), step_(1), current_(0) {}
Range(int start, int end, int step = 1)
: start_(start), end_(end), step_(step), current_(start) {}
class Iterator {
int current_, end_, step_;
public:
Iterator(int current, int end, int step) : current_(current), end_(end), step_(step) {}
int operator*() const { return current_; }
Iterator &operator++() {
current_ += step_;
return *this;
}
bool operator!=(const Iterator &other) const {
return step_ > 0 ? current_ < other.current_ : current_ > other.current_;
}
};
Iterator begin() const { return Iterator(start_, end_, step_); }
Iterator end() const { return Iterator(end_, end_, step_); }
};
template <typename T> T input() {
T val;
std::cin >> val;
return val;
}
template <typename T0, typename... Ts> void print(T0 t0, Ts... ts) {
std::cout << t0;
if constexpr (sizeof...(ts) > 0) {
std::cout << " ";
print(ts...);
} else
std::cout << endl;
}
template <typename T>
void print(std::vector<T> vec, std::string sep = " ", std::string end = "\n") {
let n = vec.size();
for (let i : Range(n)) {
if (i != 0) {
std::cout << sep;
}
std::cout << vec[i];
}
std::cout << end;
}
template <typename T> std::vector<T> inpl() {
int n = input<int>();
std::vector<T> val(n);
for (int i = 0; i < n; i++) {
std::cin >> val[i];
}
return val;
}
template <typename T> std::vector<T> inpl(size_t size) {
std::vector<T> val(size);
for (int i = 0; i < size; i++) {
std::cin >> val[i];
}
return val;
}
template <typename T, typename TIter = decltype(std::begin(std::declval<T>()))>
constexpr auto enumerate(T &&iterable) {
struct iterator {
size_t i;
TIter iter;
bool operator!=(const iterator &other) const { return iter != other.iter; }
void operator++() {
++i;
++iter;
}
auto operator*() const { return std::tie(i, *iter); }
};
struct iterable_wrapper {
T iterable;
auto begin() { return iterator{0, std::begin(iterable)}; }
auto end() { return iterator{0, std::end(iterable)}; }
};
return iterable_wrapper{std::forward<T>(iterable)};
}
|
