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 |
|---|---|---|---|---|---|---|---|
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c) << '\n';
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> b >> a >> c;
cout << min(a / b, c) << '\n';
}
| [
"expression.operation.binary.remove"
] | 913,472 | 913,473 | u434765267 | cpp |
p03105 | #include <iostream>
using std::cin;
using std::cout;
int a, b, c;
auto main() -> int {
cin >> a >> b >> c;
cout << ((a * c) >= b ? c : b / a) << '\n';
return 0;
}
| #include <iostream>
using std::cin;
using std::cout;
int a, b, c;
auto main() -> int {
cin >> a >> b >> c;
cout << ((a * c) <= b ? c : b / a) << '\n';
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 913,484 | 913,485 | u604446158 | cpp |
p03105 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int inf = 2147483647, dx[] = {-1, 0, 1, 0},
dy[] = {0, -1, 0, 1}; // 上 左 下 右
const int N = 100005, M = 1000005, mod = 1000000007;
const long long llinf = 9223372036854775807ll;
int a, b, c;
int main() {
cin >> a >> b >> c;
cout << max(b / a, c);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int inf = 2147483647, dx[] = {-1, 0, 1, 0},
dy[] = {0, -1, 0, 1}; // 上 左 下 右
const int N = 100005, M = 1000005, mod = 1000000007;
const long long llinf = 9223372036854775807ll;
int a, b, c;
int main() {
cin >> a >> b >> c;
cout << min(b / a, c);
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,488 | 913,489 | u965118468 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a > c)
cout << b / a;
else
cout << c;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a < c)
cout << b / a;
else
cout << c;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,496 | 913,497 | u662665711 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C < B) {
cout << C << endl;
} else {
cout << B % A << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C <= B) {
cout << C << endl;
} else {
cout << B / A << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operator.arithmetic.change",
"io.output.change"
] | 913,504 | 913,505 | u676198776 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define int long long
using namespace std;
signed main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c, b / a) << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define int long long
using namespace std;
signed main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,531 | 913,532 | u141968173 | cpp |
p03105 | #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c);
return 0;
}
| #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c);
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,533 | 913,534 | u006425112 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C >= B) {
cout << C << endl;
} else {
cout << B / A << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C <= B) {
cout << C << endl;
} else {
cout << B / A << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,551 | 913,552 | u033620890 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int ans = A / B;
if (ans > C)
ans = C;
cout << ans;
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int ans = B / A;
if (ans > C)
ans = C;
cout << ans;
} | [
"expression.operation.binary.remove"
] | 913,558 | 913,559 | u570417673 | cpp |
p03105 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << (B / A > C ? B / A : C) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << (B / A > C ? C : B / A) << endl;
return 0;
} | [] | 913,562 | 913,564 | u180345531 | cpp |
p03105 | #include <iostream>
#include <stdio.h>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
if (b < a * c) {
ans = b / a;
} else {
ans = a * c;
}
cout << ans << endl;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
if (b < a * c) {
ans = b / a;
} else {
ans = c;
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 913,582 | 913,584 | u231282396 | cpp |
p03105 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string str;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, a / b) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string str;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,618 | 913,620 | u780950519 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using P = pair<int, int>;
using PL = pair<ll, ll>;
using vp = vector<P>;
const int INF = 1 << 30, MOD = 1000000007;
const ll LINF = 1ll << 60;
#define _ol3(_1, _2, _3, name, ...) name
#define _rep(i, n) _repi(i, 0, n)
#define _repi(i, a, b) for (int i = a, i##_l = (b); i < i##_l; ++i)
#define REP(...) _ol3(__VA_ARGS__, _repi, _rep, )(__VA_ARGS__)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define REPA(i, v) REP(i, v.size())
#define all(v) (v).begin(), (v).end()
#define bit(n) (1ll << (n))
#define clamp(n, mi, ma) max(min(n, ma), mi)
#define uniq(v) \
sort(all(v)); \
v.erase(unique(all(v)), v.end())
#define pb push_back
#define F first
#define S second
#define endl '\n'
#ifndef LOCAL
struct ostdmy {
template <class T> ostdmy &operator<<(const T &t) { return *this; }
};
ostdmy cer_;
#define cerr cer_
#endif
#define cho(n, a, b) cout << ((n) ? a : b) << endl
#define YES(n) cho(n, "YES", "NO")
#define Yes(n) cho(n, "Yes", "No")
#define Poss(n) cho(n, "Possible", "Impossible")
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
for (const T &i : v)
o << i << ' ';
return o;
}
template <class T> istream &operator>>(istream &i, vector<T> &v) {
for (T &j : v)
i >> j;
return i;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
return o << p.F << ' ' << p.S;
}
template <class T, class U> ostream &operator>>(istream &i, pair<T, U> &p) {
return i >> p.F >> p.S;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &v) {
for (const T &i : v)
o << i << ' ';
return o;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int a, b, c;
cin >> a >> b >> c;
cout << min(c, a / b) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using P = pair<int, int>;
using PL = pair<ll, ll>;
using vp = vector<P>;
const int INF = 1 << 30, MOD = 1000000007;
const ll LINF = 1ll << 60;
#define _ol3(_1, _2, _3, name, ...) name
#define _rep(i, n) _repi(i, 0, n)
#define _repi(i, a, b) for (int i = a, i##_l = (b); i < i##_l; ++i)
#define REP(...) _ol3(__VA_ARGS__, _repi, _rep, )(__VA_ARGS__)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define REPA(i, v) REP(i, v.size())
#define all(v) (v).begin(), (v).end()
#define bit(n) (1ll << (n))
#define clamp(n, mi, ma) max(min(n, ma), mi)
#define uniq(v) \
sort(all(v)); \
v.erase(unique(all(v)), v.end())
#define pb push_back
#define F first
#define S second
#define endl '\n'
#ifndef LOCAL
struct ostdmy {
template <class T> ostdmy &operator<<(const T &t) { return *this; }
};
ostdmy cer_;
#define cerr cer_
#endif
#define cho(n, a, b) cout << ((n) ? a : b) << endl
#define YES(n) cho(n, "YES", "NO")
#define Yes(n) cho(n, "Yes", "No")
#define Poss(n) cho(n, "Possible", "Impossible")
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
for (const T &i : v)
o << i << ' ';
return o;
}
template <class T> istream &operator>>(istream &i, vector<T> &v) {
for (T &j : v)
i >> j;
return i;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
return o << p.F << ' ' << p.S;
}
template <class T, class U> ostream &operator>>(istream &i, pair<T, U> &p) {
return i >> p.F >> p.S;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &v) {
for (const T &i : v)
o << i << ' ';
return o;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 913,633 | 913,637 | u502709453 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
int num = a / b;
if (num < c)
cout << num;
else
cout << c;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
int num = b / a;
if (num < c)
cout << num;
else
cout << c;
} | [
"expression.operation.binary.remove"
] | 913,679 | 913,681 | u901678655 | cpp |
p03105 | #include <iostream>
using namespace std;
int main(void) {
int A, B, C;
cin >> A >> B >> C;
cout << ((C > B / A) ? C : B / A) << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
int A, B, C;
cin >> A >> B >> C;
cout << ((C < B / A) ? C : B / A) << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 913,695 | 913,697 | u843830192 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b / a, c);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c);
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,699 | 913,701 | u436364432 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c;
d = b / a;
if (d >= c) {
cout << c << "\n";
} else if (d < c) {
cout << b << "\n";
}
} | #include <iostream>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c;
d = b / a;
if (d >= c) {
cout << c << "\n";
} else if (d < c) {
cout << d << "\n";
}
} | [
"identifier.change",
"io.output.change"
] | 913,734 | 913,736 | u134229255 | cpp |
p03105 | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v)
out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 200010
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c) << endl;
return 0;
}
| #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v)
out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 200010
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,738 | 913,741 | u378419207 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
main() {
int A, B, C;
int cnt;
cin >> A >> B >> C;
cnt = A / B;
if (cnt < C)
cout << cnt;
else
cout << C;
} | #include <bits/stdc++.h>
using namespace std;
main() {
int A, B, C;
int cnt;
cin >> A >> B >> C;
cnt = B / A;
if (cnt < C)
cout << cnt;
else
cout << C;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 913,742 | 913,744 | u610206065 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C >= B) {
cout << B / C << endl;
} else {
cout << C << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C >= B) {
cout << B / A << endl;
} else {
cout << C << endl;
}
}
| [
"identifier.change",
"io.output.change"
] | 913,752 | 913,754 | u938317342 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C > B) {
cout << B / A << endl;
} else {
cout << A * C << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C >= B) {
cout << B / A << endl;
} else {
cout << C << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 913,756 | 913,754 | u938317342 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C >= B) {
cout << B / A << endl;
} else {
cout << A * C << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * C >= B) {
cout << B / A << endl;
} else {
cout << C << endl;
}
}
| [
"expression.operation.binary.remove"
] | 913,758 | 913,754 | u938317342 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c) << endl;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
} | [
"expression.operation.binary.remove"
] | 913,566 | 913,570 | u859897687 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <vector>
#define REP(i, n) for (int i = 0; (i) < (n); ++(i))
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
int d = b / a;
cout << max(d, c) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <vector>
#define REP(i, n) for (int i = 0; (i) < (n); ++(i))
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
int d = b / a;
cout << min(d, c) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,573 | 913,576 | u697232864 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
b /= a;
if (b > c)
;
b = c;
cout << b << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
b /= a;
if (b > c) {
b = c;
}
cout << b << endl;
} | [] | 913,579 | 913,581 | u618604643 | cpp |
p03105 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
int main() {
ll a, b, c;
cin >> a >> b >> c;
cout << max(c, b / a) << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
int main() {
ll a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,597 | 913,600 | u372550522 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
REP(WW, n) cerr << v[WW] << ' '; \
cerr << endl << endl; \
}
#define SHOW2d(v, WW, HH) \
{ \
REP(W_, WW) { \
REP(H_, HH) cerr << v[W_][H_] << ' '; \
cerr << endl; \
} \
cerr << endl; \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
REP(WW, n) cerr << v[WW] << ' '; \
cerr << endl << endl; \
}
#define SHOW2d(v, WW, HH) \
{ \
REP(W_, WW) { \
REP(H_, HH) cerr << v[W_][H_] << ' '; \
cerr << endl; \
} \
cerr << endl; \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,609 | 913,611 | u382880969 | cpp |
p03105 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a <= c) {
cout << a / b << endl;
} else if (c < b / a) {
cout << c << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a <= c) {
cout << b / a << endl;
} else if (c < b / a) {
cout << c << endl;
}
return 0;
} | [
"expression.operation.binary.remove"
] | 913,653 | 913,655 | u352296732 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << (a * c <= b ? a : b / a) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << (a * c <= b ? c : b / a) << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 913,666 | 913,668 | u274962354 | cpp |
p03105 | #include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >= C) {
cout << C << endl;
}
else if (B / A <= C) {
cout << A << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >= C) {
cout << C << endl;
}
else if (B / A <= C) {
cout << B / A << endl;
}
return 0;
} | [
"expression.operation.binary.add"
] | 913,684 | 913,686 | u842842118 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >> C) {
cout << B;
} else {
cout << C;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((B / A) < C) {
cout << B / A;
} else {
cout << C;
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 913,713 | 913,715 | u056033056 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define str string
ll MOD = 1000000007, INFL = 1ll << 60, INF = 1 << 30;
ll A[10000000] = {}, X[1000000] = {};
ll aiti[10000];
int dy[] = {0, 0, 1, -1}, dx[] = {1, -1, 0, 0};
vector<ll> v;
ll a = 0, b = 0, c = 0, n = 0, sum = 0, max = INF;
str S;
int ans = 0;
int findDigits(int n) {
int i = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
i++;
}
return i;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// Code Line
cin >> a >> b >> c;
cout << min(b / a, c / a) << endl;
// Code Line
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define str string
ll MOD = 1000000007, INFL = 1ll << 60, INF = 1 << 30;
ll A[10000000] = {}, X[1000000] = {};
ll aiti[10000];
int dy[] = {0, 0, 1, -1}, dx[] = {1, -1, 0, 0};
vector<ll> v;
ll a = 0, b = 0, c = 0, n = 0, sum = 0, max = INF;
str S;
int ans = 0;
int findDigits(int n) {
int i = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
i++;
}
return i;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// Code Line
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
// Code Line
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,759 | 913,762 | u109792330 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A > C)
cout << C << endl;
else if (B / A < C)
cout << B / A << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >= C)
cout << C << endl;
else if (B / A < C)
cout << B / A << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,773 | 913,774 | u102871988 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A > C)
cout << C << endl;
else if (B / A < C)
cout << B / A << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >= C)
cout << C << endl;
else if (B / A < C)
cout << B / A << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,775 | 913,774 | u102871988 | cpp |
p03105 | #include <bits/stdc++.h> //atcoder.120.a
using namespace std;
int main() {
int a, b, c, n;
cin >> a >> b >> c;
n = b / a;
if (b > c)
cout << c;
else
cout << n;
return 0;
} | #include <bits/stdc++.h> //atcoder.120.a
using namespace std;
int main() {
int a, b, c, n;
cin >> a >> b >> c;
n = b / a;
if (n > c)
cout << c;
else
cout << n;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 913,782 | 913,783 | u014014258 | cpp |
p03105 | #include <stdio.h>
typedef long long ll;
using namespace std;
int main(void) {
ll i, j, k, a, b, c, n, m;
scanf("%lld%lld%lld", &a, &b, &c);
printf("%lld", b / a < c ? c : b / a);
return 0;
} | #include <stdio.h>
typedef long long ll;
using namespace std;
int main(void) {
ll i, j, k, a, b, c, n, m;
scanf("%lld%lld%lld", &a, &b, &c);
printf("%lld", b / a > c ? c : b / a);
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 913,796 | 913,797 | u440920318 | cpp |
p03105 | #include <algorithm>
#include <iostream>
using lint = int64_t;
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << min(A / B, C) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
using lint = int64_t;
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << min(B / A, C) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,798 | 913,799 | u021423660 | cpp |
p03105 | #include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(int(B / A), C) << endl;
}
| #include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << min(int(B / A), C) << endl;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,800 | 913,801 | u601256797 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int main() {
// cout.precision(10);
int A, B, C;
cin >> A >> B >> C;
cout << min(C, A / B) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int main() {
// cout.precision(10);
int A, B, C;
cin >> A >> B >> C;
cout << min(C, B / A) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,804 | 913,805 | u980655160 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define N 200005
ll mod = 998244353;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
ll powermodm(ll x, ll n, ll M) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
ll power(ll _a, ll _b) {
ll _r = 1;
while (_b) {
if (_b % 2 == 1)
_r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
ll gcd(ll a, ll b) {
while (a && b)
a > b ? a %= b : b %= a;
return a + b;
}
ll lcm(ll a, ll b) { return (max(a, b) / gcd(a, b)) * min(a, b); }
int main() {
fast;
ll a, b, c;
cin >> a >> b >> c;
ll x = b / a;
cout << max(x, c) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define N 200005
ll mod = 998244353;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
ll powermodm(ll x, ll n, ll M) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
ll power(ll _a, ll _b) {
ll _r = 1;
while (_b) {
if (_b % 2 == 1)
_r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
ll gcd(ll a, ll b) {
while (a && b)
a > b ? a %= b : b %= a;
return a + b;
}
ll lcm(ll a, ll b) { return (max(a, b) / gcd(a, b)) * min(a, b); }
int main() {
fast;
ll a, b, c;
cin >> a >> b >> c;
ll x = b / a;
cout << min(x, c) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,806 | 913,807 | u043829256 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(int(B / A), C) << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << min(int(B / A), C) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,808 | 913,809 | u981068718 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(int(A / B), C) << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << min(int(B / A), C) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"expression.operation.binary.remove"
] | 913,810 | 913,809 | u981068718 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
#define REP(n) for (LL i = 0; i < (n); i++)
#define COUT(val) cout << (val) << endl
#define CIN(val) cin >> (val)
#define SORT(vec) sort(vec.begin(), vec.end())
#define SORT_GRE(vec) sort(vec.begin(), vec.end(), greater<LL>())
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c >= b) {
cout << c << endl;
} else {
cout << b / a << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
#define REP(n) for (LL i = 0; i < (n); i++)
#define COUT(val) cout << (val) << endl
#define CIN(val) cin >> (val)
#define SORT(vec) sort(vec.begin(), vec.end())
#define SORT_GRE(vec) sort(vec.begin(), vec.end(), greater<LL>())
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c <= b) {
cout << c << endl;
} else {
cout << b / a << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,815 | 913,816 | u319491032 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c) {
cout << c << endl;
} else if (b / a < c) {
cout << b % a << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c) {
cout << c << endl;
} else if (b / a < c) {
cout << b / a << endl;
}
return 0;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 913,821 | 913,822 | u534015096 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b % a >= c) {
cout << c << endl;
} else if (b % a < c) {
cout << b % a << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c) {
cout << c << endl;
} else if (b / a < c) {
cout << b / a << endl;
}
return 0;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 913,823 | 913,822 | u534015096 | cpp |
p03105 | #include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >= 4)
cout << "4";
else
cout << B / A;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B / A >= C)
cout << C;
else
cout << B / A;
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 913,838 | 913,839 | u668836563 | cpp |
p03105 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define sz(c) ((int)(c).size())
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
// const int MAX=;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(C, B / A) << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define sz(c) ((int)(c).size())
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
// const int MAX=;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << min(C, B / A) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,844 | 913,845 | u228214259 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d;
d = b / a;
if (a < d) {
cout << c << endl;
} else
cout << d << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d;
d = b / a;
if (c < d) {
cout << c << endl;
} else
cout << d << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 913,846 | 913,847 | u511379665 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d;
d = b / a;
if (a < d) {
cout << a << endl;
} else
cout << d << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d;
d = b / a;
if (c < d) {
cout << c << endl;
} else
cout << d << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 913,848 | 913,847 | u511379665 | cpp |
p03105 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, c;
cin >> a >> b >> c;
cout << max(c, b / a) << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 913,853 | 913,854 | u499373855 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a <= c)
cout << c;
else
cout << b / a;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c)
cout << c;
else
cout << b / a;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,859 | 913,860 | u518383459 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c;
d = b / a;
if (d > c) {
cout << c << endl;
} else if (c > d) {
cout << d << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c;
d = b / a;
if (d > c) {
cout << c << endl;
} else if (c >= d) {
cout << d << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,863 | 913,864 | u455602089 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c)
cout << c;
if (b / c < c)
cout << b / a;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c)
cout << c;
if (b / a < c)
cout << b / a;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 913,867 | 913,868 | u194193990 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b - a * 4 > 0) {
cout << c << endl;
} else {
cout << b / a << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((b - a * c) > 0) {
cout << c << endl;
} else {
cout << b / a << endl;
}
}
| [
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove"
] | 913,869 | 913,870 | u560135121 | cpp |
p03105 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <vector>
//#include "boost/variant.hpp"
// #include "bits/stdc++.h"
using namespace std;
#define rep(i, N, M) for (ll i = N, i##_len = (M); i < i##_len; ++i)
#define rep_skip(i, N, M, ...) \
for (ll i = N, i##_len = (M); i < i##_len; i += (skip))
#define rrep(i, N, M) for (ll i = (M)-1, i##_len = (N - 1); i > i##_len; --i)
#define pb push_back
typedef pair<double, double> pd;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef tuple<ll, ll, ll> tll;
typedef tuple<ll, ll, ll, ll> tll4;
typedef tuple<ll, ll, ll, ll, ll> tll5;
typedef tuple<ll, ll, ll, ll, ll, ll> tll6;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template <typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define vec(a) vector<a>
#define perm(c) \
sort(all(c)); \
for (bool c##perm = 1; c##perm; c##perm = next_permutation(all(c)))
template <typename T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <typename T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
vll seq(ll i, ll j) {
vll res(j - i);
rep(k, i, j) res[k] = i + k;
return res;
}
constexpr ll POW_(ll n, ll m) {
ll res = 1;
rep(i, 0, m) { res *= n; }
return res;
}
template <int mod = 0> constexpr ll POW(ll x, ll n) {
if (x == 2) {
return (1LL << n) % mod;
}
if (n == 0)
return 1;
if (n == 1)
return x % mod;
if (n % 2 == 0)
return POW_(POW<mod>(x, n / 2), 2LL) % mod;
return ((POW_(POW<mod>(x, n / 2), 2LL) % mod) * (x % mod)) % mod;
}
template <> constexpr ll POW<0>(ll x, ll n) {
if (x == 2) {
return 1LL << n;
}
if (n == 0)
return 1;
if (n == 1)
return x;
if (n % 2 == 0)
return POW_(POW(x, n / 2), 2);
return (POW_(POW(x, n / 2), 2)) * x;
}
template <ll bit = 2LL> ll at_bit(ll n, ll i) { return n / POW(bit, i) % bit; }
template <> ll at_bit<2>(ll n, ll i) { return (n >> i) % 2LL; }
template <ll bit> ll get_bit(ll i) { return POW(bit, i); }
template <> ll get_bit<2>(ll i) { return 1LL << i; }
template <ll bit = 2> ll get_max_bit(ll n) {
ll tmp = bit;
ll at = 0;
while (tmp <= n) {
at++;
tmp *= bit;
}
return at;
}
template <> ll get_max_bit<2>(ll n) {
ll tmp = 2;
ll at = 0;
while (tmp <= n) {
at++;
tmp <<= 1;
}
return at;
}
vll getDivisors(ll n) {
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
res.push_back(i);
res.push_back(n / i);
}
}
if (i * i == n)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
vll getDivisors(ll n, ll m) {
if (n > m)
swap(n, m);
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
if (m % i == 0)
res.push_back(i);
if (m % (n / i) == 0)
res.push_back(n / i);
}
}
if (i * i == n)
if (m % i == 0)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs &inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs &inputs, Functor f) {
std::stable_sort(
std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
// Functor is expected to be functional<val ,bool>
// This function returns the maximum iterator that stisfies f(*it) == f(*
// inputs.begin())
template <typename Inputs, typename Functor,
typename ValType = typename Inputs::value_type>
pair<typename Inputs::iterator, typename Inputs::iterator>
binary_solve(Inputs &inputs, Functor f) {
auto left = inputs.begin();
auto right = inputs.end();
auto n = inputs.size();
auto left_val = f(*left);
auto right_val = f(*(right - 1));
// check
assert(n >= 2);
assert(left_val != right_val);
while (left + 1 != right) {
auto mid = left + (right - left) / 2;
if (f(*mid) == left_val) {
left = mid;
} else {
right = mid;
}
}
return {left, right};
}
template <int I> vll proj(vpll v) {
vll res(v.size());
rep(i, 0, v.size()) {
if (!I)
res[i] = v[i].first;
else
res[i] = v[i].second;
}
return res;
}
template <int I, class T> vll proj(T v) {
vll res(v.size());
rep(i, 0, v.size()) { res[i] = get<I>(v[i]); }
return res;
}
vector<pll> prime_factorize(ll n) {
vector<pll> res;
for (ll p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
ll num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back({p, num});
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
constexpr ll MOD = 1000000007;
ll INF = 1LL << 50;
ll n;
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename Monoid> struct segment_tree {
using underlying_type = typename Monoid::underlying_type;
segment_tree(ll a_n) : size_original(a_n) {
vector<underlying_type> initial_value =
vector<underlying_type>(a_n, Monoid::unit());
segment_tree_impl(a_n, initial_value);
}
segment_tree(ll a_n, vector<underlying_type> &initial_value)
: size_original(a_n) {
segment_tree_impl(a_n, initial_value);
}
void update(int i, underlying_type z) { // 0-based
assert(0 <= i && i < 2 * n - 1);
a[i + n - 1] = z;
for (i = (i + n) / 2; i > 0; i /= 2) { // 1-based
a[i - 1] = Monoid::append(a[2 * i - 1], a[2 * i]);
}
}
underlying_type query(ll l, ll r) { // 0-based, [l, r)
underlying_type lacc = Monoid::unit(), racc = Monoid::unit();
assert(l <= r && r <= n);
l += n;
r += n;
for (; l < r; l /= 2, r /= 2) { // 1-based loop, 2x faster than recursion
if (l % 2 == 1)
lacc = Monoid::append(lacc, a[(l++) - 1]);
if (r % 2 == 1)
racc = Monoid::append(a[(--r) - 1], racc);
}
return Monoid::append(lacc, racc);
}
ll size() { return size_original; }
private:
ll size_original;
ll n;
vector<underlying_type> a;
void segment_tree_impl(ll a_n, vector<underlying_type> &initial_value) {
assert(a_n == initial_value.size());
n = 1;
while (n < a_n)
n *= 2;
a.resize(2 * n - 1, Monoid::unit());
rep(i, 0, initial_value.size()) { a[i + (n - 1)] = initial_value[i]; }
rrep(i, 0, n - 1) a[i] =
Monoid::append(a[2 * i + 1], a[2 * i + 2]); // propagate initial values
}
};
template <typename T> struct min_indexed_t {
typedef pair<T, ll> underlying_type;
static underlying_type make_indexed(vector<T> v) {
underlying_type w(v.size());
rep(i, 0, v.size()) { w[i] = {v[i], i}; }
return w;
}
static underlying_type unit() {
return make_pair(numeric_limits<T>::max(), -1);
}
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
template <typename T> struct min_t {
typedef T underlying_type;
static underlying_type unit() { return numeric_limits<T>::max(); }
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
struct linear_t {
typedef pd underlying_type;
static underlying_type unit() { return underlying_type{1., 0.}; }
static underlying_type append(underlying_type a, underlying_type b) {
return underlying_type{a.first * b.first, b.first * a.second + b.second};
}
};
vll get_topologically_sorted_nodes(const vvll &graph) {
// graph needs to be represented by adjacent list.
// complexity: O( node size + edge size)
ll nodeSize = graph.size();
// find root
vll roots;
vll inDegree(nodeSize);
rep(i, 0, nodeSize) {
for (ll sibling : graph[i]) {
inDegree[sibling]++;
}
}
rep(i, 0, nodeSize) {
if (inDegree[i] == 0) {
roots.push_back(i);
}
}
stack<ll> parents;
for (ll i : roots)
parents.push(i);
vll sortedNodes;
while (!parents.empty()) {
ll parent = parents.top();
parents.pop();
sortedNodes.push_back(parent);
for (ll sibling : graph[parent]) {
inDegree[sibling]--;
if (inDegree[sibling] == 0) {
parents.push(sibling);
}
}
}
return sortedNodes;
}
struct UnionFind {
vector<ll> data;
vll querySize_;
set<ll> roots;
UnionFind(ll size) : data(size, -1), querySize_(size, 0) {
rep(i, 0, size) roots.insert(i);
}
ll unite(ll x, ll y) {
// return: root
x = operator[](x);
y = operator[](y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
querySize_[x] += querySize_[y] + 1;
roots.erase(y);
return x;
} else {
querySize_[x]++;
return x;
}
}
bool is_same(ll x, ll y) {
// check whether x and y are connected
return operator[](x) == operator[](y);
}
ll operator[](ll x) {
// get root
return data[x] < 0 ? x : data[x] = operator[](data[x]);
}
ll size(ll x) { return -data[operator[](x)]; }
ll query_size(ll x) { return querySize_[operator[](x)]; }
const set<ll> &getRoots() { return roots; }
ll rank(ll x) { return -data[operator[](x)]; }
void initialize() {
for (auto &i : data) {
i = -1;
}
}
};
ll POW_3(ll x, ll y) { return y == 0 ? 1 : (POW_3(x, y - 1) * x) % MOD; }
int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c);
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <vector>
//#include "boost/variant.hpp"
// #include "bits/stdc++.h"
using namespace std;
#define rep(i, N, M) for (ll i = N, i##_len = (M); i < i##_len; ++i)
#define rep_skip(i, N, M, ...) \
for (ll i = N, i##_len = (M); i < i##_len; i += (skip))
#define rrep(i, N, M) for (ll i = (M)-1, i##_len = (N - 1); i > i##_len; --i)
#define pb push_back
typedef pair<double, double> pd;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef tuple<ll, ll, ll> tll;
typedef tuple<ll, ll, ll, ll> tll4;
typedef tuple<ll, ll, ll, ll, ll> tll5;
typedef tuple<ll, ll, ll, ll, ll, ll> tll6;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template <typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define vec(a) vector<a>
#define perm(c) \
sort(all(c)); \
for (bool c##perm = 1; c##perm; c##perm = next_permutation(all(c)))
template <typename T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <typename T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
vll seq(ll i, ll j) {
vll res(j - i);
rep(k, i, j) res[k] = i + k;
return res;
}
constexpr ll POW_(ll n, ll m) {
ll res = 1;
rep(i, 0, m) { res *= n; }
return res;
}
template <int mod = 0> constexpr ll POW(ll x, ll n) {
if (x == 2) {
return (1LL << n) % mod;
}
if (n == 0)
return 1;
if (n == 1)
return x % mod;
if (n % 2 == 0)
return POW_(POW<mod>(x, n / 2), 2LL) % mod;
return ((POW_(POW<mod>(x, n / 2), 2LL) % mod) * (x % mod)) % mod;
}
template <> constexpr ll POW<0>(ll x, ll n) {
if (x == 2) {
return 1LL << n;
}
if (n == 0)
return 1;
if (n == 1)
return x;
if (n % 2 == 0)
return POW_(POW(x, n / 2), 2);
return (POW_(POW(x, n / 2), 2)) * x;
}
template <ll bit = 2LL> ll at_bit(ll n, ll i) { return n / POW(bit, i) % bit; }
template <> ll at_bit<2>(ll n, ll i) { return (n >> i) % 2LL; }
template <ll bit> ll get_bit(ll i) { return POW(bit, i); }
template <> ll get_bit<2>(ll i) { return 1LL << i; }
template <ll bit = 2> ll get_max_bit(ll n) {
ll tmp = bit;
ll at = 0;
while (tmp <= n) {
at++;
tmp *= bit;
}
return at;
}
template <> ll get_max_bit<2>(ll n) {
ll tmp = 2;
ll at = 0;
while (tmp <= n) {
at++;
tmp <<= 1;
}
return at;
}
vll getDivisors(ll n) {
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
res.push_back(i);
res.push_back(n / i);
}
}
if (i * i == n)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
vll getDivisors(ll n, ll m) {
if (n > m)
swap(n, m);
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
if (m % i == 0)
res.push_back(i);
if (m % (n / i) == 0)
res.push_back(n / i);
}
}
if (i * i == n)
if (m % i == 0)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs &inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs &inputs, Functor f) {
std::stable_sort(
std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
// Functor is expected to be functional<val ,bool>
// This function returns the maximum iterator that stisfies f(*it) == f(*
// inputs.begin())
template <typename Inputs, typename Functor,
typename ValType = typename Inputs::value_type>
pair<typename Inputs::iterator, typename Inputs::iterator>
binary_solve(Inputs &inputs, Functor f) {
auto left = inputs.begin();
auto right = inputs.end();
auto n = inputs.size();
auto left_val = f(*left);
auto right_val = f(*(right - 1));
// check
assert(n >= 2);
assert(left_val != right_val);
while (left + 1 != right) {
auto mid = left + (right - left) / 2;
if (f(*mid) == left_val) {
left = mid;
} else {
right = mid;
}
}
return {left, right};
}
template <int I> vll proj(vpll v) {
vll res(v.size());
rep(i, 0, v.size()) {
if (!I)
res[i] = v[i].first;
else
res[i] = v[i].second;
}
return res;
}
template <int I, class T> vll proj(T v) {
vll res(v.size());
rep(i, 0, v.size()) { res[i] = get<I>(v[i]); }
return res;
}
vector<pll> prime_factorize(ll n) {
vector<pll> res;
for (ll p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
ll num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back({p, num});
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
constexpr ll MOD = 1000000007;
ll INF = 1LL << 50;
ll n;
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename Monoid> struct segment_tree {
using underlying_type = typename Monoid::underlying_type;
segment_tree(ll a_n) : size_original(a_n) {
vector<underlying_type> initial_value =
vector<underlying_type>(a_n, Monoid::unit());
segment_tree_impl(a_n, initial_value);
}
segment_tree(ll a_n, vector<underlying_type> &initial_value)
: size_original(a_n) {
segment_tree_impl(a_n, initial_value);
}
void update(int i, underlying_type z) { // 0-based
assert(0 <= i && i < 2 * n - 1);
a[i + n - 1] = z;
for (i = (i + n) / 2; i > 0; i /= 2) { // 1-based
a[i - 1] = Monoid::append(a[2 * i - 1], a[2 * i]);
}
}
underlying_type query(ll l, ll r) { // 0-based, [l, r)
underlying_type lacc = Monoid::unit(), racc = Monoid::unit();
assert(l <= r && r <= n);
l += n;
r += n;
for (; l < r; l /= 2, r /= 2) { // 1-based loop, 2x faster than recursion
if (l % 2 == 1)
lacc = Monoid::append(lacc, a[(l++) - 1]);
if (r % 2 == 1)
racc = Monoid::append(a[(--r) - 1], racc);
}
return Monoid::append(lacc, racc);
}
ll size() { return size_original; }
private:
ll size_original;
ll n;
vector<underlying_type> a;
void segment_tree_impl(ll a_n, vector<underlying_type> &initial_value) {
assert(a_n == initial_value.size());
n = 1;
while (n < a_n)
n *= 2;
a.resize(2 * n - 1, Monoid::unit());
rep(i, 0, initial_value.size()) { a[i + (n - 1)] = initial_value[i]; }
rrep(i, 0, n - 1) a[i] =
Monoid::append(a[2 * i + 1], a[2 * i + 2]); // propagate initial values
}
};
template <typename T> struct min_indexed_t {
typedef pair<T, ll> underlying_type;
static underlying_type make_indexed(vector<T> v) {
underlying_type w(v.size());
rep(i, 0, v.size()) { w[i] = {v[i], i}; }
return w;
}
static underlying_type unit() {
return make_pair(numeric_limits<T>::max(), -1);
}
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
template <typename T> struct min_t {
typedef T underlying_type;
static underlying_type unit() { return numeric_limits<T>::max(); }
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
struct linear_t {
typedef pd underlying_type;
static underlying_type unit() { return underlying_type{1., 0.}; }
static underlying_type append(underlying_type a, underlying_type b) {
return underlying_type{a.first * b.first, b.first * a.second + b.second};
}
};
vll get_topologically_sorted_nodes(const vvll &graph) {
// graph needs to be represented by adjacent list.
// complexity: O( node size + edge size)
ll nodeSize = graph.size();
// find root
vll roots;
vll inDegree(nodeSize);
rep(i, 0, nodeSize) {
for (ll sibling : graph[i]) {
inDegree[sibling]++;
}
}
rep(i, 0, nodeSize) {
if (inDegree[i] == 0) {
roots.push_back(i);
}
}
stack<ll> parents;
for (ll i : roots)
parents.push(i);
vll sortedNodes;
while (!parents.empty()) {
ll parent = parents.top();
parents.pop();
sortedNodes.push_back(parent);
for (ll sibling : graph[parent]) {
inDegree[sibling]--;
if (inDegree[sibling] == 0) {
parents.push(sibling);
}
}
}
return sortedNodes;
}
struct UnionFind {
vector<ll> data;
vll querySize_;
set<ll> roots;
UnionFind(ll size) : data(size, -1), querySize_(size, 0) {
rep(i, 0, size) roots.insert(i);
}
ll unite(ll x, ll y) {
// return: root
x = operator[](x);
y = operator[](y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
querySize_[x] += querySize_[y] + 1;
roots.erase(y);
return x;
} else {
querySize_[x]++;
return x;
}
}
bool is_same(ll x, ll y) {
// check whether x and y are connected
return operator[](x) == operator[](y);
}
ll operator[](ll x) {
// get root
return data[x] < 0 ? x : data[x] = operator[](data[x]);
}
ll size(ll x) { return -data[operator[](x)]; }
ll query_size(ll x) { return querySize_[operator[](x)]; }
const set<ll> &getRoots() { return roots; }
ll rank(ll x) { return -data[operator[](x)]; }
void initialize() {
for (auto &i : data) {
i = -1;
}
}
};
ll POW_3(ll x, ll y) { return y == 0 ? 1 : (POW_3(x, y - 1) * x) % MOD; }
int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c);
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,892 | 913,893 | u304121198 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B < A * C) {
cout << B % A << endl;
} else {
cout << C << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B < A * C) {
cout << B / A << endl;
} else {
cout << C << endl;
}
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 913,894 | 913,895 | u041978507 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A < B * C) {
cout << B % A << endl;
} else {
cout << C << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B < A * C) {
cout << B / A << endl;
} else {
cout << C << endl;
}
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"expression.operator.arithmetic.change",
"io.output.change"
] | 913,896 | 913,895 | u041978507 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b >= a * c)
cout << c << endl;
else
cout << b / 3 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b >= a * c)
cout << c << endl;
else
cout << b / a << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 913,908 | 913,909 | u634527561 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
int ans;
cin >> A >> B >> C;
ans = B / A;
if (ans > C) {
ans = C;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
int ans;
cin >> A >> B >> C;
ans = B / A;
if (ans > C) {
ans = C;
}
cout << ans;
return 0;
} | [] | 913,910 | 913,911 | u582357587 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
vector<int> transenisin(int num) {
vector<int> nisin;
while (1) {
if (num % 2 == 1)
nisin.push_back(1);
else
nisin.push_back(0);
num = num / 2;
if (num == 1) {
nisin.push_back(1);
break;
}
}
return nisin;
}
void print(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
// cout<<endl;
}
int A, B, C;
void solve() {
cin >> A >> B >> C;
if (A * C <= B)
cout << C << endl;
else
cout << B / C << endl;
}
int main() {
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
vector<int> transenisin(int num) {
vector<int> nisin;
while (1) {
if (num % 2 == 1)
nisin.push_back(1);
else
nisin.push_back(0);
num = num / 2;
if (num == 1) {
nisin.push_back(1);
break;
}
}
return nisin;
}
void print(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
// cout<<endl;
}
int A, B, C;
void solve() {
cin >> A >> B >> C;
if (A * C <= B)
cout << C << endl;
else
cout << B / A << endl;
}
int main() {
solve();
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 913,929 | 913,930 | u040301585 | cpp |
p03105 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdlib.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
using db = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / 4 - 1;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double gold = 1.618033988;
constexpr long double eps = 1e-15;
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 2
#define itr(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritr(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define fro front
#define bac back
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
struct setupper {
setupper() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
std::cout << fixed << setprecision(stdout_precision);
std::cerr << fixed << setprecision(stderr_precision);
// #ifdef Local
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() /
// (double)CLOCKS_PER_SEC * 1000.0 << "ms\n"; std::cerr <<
// "------------\n";
// };
// atexit((void(*)())print_atexit);
// #endif
}
} setupper_;
namespace std {
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = int> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::chmax;
using updater::chmin;
template <class T> T minf(const T &x, const T &y) { return min(x, y); }
template <class T> T mixf(const T &x, const T &y) { return max(x, y); }
bool bit(i64 n, uint8_t e) { return (n >> e) & 1; }
i64 mask(i64 n, uint8_t e) { return n & ((1 << e) - 1); }
int ilog(uint64_t x, uint64_t b = 2) { return x ? 1 + ilog(x / b, b) : -1; }
template <class F> i64 binry(i64 ok, i64 ng, const F &fn) {
while (abs(ok - ng) > 1) {
i64 mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class A> void cmprs(A ary[], size_t n) {
vector<A> tmp(ary, ary + n);
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (A *i = ary; i != ary + n; ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class T> void cmprs(vector<T> &v) {
vector<T> tmp = v;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (auto i = begin(v); i != end(v); ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
int a, b, c;
signed main() {
cin >> a >> b >> c;
if (b >= a * c) {
cout << a * c << endl;
} else {
cout << a * (b / a) << endl;
}
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdlib.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
using db = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / 4 - 1;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double gold = 1.618033988;
constexpr long double eps = 1e-15;
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 2
#define itr(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritr(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define fro front
#define bac back
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
struct setupper {
setupper() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
std::cout << fixed << setprecision(stdout_precision);
std::cerr << fixed << setprecision(stderr_precision);
// #ifdef Local
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() /
// (double)CLOCKS_PER_SEC * 1000.0 << "ms\n"; std::cerr <<
// "------------\n";
// };
// atexit((void(*)())print_atexit);
// #endif
}
} setupper_;
namespace std {
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = int> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::chmax;
using updater::chmin;
template <class T> T minf(const T &x, const T &y) { return min(x, y); }
template <class T> T mixf(const T &x, const T &y) { return max(x, y); }
bool bit(i64 n, uint8_t e) { return (n >> e) & 1; }
i64 mask(i64 n, uint8_t e) { return n & ((1 << e) - 1); }
int ilog(uint64_t x, uint64_t b = 2) { return x ? 1 + ilog(x / b, b) : -1; }
template <class F> i64 binry(i64 ok, i64 ng, const F &fn) {
while (abs(ok - ng) > 1) {
i64 mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class A> void cmprs(A ary[], size_t n) {
vector<A> tmp(ary, ary + n);
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (A *i = ary; i != ary + n; ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class T> void cmprs(vector<T> &v) {
vector<T> tmp = v;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (auto i = begin(v); i != end(v); ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
int a, b, c;
signed main() {
cin >> a >> b >> c;
if (b >= a * c) {
cout << c << endl;
} else {
cout << b / a << endl;
}
}
| [
"expression.operation.binary.remove"
] | 913,935 | 913,936 | u629015299 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b >= a * c / b) {
cout << c << endl;
} else
cout << b / a << endl;
;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b >= a * c) {
cout << c << endl;
} else
cout << b / a << endl;
;
return 0;
} | [
"expression.operation.binary.remove"
] | 913,941 | 913,942 | u881210121 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = b / a;
if ((d / a) >= c) {
cout << c;
} else {
cout << d;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = b / a;
if ((b / a) >= c) {
cout << c;
} else {
cout << d;
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 913,949 | 913,950 | u614970814 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
int ans;
cin >> a;
cin >> b;
cin >> c;
ans = b / a;
if (ans > c) {
c = ans;
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
int ans;
cin >> a;
cin >> b;
cin >> c;
ans = b / a;
if (ans > c) {
ans = c;
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 913,955 | 913,956 | u506441365 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
int ans;
cin >> a;
cin >> b;
cin >> c;
ans = b / a;
if (ans > c) {
c = ans;
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
int ans;
cin >> a;
cin >> b;
cin >> c;
ans = b / a;
if (ans > c) {
ans = c;
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 913,957 | 913,956 | u506441365 | cpp |
p03105 | #include <stdio.h>
int main(void) {
int A;
int B;
int C;
1 <= A, B, C;
A, B, C <= 100;
scanf("%d", &A);
scanf("%d", &B);
scanf("%d", &C);
if ((B / A) > C) {
printf("%d", C);
}
if ((B / A) < C) {
printf("%d", B / A);
}
return 0;
}
| #include <stdio.h>
int main(void) {
int A;
int B;
int C;
1 <= A, B, C;
A, B, C <= 100;
scanf("%d", &A);
scanf("%d", &B);
scanf("%d", &C);
if ((B / A) >= C) {
printf("%d", C);
}
if ((B / A) < C) {
printf("%d", B / A);
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,960 | 913,961 | u607104908 | cpp |
p03105 | #include <stdio.h>
int main(void) {
int A;
int B;
int C;
1 <= A, B, C;
A, B, C <= 100;
scanf("%d", &A);
scanf("%d", &B);
scanf("%d", &C);
if ((B / A) > C) {
printf("%d", C);
}
if ((B / A) < C) {
printf("%d", B / A);
}
}
| #include <stdio.h>
int main(void) {
int A;
int B;
int C;
1 <= A, B, C;
A, B, C <= 100;
scanf("%d", &A);
scanf("%d", &B);
scanf("%d", &C);
if ((B / A) >= C) {
printf("%d", C);
}
if ((B / A) < C) {
printf("%d", B / A);
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 913,962 | 913,961 | u607104908 | cpp |
p03105 | #include <bits/stdc++.h>
#define int long long
#define f(i, n) for (int i = 0; i < n; i++)
#define F first
#define S second
#define mod 1000000007
#define P pair<int, int>
using namespace std;
signed main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, a / b) << endl;
}
| #include <bits/stdc++.h>
#define int long long
#define f(i, n) for (int i = 0; i < n; i++)
#define F first
#define S second
#define mod 1000000007
#define P pair<int, int>
using namespace std;
signed main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
}
| [
"expression.operation.binary.remove"
] | 913,969 | 913,970 | u259210975 | cpp |
p03105 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <stdio.h>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, a, n) for (ll i = (a); i < (n); ++i)
#define urep(i, a, n) for (ll i = (a); i >= (n); --i)
#define all(x) (x).begin(), (x).end()
#define INF 1e18
const int mod = 1e9 + 7;
typedef long long ll;
using namespace std;
ll dx[4] = {1, -1, 0, 0};
ll dy[4] = {0, 0, 1, -1};
ll N, M, X, Y, A, B, C, Q, K, R, W, H, P, L;
string S, T;
ll ans;
ll x[101010];
ll y[101010];
ll a[201010];
ll b[101010];
ll c[101010];
ll t[101010];
ll p[101010];
ll n[101010];
ll l[101010];
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
struct Edge {
ll to, cost;
Edge(int to, int cost) : to(to), cost(cost) {}
};
typedef vector<vector<Edge>> AdjList;
AdjList graph;
vector<ll> dist;
bool flag[100];
vector<ll> Prime{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int main() {
cin >> A >> B >> C;
cout << min(C, A / B) << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <stdio.h>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, a, n) for (ll i = (a); i < (n); ++i)
#define urep(i, a, n) for (ll i = (a); i >= (n); --i)
#define all(x) (x).begin(), (x).end()
#define INF 1e18
const int mod = 1e9 + 7;
typedef long long ll;
using namespace std;
ll dx[4] = {1, -1, 0, 0};
ll dy[4] = {0, 0, 1, -1};
ll N, M, X, Y, A, B, C, Q, K, R, W, H, P, L;
string S, T;
ll ans;
ll x[101010];
ll y[101010];
ll a[201010];
ll b[101010];
ll c[101010];
ll t[101010];
ll p[101010];
ll n[101010];
ll l[101010];
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
struct Edge {
ll to, cost;
Edge(int to, int cost) : to(to), cost(cost) {}
};
typedef vector<vector<Edge>> AdjList;
AdjList graph;
vector<ll> dist;
bool flag[100];
vector<ll> Prime{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int main() {
cin >> A >> B >> C;
cout << min(C, B / A) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 913,987 | 913,988 | u406225550 | cpp |
p03105 | #include <iostream>
using namespace std;
int main(int argc, char **argv) {
int a, b, c;
cin >> a >> b >> c;
if (b % a >= c) {
cout << c << endl;
} else {
cout << b / a << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(int argc, char **argv) {
int a, b, c;
cin >> a >> b >> c;
if (b / a >= c) {
cout << c << endl;
} else {
cout << b / a << endl;
}
return 0;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 913,991 | 913,992 | u791687581 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A * B >= A * C) {
cout << C << endl;
} else {
cout << B / A << endl;
}
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (B >= A * C) {
cout << C << endl;
} else {
cout << B / A << endl;
}
} | [
"expression.operation.binary.remove"
] | 913,997 | 913,998 | u303745819 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = a / b;
if (ans > c) {
cout << c;
} else
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = b / a;
if (ans >= c) {
cout << c;
} else
cout << ans;
return 0;
} | [
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 914,001 | 914,002 | u508332677 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <vector>
typedef long long int ll;
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a > c) {
cout << c << endl;
} else {
cout << a / b << endl;
}
} | #include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <vector>
typedef long long int ll;
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a > c) {
cout << c << endl;
} else {
cout << b / a << endl;
}
} | [
"expression.operation.binary.remove"
] | 914,003 | 914,004 | u149526875 | cpp |
p03105 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / c);
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a);
}
| [
"identifier.change",
"io.output.change"
] | 914,005 | 914,006 | u361767189 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C, ans;
cin >> A >> B >> C;
ans = A / B;
if (ans > C)
ans = C;
cout << ans << endl;
}
| #include <iostream>
using namespace std;
int main() {
int A, B, C, ans;
cin >> A >> B >> C;
ans = B / A;
if (ans > C)
ans = C;
cout << ans << endl;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 914,007 | 914,008 | u041282550 | cpp |
p03105 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long int
ll const MOD = 1000000007;
ll const INF = (long long int)1 << 61;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long int
ll const MOD = 1000000007;
ll const INF = (long long int)1 << 61;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 914,009 | 914,010 | u369508054 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b / a, c);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c);
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 914,011 | 914,012 | u058348416 | cpp |
p03105 | /////////////////////////////////////////////////////////
//
// c/temp.cpp file
// Last Updated: 2018-10-23 ...Maybe
//
// I hope you adding this code to the setting file
// alias g++='g++ -std=c++1y -DDEBUG_LOCAL'
//
/////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
//#define int long long
#define _overload3(_1, _2, _3, name, ...) name
#define _REP(i, n) REAP(i, 0, n)
#define REAP(i, a, b) for (int i = int(a); i < int(b); ++i)
#define REP(...) _overload3(__VA_ARGS__, REAP, _REP, )(__VA_ARGS__)
#define _REPR(i, n) REAPR(i, n, 0)
#define REAPR(i, a, b) for (int i = int(a - 1); i >= int(b); --i)
#define REPR(...) _overload3(__VA_ARGS__, REAPR, _REPR, )(__VA_ARGS__)
#define ALL(a) a.begin(), a.end()
#define rALL(a) a.rbegin(), a.rend()
#define coutALL(a) \
{ \
int loop_coutALL = 0; \
for (auto e : a) \
cout << (loop_coutALL++ ? " " : "") << e; \
cout << endl; \
}
#define coutYN(a) cout << ((a) ? "YES" : "NO") << endl;
#define coutYn(a) cout << ((a) ? "Yes" : "No") << endl;
#define coutyn(a) cout << ((a) ? "yes" : "no") << endl;
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
const int INF = 1145141919;
// const long long INF=114514191911451419;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-12;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// const int dx[]={-1,-1,-1,0,1,1,1,0},dy[]={-1,0,1,1,1,0,-1,-1};
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
typedef pair<int, int> pii;
typedef pair<int, string> pis;
typedef pair<string, int> psi;
typedef pair<string, string> pss;
typedef long long ll;
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
int i = 0;
for (T &x : v)
os << (i++ ? " " : "") << x;
return os;
}
ll rev(ll n) {
ll x = 0;
for (; n > 0;) {
x = x * 10 + n % 10;
n /= 10;
}
return x;
}
ll upper(ll n, ll m) { return (n + m - 1) / m; };
ll rounding(ll n) { return (long double)n + 0.5; };
bool inG(ll x, ll n) { return 0 <= x && x < n; }
bool outG(ll x, ll n) { return x < 0 || n <= x; }
inline int qp(int a, ll b) {
if (!b)
return 1;
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a;
a = 1ll * a * a;
} while (b >>= 1);
return ans;
}
inline int qp(int a, ll b, int mo) {
if (!b)
return 1;
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
inline ll fac(ll k, ll n) {
ll a = 1;
for (int i = 0; i < n; i++)
a *= k--;
return a;
}
inline ll fac(ll k, ll n, int mo) {
ll a = 1;
for (int i = 0; i < n; i++)
a *= k--, a %= mo;
return a;
}
inline int dsum(ll n) {
int a = 0;
for (; n; n /= 10)
a += n % 10;
return a;
}
struct Arithmetic {
Arithmetic() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
};
//#define DEBUG_LOCAL
#ifdef DEBUG_LOCAL
template <typename T> void deb(T a) { cerr << "deb: " << a << "です" << endl; }
#define debl \
{ cerr << "debug: " << __LINE__ << "行目だ" << endl; }
void what_cr() { cout << __GCC_ATOMIC_CHAR16_T_LOCK_FREE << " ←？" << endl; }
// ori_func S
// ori_func E
#else
template <typename T> void deb(T a) {}
#define debl
void what_cr() {}
void t_t() {}
#endif
signed main() {
Arithmetic Exception;
int a, b, c;
cin >> a >> b >> c;
cout << min(c, a / b) << endl;
return 0;
}
| /////////////////////////////////////////////////////////
//
// c/temp.cpp file
// Last Updated: 2018-10-23 ...Maybe
//
// I hope you adding this code to the setting file
// alias g++='g++ -std=c++1y -DDEBUG_LOCAL'
//
/////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
//#define int long long
#define _overload3(_1, _2, _3, name, ...) name
#define _REP(i, n) REAP(i, 0, n)
#define REAP(i, a, b) for (int i = int(a); i < int(b); ++i)
#define REP(...) _overload3(__VA_ARGS__, REAP, _REP, )(__VA_ARGS__)
#define _REPR(i, n) REAPR(i, n, 0)
#define REAPR(i, a, b) for (int i = int(a - 1); i >= int(b); --i)
#define REPR(...) _overload3(__VA_ARGS__, REAPR, _REPR, )(__VA_ARGS__)
#define ALL(a) a.begin(), a.end()
#define rALL(a) a.rbegin(), a.rend()
#define coutALL(a) \
{ \
int loop_coutALL = 0; \
for (auto e : a) \
cout << (loop_coutALL++ ? " " : "") << e; \
cout << endl; \
}
#define coutYN(a) cout << ((a) ? "YES" : "NO") << endl;
#define coutYn(a) cout << ((a) ? "Yes" : "No") << endl;
#define coutyn(a) cout << ((a) ? "yes" : "no") << endl;
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
const int INF = 1145141919;
// const long long INF=114514191911451419;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-12;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// const int dx[]={-1,-1,-1,0,1,1,1,0},dy[]={-1,0,1,1,1,0,-1,-1};
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
typedef pair<int, int> pii;
typedef pair<int, string> pis;
typedef pair<string, int> psi;
typedef pair<string, string> pss;
typedef long long ll;
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
int i = 0;
for (T &x : v)
os << (i++ ? " " : "") << x;
return os;
}
ll rev(ll n) {
ll x = 0;
for (; n > 0;) {
x = x * 10 + n % 10;
n /= 10;
}
return x;
}
ll upper(ll n, ll m) { return (n + m - 1) / m; };
ll rounding(ll n) { return (long double)n + 0.5; };
bool inG(ll x, ll n) { return 0 <= x && x < n; }
bool outG(ll x, ll n) { return x < 0 || n <= x; }
inline int qp(int a, ll b) {
if (!b)
return 1;
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a;
a = 1ll * a * a;
} while (b >>= 1);
return ans;
}
inline int qp(int a, ll b, int mo) {
if (!b)
return 1;
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
inline ll fac(ll k, ll n) {
ll a = 1;
for (int i = 0; i < n; i++)
a *= k--;
return a;
}
inline ll fac(ll k, ll n, int mo) {
ll a = 1;
for (int i = 0; i < n; i++)
a *= k--, a %= mo;
return a;
}
inline int dsum(ll n) {
int a = 0;
for (; n; n /= 10)
a += n % 10;
return a;
}
struct Arithmetic {
Arithmetic() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
}
};
//#define DEBUG_LOCAL
#ifdef DEBUG_LOCAL
template <typename T> void deb(T a) { cerr << "deb: " << a << "です" << endl; }
#define debl \
{ cerr << "debug: " << __LINE__ << "行目だ" << endl; }
void what_cr() { cout << __GCC_ATOMIC_CHAR16_T_LOCK_FREE << " ←？" << endl; }
// ori_func S
// ori_func E
#else
template <typename T> void deb(T a) {}
#define debl
void what_cr() {}
void t_t() {}
#endif
signed main() {
Arithmetic Exception;
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 914,013 | 914,014 | u646685002 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b / a, c) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 914,015 | 914,016 | u017167684 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, a / b) << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
}
| [
"expression.operation.binary.remove"
] | 914,017 | 914,018 | u006493569 | cpp |
p03106 | #include <algorithm>
#include <iostream>
#include <math.h>
using namespace std;
int main(void) {
int i, a, b, k, d, gcd, c = 0;
cin >> a >> b >> k;
while (1) {
d = a % b;
if (d == 0) {
gcd = b;
break;
}
a = b;
b = d;
}
for (i = 1; i < gcd; i++) {
if (gcd % i == 0)
c++;
if (c == k) {
break;
}
}
cout << i << endl;
} | #include <algorithm>
#include <iostream>
#include <math.h>
using namespace std;
int main(void) {
int i, a, b, k, d, gcd, c = 0;
cin >> a >> b >> k;
while (1) {
d = a % b;
if (d == 0) {
gcd = b;
break;
}
a = b;
b = d;
}
for (i = 1; i < gcd; i++) {
if (gcd % i == 0)
c++;
if (c == k) {
break;
}
}
cout << gcd / i << endl;
} | [
"expression.operation.binary.add"
] | 914,019 | 914,020 | u491376630 | cpp |
p03106 | // Author: Fuadul Hasan(fuadul202@gmail.com)
// BSMRSTU,Gopalganj
#include <bits/stdc++.h>
using namespace std;
// int input........
template <typename T> inline void readline(T &n) {
n = 0;
int f = 1;
register int ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); ch = getchar())
n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T, typename TT> inline void readline(T &n, TT &m) {
readline(n);
readline(m);
}
template <typename T, typename TT, typename TTT>
inline void readline(T &n, TT &m, TTT &l) {
readline(n, m);
readline(l);
}
// long long input........
template <typename T> inline void readlinel(T &n) {
n = 0;
long long f = 1;
register long long ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); ch = getchar())
n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T, typename TT> inline void readlinel(T &n, TT &m) {
readlinel(n);
readlinel(m);
}
template <typename T, typename TT, typename TTT>
inline void readlinel(T &n, TT &m, TTT &l) {
readlinel(n, m);
readlinel(l);
}
// debug..........
#define error(args...) \
{ \
vector<string> _v = split(#args, ','); \
err(_v.begin(), args); \
cout << endl; \
}
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c))
v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
//............ignore it..................//
int dx[8] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
int tc = 1;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define Pi atan(1) * 4
#define ll long long int
#define happy cin.tie(0);
#define point(x) setprecision(x)
#define coding ios::sync_with_stdio(false);
#define Test printf("Case %d: ", tc++);
#define Unique(c) (c).resize(unique(all(c)) - (c).begin())
#define vout(v) \
for (auto z : v) \
cout << z << " "; \
cout << endl;
void print(int n) { printf("%d\n", n); }
void Print(int n) { printf("%d ", n); }
void print(int n, int m) {
printf("%d ", n);
printf("%d ", m);
}
void print(int n, int m, int k) {
printf("%d ", n);
printf("%d ", m);
printf("%d ", k);
}
void print(ll n) { printf("%I64d\n", n); }
void Print(ll n) { printf("%I64d ", n); }
void print(ll n, ll m) {
printf("%I64d ", n);
printf("%I64d ", m);
}
void print(ll n, ll m, ll k) {
printf("%I64d ", n);
printf("%I64d ", m);
printf("%I64d ", k);
}
int length(long long x) {
int l = 0;
for (long long i = x; i; i /= 10)
l++;
return l;
}
int length(string s) { return s.size(); }
const int M = 1e9 + 7;
long long pow(long long a, long long n) {
ll res = 1;
while (n) {
if (n & 1)
res = ((res % M) * (a % M)) % M;
a = ((a % M) * (a % M)) % M;
n >>= 1;
}
return res % M;
}
#define pr pair<int, int>
#define vpr vector<pr>
#define vi std::vector<int>
#define vll std::vector<ll>
#define all(n) n.begin(), n.end()
const int Inf = (int)2e9 + 5;
const ll Lnf = (ll)2e18 + 5;
const int N = 4e5 + 5;
const int NN = 1e6 + 5;
vector<int> got(int a, int b) {
vi v;
for (int i = 1; i <= min(a, b); i++) {
if (a % i == 0 and b % i == 0) {
v.pb(i);
}
}
return v;
}
int solve() {
// happy coding
int a, b, k;
cin >> a >> b >> k;
vi v = got(a, b);
// vout(v)
cout << v[k - 1] << endl;
return 0;
// error();
}
int main() {
int test = 1;
// readline(test);//(void)getchar();
while (test--)
solve();
return 0;
} | // Author: Fuadul Hasan(fuadul202@gmail.com)
// BSMRSTU,Gopalganj
#include <bits/stdc++.h>
using namespace std;
// int input........
template <typename T> inline void readline(T &n) {
n = 0;
int f = 1;
register int ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); ch = getchar())
n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T, typename TT> inline void readline(T &n, TT &m) {
readline(n);
readline(m);
}
template <typename T, typename TT, typename TTT>
inline void readline(T &n, TT &m, TTT &l) {
readline(n, m);
readline(l);
}
// long long input........
template <typename T> inline void readlinel(T &n) {
n = 0;
long long f = 1;
register long long ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = -1;
for (; isdigit(ch); ch = getchar())
n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T, typename TT> inline void readlinel(T &n, TT &m) {
readlinel(n);
readlinel(m);
}
template <typename T, typename TT, typename TTT>
inline void readlinel(T &n, TT &m, TTT &l) {
readlinel(n, m);
readlinel(l);
}
// debug..........
#define error(args...) \
{ \
vector<string> _v = split(#args, ','); \
err(_v.begin(), args); \
cout << endl; \
}
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c))
v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
//............ignore it..................//
int dx[8] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
int tc = 1;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define Pi atan(1) * 4
#define ll long long int
#define happy cin.tie(0);
#define point(x) setprecision(x)
#define coding ios::sync_with_stdio(false);
#define Test printf("Case %d: ", tc++);
#define Unique(c) (c).resize(unique(all(c)) - (c).begin())
#define vout(v) \
for (auto z : v) \
cout << z << " "; \
cout << endl;
void print(int n) { printf("%d\n", n); }
void Print(int n) { printf("%d ", n); }
void print(int n, int m) {
printf("%d ", n);
printf("%d ", m);
}
void print(int n, int m, int k) {
printf("%d ", n);
printf("%d ", m);
printf("%d ", k);
}
void print(ll n) { printf("%I64d\n", n); }
void Print(ll n) { printf("%I64d ", n); }
void print(ll n, ll m) {
printf("%I64d ", n);
printf("%I64d ", m);
}
void print(ll n, ll m, ll k) {
printf("%I64d ", n);
printf("%I64d ", m);
printf("%I64d ", k);
}
int length(long long x) {
int l = 0;
for (long long i = x; i; i /= 10)
l++;
return l;
}
int length(string s) { return s.size(); }
const int M = 1e9 + 7;
long long pow(long long a, long long n) {
ll res = 1;
while (n) {
if (n & 1)
res = ((res % M) * (a % M)) % M;
a = ((a % M) * (a % M)) % M;
n >>= 1;
}
return res % M;
}
#define pr pair<int, int>
#define vpr vector<pr>
#define vi std::vector<int>
#define vll std::vector<ll>
#define all(n) n.begin(), n.end()
const int Inf = (int)2e9 + 5;
const ll Lnf = (ll)2e18 + 5;
const int N = 4e5 + 5;
const int NN = 1e6 + 5;
vector<int> got(int a, int b) {
vi v;
for (int i = 1; i <= min(a, b); i++) {
if (a % i == 0 and b % i == 0) {
v.pb(i);
}
}
return v;
}
int solve() {
// happy coding
int a, b, k;
cin >> a >> b >> k;
vi v = got(a, b);
// vout(v)
cout << v[v.size() - k] << endl;
return 0;
// error();
}
int main() {
int test = 1;
// readline(test);//(void)getchar();
while (test--)
solve();
return 0;
} | [
"variable_access.subscript.index.change",
"io.output.change",
"call.add",
"identifier.replace.add",
"literal.replace.remove"
] | 914,033 | 914,034 | u526278960 | cpp |
p03106 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a == 1 && b == 1 && c == 1)) {
cout << "1" << endl;
} else {
vector<int> v;
int f = max(a, b);
for (int i = 1; i <= f / 2; i++) {
if ((a % i) == 0 && (b % i) == 0) {
v.push_back(i);
}
}
sort(v.rbegin(), v.rend());
cout << v[c - 1] << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a == 1 && b == 1 && c == 1) {
cout << "1" << endl;
} else {
vector<int> v;
int f = min(a, b);
for (int i = 1; i <= f; i++) {
if ((a % i) == 0 && (b % i) == 0) {
v.push_back(i);
}
}
sort(v.rbegin(), v.rend());
cout << v[c - 1] << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 914,035 | 914,036 | u089230684 | cpp |
p03105 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
//変数
ll A, B, C;
//解法
void solve() {
cout << min(A / B, C);
return;
}
int main() {
//入力
cin >> A >> B >> C;
solve();
cout << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
//変数
ll A, B, C;
//解法
void solve() {
cout << min(B / A, C);
return;
}
int main() {
//入力
cin >> A >> B >> C;
solve();
cout << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 914,042 | 914,043 | u426855695 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
#define fol(i, n) for (int i = 0; i < n; i++)
#define pb push_back
typedef long long ll;
typedef pair<int, int> P;
typedef vector<P> vip;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c, b / a) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fol(i, n) for (int i = 0; i < n; i++)
#define pb push_back
typedef long long ll;
typedef pair<int, int> P;
typedef vector<P> vip;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(c, b / a) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 914,059 | 914,060 | u171026188 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define lli long long int
#define MAX 100000000
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int A, B, C;
cin >> A >> B >> C;
int X = B / A;
if (C >= X) {
cout << C << endl;
} else {
cout << X << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define lli long long int
#define MAX 100000000
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int A, B, C;
cin >> A >> B >> C;
int X = B / A;
if (C >= X) {
cout << X << endl;
} else {
cout << C << endl;
}
return 0;
} | [
"identifier.change",
"io.output.change"
] | 914,061 | 914,062 | u992432716 | cpp |
p03105 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
cout << (a * c < b) ? c : int(b / a);
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
cout << ((a * c < b) ? c : b / a);
return 0;
} | [
"call.remove"
] | 914,068 | 914,069 | u304829684 | cpp |
p03105 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
cout << (a * c < b) ? b : b / a;
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
cout << ((a * c < b) ? c : b / a);
return 0;
} | [
"identifier.change",
"io.output.change"
] | 914,070 | 914,069 | u304829684 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a > c)
c = b / a;
cout << c << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b / a < c)
c = b / a;
cout << c << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 914,071 | 914,072 | u258691775 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in(x) cin >> x
#define out(str) cout << str << endl
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int A, B, C;
int main() {
cin >> A >> B >> C;
out(max(B / A, C));
}
| #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in(x) cin >> x
#define out(str) cout << str << endl
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int A, B, C;
int main() {
cin >> A >> B >> C;
out(min(B / A, C));
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 914,080 | 914,081 | u190907730 | cpp |
p03105 | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c >= b) {
cout << c << endl;
} else {
cout << b / a << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c <= b) {
cout << c << endl;
} else {
cout << b / a << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 914,092 | 914,093 | u356117208 | cpp |
p03105 | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c >= b) {
cout << c << endl;
} else {
cout << b / c << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c <= b) {
cout << c << endl;
} else {
cout << b / a << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"io.output.change"
] | 914,094 | 914,093 | u356117208 | cpp |
p03105 | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c >= b) {
cout << c << endl;
} else {
cout << b / c;
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a * c <= b) {
cout << c << endl;
} else {
cout << b / a << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"io.output.change",
"io.output.newline.add"
] | 914,095 | 914,093 | u356117208 | cpp |
p03105 | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int D = B % A;
if (D < C) {
cout << D << endl;
} else {
cout << C << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int D = B / A;
if (D < C) {
cout << D << endl;
} else {
cout << C << endl;
}
} | [
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 914,104 | 914,105 | u299137831 | cpp |
p03105 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
cout << min(b % a, c);
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c);
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 914,106 | 914,107 | u217218591 | cpp |
p03105 | #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;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(a / b, c) << endl;
return 0;
} | #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;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int a, b, c;
cin >> b >> a >> c;
cout << min(a / b, c) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 914,114 | 914,115 | u352642493 | cpp |
p03105 | #include "bits/stdc++.h"
using namespace std;
void solve() {
int A, B, C;
cin >> A >> B >> C;
cout << max(C, B / A) << endl;
}
int main(void) {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
void solve() {
int A, B, C;
cin >> A >> B >> C;
cout << min(C, B / A) << endl;
}
int main(void) {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 914,120 | 914,121 | u344412812 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b / a, c) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(b / a, c) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 914,126 | 914,127 | u593546783 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
// 整数の入力
int a, b, c;
cin >> a >> b >> c;
// 出力
int d, e;
d = b / a;
if (d < c) {
e = d;
} else {
e = 0;
}
cout << e << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
// 整数の入力
int a, b, c;
cin >> a >> b >> c;
// 出力
int d, e;
d = b / a;
if (d < c) {
e = d;
} else {
e = c;
}
cout << e << endl;
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 914,134 | 914,135 | u184045093 | cpp |
p03105 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int S = A * C;
if (B >= S)
cout << C << endl;
if (B < S)
cout << A / B << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int S = A * C;
if (B >= S)
cout << C << endl;
if (B < S)
cout << B / A << endl;
} | [
"expression.operation.binary.remove"
] | 914,136 | 914,137 | u760111694 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.