結果
| 問題 |
No.9000 Hello World! （テスト用）
|
| ユーザー |
 plasma_e
|
| 提出日時 | 2017-02-06 12:04:10 |
| 言語 | C++14 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 2 ms / 5,000 ms |
| コード長 | 7,210 bytes |
| コンパイル時間 | 1,037 ms |
| コンパイル使用メモリ | 80,636 KB |
| 実行使用メモリ | 5,248 KB |
| 最終ジャッジ日時 | 2024-12-25 14:32:43 |
| 合計ジャッジ時間 | 1,628 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge2 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| other | AC * 4 |
コンパイルメッセージ
main.cpp:54:116: warning: friend declaration 'decltype(auto) utility::operator!=(const equality_comparable<T>&, const equality_comparable<T>&)' declares a non-template function [-Wnon-template-friend]
54 | friend decltype(auto) operator!=(equality_comparable<T>const& lhs, equality_comparable<T>const& rhs);
| ^
main.cpp:54:116: note: (if this is not what you intended, make sure the function template has already been declared and add '<>' after the function name here)
main.cpp:62:91: warning: friend declaration 'decltype(auto) utility::operator+(const addable<T>&, const addable<T>&)' declares a non-template function [-Wnon-template-friend]
62 | friend decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs);
| ^
main.cpp:71:101: warning: friend declaration 'decltype(auto) utility::operator-(const subtractable<T>&, const subtractable<T>&)' declares a non-template function [-Wnon-template-friend]
71 | friend decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs);
| ^
main.cpp:79:101: warning: friend declaration 'decltype(auto) utility::operator*(const multipliable<T>&, const multipliable<T>&)' declares a non-template function [-Wnon-template-friend]
79 | friend decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs);
| ^
main.cpp:87:95: warning: friend declaration 'decltype(auto) utility::operator/(const dividable<T>&, const dividable<T>&)' declares a non-template function [-Wnon-template-friend]
87 |
ソースコード
#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
#include<queue>
#include<functional>
#include<numeric>
#include<limits>
#include<map>
#include<bitset>
#include<array>
namespace utility
{
template<class T>struct equality_comparable;
template<class T>struct addable;
template<class T>struct subtractable;
template<class T>struct multipliable;
template<class T>struct dividable;
template<class T>decltype(auto) operator!=(equality_comparable<T>const& lhs, equality_comparable<T>const& rhs)
{
return !lhs.operator==(rhs);
}
template<class T>decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs)
{
auto x = lhs;
x += rhs;
return x;
}
template<class T>decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs)
{
auto x = lhs;
x -= rhs;
return x;
}
template<class T>decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs)
{
auto x = lhs;
x *= rhs;
return x;
}
template<class T>decltype(auto) operator/(dividable<T>const& lhs, dividable<T>const& rhs)
{
auto x = lhs;
x /= rhs;
return x;
}
template<class T>struct equality_comparable
{
decltype(auto) operator==(equality_comparable<T>const& rhs)const
{
return static_cast<T const&>(*this) == static_cast<T const&>(rhs);
}
friend decltype(auto) operator!=(equality_comparable<T>const& lhs, equality_comparable<T>const& rhs);
};
template<class T>struct addable
{
decltype(auto) operator+=(addable<T>const& rhs)
{
return static_cast<T const&>(*this) += static_cast<T const&>(rhs);
}
friend decltype(auto) operator+(addable<T>const& lhs, addable<T>const& rhs);
};
template<class T>struct subtractable
{
decltype(auto) operator-=(subtractable<T>const& rhs)
{
return static_cast<T const&>(*this) -= static_cast<T const&>(rhs);
}
friend decltype(auto) operator-(subtractable<T>const& lhs, subtractable<T>const& rhs);
};
template<class T>struct multipliable
{
decltype(auto) operator*=(multipliable<T>const& rhs)
{
return static_cast<T const&>(*this) *= static_cast<T const&>(rhs);
}
friend decltype(auto) operator*(multipliable<T>const& lhs, multipliable<T>const& rhs);
};
template<class T>struct dividable
{
decltype(auto) operator/=(dividable<T>const& rhs)
{
return static_cast<T const&>(*this) /= static_cast<T const&>(rhs);
}
friend decltype(auto) operator/(dividable<T>const& lhs, dividable<T>const& rhs);
};
}
namespace math
{
template<class T>constexpr T pow(T val, std::uint64_t p)
{
return p == 0 ? T(1) :
p == 1 ? val :
p == 2 ? val*val :
p % 2 == 0 ? pow(pow(val, p / 2), 2) :
pow(pow(val, p / 2), 2)*val;
}
template<class T,class U>constexpr int ilog(T val, U base)
{
T v(1);
for (int i{};;++i)
{
if (val <= v)
{
return i;
}
v *= base;
}
}
template<std::uint64_t Mod>class mod_number:
private utility::equality_comparable<mod_number<Mod>>,
private utility::addable<mod_number<Mod>>,
private utility::subtractable<mod_number<Mod>>,
private utility::multipliable<mod_number<Mod>>,
private utility::dividable<mod_number<Mod>>
{
std::uint64_t value;
public:
mod_number(std::uint64_t v = 0) :value(v%Mod)
{
}
mod_number(int v) :value(v%Mod)
{
}
mod_number(std::int64_t v) :value(v%Mod)
{
}
mod_number(std::uint32_t v) :value(v%Mod)
{
}
bool operator==(mod_number const& rhs)
{
return value == rhs.value;
}
auto& operator+=(mod_number const& rhs)
{
value += rhs.value;
value %= Mod;
return *this;
}
auto& operator-=(mod_number const& rhs)
{
value += Mod - rhs.value;
value %= Mod;
return *this;
}
auto& operator*=(mod_number const& rhs)
{
value *= rhs.value;
value %= Mod;
return *this;
}
auto& operator/=(mod_number const& rhs)
{
return operator*=(pow(rhs, Mod - 2));
}
};
}
namespace container
{
template<class T, std::size_t Size = 1 << 13>class addtree
{
std::array<T, 2 * Size - 1> data;
T get(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
{
if (r <= left || right <= l)
return T();
if (left <= l&&r <= right)
{
return data[i];
}
else
{
return
get(left, right, 2 * i + 1, l, (l + r) / 2) +
get(left, right, 2 * i + 2, (l + r) / 2, r);
}
}
public:
addtree() :data{}
{
}
void change(T const& val, std::size_t index)
{
T from = data[index + Size - 1];
for (std::size_t i = 1, c = math::ilog(Size, 2);i <= Size;(i <<= 1), --c)
{
data[i + (index >> c) - 1] -= from;
data[i + (index >> c) - 1] += val;
}
}
auto begin()const
{
return std::next(data.begin(), Size - 1);
}
auto end()const
{
return data.end();
}
T get(std::size_t left, std::size_t right)
{
return left > right ? T() : get(left, right + 1, 0, 0, Size);
}
};
/*template<class T, std::size_t Size = 1 << 13>class minmaxtree
{
std::array<std::pair<T, T>, 2 * Size - 1> data;
T min(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
{
if (r <= left || right <= l)
return std::numeric_limits<T>::max();
if (left <= l&&r <= right)
{
return data[i].first;
}
else
{
return std::min(
get(left, right, 2 * i + 1, l, (l + r) / 2),
get(left, right, 2 * i + 2, (l + r) / 2, r));
}
}
T max(std::size_t left, std::size_t right, std::size_t i, std::size_t l, std::size_t r)
{
if (r <= left || right <= l)
return std::numeric_limits<T>::min();
if (left <= l&&r <= right)
{
return data[i].second;
}
else
{
return std::max(
get(left, right, 2 * i + 1, l, (l + r) / 2),
get(left, right, 2 * i + 2, (l + r) / 2, r));
}
}
std::size_t change(T const& val, std::size_t index, std::size_t shift)
{
if (shift == Size)
{
val[shift + index] = val;
}
else
{
auto s = change(val, index, shift << 1);
val[shift + s - 1].first = std::min(val[2 * shift + 2 * s], val[2 * shift + 2 * s + 1]);
val[shift + s - 1].second = std::max(val[2 * shift + 2 * s], val[2 * shift + 2 * s + 1]);
}
return index >> 1;
}
public:
addtree() :data{}
{
}
void change(T const& val, std::size_t index)
{
data[index + Size - 1] = val;
}
auto begin()const
{
return std::next(data.begin(), Size - 1);
}
auto end()const
{
return data.end();
}
T min(std::size_t left, std::size_t right)const
{
return left > right ? std::numeric_limits<T>::max() : min(left, right + 1, 0, 0, Size);
}
T max(std::size_t left, std::size_t right)const
{
return left > right ? std::numeric_limits<T>::min() : min(left, right + 1, 0, 0, Size);
}
};*/
}
void Main();
int main()
{
std::ios::sync_with_stdio(false);
Main();
}
//撣
void Main()
{
std::string str;
std::cin >> str;
std::cout << "Hello World!" << std::endl;
}