problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02982 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int X[N][D];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= D; j++) {
cin >> X[i][j];
}
}
int counter = 0;
for (int i = 1; i < N; i++) {
for (int j = i + 1; j <= N; j++) {
int distance = 0;
for (int k = 1; k <= D; k++)
distance += pow((X[i][k] - X[j][k]), 2);
bool t = false;
for (int l = 1; l <= 1000; l++) {
if (distance == pow(l, 2))
t = true;
}
if (t)
counter++;
}
}
cout << counter << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int X[11][11];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= D; j++) {
cin >> X[i][j];
}
}
int counter = 0;
for (int i = 1; i < N; i++) {
for (int j = i + 1; j <= N; j++) {
int distance = 0;
for (int k = 1; k <= D; k++)
distance += pow((X[i][k] - X[j][k]), 2);
bool t = false;
for (int l = 1; l <= 1000; l++) {
if (distance == pow(l, 2))
t = true;
}
if (t)
counter++;
}
}
cout << counter << endl;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p02982 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9) + 7;
int main(void) {
int n, d;
cin >> n >> d;
vector<vector<int>> x(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < d; ++j) {
cin >> x[i][j];
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int sum = 0;
for (int k = 0; k < d; ++k) {
sum += (x[i][k] - x[j][k]) * (x[i][k] - x[j][k]);
}
bool ok = false;
for (int k = 1; k <= sum; ++k) {
if (k * k == sum)
ok = true;
}
if (ok)
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9) + 7;
int main(void) {
int n, d;
cin >> n >> d;
vector<vector<int>> x(n, vector<int>(d));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < d; ++j) {
cin >> x[i][j];
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int sum = 0;
for (int k = 0; k < d; ++k) {
sum += (x[i][k] - x[j][k]) * (x[i][k] - x[j][k]);
}
bool ok = false;
for (int k = 1; k <= sum; ++k) {
if (k * k == sum)
ok = true;
}
if (ok)
ans++;
}
}
cout << ans << endl;
return 0;
}
| replace | 24 | 25 | 24 | 25 | 0 | |
p02982 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool isSquare(int n) {
int a = (int)sqrt(n);
return a * a == n;
}
void solve() {
int n, d;
cin >> n >> d;
vector<vector<int>> v(n, vector<int>(d));
for (int i = 0; i < n; ++i)
for (int j = 0; j < d; ++j)
cin >> v[i][j];
int result = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int ans = 0;
for (int k = 0; k < d; ++j) {
ans += (v[i][k] - v[j][k]) * (v[i][k] - v[j][k]);
}
if (isSquare(ans))
result++;
}
}
cout << result << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool isSquare(int n) {
int a = (int)sqrt(n);
return a * a == n;
}
void solve() {
int n, d;
cin >> n >> d;
vector<vector<int>> v(n, vector<int>(d));
for (int i = 0; i < n; ++i)
for (int j = 0; j < d; ++j)
cin >> v[i][j];
int result = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int ans = 0;
for (int k = 0; k < d; ++k) {
ans += (v[i][k] - v[j][k]) * (v[i][k] - v[j][k]);
}
if (isSquare(ans))
result++;
}
}
cout << result << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| replace | 21 | 22 | 21 | 22 | TLE | |
p02982 | C++ | Runtime Error | #pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
int ri() {
int n;
scanf("%d", &n);
return n;
}
int64_t rll() {
long long n;
scanf("%lld", &n);
return n;
}
int main() {
int n = ri();
int d = ri();
int a[n][d];
for (int i = 0; i < n; i++) {
for (int j = 0; j < d; j++)
a[i][j] = ri();
}
int res = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) {
int cur = 0;
for (int k = 0; k < d; k++)
cur += (a[i][k] - a[j][k]) * (a[i][k] - a[j][k]);
int sq = sqrt(cur);
if (sq * sq == cur)
res++;
}
std::cout << res << std::endl;
return 0;
}
| #include <bits/stdc++.h>
int ri() {
int n;
scanf("%d", &n);
return n;
}
int64_t rll() {
long long n;
scanf("%lld", &n);
return n;
}
int main() {
int n = ri();
int d = ri();
int a[n][d];
for (int i = 0; i < n; i++) {
for (int j = 0; j < d; j++)
a[i][j] = ri();
}
int res = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) {
int cur = 0;
for (int k = 0; k < d; k++)
cur += (a[i][k] - a[j][k]) * (a[i][k] - a[j][k]);
int sq = sqrt(cur);
if (sq * sq == cur)
res++;
}
std::cout << res << std::endl;
return 0;
}
| delete | 0 | 3 | 0 | 0 | 0 | |
p02982 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
vector<vector<int>> X(N, vector<int>(D));
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
cin >> X.at(i).at(j);
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < i; j++) {
int tmp = 0;
for (int k = 0; k < N; k++) {
int tmp2 = X.at(i).at(k) - X.at(j).at(k);
tmp += tmp2 * tmp2;
}
if (sqrt(tmp) == (int)sqrt(tmp))
ans++;
}
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
vector<vector<int>> X(N, vector<int>(D));
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
cin >> X.at(i).at(j);
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < i; j++) {
int tmp = 0;
for (int k = 0; k < D; k++) {
int tmp2 = X.at(i).at(k) - X.at(j).at(k);
tmp += tmp2 * tmp2;
}
if (sqrt(tmp) == (int)sqrt(tmp))
ans++;
}
}
cout << ans << "\n";
} | replace | 17 | 18 | 17 | 18 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 2) >= this->size() (which is 2)
|
p02982 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<vector<int>> x(n, vector<int>(d));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> x[i][j];
}
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
int norm = 0;
for (int k = 0; k < d; ++k) {
int diff = x[i][k] - x[j][k];
norm += diff * diff;
}
int s = sqrt(norm) + 0.5;
if (s * s == norm)
cnt++;
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<vector<int>> x(n, vector<int>(d));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < d; ++j) {
cin >> x[i][j];
}
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
int norm = 0;
for (int k = 0; k < d; ++k) {
int diff = x[i][k] - x[j][k];
norm += diff * diff;
}
int s = sqrt(norm) + 0.5;
if (s * s == norm)
cnt++;
}
}
cout << cnt << endl;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p02982 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, D;
cin >> N >> D;
vector<vector<double>> point(N, vector<double>(D, 0));
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
cin >> point[i][j];
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < D; j++) {
double dis = 0;
for (int k = 0; k < D; k++) {
dis += (point[i][k] - point[j][k]) * (point[i][k] - point[j][k]);
}
double distance = sqrt(dis);
if (ceil(distance) == floor(distance))
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, D;
cin >> N >> D;
vector<vector<double>> point(N, vector<double>(D, 0));
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
cin >> point[i][j];
}
}
int ans = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = i + 1; j < N; j++) {
double dis = 0;
for (int k = 0; k < D; k++) {
dis += (point[i][k] - point[j][k]) * (point[i][k] - point[j][k]);
}
double distance = sqrt(dis);
if (ceil(distance) == floor(distance))
ans++;
}
}
cout << ans << endl;
return 0;
}
| replace | 19 | 21 | 19 | 21 | 0 | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
using lint = int64_t;
using namespace std;
const lint mod = 2019;
int main() {
lint L, R;
cin >> L >> R;
lint ans = 9e18;
for (lint i = L; i < R; i++) {
for (lint j = i + 1; j <= R; j++) {
if (i >= j)
continue;
ans = min(ans, i * j % mod);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
using lint = int64_t;
using namespace std;
const lint mod = 2019;
int main() {
lint L, R;
cin >> L >> R;
lint ans = 9e18;
for (lint i = L; i <= min(L + 2020, R); i++) {
for (lint j = max(L, max((lint)0, R - 2020)); j <= R; j++) {
if (i >= j)
continue;
ans = min(ans, i * j % mod);
}
}
cout << ans << endl;
return 0;
}
| replace | 12 | 14 | 12 | 14 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define M_PI 3.141592653589793238
using namespace std;
long long p9 = 998244353;
long long p1 = 1000000007;
#define upperbound(v, val) upper_bound(v.begin(), v.end(), val) - v.begin()
#define lowerbound(v, val) lower_bound(v.begin(), v.end(), val) - v.begin()
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i, n) for (int i = 0; i < n; i++)
#define sor(v) sort(v.begin(), v.end())
#define mmax(a, b) a = max(a, b)
#define mmin(a, b) a = min(a, b)
#define mkp(a, b) make_pair(a, b)
#define pin pair<int, int>
#define qin pair<pin, int>
#define V vector
#define Endl endl
#define veb vector<bool>
#define fcout cout << fixed << setprecision(15)
#define rev(s) reverse(s.begin(), s.end())
#define lower(h, val) (lower_bound(h.begin(), h.end(), val) - h.begin())
#define upper(h, val) (upper_bound(h.begin(), h.end(), val) - h.begin())
#define vveb V<veb>
#define omajinai \
cin.tie(0); \
ios::sync_with_stdio(false);
#define endl "\n"
#define pb push_back
vel kai;
vel inv_kai;
vel inv;
int root(int x, vel &pa) {
if (pa[x] == -1) {
return x;
}
int ans = root(pa[x], pa);
pa[x] = ans;
return ans;
}
bool mar(int x, int y, vel &pa) {
x = root(x, pa);
y = root(y, pa);
if (x != y) {
pa[x] = y;
}
return (x != y);
}
int gcd(int x, int y) {
if (x < y) {
return gcd(y, x);
}
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
int lcm(int x, int y) {
x = abs(x);
y = abs(y);
return x * (y / gcd(x, y));
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
void make_inv(int max_inv, int p) {
inv = vel(max_inv + 1, 1);
for (int i = 2; i <= max_inv; i++) {
inv[i] = p - ((p / i) * inv[p % i]) % p;
}
}
void make_kai(int max_kai, int p) {
kai = vel(max_kai + 1, 1);
inv_kai = kai;
make_inv(max_kai, p);
rep(i, max_kai) {
kai[i + 1] = kai[i] * (i + 1);
kai[i + 1] %= p;
inv_kai[i + 1] = inv_kai[i] * inv[i + 1];
inv_kai[i + 1] %= p;
}
}
int com(int n, int r, int p) {
if ((n < 0) || (r < 0) || (r > n)) {
return 0;
}
int ans = (kai[n] * inv_kai[r]) % p;
return (ans * inv_kai[n - r]) % p;
}
int per(int n, int r, int p) {
if ((n < 0) || (r < 0) || (r > n)) {
return 0;
}
return (kai[n] * inv_kai[n - r]) % p;
}
vel uni(vel x) {
if (x.size() == 0) {
return x;
}
sor(x);
int n = x.size();
vel ans(1, x[0]);
for (int j = 1; j < n; j++) {
if (x[j - 1] != x[j]) {
ans.push_back(x[j]);
}
}
x = ans;
return x;
}
vel dijk(V<V<pin>> &way, int st, int inf) {
int n = way.size();
vel dist(n, inf);
dist[st] = 0;
priority_queue<pin, vector<pin>, greater<pin>> pq;
pq.push(mkp(0, st));
veb is_checked(n, false);
while (!pq.empty()) {
pin x = pq.top();
pq.pop();
int pot = x.second;
if (!is_checked[pot]) {
is_checked[pot] = true;
for (auto y : way[pot]) {
int nex_dist = x.first + y.second;
int nex_pot = y.first;
if (dist[nex_pot] > nex_dist) {
dist[nex_pot] = nex_dist;
pq.push(mkp(nex_dist, y.first));
}
}
}
}
return dist;
}
void make_tree(vvel &chi, vel &par, int n) {
V<V<pin>> way(n);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
way[a].push_back(mkp(b, 1));
way[b].push_back(mkp(a, 1));
}
vel dist = dijk(way, 0, n + 1);
par = vel(n, -1);
chi = vvel(n);
rep(i, n) {
for (auto nex : way[i]) {
int pot = nex.first;
if (dist[pot] > dist[i]) {
chi[i].push_back(pot);
} else {
par[i] = pot;
}
}
}
}
void pri(vel &v) {
if (v.size() == 0) {
return;
}
cout << v[0];
rep(i, v.size() - 1) { cout << " " << v[i + 1]; }
cout << endl;
return;
}
int modpow(int a, int n, int p) {
if (n == 0) {
return 1;
}
int m = n / 2;
int x = modpow(a, n / 2, p);
x *= x;
x %= p;
if (n % 2 == 1) {
x *= a;
x %= p;
}
return x;
}
#define ui long long
vvel disj_min(vel &v) {
int n = v.size();
vvel ret(22, vel(n));
ret[0] = v;
rep(i, 21) {
rep(j, n) {
int nex = j + (1 << i);
if (nex < n) {
ret[i + 1][j] = min(ret[i][j], ret[i][nex]);
} else {
ret[i + 1][j] = ret[i][j];
}
}
}
return ret;
}
int find_min(vvel &dv, int l, int r) {
int i = 21;
while (l + (1 << i) > r) {
i--;
}
while (i >= 0) {
if (dv[i][l] > dv[i][r - (1 << i)]) {
l = r - (1 << i);
} else {
r = l + (1 << i);
}
i--;
}
return l;
}
void sol(V<string> &t, int i, string u) {
t.push_back(u);
if (i < u.size()) {
sol(t, i + 1, u);
u[i] = '.';
sol(t, i + 1, u);
}
}
V<V<pin>> dbl(V<pin> &v) {
V<V<pin>> ans(20, V<pin>(v));
int n = v.size();
rep(i, 19) {
rep(j, n) {
ans[i + 1][j].first = ans[i][ans[i][j].first].first;
ans[i + 1][j].second =
max(ans[i][j].second, ans[i][ans[i][j].first].second);
}
}
return ans;
}
int lca(int s, int t, int diff, V<V<pin>> &pa) {
if (diff < 0) {
return lca(t, s, -diff, pa);
}
int ans = 0;
rep(i, 19) {
if ((diff & (1 << i)) != 0) {
mmax(ans, pa[i][s].second);
s = pa[i][s].first;
}
}
for (int i = 19; i >= 0; i--) {
if (pa[i][s] != pa[i][t]) {
mmax(ans, pa[i][s].second);
s = pa[i][s].first;
mmax(ans, pa[i][t].second);
t = pa[i][t].first;
}
}
if (s != t) {
mmax(ans, pa[0][s].second);
mmax(ans, pa[0][t].second);
}
return ans;
}
void alp(int n, vel &pr) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
pr.push_back(i);
while (n % i == 0) {
n /= i;
}
}
}
if (n != 1) {
pr.push_back(n);
}
}
vel dx = {0, 0, -1, 1};
vel dy = {1, -1, 0, 0};
signed main() {
omajinai;
int l, r;
cin >> l >> r;
if (l - r >= 700) {
cout << 0 << endl;
return 0;
}
int ans = 2019;
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
mmin(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define M_PI 3.141592653589793238
using namespace std;
long long p9 = 998244353;
long long p1 = 1000000007;
#define upperbound(v, val) upper_bound(v.begin(), v.end(), val) - v.begin()
#define lowerbound(v, val) lower_bound(v.begin(), v.end(), val) - v.begin()
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i, n) for (int i = 0; i < n; i++)
#define sor(v) sort(v.begin(), v.end())
#define mmax(a, b) a = max(a, b)
#define mmin(a, b) a = min(a, b)
#define mkp(a, b) make_pair(a, b)
#define pin pair<int, int>
#define qin pair<pin, int>
#define V vector
#define Endl endl
#define veb vector<bool>
#define fcout cout << fixed << setprecision(15)
#define rev(s) reverse(s.begin(), s.end())
#define lower(h, val) (lower_bound(h.begin(), h.end(), val) - h.begin())
#define upper(h, val) (upper_bound(h.begin(), h.end(), val) - h.begin())
#define vveb V<veb>
#define omajinai \
cin.tie(0); \
ios::sync_with_stdio(false);
#define endl "\n"
#define pb push_back
vel kai;
vel inv_kai;
vel inv;
int root(int x, vel &pa) {
if (pa[x] == -1) {
return x;
}
int ans = root(pa[x], pa);
pa[x] = ans;
return ans;
}
bool mar(int x, int y, vel &pa) {
x = root(x, pa);
y = root(y, pa);
if (x != y) {
pa[x] = y;
}
return (x != y);
}
int gcd(int x, int y) {
if (x < y) {
return gcd(y, x);
}
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
int lcm(int x, int y) {
x = abs(x);
y = abs(y);
return x * (y / gcd(x, y));
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
void make_inv(int max_inv, int p) {
inv = vel(max_inv + 1, 1);
for (int i = 2; i <= max_inv; i++) {
inv[i] = p - ((p / i) * inv[p % i]) % p;
}
}
void make_kai(int max_kai, int p) {
kai = vel(max_kai + 1, 1);
inv_kai = kai;
make_inv(max_kai, p);
rep(i, max_kai) {
kai[i + 1] = kai[i] * (i + 1);
kai[i + 1] %= p;
inv_kai[i + 1] = inv_kai[i] * inv[i + 1];
inv_kai[i + 1] %= p;
}
}
int com(int n, int r, int p) {
if ((n < 0) || (r < 0) || (r > n)) {
return 0;
}
int ans = (kai[n] * inv_kai[r]) % p;
return (ans * inv_kai[n - r]) % p;
}
int per(int n, int r, int p) {
if ((n < 0) || (r < 0) || (r > n)) {
return 0;
}
return (kai[n] * inv_kai[n - r]) % p;
}
vel uni(vel x) {
if (x.size() == 0) {
return x;
}
sor(x);
int n = x.size();
vel ans(1, x[0]);
for (int j = 1; j < n; j++) {
if (x[j - 1] != x[j]) {
ans.push_back(x[j]);
}
}
x = ans;
return x;
}
vel dijk(V<V<pin>> &way, int st, int inf) {
int n = way.size();
vel dist(n, inf);
dist[st] = 0;
priority_queue<pin, vector<pin>, greater<pin>> pq;
pq.push(mkp(0, st));
veb is_checked(n, false);
while (!pq.empty()) {
pin x = pq.top();
pq.pop();
int pot = x.second;
if (!is_checked[pot]) {
is_checked[pot] = true;
for (auto y : way[pot]) {
int nex_dist = x.first + y.second;
int nex_pot = y.first;
if (dist[nex_pot] > nex_dist) {
dist[nex_pot] = nex_dist;
pq.push(mkp(nex_dist, y.first));
}
}
}
}
return dist;
}
void make_tree(vvel &chi, vel &par, int n) {
V<V<pin>> way(n);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
way[a].push_back(mkp(b, 1));
way[b].push_back(mkp(a, 1));
}
vel dist = dijk(way, 0, n + 1);
par = vel(n, -1);
chi = vvel(n);
rep(i, n) {
for (auto nex : way[i]) {
int pot = nex.first;
if (dist[pot] > dist[i]) {
chi[i].push_back(pot);
} else {
par[i] = pot;
}
}
}
}
void pri(vel &v) {
if (v.size() == 0) {
return;
}
cout << v[0];
rep(i, v.size() - 1) { cout << " " << v[i + 1]; }
cout << endl;
return;
}
int modpow(int a, int n, int p) {
if (n == 0) {
return 1;
}
int m = n / 2;
int x = modpow(a, n / 2, p);
x *= x;
x %= p;
if (n % 2 == 1) {
x *= a;
x %= p;
}
return x;
}
#define ui long long
vvel disj_min(vel &v) {
int n = v.size();
vvel ret(22, vel(n));
ret[0] = v;
rep(i, 21) {
rep(j, n) {
int nex = j + (1 << i);
if (nex < n) {
ret[i + 1][j] = min(ret[i][j], ret[i][nex]);
} else {
ret[i + 1][j] = ret[i][j];
}
}
}
return ret;
}
int find_min(vvel &dv, int l, int r) {
int i = 21;
while (l + (1 << i) > r) {
i--;
}
while (i >= 0) {
if (dv[i][l] > dv[i][r - (1 << i)]) {
l = r - (1 << i);
} else {
r = l + (1 << i);
}
i--;
}
return l;
}
void sol(V<string> &t, int i, string u) {
t.push_back(u);
if (i < u.size()) {
sol(t, i + 1, u);
u[i] = '.';
sol(t, i + 1, u);
}
}
V<V<pin>> dbl(V<pin> &v) {
V<V<pin>> ans(20, V<pin>(v));
int n = v.size();
rep(i, 19) {
rep(j, n) {
ans[i + 1][j].first = ans[i][ans[i][j].first].first;
ans[i + 1][j].second =
max(ans[i][j].second, ans[i][ans[i][j].first].second);
}
}
return ans;
}
int lca(int s, int t, int diff, V<V<pin>> &pa) {
if (diff < 0) {
return lca(t, s, -diff, pa);
}
int ans = 0;
rep(i, 19) {
if ((diff & (1 << i)) != 0) {
mmax(ans, pa[i][s].second);
s = pa[i][s].first;
}
}
for (int i = 19; i >= 0; i--) {
if (pa[i][s] != pa[i][t]) {
mmax(ans, pa[i][s].second);
s = pa[i][s].first;
mmax(ans, pa[i][t].second);
t = pa[i][t].first;
}
}
if (s != t) {
mmax(ans, pa[0][s].second);
mmax(ans, pa[0][t].second);
}
return ans;
}
void alp(int n, vel &pr) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
pr.push_back(i);
while (n % i == 0) {
n /= i;
}
}
}
if (n != 1) {
pr.push_back(n);
}
}
vel dx = {0, 0, -1, 1};
vel dy = {1, -1, 0, 0};
signed main() {
omajinai;
int l, r;
cin >> l >> r;
if (r - l >= 700) {
cout << 0 << endl;
return 0;
}
int ans = 2019;
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
mmin(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
}
| replace | 308 | 309 | 308 | 309 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <climits>
#include <iostream>
using namespace std;
int main() {
long L, R;
cin >> L >> R;
long minimum = LONG_MAX;
for (long i = L; i <= R; i++) {
for (long j = i + 1; j <= R; j++) {
if ((i * j) % 2019 < minimum) {
minimum = (i * j) % 2019;
}
}
}
cout << minimum << endl;
return 0;
} | #include <climits>
#include <iostream>
using namespace std;
int main() {
long L, R;
cin >> L >> R;
long minimum = LONG_MAX;
if (R - L > 2019) {
minimum = 0;
} else {
for (long i = L; i <= R; i++) {
for (long j = i + 1; j <= R; j++) {
if ((i * j) % 2019 < minimum) {
minimum = (i * j) % 2019;
}
}
}
}
cout << minimum << endl;
return 0;
} | replace | 9 | 13 | 9 | 17 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int l, r;
cin >> l >> r;
ll result = INT_MAX;
for (int i = l; (i < r && i <= (l + 2019)); ++i) {
for (int j = i + 1; j <= r && j <= (j + 2019); ++j) {
result = min(result, ((ll)i * j) % 2019);
}
}
cout << result << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int l, r;
cin >> l >> r;
ll result = INT_MAX;
for (int i = l; (i < r && i <= (l + 2019)); ++i) {
for (int j = i + 1; j <= r && j <= (i + 1 + 2019); ++j) {
result = min(result, ((ll)i * j) % 2019);
}
}
cout << result << endl;
return 0;
}
| replace | 15 | 16 | 15 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y);
const int INF = 1001001001;
int main() {
ll l, r;
cin >> l >> r;
r = min(l + 2019, r);
ll ans = INF;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
i = i % 2019;
j = j % 2019;
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y);
const int INF = 1001001001;
int main() {
ll l, r;
cin >> l >> r;
r = min(l + 2019, r);
ll ans = INF;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
// i = i%2019;
// j = j%2019;
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
} | replace | 15 | 17 | 15 | 17 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
unsigned int L, R;
cin >> L >> R;
unsigned int m = 2019;
for (unsigned int i = L; i < R; i++) {
for (unsigned int j = i + 1; j <= R; j++) {
unsigned int d = ((i % 2019) * (j % 2019)) % 2019;
if (d < m)
m = d;
if (m == 0)
break;
}
}
cout << m << endl << flush;
return 0;
}
| #include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
unsigned int L, R;
cin >> L >> R;
unsigned int m = 2019;
for (unsigned int i = L; i < R && i <= L + 2019; i++) {
for (unsigned int j = i + 1; j <= R && i <= j + 2019; j++) {
unsigned int d = ((i % 2019) * (j % 2019)) % 2019;
if (d < m)
m = d;
if (m == 0)
break;
}
}
cout << m << endl << flush;
return 0;
}
| replace | 13 | 15 | 13 | 15 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
#include <math.h>
using namespace std;
int n, m, ans = 2019 * 2019;
int main() {
cin >> n >> m;
for (int i = n; i < m; i++)
for (int o = i + 1; o <= m; o++)
ans = min(ans, ((i % 2019) * (o % 2019) % 2019));
cout << ans << endl;
} | #include <iostream>
#include <math.h>
using namespace std;
int n, m, ans = 2019 * 2019;
int main() {
cin >> n >> m;
if (m - n >= 2019)
cout << 0 << endl;
else {
for (int i = n; i < m; i++)
for (int o = i + 1; o <= m; o++)
ans = min(ans, ((i % 2019) * (o % 2019) % 2019));
cout << ans << endl;
}
} | replace | 6 | 10 | 6 | 14 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
a = abs(a), b = abs(b);
while (b > 0) {
tie(a, b) = make_pair(b, a % b);
}
return a;
}
// mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr long long INF = 1LL << 60;
constexpr int inf = 1000000007;
// constexpr long long mod = 1000000007LL;
constexpr long long mod = 998244353LL;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
constexpr ll mod = 2019;
ll L, R;
cin >> L >> R;
ll res = INF;
for (ll i = L; i <= R; i++) {
for (ll j = i + 1; j <= R; j++) {
chmin(res, (i * j) % mod);
if (res == 0)
break;
}
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
a = abs(a), b = abs(b);
while (b > 0) {
tie(a, b) = make_pair(b, a % b);
}
return a;
}
// mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr long long INF = 1LL << 60;
constexpr int inf = 1000000007;
// constexpr long long mod = 1000000007LL;
constexpr long long mod = 998244353LL;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
constexpr ll mod = 2019;
ll L, R;
cin >> L >> R;
ll res = INF;
for (ll i = L; i <= R; i++) {
for (ll j = i + 1; j <= R; j++) {
chmin(res, (i * j) % mod);
if (res == 0)
break;
}
if (res == 0)
break;
}
cout << res << endl;
return 0;
}
| insert | 72 | 72 | 72 | 74 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
constexpr int MOD = 2019;
int main() {
int L, R;
std::cin >> L >> R;
if (R - L > (MOD + 10) * (MOD + 10)) {
R = L + (MOD + 10) * (MOD + 10);
}
int min = MOD;
for (int i = L; i <= R; ++i) {
for (int j = i + 1; j <= R; ++j) {
int r = ((i % MOD) * (j % MOD)) % MOD;
min = std::min(min, r);
}
}
std::cout << min << std::endl;
return 0;
} | #include <algorithm>
#include <iostream>
constexpr int MOD = 2019;
int main() {
int L, R;
std::cin >> L >> R;
if (R - L > MOD + 10) {
R = L + MOD + 10;
}
int min = MOD;
for (int i = L; i <= R; ++i) {
for (int j = i + 1; j <= R; ++j) {
int r = ((i % MOD) * (j % MOD)) % MOD;
min = std::min(min, r);
}
}
std::cout << min << std::endl;
return 0;
} | replace | 8 | 10 | 8 | 10 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using Int = long long int;
template <typename T> void swap(T *t1, T *t2) {
T *tmp = t1;
t1 = t2;
t2 = tmp;
}
Int tmpi = 0;
double tmpd = 0.0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Int l, r;
cin >> l >> r;
Int min = pow(10, 18);
for (Int i = l; i < r; i++) {
for (Int j = i + 1; j <= r; j++) {
if (i % 2019 == 0) {
cout << 0 << endl;
break;
}
min = i * j % 2019 < min ? i * j % 2019 : min;
}
}
cout << min << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Int = long long int;
template <typename T> void swap(T *t1, T *t2) {
T *tmp = t1;
t1 = t2;
t2 = tmp;
}
Int tmpi = 0;
double tmpd = 0.0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Int l, r;
cin >> l >> r;
Int min = pow(10, 18);
for (Int i = l; i < r; i++) {
for (Int j = i + 1; j <= r; j++) {
if (i * j % 2019 == 0) {
cout << '0' << endl;
return 0;
}
min = i * j % 2019 < min ? i * j % 2019 : min;
}
}
cout << min << endl;
return 0;
} | replace | 21 | 24 | 21 | 24 | TLE | |
p02983 | C++ | Time Limit Exceeded | /*
*/
#include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main() {
long long l, r;
int ans = 2019;
cin >> l >> r;
vector<bool> a(2019, false);
for (int i = l; i <= r; i++)
a[i % 2019] = true;
for (int i = 0; i < 2019; i++) {
for (int j = i + 1; j < 2019; j++) {
if (a[i] && a[j])
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
} | /*
*/
#include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main() {
long long l, r;
int ans = 2019;
cin >> l >> r;
vector<bool> a(2019, false);
if (r - l < 2019) {
for (int i = l; i <= r; i++)
a[i % 2019] = true;
} else {
for (int i = 0; i < 2019; i++)
a[i] = true;
}
for (int i = 0; i < 2019; i++) {
for (int j = i + 1; j < 2019; j++) {
if (a[i] && a[j])
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
} | replace | 18 | 22 | 18 | 25 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
long L, R;
cin >> L >> R;
long ans = 2147483647;
for (long i = L; i <= R; i++) {
for (long j = i + 1; j <= R; j++) {
if (i % 2019 == 0) {
cout << 0;
return 0;
}
if (i * j % 2019 < ans) {
ans = i * j % 2019;
}
}
}
cout << ans;
return 0;
} | #include <iostream>
using namespace std;
int main() {
long L, R;
cin >> L >> R;
long ans = 2147483647;
for (long i = L; i <= R; i++) {
for (long j = i + 1; j <= R; j++) {
if (j % 2019 == 0) {
cout << 0;
return 0;
}
if (i * j % 2019 < ans) {
ans = i * j % 2019;
}
}
}
cout << ans;
return 0;
} | replace | 10 | 11 | 10 | 11 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define endl "\n"
using namespace std;
long long int l, r, i, j, a;
int main() {
cin >> l >> r;
int x = 2018;
for (i = l; i <= r; i++) {
for (j = i + 1; j <= r; j++) {
a = (i * j) % 2019;
if (a < x) {
x = a;
}
if (a == 0) {
break;
}
}
}
cout << x;
}
// g++ -std=c++14 comp.cpp; ./a.exe
| #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define endl "\n"
using namespace std;
long long int l, r, i, j, a;
int main() {
cin >> l >> r;
int x = 2018;
for (i = l; i <= r; i++) {
for (j = i + 1; j <= r; j++) {
a = (i * j) % 2019;
if (a < x) {
x = a;
}
if (x == 0) {
cout << 0;
return 0;
}
}
}
cout << x;
}
// g++ -std=c++14 comp.cpp; ./a.exe
| replace | 29 | 31 | 29 | 32 | TLE | |
p02983 | C++ | Time Limit Exceeded | // C
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <forward_list>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// Hang in there!
using namespace std;
//+97
int main() {
long long L, R;
cin >> L >> R;
long long ans = LLONG_MAX;
for (long long i = L; i <= R; i++) {
for (long long j = i + 1; j <= R; j++) {
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
// Maybe TLE | // C
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <forward_list>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// Hang in there!
using namespace std;
//+97
int main() {
long long L, R;
cin >> L >> R;
long long ans = LLONG_MAX;
for (long long i = L; i <= min(R, L + 2018); i++) {
for (long long j = i + 1; j <= min(R, i + 1 + 2018); j++) {
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
// Maybe TLE | replace | 87 | 89 | 87 | 89 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <climits>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip> //setprecision
#include <iostream>
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define mod 1000000007
vector<ll> to[1000005];
ll dp[2000000];
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int main() {
ll a, b, c = INT_MAX;
cin >> a >> b;
if (b - a >= 2019) {
cout << 0;
}
for (ll i = a; i < b + 1; i++) {
for (ll o = i + 1; o < b + 1; o++) {
c = min(c, i % 2019 * o % 2019);
}
}
cout << c;
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <climits>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip> //setprecision
#include <iostream>
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define mod 1000000007
vector<ll> to[1000005];
ll dp[2000000];
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int main() {
ll a, b, c = INT_MAX;
cin >> a >> b;
if (b - a >= 2019) {
cout << 0;
return 0;
}
for (ll i = a; i < b + 1; i++) {
for (ll o = i + 1; o < b + 1; o++) {
c = min(c, i % 2019 * o % 2019);
}
}
cout << c;
}
| insert | 39 | 39 | 39 | 40 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) \
; \
for (ll i = 0; i < (ll)n; i++)
int main() {
ll ans = 2018;
bool fin = false;
ll L, R;
cin >> L >> R;
for (ll i = L; i < R; i++) {
for (ll j = i + 1; j < R + 1; j++) {
ll mod = (i * j) % 2019;
if (mod < ans)
ans = mod;
if (mod = 0) {
fin = true;
break;
}
}
if (fin)
break;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) \
; \
for (ll i = 0; i < (ll)n; i++)
int main() {
ll ans = 2018;
bool fin = false;
ll L, R;
cin >> L >> R;
for (ll i = L; i < R; i++) {
for (ll j = i + 1; j < R + 1; j++) {
ll mod = (i * j) % 2019;
if (mod < ans)
ans = mod;
if (ans == 0) {
fin = true;
break;
}
}
if (fin)
break;
}
cout << ans << endl;
} | replace | 18 | 19 | 18 | 19 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long L, R;
cin >> L >> R;
long answer = L * R;
if (!(L * R < 2019)) {
for (long i = L; i < R; i++) {
for (long j = L + 1; j <= R; j++) {
long mod = (i * j) % 2019;
if (answer > mod) {
answer = mod;
}
}
}
}
cout << answer << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long L, R;
cin >> L >> R;
long answer = L * R;
if (R - L + 1 >= 2019) {
cout << 0 << endl;
return 0;
}
if (!(L * R < 2019)) {
for (long i = L; i < R; i++) {
for (long j = L + 1; j <= R; j++) {
long mod = (i * j) % 2019;
if (answer > mod) {
answer = mod;
}
}
}
}
cout << answer << endl;
}
| insert | 7 | 7 | 7 | 11 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main(void) {
long long int l;
long long int r;
long long int a, b;
long long int n = 0;
int min = 10000000;
cin >> l >> r;
for (a = l; a < r; a++) {
for (b = l + 1; b < r + 1; b++) {
n = a * b % 2019;
if (n < min) {
min = n;
}
}
}
cout << min << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
long long int l;
long long int r;
long long int a, b;
long long int n = 0;
int min = 10000000;
cin >> l >> r;
if (r - l > 2020) {
cout << "0" << endl;
return 0;
}
for (a = l; a < r; a++) {
for (b = l + 1; b < r + 1; b++) {
n = a * b % 2019;
if (n < min) {
min = n;
}
}
}
cout << min << endl;
return 0;
} | insert | 11 | 11 | 11 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
long long l, r, ans = 2020, a[2020];
int main(int argc, char const *argv[]) {
scanf("%lld%lld", &l, &r);
for (long long i = l; i <= r; ++i) {
memset(a, 0, sizeof(a));
for (long long j = i + 1; j <= r; ++j) {
if (a[(i * j) % 2019] == 1)
break;
a[(i * j) % 2019] = 1;
ans = min(ans, (i * j) % 2019);
}
}
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
long long l, r, ans = 2020, a[2020];
int main(int argc, char const *argv[]) {
scanf("%lld%lld", &l, &r);
if (l / 2019 != r / 2019) {
printf("0\n");
return 0;
}
for (long long i = l; i <= r; ++i) {
memset(a, 0, sizeof(a));
for (long long j = i + 1; j <= r; ++j) {
if (a[(i * j) % 2019] == 1)
break;
a[(i * j) % 2019] = 1;
ans = min(ans, (i * j) % 2019);
}
}
printf("%lld\n", ans);
return 0;
} | insert | 9 | 9 | 9 | 13 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int l, r;
cin >> l >> r;
int d = r - l;
int ans = 2019;
for (int i = 0; i < d; i++) {
for (int j = i + 1; j <= d; j++) {
int x = (l + i) % 2019;
int y = (l + j) % 2019;
ans = min(ans, (x * y) % 2019);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int l, r;
cin >> l >> r;
int d = min(2019, (r - l));
int ans = 2019;
for (int i = 0; i < d; i++) {
for (int j = i + 1; j <= d; j++) {
int x = (l + i) % 2019;
int y = (l + j) % 2019;
ans = min(ans, (x * y) % 2019);
}
}
cout << ans << endl;
} | replace | 6 | 7 | 6 | 7 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
ll P = 2019;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
if (r - l > 2019) {
cout << 0 << endl;
}
ll ans = 2019 * 2019;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++)
ans = min(ans, (i % P * j % P) % P);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
ll P = 2019;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
if (r - l > 2019) {
cout << 0 << endl;
return 0;
}
ll ans = 2019 * 2019;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++)
ans = min(ans, (i % P * j % P) % P);
}
cout << ans << endl;
return 0;
}
| insert | 19 | 19 | 19 | 20 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using vi = vector<int>;
using vii = vector<vi>;
int main() {
long long int l, r;
cin >> l >> r;
bool flag = false;
int m = 2019;
if (l - r + 1 >= 2019) {
m = 0;
flag = true;
}
if (!flag) {
for (long long int i = l; i < r; i++) {
for (long long int j = l + 1; j <= r; j++) {
long long int a, b;
a = i % 2019;
b = j % 2019;
if (m > (a * b) % 2019) {
m = (a * b) % 2019;
if (m == 0)
break;
}
}
}
}
cout << m << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using vi = vector<int>;
using vii = vector<vi>;
int main() {
long long int l, r;
cin >> l >> r;
bool flag = false;
int m = 2019;
if (l - r + 1 >= 2019) {
m = 0;
flag = true;
}
if (!flag) {
for (long long int i = l; i < r; i++) {
for (long long int j = l + 1; j <= r; j++) {
long long int a, b;
a = i % 2019;
b = j % 2019;
if (m > (a * b) % 2019) {
m = (a * b) % 2019;
if (m == 0)
break;
}
}
if (m == 0)
break;
}
}
cout << m << endl;
}
| insert | 30 | 30 | 30 | 32 | TLE | |
p02983 | C++ | Time Limit Exceeded | #pragma GCC optimize("O3")
#pragma GCC target("tune=native")
#pragma GCC target("avx")
#include <bits/stdc++.h>
// 汎用マクロ
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i, n) for (long long i = 0, i##_len = (n); i < i##_len; i++)
#define RANGE(i, is, ie) \
for (long long i = (is), i##_end = (ie); i <= i##_end; i++)
#define DSRNG(i, is, ie) \
for (long long i = (is), i##_end = (ie); i >= i##_end; i--)
#define UNIQUE(v) \
{ \
sort((v).begin(), (v).end()); \
(v).erase(unique((v).begin(), (v).end()), (v).end()); \
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define INF 0x7FFFFFFF
#define LINF 0x7FFFFFFFFFFFFFFFLL
#define Yes(q) (q ? "Yes" : "No")
#define YES(q) (q ? "YES" : "NO")
#define DUMP(q) \
cerr << "[DEBUG] " #q ": " << (q) << " at " __FILE__ ":" << __LINE__ << endl
#define DUMPALL(q) \
{ \
cerr << "[DEBUG] " #q ": ["; \
REP(dumpall_i, (q).size()) { \
cerr << q[dumpall_i] << (dumpall_i == (q).size() - 1 ? "" : ", "); \
} \
cerr << "] at " __FILE__ ":" << __LINE__ << endl; \
}
template <class T> T gcd(const T &a, const T &b) {
return a < b ? gcd(b, a) : b ? gcd(b, a % b) : a;
}
template <class T> T lcm(const T &a, const T &b) { return a / gcd(a, b) * b; }
// gcc拡張マクロ
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
// エイリアス
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using namespace std;
// モジュール
// 処理内容
int main() {
ll l, r;
cin >> l >> r;
if (l - r + 1 >= 2019) {
cout << 0 << endl;
return 0;
} else {
ll ans = INF;
RANGE(i, l, r) RANGE(j, i + 1, r) { chmin(ans, i * j % 2019); }
cout << ans << endl;
}
} | #pragma GCC optimize("O3")
#pragma GCC target("tune=native")
#pragma GCC target("avx")
#include <bits/stdc++.h>
// 汎用マクロ
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i, n) for (long long i = 0, i##_len = (n); i < i##_len; i++)
#define RANGE(i, is, ie) \
for (long long i = (is), i##_end = (ie); i <= i##_end; i++)
#define DSRNG(i, is, ie) \
for (long long i = (is), i##_end = (ie); i >= i##_end; i--)
#define UNIQUE(v) \
{ \
sort((v).begin(), (v).end()); \
(v).erase(unique((v).begin(), (v).end()), (v).end()); \
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define INF 0x7FFFFFFF
#define LINF 0x7FFFFFFFFFFFFFFFLL
#define Yes(q) (q ? "Yes" : "No")
#define YES(q) (q ? "YES" : "NO")
#define DUMP(q) \
cerr << "[DEBUG] " #q ": " << (q) << " at " __FILE__ ":" << __LINE__ << endl
#define DUMPALL(q) \
{ \
cerr << "[DEBUG] " #q ": ["; \
REP(dumpall_i, (q).size()) { \
cerr << q[dumpall_i] << (dumpall_i == (q).size() - 1 ? "" : ", "); \
} \
cerr << "] at " __FILE__ ":" << __LINE__ << endl; \
}
template <class T> T gcd(const T &a, const T &b) {
return a < b ? gcd(b, a) : b ? gcd(b, a % b) : a;
}
template <class T> T lcm(const T &a, const T &b) { return a / gcd(a, b) * b; }
// gcc拡張マクロ
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
// エイリアス
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using namespace std;
// モジュール
// 処理内容
int main() {
ll l, r;
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0 << endl;
return 0;
} else {
ll ans = INF;
RANGE(i, l, r) RANGE(j, i + 1, r) { chmin(ans, i * j % 2019); }
cout << ans << endl;
}
} | replace | 69 | 70 | 69 | 70 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
long int l, r;
long int min = 3000;
cin >> l >> r;
for (long int i = l; i <= r - 1; i++) {
for (long int j = i + 1; j <= r; j++) {
int tmp = (i * j) % 2019;
if (tmp < min) {
min = tmp;
}
}
}
cout << min << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
long int l, r;
long int min = 3000;
cin >> l >> r;
for (long int i = l; i <= r - 1; i++) {
for (long int j = i + 1; j <= r; j++) {
int tmp = (i * j) % 2019;
if (tmp < min) {
min = tmp;
}
if (min == 0) {
break;
}
}
if (min == 0) {
break;
}
}
cout << min << endl;
return 0;
}
| insert | 16 | 16 | 16 | 22 | TLE | |
p02983 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long long ll;
const long long INF = 200000000000000;
double pi = 3.141592653589793;
const int MOD = 1000000007;
long long gcd(long long a, long long b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(a % b, b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long myPow(long long x, long long n, long long m = MOD) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
ll digit(ll num) {
ll ret = 0;
string s = to_string(num);
return s.length();
}
class Edge {
public:
ll num;
ll a;
ll b;
ll color = 0;
Edge(ll _num, ll _a, ll _b) {
num = _num;
a = _a;
b = _b;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll l, r;
cin >> l >> r;
if (r - l >= 3000) {
cout << 0 << endl;
return 0;
}
ll ans = INF;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, (ll)(i * j) % 2019);
}
}
cout << ans << endl;
return 1;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long long ll;
const long long INF = 200000000000000;
double pi = 3.141592653589793;
const int MOD = 1000000007;
long long gcd(long long a, long long b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(a % b, b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long myPow(long long x, long long n, long long m = MOD) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
ll digit(ll num) {
ll ret = 0;
string s = to_string(num);
return s.length();
}
class Edge {
public:
ll num;
ll a;
ll b;
ll color = 0;
Edge(ll _num, ll _a, ll _b) {
num = _num;
a = _a;
b = _b;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll l, r;
cin >> l >> r;
if (r - l >= 3000) {
cout << 0 << endl;
return 0;
}
ll ans = INF;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, (ll)(i * j) % 2019);
}
}
cout << ans << endl;
// return 1;
}
| replace | 72 | 73 | 72 | 73 | 1 | |
p02983 | C++ | Time Limit Exceeded | // nlather (Nishant Raj Lather)
// Chrollo_Lucifer
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rnd(x, y) uniform_int_distribution<ll>(x, y)(rng)
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr);
#define rep(i, x, n) for (ll i = x; i < n; i++)
#define rrep(i, x, n) for (ll i = x; i >= n; i--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define e emplace
#define mp make_pair
#define debug(this) cout << "> " << #this << " : " << this << "\n"
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
const ll MOD = 1e9 + 7;
ld PI = 3.1415926535897932384626;
ld EPS = 1e-9;
#define endl '\n'
int main() {
boost;
ll l, r;
cin >> l >> r;
if (l <= 2019 and r >= 2019) {
cout << "0";
return 0;
}
ll ans = (l * r) % 2019;
l %= (2019 * 2019), r %= (2019 * 2019);
if (l > r)
swap(l, r);
rep(i, l, r) rep(j, (i + 1), (r + 1)) ans = min(ans, (i * j) % 2019);
cout << ans;
}
| // nlather (Nishant Raj Lather)
// Chrollo_Lucifer
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rnd(x, y) uniform_int_distribution<ll>(x, y)(rng)
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr);
#define rep(i, x, n) for (ll i = x; i < n; i++)
#define rrep(i, x, n) for (ll i = x; i >= n; i--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define e emplace
#define mp make_pair
#define debug(this) cout << "> " << #this << " : " << this << "\n"
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
const ll MOD = 1e9 + 7;
ld PI = 3.1415926535897932384626;
ld EPS = 1e-9;
#define endl '\n'
int main() {
boost;
ll l, r;
cin >> l >> r;
if (l <= 2019 and r >= 2019) {
cout << "0";
return 0;
}
ll ans = (l * r) % 2019;
l = max(l, r - 4 * 2019);
rep(i, l, r) rep(j, (i + 1), (r + 1)) ans = min(ans, (i * j) % 2019);
cout << ans;
}
| replace | 60 | 63 | 60 | 61 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long min = 2020;
for (long long i = l; i <= r; i++) {
long long tmp = i % 2019;
if (tmp < min)
min = tmp;
}
if (min == 0) {
cout << 0 << endl;
return 0;
}
long long start = l % 2019;
long long end = r % 2019;
if (start > end) {
long long tmp = start;
start = end;
end = tmp;
}
long long answer = 2020;
for (long long i = start; i < end; i++) {
for (long long j = start + 1; j <= end; j++) {
long long tmp = i * j;
tmp %= 2019;
if (answer > tmp)
answer = tmp;
if (answer == 0)
break;
}
}
cout << answer << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long min = 2020;
for (long long i = l; i <= r; i++) {
long long tmp = i % 2019;
if (tmp < min)
min = tmp;
if (min == 0)
break;
}
if (min == 0) {
cout << 0 << endl;
return 0;
}
long long start = l % 2019;
long long end = r % 2019;
if (start > end) {
long long tmp = start;
start = end;
end = tmp;
}
long long answer = 2020;
for (long long i = start; i < end; i++) {
for (long long j = start + 1; j <= end; j++) {
long long tmp = i * j;
tmp %= 2019;
if (answer > tmp)
answer = tmp;
if (answer == 0)
break;
}
}
cout << answer << endl;
} | insert | 12 | 12 | 12 | 14 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long mind = 1e9;
for (long long i = l; i < r; i++) {
for (long long j = i + 1; j < r + 1; j++) {
mind = min(((i * j) % 2019), mind);
if (mind == 0)
break;
}
}
cout << mind << endl;
// cout << (((l <= 2019 && r > 2019)|| l == 0 ) ? 0 : (l*(l+1))%2019 )<<
// endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long mind = 2018;
if (r - l > 2019) {
cout << 0 << endl;
return 0;
}
for (long long i = l % 2019; i < r % 2019; i++) {
for (long long j = i + 1; j <= r % 2019; j++) {
mind = min(((i * j) % 2019), mind);
if (mind == 0)
break;
}
}
cout << mind << endl;
// cout << (((l <= 2019 && r > 2019)|| l == 0 ) ? 0 : (l*(l+1))%2019 )<<
// endl;
} | replace | 8 | 11 | 8 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
const int mod = 1e9 + 7;
signed main() {
int l, r, ans = 1e18;
cin >> l >> r;
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
chmin(ans, (i * j) % 2019);
}
}
print(ans);
}
| #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
const int mod = 1e9 + 7;
signed main() {
int l, r, ans = 1e18;
cin >> l >> r;
for (int i = l; i <= r && i <= l + 4038; i++) {
for (int j = i + 1; j <= r && j <= l + 4038; j++) {
chmin(ans, (i * j) % 2019);
}
}
print(ans);
}
| replace | 85 | 87 | 85 | 87 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility> // pair make_pair
#include <vector>
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define ll long long
#define int ll
#define INF LLONG_MAX / 10
using namespace std;
using Pi = pair<int, int>;
using Graph = vector<vector<int>>;
using WeightGraph = vector<vector<Pi>>;
signed main() {
int L, R;
cin >> L >> R;
if (R - L >= 2018) {
cout << 0 << endl;
return 0;
}
int x = L % 2019;
int y = R % 2019;
int ans = INF;
for (int i = x; i < y; i = (i + 1) % 2019) {
for (int j = (i + 1) % 2019; j <= y; j = (j + 1) % 2019) {
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <assert.h>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility> // pair make_pair
#include <vector>
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define ll long long
#define int ll
#define INF LLONG_MAX / 10
using namespace std;
using Pi = pair<int, int>;
using Graph = vector<vector<int>>;
using WeightGraph = vector<vector<Pi>>;
signed main() {
int L, R;
cin >> L >> R;
if (R - L >= 2018) {
cout << 0 << endl;
return 0;
}
int x = L % 2019;
int y = R % 2019;
int ans = INF;
for (int i = x; i < y; i = (i + 1) % 2019) {
for (int j = (i + 1) % 2019; j <= y; j = (j + 1) % 2019) {
if (i == 0 || j == 0) {
cout << 0 << endl;
return 0;
}
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
| insert | 43 | 43 | 43 | 47 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#define lli long long int
#define ulli unsigned long long int
#define ld long double
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define loop(i, a, b) for (lli i = a; i < b; i++)
#define initialize(array, size, value) \
for (lli i = 0; i < size; i++) \
array[i] = value
#define couta(array, size) \
for (lli i = 0; i < size; i++) \
cout << array[i] << " "
#define vl vector<lli>
#define vp vector<pair<lli, lli>>
#define sl set<lli>
#define msp multiset<pair<long long, long long>> S;
#define pll pair<lli, lli>
#define mll \
map<lli, \
lli> // for( map<lli, lli>::iterator
// i=temp.begin();i!=temp.end();i++)cout<<i->fi<<" "<<i->se<<endl;
#define mvl map<lli, vl>
#define umll unordered_map<lli, lli>
#define vt vector<pair<lli, pll>>
#define vf vector<pair<pll, pll>>
#define qu queue<lli>
#define pq priority_queue<lli>
#define dq deque<lli>
#define ptr vector<lli>::iterator
#define bs(array, x) \
binary_search(array.begin(), array.end(), \
x) // also valid for set and multiset
#define lb(array, x) lower_bound(array.begin(), array.end(), x)
#define ub(array, x) upper_bound(array.begin(), array.end(), x)
#define nobw(array, i, j) \
upper_bound(array.begin(), array.end(), j) - \
lower_bound(array.begin(), array.end(), \
i) // number of numbers between i & j
#define vc clear()
#define endl '\n'
#define sp system("pause");
#define INF 9223372036854775807
#define MINF -9223372036854775808
typedef tree<lli, null_type, less<lli>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
// string binary = bitset<32>(n).to_string();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
lli l, r;
cin >> l >> r;
lli d = l - r;
if (d >= 2019)
cout << 0;
else {
lli ans = 2018;
for (lli i = l; i <= r; i++)
for (lli j = i + 1; j <= r; j++)
ans = min(ans, (i * j) % 2019);
cout << ans;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#define lli long long int
#define ulli unsigned long long int
#define ld long double
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define loop(i, a, b) for (lli i = a; i < b; i++)
#define initialize(array, size, value) \
for (lli i = 0; i < size; i++) \
array[i] = value
#define couta(array, size) \
for (lli i = 0; i < size; i++) \
cout << array[i] << " "
#define vl vector<lli>
#define vp vector<pair<lli, lli>>
#define sl set<lli>
#define msp multiset<pair<long long, long long>> S;
#define pll pair<lli, lli>
#define mll \
map<lli, \
lli> // for( map<lli, lli>::iterator
// i=temp.begin();i!=temp.end();i++)cout<<i->fi<<" "<<i->se<<endl;
#define mvl map<lli, vl>
#define umll unordered_map<lli, lli>
#define vt vector<pair<lli, pll>>
#define vf vector<pair<pll, pll>>
#define qu queue<lli>
#define pq priority_queue<lli>
#define dq deque<lli>
#define ptr vector<lli>::iterator
#define bs(array, x) \
binary_search(array.begin(), array.end(), \
x) // also valid for set and multiset
#define lb(array, x) lower_bound(array.begin(), array.end(), x)
#define ub(array, x) upper_bound(array.begin(), array.end(), x)
#define nobw(array, i, j) \
upper_bound(array.begin(), array.end(), j) - \
lower_bound(array.begin(), array.end(), \
i) // number of numbers between i & j
#define vc clear()
#define endl '\n'
#define sp system("pause");
#define INF 9223372036854775807
#define MINF -9223372036854775808
typedef tree<lli, null_type, less<lli>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
// string binary = bitset<32>(n).to_string();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
lli l, r;
cin >> l >> r;
lli d = r - l;
if (d >= 2019)
cout << 0;
else {
lli ans = 2018;
for (lli i = l; i <= r; i++)
for (lli j = i + 1; j <= r; j++)
ans = min(ans, (i * j) % 2019);
cout << ans;
}
return 0;
} | replace | 58 | 59 | 58 | 59 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
#define INF (1LL << 60)
#define MOD 1000000007
#define REP(i, m, n) for (ll(i) = (m), i_len = (n); (i) < (i_len); ++(i))
#define FORR(i, v) for (auto(i) : v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define pb push_back
#define mp make_pair
int main() {
ll L, R;
cin >> L >> R;
ll m = 2018;
REP(i, L, R) {
REP(j, i + 1, R + 1) {
m = MIN((i * j) % 2019, m);
if (m == 0)
break;
}
}
PR(m);
return 0;
}
/*
*/ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
#define INF (1LL << 60)
#define MOD 1000000007
#define REP(i, m, n) for (ll(i) = (m), i_len = (n); (i) < (i_len); ++(i))
#define FORR(i, v) for (auto(i) : v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define pb push_back
#define mp make_pair
int main() {
ll L, R;
cin >> L >> R;
ll m = 2018;
if ((R - L + 1) >= 2019)
m = 0;
else {
REP(i, L, R) {
REP(j, i + 1, R + 1) { m = MIN((i * j) % 2019, m); }
}
}
PR(m);
return 0;
}
/*
*/ | replace | 25 | 30 | 25 | 30 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
//-----------------------------------------------
int mod = 2019;
//------------------------------------------------
int main() {
int l, r, ans, a;
cin >> l >> r;
ans = 2018;
rep(i, l, r) {
rep(k, i + 1, r + 1) {
a = (i % mod) * (k % mod);
ans = min(ans, a % mod);
if (ans == 0)
break;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
//-----------------------------------------------
int mod = 2019;
//------------------------------------------------
int main() {
int l, r, ans, a;
cin >> l >> r;
ans = 2018;
rep(i, l, r) {
if (r / 673 - l / 673 > 0) {
ans = 0;
break;
}
rep(k, i + 1, r + 1) {
a = (i % mod) * (k % mod);
ans = min(ans, a % mod);
if (ans == 0)
break;
}
}
cout << ans << endl;
}
| insert | 14 | 14 | 14 | 18 | TLE | |
p02983 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// typedef
typedef long long lint;
typedef unsigned long long ull;
typedef complex<long double> Complex;
typedef pair<int, int> P;
typedef tuple<int, int, int> TP;
typedef vector<int> vec;
typedef vector<vec> mat;
// constant
const int MOD = (int)1e9 + 7;
const int INF = (int)1e18;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int ddx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[] = {1, 1, 0, -1, -1, -1, 0, 1};
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
//
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
lint L, R;
cin >> L >> R;
if (2019 * 2019 <= R - L) {
cout << 0 << endl;
return 0;
}
lint ans = 2019;
for (lint i = L; i < R; i++) {
for (lint j = i + 1; j <= R; j++) {
ans = min(ans, i * j % 2019);
}
}
cout << ans << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// typedef
typedef long long lint;
typedef unsigned long long ull;
typedef complex<long double> Complex;
typedef pair<int, int> P;
typedef tuple<int, int, int> TP;
typedef vector<int> vec;
typedef vector<vec> mat;
// constant
const int MOD = (int)1e9 + 7;
const int INF = (int)1e18;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int ddx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[] = {1, 1, 0, -1, -1, -1, 0, 1};
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
//
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
lint L, R;
cin >> L >> R;
if (2019 < R - L) {
cout << 0 << endl;
return 0;
}
lint ans = 2019;
for (lint i = L; i < R; i++) {
for (lint j = i + 1; j <= R; j++) {
ans = min(ans, i * j % 2019);
}
}
cout << ans << endl;
return 0;
} | replace | 72 | 73 | 72 | 73 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define FOR(i, l, r) for (int i = (l), i##R = (r); i <= i##R; i++)
#define DOR(i, r, l) for (int i = (r), i##L = (l); i >= i##L; i--)
#define loop(i, n) for (int i = 0, i##R = (n); i < i##R; i++)
#define sf scanf
#define pf printf
#define mms(a, x) memset(a, x, sizeof a)
using namespace std;
typedef long long ll;
template <typename A, typename B> inline void chkmax(A &x, const B y) {
if (x < y)
x = y;
}
template <typename A, typename B> inline void chkmin(A &x, const B y) {
if (x > y)
x = y;
}
const int N = 25;
int main() {
int L, R;
sf("%d%d", &L, &R);
if (L - R > 2019)
puts("0");
else {
int ans = 1e9;
FOR(i, L, R) FOR(j, i + 1, R) chkmin(ans, (int)(1ll * i * j % 2019));
pf("%d\n", ans);
}
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, l, r) for (int i = (l), i##R = (r); i <= i##R; i++)
#define DOR(i, r, l) for (int i = (r), i##L = (l); i >= i##L; i--)
#define loop(i, n) for (int i = 0, i##R = (n); i < i##R; i++)
#define sf scanf
#define pf printf
#define mms(a, x) memset(a, x, sizeof a)
using namespace std;
typedef long long ll;
template <typename A, typename B> inline void chkmax(A &x, const B y) {
if (x < y)
x = y;
}
template <typename A, typename B> inline void chkmin(A &x, const B y) {
if (x > y)
x = y;
}
const int N = 25;
int main() {
int L, R;
sf("%d%d", &L, &R);
if (R - L > 2019)
puts("0");
else {
int ans = 1e9;
FOR(i, L, R) FOR(j, i + 1, R) chkmin(ans, (int)(1ll * i * j % 2019));
pf("%d\n", ans);
}
return 0;
} | replace | 21 | 22 | 21 | 22 | TLE | |
p02983 | C++ | Time Limit Exceeded | //* AuThOr GaRyMr *//
#include <bits/stdc++.h>
#define rb(a, b, c) for (LL a = b; a <= c; ++a)
#define rl(a, b, c) for (LL a = b; a >= c; --a)
#define niv vector<int>
#define LL long long
#define IT iterator
#define PB(a) push_back(a)
#define II(a, b) make_pair(a, b)
#define FIR first
#define SEC second
using namespace std;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> mp;
typedef pair<mp, mp> superpair;
int main() {
int l, r;
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0;
}
int tot = r - l;
LL sum = INF;
rb(i, l, r) {
rb(j, i + 1, r) { sum = min(sum, (i * j) % 2019); }
}
cout << sum;
return 0;
} | //* AuThOr GaRyMr *//
#include <bits/stdc++.h>
#define rb(a, b, c) for (LL a = b; a <= c; ++a)
#define rl(a, b, c) for (LL a = b; a >= c; --a)
#define niv vector<int>
#define LL long long
#define IT iterator
#define PB(a) push_back(a)
#define II(a, b) make_pair(a, b)
#define FIR first
#define SEC second
using namespace std;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> mp;
typedef pair<mp, mp> superpair;
int main() {
int l, r;
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0;
return 0;
}
int tot = r - l;
LL sum = INF;
rb(i, l, r) {
rb(j, i + 1, r) { sum = min(sum, (i * j) % 2019); }
}
cout << sum;
return 0;
} | insert | 20 | 20 | 20 | 21 | TLE | |
p02983 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i, j, k) for (int(i) = (j); (i) < (int)(k); ++(i))
#define rep(i, j) FOR(i, 0, j)
#define each(x, y) for (auto &(x) : (y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(), (x).end()
#define debug(x) cout << #x << ": " << (x) << endl
#define smax(x, y) (x) = max((x), (y))
#define smin(x, y) (x) = min((x), (y))
#define MEM(x, y) memset((x), (y), sizeof(x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
void solve() {
int mi = INT_MAX;
int L, R;
cin >> L >> R;
for (int i = L; i < min(R, i + 2019); ++i) {
int x = i % 2019;
for (int j = i + 1; j < min(R + 1, i + 2020); ++j) {
int y = j % 2019;
int z = x * y % 2019;
smin(mi, z);
}
}
cout << mi << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i, j, k) for (int(i) = (j); (i) < (int)(k); ++(i))
#define rep(i, j) FOR(i, 0, j)
#define each(x, y) for (auto &(x) : (y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(), (x).end()
#define debug(x) cout << #x << ": " << (x) << endl
#define smax(x, y) (x) = max((x), (y))
#define smin(x, y) (x) = min((x), (y))
#define MEM(x, y) memset((x), (y), sizeof(x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
void solve() {
int mi = INT_MAX;
int L, R;
cin >> L >> R;
for (int i = L; i < min(R, L + 2019); ++i) {
int x = i % 2019;
for (int j = i + 1; j < min(R + 1, i + 2020); ++j) {
int y = j % 2019;
int z = x * y % 2019;
smin(mi, z);
}
}
cout << mi << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| replace | 25 | 26 | 25 | 26 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <deque> // deque
#include <iomanip> //setprecsion
#include <iostream> // cout, endl, cin
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <utility> // pair, make_pair
#include <vector> // vector
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath> //sin, cos, tan
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = (n - 1); i >= 0; --i)
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define mt(p, q, r) make_tuple(p, q, r)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<ll> vll;
typedef vector<ld> vd;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<str> vs;
typedef vector<vector<ll>> vvll;
typedef vector<vector<ld>> vvd;
typedef vector<vector<bool>> vvb;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
typedef vector<pair<ll, ll>> vpll;
typedef vector<tuple<ll, ll, ll>> vtlll;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
template <typename T> void fin(T a) {
cout << a << endl;
exit(0);
}
ll GetDigit(ll num) { return log10(num) + 1; }
// n ~ mの和
ll sigma(ll n, ll m) { return ((n + m) * (m - n + 1) * 0.5); }
void Main() {
ll l, r;
cin >> l >> r;
ll ans = MAX;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= min(r, i + 5000); j++) {
ll h = i * j;
h %= 2019;
ans = min(h, ans);
}
}
fin(ans);
}
// 前処理
int main() {
// ios::sync_with_stdio(false);
// cin.tie(0);
cout << fixed << setprecision(20); // 高精度少数表示
// cout << setfill('0') << internal << setw(4); 0埋め４桁
Main();
return 0;
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <deque> // deque
#include <iomanip> //setprecsion
#include <iostream> // cout, endl, cin
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <utility> // pair, make_pair
#include <vector> // vector
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath> //sin, cos, tan
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = (n - 1); i >= 0; --i)
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define mt(p, q, r) make_tuple(p, q, r)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<ll> vll;
typedef vector<ld> vd;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<str> vs;
typedef vector<vector<ll>> vvll;
typedef vector<vector<ld>> vvd;
typedef vector<vector<bool>> vvb;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
typedef vector<pair<ll, ll>> vpll;
typedef vector<tuple<ll, ll, ll>> vtlll;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
template <typename T> void fin(T a) {
cout << a << endl;
exit(0);
}
ll GetDigit(ll num) { return log10(num) + 1; }
// n ~ mの和
ll sigma(ll n, ll m) { return ((n + m) * (m - n + 1) * 0.5); }
void Main() {
ll l, r;
cin >> l >> r;
ll ans = MAX;
for (ll i = l; i <= min(r, l + 5000); i++) {
for (ll j = i + 1; j <= min(r, l + 5000); j++) {
ll h = i * j;
h %= 2019;
ans = min(h, ans);
}
}
fin(ans);
}
// 前処理
int main() {
// ios::sync_with_stdio(false);
// cin.tie(0);
cout << fixed << setprecision(20); // 高精度少数表示
// cout << setfill('0') << internal << setw(4); 0埋め４桁
Main();
return 0;
}
| replace | 66 | 68 | 66 | 68 | TLE | |
p02983 | C++ | Time Limit Exceeded | /* long long or int */
/* xx 396*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll l, r;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> l >> r;
if (l - r + 1 >= 2019) {
cout << 0 << endl;
return 0;
}
ll ans = 2019;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ll sum = i * j;
ans = min(sum % 2019, ans);
}
}
cout << ans << endl;
return 0;
} | /* long long or int */
/* xx 396*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll l, r;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0 << endl;
return 0;
}
ll ans = 2019;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ll sum = i * j;
ans = min(sum % 2019, ans);
}
}
cout << ans << endl;
return 0;
} | replace | 15 | 16 | 15 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define PI acos(-1)
typedef long long ll;
ll gcd(ll x, ll y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
using namespace std;
int main() {
ll l, r;
cin >> l >> r;
ll ml = 10000, mr = 0;
for (ll i = l; i <= r; i++) {
ml = min(ml, i % 2019);
mr = max(mr, i % 2019);
}
ll ans = 10000;
for (ll i = ml; i < mr + 1; i++) {
for (ll j = i + 1; j < mr + 1; j++) {
ans = min(ans, i * j % 2019);
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define PI acos(-1)
typedef long long ll;
ll gcd(ll x, ll y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
using namespace std;
int main() {
ll l, r;
cin >> l >> r;
ll ml = 10000, mr = 0;
for (ll i = l; i <= r; i++) {
ml = min(ml, i % 2019);
mr = max(mr, i % 2019);
if (i - l > 5000)
break;
}
ll ans = 10000;
for (ll i = ml; i < mr + 1; i++) {
for (ll j = i + 1; j < mr + 1; j++) {
ans = min(ans, i * j % 2019);
}
}
cout << ans;
return 0;
}
| insert | 22 | 22 | 22 | 24 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
using namespace std;
typedef long long ll;
const int MOD = 2019;
int L, R;
int main() {
cin >> L >> R;
int k = L - R + 1;
if (k >= 2019) {
cout << 0 << endl;
return 0;
}
int ans = MOD - 1;
for (int i = L; i <= R - 1; i++) {
for (int j = i + 1; j <= R; j++) {
if ((i % MOD) * (j % MOD) % MOD < ans)
ans = (i % MOD) * (j % MOD) % MOD;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
using namespace std;
typedef long long ll;
const int MOD = 2019;
int L, R;
int main() {
cin >> L >> R;
int k = R - L + 1;
if (k >= 2019) {
cout << 0 << endl;
return 0;
}
int ans = MOD - 1;
for (int i = L; i <= R - 1; i++) {
for (int j = i + 1; j <= R; j++) {
if ((i % MOD) * (j % MOD) % MOD < ans)
ans = (i % MOD) * (j % MOD) % MOD;
}
}
cout << ans << endl;
} | replace | 18 | 19 | 18 | 19 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long L, R;
cin >> L >> R;
long long Min = 2018;
if (L - R < 2019) {
for (long long i = L; i < R; i++) {
for (long long j = i + 1; j <= R; j++) {
Min = min(Min, (i * j) % 2019);
}
}
printf("%lld", Min);
} else {
cout << 0 << endl;
}
}
| #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long long L, R;
cin >> L >> R;
long long Min = 2018;
if (R - L < 2019) {
for (long long i = L; i < R; i++) {
for (long long j = i + 1; j <= R; j++) {
Min = min(Min, (i * j) % 2019);
}
}
printf("%lld", Min);
} else {
cout << 0 << endl;
}
}
| replace | 7 | 8 | 7 | 8 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, min = 2018;
cin >> l >> r;
for (int i = l; i <= r - 1; i++) {
for (int j = r; j >= l + 1; j--) {
int left = i, right = j;
left %= 2019;
right %= 2019;
if (left * right % 2019 < min)
min = left * right % 2019;
}
if (min == 0)
break;
}
cout << min << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, min = 2018;
cin >> l >> r;
for (int i = l; i <= r - 1; i++) {
for (int j = r; j >= l + 1; j--) {
if (min == 0)
break;
int left = i, right = j;
left %= 2019;
right %= 2019;
if (left * right % 2019 < min)
min = left * right % 2019;
}
if (min == 0)
break;
}
cout << min << endl;
}
| insert | 9 | 9 | 9 | 11 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define rep(i, b) Rep(i, 0, b)
#define rrep(i, a) for (int i = a; i >= 0; i--)
#define allof(a) (a).begin(), (a).end()
typedef long long ll;
const int inf = 1e9 + 7;
const ll infll = 1ll << 60ll;
const ll mod = 1e9 + 7;
// 0~3までは右左下上 4~7までは斜め
constexpr int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, -1, 1};
/*
// 最大公約数
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
// 最小公倍数
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}*/
int main() {
ll l, r;
cin >> l >> r;
// 2019で割ったあまりの最小値
// 全探索したいなぁ
ll ans = inf;
for (ll i = l; i <= r && i <= l + (ll)2019; i++) {
for (ll j = i + 1; j <= r && i <= l + (ll)2020; j++) {
ans = min(ans, (i * j) % (ll)2019);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define rep(i, b) Rep(i, 0, b)
#define rrep(i, a) for (int i = a; i >= 0; i--)
#define allof(a) (a).begin(), (a).end()
typedef long long ll;
const int inf = 1e9 + 7;
const ll infll = 1ll << 60ll;
const ll mod = 1e9 + 7;
// 0~3までは右左下上 4~7までは斜め
constexpr int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, -1, 1};
/*
// 最大公約数
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
// 最小公倍数
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}*/
int main() {
ll l, r;
cin >> l >> r;
// 2019で割ったあまりの最小値
// 全探索したいなぁ
ll ans = inf;
for (ll i = l; i <= r && i <= l + (ll)2019; i++) {
for (ll j = i + 1; j <= r && j <= l + (ll)2020; j++) {
ans = min(ans, (i * j) % (ll)2019);
}
}
cout << ans << endl;
return 0;
}
| replace | 58 | 59 | 58 | 59 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define MOD 1000000007
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REP1(i, N) for (int i = 1; i <= N; ++i)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ALL(a) a.begin(), a.end()
int main() {
ll l, r;
cin >> l >> r;
ll ans = 3000;
for (ll i = l; i < r; ++i) {
for (ll j = i + 1; j <= r; ++j) {
ll res = (i * j) % 2019;
ans = min(ans, res);
if (ans == 0)
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define MOD 1000000007
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REP1(i, N) for (int i = 1; i <= N; ++i)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ALL(a) a.begin(), a.end()
int main() {
ll l, r;
cin >> l >> r;
ll ans = 3000;
for (ll i = l; i < r; ++i) {
for (ll j = i + 1; j <= r; ++j) {
ll res = (i * j) % 2019;
ans = min(ans, res);
if (ans == 0) {
cout << ans << endl;
return 0;
}
}
}
cout << ans << endl;
return 0;
} | replace | 23 | 25 | 23 | 27 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define debug(...) \
cerr << __LINE__ << " [" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto v : vec)
os << v << ' ';
os << '\n';
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << '(' << pa.first << ',' << pa.second << ')';
return os;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = (1 << 30) - 1;
const ll LINF = (1LL << 60) - 1;
void solve() {
ll l, r;
cin >> l >> r;
if (r - l >= 2018) {
cout << 0 << endl;
return;
}
l %= 2019;
r %= 2019;
if (r <= l)
r += 2019;
ll ans = LINF;
for (int i = l; i < r; i++) {
for (int j = l + 1; j <= r; j++) {
debug(i, j);
chmin(ans, 1LL * i * j % 2019);
}
}
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define debug(...) \
cerr << __LINE__ << " [" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto v : vec)
os << v << ' ';
os << '\n';
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << '(' << pa.first << ',' << pa.second << ')';
return os;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = (1 << 30) - 1;
const ll LINF = (1LL << 60) - 1;
void solve() {
ll l, r;
cin >> l >> r;
if (r - l >= 2018) {
cout << 0 << endl;
return;
}
l %= 2019;
r %= 2019;
if (r <= l)
r += 2019;
ll ans = LINF;
for (int i = l; i < r; i++) {
for (int j = l + 1; j <= r; j++) {
chmin(ans, 1LL * i * j % 2019);
}
}
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| delete | 59 | 60 | 59 | 59 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int L, R;
cin >> L >> R;
int min = 99999;
for (int i = L; i <= R - 1; i++) {
for (int j = i + 1; j <= R && j < i + 2050; j++) {
int a = i % 2019;
int b = j % 2019;
if ((a * b) % 2019 < min)
min = (a * b) % 2019;
}
}
cout << min << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int L, R;
cin >> L >> R;
int min = 99999;
for (int i = L; i <= R - 1 && i < L + 2050; i++) {
for (int j = i + 1; j <= R && j < i + 2050; j++) {
int a = i % 2019;
int b = j % 2019;
if ((a * b) % 2019 < min)
min = (a * b) % 2019;
}
}
cout << min << endl;
return 0;
} | replace | 7 | 8 | 7 | 8 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i < n + 1; ++i)
#include <string>
using namespace std;
int main() {
long long L, R;
cin >> L >> R;
R = min(R, R + 4038);
int ans = 2018;
for (long long i = L; i < R; ++i) {
for (long long j = i + 1; j <= R; ++j) {
int x = i * j % 2019;
ans = min(ans, x);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i < n + 1; ++i)
#include <string>
using namespace std;
int main() {
long long L, R;
cin >> L >> R;
R = min(R, L + 4038);
int ans = 2018;
for (long long i = L; i < R; ++i) {
for (long long j = i + 1; j <= R; ++j) {
int x = i * j % 2019;
ans = min(ans, x);
}
}
cout << ans << endl;
return 0;
} | replace | 8 | 9 | 8 | 9 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int INF = 1 << 30;
bool m[2020] = {};
int main() {
int l, r;
cin >> l >> r;
for (int i = l; i <= r; i++) {
m[i % 2019] = true;
}
int ans = INF;
for (int i = 0; i < 2019; i++) {
if (!m[i])
continue;
for (int j = 0; j < i; j++) {
if (!m[j])
continue;
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int INF = 1 << 30;
bool m[2020] = {};
int main() {
int l, r;
cin >> l >> r;
if (2019 * (l / 2019) + 2019 <= r) {
r %= 2019;
r += 2019;
l %= 2019;
} else {
r %= 2019;
l %= 2019;
}
for (int i = l; i <= r; i++) {
m[i % 2019] = true;
}
int ans = INF;
for (int i = 0; i < 2019; i++) {
if (!m[i])
continue;
for (int j = 0; j < i; j++) {
if (!m[j])
continue;
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
} | insert | 8 | 8 | 8 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | /**
* author: yuya1234
* created: 10.07.2020 16:33:27
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define FORV(i, v) for (auto i = v.begin(); i != v.end(); i++)
#define SORT(s) sort((s).begin(), (s).end())
#define SORTD(s) sort((s).rbegin(), (s).rend())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define SZ(x) ((int)(x).size())
#define MEMSET(v, h) memset((v), h, sizeof(v))
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
ll ans = 2019;
FOR(i, l, r - 1) {
FOR(j, i + 1, r) { ans = min(ans, (i * j) % 2019); }
}
cout << ans << endl;
return 0;
} | /**
* author: yuya1234
* created: 10.07.2020 16:33:27
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define FORV(i, v) for (auto i = v.begin(); i != v.end(); i++)
#define SORT(s) sort((s).begin(), (s).end())
#define SORTD(s) sort((s).rbegin(), (s).rend())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define SZ(x) ((int)(x).size())
#define MEMSET(v, h) memset((v), h, sizeof(v))
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
ll ans = 2019;
FOR(i, l, r - 1) {
FOR(j, i + 1, r) {
ans = min(ans, (i * j) % 2019);
if (ans == 0) {
i = r;
j = r;
}
}
}
cout << ans << endl;
return 0;
} | replace | 32 | 33 | 32 | 39 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdint>
#include <iostream>
#include <math.h>
#include <string>
#include <map>
using namespace std;
typedef long long ll;
ll ans, mx, sum, mn = 1e18, flag;
int main() {
ll l, r;
cin >> l >> r;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ll flag = (i * j) % 2019;
mn = min(mn, flag);
}
}
cout << mn << endl;
}
| #include <algorithm>
#include <cstdint>
#include <iostream>
#include <math.h>
#include <string>
#include <map>
using namespace std;
typedef long long ll;
ll ans, mx, sum, mn = 1e18, flag;
int main() {
ll l, r;
cin >> l >> r;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ll flag = (i * j) % 2019;
mn = min(mn, flag);
if (mn == 0) {
cout << mn << endl;
return 0;
}
}
}
cout << mn << endl;
}
| insert | 20 | 20 | 20 | 24 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pld;
#define all(x) (x).begin(), (x).end()
#define Sort(x) sort(all(x))
#define sep ' '
#define endl '\n'
#define tab '\t'
#define X first
#define Y second
#define fast_io \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define file_io \
freopen("in.txt", "r", stdin); \
freopen("out.txt", "w", stdout);
#define set_random \
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const ll MOD = 1e9 + 7, MAXN = 1e6 + 10, INF = 1e18;
ll l, r, ans = INF;
int main() {
fast_io;
cin >> l >> r;
if (l <= 2019 && r >= 2019)
return cout << 0 << endl, 0;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, i * j % 2019);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pld;
#define all(x) (x).begin(), (x).end()
#define Sort(x) sort(all(x))
#define sep ' '
#define endl '\n'
#define tab '\t'
#define X first
#define Y second
#define fast_io \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define file_io \
freopen("in.txt", "r", stdin); \
freopen("out.txt", "w", stdout);
#define set_random \
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const ll MOD = 1e9 + 7, MAXN = 1e6 + 10, INF = 1e18;
ll l, r, ans = INF;
int main() {
fast_io;
cin >> l >> r;
if ((l <= 2019 && r >= 2019) || (r - l + 1 >= 2019))
return cout << 0 << endl, 0;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, i * j % 2019);
}
}
cout << ans << endl;
return 0;
}
| replace | 30 | 31 | 30 | 31 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int l, r;
cin >> l >> r;
long long int ans = 2019;
for (long long int i = l; i < r; ++i) {
for (long long int j = i + 1; j <= r; ++j) {
ans = min((i * j) % 2019, ans);
if (ans == 0)
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int l, r;
cin >> l >> r;
long long int ans = 2019;
for (long long int i = l; i < r; ++i) {
for (long long int j = i + 1; j <= r && j < l + 2019; ++j) {
ans = min((i * j) % 2019, ans);
if (ans == 0)
break;
}
}
cout << ans << endl;
} | replace | 10 | 11 | 10 | 11 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int main() {
long long int L, R, sum, i, j, tmp, tmp_i, tmp_j, min;
scanf("%lld %lld", &L, &R);
min = (L % 2019) * (R % 2019) % 2019;
for (i = L; i < R; i++) {
for (j = i + 1; j <= R; j++) {
tmp_i = i % 2019;
tmp_j = j % 2019;
tmp = tmp_i * tmp_j % 2019;
if (min > tmp)
min = tmp;
}
}
printf("%lld\n", min);
return 0;
}
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int main() {
long long int L, R, sum, i, j, tmp, tmp_i, tmp_j, min;
scanf("%lld %lld", &L, &R);
min = (L % 2019) * (R % 2019) % 2019;
for (i = L; i < R; i++) {
for (j = i + 1; j <= R; j++) {
tmp_i = i % 2019;
tmp_j = j % 2019;
tmp = tmp_i * tmp_j % 2019;
if (min > tmp)
min = tmp;
if (min == 0) {
printf("0\n");
return 0;
}
}
}
printf("%lld\n", min);
return 0;
}
| insert | 21 | 21 | 21 | 25 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
typedef long long ll;
int main() {
ll l, r;
cin >> l >> r;
int ans = 2018;
r = min(r, l + 4038); // rのサイズが小さくなるため通常ループで計算可能になる
for (ll i = l; i < r + 1; i++) {
for (ll j = i + 1; i < r + 1; j++) {
int x = i * j % 2019;
ans = min(ans, x);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
typedef long long ll;
int main() {
ll l, r;
cin >> l >> r;
int ans = 2018;
r = min(r, l + 4038); // rのサイズが小さくなるため通常ループで計算可能になる
for (ll i = l; i < r + 1; i++) {
for (ll j = i + 1; j < r + 1; j++) {
int x = i * j % 2019;
ans = min(ans, x);
}
}
cout << ans << endl;
}
| replace | 14 | 15 | 14 | 15 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
// #pragma GCC optimize ("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void _main() {
ll L, R;
cin >> L >> R;
if (L - R + 1 >= 2019) {
cout << 0 << endl;
return;
}
ll ans = 100000000;
for (ll i = L; i <= R; ++i) {
for (ll j = i + 1; j <= R; ++j) {
chmin(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
// #pragma GCC optimize ("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void _main() {
ll L, R;
cin >> L >> R;
if (R - L + 1 >= 2019) {
cout << 0 << endl;
return;
}
ll ans = 100000000;
for (ll i = L; i <= R; ++i) {
for (ll j = i + 1; j <= R; ++j) {
chmin(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
| replace | 35 | 36 | 35 | 36 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout << d << endl;
#define coutd(d) cout << std::setprecision(10) << d << endl;
#define cinline(n) getline(cin, n);
#define replace_all(s, b, a) replace(s.begin(), s.end(), b, a);
#define rv(s) reverse(s.begin(), s.end());
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
template <class T, class C> void chmax(T &a, C b) { a > b ?: a = b; }
template <class T, class C> void chmin(T &a, C b) { a < b ?: a = b; }
int vtotal(vi &v) {
int total = 0;
rep(i, v.size()) total += v[i];
return total;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
int mod = 2019;
ll ans = 2018;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
int tmp = i * j % mod;
if (ans > tmp)
ans = tmp;
if (ans == 0)
break;
}
}
cout(ans);
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout << d << endl;
#define coutd(d) cout << std::setprecision(10) << d << endl;
#define cinline(n) getline(cin, n);
#define replace_all(s, b, a) replace(s.begin(), s.end(), b, a);
#define rv(s) reverse(s.begin(), s.end());
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
template <class T, class C> void chmax(T &a, C b) { a > b ?: a = b; }
template <class T, class C> void chmin(T &a, C b) { a < b ?: a = b; }
int vtotal(vi &v) {
int total = 0;
rep(i, v.size()) total += v[i];
return total;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
int mod = 2019;
ll ans = 2018;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
int tmp = i * j % mod;
if (ans > tmp)
ans = tmp;
if (ans == 0) {
cout(0);
return 0;
}
}
}
cout(ans);
} | replace | 54 | 56 | 54 | 58 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long ans = 9223372036854775807;
long long mod = 2019;
for (int i = l; i < r + 1; i++) {
for (int j = l; j < i; j++) {
ans = min(((i % mod) * (j % mod)) % mod, ans);
}
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long ans = 9223372036854775807;
long long mod = 2019;
for (int i = l; i < r + 1; i++) {
for (int j = l; j < i; j++) {
ans = min(((i % mod) * (j % mod)) % mod, ans);
if (ans == 0) {
break;
}
}
if (ans == 0) {
break;
}
}
cout << ans << endl;
} | insert | 20 | 20 | 20 | 26 | TLE | |
p02983 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n, x) for (int i = n; i < x; i++)
#define rem(i, n, x) for (int i = n; i > x; i--)
#define SORT(x) sort(x.begin(), x.end())
#define REV(x) reverse(x.begin(), x.end())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
#define setp(x) setprecision(x)
using LL = long long;
using ULL = unsigned long long;
int main() {
LL l, r;
cin >> l >> r;
if (r - l >= 2019) {
cout << 0 << endl;
return 0;
}
vector<LL> ans;
LL mod = 2019;
rep(i, l, r + 1) { ans.pb(i); }
rep(i, 0, r - l) {
rep(j, i + 1, r) {
LL a = (ans[i] % 2019) * (ans[j] % 2019) % 2019;
mod = min(mod, a);
}
}
cout << mod << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n, x) for (int i = n; i < x; i++)
#define rem(i, n, x) for (int i = n; i > x; i--)
#define SORT(x) sort(x.begin(), x.end())
#define REV(x) reverse(x.begin(), x.end())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
#define setp(x) setprecision(x)
using LL = long long;
using ULL = unsigned long long;
int main() {
LL l, r;
cin >> l >> r;
if (r - l >= 2019) {
cout << 0 << endl;
return 0;
}
vector<LL> ans;
LL mod = 2019;
rep(i, l, r + 1) { ans.pb(i); }
int siz = ans.size();
rep(i, 0, siz - 1) {
rep(j, i + 1, siz) {
LL a = (ans[i] % 2019) * (ans[j] % 2019) % 2019;
mod = min(mod, a);
}
}
cout << mod << endl;
return 0;
} | replace | 39 | 41 | 39 | 42 | 0 | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll l, r;
cin >> l >> r;
ll ans = 2019;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll l, r;
cin >> l >> r;
ll ans = 2019;
if (r - l >= 2019) {
ans = 0;
} else {
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, (i * j) % 2019);
}
}
}
cout << ans << endl;
return 0;
}
| replace | 18 | 21 | 18 | 25 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
using V = vector<int>;
using P = pair<int, int>;
int main() {
ll l, r;
cin >> l >> r;
ll ans = INF;
int m = 2019;
if (r - l + 1 >= m)
ans = 0;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, ((i % m) * (j % m) % m));
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
using V = vector<int>;
using P = pair<int, int>;
int main() {
ll l, r;
cin >> l >> r;
ll ans = INF;
int m = 2019;
if (r - l + 1 >= m)
ans = 0;
else {
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, ((i % m) * (j % m) % m));
}
}
}
cout << ans << endl;
return 0;
}
| replace | 19 | 23 | 19 | 24 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define INF 1e9;
using namespace std;
typedef long long ll;
int main() {
ll L, R;
cin >> L >> R;
ll a = L % 2019;
ll b = R - L + 1;
bool c = false, d = false;
int ans = a * (a + 1);
FOR(i, a, a + b) {
FOR(j, i + 1, a + b) { ans = min(ans, (i * j) % 2019); }
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define INF 1e9;
using namespace std;
typedef long long ll;
int main() {
ll L, R;
cin >> L >> R;
ll a = L % 2019;
ll b = R - L + 1;
bool c = false, d = false;
int ans = a * (a + 1);
if (a + b > 2019) {
cout << 0;
return 0;
}
FOR(i, a, a + b) {
FOR(j, i + 1, a + b) { ans = min(ans, (i * j) % 2019); }
}
cout << ans;
return 0;
} | insert | 15 | 15 | 15 | 19 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
ll l, r, cnt1;
ll cnt2;
ll tmp = 2018;
bool judge;
int main() {
cin >> l >> r;
REP(i, l, r + 1) {
REP(j, i + 1, r + 1) {
if (tmp > (ll)(i) * (ll)(j) % 2019) {
tmp = (ll)(i) * (ll)(j) % 2019;
}
}
if (tmp == 0)
break;
}
cout << tmp << endl;
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
ll l, r, cnt1;
ll cnt2;
ll tmp = 2018;
bool judge;
int main() {
cin >> l >> r;
REP(i, l, r + 1) {
REP(j, i + 1, r + 1) {
if (tmp > (ll)(i) * (ll)(j) % 2019) {
tmp = (ll)(i) * (ll)(j) % 2019;
}
if (tmp == 0)
break;
}
if (tmp == 0)
break;
}
cout << tmp << endl;
return 0;
}
| insert | 40 | 40 | 40 | 42 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
int main() {
using namespace std;
int L, R, now_min;
now_min = 2019;
cin >> L >> R;
for (int i = L; i < R; i++) {
for (int j = i + 1; j <= R; j++) {
now_min = min(((i % 2019) * (j % 2019)) % 2019, now_min);
if (now_min == 0) {
break;
}
}
}
cout << now_min << endl;
}
| #include <iostream>
int main() {
using namespace std;
int L, R, now_min;
now_min = 2019;
cin >> L >> R;
if (R - L + 1 >= 2019) {
cout << 0 << endl;
return 0;
}
for (int i = L; i < R; i++) {
for (int j = i + 1; j <= R; j++) {
now_min = min(((i % 2019) * (j % 2019)) % 2019, now_min);
if (now_min == 0) {
break;
}
}
}
cout << now_min << endl;
}
| insert | 6 | 6 | 6 | 10 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define Abs(x) ((x) < 0 ? (x) * -1 : (x))
#define rep(x, y) for ((x) = 0; (x) < (y); (x)++)
#define repin(x, y) for ((x) = 0; (x) <= (y); (x)++)
#define nep(x, y) for ((x) = (y)-1; 0 <= (x); (x)--)
#define nepi(x, y, z) for ((x) = (y)-1; (z) <= (x); (x)--)
#define repi(x, y, z) for ((x) = (z); (x) < (y); (x)++)
#define repiin(x, y, z) for ((x) = (z); (x) <= (y); (x)++)
#define reps(x, y, z) for ((x) = 0; (x) < (y); (x) += (z))
#define repis(x, y, z, s) for ((x) = (z); (x) < (y); (x) += (s))
#define repiins(x, y, z, s) for ((x) = (z); (x) <= (y); (x) += (s))
#define repit(x) \
for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define repit2(x) \
for (__typeof((x).begin()) it2 = (x).begin(); it2 != (x).end(); it2++)
#define nepit(x) \
for (__typeof((x).rbegin()) it = (x).rbegin(); it != (x).rend(); it++)
#define All(x) (x).begin(), (x).end()
#define Mem0(x) memset(x, 0, sizeof(x))
#define Mem1(x) memset(x, -1, sizeof(x))
// can be applied to string type
#define Unique(v) v.resize(unique(All(v)) - v.begin())
#define peq(p0, p1) (p0.first == p1.first && p0.second == p1.second)
#define End '\n'
#define Out(x) cout << (x) << End
template <typename T> void OutN(T x) {
size_t i, len = x.size() - 1;
for (i = 0; i < len; i++)
cout << x[i] << " ";
cout << x[len] << '\n';
}
#define OutaN(x) \
do { \
size_t i, len = sizeof(x) / sizeof(__typeof(x[0])) - 1; \
for (i = 0; i < len; i++) \
cout << x[i] << " "; \
cout << x[len] << '\n'; \
} while (0);
template <typename T> void Outit(T x) {
auto end = x.end();
end--;
for (auto it = x.begin(); it != end; it++)
cout << *it << " ";
cout << *end << '\n';
}
template <typename T> void Debug(const T &val) { cerr << val << End; }
template <typename T, typename... Args> void Debug(const T &val, Args... args) {
cerr << val << ' ';
Debug(std::forward<Args>(args)...);
}
template <typename T> inline bool Max(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T> inline bool Min(T &x, const T &y) {
return x > y ? x = y, 1 : 0;
}
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
// can be applied to string type
#define Sort(v) sort(All(v))
#define SortR(v) sort(All(v), std::greater<__typeof(v[0])>())
// array sorters
#define Sart(a) sort(a, a + sizeof(a) / sizeof(__typeof(a[0])));
#define SartR(a) \
sort(a, a + sizeof(a) / sizeof(__typeof(a[0])), \
std::greater<__typeof(a[0])>())
#define pb push_back
#define mp make_pair
#define a first
#define b second
#define lb std::lower_bound
#define ub std::upper_bound
#define lbi(v, x) lb(All(v), (x)) - v.begin()
#define ubi(v, x) ub(All(v), (x)) - v.begin()
static const ll MOD = 1e9 + 7;
static const double PI = 3.141592653589793;
#define LOCAL 0
int main() {
#if LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("debug.txt", "w", stderr);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
// std::cout.precision(18);
ll l, r;
cin >> l >> r;
if (l == 0) {
Out(0);
} else if (l + 1 == r) {
Out((l * r) % 2019);
} else {
map<int, ll> table;
V<pair<int, ll>> v;
int ans = INT_MAX;
ll i, j, len;
repiin(i, r, l) table[i % 2019]++;
repit(table) v.pb(*it);
len = v.size();
rep(i, len) {
if (1 < v[i].b)
Min(ans, (v[i].a * v[i].a) % 2019);
repi(j, len, i + 1) Min(ans, (v[i].a * v[j].a) % 2019);
}
Out(ans);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define Abs(x) ((x) < 0 ? (x) * -1 : (x))
#define rep(x, y) for ((x) = 0; (x) < (y); (x)++)
#define repin(x, y) for ((x) = 0; (x) <= (y); (x)++)
#define nep(x, y) for ((x) = (y)-1; 0 <= (x); (x)--)
#define nepi(x, y, z) for ((x) = (y)-1; (z) <= (x); (x)--)
#define repi(x, y, z) for ((x) = (z); (x) < (y); (x)++)
#define repiin(x, y, z) for ((x) = (z); (x) <= (y); (x)++)
#define reps(x, y, z) for ((x) = 0; (x) < (y); (x) += (z))
#define repis(x, y, z, s) for ((x) = (z); (x) < (y); (x) += (s))
#define repiins(x, y, z, s) for ((x) = (z); (x) <= (y); (x) += (s))
#define repit(x) \
for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define repit2(x) \
for (__typeof((x).begin()) it2 = (x).begin(); it2 != (x).end(); it2++)
#define nepit(x) \
for (__typeof((x).rbegin()) it = (x).rbegin(); it != (x).rend(); it++)
#define All(x) (x).begin(), (x).end()
#define Mem0(x) memset(x, 0, sizeof(x))
#define Mem1(x) memset(x, -1, sizeof(x))
// can be applied to string type
#define Unique(v) v.resize(unique(All(v)) - v.begin())
#define peq(p0, p1) (p0.first == p1.first && p0.second == p1.second)
#define End '\n'
#define Out(x) cout << (x) << End
template <typename T> void OutN(T x) {
size_t i, len = x.size() - 1;
for (i = 0; i < len; i++)
cout << x[i] << " ";
cout << x[len] << '\n';
}
#define OutaN(x) \
do { \
size_t i, len = sizeof(x) / sizeof(__typeof(x[0])) - 1; \
for (i = 0; i < len; i++) \
cout << x[i] << " "; \
cout << x[len] << '\n'; \
} while (0);
template <typename T> void Outit(T x) {
auto end = x.end();
end--;
for (auto it = x.begin(); it != end; it++)
cout << *it << " ";
cout << *end << '\n';
}
template <typename T> void Debug(const T &val) { cerr << val << End; }
template <typename T, typename... Args> void Debug(const T &val, Args... args) {
cerr << val << ' ';
Debug(std::forward<Args>(args)...);
}
template <typename T> inline bool Max(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T> inline bool Min(T &x, const T &y) {
return x > y ? x = y, 1 : 0;
}
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
// can be applied to string type
#define Sort(v) sort(All(v))
#define SortR(v) sort(All(v), std::greater<__typeof(v[0])>())
// array sorters
#define Sart(a) sort(a, a + sizeof(a) / sizeof(__typeof(a[0])));
#define SartR(a) \
sort(a, a + sizeof(a) / sizeof(__typeof(a[0])), \
std::greater<__typeof(a[0])>())
#define pb push_back
#define mp make_pair
#define a first
#define b second
#define lb std::lower_bound
#define ub std::upper_bound
#define lbi(v, x) lb(All(v), (x)) - v.begin()
#define ubi(v, x) ub(All(v), (x)) - v.begin()
static const ll MOD = 1e9 + 7;
static const double PI = 3.141592653589793;
#define LOCAL 0
int main() {
#if LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("debug.txt", "w", stderr);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
// std::cout.precision(18);
ll l, r;
cin >> l >> r;
if (l == 0) {
Out(0);
} else if (l + 1 == r) {
Out((l * r) % 2019);
} else {
map<int, ll> table;
V<pair<int, ll>> v;
int ans = INT_MAX;
ll i, j, len;
repiin(i, r, l) {
if (i % 2019 == 0) {
Out(0);
return 0;
}
table[i % 2019]++;
}
repit(table) v.pb(*it);
len = v.size();
rep(i, len) {
if (1 < v[i].b)
Min(ans, (v[i].a * v[i].a) % 2019);
repi(j, len, i + 1) Min(ans, (v[i].a * v[j].a) % 2019);
}
Out(ans);
}
return 0;
}
| replace | 126 | 127 | 126 | 135 | TLE | |
p02983 | C++ | Time Limit Exceeded | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
class CRemainderMinimization2019 {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
void solve(std::istream &cin, std::ostream &cout) {
int L, R;
cin >> L >> R;
int l = L % 2019;
int r = R % 2019;
if (r - l + 1 >= 2019) {
cout << 0 << endl;
return;
}
int res = INF;
FOR(i, L, R - 1) {
FOR(j, i + 1, R) { res = min(res, (i * j) % 2019); }
}
cout << res << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
CRemainderMinimization2019 solver;
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
class CRemainderMinimization2019 {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
void solve(std::istream &cin, std::ostream &cout) {
int L, R;
cin >> L >> R;
if (R - L + 1 >= 2019) {
cout << 0 << endl;
return;
}
int res = INF;
FOR(i, L, R - 1) {
FOR(j, i + 1, R) { res = min(res, (i * j) % 2019); }
}
cout << res << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
CRemainderMinimization2019 solver;
solver.solve(in, out);
return 0;
}
| replace | 60 | 63 | 60 | 61 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iomanip>
#include <iostream>
using namespace std;
long long l, r;
int main() {
ios::sync_with_stdio(false);
cin >> l >> r;
int min1 = (1 << 30);
for (long long i = l; i <= r; i++)
for (long long j = i + 1; j <= r; j++) {
if (min1 > i % 2019 * (j % 2019) % 2019)
min1 = i % 2019 * (j % 2019) % 2019;
}
cout << min1 << endl;
return 0;
} | #include <cstdio>
#include <iomanip>
#include <iostream>
using namespace std;
long long l, r;
int main() {
ios::sync_with_stdio(false);
cin >> l >> r;
int min1 = (1 << 30);
int l1 = l % 2019, r1 = r % 2019;
if (l / 2019 != r / 2019) {
cout << "0";
return 0;
} else {
for (long long i = l; i <= r; i++)
for (long long j = i + 1; j <= r; j++) {
if (min1 > i * j % 2019)
min1 = i * j % 2019;
}
cout << min1 << endl;
}
return 0;
} | replace | 9 | 15 | 9 | 21 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
int main() {
long L, R;
std::cin >> L >> R;
if (R / 2019 != L / 2019 || L % 2019 == 0) {
std::cout << "0\n";
}
long result = 2018;
for (long i = L; i < R; ++i) {
for (long j = i + 1; j <= R; ++j) {
result = std::min(result, (i * j) % 2019);
}
}
std::cout << result << "\n";
}
| #include <algorithm>
#include <array>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
int main() {
long L, R;
std::cin >> L >> R;
if (R / 2019 != L / 2019 || L % 2019 == 0) {
std::cout << "0\n";
return 0;
}
long result = 2018;
for (long i = L; i < R; ++i) {
for (long j = i + 1; j <= R; ++j) {
result = std::min(result, (i * j) % 2019);
}
}
std::cout << result << "\n";
}
| insert | 24 | 24 | 24 | 25 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 100100100;
ll cnt = 0;
bool flag = false;
if (r - l < 1000000) {
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ll pre = ans;
ans = min((i * j) % 2019, ans);
if (pre == ans) {
cnt++;
if (cnt > 100000)
flag = true;
} else {
cnt = 0;
}
}
}
} else {
for (ll i = r; i > l; i--) {
ll pre = ans;
ans = min(i * (i - 1) % 2019, ans);
if (ans == pre) {
cnt++;
if (cnt == 10000)
break;
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 100100100;
ll cnt = 0;
bool flag = false;
if (r - l < 100000) {
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
ll pre = ans;
ans = min((i * j) % 2019, ans);
if (pre == ans) {
cnt++;
if (cnt > 100000)
flag = true;
} else {
cnt = 0;
}
}
}
} else {
for (ll i = r; i > l; i--) {
ll pre = ans;
ans = min(i * (i - 1) % 2019, ans);
if (ans == pre) {
cnt++;
if (cnt == 10000)
break;
}
}
}
cout << ans << endl;
return 0;
} | replace | 12 | 13 | 12 | 13 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, t, res = 2020;
cin >> a >> b;
b = min(b, b + 2019);
for (long i = a; i <= b; i++) {
for (long j = i + 1; j <= b; j++) {
t = (i * j) % 2019;
res = min(t, res);
}
}
cout << res;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, t, res = 2020;
cin >> a >> b;
b = min(b, a + 2019);
for (long i = a; i <= b; i++) {
for (long j = i + 1; j <= b; j++) {
t = (i * j) % 2019;
res = min(t, res);
}
}
cout << res;
return 0;
}
| replace | 7 | 8 | 7 | 8 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <limits>
int main() {
long long L, R;
std::cin >> L >> R;
const long long mod = 2019;
auto ret = std::numeric_limits<long long>::max();
for (long long i = L; i < R; ++i) {
const auto i_mod = i % mod;
const auto j_max = std::min(R, i + mod);
for (long long j = i + 1; j <= j_max; ++j) {
const auto j_mod = j % mod;
const auto i_j_mod = (i_mod * j_mod) % mod;
ret = std::min(ret, i_j_mod);
}
}
std::cout << ret << std::endl;
}
| #include <algorithm>
#include <iostream>
#include <limits>
int main() {
long long L, R;
std::cin >> L >> R;
const long long mod = 2019;
auto ret = std::numeric_limits<long long>::max();
const auto i_max = std::min(R, L + mod - 1);
for (long long i = L; i < i_max; ++i) {
const auto i_mod = i % mod;
const auto j_max = std::min(R, i + mod);
for (long long j = i + 1; j <= j_max; ++j) {
const auto j_mod = j % mod;
const auto i_j_mod = (i_mod * j_mod) % mod;
ret = std::min(ret, i_j_mod);
}
}
std::cout << ret << std::endl;
}
| replace | 11 | 12 | 11 | 13 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int l, r;
scanf("%d%d", &l, &r);
if (l - r + 1 >= 2020)
printf("0");
else {
int ans = 2019;
for (int i = l; i <= r; i++)
for (int j = i + 1; j <= r; j++)
if (((i % 2019) * (j % 2019)) % 2019 < ans)
ans = ((i % 2019) * (j % 2019)) % 2019;
printf("%d", ans);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int l, r;
scanf("%d%d", &l, &r);
if (r - l + 1 >= 2020)
printf("0");
else {
int ans = 2019;
for (int i = l; i <= r; i++)
for (int j = i + 1; j <= r; j++)
if (((i % 2019) * (j % 2019)) % 2019 < ans)
ans = ((i % 2019) * (j % 2019)) % 2019;
printf("%d", ans);
}
return 0;
}
| replace | 5 | 6 | 5 | 6 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 2020;
for (ll i = l; i <= r - 1; ++i) {
for (ll j = l + 1; j <= r; ++j) {
ans = min(ans, i * j % 2019);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 2020;
if (r - l >= 2019) {
r = l + 2019;
}
for (ll i = l; i <= r - 1; ++i) {
for (ll j = l + 1; j <= r; ++j) {
ans = min(ans, i * j % 2019);
}
}
cout << ans << endl;
return 0;
}
| insert | 10 | 10 | 10 | 13 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
int main() {
ll l, r;
cin >> l >> r;
set<int> mods;
for (ll i = l; i <= r; i++) {
mods.insert(i % 2019);
}
vector<int> m;
for (auto itr = mods.begin(); itr != mods.end(); itr++) {
m.push_back(*itr);
}
int ans = 2020;
for (int i = 0; i < m.size(); i++) {
for (int j = i + 1; j < m.size(); j++) {
ans = min(ans, (m[i] * m[j]) % 2019);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
int main() {
ll l, r;
cin >> l >> r;
set<int> mods;
for (ll i = l; i <= r; i++) {
int mod = i % 2019;
mods.insert(mod);
if (mods.size() >= 2019)
break;
}
vector<int> m;
for (auto itr = mods.begin(); itr != mods.end(); itr++) {
m.push_back(*itr);
}
int ans = 2020;
for (int i = 0; i < m.size(); i++) {
for (int j = i + 1; j < m.size(); j++) {
ans = min(ans, (m[i] * m[j]) % 2019);
}
}
cout << ans << endl;
}
| replace | 10 | 11 | 10 | 14 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define cina(s, n, a) \
for (int i = s; i < n; i++) \
cin >> a[i]
#define couta(n, a) \
for (int i = 0; i < n; i++) \
cout << a[i] << ' '
#define copy(s, n, a, b) \
for (int i = s; i < n; i++) \
b[i] = a[i]
#define yesno(ok) cout << (ok ? "YES" : "NO")
#define mod(a, b) (b + (a % b)) % b
#define MOD (int)1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef std::vector<int> vi;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
typedef std::vector<pii> vpii;
using namespace std;
void solve() {
ll x, y;
cin >> x >> y;
if (x - y > 2019) {
cout << 2;
} else {
ll ans = INT_MAX;
for (ll i = x; i <= y; i++) {
for (ll j = x; j <= y; j++) {
if (i != j)
ans = min(ans, (i * j) % 2019);
}
}
cout << ans;
}
}
int main() {
ios::sync_with_stdio(false);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int q = 1;
// cin >> q;
for (int i = 1; i <= q; i++) {
solve();
}
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define cina(s, n, a) \
for (int i = s; i < n; i++) \
cin >> a[i]
#define couta(n, a) \
for (int i = 0; i < n; i++) \
cout << a[i] << ' '
#define copy(s, n, a, b) \
for (int i = s; i < n; i++) \
b[i] = a[i]
#define yesno(ok) cout << (ok ? "YES" : "NO")
#define mod(a, b) (b + (a % b)) % b
#define MOD (int)1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef std::vector<int> vi;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
typedef std::vector<pii> vpii;
using namespace std;
void solve() {
ll x, y;
cin >> x >> y;
if (abs(x - y) > 2019) {
cout << 0;
} else {
ll ans = INT_MAX;
for (ll i = x; i <= y; i++) {
for (ll j = x; j <= y; j++) {
if (i != j)
ans = min(ans, (i * j) % 2019);
}
}
cout << ans;
}
}
int main() {
ios::sync_with_stdio(false);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int q = 1;
// cin >> q;
for (int i = 1; i <= q; i++) {
solve();
}
}
| replace | 42 | 44 | 42 | 44 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define INF 100000000000
#define MOD 1000000007
#define ll long long int
// #define int long long int
using namespace std;
int main() {
ll L, R;
ll ans = 10000;
cin >> L >> R;
for (ll i = L; i <= R; i++) {
ll a = i * i % 2019;
if (i + 2019 > R)
break;
ans = min(a, ans);
}
L = L % 2019;
R = R % 2019;
ll r = max(L, R);
ll l = min(L, R);
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
ll seki = i * j;
// cout<<i<<" "<<j<<endl;
seki = seki % 2019;
ans = min(seki, ans);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define INF 100000000000
#define MOD 1000000007
#define ll long long int
// #define int long long int
using namespace std;
int main() {
ll L, R;
ll ans = 10000;
cin >> L >> R;
for (ll i = L; i <= min(R, L + 3000); i++) {
ll a = i * i % 2019;
if (i + 2019 > R)
break;
ans = min(a, ans);
}
L = L % 2019;
R = R % 2019;
ll r = max(L, R);
ll l = min(L, R);
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
ll seki = i * j;
// cout<<i<<" "<<j<<endl;
seki = seki % 2019;
ans = min(seki, ans);
}
}
cout << ans << endl;
return 0;
} | replace | 21 | 22 | 21 | 22 | TLE | |
p02983 | C++ | Time Limit Exceeded | // include
// ------------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <vector>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(long long n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
// code
// ------------------------------------------------
int main() {
ll l, r, lmod, rmod;
cin >> l >> r;
bool flg = false;
ll ans = LLONG_MAX;
for (ll i = l; i <= r; i++) {
if (i % 2019 == 0) {
cout << 0 << endl;
return 0;
}
for (ll j = i + 1; j <= r; j++) {
ans = min(ans, (i % 2019 * j % 2019) % 2019);
}
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(ll n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 0)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
| // include
// ------------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <vector>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(long long n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
// code
// ------------------------------------------------
int main() {
ll l, r, lmod, rmod;
cin >> l >> r;
bool flg = false;
ll ans = LLONG_MAX;
for (ll i = l; i <= r; i++) {
if (i % 2019 == 0) {
cout << 0 << endl;
return 0;
}
for (ll j = i + 1; j <= min(i + 2020, r); j++) {
ans = min(ans, (i % 2019 * j % 2019) % 2019);
}
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(ll n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 0)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
| replace | 49 | 50 | 49 | 50 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll L, R;
cin >> L >> R;
ll ans = 2019;
for (int i = L; i < R && i - L <= 2019; i++) {
for (int j = i + 1; j <= R && j - R <= 2019; j++) {
ans = min(ans, (ll)i * j % 2019);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll L, R;
cin >> L >> R;
ll ans = 2019;
for (int i = L; i < R && i - L <= 2019; i++) {
for (int j = i + 1; j <= R && j - L <= 2019; j++) {
ans = min(ans, (ll)i * j % 2019);
}
}
cout << ans << endl;
return 0;
}
| replace | 11 | 12 | 11 | 12 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define MOD 2019
int main() {
ll L, R;
cin >> L >> R;
ll ans = 2999999999;
for (int i = L; i < R; i++) {
for (int j = L + 1; j <= R; j++) {
ll tmp = ((i % MOD) * (j % MOD)) % MOD;
ans = min(ans, tmp);
if (ans == 0)
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define MOD 2019
int main() {
ll L, R;
cin >> L >> R;
ll ans = 2999999999;
for (int i = L; i < R; i++) {
for (int j = L + 1; j <= R; j++) {
ll tmp = ((i % MOD) * (j % MOD)) % MOD;
ans = min(ans, tmp);
if (ans == 0)
break;
}
if (ans == 0)
break;
}
cout << ans << endl;
} | insert | 19 | 19 | 19 | 21 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int mod = 2019;
int main() {
int l, r;
cin >> l >> r;
long long ans = mod;
if (l - r >= mod) {
ans = 0;
} else {
for (long long i = l; i <= r; i++) {
for (long long j = i + 1; j <= r; j++) {
ans = min(ans, i * j % mod);
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int mod = 2019;
int main() {
int l, r;
cin >> l >> r;
long long ans = mod;
if (r - l >= mod) {
ans = 0;
} else {
for (long long i = l; i <= r; i++) {
for (long long j = i + 1; j <= r; j++) {
ans = min(ans, i * j % mod);
}
}
}
cout << ans << endl;
return 0;
}
| replace | 15 | 16 | 15 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | /**
������������ Author : Avi J Patel ������������
������������ University : DA-IICT ������������
**/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define N 100000
#define ff first
#define ss second
#define si size()
#define MOD 1000000007
#define large 10000000000000001
#define For(i, m, n) for (long long i = m; i < n; i++)
#define st(x) sort(x.begin(), x.end())
#define re(x, i) reverse(x.begin() + i, x.end())
#define FAST \
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); \
srand(time(NULL));
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
/*void calc()
{
for(int i=0;i<2005;i++)
{
a[i][0]=1;
a[i][i]=1;
for(int j=1;j<i;j++)
{
a[i][j]=(a[i-1][j-1]+a[i-1][j])%MOD;
}
}
}*/
int main() {
ll l, r;
cin >> l >> r;
if ((r - l + 1) >= 2019) {
cout << 0;
}
ll min1 = INT_MAX;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
min1 = min(min1, ((i % 2019) * (j % 2019)) % 2019);
}
}
cout << min1;
return 0;
}
| /**
������������ Author : Avi J Patel ������������
������������ University : DA-IICT ������������
**/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define N 100000
#define ff first
#define ss second
#define si size()
#define MOD 1000000007
#define large 10000000000000001
#define For(i, m, n) for (long long i = m; i < n; i++)
#define st(x) sort(x.begin(), x.end())
#define re(x, i) reverse(x.begin() + i, x.end())
#define FAST \
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); \
srand(time(NULL));
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
/*void calc()
{
for(int i=0;i<2005;i++)
{
a[i][0]=1;
a[i][i]=1;
for(int j=1;j<i;j++)
{
a[i][j]=(a[i-1][j-1]+a[i-1][j])%MOD;
}
}
}*/
int main() {
ll l, r;
cin >> l >> r;
if ((r - l + 1) >= 2019) {
cout << 0;
return 0;
}
l %= 2019;
r %= 2019;
if (r <= l) {
cout << 0;
return 0;
}
ll min1 = INT_MAX;
for (ll i = l; i < r; i++) {
for (ll j = i + 1; j <= r; j++) {
min1 = min(min1, ((i % 2019) * (j % 2019)) % 2019);
}
}
cout << min1;
return 0;
}
| insert | 45 | 45 | 45 | 52 | TLE | |
p02983 | C++ | Time Limit Exceeded | // A Naive recursive C++ program to find minimum of coins
// to make a given change V
#include <bits/stdc++.h>
using namespace std;
int main() {
long int l, r;
cin >> l >> r;
int a[2019] = {0};
for (long int i = l; i <= r; i++)
a[i % 2019]++;
int min1 = INT_MAX;
// cout<<a[4]<<" "<<a[5]<<endl;
if (a[0] != 0)
cout << 0;
else {
for (int i = 1; i < 2019; i++) {
for (int j = i + 1; j < 2019; j++) {
if (a[i] != 0 && a[j] != 0)
if (min1 > ((i * j) % 2019))
min1 = ((i * j) % 2019);
}
}
cout << min1 << endl;
}
} | // A Naive recursive C++ program to find minimum of coins
// to make a given change V
#include <bits/stdc++.h>
using namespace std;
int main() {
long int l, r;
cin >> l >> r;
int a[2019] = {0};
for (long int i = l; i <= min(r, l + 2020); i++)
a[i % 2019]++;
int min1 = INT_MAX;
// cout<<a[4]<<" "<<a[5]<<endl;
if (a[0] != 0)
cout << 0;
else {
for (int i = 1; i < 2019; i++) {
for (int j = i + 1; j < 2019; j++) {
if (a[i] != 0 && a[j] != 0)
if (min1 > ((i * j) % 2019))
min1 = ((i * j) % 2019);
}
}
cout << min1 << endl;
}
} | replace | 8 | 9 | 8 | 9 | TLE | |
p02983 | C++ | Time Limit Exceeded | //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main(int argc, char *argv[]) {
ll L, R;
cin >> L >> R;
if (L - R >= 2018) {
cout << 0 << endl;
return 0;
}
ll ans = numeric_limits<ll>::max();
for (ll x = L; x <= R; x++) {
for (ll y = x + 1; y <= R; y++) {
ans = min(ans, (x * y) % 2019);
}
}
cout << ans << endl;
}
| //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main(int argc, char *argv[]) {
ll L, R;
cin >> L >> R;
if (R - L >= 2018) {
cout << 0 << endl;
return 0;
}
ll ans = numeric_limits<ll>::max();
for (ll x = L; x <= R; x++) {
for (ll y = x + 1; y <= R; y++) {
ans = min(ans, (x * y) % 2019);
}
}
cout << ans << endl;
}
| replace | 33 | 34 | 33 | 34 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using vl = vector<ll>;
using Map = map<ll, ll>;
using T = tuple<ll, ll, ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define print(v) cout << v << endl
#define first(v) get<0>(v)
#define second(v) get<1>(v)
#define third(v) get<2>(v)
template <typename T> bool chmax(T &a, T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
int main() {
ll L;
cin >> L;
ll R;
cin >> R;
Map M;
for (ll i = L; i <= R; i++) {
ll k = i % 2019LL;
M[k]++;
;
}
ll ans = INF;
for (ll i = 0; i < 2018; i++) {
for (ll j = i + 1; j < 2019; j++) {
if (M[i] && M[j]) {
ll k = (i * j) % 2019;
chmin(ans, k);
};
};
}
print(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using vl = vector<ll>;
using Map = map<ll, ll>;
using T = tuple<ll, ll, ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define print(v) cout << v << endl
#define first(v) get<0>(v)
#define second(v) get<1>(v)
#define third(v) get<2>(v)
template <typename T> bool chmax(T &a, T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
int main() {
ll L;
cin >> L;
ll R;
cin >> R;
Map M;
if (R - L > 2020) {
print(0);
return 0;
}
for (ll i = L; i <= R; i++) {
ll k = i % 2019LL;
M[k]++;
;
}
ll ans = INF;
for (ll i = 0; i < 2018; i++) {
for (ll j = i + 1; j < 2019; j++) {
if (M[i] && M[j]) {
ll k = (i * j) % 2019;
chmin(ans, k);
};
};
}
print(ans);
return 0;
}
| insert | 36 | 36 | 36 | 40 | TLE | |
p02983 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define CHAL_BC_APNE_BAAP_KO_MAT_SIKHA \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define fr first
#define se second
signed main() {
CHAL_BC_APNE_BAAP_KO_MAT_SIKHA;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int l, r;
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0 << endl;
} else {
l = l % 2019;
int mn = INT_MAX;
r = r % 2019;
if (r < l) {
cout << 0 << endl;
return 0;
}
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++)
mn = min(mn, (i * j) % 2019);
}
cout << mn << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define CHAL_BC_APNE_BAAP_KO_MAT_SIKHA \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define fr first
#define se second
signed main() {
CHAL_BC_APNE_BAAP_KO_MAT_SIKHA;
int l, r;
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0 << endl;
} else {
l = l % 2019;
int mn = INT_MAX;
r = r % 2019;
if (r < l) {
cout << 0 << endl;
return 0;
}
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++)
mn = min(mn, (i * j) % 2019);
}
cout << mn << endl;
}
}
| delete | 12 | 16 | 12 | 12 | 0 | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long ans = 1e9;
if (r < l + 2019) {
for (long long i = l; i <= r; i++) {
for (long long j = i + 1; j <= r; j++) {
if ((i * j) % 2019 < ans)
ans = (i * j) % 2019;
// cout<<ans;
}
}
} else {
for (long long i = l; l <= l + 2019; i++) {
for (long long j = l + 1; j < l + 2019; j++) {
if ((i * j) % 2019 < ans)
ans = (i * j) % 2019;
}
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long ans = 1e9;
if (r < l + 2019) {
for (long long i = l; i <= r; i++) {
for (long long j = i + 1; j <= r; j++) {
if ((i * j) % 2019 < ans)
ans = (i * j) % 2019;
// cout<<ans;
}
}
} else {
for (long long i = l; i <= l + 2019; i++) {
for (long long j = l + 1; j < l + 2019; j++) {
if ((i * j) % 2019 < ans)
ans = (i * j) % 2019;
}
}
}
cout << ans;
}
| replace | 15 | 16 | 15 | 16 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b);
return a;
}
int main() {
int l, r;
int ans = 2019;
cin >> l >> r;
for (int i = l; i < r; i++) {
for (int j = i + 1; j <= r; j++) {
ans = min(ans, ((i % 2019) * (j % 2019)) % 2019);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b);
return a;
}
int main() {
int l, r;
int ans = 2019;
cin >> l >> r;
int num = min(r - l, 2019);
for (int i = l; i < l + num; i++) {
for (int j = i + 1; j <= l + num; j++) {
ans = min(ans, ((i % 2019) * (j % 2019)) % 2019);
}
}
cout << ans << endl;
return 0;
} | replace | 29 | 31 | 29 | 32 | TLE | |
p02983 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MM = 1000000000;
const int MOD = MM + 7;
const int MAX = 510000;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define Rep(i, j, n) for (ll i = j; i < n; i++)
#define all(vec) vec.begin(), vec.end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll INF = 1LL << 60;
const double pi = acos(-1.0);
int main() {
ll l, r;
cin >> l >> r;
l %= 2019, r %= 2019;
vector<ll> v;
Rep(i, l, r + 1) v.push_back(i);
sort(all(v));
cout << v[0] * v[1] % 2019 << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MM = 1000000000;
const int MOD = MM + 7;
const int MAX = 510000;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define Rep(i, j, n) for (ll i = j; i < n; i++)
#define all(vec) vec.begin(), vec.end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll INF = 1LL << 60;
const double pi = acos(-1.0);
int main() {
ll l, r;
cin >> l >> r;
if (l / 2019 != r / 2019) {
cout << 0 << endl;
return 0;
}
ll ans = INF;
Rep(i, l, r) Rep(j, i + 1, r + 1) chmin(ans, i * j % 2019);
cout << ans << endl;
} | replace | 29 | 34 | 29 | 36 | 0 | |
p02983 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define lb lower_bound
#define ub upper_bound
#define f first
#define s second
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
template <typename T> void ckmin(T &a, const T &b) { a = min(a, b); }
template <typename T> void ckmax(T &a, const T &b) { a = max(a, b); }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2> void re(pair<T1, T2> &p);
template <class T> void re(vector<T> &a);
template <class T, size_t SZ> void re(array<T, SZ> &a);
template <class T> void re(T &x) { cin >> x; }
void re(double &x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args> void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <class T1, class T2> void re(pair<T1, T2> &p) { re(p.f, p.s); }
template <class T> void re(vector<T> &a) { F0R(i, sz(a)) re(a[i]); }
template <class T, size_t SZ> void re(array<T, SZ> &a) { F0R(i, SZ) re(a[i]); }
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2> void pr(const pair<T1, T2> &x);
template <class T, size_t SZ> void pr(const array<T, SZ> &x);
template <class T> void pr(const vector<T> &x);
template <class T> void pr(const set<T> &x);
template <class T1, class T2> void pr(const map<T1, T2> &x);
template <class T> void pr(const T &x) { cout << x; }
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2> void pr(const pair<T1, T2> &x) {
pr("{", x.f, ", ", x.s, "}");
}
template <class T> void prContain(const T &x) {
pr("{");
bool fst = 1;
for (const auto &a : x)
pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
template <class T, size_t SZ> void pr(const array<T, SZ> &x) { prContain(x); }
template <class T> void pr(const vector<T> &x) { prContain(x); }
template <class T> void pr(const set<T> &x) { prContain(x); }
template <class T1, class T2> void pr(const map<T1, T2> &x) { prContain(x); }
void ps() { pr("\n"); }
template <class Arg> void ps(const Arg &first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg &first, const Args &...rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int L, R;
re(L, R);
vb have(2019);
FOR(v, L, R + 1)
have[v % 2019] = true;
int ans = INT_MAX;
F0R(a, 2019)
FOR(b, a + 1, 2019)
if (have[a] && have[b])
ckmin(ans, a * b % 2019);
ps(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define lb lower_bound
#define ub upper_bound
#define f first
#define s second
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
template <typename T> void ckmin(T &a, const T &b) { a = min(a, b); }
template <typename T> void ckmax(T &a, const T &b) { a = max(a, b); }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2> void re(pair<T1, T2> &p);
template <class T> void re(vector<T> &a);
template <class T, size_t SZ> void re(array<T, SZ> &a);
template <class T> void re(T &x) { cin >> x; }
void re(double &x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args> void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <class T1, class T2> void re(pair<T1, T2> &p) { re(p.f, p.s); }
template <class T> void re(vector<T> &a) { F0R(i, sz(a)) re(a[i]); }
template <class T, size_t SZ> void re(array<T, SZ> &a) { F0R(i, SZ) re(a[i]); }
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2> void pr(const pair<T1, T2> &x);
template <class T, size_t SZ> void pr(const array<T, SZ> &x);
template <class T> void pr(const vector<T> &x);
template <class T> void pr(const set<T> &x);
template <class T1, class T2> void pr(const map<T1, T2> &x);
template <class T> void pr(const T &x) { cout << x; }
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2> void pr(const pair<T1, T2> &x) {
pr("{", x.f, ", ", x.s, "}");
}
template <class T> void prContain(const T &x) {
pr("{");
bool fst = 1;
for (const auto &a : x)
pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
template <class T, size_t SZ> void pr(const array<T, SZ> &x) { prContain(x); }
template <class T> void pr(const vector<T> &x) { prContain(x); }
template <class T> void pr(const set<T> &x) { prContain(x); }
template <class T1, class T2> void pr(const map<T1, T2> &x) { prContain(x); }
void ps() { pr("\n"); }
template <class Arg> void ps(const Arg &first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg &first, const Args &...rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int L, R;
re(L, R);
vb have(2019);
FOR(v, L, min(R + 1, L + 2019))
have[v % 2019] = true;
int ans = INT_MAX;
F0R(a, 2019)
FOR(b, a + 1, 2019)
if (have[a] && have[b])
ckmin(ans, a * b % 2019);
ps(ans);
return 0;
}
| replace | 107 | 108 | 107 | 108 | TLE | |
p02983 | C++ | Time Limit Exceeded | // #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
long long L, R;
// vector<int> vp;
// int vp[12][12];
cin >> L >> R;
// for (int j=0; j<N; j++){
// for (int i=0; i<D; i++){
// cin >> vp[j][i];
// }
// }
long long res = 2020;
long long mod2019;
for (long long i = L; i <= R - 1; i++) {
for (long long j = i + 1; j <= R; j++) {
// mod2019 = (i * j) % 2019; // TLE
mod2019 = ((i % 2019) * (j % 2019)) % 2019;
if (mod2019 < res)
res = mod2019;
if (res == 0)
break;
}
}
cout << res << endl;
return 0;
}
| // #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
long long L, R;
// vector<int> vp;
// int vp[12][12];
cin >> L >> R;
// for (int j=0; j<N; j++){
// for (int i=0; i<D; i++){
// cin >> vp[j][i];
// }
// }
long long res = 2020;
long long mod2019;
for (long long i = L; i <= R - 1; i++) {
for (long long j = i + 1; j <= R; j++) {
// mod2019 = (i * j) % 2019; // TLE
mod2019 = ((i % 2019) * (j % 2019)) % 2019;
if (mod2019 < res)
res = mod2019;
if (res == 0)
break;
}
if (res == 0)
break;
}
cout << res << endl;
return 0;
} | insert | 30 | 30 | 30 | 32 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, o) for (int i = 0; i < (o); i++)
#define rep_s(i, o) for (int i = 1; i < (o); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) < (int)(b); i++)
#define NUM 1e5
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
return b;
}
return a;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ull l, r;
cin >> l >> r;
ull mini = 1e9 + 2;
for (ull i = l; i < r; i++) {
for (ull j = i + 1; j <= r; j++) {
/* code */
mini = min(mini, (i * j) % 2019);
}
}
// n = (m + n)/2;
cout << mini << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, o) for (int i = 0; i < (o); i++)
#define rep_s(i, o) for (int i = 1; i < (o); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) < (int)(b); i++)
#define NUM 1e5
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
return b;
}
return a;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ull l, r;
cin >> l >> r;
if (r - l >= 2019) {
cout << 0 << endl;
return 0;
}
ull mini = 1e9 + 2;
for (ull i = l; i < r; i++) {
for (ull j = i + 1; j <= r; j++) {
/* code */
mini = min(mini, (i * j) % 2019);
}
}
// n = (m + n)/2;
cout << mini << endl;
return 0;
} | insert | 40 | 40 | 40 | 45 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <istream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 2018;
r = min(r, r + 2019);
for (ll i = l; i < r; i++) {
for (ll j = l + 1; j <= r; j++) {
ans = min((i % 2019) * (j % 2019) % 2019, ans);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <istream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 2018;
r = min(r, l + 2019);
for (ll i = l; i < r; i++) {
for (ll j = l + 1; j <= r; j++) {
ans = min((i % 2019) * (j % 2019) % 2019, ans);
}
}
cout << ans << endl;
return 0;
} | replace | 25 | 26 | 25 | 26 | TLE | |
p02983 | C++ | Time Limit Exceeded | #include <iostream>
int main() {
long long L, R;
std::cin >> L >> R;
int min = 2018 * 2018;
if (L - R >= 2019) {
std::cout << 0 << std::endl;
return 0;
} else {
for (int i = L; i <= R; i++) {
for (int j = i + 1; j <= R; j++) {
int l = i % 2019;
int r = j % 2019;
int Z = l * r;
int min_temp = l * r % 2019;
if (min >= min_temp)
min = min_temp;
}
}
}
std::cout << min << std::endl;
return 0;
}
| #include <iostream>
int main() {
long long L, R;
std::cin >> L >> R;
int min = 2018 * 2018;
if (R - L >= 2019) {
std::cout << 0 << std::endl;
return 0;
} else {
for (int i = L; i <= R; i++) {
for (int j = i + 1; j <= R; j++) {
int l = i % 2019;
int r = j % 2019;
int Z = l * r;
int min_temp = l * r % 2019;
if (min >= min_temp)
min = min_temp;
}
}
}
std::cout << min << std::endl;
return 0;
}
| replace | 7 | 8 | 7 | 8 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.