QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#240261#1. I/O TestXiaohuba200 ✓63ms101016kbC++2317.1kb2023-11-05 14:02:552023-11-05 14:02:57

Judging History

你现在查看的是最新测评结果

  • [2023-11-05 14:02:57]
  • 评测
  • 测评结果：200
  • 用时：63ms
  • 内存：101016kb
查看
  • [2023-11-05 14:02:55]
  • 提交

config.txt

10000000 10000000
Text file

input_test

// clang-format off
#include <bits/stdc++.h>

using namespace std;

#if __cplusplus < 201400
  #warning "Please use c++14 or higher."
  #define INLINE_V
  #define REGISTER_V register
  #define CPP14CONSTEXPR
  #define gcd __gcd
  #define CPP14ENABLE_IF
#elif __cplusplus < 201700
  #define INLINE_V
  #define REGISTER_V
  #define CPP14CONSTEXPR constexpr
  #define gcd __gcd
  #define CPP14ENABLE_IF ,enable_if_t<_is_integer<T>, int> = 0
#else
  #define INLINE_V inline
  #define REGISTER_V
  #define CPP14CONSTEXPR constexpr
  #define CPP14ENABLE_IF ,enable_if_t<_is_integer<T>, int> = 0
#endif

#if !defined(_WIN32) && !defined(LOCK_GETCHAR)
  #define getchar getchar_unlocked
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define For(i,j,k) for(REGISTER_V int i=(j);i<=(k);++i) // NOLINT
#define ForDown(i,j,k) for(REGISTER_V int i=(j);i>=(k);--i) // NOLINT
#define pb push_back
#define eb emplace_back
#define FileIO(filename) freopen(filename".in","r",stdin);freopen(filename".out","w",stdout)

using ll = long long;
// using lll = __int128_t;
using uint = unsigned int;
using ull = unsigned long long;
// using ulll = __uint128_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

template<typename T> constexpr il T sq(const T & x){return x*x;}
template<typename T> CPP14CONSTEXPR il void cmin(T & x, const T &y){x=min(x,y);}
template<typename T> CPP14CONSTEXPR il void cmax(T & x, const T &y){x=max(x,y);}
template<typename T> CPP14CONSTEXPR il T qpow(T x, ull y, T mod){T ans=1;x%=mod;while(y){if(y&1)(ans*=x)%=mod;(x*=x)%=mod;y>>=1;}return ans;}
template<typename T> CPP14CONSTEXPR il T qpow(T x, ull y){T ans=1;while(y){if(y&1)ans*=x;x*=x;y>>=1;}return ans;}

// File head end
// clang-format on

namespace FastIO {
// ------------------------------
// #define IN_HAS_NEG
// #define OUT_HAS_NEG
// #define CHK_EOF
// #define DISABLE_MMAP
// ------------------------------
#if __cplusplus < 201400
#error Please use C++14 or higher.
#endif
#if __cplusplus > 201700
#define INLINE_V inline
#else
#define INLINE_V
#endif
#if (defined(LOCAL) || defined(_WIN32)) && !defined(DISABLE_MMAP)
#define DISABLE_MMAP
#endif
#ifndef DISABLE_MMAP
#include <sys/mman.h>
#endif
#ifdef LOCAL
inline char gc() { return getchar(); }
inline void pc(char c) { putchar(c); }
#else
#ifdef DISABLE_MMAP
INLINE_V constexpr int _READ_SIZE = 1 << 18;
INLINE_V static char _read_buffer[_READ_SIZE], *_read_ptr = nullptr,
                                               *_read_ptr_end = nullptr;
inline char gc() {
  if (__builtin_expect(_read_ptr == _read_ptr_end, false)) {
    _read_ptr = _read_buffer;
    _read_ptr_end = _read_buffer + fread(_read_buffer, 1, _READ_SIZE, stdin);
#ifdef CHK_EOF
    if (__builtin_expect(_read_ptr == _read_ptr_end, false))
      return EOF;
#endif
  }
  return *_read_ptr++;
}
#else
INLINE_V static const char *_read_ptr =
    (const char *)mmap(nullptr, INT_MAX, 1, 2, 0, 0);
inline char gc() { return *_read_ptr++; }
#endif
INLINE_V constexpr int _WRITE_SIZE = 1 << 18;
INLINE_V static char _write_buffer[_WRITE_SIZE], *_write_ptr = _write_buffer;
inline void pc(char c) {
  *_write_ptr++ = c;
  if (__builtin_expect(_write_buffer + _WRITE_SIZE == _write_ptr, false)) {
    fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout);
    _write_ptr = _write_buffer;
  }
}
INLINE_V struct _auto_flush {
  ~_auto_flush() {
    fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout);
  }
} _auto_flush;
#endif
#ifdef CHK_EOF
inline bool _isdigit(char c) { return (c & 16) && c != EOF; }
inline bool _isgraph(char c) { return c > 32 && c != EOF; }
#else
inline bool _isdigit(char c) { return c & 16; }
inline bool _isgraph(char c) { return c > 32; }
#endif
template <class T>
INLINE_V constexpr bool _is_integer = numeric_limits<T>::is_integer;
template <class T>
INLINE_V constexpr bool _is_signed = numeric_limits<T>::is_signed;
template <class T>
INLINE_V constexpr bool _is_unsigned = _is_integer<T> && !_is_signed<T>;
template <> INLINE_V constexpr bool _is_integer<__int128> = true;
template <> INLINE_V constexpr bool _is_integer<__uint128_t> = true;
template <> INLINE_V constexpr bool _is_signed<__int128> = true;
template <> INLINE_V constexpr bool _is_unsigned<__uint128_t> = true;
#undef INLINE_V
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();
}
#ifdef IN_HAS_NEG
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void read(T &x) {
  char c = gc();
  bool f = true;
  x = 0;
  while (!_isdigit(c)) {
    if (c == 45)
      f = false;
    c = gc();
  }
  if (f)
    while (_isdigit(c))
      x = x * 10 + (c & 15), c = gc();
  else
    while (_isdigit(c))
      x = x * 10 - (c & 15), c = gc();
}
template <class T, enable_if_t<_is_unsigned<T>, int> = 0>
#else
template <class T, enable_if_t<_is_integer<T>, int> = 0>
#endif
inline void read(T &x) {
  char c = gc();
  while (!_isdigit(c))
    c = gc();
  x = 0;
  while (_isdigit(c))
    x = x * 10 + (c & 15), c = gc();
}
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);
}
#ifdef OUT_HAS_NEG
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void write(T x) {
  char buffer[numeric_limits<T>::digits10 + 1];
  int digits = 0;
  if (x >= 0)
    do
      buffer[digits++] = (x % 10) | 48, x /= 10;
    while (x);
  else {
    pc(45);
    do
      buffer[digits++] = -(x % 10) | 48, x /= 10;
    while (x);
  }
  while (digits)
    pc(buffer[--digits]);
}
template <class T, enable_if_t<_is_unsigned<T>, int> = 0>
#else
template <class T, enable_if_t<_is_integer<T>, int> = 0>
#endif
inline void write(T x) {
  char buffer[numeric_limits<T>::digits10 + 1];
  int digits = 0;
  do
    buffer[digits++] = (x % 10) | 48, x /= 10;
  while (x);
  while (digits)
    pc(buffer[--digits]);
}
template <int N> struct _tuple_io_helper {
  template <class... T> static inline void _read(tuple<T...> &x) {
    _tuple_io_helper<N - 1>::_read(x), read(get<N - 1>(x));
  }
  template <class... T> static inline void _write(const tuple<T...> &x) {
    _tuple_io_helper<N - 1>::_write(x), pc(32), write(get<N - 1>(x));
  }
};
template <> struct _tuple_io_helper<1> {
  template <class... T> static inline void _read(tuple<T...> &x) {
    read(get<0>(x));
  }
  template <class... T> static inline void _write(const tuple<T...> &x) {
    write(get<0>(x));
  }
};
template <class... T> inline void read(tuple<T...> &x) {
  _tuple_io_helper<sizeof...(T)>::_read(x);
}
template <class... T> inline void write(const tuple<T...> &x) {
  _tuple_io_helper<sizeof...(T)>::_write(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 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) {
  print(x), pc(32), print(y...);
}
template <class... T> inline void print_cstr(const char *x, const T *...y) {
  print_cstr(x), print_cstr(y...);
}
inline void println() {}
inline void println_cstr() {}
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);
}
} // namespace FastIO
using namespace FastIO;

namespace {
il void solver_main() {
  int n, x;
  ll ans = 0;
  read(n);
  For(i, 1, n) { read(x), ans += x; }
  write(ans);
}
} // namespace

signed main() { return solver_main(), 0; }
Source code, Language: C++23

output_test

// clang-format off
#include <bits/stdc++.h>

using namespace std;

#if __cplusplus < 201400
  #warning "Please use c++14 or higher."
  #define INLINE_V
  #define REGISTER_V register
  #define CPP14CONSTEXPR
  #define gcd __gcd
  #define CPP14ENABLE_IF
#elif __cplusplus < 201700
  #define INLINE_V
  #define REGISTER_V
  #define CPP14CONSTEXPR constexpr
  #define gcd __gcd
  #define CPP14ENABLE_IF ,enable_if_t<_is_integer<T>, int> = 0
#else
  #define INLINE_V inline
  #define REGISTER_V
  #define CPP14CONSTEXPR constexpr
  #define CPP14ENABLE_IF ,enable_if_t<_is_integer<T>, int> = 0
#endif

#if !defined(_WIN32) && !defined(LOCK_GETCHAR)
  #define getchar getchar_unlocked
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define For(i,j,k) for(REGISTER_V int i=(j);i<=(k);++i) // NOLINT
#define ForDown(i,j,k) for(REGISTER_V int i=(j);i>=(k);--i) // NOLINT
#define pb push_back
#define eb emplace_back
#define FileIO(filename) freopen(filename".in","r",stdin);freopen(filename".out","w",stdout)

using ll = long long;
// using lll = __int128_t;
using uint = unsigned int;
using ull = unsigned long long;
// using ulll = __uint128_t;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

template<typename T> constexpr il T sq(const T & x){return x*x;}
template<typename T> CPP14CONSTEXPR il void cmin(T & x, const T &y){x=min(x,y);}
template<typename T> CPP14CONSTEXPR il void cmax(T & x, const T &y){x=max(x,y);}
template<typename T> CPP14CONSTEXPR il T qpow(T x, ull y, T mod){T ans=1;x%=mod;while(y){if(y&1)(ans*=x)%=mod;(x*=x)%=mod;y>>=1;}return ans;}
template<typename T> CPP14CONSTEXPR il T qpow(T x, ull y){T ans=1;while(y){if(y&1)ans*=x;x*=x;y>>=1;}return ans;}

// File head end
// clang-format on

namespace FastIO {
// ------------------------------
// #define IN_HAS_NEG
// #define OUT_HAS_NEG
// #define CHK_EOF
// #define DISABLE_MMAP
// ------------------------------
#if __cplusplus < 201400
#error Please use C++14 or higher.
#endif
#if __cplusplus > 201700
#define INLINE_V inline
#else
#define INLINE_V
#endif
#if (defined(LOCAL) || defined(_WIN32)) && !defined(DISABLE_MMAP)
#define DISABLE_MMAP
#endif
#ifndef DISABLE_MMAP
#include <sys/mman.h>
#endif
#ifdef LOCAL
inline char gc() { return getchar(); }
inline void pc(char c) { putchar(c); }
#else
#ifdef DISABLE_MMAP
INLINE_V constexpr int _READ_SIZE = 1 << 18;
INLINE_V static char _read_buffer[_READ_SIZE], *_read_ptr = nullptr,
                                               *_read_ptr_end = nullptr;
inline char gc() {
  if (__builtin_expect(_read_ptr == _read_ptr_end, false)) {
    _read_ptr = _read_buffer;
    _read_ptr_end = _read_buffer + fread(_read_buffer, 1, _READ_SIZE, stdin);
#ifdef CHK_EOF
    if (__builtin_expect(_read_ptr == _read_ptr_end, false))
      return EOF;
#endif
  }
  return *_read_ptr++;
}
#else
INLINE_V static const char *_read_ptr =
    (const char *)mmap(nullptr, INT_MAX, 1, 2, 0, 0);
inline char gc() { return *_read_ptr++; }
#endif
INLINE_V constexpr int _WRITE_SIZE = 1 << 18;
INLINE_V static char _write_buffer[_WRITE_SIZE], *_write_ptr = _write_buffer;
inline void pc(char c) {
  *_write_ptr++ = c;
  if (__builtin_expect(_write_buffer + _WRITE_SIZE == _write_ptr, false)) {
    fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout);
    _write_ptr = _write_buffer;
  }
}
INLINE_V struct _auto_flush {
  ~_auto_flush() {
    fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout);
  }
} _auto_flush;
#endif
#ifdef CHK_EOF
inline bool _isdigit(char c) { return (c & 16) && c != EOF; }
inline bool _isgraph(char c) { return c > 32 && c != EOF; }
#else
inline bool _isdigit(char c) { return c & 16; }
inline bool _isgraph(char c) { return c > 32; }
#endif
template <class T>
INLINE_V constexpr bool _is_integer = numeric_limits<T>::is_integer;
template <class T>
INLINE_V constexpr bool _is_signed = numeric_limits<T>::is_signed;
template <class T>
INLINE_V constexpr bool _is_unsigned = _is_integer<T> && !_is_signed<T>;
template <> INLINE_V constexpr bool _is_integer<__int128> = true;
template <> INLINE_V constexpr bool _is_integer<__uint128_t> = true;
template <> INLINE_V constexpr bool _is_signed<__int128> = true;
template <> INLINE_V constexpr bool _is_unsigned<__uint128_t> = true;
#undef INLINE_V
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();
}
#ifdef IN_HAS_NEG
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void read(T &x) {
  char c = gc();
  bool f = true;
  x = 0;
  while (!_isdigit(c)) {
    if (c == 45)
      f = false;
    c = gc();
  }
  if (f)
    while (_isdigit(c))
      x = x * 10 + (c & 15), c = gc();
  else
    while (_isdigit(c))
      x = x * 10 - (c & 15), c = gc();
}
template <class T, enable_if_t<_is_unsigned<T>, int> = 0>
#else
template <class T, enable_if_t<_is_integer<T>, int> = 0>
#endif
inline void read(T &x) {
  char c = gc();
  while (!_isdigit(c))
    c = gc();
  x = 0;
  while (_isdigit(c))
    x = x * 10 + (c & 15), c = gc();
}
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);
}
#ifdef OUT_HAS_NEG
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void write(T x) {
  char buffer[numeric_limits<T>::digits10 + 1];
  int digits = 0;
  if (x >= 0)
    do
      buffer[digits++] = (x % 10) | 48, x /= 10;
    while (x);
  else {
    pc(45);
    do
      buffer[digits++] = -(x % 10) | 48, x /= 10;
    while (x);
  }
  while (digits)
    pc(buffer[--digits]);
}
template <class T, enable_if_t<_is_unsigned<T>, int> = 0>
#else
template <class T, enable_if_t<_is_integer<T>, int> = 0>
#endif
inline void write(T x) {
  char buffer[numeric_limits<T>::digits10 + 1];
  int digits = 0;
  do
    buffer[digits++] = (x % 10) | 48, x /= 10;
  while (x);
  while (digits)
    pc(buffer[--digits]);
}
template <int N> struct _tuple_io_helper {
  template <class... T> static inline void _read(tuple<T...> &x) {
    _tuple_io_helper<N - 1>::_read(x), read(get<N - 1>(x));
  }
  template <class... T> static inline void _write(const tuple<T...> &x) {
    _tuple_io_helper<N - 1>::_write(x), pc(32), write(get<N - 1>(x));
  }
};
template <> struct _tuple_io_helper<1> {
  template <class... T> static inline void _read(tuple<T...> &x) {
    read(get<0>(x));
  }
  template <class... T> static inline void _write(const tuple<T...> &x) {
    write(get<0>(x));
  }
};
template <class... T> inline void read(tuple<T...> &x) {
  _tuple_io_helper<sizeof...(T)>::_read(x);
}
template <class... T> inline void write(const tuple<T...> &x) {
  _tuple_io_helper<sizeof...(T)>::_write(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 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) {
  print(x), pc(32), print(y...);
}
template <class... T> inline void print_cstr(const char *x, const T *...y) {
  print_cstr(x), print_cstr(y...);
}
inline void println() {}
inline void println_cstr() {}
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);
}
} // namespace FastIO
using namespace FastIO;

namespace {
il void solver_main() {
  int n;
  read(n);
  For(i, 1, n) { write_cstr("100000000 "); }
}
} // namespace

signed main() { return solver_main(), 0; }
Source code, Language: C++23

Details

Tip: Click on the bar to expand more detailed information

Subtask #1:

score: 100
Accepted

Test #1:

score: 100
Accepted
time: 63ms
memory: 101016kb

input:

10000000
987417524 397674828 389020276 757641497 620000609 146170775 771168876 291005025 874016413 719115883 618892437 504696350 677976042 959495914 131302795 709912539 440055584 368790211 961219262 443049778 618083596 313890339 349994237 397168254 648566233 583405709 993811493 808756176 635055599 3...

output:

5499614557458894

result:

points 1.0 input test passed

Subtask #2:

score: 100
Accepted

Test #2:

score: 100
Accepted
time: 59ms
memory: 3768kb

input:

10000000

output:

100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ...

result:

points 1.0 output test passed
English 繁體中文 简体中文

Server Time: 2025-01-20 05:48:05 | OpenSource Project