QOJ.ac
QOJ
| ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
|---|---|---|---|---|---|---|---|---|---|
| #714895 | #9562. 欧伊昔 | cmk666 | 5 | 13ms | 6116kb | C++23 | 15.6kb | 2024-11-06 09:02:24 | 2024-11-06 09:02:25 |
Judging History
answer
/* _ _ _ _ __ __ __
/ \ _ _ | |_ | |__ ___ _ __ _ ___ _ __ ___ | | __ / /_ / /_ / /_
/ _ \ | | | | | __| | '_ \ / _ \ | '__| (_) / __| | '_ ` _ \ | |/ / | '_ \ | '_ \ | '_ \
/ ___ \ | |_| | | |_ | | | | | (_) | | | _ | (__ | | | | | | | < | (_) | | (_) | | (_) |
/_/ \_\ \__,_| \__| |_| |_| \___/ |_| (_) \___| |_| |_| |_| |_|\_\ \___/ \___/ \___/
[Created Time: 2024-11-06 08:20:40]
[Last Modified Time: 2024-11-06 09:02:08] */
#ifdef LOCAL
#include<bits/stdc++.h>
#include"debug.h"
#else
#pragma GCC optimize("Ofast", "unroll-loops")
#include<bits/stdc++.h>
#define D(...) ((void)0)
#endif
using namespace std; using ll = long long;
#define For(i, j, k) for ( int i = (j) ; i <= (k) ; i++ )
#define Fol(i, j, k) for ( int i = (j) ; i >= (k) ; i-- )
namespace FastIO
{
#define USE_FastIO
// ------------------------------
// #define DISABLE_MMAP
// ------------------------------
#if ( defined(LOCAL) || defined(_WIN32) ) && !defined(DISABLE_MMAP)
#define DISABLE_MMAP
#endif
#ifdef LOCAL
inline void _chk_i() {}
inline char _gc_nochk() { return getchar(); }
inline char _gc() { return getchar(); }
inline void _chk_o() {}
inline void _pc_nochk(char c) { putchar(c); }
inline void _pc(char c) { putchar(c); }
template < int n > inline void _pnc_nochk(const char *c) { for ( int i = 0 ; i < n ; i++ ) putchar(c[i]); }
#else
#ifdef DISABLE_MMAP
inline constexpr int _READ_SIZE = 1 << 18; inline static char _read_buffer[_READ_SIZE + 40], *_read_ptr = nullptr, *_read_ptr_end = nullptr; static inline bool _eof = false;
inline void _chk_i() { if ( __builtin_expect(!_eof, true) && __builtin_expect(_read_ptr_end - _read_ptr < 40, false) ) { int sz = _read_ptr_end - _read_ptr; if ( sz ) memcpy(_read_buffer, _read_ptr, sz); char *beg = _read_buffer + sz; _read_ptr = _read_buffer, _read_ptr_end = beg + fread(beg, 1, _READ_SIZE, stdin); if ( __builtin_expect(_read_ptr_end != beg + _READ_SIZE, false) ) _eof = true, *_read_ptr_end = EOF; } }
inline char _gc_nochk() { return __builtin_expect(_eof && _read_ptr == _read_ptr_end, false) ? EOF : *_read_ptr++; }
inline char _gc() { _chk_i(); return _gc_nochk(); }
#else
#include<sys/mman.h>
#include<sys/stat.h>
inline static char *_read_ptr = (char *)mmap(nullptr, [] { struct stat s; return fstat(0, &s), s.st_size; } (), 1, 2, 0, 0);
inline void _chk_i() {}
inline char _gc_nochk() { return *_read_ptr++; }
inline char _gc() { return *_read_ptr++; }
#endif
inline constexpr int _WRITE_SIZE = 1 << 18; inline static char _write_buffer[_WRITE_SIZE + 40], *_write_ptr = _write_buffer;
inline void _chk_o() { if ( __builtin_expect(_write_ptr - _write_buffer > _WRITE_SIZE, false) ) fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout), _write_ptr = _write_buffer; }
inline void _pc_nochk(char c) { *_write_ptr++ = c; }
inline void _pc(char c) { *_write_ptr++ = c, _chk_o(); }
template < int n > inline void _pnc_nochk(const char *c) { memcpy(_write_ptr, c, n), _write_ptr += n; }
inline struct _auto_flush { inline ~_auto_flush() { fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout); } } _auto_flush;
#endif
#define println println_ // don't use C++23 std::println
template < class T > inline constexpr bool _is_signed = numeric_limits < T >::is_signed;
template < class T > inline constexpr bool _is_unsigned = numeric_limits < T >::is_integer && !_is_signed < T >;
#if __SIZEOF_LONG__ == 64
template <> inline constexpr bool _is_signed < __int128 > = true;
template <> inline constexpr bool _is_unsigned < __uint128_t > = true;
#endif
inline bool _isgraph(char c) { return c >= 33; }
inline bool _isdigit(char c) { return 48 <= c && c <= 57; } // or faster, remove c <= 57
constexpr struct _table {
#ifndef LOCAL
int i[65536];
#endif
char o[40000]; constexpr _table() :
#ifndef LOCAL
i{},
#endif
o{} {
#ifndef LOCAL
for ( int x = 0 ; x < 65536 ; x++ ) i[x] = -1; for ( int x = 0 ; x <= 9 ; x++ ) for ( int y = 0 ; y <= 9 ; y++ ) i[x + y * 256 + 12336] = x * 10 + y;
#endif
for ( int x = 0 ; x < 10000 ; x++ ) for ( int y = 3, z = x ; ~y ; y-- ) o[x * 4 + y] = z % 10 + 48, z /= 10; } } _table;
template < class T, int digit > inline constexpr T _pw10 = 10 * _pw10 < T, digit - 1 >;
template < class T > inline constexpr T _pw10 < T, 0 > = 1;
inline void read(char &c) { do c = _gc(); while ( !_isgraph(c) ); }
inline void read_cstr(char *s) { char c = _gc(); while ( !_isgraph(c) ) c = _gc(); while ( _isgraph(c) ) *s++ = c, c = _gc(); *s = 0; }
inline void read(string &s) { char c = _gc(); s.clear(); while ( !_isgraph(c) ) c = _gc(); while ( _isgraph(c) ) s.push_back(c), c = _gc(); }
template < class T, bool neg >
#ifndef LOCAL
__attribute__((no_sanitize("undefined")))
#endif
inline void _read_int_suf(T &x) { _chk_i(); char c; while
#ifndef LOCAL
( ~_table.i[*reinterpret_cast < unsigned short *& >(_read_ptr)] ) if constexpr ( neg ) x = x * 100 - _table.i[*reinterpret_cast < unsigned short *& >(_read_ptr)++]; else x = x * 100 + _table.i[*reinterpret_cast < unsigned short *& >(_read_ptr)++]; if
#endif
( _isdigit(c = _gc_nochk()) ) if constexpr ( neg ) x = x * 10 - ( c & 15 ); else x = x * 10 + ( c & 15 ); }
template < class T, enable_if_t < _is_signed < T >, int > = 0 > inline void read(T &x) { char c; while ( !_isdigit(c = _gc()) ) if ( c == 45 ) { _read_int_suf < T, true >(x = -( _gc_nochk() & 15 )); return; } _read_int_suf < T, false >(x = c & 15); }
template < class T, enable_if_t < _is_unsigned < T >, int > = 0 > inline void read(T &x) { char c; while ( !_isdigit(c = _gc()) ); _read_int_suf < T, false >(x = c & 15); }
inline void write(bool x) { _pc(x | 48); }
inline void write(char c) { _pc(c); }
inline void write_cstr(const char *s) { while ( *s ) _pc(*s++); }
inline void write(const string &s) { for ( char c : s ) _pc(c); }
template < class T, bool neg, int digit > inline void _write_int_suf(T x) { if constexpr ( digit == 4 ) _pnc_nochk < 4 >(_table.o + ( neg ? -x : x ) * 4); else _write_int_suf < T, neg, digit / 2 >(x / _pw10 < T, digit / 2 >), _write_int_suf < T, neg, digit / 2 >(x % _pw10 < T, digit / 2 >); }
template < class T, bool neg, int digit > inline void _write_int_pre(T x) { if constexpr ( digit <= 4 ) if ( digit >= 3 && ( neg ? x <= -100 : x >= 100 ) ) if ( digit >= 4 && ( neg ? x <= -1000 : x >= 1000 ) ) _pnc_nochk < 4 >(_table.o + ( neg ? -x : x ) * 4); else _pnc_nochk < 3 >(_table.o + ( neg ? -x : x ) * 4 + 1); else if ( digit >= 2 && ( neg ? x <= -10 : x >= 10 ) ) _pnc_nochk < 2 >(_table.o + ( neg ? -x : x ) * 4 + 2); else _pc_nochk(( neg ? -x : x ) | 48); else { constexpr int cur = 1 << __lg(digit - 1); if ( neg ? x <= -_pw10 < T, cur > : x >= _pw10 < T, cur > ) _write_int_pre < T, neg, digit - cur >(x / _pw10 < T, cur >), _write_int_suf < T, neg, cur >(x % _pw10 < T, cur >); else _write_int_pre < T, neg, cur >(x); } }
template < class T, enable_if_t < _is_signed < T >, int > = 0 > inline void write(T x) { if ( x >= 0 ) _write_int_pre < T, false, numeric_limits < T >::digits10 + 1 >(x); else _pc_nochk(45), _write_int_pre < T, true, numeric_limits < T >::digits10 + 1 >(x); _chk_o(); }
template < class T, enable_if_t < _is_unsigned < T >, int > = 0 > inline void write(T x) { _write_int_pre < T, false, numeric_limits < T >::digits10 + 1 >(x), _chk_o(); }
template < size_t N, class ...T > inline void _read_tuple(tuple < T... > &x) { read(get < N >(x)); if constexpr ( N + 1 != sizeof...(T) ) _read_tuple < N + 1, T... >(x); }
template < size_t N, class ...T > inline void _write_tuple(const tuple < T... > &x) { write(get < N >(x)); if constexpr ( N + 1 != sizeof...(T) ) _pc(32), _write_tuple < N + 1, T... >(x); }
template < class ...T > inline void read(tuple < T... > &x) { _read_tuple < 0, T... >(x); }
template < class ...T > inline void write(const tuple < T... > &x) { _write_tuple < 0, T... >(x); }
template < class T1, class T2 > inline void read(pair < T1, T2 > &x) { read(x.first), read(x.second); }
template < class T1, class T2 > inline void write(const pair < T1, T2 > &x) { write(x.first), _pc(32), write(x.second); }
template < class T > inline auto read(T &x) -> decltype(x.read(), void()) { x.read(); }
template < class T > inline auto write(const T &x) -> decltype(x.write(), void()) { x.write(); }
template < class T1, class ...T2 > inline void read(T1 &x, T2 &...y) { read(x), read(y...); }
template < class ...T > inline void read_cstr(char *x, T *...y) { read_cstr(x), read_cstr(y...); }
template < class T1, class ...T2 > inline void write(const T1 &x, const T2 &...y) { write(x), write(y...); }
template < class ...T > inline void write_cstr(const char *x, const T *...y) { write_cstr(x), write_cstr(y...); }
template < class T > inline void print(const T &x) { write(x); }
inline void print_cstr(const char *x) { write_cstr(x); }
template < class T1, class ...T2 > inline void print(const T1 &x, const T2 &...y) { write(x), _pc(32), print(y...); }
template < class ...T > inline void print_cstr(const char *x, const T *...y) { write_cstr(x), _pc(32), print_cstr(y...); }
inline void println() { _pc(10); }
inline void println_cstr() { _pc(10); }
template < class ...T > inline void println(const T &...x) { print(x...), _pc(10); }
template < class ...T > inline void println_cstr(const T *...x) { print_cstr(x...), _pc(10); }
} using FastIO::read, FastIO::read_cstr, FastIO::write, FastIO::write_cstr, FastIO::println, FastIO::println_cstr;
template < auto P_ > class MontgomeryModInt
{
using S = decltype(P_); static_assert(is_same_v < S, int > || is_same_v < S, long > || is_same_v < S, long long >);
static_assert(P_ & 1 && 0 < P_ && P_ < ( (S)1 << ( sizeof(S) * 8 - 2 ) ));
using U = conditional_t < is_same_v < S, int >, unsigned, unsigned long long >; using D = conditional_t < is_same_v < S, int >, unsigned long long, __uint128_t >;
inline constexpr static U uinv(U x) { U y = x; for ( int i = is_same_v < S, int > ? 4 : 5 ; i-- ; ) y *= 2 - x * y; return y; }
constexpr static U P = P_, P2 = P << 1, R = -uinv(P), R2 = -(D)P % P; static_assert(P * R == -1);
inline constexpr static U reduce(D x) { return ( x + (U)x * R * (D)P ) >> ( sizeof(U) * 8 ); }
inline constexpr MontgomeryModInt(U x, int) : v(x) {} U v;
public:
inline constexpr static S mod() { return P; }
inline constexpr MontgomeryModInt() : v(0) {}
inline constexpr MontgomeryModInt(const MontgomeryModInt &x) : v(x.v) {}
template < class T, enable_if_t < numeric_limits < T >::is_integer, int > = 0 > inline constexpr MontgomeryModInt(T x) : v(reduce((D)R2 * ( numeric_limits < T >::is_signed && x < 0 ? ( ( x + P < 0 ) && ( x %= P ), x + P ) : ( ( sizeof(T) > sizeof(U) && x >= (T)1 << sizeof(U) ) && ( x %= P ), x ) ))) {}
inline constexpr S val()const { U x = reduce(v); return ( x - P ) >> ( sizeof(U) * 8 - 1 ) ? x : x - P; }
template < class T, enable_if_t < numeric_limits < T >::is_integer, int > = 0 > explicit inline constexpr operator T()const { return val(); }
inline constexpr friend bool operator==(const MontgomeryModInt &x, const MontgomeryModInt &y) { return x.val() == y.val(); }
inline constexpr friend bool operator!=(const MontgomeryModInt &x, const MontgomeryModInt &y) { return x.val() != y.val(); }
inline constexpr MontgomeryModInt &operator=(const MontgomeryModInt &x) & { v = x.v; return *this; }
inline constexpr MontgomeryModInt &operator++() & { return *this += 1; }
inline constexpr MontgomeryModInt operator++(int) & { MontgomeryModInt x = *this; *this += 1; return x; }
inline constexpr MontgomeryModInt &operator--() & { return *this -= 1; }
inline constexpr MontgomeryModInt operator--(int) & { MontgomeryModInt x = *this; *this -= 1; return x; }
inline constexpr MontgomeryModInt operator-()const { return MontgomeryModInt(v ? P2 - v : 0, 0); }
inline constexpr MontgomeryModInt &operator+=(const MontgomeryModInt &x) & { v += x.v, ( v - P2 ) >> ( sizeof(U) * 8 - 1 ) || ( v -= P2 ); return *this; }
inline constexpr MontgomeryModInt &operator-=(const MontgomeryModInt &x) & { v -= x.v, v >> ( sizeof(U) * 8 - 1 ) && ( v += P2 ); return *this; }
inline constexpr MontgomeryModInt &operator*=(const MontgomeryModInt &x) & { v = reduce((D)v * x.v); return *this; }
inline constexpr MontgomeryModInt &operator/=(const MontgomeryModInt &x) & { return *this *= x.inv(); }
inline constexpr friend MontgomeryModInt operator+(MontgomeryModInt x, const MontgomeryModInt &y) { return x += y; }
inline constexpr friend MontgomeryModInt operator-(MontgomeryModInt x, const MontgomeryModInt &y) { return x -= y; }
inline constexpr friend MontgomeryModInt operator*(MontgomeryModInt x, const MontgomeryModInt &y) { return x *= y; }
inline constexpr friend MontgomeryModInt operator/(MontgomeryModInt x, const MontgomeryModInt &y) { return x /= y; }
template < class T, enable_if_t < numeric_limits < T >::is_integer, int > = 0 > inline constexpr MontgomeryModInt qpow(T y)const { MontgomeryModInt x = *this, z = 1; while ( y ) { if ( y & 1 ) z *= x; if ( y >>= 1 ) x *= x; } return z; }
template < class T, enable_if_t < numeric_limits < T >::is_integer, int > = 0 > inline constexpr friend MontgomeryModInt qpow(const MontgomeryModInt &x, T y) { return x.qpow(y); }
inline constexpr MontgomeryModInt inv()const { return qpow(P - 2); }
inline constexpr friend MontgomeryModInt inv(const MontgomeryModInt &x) { return x.inv(); }
inline friend istream &operator>>(istream &is, MontgomeryModInt &x) { S y; is >> y, x = y; return is; }
inline friend ostream &operator<<(ostream &os, const MontgomeryModInt &x) { return os << x.val(); }
#ifdef USE_FastIO
inline void read() & { S x; ::read(x), *this = x; }
inline void write()const { ::write(val()); }
#endif
}; using MI = MontgomeryModInt < 1000000009 >; // 1000000007 1145141919810000037
int pw3[12];
namespace OP
{
int op[3][3], pa[3], pb[3], pc[3], qa[3], qb[3], qc[3], o; bool flg, is_add;
vector < pair < int, int > > vec, err;
inline void cpy() { copy(qa, qa + 3, pa), copy(qb, qb + 3, pb), copy(qc, qc + 3, pc); }
inline void init()
{
For(i, 0, 2) For(j, 0, 2) read(op[i][j]);
For(i, 0, pw3[9] - 1)
{
o = i, vec.clear(), flg = true;
For(j, 0, 2) qa[j] = o % 3, o /= 3;
For(j, 0, 2) qb[j] = o % 3, o /= 3;
For(j, 0, 2) qc[j] = o % 3, o /= 3;
For(j, 0, 2) For(k, 0, 2)
{
flg &= qc[( qa[j] + qb[k] ) % 3] == op[j][k];
if ( qc[max(qa[j], qb[k])] != op[j][k] ) vec.emplace_back(j, k);
}
if ( flg ) { cpy(), is_add = true; break; }
if ( !i || vec.size() < err.size() ) cpy(), err = vec;
}
D(is_add, err.size());
}
}
namespace ADD
{
constexpr MI G = 5, W1 = qpow(G, MI::mod() / 3), W2 = W1 * W1;
int n; MI a[180009], b[180009];
template < bool I > inline void dft(MI &a, MI &b, MI &c)
{ tie(a, I ? c : b, I ? b : c) = tuple(a + b + c, a + W1 * b + W2 * c, a + W2 * b + W1 * c); }
template < bool I = false > inline void fwt(MI *x)
{
For(i, 0, n - 1) for ( int j = 0 ; j != pw3[n] ; j += pw3[i + 1] ) For(k, j, j + pw3[i] - 1)
dft<I>(x[k], x[k + pw3[i]], x[k + pw3[i] + pw3[i]]);
}
inline void ifwt(MI *x) { fwt<true>(x); MI a = inv(MI(pw3[n])); For(i, 0, pw3[n] - 1) x[i] *= a; }
inline void slv()
{
read(n);
For(i, 0, pw3[n] - 1) read(a[i]);
For(i, 0, pw3[n] - 1) read(b[i]);
fwt(a), fwt(b); For(i, 0, pw3[n] - 1) a[i] *= b[i]; ifwt(a);
For(i, 0, pw3[n] - 1) write(a[i], i == pw3[n] - 1 ? '\n' : ' ');
}
}
namespace NORMAL
{
inline void slv()
{
println(":("s);
}
}
int main()
{
*pw3 = 1; For(i, 1, 11) pw3[i] = pw3[i - 1] * 3;
return OP::init(), OP::is_add ? ADD::slv() : NORMAL::slv(), 0;
}
// 想上GM捏 想上GM捏 想上GM捏 想上GM捏 想上GM捏
// 伊娜可爱捏 伊娜贴贴捏
Details
Tip: Click on the bar to expand more detailed information
Subtask #1:
score: 5
Accepted
Test #1:
score: 5
Accepted
time: 1ms
memory: 3724kb
input:
0 1 2 1 2 0 2 0 1 1 7 1 5 8 4 5
output:
81 61 79
result:
ok single line: '81 61 79'
Test #2:
score: 5
Accepted
time: 1ms
memory: 3660kb
input:
0 1 2 1 2 0 2 0 1 3 6 4 1 8 7 9 6 1 4 1 6 4 5 8 2 5 2 8 1 8 7 9 8 1 1 8 8 9 6 5 9 8 7 5 0 4 7 7 1 1 8 0 9 2 2 8 9 3 8 8 5 2 1 5
output:
697 607 678 641 734 754 699 750 774 704 695 713 676 751 706 737 724 668 686 706 636 703 751 761 713 764 754
result:
ok single line: '697 607 678 641 734 754 699 75...706 636 703 751 761 713 764 754'
Test #3:
score: 5
Accepted
time: 1ms
memory: 3996kb
input:
0 1 2 1 2 0 2 0 1 6 4 7 8 2 3 9 8 2 3 1 3 2 7 4 9 1 9 9 3 9 4 8 8 3 4 2 6 7 0 4 5 0 3 7 8 0 0 0 9 5 4 3 0 9 7 6 0 5 9 6 1 6 9 4 1 9 5 4 5 8 8 3 2 4 1 2 0 2 0 2 7 9 6 8 1 0 9 4 1 5 5 4 2 7 5 8 4 2 8 2 4 2 0 7 3 3 5 2 6 2 5 4 3 2 3 7 3 4 3 7 8 4 3 5 5 1 2 9 9 4 2 4 0 3 2 4 0 6 5 8 6 3 4 7 8 7 2 9 2 0 ...
output:
14700 14442 14900 14208 14286 14793 14470 14589 14638 14410 14487 14557 14384 14379 14349 14487 14611 14746 14691 14522 14296 14618 14777 14822 14692 14403 14429 14634 14616 14623 14881 14495 14435 14921 14915 14387 14662 14498 14959 14809 14728 14395 14052 14358 13982 14996 14685 14955 14393 14327 ...
result:
ok single line: '14700 14442 14900 14208 14286 ...1 14314 14301 14704 14346 14600'
Test #4:
score: 5
Accepted
time: 0ms
memory: 4320kb
input:
0 1 2 1 2 0 2 0 1 9 2 3 5 0 2 1 7 9 9 8 3 3 8 6 0 7 1 9 5 0 9 7 2 4 8 5 3 7 2 1 5 3 6 1 6 3 3 4 0 6 3 1 4 4 3 2 8 0 5 1 3 0 2 9 6 7 7 0 8 2 7 4 4 7 2 7 8 6 0 7 4 6 7 5 2 6 7 9 6 1 5 8 5 6 7 9 7 9 3 7 6 4 0 6 7 5 6 5 2 2 2 8 7 7 4 8 9 0 4 3 1 4 2 7 9 8 7 4 1 4 0 6 2 5 6 9 1 2 4 2 6 9 8 6 6 6 3 1 7 1 ...
output:
394989 396540 394557 395621 396482 394434 394798 394810 395056 395834 393311 394708 394814 393791 397819 393252 393212 394704 396791 395950 397023 395361 395243 394075 393972 394019 396705 396235 396328 395603 395505 395548 395307 394855 395834 395596 395881 395357 396429 395491 394378 395132 396642...
result:
ok single line: '394989 396540 394557 395621 39...457 392714 395489 394271 395605'
Test #5:
score: 5
Accepted
time: 13ms
memory: 6116kb
input:
0 1 2 1 2 0 2 0 1 11 1 6 2 1 2 0 1 5 0 2 0 0 1 5 0 3 7 1 7 5 6 5 0 2 4 3 6 6 6 6 3 9 2 1 1 1 8 7 8 5 2 1 4 9 7 6 1 3 6 3 8 2 9 4 3 0 6 3 4 8 6 7 1 1 2 8 7 7 1 8 5 6 0 2 1 0 5 9 7 0 2 0 3 6 9 6 3 7 6 6 5 1 1 8 2 6 5 1 6 4 3 3 2 6 4 9 1 6 1 7 7 8 8 7 2 4 9 3 8 9 0 6 1 7 8 2 8 4 8 4 9 6 4 1 3 8 8 3 9 7...
output:
3604328 3606586 3614489 3601944 3600772 3606127 3610365 3607012 3609133 3605717 3603103 3605403 3601041 3612587 3612125 3599467 3610664 3605910 3610160 3605199 3601396 3606846 3609903 3609073 3607772 3607588 3606298 3603367 3608036 3608244 3607173 3608461 3600398 3603955 3606346 3605362 3608084 3609...
result:
ok single line: '3604328 3606586 3614489 360194...3608101 3606150 3600205 3608243'
Subtask #2:
score: 0
Wrong Answer
Test #6:
score: 0
Wrong Answer
time: 1ms
memory: 3704kb
input:
1 2 1 2 0 0 1 0 0 1 8 9 3 1 6 1
output:
:(
result:
wrong answer 1st lines differ - expected: '84 19 57', found: ':('
Subtask #3:
score: 0
Wrong Answer
Test #11:
score: 0
Wrong Answer
time: 0ms
memory: 3728kb
input:
1 1 1 0 0 0 1 1 1 1 6 2 1 3 1 5
output:
29 17 35
result:
wrong answer 1st lines differ - expected: '18 63 0', found: '29 17 35'
Subtask #4:
score: 0
Wrong Answer
Test #16:
score: 0
Wrong Answer
time: 0ms
memory: 3788kb
input:
1 1 1 0 0 1 1 1 0 1 1 0 9 8 1 9
output:
17 82 81
result:
wrong answer 1st lines differ - expected: '81 99 0', found: '17 82 81'
Subtask #5:
score: 0
Wrong Answer
Test #21:
score: 0
Wrong Answer
time: 1ms
memory: 3788kb
input:
0 2 2 1 1 1 0 1 1 9 2 7 2 7 4 5 9 7 9 6 8 4 0 6 3 3 6 3 0 5 2 3 7 6 7 8 3 6 1 1 6 9 9 2 7 2 1 2 8 2 9 3 5 0 5 7 1 2 3 1 4 8 0 4 3 4 2 8 8 4 2 9 3 7 1 1 6 6 4 0 9 6 5 8 8 1 3 8 7 3 0 4 3 8 7 0 0 7 6 4 3 6 0 2 3 3 6 5 0 5 9 8 6 1 0 4 7 8 2 4 7 4 8 6 9 6 3 5 1 8 0 1 4 7 0 0 1 2 7 7 0 5 5 3 8 2 7 8 9 8 ...
output:
:(
result:
wrong answer 1st lines differ - expected: '18440 36200 13740 21447 61214 ...176 81555 44223 4512 28578 4596', found: ':('
Subtask #6:
score: 0
Skipped
Dependency #5:
0%
Subtask #7:
score: 0
Skipped
Dependency #6:
0%