problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p02925 | #include <bits/stdc++.h>
// #include <iostream> // cout, endl, cin
// #include <string> // string, to_string, stoi
// #include <vector> // vector
// #include <algorithm> // min, max, swap, sort, reverse, lower_bound,
// upper_bound #include <utility> // pair, make_pair #include <tuple> // tuple,
// make_tuple #include... | #include <bits/stdc++.h>
// #include <iostream> // cout, endl, cin
// #include <string> // string, to_string, stoi
// #include <vector> // vector
// #include <algorithm> // min, max, swap, sort, reverse, lower_bound,
// upper_bound #include <utility> // pair, make_pair #include <tuple> // tuple,
// make_tuple #include... | [
"expression.operation.binary.add"
] | 729,392 | 729,393 | u764234894 | cpp |
p02925 | #include <iostream>
#include <queue>
using namespace std;
int main() {
int a[1000][1000];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - 1; j++) {
cin >> a[i][j];
a[i][j]--;
}
}
int ind[1000];
for (int i = 0; i < n; i++) {
ind[i] = 0;
}
int count = 1;
... | #include <iostream>
#include <queue>
using namespace std;
int main() {
int a[1000][1000];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - 1; j++) {
cin >> a[i][j];
a[i][j]--;
}
}
int ind[1000];
for (int i = 0; i < n; i++) {
ind[i] = 0;
}
int count = 1;
... | [
"call.arguments.add",
"call.arguments.change"
] | 729,396 | 729,397 | u023751250 | cpp |
p02925 | #include <bitset>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
typedef long long ll;
using std::vector;
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typen... | #include <bitset>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
typedef long long ll;
using std::vector;
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typen... | [
"assignment.change"
] | 729,398 | 729,399 | u888094685 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define FOR(i, s, n) for (int i = (s); i < (n); i++)
#define RFOR(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
const long long MOD = 1e9 + 7, INF = 1e18;
t... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define FOR(i, s, n) for (int i = (s); i < (n); i++)
#define RFOR(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
const long long MOD = 1e9 + 7, INF = 1e18;
t... | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 729,415 | 729,416 | u693027786 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
#define N 1003
int Q[N * N], HEAD[N * N], Ne[N * N], E[N * N], V[N];
int To[N * N], b, n, Num[N][N], A[N], cnt, t, h, q;
void ADD(int s, int e) { Ne[++b] = HEAD[s], HEAD[s] = b, E[b] = e, To[e]++; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int... | #include <bits/stdc++.h>
using namespace std;
#define N 1003
int Q[N * N], HEAD[N * N], Ne[N * N], E[N * N], V[N * N];
int To[N * N], b, n, Num[N][N], A[N], cnt, t, h, q;
void ADD(int s, int e) { Ne[++b] = HEAD[s], HEAD[s] = b, E[b] = e, To[e]++; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for ... | [
"literal.number.change",
"assignment.value.change"
] | 729,426 | 729,425 | u399268660 | cpp |
p02925 | #include <iostream>
#include <queue>
using namespace std;
queue<int> q[1000];
int n, a, i, j;
int d[1000];
int c = 0, t = 0, now, l;
bool f;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
for (j = 0; j < n - 1; j++) {
scanf("%d", &a);
q[i].push(a - 1);
}
d[i] = -1;
}
l = n * (... | #include <iostream>
#include <queue>
using namespace std;
queue<int> q[1000];
int n, a, i, j;
int d[1000];
int c = 0, t = 0, now, l;
bool f;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
for (j = 0; j < n - 1; j++) {
scanf("%d", &a);
q[i].push(a - 1);
}
d[i] = -1;
}
l = n * (... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,436 | 729,437 | u069877747 | cpp |
p02925 | #include <bits/stdc++.h>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define ll long long
#define lld long double
#define ALL(x) x.begin(), x.end()
#ifdef ... | #include <bits/stdc++.h>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define ll long long
#define lld long double
#define ALL(x) x.begin(), x.end()
#ifdef ... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,442 | 729,443 | u174404613 | cpp |
p02925 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#define LL long long
using namespace std;
struct graph {
int to, next;
} gr[1000005];
int n, num, cnt, tot, ans, head[1000005], a[1005][1005], c[1005][1005],
in[1000005], t[1000005], day[1000005];
void border(int u, int... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#define LL long long
using namespace std;
struct graph {
int to, next;
} gr[1000005];
int n, num, cnt, tot, ans, head[1000005], a[1005][1005], c[1005][1005],
in[1000005], t[1000005], day[1000005];
void border(int u, int... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 729,449 | 729,450 | u296197760 | cpp |
p02925 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
// const ll mod = ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
// const ll mod = ... | [
"expression.operation.binary.add"
] | 729,497 | 729,498 | u702582248 | cpp |
p02925 | #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 1005
int N;
int table[SIZE][SIZE];
int loc[SIZE];
bool check(int node_id) {
if (lo... | #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 1005
int N;
int table[SIZE][SIZE];
int loc[SIZE];
bool check(int node_id) {
if (lo... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 729,504 | 729,505 | u000022466 | cpp |
p02925 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | [
"expression.unary.arithmetic.add"
] | 729,512 | 729,513 | u980909653 | cpp |
p02925 | #include <bits/stdc++.h>
#define repd(i, a, b) for (ll i = (a); i < (b); i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rep(i, n) repd(i, 0, n)
using namespace std;
using ll = long long;
using ul = unsigned long long;
ll mod = 1000000007;
ll dfs(vector<set<ll>> &g, vector<bool> &seen, vector<ll> &d... | #include <bits/stdc++.h>
#define repd(i, a, b) for (ll i = (a); i < (b); i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rep(i, n) repd(i, 0, n)
using namespace std;
using ll = long long;
using ul = unsigned long long;
ll mod = 1000000007;
ll dfs(vector<set<ll>> &g, vector<bool> &seen, vector<ll> &d... | [] | 729,519 | 729,520 | u030992242 | cpp |
p02925 | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
bool seen[2000000]{};
bool finished[2000000]{};
int d... | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
bool seen[2000000]{};
bool finished[2000000]{};
int d... | [
"assignment.change"
] | 729,521 | 729,522 | u415916075 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | [
"identifier.change",
"variable_access.subscript.index.change"
] | 729,546 | 729,547 | u347057617 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef int64_t Int;
typedef pair<int, int> P;
int N;
vector<deque<int>> A(N);
vector<P> match;
// kさんが試合をできればmatchに代入する
void check(int i) {
if (A[i].size() == 0)
return;
int j = A[i].front();
if (A[j].front... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef int64_t Int;
typedef pair<int, int> P;
int N;
vector<deque<int>> A(1010);
vector<P> match;
// kさんが試合をできればmatchに代入する
void check(int i) {
if (A[i].size() == 0)
return;
int j = A[i].front();
if (A[j].fr... | [] | 729,556 | 729,557 | u285358283 | cpp |
p02925 | #include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#includ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#includ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,560 | 729,561 | u265392294 | cpp |
p02925 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int MAXN = 1005;
const int MAXV = MAXN * (MAXN - 1) / 2;
vector<int> to[MAXV];
int id[MAXN][MAXN];
int toId(int i, int j) {
if (i > j)
swap(i, j);
return id[i][j];
}
bool visited[MAXV];
boo... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int MAXN = 1005;
const int MAXV = MAXN * (MAXN - 1) / 2;
vector<int> to[MAXV];
int id[MAXN][MAXN];
int toId(int i, int j) {
if (i > j)
swap(i, j);
return id[i][j];
}
bool visited[MAXV];
boo... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 729,564 | 729,565 | u108540384 | cpp |
p02925 | #include <bits/stdc++.h>
#define whlie while
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define rep(i, N) for (int i = 0; i < (N); i++)
#define repr(i, N) for (int i = (N)-1; i >= 0; i--)
#define rep1(i, N) for (int i = 1; i <= (N); i++)
#define repr1(i, N) for (int i = (N); i > 0; ... | #include <bits/stdc++.h>
#define whlie while
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define rep(i, N) for (int i = 0; i < (N); i++)
#define repr(i, N) for (int i = (N)-1; i >= 0; i--)
#define rep1(i, N) for (int i = 1; i <= (N); i++)
#define repr1(i, N) for (int i = (N); i > 0; ... | [
"identifier.change"
] | 729,568 | 729,569 | u168578024 | cpp |
p02925 | #include <bits/stdc++.h>
#define loop(n) \
for (int ngtkana_is_genius = 0; ngtkana_is_genius < int(n); \
ngtkana_is_genius++)
#define rep(i, begin, end) for (int i = int(begin); i < int(end); i++)
#define lint long long
auto cmn = ... | #include <bits/stdc++.h>
#define loop(n) \
for (int ngtkana_is_genius = 0; ngtkana_is_genius < int(n); \
ngtkana_is_genius++)
#define rep(i, begin, end) for (int i = int(begin); i < int(end); i++)
#define lint long long
auto cmn = ... | [
"assignment.change"
] | 729,570 | 729,571 | u846041485 | cpp |
p02925 | #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 <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sst... | #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 <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sst... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,576 | 729,577 | u340303097 | cpp |
p02925 | #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 <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sst... | #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 <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sst... | [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,578 | 729,577 | u340303097 | cpp |
p02925 | #include <algorithm>
#include <cmath>
#include <cstdarg>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (l... | #include <algorithm>
#include <cmath>
#include <cstdarg>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (l... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 729,581 | 729,582 | u176567747 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool c... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool c... | [
"control_flow.branch.else.add"
] | 729,586 | 729,587 | u187878098 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
queue<int> a[1001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < n; j++) {
int x;
cin >> x;
a[i].push(x);
}
}
int sc = n * (n - 1) / 2;
// cout<<sc<<endl;
int cnt = 0;
while (sc > 0) {
// cou... | #include <bits/stdc++.h>
using namespace std;
queue<int> a[1001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < n; j++) {
int x;
cin >> x;
a[i].push(x);
}
}
int sc = n * (n - 1) / 2;
// cout<<sc<<endl;
int cnt = 0;
while (sc > 0) {
// cou... | [
"control_flow.break.remove",
"control_flow.continue.add"
] | 729,595 | 729,596 | u201455094 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) ... | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) ... | [
"literal.number.change",
"variable_declaration.value.change"
] | 729,600 | 729,601 | u337054478 | cpp |
p02925 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#defi... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#defi... | [
"literal.number.change",
"variable_declaration.value.change"
] | 729,602 | 729,603 | u108648546 | cpp |
p02925 | #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(s... |
#include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,608 | 729,609 | u438319362 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define MOD 1000000007
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#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) ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define MOD 1000000007
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#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) ... | [
"expression.operation.binary.add"
] | 729,620 | 729,621 | u888717396 | cpp |
p02925 | /**
* Created by hiramekun at 15:11 on 2019-09-02.
*/
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using P = pair<ll, ll>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greate... | /**
* Created by hiramekun at 15:11 on 2019-09-02.
*/
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using P = pair<ll, ll>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greate... | [
"control_flow.break.remove",
"control_flow.continue.add"
] | 729,622 | 729,623 | u136378781 | cpp |
p02925 |
//#pragma GCC optimize ("-O3")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <reg... |
//#pragma GCC optimize ("-O3")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <reg... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 729,637 | 729,638 | u304121198 | cpp |
p02925 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int N;
int order[1005][1005 - 1];
int convert[1005][1005 - 1];
vector<vector<int>> E;
const int MAXV = 1005 * (1005 - 1) / 2;
int dp[MAXV];
bool finished[MAXV];
bool reached[MAXV];
int dfs(int pos) {
if (reached[pos]) {
if (!fin... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int N;
int order[1005][1005 - 1];
int convert[1005][1005 - 1];
vector<vector<int>> E;
const int MAXV = 1005 * (1005 - 1) / 2;
int dp[MAXV];
bool finished[MAXV];
bool reached[MAXV];
int dfs(int pos) {
if (reached[pos]) {
if (!fin... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,643 | 729,644 | u107077805 | cpp |
p02925 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int MAXN = 1005;
const int MAXV = MAXN * (MAXN - 1) / 2;
vector<int> E[MAXV];
int id[MAXN][MAXN];
bool reached[MAXV];
bool finished[MAXV];
int dp[MAXV]; // max length of path from v
int dfs(int po... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int MAXN = 1005;
const int MAXV = MAXN * (MAXN - 1) / 2;
vector<int> E[MAXV];
int id[MAXN][MAXN];
bool reached[MAXV];
bool finished[MAXV];
int dp[MAXV]; // max length of path from v
int dfs(int po... | [
"expression.operation.binary.add"
] | 729,645 | 729,646 | u107077805 | cpp |
p02925 | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_E main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX / 2)
const int... | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_E main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX / 2)
const int... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 729,651 | 729,652 | u404244809 | cpp |
p02925 | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_E main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX / 2)
const int... | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_E main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX / 2)
const int... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 729,653 | 729,652 | u404244809 | cpp |
p02925 | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_E main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX / 2)
const int... | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_E main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LLONG_MAX / 2)
const int... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 729,654 | 729,655 | u404244809 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> g[1111][1111];
int d[1111][1111], v[1111][1111];
int f(int i, int j) {
if (v[i][j])
return d[i][j] ? d[i][j] : 1e9;
v[i][j] = 1;
int m = 0;
for (auto p : g[i][j])
m = max(m, f(p.first, p.second));
return d[i][j] = m + 1;
}
int main(... | #include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> g[1111][1111];
int d[1111][1111], v[1111][1111];
int f(int i, int j) {
if (v[i][j])
return d[i][j] ? d[i][j] : 1e9;
v[i][j] = 1;
int m = 0;
for (auto p : g[i][j])
m = max(m, f(p.first, p.second));
return d[i][j] = m + 1;
}
int main(... | [
"variable_declaration.add"
] | 729,677 | 729,678 | u337381518 | cpp |
p02925 | #include <bits/stdc++.h>
#define int long long
#define sd(a) scanf("%lld", &a)
#define pd(a) printf("%lld", a)
using namespace std;
const int maxn = 1e3 + 10;
int a[maxn][maxn];
int dur[maxn];
bool vis[maxn];
main() {
int n;
sd(n);
for (int i = 1; i <= n; ++i)
dur[i] = 1ll;
for (int i = 1; i <= n; ++i)
... | #include <bits/stdc++.h>
#define int long long
#define sd(a) scanf("%lld", &a)
#define pd(a) printf("%lld", a)
using namespace std;
const int maxn = 1e3 + 10;
int a[maxn][maxn];
int dur[maxn];
bool vis[maxn];
main() {
int n;
sd(n);
for (int i = 1; i <= n; ++i)
dur[i] = 1ll;
for (int i = 1; i <= n; ++i)
... | [
"control_flow.branch.if.condition.change",
"control_flow.break.remove",
"control_flow.continue.add"
] | 729,686 | 729,687 | u976418120 | cpp |
p02925 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 729,701 | 729,702 | u031448582 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9 + 1;
const long long LINF = (long long)9e18 + 1;
const int MAXN = 1005;
const int MAXV = MAXN * (MAXN - 1) / 2;
vector<int> to[MAXV];
int id[MAXN][MAXV];
int toId(int i, int j) {
if (i > j)
swap(i, j);
return id[i][j];
}
bool visited[MAXV]... | #include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9 + 1;
const long long LINF = (long long)9e18 + 1;
const int MAXN = 1005;
const int MAXV = MAXN * (MAXN - 1) / 2;
vector<int> to[MAXV];
int id[MAXN][MAXN];
int toId(int i, int j) {
if (i > j)
swap(i, j);
return id[i][j];
}
bool visited[MAXV]... | [
"identifier.change",
"variable_declaration.array_dimensions.change"
] | 729,709 | 729,710 | u480117549 | cpp |
p02925 | #if 1
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N = 1e3 + 5;
const int inf = 80000;
#define endl '\n'
int vs[N][N];
int p[N], idx[N];
bool vis[N], flag;
int getint() {
int w = 0, q = 0;
char c = getchar();
while (c < '0' || c > '9' && c != '-')... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N = 1e3 + 5;
const int inf = 80000;
#define endl '\n'
int vs[N][N];
int p[N], idx[N];
bool vis[N], flag;
int getint() {
int w = 0, q = 0;
char c = getchar();
while (c < '0' || c > '9' && c != '-')
c... | [
"control_flow.branch.else.remove"
] | 729,715 | 729,716 | u278034730 | cpp |
p02925 | #include <algorithm>
#include <array>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
//#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
typedef long long ll;
// static const ll MOD = 1000000007;
int main() {
ll N;
... | #include <algorithm>
#include <array>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
//#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
typedef long long ll;
// static const ll MOD = 1000000007;
int main() {
ll N;
... | [
"control_flow.branch.if.condition.change"
] | 729,734 | 729,735 | u909577618 | cpp |
p02925 | #include <bits/stdc++.h>
#define maxn 1005
using namespace std;
int n;
inline int id(int i, int j) { return i * n + j; }
vector<int> G[maxn * maxn];
int vis[maxn * maxn];
int dp[maxn * maxn];
bool dfs(int u) {
dp[u] = 1;
vis[u] = 1;
for (int v : G[u]) {
if (vis[v] == 1)
return false;
else {
if... | #include <bits/stdc++.h>
#define maxn 1005
using namespace std;
int n;
inline int id(int i, int j) { return i * n + j; }
vector<int> G[maxn * maxn];
int vis[maxn * maxn];
int dp[maxn * maxn];
bool dfs(int u) {
dp[u] = 1;
vis[u] = 1;
for (int v : G[u]) {
if (vis[v] == 1)
return false;
else {
if... | [
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 729,759 | 729,760 | u399391169 | cpp |
p02925 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) for... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) for... | [
"expression.operation.binary.remove"
] | 729,761 | 729,762 | u215122692 | cpp |
p02925 | #include <bits/stdc++.h>
#define all(v) (v).begin(), (v).end()
#define sortv(v) sort(all(v))
#define uniqv(v) (v).erase(unique(all(v)), (v).end())
#define pb push_back
#define FI first
#define SE second
#define lb lower_bound
#define ub upper_bound
#define mp make_pair
#define test 1
#define TEST if (test)
using name... | #include <bits/stdc++.h>
#define all(v) (v).begin(), (v).end()
#define sortv(v) sort(all(v))
#define uniqv(v) (v).erase(unique(all(v)), (v).end())
#define pb push_back
#define FI first
#define SE second
#define lb lower_bound
#define ub upper_bound
#define mp make_pair
#define test 1
#define TEST if (test)
using name... | [
"call.function.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 729,771 | 729,770 | u950523274 | cpp |
p02925 | #include <algorithm>
#include <cstdint>
#include <cstdio>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>
int main() {
size_t N;
scanf("%zu", &N);
auto enc = [&](size_t i, size_t j) {
if (i > j)
std::swap(i, j);
return i * N + j;
};
std::... | #include <algorithm>
#include <cstdint>
#include <cstdio>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>
int main() {
size_t N;
scanf("%zu", &N);
auto enc = [&](size_t i, size_t j) {
if (i > j)
std::swap(i, j);
return i * N + j;
};
std::... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 729,774 | 729,775 | u352499693 | cpp |
p02925 | #include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n;
int a[N][N];
int idx[N];
bool waiting[N][N];
int main() {
scanf("%d", &n);
vector<int> toCheck;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n - 1; ++j) {
scanf("%d", &a[i][j]);
--a[i][j];
}
idx[i] = 0;
... | #include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n;
int a[N][N];
int idx[N];
bool waiting[N][N];
int main() {
scanf("%d", &n);
vector<int> toCheck;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n - 1; ++j) {
scanf("%d", &a[i][j]);
--a[i][j];
}
idx[i] = 0;
... | [
"control_flow.branch.if.add"
] | 729,780 | 729,781 | u574811687 | cpp |
p02925 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#includ... | [
"expression.operation.binary.add"
] | 729,784 | 729,785 | u495699318 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl '\n'
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl '\n'
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
... | [] | 729,786 | 729,787 | u030090262 | cpp |
p02926 | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <tim... | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <tim... | [
"identifier.change",
"call.function.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 729,790 | 729,789 | u539145601 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;
const long double pi = atan2l(0, -1);
int N;
pair<long long, long long> operator+(pair<long long, long long> &a,
pair<long long, long long> &b) {
return make_pair(a.first + b.first, a.second + ... | #include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;
const long double pi = atan2l(0, -1);
int N;
pair<long long, long long> operator+(pair<long long, long long> &a,
pair<long long, long long> &b) {
return make_pair(a.first + b.first, a.second + ... | [
"misc.opposites",
"control_flow.loop.condition.change"
] | 729,794 | 729,795 | u844382784 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
struct V {
double x, y;
V(double x = 0, double y = 0) : x(x), y(y) {}
V &operator+=(const V &v) {
x += v.x;
y += v.y;
return *th... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
struct V {
double x, y;
V(double x = 0, double y = 0) : x(x), y(y) {}
V &operator+=(const V &v) {
x += v.x;
y += v.y;
return *th... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,805 | 729,806 | u564182781 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#defin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#defin... | [] | 729,814 | 729,815 | u277556971 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <queue>
#include <tuple>
template <typename T> void fin(T const &t) {
std::cout << t << std::endl;
exit(0);
}
struct vec {
int64_t x, y;
vec() : x(0), y(0) {}
vec(int64_t x, int64_t y) : x(x), y(y) {}
v... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <queue>
#include <tuple>
template <typename T> void fin(T const &t) {
std::cout << t << std::endl;
exit(0);
}
struct vec {
int64_t x, y;
vec() : x(0), y(0) {}
vec(int64_t x, int64_t y) : x(x), y(y) {}
v... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 729,849 | 729,850 | u294638337 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().coun... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().coun... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,853 | 729,854 | u322084037 | cpp |
p02926 | #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 SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define VRSORT(v) sort(... | #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 SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define VRSORT(v) sort(... | [
"assignment.change",
"control_flow.branch.if.condition.change"
] | 729,865 | 729,866 | u858670323 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n;
double x[100], y[100], dis, ans = 0.0, xx, yy, a, b;
const double PI = 3.14159265358979323846;
scanf("%d", &n);
for (int i = 0; i < n; i++) {... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n;
double x[100], y[100], dis, ans = 0.0, xx, yy, a, b;
const double PI = 3.14159265358979323846;
scanf("%d", &n);
for (int i = 0; i < n; i++) {... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 729,881 | 729,882 | u855429581 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxx = 1e5 + 10;
struct point {
double x, y;
};
bool cmp1(point a, point b) {
if (atan2(a.y, a.x) != atan2(b.y, b.x))
return atan2(a.y, a.x) < atan2(b.y, b.x);
else
return a.x < b.x;
}
point a[maxx];
int main() {
int n;
cin ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxx = 1e5 + 10;
struct point {
double x, y;
};
bool cmp1(point a, point b) {
if (atan2(a.y, a.x) != atan2(b.y, b.x))
return atan2(a.y, a.x) < atan2(b.y, b.x);
else
return a.x < b.x;
}
point a[maxx];
int main() {
int n;
cin ... | [] | 729,893 | 729,894 | u128408308 | cpp |
p02926 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#includ... | [
"literal.number.change",
"variable_declaration.value.change"
] | 729,899 | 729,898 | u495699318 | cpp |
p02926 | #include <bits/stdc++.h>
using namespace std;
template <typename T> struct Pt {
T x, y;
Pt() : x(0), y(0) {}
Pt(const T x, const T y) : x(x), y(y) {}
template <class F> explicit operator Pt<F>() const {
return Pt<F>((F)x, (F)y);
}
Pt operator+(const Pt b) const { return Pt(x + b.x, y + b.y); }
Pt op... | #include <bits/stdc++.h>
using namespace std;
template <typename T> struct Pt {
T x, y;
Pt() : x(0), y(0) {}
Pt(const T x, const T y) : x(x), y(y) {}
template <class F> explicit operator Pt<F>() const {
return Pt<F>((F)x, (F)y);
}
Pt operator+(const Pt b) const { return Pt(x + b.x, y + b.y); }
Pt op... | [
"assignment.change"
] | 729,902 | 729,903 | u459737327 | cpp |
p02926 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> X(N), Y(N);
for (int i = 0; i < N; i++)
cin >> X[i] >> Y[i];
long long answer = 0;
for (int r = 0; r < 100; r++) {
for (int i = 0; i ... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> X(N), Y(N);
for (int i = 0; i < N; i++)
cin >> X[i] >> Y[i];
long long answer = 0;
for (int r = 0; r < 10; r++) {
for (int i = 0; i <... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 729,910 | 729,911 | u374099594 | cpp |
p02927 | #include <cstdio>
#include <iostream>
using namespace std;
int m, d;
int main() {
scanf("%d%d", &m, &d);
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int d10 = 2; d10 <= d / 10; d10++)
if (i % d10 == 0) {
int d1 = i / d10;
if (d1 >= 2 && d10 * 10 + d1 <= d)
ans++;
}
... | #include <cstdio>
#include <iostream>
using namespace std;
int m, d;
int main() {
scanf("%d%d", &m, &d);
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int d10 = 2; d10 <= d / 10; d10++)
if (i % d10 == 0) {
int d1 = i / d10;
if (d1 >= 2 && d1 <= 9 && d10 * 10 + d1 <= d)
ans++... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 729,930 | 729,931 | u648316846 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10;
int d10 = j / 10;
if (d1 >= 2 && d10 >= 2 && d1 * d10 == m)
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10;
int d10 = j / 10;
if (d1 >= 2 && d10 >= 2 && d1 * d10 == i)
ans++;
}
}
cout << ans << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 729,932 | 729,933 | u528258842 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define For(i, n) for (ll i = 0; i < (n); i++)
#define For1(i, n) for (ll i = 1; i < (n); i++)
#define MOD 1000000007
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main() {
ll d, m, ans = 0;
cin >> m >> d;
For1(i, m + 1) {
For1(j, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define For(i, n) for (ll i = 0; i < (n); i++)
#define For1(i, n) for (ll i = 1; i < (n); i++)
#define MOD 1000000007
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main() {
ll d, m, ans = 0;
cin >> m >> d;
For1(i, m + 1) {
For1(j, ... | [
"expression.operation.binary.add"
] | 729,941 | 729,942 | u813174766 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, i = 0;
cin >> M >> D;
for (int m = 4; m <= M; m++)
for (int d10 = 2; d10 * 10 <= D; d10++)
for (int d1 = 2; d10 * 10 + d1 <= D; d1++)
if (m == d1 * d10)
i++;
cout << i << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D, i = 0;
cin >> M >> D;
for (int m = 4; m <= M; m++)
for (int d10 = 2; d10 * 10 <= D; d10++)
for (int d1 = 2; d10 * 10 + d1 <= D && d1 < 10; d1++)
if (m == d1 * d10)
i++;
cout << i << endl;
} | [
"control_flow.loop.for.condition.change"
] | 729,951 | 729,952 | u306482197 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<long long, long long>
#define ff first
#define ss second
#define ld long double
main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int M, D;
cin >> M >> D;
int ans = 0, cnt = 0;
for (int i = 2; i <= D; i++) {
... | /*#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<long long, long long>
#define ff first
#define ss second
#define ld long double
main(){
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii ... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 729,953 | 729,954 | u827016215 | cpp |
p02927 | #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 m, d;
cin >> m >> d;
int ans = 0;
if (m == 1 || d < 22)
cout << 0 << endl;
else {
for (int i = 2; i <= m; i++) {
for (int j = 22; j <= d... | #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 m, d;
cin >> m >> d;
int ans = 0;
if (m == 1 || d < 22)
cout << 0 << endl;
else {
for (int i = 2; i <= m; i++) {
for (int j = 22; j <= d... | [] | 729,958 | 729,959 | u021657949 | cpp |
p02927 | // Problem: JSC2019 Qual A
// Progress: Working
#include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, m, ans = 0;
cin >> n >> m;
for (ll i = 22; i < m; i++)
if (i % 10 >= 2 && (i / 10) >= 2 && i % 10 *... | // Problem: JSC2019 Qual A
// Progress: Working
#include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, m, ans = 0;
cin >> n >> m;
for (ll i = 22; i <= m; i++)
if (i % 10 >= 2 && (i / 10) >= 2 && i % 10 ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 729,965 | 729,966 | u393558821 | cpp |
p02927 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 4; i <= m; ++i) {
for (int j = 22; j <= d; ++j) {
if (d % 10 <= 1)
continue;
if (i == (j / 10) * (j % 10))
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 4; i <= m; ++i) {
for (int j = 22; j <= d; ++j) {
if (j % 10 <= 1)
continue;
if (i == (j / 10) * (j % 10))
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 729,971 | 729,972 | u754114382 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10;
int d10 = j / 10;
if ((d1 >= 2) && (d10 >= 2) && (d1 * 10 == i)) {
cnt++;
}
}
}
cout << ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10;
int d10 = j / 10;
if ((d1 >= 2) && (d10 >= 2) && (d1 * d10 == i)) {
cnt++;
}
}
}
cout <<... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 729,973 | 729,974 | u729703601 | cpp |
p02927 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#incl... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#incl... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 729,975 | 729,976 | u809967037 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using vpii = vector<pii>;
using vpli = vector<pli>;
using vpll = vector<pll>... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
using vpii = vector<pii>;
using vpli = vector<pli>;
using vpll = vector<pll>... | [
"call.arguments.add"
] | 729,977 | 729,978 | u236658355 | cpp |
p02927 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// #define int long long
// #define double long double
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i < (int)(n); ++i)
#define repeq(i, n) for (int i = 0; i <= (int)(n); ++i)
#define rep1eq(i, n) for (int ... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// #define int long long
// #define double long double
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i < (int)(n); ++i)
#define repeq(i, n) for (int i = 0; i <= (int)(n); ++i)
#define rep1eq(i, n) for (int ... | [
"identifier.change",
"expression.operation.binary.change"
] | 729,981 | 729,982 | u104057163 | cpp |
p02927 | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int res = 0;
int d1;
int d2;
for (int month = ... | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int res = 0;
int d1;
int d2;
for (int month = ... | [] | 729,985 | 729,986 | u583888880 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream> //���炵���̂Œ���
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define Cout(s) cout << s ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream> //���炵���̂Œ���
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define Cout(s) cout << s ... | [
"expression.operation.binary.add"
] | 729,987 | 729,988 | u465760322 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int Ans = 0;
for (int i = 1; i <= M; i++) {
for (int j = 1; j <= D; j++) {
int D10 = D / 10;
int D1 = D - 10 * D10;
if (D10 >= 2 && D1 >= 2 && D10 * D1 == M) {
Ans++;
}
}
}
cout << An... | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int Ans = 0;
for (int i = 1; i <= M; i++) {
for (int j = 1; j <= D; j++) {
int D10 = j / 10;
int D1 = j - 10 * D10;
if (D10 >= 2 && D1 >= 2 && D10 * D1 == i) {
Ans++;
}
}
}
cout << An... | [
"identifier.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 729,989 | 729,990 | u164730704 | cpp |
p02927 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end(... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end(... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 729,991 | 729,992 | u459105164 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
int count = 0;
cin >> m >> d;
for (int i = 1; i <= m; i++) {
for (int j = 2; j <= d; j++) {
for (int k = 2; k <= d; k++) {
if (10 * j + ... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int m, d;
int count = 0;
cin >> m >> d;
for (int i = 1; i <= m; i++) {
for (int j = 2; j <= d; j++) {
for (int k = 2; k < 10; k++) {
if (10 * j + ... | [
"control_flow.loop.for.condition.change"
] | 730,006 | 730,007 | u198469037 | cpp |
p02927 | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
if (D < 22) {
cout << 0 << endl;
} else {
int ans = 0;
for (int i = 22; i < D; i++) {
int d1 = i / 10;
int d2 = i - 10 * d1;
if (d2 < 2)
continue;
if (d1... | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
if (D < 22) {
cout << 0 << endl;
} else {
int ans = 0;
for (int i = 22; i <= D; i++) {
int d1 = i / 10;
int d2 = i % 10;
if (d2 < 2)
continue;
if (d1 * d... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 730,008 | 730,009 | u868132236 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reprev(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
int main() {
int m, d, res, d10, d1;
c... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reprev(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
int main() {
int m, d, res, d10, d1;
c... | [
"expression.operation.binary.add"
] | 730,012 | 730,013 | u430419385 | cpp |
p02927 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
int main() {
long long int M, D;
scanf("%lld%lld", &M, &D);
long long int ans = 0;
for (l... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
int main() {
long long int M, D;
scanf("%lld%lld", &M, &D);
long long int ans = 0;
for (l... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,014 | 730,015 | u401013791 | cpp |
p02927 | #include <bits/stdc++.h>
#define rep(i, m, n) for (int i = m; i < n; i++)
#define fix(n) cout << fixed << setprecision(n)
#define co(n) cout << n << endl
#define all(n) (n).begin(), (n).end()
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
double pi = 3.1415926535;
int main() {
int m, d, a, b;
... | #include <bits/stdc++.h>
#define rep(i, m, n) for (int i = m; i < n; i++)
#define fix(n) cout << fixed << setprecision(n)
#define co(n) cout << n << endl
#define all(n) (n).begin(), (n).end()
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
double pi = 3.1415926535;
int main() {
int m, d, a, b;
... | [] | 730,016 | 730,017 | u558115145 | cpp |
p02927 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin()... | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin()... | [
"expression.operation.binary.add"
] | 730,020 | 730,021 | u526630579 | cpp |
p02927 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 ... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 730,022 | 730,023 | u057611820 | cpp |
p02927 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using na... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using na... | [
"expression.operation.binary.add"
] | 730,024 | 730,025 | u841131859 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
pair<int, int> mul(int n) {
int d1 = n % 10;
int d2 = n / 10;
pair<int, int> p = make_pair(d2, d1);
return p;
}
int main() {
int m;
int d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i < d; i++) {
pair<int, int> p = mul(i);
if (p.first >= 2 ... | #include <bits/stdc++.h>
using namespace std;
pair<int, int> mul(int n) {
int d1 = n % 10;
int d2 = n / 10;
pair<int, int> p = make_pair(d2, d1);
return p;
}
int main() {
int m;
int d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= d; i++) {
pair<int, int> p = mul(i);
if (p.first >= 2... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,030 | 730,031 | u045368371 | cpp |
p02927 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int result = 0;
rep(i, m) rep(j, d) {
if ((j + 1) % 10 < 2 || (j + 1) / 10 < 2)
continue;
if (((j + 1) % 10) * ((j + 1) / 10) == m + 1)
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int result = 0;
rep(i, m) rep(j, d) {
if ((j + 1) % 10 < 2 || (j + 1) / 10 < 2)
continue;
if ((((j + 1) % 10) * ((j + 1) / 10)) == (i + 1))
... | [
"control_flow.branch.if.condition.change"
] | 730,032 | 730,033 | u021358975 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j < d; j++) {
int d1 = j % 10, d10 = j / 10;
if (d1 >= 2 && d10 >= 2) {
if (d1 * d10 == i) {
ans++;
}
}
}
}
c... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= d; j++) {
int d1 = j % 10, d10 = j / 10;
if (d1 >= 2 && d10 >= 2) {
if (d1 * d10 == i) {
ans++;
}
}
}
}
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,038 | 730,039 | u648009244 | cpp |
p02927 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define co(x) cout << x << endl
#define cs(x) cout << x << " "
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define co(x) cout << x << endl
#define cs(x) cout << x << " "
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;... | [
"identifier.change"
] | 730,043 | 730,044 | u984529214 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, d1, d10, answer;
answer = 0;
cin >> m >> d;
for (int i = 0; i < m; i++) {
for (int j = 0; j < d; j++) {
d1 = j % 10;
d10 = j / 10;
if (d1 > 1 && d10 > 1 & i == d1 * d10)
answer++;
}
}
cout << answer << en... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, d1, d10, answer;
answer = 0;
cin >> m >> d;
for (int i = 1; i < m + 1; i++) {
for (int j = 1; j < d + 1; j++) {
d1 = j % 10;
d10 = j / 10;
if (d1 > 1 && d10 > 1 & i == d1 * d10)
answer++;
}
}
cout << answ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 730,045 | 730,046 | u993074316 | cpp |
p02927 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typede... | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typede... | [
"control_flow.branch.if.condition.change"
] | 730,055 | 730,056 | u824337972 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, count = 0;
cin >> m >> d;
if (d < 22 || m < 4) {
cout << 0 << endl;
return 0;
}
for (int j = 4; j <= m; j++) {
for (int i = 22; i <= d; i++) {
int d1 = d % 10, d10 = d / 10;
if (d1 < 2)
continue;
else i... | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d, count = 0;
cin >> m >> d;
if (d < 22 || m < 4) {
cout << 0 << endl;
return 0;
}
for (int j = 4; j <= m; j++) {
for (int i = 22; i <= d; i++) {
int d1 = i % 10, d10 = i / 10;
if (d1 < 2)
continue;
else i... | [
"identifier.change",
"expression.operation.binary.change"
] | 730,066 | 730,067 | u351265848 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= d; j++)
if (m == (j / 10 >= 2 ? j / 10 : 0) * (j % 10 >= 2 ? j % 10 : 0))
ans++;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int ans = 0;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= d; j++)
if (i == (j / 10 >= 2 ? j / 10 : 1000) * (j % 10 >= 2 ? j % 10 : 1000))
ans++;
cout << ans << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 730,068 | 730,069 | u481694065 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int int_len(int n) {
int s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
int int_sum(int n) {
int m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (int i = s - 1; i >= 0; i--)
m += n / ((int)pow(... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int int_len(int n) {
int s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
int int_sum(int n) {
int m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (int i = s - 1; i >= 0; i--)
m += n / ((int)pow(... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,070 | 730,071 | u264265458 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
/*m月d日:d=10*e+f
e>=2 && f>=2 && e*f==m */
int count = 0;
for (int e = 2; e <= D / 10; e++) {
for (int f = 0; e * 10 + f <= D; f++) {
if (e * f <= M)
count++;
}
}
cout << count << endl;
return 0;
}... | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
/*m月d日:d=10*e+f
e>=2 && f>=2 && e*f==m */
int count = 0;
for (int e = 2; e <= D / 10; e++) {
for (int f = 2; e * 10 + f <= D && f <= 9; f++) {
if (e * f <= M)
count++;
}
}
cout << count << endl;
r... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change"
] | 730,077 | 730,078 | u660112829 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
/*m月d日:d=10*e+f
e>=2 && f>=2 && e*f==m */
int count = 0;
for (int e = 2; e <= D / 10; e++) {
for (int f = 1; e * 10 + f <= D; f++) {
if (e * f <= M)
count++;
}
}
cout << count << endl;
return 0;
}... | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
/*m月d日:d=10*e+f
e>=2 && f>=2 && e*f==m */
int count = 0;
for (int e = 2; e <= D / 10; e++) {
for (int f = 2; e * 10 + f <= D && f <= 9; f++) {
if (e * f <= M)
count++;
}
}
cout << count << endl;
r... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change"
] | 730,079 | 730,078 | u660112829 | cpp |
p02927 | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
/*m月d日:d=10*e+f
e>=2 && f>=2 && e*f==m */
int count = 0;
for (int e = 2; e <= D / 10; e++) {
for (int f = 2; e * 10 + f <= D; f++) {
if (e * f <= M)
count++;
}
}
cout << count << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
/*m月d日:d=10*e+f
e>=2 && f>=2 && e*f==m */
int count = 0;
for (int e = 2; e <= D / 10; e++) {
for (int f = 2; e * 10 + f <= D && f <= 9; f++) {
if (e * f <= M)
count++;
}
}
cout << count << endl;
r... | [
"control_flow.loop.for.condition.change"
] | 730,080 | 730,078 | u660112829 | cpp |
p02927 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int answer = 0;
if (D >= 22) {
for (int i = 2; i <= D / 10; i++) {
if (i < D / 10) {
for (int j = 2; j <= 9; j++) {
if (i * j <= M) {
an... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int answer = 0;
if (D >= 22) {
for (int i = 2; i <= D / 10; i++) {
if (i < D / 10) {
for (int j = 2; j <= 9; j++) {
if (i * j <= M) {
an... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 730,085 | 730,086 | u088111798 | cpp |
p02927 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr auto inf = static_cast<ll>(1e18);
template <typename T = ll> inline T in() {
T ret;
cin >> ret;
return ret;
}
template <typename T = ll> inline auto vec2(size_t h, size_t w, T v = T()) {
return vector<v... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr auto inf = static_cast<ll>(1e18);
template <typename T = ll> inline T in() {
T ret;
cin >> ret;
return ret;
}
template <typename T = ll> inline auto vec2(size_t h, size_t w, T v = T()) {
return vector<v... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 730,089 | 730,090 | u388817534 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int counter = 0;
for (int x = 2; x < 9; x++) {
for (int y = 2; y < 9; y++) {
if (10 * x + y <= D && x * y <= M) {
counter++;
}
}
}
cout << counter << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int M, D;
cin >> M >> D;
int counter = 0;
for (int x = 2; x <= 9; x++) {
for (int y = 2; y <= 9; y++) {
if (10 * x + y <= D && x * y <= M) {
counter++;
}
}
}
cout << counter << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 730,093 | 730,094 | u854161810 | cpp |
p02927 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int c = 0;
for (int i = 2; i <= d; i++) {
for (int j = 2; j <= d; j++) {
if (i * j <= m && (10 * i + j) <= d) {
++c;
} else {
break;
}
}
}
cout << c << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, d;
cin >> m >> d;
int c = 0;
for (int i = 2; i <= 9; i++) {
for (int j = 2; j <= 9; j++) {
if (i * j <= m && (10 * i + j) <= d) {
++c;
} else {
break;
}
}
}
cout << c << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 730,095 | 730,096 | u278530069 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.