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 8
values |
|---|---|---|---|---|---|---|---|
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
long long last = x;
for (int i = 0; i < 10; i++) {
last = r * last + d;
cout << last << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
long long last = x;
for (int i = 0; i < 10; i++) {
last = r * last - d;
cout << last << endl;
}
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 849,031 | 849,032 | u553321223 | cpp |
p03036 | #include <algorithm>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define N_MAX (100000)
#define LL_MAX_NUM (1LL... | #include <algorithm>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define N_MAX (100000)
#define LL_MAX_NUM (1LL... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,035 | 849,036 | u221174888 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
long long r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * 2 - d;
cout << x << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
long long r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * r - d;
cout << x << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,049 | 849,050 | u628758223 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * 2 - d;
cout << x << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
long long r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * r - d;
cout << x << endl;
}
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,051 | 849,050 | u628758223 | cpp |
p03036 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <math.h>
#include <string.h>
#include <string>
#include <vector>
#define ll long long
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 11; i++) {
x = r * x - d;
cout ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <math.h>
#include <string.h>
#include <string>
#include <vector>
#define ll long long
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x - d;
cout ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,057 | 849,058 | u020230257 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long r, d, x;
cin >> r >> d >> x;
long long y = 0;
for (long long i = 0; i < 10; i++) {
y = (r * x) - d;
cout << y;
x = y;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long r, d, x;
cin >> r >> d >> x;
long long y = 0;
for (long long i = 0; i < 10; i++) {
y = (r * x) - d;
cout << y << endl;
x = y;
}
return 0;
} | [
"io.output.newline.add"
] | 849,063 | 849,064 | u968285884 | cpp |
p03036 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) vector<v... | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) vector<v... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,068 | 849,069 | u776194115 | cpp |
p03036 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) vector<v... | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) vector<v... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.value.change"
] | 849,070 | 849,069 | u776194115 | cpp |
p03036 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int r, d;
long long int x[11];
cin >> r >> d >> x[0];
for (int i = 1; i < 11; i++) {
x[i] = r * x[i - 1] - d;
}
for (int i = 0; i < 11; i++) {
cout <<... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int r, d;
long long int x[11];
cin >> r >> d >> x[0];
for (int i = 1; i < 11; i++) {
x[i] = r * x[i - 1] - d;
}
for (int i = 1; i < 11; i++) {
cout <<... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 849,071 | 849,072 | u696865277 | cpp |
p03036 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int r, d;
int x[11];
cin >> r >> d >> x[0];
for (int i = 1; i < 11; i++) {
x[i] = r * x[i - 1] - d;
}
for (int i = 0; i < 11; i++) {
cout << x[i] << e... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int r, d;
long long int x[11];
cin >> r >> d >> x[0];
for (int i = 1; i < 11; i++) {
x[i] = r * x[i - 1] - d;
}
for (int i = 1; i < 11; i++) {
cout <<... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 849,073 | 849,072 | u696865277 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
for (int i = 0; i < 10; i++) {
x = x * r - D;
cout << x;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
for (int i = 0; i < 10; i++) {
x = x * r - D;
cout << x << endl;
}
return 0;
}
| [
"io.output.newline.add"
] | 849,074 | 849,075 | u426855695 | cpp |
p03036 | #include "iostream"
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
int xx[11] = {0};
xx[0] = x;
for (int i = 0; i < 11; i++) {
xx[i + 1] = r * xx[i] - d;
cout << xx[i] << endl;
}
} | #include "iostream"
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
int xx[11] = {0};
xx[0] = x;
for (int i = 1; i < 11; i++) {
xx[i] = r * xx[i - 1] - d;
cout << xx[i] << endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.remove",
"assignment.change"
] | 849,078 | 849,079 | u293974951 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, D, x;
long long ans[10];
cin >> r >> D >> x;
ans[0] = r * x - D;
cout << ans[0] << endl;
for (int i = 0; i < 10; i++) {
ans[i + 1] = r * ans[i] - D;
cout << ans[i] << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, D, x;
long long ans[10];
cin >> r >> D >> x;
ans[0] = r * x - D;
cout << ans[0] << endl;
for (int i = 0; i < 9; i++) {
ans[i + 1] = r * ans[i] - D;
cout << ans[i + 1] << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,087 | 849,088 | u710135612 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, x[11];
cin >> r >> d >> x[0];
for (int i = 0; i < 11; i++) {
x[i + 1] = r * x[i] - d;
cout << x[i + 1] << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int r, d, x[11];
cin >> r >> d >> x[0];
for (int i = 0; i < 10; i++) {
x[i + 1] = r * x[i] - d;
cout << x[i + 1] << endl;
}
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,096 | 849,097 | u340494803 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, x, ans;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
ans = r * x - d;
cout << ans << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int r, d, x, ans;
cin >> r >> d >> x;
ans = x;
for (int i = 0; i < 10; i++) {
ans = r * ans - d;
cout << ans << endl;
}
return 0;
}
| [
"assignment.add",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 849,111 | 849,112 | u313043608 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, D, x;
std::cin >> r >> D >> x;
for (int i = 0; i < 10; ++i) {
x = r * x - D;
cout << x;
}
} | #include <iostream>
using namespace std;
int main() {
int r, D, x;
std::cin >> r >> D >> x;
for (int i = 0; i < 10; ++i) {
x = r * x - D;
cout << x << endl;
}
} | [
"io.output.newline.add"
] | 849,116 | 849,117 | u838009496 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, a, i;
cin >> r >> d >> a;
for (i = 0; i < 10; i++) {
a = a * r - d;
cout << a;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, a, i;
cin >> r >> d >> a;
for (i = 0; i < 10; i++) {
a = a * r - d;
cout << a << endl;
}
}
| [
"io.output.newline.add"
] | 849,120 | 849,121 | u016726316 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x, a;
cin >> r >> D >> x;
a = r * x - D;
for (int i = 0; i <= 10; i++) {
cout << a;
a = r * a - D;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x, a;
cin >> r >> D >> x;
a = r * x - D;
for (int i = 1; i <= 10; i++) {
cout << a << endl;
a = r * a - D;
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"io.output.newline.add"
] | 849,126 | 849,127 | u046585946 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x, a;
cin >> r >> D >> x;
a = r * x - D;
for (int i = 1; i <= 10; i++) {
cout << a;
a = r * a - D;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x, a;
cin >> r >> D >> x;
a = r * x - D;
for (int i = 1; i <= 10; i++) {
cout << a << endl;
a = r * a - D;
}
}
| [
"io.output.newline.add"
] | 849,128 | 849,127 | u046585946 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, x, d;
cin >> r >> x >> d;
int before = r * x - d;
cout << before << endl;
for (int i = 1; i < 10; ++i) {
x = r * before - d;
cout << x << endl;
before = x;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, x, d;
cin >> r >> d >> x;
int before = r * x - d;
cout << before << endl;
for (int i = 1; i < 10; ++i) {
x = r * before - d;
cout << x << endl;
before = x;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 849,131 | 849,132 | u676654593 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(10, 0);
x[0] = x0;
for (int i = 0; i < 10 + 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(11, 0);
x[0] = x0;
for (int i = 0; i < 10 + 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| [
"literal.number.change",
"call.arguments.change"
] | 849,133 | 849,134 | u492047031 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(10, 0);
x[0] = x0;
for (int i = 0; i < 10; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(11, 0);
x[0] = x0;
for (int i = 0; i < 10 + 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 849,135 | 849,134 | u492047031 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(10, 0);
x[0] = x0;
for (int i = 0; i < 10 - 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(11, 0);
x[0] = x0;
for (int i = 0; i < 10 + 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| [
"literal.number.change",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,137 | 849,134 | u492047031 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(10, 0);
x[0] = x0;
for (int i = 0; i < 10 - 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10; ++i) {
cout << x[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x0;
cin >> r >> D >> x0;
vector<int> x(11, 0);
x[0] = x0;
for (int i = 0; i < 10 + 1; ++i) {
x[i + 1] = r * x[i] - D;
}
for (int i = 1; i < 10 + 1; ++i) {
cout << x[i] << endl;
}
}
| [
"literal.number.change",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one"
] | 849,138 | 849,134 | u492047031 | cpp |
p03036 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 1; i < 10; i++) {
int ans = r * x - d;
cout << ans << "\n";
x = ans;
}
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
int ans = r * x - d;
cout << ans << "\n";
x = ans;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 849,143 | 849,144 | u725133562 | cpp |
p03036 |
#include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
int cal = x * 2 - d;
x = cal;
cout << cal << endl;
}
} |
#include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
int cal = x * r - d;
x = cal;
cout << cal << endl;
}
} | [
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,149 | 849,150 | u286623856 | cpp |
p03036 |
#include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
int cal = x * 2 - 10;
x = cal;
cout << cal << endl;
}
} |
#include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
int cal = x * r - d;
x = cal;
cout << cal << endl;
}
} | [
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,151 | 849,150 | u286623856 | cpp |
p03036 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
int X[11];
X[0] = x;
for (int i = 1; i < 11; i++) {
X[i] = r * X[i - 1] - D;
}
for (int i = 0; i < 11; i++) {
cout << X[i] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
int X[11];
X[0] = x;
for (int i = 1; i < 11; i++) {
X[i] = r * X[i - 1] - D;
}
for (int i = 1; i < 11; i++) {
cout << X[i] << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 849,154 | 849,155 | u037098269 | cpp |
p03036 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
#define Z class
#define ln cout << '\n'
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
// ASCII... | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
#define Z class
#define ln cout << '\n'
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
// ASCII... | [] | 849,158 | 849,159 | u496074393 | cpp |
p03036 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int r, d;
int n = 9;
vector<int> X(11);
cin >> r >> d >> X[0];
for (int i = 0; i <= n; i++) {
X[i + 1] = r * X[i] - d;
cout << X[i] << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int r, d;
int n = 9;
vector<int> X(11);
cin >> r >> d >> X[0];
for (int i = 0; i <= n; i++) {
X[i + 1] = r * X[i] - d;
cout << X[i + 1] << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 849,162 | 849,163 | u297046168 | cpp |
p03036 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int r, d;
int n = 11;
vector<int> X(n);
cin >> r >> d >> X[0];
for (int i = 0; i <= n; i++) {
X[i + 1] = r * X[i] - d;
cout << X[i] << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int r, d;
int n = 9;
vector<int> X(11);
cin >> r >> d >> X[0];
for (int i = 0; i <= n; i++) {
X[i + 1] = r * X[i] - d;
cout << X[i + 1] << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 849,164 | 849,163 | u297046168 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, D;
cin >> r >> D;
int x[10];
cin >> x[0];
for (int i = 0; i < 10; ++i) {
x[i + 1] = r * x[i] - D;
cout << x[i] << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, D;
cin >> r >> D;
int x[11];
cin >> x[0];
for (int i = 0; i < 10; ++i) {
x[i + 1] = r * x[i] - D;
cout << x[i + 1] << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 849,165 | 849,166 | u318150500 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(ll r, ll D, ll x) {
vector<ll> X(11, 0);
X[0] = x;
for (int i = 0; i < X.size(); ++i) {
X[i + 1] = r * X[i] - D;
}
for (int i = 1; i < X.size(); ++i)
cout << X[i] << endl;
}
int main() {
ll r, D, x;
cin >> r >> D >> x... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(ll r, ll D, ll x) {
vector<ll> X(11, 0);
X[0] = x;
for (int i = 0; i < X.size() - 1; ++i) {
X[i + 1] = r * X[i] - D;
}
for (int i = 1; i < X.size(); ++i)
cout << X[i] << endl;
}
int main() {
ll r, D, x;
cin >> r >> D ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 849,167 | 849,168 | u972398652 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(ll r, ll D, ll x) {
vector<ll> X(11, 0);
X[0] = x;
for (int i = 0; i < X.size(); ++i) {
// cout << r << " " << D << " " << X[i] << endl;
X[i + 1] = r * X[i] - D;
}
for (int i = 1; i < X.size(); ++i)
cout << X[i] << end... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(ll r, ll D, ll x) {
vector<ll> X(11, 0);
X[0] = x;
for (int i = 0; i < X.size() - 1; ++i) {
X[i + 1] = r * X[i] - D;
}
for (int i = 1; i < X.size(); ++i)
cout << X[i] << endl;
}
int main() {
ll r, D, x;
cin >> r >> D ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 849,169 | 849,168 | u972398652 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, D;
int x[15];
cin >> r >> D >> x[0];
for (int i = 0; i < 11; ++i) {
x[i + 1] = r * x[i] - D;
cout << x[i + 1] << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int r, D;
int x[15];
cin >> r >> D >> x[0];
for (int i = 0; i < 10; ++i) {
x[i + 1] = r * x[i] - D;
cout << x[i + 1] << endl;
}
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,170 | 849,171 | u777474133 | cpp |
p03036 | #include <iostream>
using namespace std;
// Coding below.
int main() {
int r, D, x, next;
cin >> r >> D >> x;
next = x;
for (int i = 0; i < 10; i = i + 1) {
next = (next * r) - D;
cout << next;
}
} | #include <iostream>
using namespace std;
// Coding below.
int main() {
int r, D, x, next;
cin >> r >> D >> x;
next = x;
for (int i = 0; i < 10; i = i + 1) {
next = (next * r) - D;
cout << next << endl;
}
} | [
"io.output.newline.add"
] | 849,172 | 849,173 | u901555384 | cpp |
p03036 | #include <array>
#include <iostream>
int main() {
int r;
int D;
std::array<int, 10> x_2000;
std::cin >> r >> D >> x_2000[0];
for (auto i = 0; i < 9; ++i) {
x_2000[i + 1] = r * x_2000[i] - D;
}
for (auto i = 0; i < 10; ++i) {
std::cout << x_2000[i] << std::endl;
}
} | #include <array>
#include <iostream>
int main() {
int r;
int D;
std::array<int, 11> x_2000;
std::cin >> r >> D >> x_2000[0];
for (auto i = 0; i < 10; ++i) {
x_2000[i + 1] = r * x_2000[i] - D;
}
for (auto i = 1; i < 11; ++i) {
std::cout << x_2000[i] << std::endl;
}
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 849,196 | 849,197 | u425547861 | cpp |
p03036 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <queue>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int r, d, x, xx;
cin >> r >> d >> x;
xx = x;
for (int i = 0; i < 10; i++) {
cout <... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <queue>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int r, d, x, xx;
cin >> r >> d >> x;
xx = x;
for (int i = 0; i < 10; i++) {
cout <... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 849,205 | 849,206 | u817014213 | cpp |
p03036 | /*
ID: thanhvq1
LANG: C++14
PROB: namenum
*/
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include <unistd.h>
using namespace std;
//#define int long long
#define double long double
#define vec vector
#define vi vector<int>
#define FZ(n) memset((n), 0, sizeof(n))
#define FMO(n) memset((n), -1, sizeof(n))
#defin... | /*
ID: thanhvq1
LANG: C++14
PROB: namenum
*/
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include <unistd.h>
using namespace std;
//#define int long long
#define double long double
#define vec vector
#define vi vector<int>
#define FZ(n) memset((n), 0, sizeof(n))
#define FMO(n) memset((n), -1, sizeof(n))
#defin... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 849,207 | 849,208 | u210484769 | cpp |
p03036 | #include <iostream>
#include <string>
using namespace std;
int main() {
int r, D, x, i;
cin >> r;
cin >> D;
cin >> x;
for (i = 0; i < 10; i++) {
x = r * x - D;
cout << x;
}
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int r, D, x, i;
cin >> r;
cin >> D;
cin >> x;
for (i = 0; i < 10; i++) {
x = r * x - D;
cout << x << endl;
}
return 0;
}
| [
"io.output.newline.add"
] | 849,213 | 849,214 | u638696958 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, a;
cin >> r >> d >> a;
for (int i = 1; i <= 10; i++) {
a = r * a - d;
cout << a;
}
}
|
#include <iostream>
using namespace std;
int main() {
int r, d, a;
cin >> r >> d >> a;
for (int i = 1; i <= 10; i++) {
a = r * a - d;
cout << a << endl;
}
}
| [
"io.output.newline.add"
] | 849,215 | 849,216 | u093744128 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, X, D;
cin >> r >> X >> D;
for (int i = 0; i < 10; i++) {
X = r * X - D;
cout << X << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int r, X, D;
cin >> r >> D >> X;
for (int i = 0; i < 10; i++) {
X = r * X - D;
cout << X << endl;
}
}
| [
"expression.operation.binary.remove"
] | 849,237 | 849,238 | u559218489 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int r, d, x, m = 0, i;
cin >> r >> d >> x;
for (i = 0; i < 10; i++) {
m = r * x - d;
cout << m;
x = m;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int r, d, x, m = 0, i;
cin >> r >> d >> x;
for (i = 0; i < 10; i++) {
m = r * x - d;
cout << m << endl;
x = m;
}
} | [
"io.output.newline.add"
] | 849,243 | 849,244 | u802406405 | cpp |
p03036 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
long long dp[11];
int r, d, x;
void solve() {
dp[0] = x;
for (int i = 1; i <= 10; i++) {
dp[i] = r * dp[i - 1] - d;
}
for (int i = 0; i <= 10; i++) {
cout << dp[i] << endl;
}
}
int mai... |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
long long dp[11];
int r, d, x;
void solve() {
dp[0] = x;
for (int i = 1; i <= 10; i++) {
dp[i] = r * dp[i - 1] - d;
}
for (int i = 1; i <= 10; i++) {
cout << dp[i] << endl;
}
}
int mai... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 849,247 | 849,248 | u112318601 | cpp |
p03036 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rept(i, a, b)... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rept(i, a, b)... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 849,266 | 849,267 | u569041543 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int e, d, x, y;
cin >> e >> d >> x;
for (int i = 0; i < 10; i++) {
x = e * x - d;
cout << x;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int e, d, x, y;
cin >> e >> d >> x;
for (int i = 0; i < 10; i++) {
x = e * x - d;
cout << x << "\n";
}
}
| [
"io.output.change"
] | 849,271 | 849,272 | u209011781 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long r, d, x;
cin >> r >> d >> x;
long long a[10];
a[0] = x;
for (int i = 1; i < 10; i++) {
a[i] = r * a[i - 1] - d;
}
for (int i = 0; i < 10; i++)
cout << a[i] <... | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long r, d, x;
cin >> r >> d >> x;
long long a[11];
a[0] = x;
for (int i = 1; i < 11; i++) {
a[i] = r * a[i - 1] - d;
}
for (int i = 1; i < 11; i++)
cout << a[i] <... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 849,273 | 849,274 | u435225553 | cpp |
p03036 | // https://atcoder.jp/contests/abc127/tasks/abc127_b
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll... | // https://atcoder.jp/contests/abc127/tasks/abc127_b
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,275 | 849,276 | u858107870 | cpp |
p03036 | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int i, r, d, x, weight;
cin >> r >> d >> x;
for (i = 1; i <= 20; i++) {
x = r * x - d;
cout << x << endl;
}
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int i, r, d, x, weight;
cin >> r >> d >> x;
for (i = 1; i <= 10; i++) {
x = r * x - d;
cout << x << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,279 | 849,280 | u759818763 | cpp |
p03036 | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int i, r, d, x, weight;
cin >> r >> d >> x;
for (i = 1; i <= 20; i++) {
x = r * x - d;
cout << x;
}
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int i, r, d, x, weight;
cin >> r >> d >> x;
for (i = 1; i <= 10; i++) {
x = r * x - d;
cout << x << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"io.output.newline.add"
] | 849,281 | 849,280 | u759818763 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, y;
cin >> r >> D >> y;
vector<int> x(10);
x[0] = y;
for (int i = 0; i < 9; i++) {
x[i + 1] = r * x[i] - D;
}
for (int i = 0; i < 10; i++) {
cout << x[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, y;
cin >> r >> D >> y;
vector<int> x(10);
x[0] = r * y - D;
for (int i = 0; i < 9; i++) {
x[i + 1] = r * x[i] - D;
}
for (int i = 0; i < 10; i++) {
cout << x[i] << endl;
}
}
| [
"assignment.change"
] | 849,303 | 849,304 | u552201227 | cpp |
p03036 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 849,310 | 849,311 | u906208439 | cpp |
p03036 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
const long long N = 1e5 + 17;
ll cnt, lnt, mn = N, mx, a[N], n, m, k, x, y, ans, sum;
pair<ll, ll> pr[N];
vector<ll> v, v2, v3;
map<ll, ll> mp;
bool used[N], t1, t2;
vector<string> sv;
vector<char> vi;
int main() {
cin >> n >> m... | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
const long long N = 1e5 + 17;
ll cnt, lnt, mn = N, mx, a[N], n, m, k, x, y, ans, sum;
pair<ll, ll> pr[N];
vector<ll> v, v2, v3;
map<ll, ll> mp;
bool used[N], t1, t2;
vector<string> sv;
vector<char> vi;
int main() {
cin >> n >> m... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,317 | 849,318 | u361768313 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x + d;
cout << x << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x - d;
cout << x << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 849,319 | 849,320 | u809153881 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define each(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define all(v)... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define each(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define all(v)... | [
"literal.number.change",
"call.arguments.change"
] | 849,323 | 849,324 | u569778242 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main()
{
int r, d, x, s, i;
cin >> r >> d >> x;
cout << r * x - d << endl;
s = r * x - d;
for (i = 2; i <= 10; i++) {
cout << r * s - d << endl;
s = r * x - d;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
int r, d, x, s, i;
cin >> r >> d >> x;
cout << r * x - d << endl;
s = r * x - d;
for (i = 2; i <= 10; i++) {
cout << r * s - d << endl;
s = r * s - d;
}
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 849,329 | 849,330 | u100452936 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, x;
cin >> n >> d >> x;
for (int i = 0; i < d; i++) {
x = x * n - d;
cout << x << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d, x;
cin >> n >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * n - d;
cout << x << endl;
}
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,331 | 849,332 | u265392294 | cpp |
p03036 | #include <stdio.h>
int main() {
int i, r, d, x, xi, ans;
scanf("%d%d%d", &r, &d, &x);
xi = x;
for (i = 1; i <= 10; i++) {
ans = r + xi - d;
printf("%d\n", ans);
xi = ans;
}
return 0;
}
| #include <stdio.h>
int main() {
int i, r, d, x, xi, ans;
scanf("%d%d%d", &r, &d, &x);
xi = x;
for (i = 1; i <= 10; i++) {
ans = r * xi - d;
printf("%d\n", ans);
xi = ans;
}
return 0;
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 849,337 | 849,338 | u632679464 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
int temp;
cin >> a >> b >> c;
temp = c;
for (int cnt = 0; cnt < b; cnt++) {
d = a * temp - b;
temp = d;
cout << d << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
int temp;
cin >> a >> b >> c;
temp = c;
for (int cnt = 0; cnt < 10; cnt++) {
d = a * temp - b;
temp = d;
cout << d << endl;
}
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,339 | 849,340 | u256293517 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
int ans;
for (int i = 0; i < 10; i++) {
ans = r * x - D;
cout << ans;
x = ans;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
int ans;
for (int i = 0; i < 10; i++) {
ans = r * x - D;
cout << ans << "\n";
x = ans;
}
return 0;
}
| [
"io.output.change"
] | 849,346 | 849,347 | u057617112 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
int D;
cin >> D;
int x;
cin >> x;
for (int i = 0; i < 9; i++) {
x = r * x - D;
cout << x << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
int D;
cin >> D;
int x;
cin >> x;
for (int i = 0; i < 10; i++) {
x = r * x - D;
cout << x << endl;
}
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,350 | 849,351 | u799521877 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i < 10; i++) {
a = a * c - b;
cout << a << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i < 10; i++) {
c = a * c - b;
cout << c << endl;
}
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"io.output.change"
] | 849,352 | 849,353 | u418568023 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < d; i++) {
cout << r * x - d << endl;
x = r * x - d;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long r, d, x;
cin >> r >> d >> x;
for (long long i = 0; i < 10; i++) {
cout << r * x - d << endl;
x = r * x - d;
}
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.initializer.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,356 | 849,357 | u655843213 | cpp |
p03036 |
#include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
int d;
cin >> d;
int x;
cin >> x;
for (int i = 1; i <= 10; i++) {
x = r * x - d;
cout << x;
}
return 0;
} |
#include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
int d;
cin >> d;
int x;
cin >> x;
for (int i = 1; i <= 10; i++) {
x = r * x - d;
cout << x << endl;
}
return 0;
} | [
"io.output.newline.add"
] | 849,361 | 849,362 | u196746947 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int x[10], r, d;
cin >> r >> d >> x[0];
for (int i = 1; i < 10; i++) {
x[i] = r * x[i - 1] - d;
cout << x[i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int x[11], r, d;
cin >> r >> d >> x[0];
for (int i = 1; i < 11; i++) {
x[i] = r * x[i - 1] - d;
cout << x[i] << endl;
}
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,363 | 849,364 | u467632860 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int x[9], r, d;
cin >> r >> d >> x[0];
for (int i = 1; i < 9; i++) {
x[i] = r * x[i - 1] - d;
cout << x[i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int x[11], r, d;
cin >> r >> d >> x[0];
for (int i = 1; i < 11; i++) {
x[i] = r * x[i - 1] - d;
cout << x[i] << endl;
}
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,365 | 849,364 | u467632860 | cpp |
p03036 | #include <iostream>
using namespace std;
int x[12];
int main() {
int a, b, c;
cin >> a >> b >> c;
x[0] = a * c - b;
cout << x[0] << endl;
for (int i = 1; i <= 10; i++) {
x[i] = a * x[i - 1] - b;
cout << x[i] << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int x[12];
int main() {
int a, b, c;
cin >> a >> b >> c;
x[0] = a * c - b;
cout << x[0] << endl;
for (int i = 1; i <= 9; i++) {
x[i] = a * x[i - 1] - b;
cout << x[i] << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,366 | 849,367 | u407700771 | cpp |
p03036 | #include <stdio.h>
int cal(int r, int temp, int d) {
int s;
s = r * temp - d;
return s;
}
int main() {
int r, d;
int x2000;
int i, temp;
scanf("%d%d%d", &r, &x2000, &d);
temp = x2000;
for (i = 1; i <= 10; i++) {
temp = cal(r, temp, d);
printf("%d\n", temp);
}
return 0;
}
| #include <stdio.h>
int cal(int r, int temp, int d) {
int s;
s = r * temp - d;
return s;
}
int main() {
int r, d;
int x2000;
int i, temp;
scanf("%d%d%d", &r, &d, &x2000);
temp = x2000;
for (i = 1; i <= 10; i++) {
temp = cal(r, temp, d);
printf("%d\n", temp);
}
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 849,384 | 849,385 | u165785307 | cpp |
p03036 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend()) // vectorの降順ソート
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 1e18
#define MOD 1000000007... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend()) // vectorの降順ソート
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 1e18
#define MOD 1000000007... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 849,399 | 849,400 | u493750228 | cpp |
p03036 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x + d;
cout << x << endl;
}
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x - d;
cout << x << endl;
}
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 849,405 | 849,406 | u959815036 | cpp |
p03036 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
// sort(a, a... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
// sort(a, a... | [
"io.output.newline.add"
] | 849,407 | 849,408 | u499009346 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x[100];
cin >> r >> D >> x[0];
for (int i = 0; i < 9; i++) {
x[i + 1] = r * x[i] - D;
cout << x[i + 1] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x[100];
cin >> r >> D >> x[0];
for (int i = 0; i < 10; i++) {
x[i + 1] = r * x[i] - D;
cout << x[i + 1] << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,411 | 849,412 | u818818531 | cpp |
p03036 | #include <algorithm>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef stack<int> IntStack;
typedef queue<int> IntQueue;
const double pi = 3.141592653589793;
int char_to_int... | #include <algorithm>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef stack<int> IntStack;
typedef queue<int> IntQueue;
const double pi = 3.141592653589793;
int char_to_int... | [
"io.output.newline.add"
] | 849,417 | 849,418 | u397037010 | cpp |
p03036 | #include <algorithm>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef stack<int> IntStack;
typedef queue<int> IntQueue;
const double pi = 3.141592653589793;
int char_to_int... | #include <algorithm>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef stack<int> IntStack;
typedef queue<int> IntQueue;
const double pi = 3.141592653589793;
int char_to_int... | [
"variable_declaration.type.widen.change",
"io.output.newline.add"
] | 849,419 | 849,418 | u397037010 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef long long LL;
typedef pair<long, long> PLL;
// container util
//--------... | #include <bits/stdc++.h>
using namespace std;
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef long long LL;
typedef pair<long, long> PLL;
// container util
//--------... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,420 | 849,421 | u771306245 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")"... | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")"... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,426 | 849,427 | u293764826 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, s;
cin >> r >> d >> s;
for (int i = 1; i <= 10; i++) {
s = 2 * s - d;
cout << s << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, s;
cin >> r >> d >> s;
for (int i = 1; i <= 10; i++) {
s = r * s - d;
cout << s << endl;
}
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 849,430 | 849,431 | u410878763 | cpp |
p03036 | #include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * r - d;
cout << x;
}
} | #include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = x * r - d;
cout << x << endl;
}
} | [
"io.output.newline.add"
] | 849,434 | 849,435 | u225056035 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
vector<int> X(11);
X.at(0) = x;
for (int i = 0; i < 11; i++) {
X.at(i + 1) = r * X.at(i) - D;
}
for (int i = 1; i < 11; i++) {
cout << X.at(i) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, D, x;
cin >> r >> D >> x;
vector<int> X(11);
X.at(0) = x;
for (int i = 0; i < 10; i++) {
X.at(i + 1) = r * X.at(i) - D;
}
for (int i = 1; i < 11; i++) {
cout << X.at(i) << endl;
}
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 849,436 | 849,437 | u028061225 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long r, D, x;
cin >> r >> D >> x;
for (int i = 0; i < 10; i++) {
x = r * x - D;
cout << x;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long r, D, x;
cin >> r >> D >> x;
for (int i = 0; i < 10; i++) {
x = r * x - D;
cout << x << endl;
;
}
return 0;
} | [
"io.output.newline.add"
] | 849,441 | 849,442 | u898331860 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int kari = c;
for (int i = 0; i < 10; i++) {
kari = kari * a - b;
cout << c << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int kari = c;
for (int i = 0; i < 10; i++) {
kari = kari * a - b;
cout << kari << endl;
}
} | [
"identifier.change",
"io.output.change"
] | 849,443 | 849,444 | u578806044 | cpp |
p03036 | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int mod = pow(10, 9) + 7;
// const int mod = 998244353;
// const int mod = ;
const int INF = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvwxyz";
template <class T> bool chmin(T &a, T b) {
... | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int mod = pow(10, 9) + 7;
// const int mod = 998244353;
// const int mod = ;
const int INF = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvwxyz";
template <class T> bool chmin(T &a, T b) {
... | [
"expression.operation.binary.add"
] | 849,445 | 849,446 | u811472478 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, x, i;
cin >> r >> x >> d;
for (i = 0; i < 10; i++) {
x = r * x - d;
cout << x << '\n';
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, d, x, i;
cin >> r >> d >> x;
for (i = 0; i < 10; i++) {
x = r * x - d;
cout << x << '\n';
}
return 0;
} | [
"expression.operation.binary.remove"
] | 849,447 | 849,448 | u058348416 | cpp |
p03036 | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x - d;
cout << x;
}
} | #include <iostream>
using namespace std;
int main() {
int r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < 10; i++) {
x = r * x - d;
cout << x << endl;
}
} | [
"io.output.newline.add"
] | 849,449 | 849,450 | u879036323 | cpp |
p03036 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int r, d, x[10];
cin >> r >> d >> x[0];
for (int i = 1; i < 10; i++) {
x[i] = (r * x[i - 1]) - d;
cout << x[i] << endl;
}
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int r, d, x[11];
cin >> r >> d >> x[0];
for (int i = 1; i <= 10; i++) {
x[i] = (r * x[i - 1]) - d;
cout << x[i] << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 849,453 | 849,452 | u564755644 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
ll r, d, x;
cin >> r >> d >> x;
ll ans[x];
ans[0] = r * x - d;
for (int i = 1; i < x; i++) {
ans[i] = r * ans[i - 1] - d;
}
for (int i = 0; i < 10; i++) {
cout << ans[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
ll r, d, x;
cin >> r >> d >> x;
ll ans[100];
ans[0] = r * x - d;
for (int i = 1; i < 11; i++) {
ans[i] = r * ans[i - 1] - d;
}
for (int i = 0; i < 10; i++) {
cout << ans[i] << endl;
}
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,456 | 849,455 | u876784108 | cpp |
p03036 | #include <stdio.h>
int main(void) {
int a, b, c;
int hako[10000];
int ans = 0;
int i, j;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
int box = c;
for (i = 0; i < b; i++) {
ans = a * box - b;
box = ans;
printf("%d\n", ans);
}
return 0;
} | #include <stdio.h>
int main(void) {
int a, b, c;
int hako[10000];
int ans = 0;
int i, j;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
int box = c;
for (i = 0; i < 10; i++) {
ans = a * box - b;
box = ans;
printf("%d\n", ans);
}
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,465 | 849,466 | u015875086 | cpp |
p03036 | #include <bits/stdc++.h>
using namespace std;
int main() {
/*long long a, b, c, n;
string s;
cin >> a, b;
if (a <= 12){
cout << b / 2 << endl;
}else{
cout << b;
}*/
long long r, d, x;
cin >> r >> d >> x;
for (int i = 0; i < d; i++) {
cout << x * r - d << endl;
x = x * r - d;
}... | #include <bits/stdc++.h>
using namespace std;
int main() {
/*
long long a, b, c, n;
string s;
cin >> a, b;
if (a <= 12 && 5 < a){
cout << b / 2 << endl;
return 0;
}else{
cout << b;
return 0;
}
cout << 0 << endl;
*/
long long r, d, x;
cin >> r >> d >> x;
for (int i ... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 849,489 | 849,490 | u053227023 | cpp |
p03036 | #include <algorithm>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
#define int long long
int inf = (1LL << 62);
using namespace std... | #include <algorithm>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
#define int long long
int inf = (1LL << 62);
using namespace std... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 849,496 | 849,497 | u179987763 | cpp |
p03036 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a, b) for (int(i) = (a); i < (b); ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a, b) for (int(i) = (a); i < (b); ... | [
"literal.number.change",
"assignment.variable.change",
"call.arguments.change"
] | 849,498 | 849,499 | u080318287 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
int l = 1, r = n;
for (int i = 0; i < m; i++) {
int il, ir;
cin >> il >> ir;
l = max(l, il);
r = min(r, ir);
}
cout << r - l + 1 << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
int l = 1, r = n;
for (int i = 0; i < m; i++) {
int il, ir;
cin >> il >> ir;
l = max(l, il);
r = min(r, ir);
}
cout << max(0, r - l + 1) << "\n";
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 849,511 | 849,512 | u288035794 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long M, std::vector<long long> L,
std::vector<long long> R) {
long long maxL = *max_element(L.begin(), L.end());
long long minR = *min_element(R.begin(), R.end());
cout << minR - maxL + 1 << endl;
}
int main() {
long long N;... | #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long M, std::vector<long long> L,
std::vector<long long> R) {
long long maxL = *max_element(L.begin(), L.end());
long long minR = *min_element(R.begin(), R.end());
cout << max(0LL, minR - maxL + 1) << endl;
}
int main() {
lo... | [
"call.add",
"call.arguments.change"
] | 849,525 | 849,526 | u972398652 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++)
cin >> l.at(i) >> r.at(i);
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int c;
c = r.begin() - l.end() + 1;
if (c < 0)
c = 0;
cout << c << endl;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++)
cin >> l.at(i) >> r.at(i);
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int c;
c = r.at(0) - l.at(m - 1) + 1;
if (c < 0)
c = 0;
cout << c << endl... | [
"assignment.value.change",
"call.function.change",
"expression.operation.binary.change",
"call.arguments.change",
"assignment.change"
] | 849,539 | 849,540 | u011837431 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++)
cin >> l.at(i) >> r.at(i);
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int c;
c = r.at(m - 1) - l.at(1) + 1;
if (c < 0)
c = 0;
cout << c << endl... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++)
cin >> l.at(i) >> r.at(i);
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int c;
c = r.at(0) - l.at(m - 1) + 1;
if (c < 0)
c = 0;
cout << c << endl... | [
"assignment.change",
"expression.operation.binary.remove"
] | 849,541 | 849,540 | u011837431 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int maxL = 1, minR = n;
for (int i = 0; i < m; i++) {
int L, R;
cin >> L >> R;
maxL = max(maxL, L);
minR = min(minR, R);
}
cout << (minR > maxL ? 0 : (minR - maxL) + 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int maxL = 1, minR = n;
for (int i = 0; i < m; i++) {
int L, R;
cin >> L >> R;
maxL = max(maxL, L);
minR = min(minR, R);
}
cout << (minR < maxL ? 0 : (minR - maxL) + 1) << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 849,548 | 849,549 | u875139518 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first == b.first) {
if (a.second <= b.second)
return true;
else
return false;
}
if (a.first > b.first)
return true;
else
return false;... | #include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first == b.first) {
if (a.second <= b.second)
return true;
else
return false;
}
if (a.first > b.first)
return true;
else
return false;... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 849,558 | 849,559 | u178665131 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first == b.first) {
if (a.second <= b.second)
return true;
else
return false;
}
if (a.first > b.first)
return true;
else
return false;... | #include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first == b.first) {
if (a.second <= b.second)
return true;
else
return false;
}
if (a.first > b.first)
return true;
else
return false;... | [
"call.add",
"call.arguments.change"
] | 849,560 | 849,559 | u178665131 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
int l, r;
int l_max = 0;
int r_min = n - 1;
rep(i, m) {
cin >> l >> r;
l--;
r--;
l_max = max(l, l_max);
r_min = min(r, r_min);
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
int l, r;
int l_max = 0;
int r_min = n - 1;
rep(i, m) {
cin >> l >> r;
l--;
r--;
l_max = max(l, l_max);
r_min = min(r, r_min);
... | [
"call.add",
"call.arguments.add"
] | 849,565 | 849,566 | u869009830 | cpp |
p03037 | #include <cmath>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int lmax = 0;
int rmin = 1000000;
rep(i, m) {
int l, r;
cin >> l >> r;
lmax = max(lmax, l);
rmin = min(rmin, r);
}
int ans = rmin... | #include <cmath>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int lmax = 0;
int rmin = 1000000;
rep(i, m) {
int l, r;
cin >> l >> r;
lmax = max(lmax, l);
rmin = min(rmin, r);
}
int ans = max(... | [
"call.add",
"call.arguments.change"
] | 849,573 | 849,574 | u622070196 | cpp |
p03037 | #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 N, M;
cin >> N >> M;
vector<int> L(M), R(M);
rep(i, M) cin >> L.at(i) >> R.at(i);
sort(L.begin(), L.end(), greater<int>());
sort(R.begin(), R.end())... | #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 N, M;
cin >> N >> M;
vector<int> L(M), R(M);
rep(i, M) cin >> L.at(i) >> R.at(i);
sort(L.begin(), L.end(), greater<int>());
sort(R.begin(), R.end())... | [
"call.arguments.change"
] | 849,593 | 849,594 | u097161601 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.