test/aoj/2159.rational.test.cpp

• View this file on GitHub
• Last update: 2024-09-28 19:54:09+09:00
• Problem: https://onlinejudge.u-aizu.ac.jp/problems/2159

Depends on

• 直線 (src/Geometry/Line.hpp)
• 点 (src/Geometry/Point.hpp)
• int から long long などのテンプレート (src/Internal/long_traits.hpp)
• Binary GCD (src/Math/binary_gcd.hpp)
• 有理数 $\mathbb{Q}$ (src/Math/Rational.hpp)

Code

// competitive-verifier: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/2159
// competitive-verifier: TLE 0.5
// competitive-verifier: MLE 64
// long long だと TLE(WA?)
#include <iostream>
#include <vector>
#include <set>
#include "src/Math/Rational.hpp"
#include "src/Geometry/Line.hpp"
using namespace std;
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(false);
 using namespace geo;
 using R= Rational<__int128_t>;
 int N;
 cin >> N;
 vector<Point<R>> ps(N);
 set<Point<R>> S;
 for (int i= 0; i < N; ++i) cin >> ps[i], S.insert(ps[i]);
 bool isline= true;
 Line m= line_through(ps[0], ps[1]);
 for (int i= 2; i < N; ++i) isline&= m.where(ps[i]) == 0;
 if (isline) return cout << "No" << '\n', 0;
 vector<Line<R>> ls;
 for (int i= 3; i--;)
  for (int j= i + 1; j < N; ++j) ls.emplace_back(bisector(ps[i], ps[j]));
 auto check= [&](const Line<R> &l) {
  int cnt= 0;
  auto ref= reflect(l);
  for (Point p: ps) {
   cnt+= l.where(p) == 0;
   if (!S.count(ref(p))) return false;
  }
  return cnt <= 2;
 };
 bool isok= false;
 for (auto &l: ls) isok|= check(l);
 cout << (isok ? "Yes" : "No") << '\n';
 return 0;
}

#line 1 "test/aoj/2159.rational.test.cpp"
// competitive-verifier: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/2159
// competitive-verifier: TLE 0.5
// competitive-verifier: MLE 64
// long long だと TLE(WA?)
#include <iostream>
#include <vector>
#include <set>
#line 2 "src/Math/Rational.hpp"
#include <string>
#include <limits>
#include <sstream>
#line 2 "src/Math/binary_gcd.hpp"
#include <type_traits>
#include <algorithm>
#include <cstdint>
template <class Int> constexpr int bsf(Int a) {
 if constexpr (sizeof(Int) == 16) {
  uint64_t lo= a & uint64_t(-1);
  return lo ? __builtin_ctzll(lo) : 64 + __builtin_ctzll(a >> 64);
 } else if constexpr (sizeof(Int) == 8) return __builtin_ctzll(a);
 else return __builtin_ctz(a);
}
template <class Int> constexpr Int binary_gcd(Int a, Int b) {
 if (a == 0 || b == 0) return a + b;
 int n= bsf(a), m= bsf(b), s= 0;
 for (a>>= n, b>>= m; a != b;) {
  Int d= a - b;
  bool f= a > b;
  s= bsf(d), b= f ? b : a, a= (f ? d : -d) >> s;
 }
 return a << std::min(n, m);
}
#line 6 "src/Math/Rational.hpp"
template <class Int, bool reduction= true> struct Rational {
 Int num, den;
 constexpr Rational(): num(0), den(1) {}
 constexpr Rational(Int n, Int d= 1): num(n), den(d) {
  if (den < 0) num= -num, den= -den;
  if constexpr (reduction) reduce(num, den);
 }
 constexpr Rational(const std::string &str) {
  auto it= str.find("/");
  if (it == std::string::npos) num= std::stoi(str), den= 1;
  else num= std::stoi(str.substr(0, it)), den= std::stoi(str.substr(it + 1));
  if constexpr (reduction) reduce(num, den);
 }
 static constexpr void reduce(Int &a, Int &b) {
  const Int g= binary_gcd(a < 0 ? -a : a, b);
  a/= g, b/= g;
 }
 static constexpr Rational raw(Int n, Int d) {
  Rational ret;
  return ret.num= n, ret.den= d, ret;
 }
 constexpr Rational operator-() const { return raw(-num, den); }
 constexpr Rational operator+(const Rational &r) const { return Rational(num * r.den + den * r.num, den * r.den); }
 constexpr Rational operator-(const Rational &r) const { return Rational(num * r.den - den * r.num, den * r.den); }
 constexpr Rational operator*(const Rational &r) const {
  if constexpr (reduction) {
   Int ln= num, ld= den, rn= r.num, rd= r.den;
   return reduce(ln, rd), reduce(rn, ld), raw(ln * rn, ld * rd);
  } else return Rational(num * r.num, den * r.den);
 }
 constexpr Rational operator/(const Rational &r) const {
  if constexpr (reduction) {
   Int ln= num, ld= den, rn= r.num, rd= r.den;
   if (rn < 0) rd= -rd, rn= -rn;
   return reduce(ln, rn), reduce(rd, ld), raw(ln * rd, ld * rn);
  } else return Rational(num * r.den, den * r.num);
 }
 Rational &operator+=(const Rational &r) { return *this= *this + r; }
 Rational &operator-=(const Rational &r) { return *this= *this - r; }
 Rational &operator*=(const Rational &r) { return *this= *this * r; }
 Rational &operator/=(const Rational &r) { return *this= *this / r; }
 constexpr bool operator==(const Rational &r) const {
  if constexpr (reduction) return num == r.num && den == r.den;
  else return den == 0 && r.den == 0 ? num * r.num > 0 : num * r.den == den * r.num;
 }
 constexpr bool operator!=(const Rational &r) const { return !(*this == r); }
 constexpr bool operator<(const Rational &r) const {
  if (den == 0 && r.den == 0) return num < r.num;
  else if (den == 0) return num < 0;
  else if (r.den == 0) return r.num > 0;
  else return num * r.den < den * r.num;
 }
 constexpr bool operator>(const Rational &r) const { return r < *this; }
 constexpr bool operator<=(const Rational &r) const { return !(r < *this); }
 constexpr bool operator>=(const Rational &r) const { return !(*this < r); }
 constexpr explicit operator bool() const { return num != 0; }
 constexpr long double to_fp() const { return (long double)num / den; }
 constexpr explicit operator long double() const { return to_fp(); }
 constexpr explicit operator double() const { return to_fp(); }
 constexpr explicit operator float() const { return to_fp(); }
 constexpr Int floor() const { return num < 0 ? -((-num + den - 1) / den) : num / den; }
 constexpr Int ceil() const { return num < 0 ? -(-num / den) : (num + den - 1) / den; }
 constexpr Rational abs() const { return raw(num < 0 ? -num : num, den); }
 constexpr friend Int floor(const Rational &r) { return r.floor(); }
 constexpr friend Int ceil(const Rational &r) { return r.ceil(); }
 constexpr friend Rational abs(const Rational &r) { return r.abs(); }
 std::string to_string() const {
  if (!num) return "0";
  std::stringstream ss;
  if (den == 1) return ss << num, ss.str();
  return ss << num << "/" << den, ss.str();
 }
 friend std::istream &operator>>(std::istream &is, Rational &r) {
  std::string s;
  if (is >> s; s != "") r= Rational(s);
  return is;
 }
 friend std::ostream &operator<<(std::ostream &os, const Rational &r) { return os << r.to_string(); }
};
template <class Int, bool reduction> struct std::numeric_limits<Rational<Int, reduction>> {
 static constexpr Rational<Int, reduction> max() noexcept { return Rational<Int, reduction>(1, 0); }
 static constexpr Rational<Int, reduction> min() noexcept { return Rational<Int, reduction>(1, std::numeric_limits<Int>::max()); }
 static constexpr Rational<Int, reduction> lowest() noexcept { return Rational<Int, reduction>(-1, 0); }
};
#line 3 "src/Geometry/Point.hpp"
#include <fstream>
#include <iomanip>
#include <cmath>
#include <cassert>
#line 2 "src/Internal/long_traits.hpp"
// clang-format off
template<class T>struct make_long{using type= T;};
template<>struct make_long<char>{using type= short;};
template<>struct make_long<unsigned char>{using type= unsigned short;};
template<>struct make_long<short>{using type= int;};
template<>struct make_long<unsigned short>{using type= unsigned;};
template<>struct make_long<int>{using type= long long;};
template<>struct make_long<unsigned>{using type= unsigned long long;};
template<>struct make_long<long long>{using type= __int128_t;};
template<>struct make_long<unsigned long long>{using type= __uint128_t;};
template<>struct make_long<float>{using type= double;};
template<>struct make_long<double>{using type= long double;};
template<class T> using make_long_t= typename make_long<T>::type;
// clang-format on
#line 8 "src/Geometry/Point.hpp"
namespace geo {
using namespace std;
struct Visualizer {
 ofstream ofs;
 Visualizer(string s= "visualize.txt"): ofs(s) { ofs << fixed << setprecision(10); }
 friend Visualizer &operator<<(Visualizer &vis, const string &s) { return vis.ofs << s, vis; }
};
template <class K> int sgn(K x) {
 if constexpr (is_floating_point_v<K>) {
  static constexpr K EPS= 1e-9;
  return x < -EPS ? -1 : x > EPS;
 } else return x < 0 ? -1 : x > 0;
}
template <class K> K err_floor(K x) {
 K y= floor(x);
 if constexpr (is_floating_point_v<K>)
  if (K z= y + 1, w= x - z; 0 <= sgn(w) && sgn(w - 1) < 0) return z;
 return y;
}
template <class K> K err_ceil(K x) {
 K y= ceil(x);
 if constexpr (is_floating_point_v<K>)
  if (K z= y - 1, w= x - z; 0 < sgn(w + 1) && sgn(w) <= 0) return z;
 return y;
}
template <class K> struct Point {
 K x, y;
 Point(K x= K(), K y= K()): x(x), y(y) {}
 Point &operator+=(const Point &p) { return x+= p.x, y+= p.y, *this; }
 Point &operator-=(const Point &p) { return x-= p.x, y-= p.y, *this; }
 Point &operator*=(K a) { return x*= a, y*= a, *this; }
 Point &operator/=(K a) { return x/= a, y/= a, *this; }
 Point operator+(const Point &p) const { return {x + p.x, y + p.y}; }
 Point operator-(const Point &p) const { return {x - p.x, y - p.y}; }
 Point operator*(K a) const { return {x * a, y * a}; }
 Point operator/(K a) const { return {x / a, y / a}; }
 friend Point operator*(K a, const Point &p) { return {a * p.x, a * p.y}; }
 Point operator-() const { return {-x, -y}; }
 bool operator<(const Point &p) const {
  int s= sgn(x - p.x);
  return s ? s < 0 : sgn(y - p.y) < 0;
 }
 bool operator>(const Point &p) const { return p < *this; }
 bool operator<=(const Point &p) const { return !(p < *this); }
 bool operator>=(const Point &p) const { return !(*this < p); }
 bool operator==(const Point &p) const { return !sgn(x - p.x) && !sgn(y - p.y); }
 bool operator!=(const Point &p) const { return sgn(x - p.x) || sgn(y - p.y); }
 Point operator!() const { return {-y, x}; }  // rotate 90 degree
 friend istream &operator>>(istream &is, Point &p) { return is >> p.x >> p.y; }
 friend ostream &operator<<(ostream &os, const Point &p) { return os << "(" << p.x << ", " << p.y << ")"; }
 friend Visualizer &operator<<(Visualizer &vis, const Point &p) { return vis.ofs << p.x << " " << p.y << "\n", vis; }
};
template <class K> make_long_t<K> dot(const Point<K> &p, const Point<K> &q) { return make_long_t<K>(p.x) * q.x + make_long_t<K>(p.y) * q.y; }
// left turn: > 0, right turn: < 0
template <class K> make_long_t<K> cross(const Point<K> &p, const Point<K> &q) { return make_long_t<K>(p.x) * q.y - make_long_t<K>(p.y) * q.x; }
template <class K> make_long_t<K> norm2(const Point<K> &p) { return dot(p, p); }
template <class K> long double norm(const Point<K> &p) { return sqrt(norm2(p)); }
template <class K> make_long_t<K> dist2(const Point<K> &p, const Point<K> &q) { return norm2(p - q); }
template <class T, class U> long double dist(const T &a, const U &b) { return sqrt(dist2(a, b)); }
enum CCW { COUNTER_CLOCKWISE, CLOCKWISE, ONLINE_BACK, ONLINE_FRONT, ON_SEGMENT };
ostream &operator<<(ostream &os, CCW c) { return os << (c == COUNTER_CLOCKWISE ? "COUNTER_CLOCKWISE" : c == CLOCKWISE ? "CLOCKWISE" : c == ONLINE_BACK ? "ONLINE_BACK" : c == ONLINE_FRONT ? "ONLINE_FRONT" : "ON_SEGMENT"); }
template <class K> CCW ccw(const Point<K> &p0, const Point<K> &p1, const Point<K> &p2) {
 Point a= p1 - p0, b= p2 - p0;
 int s;
 if constexpr (is_floating_point_v<K>) s= sgn(sgn(cross(a, b) / sqrt(norm2(a) * norm2(b))));
 else s= sgn(cross(a, b));
 if (s) return s > 0 ? COUNTER_CLOCKWISE : CLOCKWISE;
 if (K d= dot(a, b); sgn(d) < 0) return ONLINE_BACK;
 else return sgn(d - norm2(a)) > 0 ? ONLINE_FRONT : ON_SEGMENT;
}
template <class K> struct Line;
template <class K> struct Segment;
template <class K> class Polygon;
template <class K> struct Convex;
template <class K> struct Affine {
 K a00= 1, a01= 0, a10= 0, a11= 1;
 Point<K> b;
 Point<K> operator()(const Point<K> &p) const { return {a00 * p.x + a01 * p.y + b.x, a10 * p.x + a11 * p.y + b.y}; }
 Line<K> operator()(const Line<K> &l);
 Segment<K> operator()(const Segment<K> &s);
 Polygon<K> operator()(const Polygon<K> &p);
 Convex<K> operator()(const Convex<K> &c);
 Affine operator*(const Affine &r) const { return {a00 * r.a00 + a01 * r.a10, a00 * r.a01 + a01 * r.a11, a10 * r.a00 + a11 * r.a10, a10 * r.a01 + a11 * r.a11, (*this)(r)}; }
 Affine &operator*=(const Affine &r) { return *this= *this * r; }
};
template <class K> Affine<K> translate(const Point<K> &p) { return {1, 0, 0, 1, p}; }
}
#line 4 "src/Geometry/Line.hpp"
namespace geo {
template <class K> struct Line {
 using P= Point<K>;
 P p, d;  // p+td
 Line() {}
 // p + td
 Line(const P &p, const P &d): p(p), d(d) { assert(sgn(norm2(d))); }
 // ax+by+c=0 ................. ax+by+c>0: left, ax+by+c=0: on, ax+by+c<0: right
 Line(K a, K b, K c) {
  int sa= sgn(a), sb= sgn(b);
  assert(sa || sb);
  d= P{b, -a}, p= sb ? P{0, -c / b} : P{-c / a, 0};
 }
 bool operator==(const Line &l) const { return !sgn(cross(d, l.d)) && !where(l.p); }
 bool operator!=(const Line &l) const { return sgn(cross(d, l.d)) || where(l.p); }
 // +1: left, 0: on, -1: right
 int where(const P &q) const { return sgn(cross(d, q - p)); }
 P project(const P &q) const { return p + dot(q - p, d) / norm2(d) * d; }
 // return  a,b,c of ax+by+c=0
 tuple<K, K, K> coef() const { return make_tuple(-d.y, d.x, cross(p, d)); }
 friend ostream &operator<<(ostream &os, const Line &l) { return os << l.p << " + t" << l.d; }
 friend Visualizer &operator<<(Visualizer &vis, const Line &l) {
  auto [a, b, c]= l.coef();
  return vis.ofs << "Line " << a << " " << b << " " << c << "\n", vis;
 }
};
// p + t(q-p)
template <class K> Line<K> line_through(const Point<K> &p, const Point<K> &q) { return Line(p, q - p); }
template <class K> bool is_parallel(const Line<K> &l, const Line<K> &m) { return !sgn(cross(l.d, m.d)); }
template <class K> bool is_orthogonal(const Line<K> &l, const Line<K> &m) { return !sgn(dot(l.d, m.d)); }
// 1 : properly crossing, 0 : disjoint parallel, 2 : same line
template <class K> vector<Point<K>> cross_points(const Line<K> &l, const Line<K> &m) {
 K a= cross(m.d, l.d), b= cross(l.p - m.p, l.d);
 if (sgn(a)) return {m.p + b / a * m.d};  // properly crossing
 if (sgn(b)) return {};                   // disjoint parallel
 return {m.p, m.p + m.d};                 // same line
}
// perpendicular bisector ............ p on leftside
template <class K> Line<K> bisector(const Point<K> &p, const Point<K> &q) { return Line((p + q) / 2, !(q - p)); }
// angle bisector ........... parallel -> 1 line, non-parallel -> 2 lines
template <class K> vector<Line<K>> bisector(const Line<K> &l, const Line<K> &m) {
 auto cp= cross_points(l, m);
 if (cp.size() != 1) return {Line((l.p + m.p) / 2, l.d)};
 auto d= l.d / norm(l.d) + m.d / norm(m.d);
 return {Line(cp[0], d), Line(cp[0], !d)};
}
template <class K> make_long_t<K> dist2(const Line<K> &l, const Point<K> &p) {
 make_long_t<K> a= cross(l.d, p - l.p);
 return a * a / norm2(l.d);
}
template <class K> make_long_t<K> dist2(const Point<K> &p, const Line<K> &l) { return dist2(l, p); }
template <class K> make_long_t<K> dist2(const Line<K> &l, const Line<K> &m) { return is_parallel(l, m) ? dist2(l, m.p) : 0; }
template <class K> Affine<K> reflect(const Line<K> &l) {
 K a= l.d.x * l.d.x, b= l.d.x * l.d.y * 2, c= l.d.y * l.d.y, d= a + c;
 a/= d, b/= d, c/= d, d= a - c;
 return {d, b, b, -d, Point<K>{c * 2 * l.p.x - b * l.p.y, a * 2 * l.p.y - b * l.p.x}};
}
template <class K> Line<K> Affine<K>::operator()(const Line<K> &l) { return line_through((*this)(l.p), (*this)(l.p + l.d)); }
}
#line 10 "test/aoj/2159.rational.test.cpp"
using namespace std;
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(false);
 using namespace geo;
 using R= Rational<__int128_t>;
 int N;
 cin >> N;
 vector<Point<R>> ps(N);
 set<Point<R>> S;
 for (int i= 0; i < N; ++i) cin >> ps[i], S.insert(ps[i]);
 bool isline= true;
 Line m= line_through(ps[0], ps[1]);
 for (int i= 2; i < N; ++i) isline&= m.where(ps[i]) == 0;
 if (isline) return cout << "No" << '\n', 0;
 vector<Line<R>> ls;
 for (int i= 3; i--;)
  for (int j= i + 1; j < N; ++j) ls.emplace_back(bisector(ps[i], ps[j]));
 auto check= [&](const Line<R> &l) {
  int cnt= 0;
  auto ref= reflect(l);
  for (Point p: ps) {
   cnt+= l.where(p) == 0;
   if (!S.count(ref(p))) return false;
  }
  return cnt <= 2;
 };
 bool isok= false;
 for (auto &l: ls) isok|= check(l);
 cout << (isok ? "Yes" : "No") << '\n';
 return 0;
}

Test cases

Env	Name	Status	Elapsed	Memory
g++-13	testcase_00	AC	5 ms	4 MB
g++-13	testcase_01	AC	4 ms	4 MB
g++-13	testcase_02	AC	7 ms	4 MB
g++-13	testcase_03	AC	4 ms	4 MB
g++-13	testcase_04	AC	4 ms	4 MB
g++-13	testcase_05	AC	4 ms	4 MB
g++-13	testcase_06	AC	4 ms	4 MB
g++-13	testcase_07	AC	4 ms	4 MB
g++-13	testcase_08	AC	4 ms	4 MB
g++-13	testcase_09	AC	4 ms	4 MB
g++-13	testcase_10	AC	4 ms	4 MB
g++-13	testcase_11	AC	4 ms	4 MB
g++-13	testcase_12	AC	4 ms	4 MB
g++-13	testcase_13	AC	5 ms	4 MB
g++-13	testcase_14	AC	5 ms	4 MB
g++-13	testcase_15	AC	5 ms	4 MB
g++-13	testcase_16	AC	19 ms	4 MB
g++-13	testcase_17	AC	18 ms	4 MB
g++-13	testcase_18	AC	17 ms	4 MB
g++-13	testcase_19	AC	18 ms	4 MB
g++-13	testcase_20	AC	18 ms	4 MB
g++-13	testcase_21	AC	18 ms	4 MB
g++-13	testcase_22	AC	4 ms	4 MB
g++-13	testcase_23	AC	19 ms	4 MB
g++-13	testcase_24	AC	21 ms	4 MB
g++-13	testcase_25	AC	4 ms	4 MB
g++-13	testcase_26	AC	4 ms	4 MB
g++-13	testcase_27	AC	4 ms	4 MB
g++-13	testcase_28	AC	4 ms	4 MB
g++-13	testcase_29	AC	4 ms	4 MB
g++-13	testcase_30	AC	4 ms	4 MB
g++-13	testcase_31	AC	4 ms	4 MB
g++-13	testcase_32	AC	4 ms	4 MB
g++-13	testcase_33	AC	4 ms	4 MB
g++-13	testcase_34	AC	4 ms	4 MB
g++-13	testcase_35	AC	4 ms	4 MB
g++-13	testcase_36	AC	4 ms	4 MB
g++-13	testcase_37	AC	4 ms	4 MB
g++-13	testcase_38	AC	8 ms	4 MB
g++-13	testcase_39	AC	13 ms	4 MB
g++-13	testcase_40	AC	23 ms	4 MB
g++-13	testcase_41	AC	7 ms	4 MB
g++-13	testcase_42	AC	19 ms	4 MB
g++-13	testcase_43	AC	25 ms	4 MB
g++-13	testcase_44	AC	4 ms	4 MB
g++-13	testcase_45	AC	22 ms	4 MB
g++-13	testcase_46	AC	23 ms	4 MB
g++-13	testcase_47	AC	23 ms	4 MB
g++-13	testcase_48	AC	4 ms	4 MB
g++-13	testcase_49	AC	4 ms	4 MB
g++-13	testcase_50	AC	4 ms	4 MB
g++-13	testcase_51	AC	4 ms	4 MB
clang++-18	testcase_00	AC	5 ms	4 MB
clang++-18	testcase_01	AC	4 ms	4 MB
clang++-18	testcase_02	AC	7 ms	4 MB
clang++-18	testcase_03	AC	4 ms	4 MB
clang++-18	testcase_04	AC	4 ms	4 MB
clang++-18	testcase_05	AC	4 ms	4 MB
clang++-18	testcase_06	AC	4 ms	4 MB
clang++-18	testcase_07	AC	4 ms	4 MB
clang++-18	testcase_08	AC	4 ms	4 MB
clang++-18	testcase_09	AC	4 ms	4 MB
clang++-18	testcase_10	AC	4 ms	4 MB
clang++-18	testcase_11	AC	4 ms	4 MB
clang++-18	testcase_12	AC	4 ms	4 MB
clang++-18	testcase_13	AC	5 ms	4 MB
clang++-18	testcase_14	AC	5 ms	4 MB
clang++-18	testcase_15	AC	5 ms	4 MB
clang++-18	testcase_16	AC	18 ms	4 MB
clang++-18	testcase_17	AC	18 ms	4 MB
clang++-18	testcase_18	AC	16 ms	4 MB
clang++-18	testcase_19	AC	18 ms	4 MB
clang++-18	testcase_20	AC	18 ms	4 MB
clang++-18	testcase_21	AC	19 ms	4 MB
clang++-18	testcase_22	AC	4 ms	4 MB
clang++-18	testcase_23	AC	19 ms	4 MB
clang++-18	testcase_24	AC	21 ms	4 MB
clang++-18	testcase_25	AC	4 ms	4 MB
clang++-18	testcase_26	AC	4 ms	4 MB
clang++-18	testcase_27	AC	4 ms	4 MB
clang++-18	testcase_28	AC	4 ms	4 MB
clang++-18	testcase_29	AC	4 ms	4 MB
clang++-18	testcase_30	AC	4 ms	4 MB
clang++-18	testcase_31	AC	4 ms	4 MB
clang++-18	testcase_32	AC	4 ms	4 MB
clang++-18	testcase_33	AC	4 ms	4 MB
clang++-18	testcase_34	AC	4 ms	4 MB
clang++-18	testcase_35	AC	4 ms	4 MB
clang++-18	testcase_36	AC	4 ms	4 MB
clang++-18	testcase_37	AC	4 ms	4 MB
clang++-18	testcase_38	AC	8 ms	4 MB
clang++-18	testcase_39	AC	13 ms	4 MB
clang++-18	testcase_40	AC	23 ms	4 MB
clang++-18	testcase_41	AC	7 ms	4 MB
clang++-18	testcase_42	AC	19 ms	4 MB
clang++-18	testcase_43	AC	25 ms	4 MB
clang++-18	testcase_44	AC	4 ms	4 MB
clang++-18	testcase_45	AC	21 ms	4 MB
clang++-18	testcase_46	AC	22 ms	4 MB
clang++-18	testcase_47	AC	22 ms	4 MB
clang++-18	testcase_48	AC	4 ms	4 MB
clang++-18	testcase_49	AC	4 ms	4 MB
clang++-18	testcase_50	AC	4 ms	4 MB
clang++-18	testcase_51	AC	4 ms	4 MB

Back to top page