library
This documentation is automatically generated by online-judge-tools/verification-helper
test/TemplateFunctions.test.cpp
- View this file on GitHub
- Last update: 2021-04-18 18:33:15+09:00
- Problem: https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/1/ITP1_1_A
Depends on
Code
#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/1/ITP1_1_A"
#include "./../Utility/functions.cpp"
#include <iostream>
using namespace std;
int main() {
static_assert(div_ceil(9, 3) == 3);
static_assert(div_ceil(10, 3) == 4);
static_assert(div_ceil(11, 3) == 4);
static_assert(div_ceil(12, 3) == 4);
static_assert(div_ceil(13, 3) == 5);
static_assert(div_ceil(1000000000000000000ll, 3) == 333333333333333334ll);
static_assert(div_ceil(3, 1000000000000000000ll) == 1);
static_assert(div_ceil(1000000000000000000ll, 300000000000000000) == 4);
static_assert(div_ceil2(9, 3) == 9);
static_assert(div_ceil2(10, 3) == 12);
static_assert(div_ceil2(11, 3) == 12);
static_assert(div_ceil2(12, 3) == 12);
static_assert(div_ceil2(13, 3) == 15);
static_assert(div_ceil2(1000000000000000000ll, 3) == 1000000000000000002ll);
static_assert(div_ceil2(3, 1000000000000000000ll) == 1000000000000000000ll);
static_assert(div_ceil2(1000000000000000000ll, 300000000000000000) ==
1200000000000000000ll);
static_assert(triangle(0) == 0);
static_assert(triangle(1) == 1);
static_assert(triangle(2) == 3);
static_assert(triangle(3) == 6);
static_assert(triangle(1000000000ll) == 500000000500000000ll);
static_assert(triangle(4000000000ll) == 8000000002000000000ll);
static_assert(nC2(0) == 0);
static_assert(nC2(1) == 0);
static_assert(nC2(2) == 1);
static_assert(nC2(3) == 3);
static_assert(nC2(1000000000ll) == 499999999500000000ll);
static_assert(nC2(4000000000ll) == 7999999998000000000ll);
static_assert(middle(-10, 10) == 0);
static_assert(middle(10, 10) == 10);
static_assert(middle(10, 15) == 12);
static_assert(middle(0, 1000000000000000000ll) == 500000000000000000ll);
static_assert(middle(1000000000000000000ll, 3000000000000000000ll) ==
2000000000000000000ll);
static_assert(!in_range(-1, 0, 20));
static_assert(in_range(0, 0, 20));
static_assert(in_range(19, 0, 20));
static_assert(!in_range(20, 0, 20));
static_assert(!in_range(-1, 0, 1000000000000000000ll));
static_assert(in_range(0, 0, 1000000000000000000ll));
static_assert(in_range(999999999999999999ll, 0, 1000000000000000000ll));
static_assert(!in_range(1000000000000000000ll, 0, 1000000000000000000ll));
static_assert(!is_square(15));
static_assert(is_square(16));
static_assert(!is_square(17));
static_assert(!is_square(996491788296388608ll));
static_assert(is_square(996491788296388609ll));
static_assert(!is_square(996491788296388610ll));
static_assert(BIT<int>(0) == 1);
static_assert(BIT<int>(1) == 2);
static_assert(BIT(0) == 1);
static_assert(BIT(1) == 2);
static_assert(BIT(32) == 4294967296ll);
static_assert(BIT(62) == 4611686018427387904ll);
static_assert(Pow(0, 0) == 1);
static_assert(Pow(1000000000000000000ll, 0) == 1);
static_assert(Pow(0, 1) == 0);
static_assert(Pow(1000000000000000000ll, 1) == 1000000000000000000ll);
static_assert(Pow(2, 10) == 1024);
static_assert(Pow(2ll, 62) == 4611686018427387904ll);
static_assert(Pow(10, 9) == 1000000000);
static_assert(Pow(10ll, 18) == 1000000000000000000ll);
static_assert(Powmod(0, 0, 2) == 1);
static_assert(Powmod(1000000000000000000ll, 0, 2ll) == 1);
static_assert(Powmod(0, 1, 2) == 0);
static_assert(Powmod(1000000000000000000ll, 1, 3ll) == 1);
static_assert(Powmod(2, 10, 1000000000) == 1024);
static_assert(Powmod(2ll, 998244353, 1000000007ll) == 213467670);
static_assert(Powmod(10ll, 998244353998244353ll, 1000000007ll) == 821601853);
static_assert(Powmod(998244353998244353ll, 998244353998244353ll, 1000000007ll) ==
55266312);
static_assert(TEN<int>(0) == 1);
static_assert(TEN<int>(1) == 10);
static_assert(TEN<int>(9) == 1000000000);
static_assert(TEN(0) == 1);
static_assert(TEN(1) == 10);
static_assert(TEN(9) == 1000000000);
static_assert(TEN(18) == 1000000000000000000);
cout << "Hello World" << endl;
}#line 1 "test/TemplateFunctions.test.cpp"
#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/1/ITP1_1_A"
#line 2 "Utility/functions.cpp"
#include <algorithm>
#include <numeric>
#include <cmath>
#include <vector>
#include <tuple>
#include <cassert>
template <class T = long long> constexpr T TEN(std::size_t n) {
T result = 1;
for (std::size_t i = 0; i < n; ++i) result *= 10;
return result;
}
template <
class T, class U,
std::enable_if_t<std::is_integral_v<T> && std::is_integral_v<U>, std::nullptr_t> = nullptr>
constexpr auto div_ceil(T n, U m) {
return (n + m - 1) / m;
}
template <class T, class U> constexpr auto div_ceil2(T n, U m) {
return div_ceil(n, m) * m;
}
template <class T> constexpr T triangle(T n) {
return (n & 1) ? (n + 1) / 2 * n : n / 2 * (n + 1);
}
template <class T> constexpr T nC2(T n) {
return (n & 1) ? (n - 1) / 2 * n : n / 2 * (n - 1);
}
template <class T, class U> constexpr auto middle(const T& l, const U& r) {
return l + (r - l) / 2;
}
template <class T, class U, class V>
constexpr bool in_range(const T& v, const U& lower, const V& upper) {
return lower <= v && v < upper;
}
template <class T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>
constexpr bool is_square(T n) {
T s = std::sqrt(n);
return s * s == n || (s + 1) * (s + 1) == n;
}
template <class T = long long> constexpr T BIT(int b) {
return T(1) << b;
}
template <class T> constexpr int BIT(T x, int i) {
return (x & (T(1) << i)) ? 1 : 0;
}
template <class T> constexpr int Sgn(T x) {
return (0 < x) - (0 > x);
}
template <class T> bool is_leap(T year) {
return !(year % 4) && (year % 100 || !(year % 400));
}
template <class T, class U, std::enable_if_t<std::is_integral_v<U>, std::nullptr_t> = nullptr>
constexpr T Pow(T a, U n) {
assert(n >= 0);
T result = 1;
while (n > 0) {
if (n & 1) {
result *= a;
n--;
} else {
a *= a;
n >>= 1;
}
}
return result;
}
template <class T, class U, std::enable_if_t<std::is_integral_v<U>, std::nullptr_t> = nullptr>
constexpr T Powmod(T a, U n, T mod) {
assert(n >= 0);
if (a > mod) a %= mod;
T result = 1;
while (n > 0) {
if (n & 1) {
result = result * a % mod;
n--;
} else {
a = a * a % mod;
n >>= 1;
}
}
return result;
}
template <class T> bool chmax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <class T> bool chmin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T> int sz(const T& v) {
return v.size();
}
template <class T, class U> int lower_index(const T& a, const U& v) {
return std::lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U, class F> int lower_index(const T& a, const U& v, const F& f) {
return std::lower_bound(a.begin(), a.end(), v, f) - a.begin();
}
template <class T, class U> int upper_index(const T& a, const U& v) {
return std::upper_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U, class F> int upper_index(const T& a, const U& v, const F& f) {
return std::upper_bound(a.begin(), a.end(), v, f) - a.begin();
}
template <class T, class U = typename T::value_type> U Gcdv(const T& v) {
return std::accumulate(std::next(v.begin()), v.end(), U(*v.begin()), std::gcd<U, U>);
}
template <class T, class U = typename T::value_type> U Lcmv(const T& v) {
return std::accumulate(std::next(v.begin()), v.end(), U(*v.begin()), std::lcm<U, U>);
}
template <class T> T& Concat(T& v, const T& vec) {
v.insert(v.end(), vec.begin(), vec.end());
return v;
}
namespace internal {
template <class T, std::size_t N>
auto make_vector(std::vector<int>& sizes, const T& init) {
if constexpr (N == 1) {
return std::vector(sizes[0], init);
} else {
int size = sizes[N - 1];
sizes.pop_back();
return std::vector(size, make_vector<T, N - 1>(sizes, init));
}
}
} // namespace internal
template <class T, std::size_t N>
auto make_vector(const int (&sizes)[N], const T& init = T()) {
std::vector s(std::rbegin(sizes), std::rend(sizes));
return internal::make_vector<T, N>(s, init);
}
template <class F> struct rec_lambda {
F f;
rec_lambda(F&& f_) : f(std::forward<F>(f_)) {}
template <class... Args> auto operator()(Args&&... args) const {
return f(*this, std::forward<Args>(args)...);
}
};
namespace lambda {
auto char_to_int = [](char c) {
return c - '0';
};
auto lower_to_int = [](char c) {
return c - 'a';
};
auto upper_to_int = [](char c) {
return c - 'A';
};
auto int_to_char = [](int i) -> char {
return '0' + i;
};
auto int_to_lower = [](int i) -> char {
return 'a' + i;
};
auto int_to_upper = [](int i) -> char {
return 'A' + i;
};
auto is_odd = [](auto n) {
return n % 2 == 1;
};
auto is_even = [](auto n) {
return n % 2 == 0;
};
auto is_positive = [](auto n) {
return n > 0;
};
auto is_negative = [](auto n) {
return n < 0;
};
auto increment = [](auto n) {
return ++n;
};
auto decrement = [](auto n) {
return --n;
};
auto self = [](const auto& n) {
return n;
};
auto first = [](const auto& n) {
return n.first;
};
auto second = [](const auto& n) {
return n.second;
};
template <class T> auto cast() {
return [](const auto& n) {
return static_cast<T>(n);
};
};
template <class T> auto equal_to(const T& x) {
return [x](auto y) {
return x == y;
};
}
template <std::size_t I> auto get() {
return [](const auto& n) {
return std::get<I>(n);
};
}
template <class F> auto cmp(F&& f) {
return [f](const auto& a, const auto& b) {
return f(a) < f(b);
};
}
} // namespace lambda
#line 3 "test/TemplateFunctions.test.cpp"
#include <iostream>
using namespace std;
int main() {
static_assert(div_ceil(9, 3) == 3);
static_assert(div_ceil(10, 3) == 4);
static_assert(div_ceil(11, 3) == 4);
static_assert(div_ceil(12, 3) == 4);
static_assert(div_ceil(13, 3) == 5);
static_assert(div_ceil(1000000000000000000ll, 3) == 333333333333333334ll);
static_assert(div_ceil(3, 1000000000000000000ll) == 1);
static_assert(div_ceil(1000000000000000000ll, 300000000000000000) == 4);
static_assert(div_ceil2(9, 3) == 9);
static_assert(div_ceil2(10, 3) == 12);
static_assert(div_ceil2(11, 3) == 12);
static_assert(div_ceil2(12, 3) == 12);
static_assert(div_ceil2(13, 3) == 15);
static_assert(div_ceil2(1000000000000000000ll, 3) == 1000000000000000002ll);
static_assert(div_ceil2(3, 1000000000000000000ll) == 1000000000000000000ll);
static_assert(div_ceil2(1000000000000000000ll, 300000000000000000) ==
1200000000000000000ll);
static_assert(triangle(0) == 0);
static_assert(triangle(1) == 1);
static_assert(triangle(2) == 3);
static_assert(triangle(3) == 6);
static_assert(triangle(1000000000ll) == 500000000500000000ll);
static_assert(triangle(4000000000ll) == 8000000002000000000ll);
static_assert(nC2(0) == 0);
static_assert(nC2(1) == 0);
static_assert(nC2(2) == 1);
static_assert(nC2(3) == 3);
static_assert(nC2(1000000000ll) == 499999999500000000ll);
static_assert(nC2(4000000000ll) == 7999999998000000000ll);
static_assert(middle(-10, 10) == 0);
static_assert(middle(10, 10) == 10);
static_assert(middle(10, 15) == 12);
static_assert(middle(0, 1000000000000000000ll) == 500000000000000000ll);
static_assert(middle(1000000000000000000ll, 3000000000000000000ll) ==
2000000000000000000ll);
static_assert(!in_range(-1, 0, 20));
static_assert(in_range(0, 0, 20));
static_assert(in_range(19, 0, 20));
static_assert(!in_range(20, 0, 20));
static_assert(!in_range(-1, 0, 1000000000000000000ll));
static_assert(in_range(0, 0, 1000000000000000000ll));
static_assert(in_range(999999999999999999ll, 0, 1000000000000000000ll));
static_assert(!in_range(1000000000000000000ll, 0, 1000000000000000000ll));
static_assert(!is_square(15));
static_assert(is_square(16));
static_assert(!is_square(17));
static_assert(!is_square(996491788296388608ll));
static_assert(is_square(996491788296388609ll));
static_assert(!is_square(996491788296388610ll));
static_assert(BIT<int>(0) == 1);
static_assert(BIT<int>(1) == 2);
static_assert(BIT(0) == 1);
static_assert(BIT(1) == 2);
static_assert(BIT(32) == 4294967296ll);
static_assert(BIT(62) == 4611686018427387904ll);
static_assert(Pow(0, 0) == 1);
static_assert(Pow(1000000000000000000ll, 0) == 1);
static_assert(Pow(0, 1) == 0);
static_assert(Pow(1000000000000000000ll, 1) == 1000000000000000000ll);
static_assert(Pow(2, 10) == 1024);
static_assert(Pow(2ll, 62) == 4611686018427387904ll);
static_assert(Pow(10, 9) == 1000000000);
static_assert(Pow(10ll, 18) == 1000000000000000000ll);
static_assert(Powmod(0, 0, 2) == 1);
static_assert(Powmod(1000000000000000000ll, 0, 2ll) == 1);
static_assert(Powmod(0, 1, 2) == 0);
static_assert(Powmod(1000000000000000000ll, 1, 3ll) == 1);
static_assert(Powmod(2, 10, 1000000000) == 1024);
static_assert(Powmod(2ll, 998244353, 1000000007ll) == 213467670);
static_assert(Powmod(10ll, 998244353998244353ll, 1000000007ll) == 821601853);
static_assert(Powmod(998244353998244353ll, 998244353998244353ll, 1000000007ll) ==
55266312);
static_assert(TEN<int>(0) == 1);
static_assert(TEN<int>(1) == 10);
static_assert(TEN<int>(9) == 1000000000);
static_assert(TEN(0) == 1);
static_assert(TEN(1) == 10);
static_assert(TEN(9) == 1000000000);
static_assert(TEN(18) == 1000000000000000000);
cout << "Hello World" << endl;
}