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 |
|---|---|---|---|---|---|---|---|
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (b * (t) / a) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * (t / a) << '\n';
return 0;
} | [] | 871,046 | 871,047 | u551519692 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
double a, s, d;
cin >> a >> s >> d;
cout << (d) / a * s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, s, d;
cin >> a >> s >> d;
cout << (d) / a * s << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 871,054 | 871,055 | u103850114 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
double a, s, d;
cin >> a >> s >> d;
cout << (d + 0.5) / a * s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, s, d;
cin >> a >> s >> d;
cout << (d) / a * s << endl;
}
| [
"variable_declaration.type.primitive.change",
"expression.operation.binary.remove"
] | 871,056 | 871,055 | u103850114 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, s, d;
cin >> a >> s >> d;
cout << (d + 0.5) / a * s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, s, d;
cin >> a >> s >> d;
cout << (d) / a * s << endl;
}
| [
"expression.operation.binary.remove"
] | 871,057 | 871,055 | u103850114 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int time = 0;
int bis = 0;
while (time <= t) {
bis += b;
time += a;
}
cout << bis << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int time = 0;
int bis = 0;
while (time <= t) {
bis += b;
time += a;
}
bis -= b;
cout << bis << endl;
} | [
"assignment.add"
] | 871,060 | 871,061 | u615258936 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int time = 0;
int bis = 0;
while (time < t) {
bis += b;
time += a;
}
cout << bis << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int time = 0;
int bis = 0;
while (time <= t) {
bis += b;
time += a;
}
bis -= b;
cout << bis << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"assignment.add"
] | 871,062 | 871,061 | u615258936 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
int count = 0;
int time = 0;
while (time < T + 0.5) {
time += A;
count += B;
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
int count = 0;
int time = 0;
while (time < T + 0.5) {
time += A;
count += B;
}
cout << count - B << endl;
} | [
"expression.operation.binary.add"
] | 871,063 | 871,064 | u615258936 | cpp |
p03059 | // 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// --------------------<optimizations>--------------------
#pragma GCC optimize("O3")
//(UNCOMMENT WHEN HAVING LOTS OF RECURSIONS)\
#pragma comment(linker, "/stack:200000000")
//(UNCOMMENT WHEN TRYING TO BRUTEFORCE WITH A LOT OF LOOPS)\
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define F first
#define S second
#define ld long double
#define built __builtin_popcountll
#define mst(a, i) memset(a, i, sizeof(a))
#define all(x) x.begin(), x.end()
#define itit(it, a) for (auto it = (a).begin(); it != (a).end(); it++)
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define reprr(i, a, b) for (ll i = a; i >= b; i--)
#define pi 3.14159265358979323846264338327950288419716939937510582097494459230
ll max3(ll x, ll y, ll z) { return max(max(x, y), z); }
ll min3(ll x, ll y, ll z) { return min(min(x, y), z); }
const ll N = 1e5 + 10, M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7,
inf = 1e17 + 10;
const int INF = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
int X[] = {0, 1, 0, -1};
int Y[] = {-1, 0, 1, 0};
ll power(ll x, ll n) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return result;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll a, b, t;
cin >> a >> b >> t;
ll x = ((t + .5) / a) * b;
cout << x;
return 0;
}
/* The judge is never wrong! Your code is buggy
Look for:
* * Read the problem carefully.
* * Don't forget to sort(), mod, ll!!!!
* * Initial value = +/- infinity instead of zero!!!
* * an easier and alternate approach
* * read the problem statement carefully
* * if concept is correct and still WA, try with a different implementation
* * special cases (n=1?)
* * if you have no idea just guess the appropriate well-known algorithm instead
of doing nothing :/
*/ | // 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// --------------------<optimizations>--------------------
#pragma GCC optimize("O3")
//(UNCOMMENT WHEN HAVING LOTS OF RECURSIONS)\
#pragma comment(linker, "/stack:200000000")
//(UNCOMMENT WHEN TRYING TO BRUTEFORCE WITH A LOT OF LOOPS)\
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define F first
#define S second
#define ld long double
#define built __builtin_popcountll
#define mst(a, i) memset(a, i, sizeof(a))
#define all(x) x.begin(), x.end()
#define itit(it, a) for (auto it = (a).begin(); it != (a).end(); it++)
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define reprr(i, a, b) for (ll i = a; i >= b; i--)
#define pi 3.14159265358979323846264338327950288419716939937510582097494459230
ll max3(ll x, ll y, ll z) { return max(max(x, y), z); }
ll min3(ll x, ll y, ll z) { return min(min(x, y), z); }
const ll N = 1e5 + 10, M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7,
inf = 1e17 + 10;
const int INF = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
int X[] = {0, 1, 0, -1};
int Y[] = {-1, 0, 1, 0};
ll power(ll x, ll n) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return result;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll a, b, t;
cin >> a >> b >> t;
ll x = ((t) / a) * b;
cout << x;
return 0;
}
/* The judge is never wrong! Your code is buggy
Look for:
* * Read the problem carefully.
* * Don't forget to sort(), mod, ll!!!!
* * Initial value = +/- infinity instead of zero!!!
* * an easier and alternate approach
* * read the problem statement carefully
* * if concept is correct and still WA, try with a different implementation
* * special cases (n=1?)
* * if you have no idea just guess the appropriate well-known algorithm instead
of doing nothing :/
*/
| [
"expression.operation.binary.remove"
] | 871,067 | 871,068 | u652633828 | cpp |
p03059 | #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int time = t / 1;
cout << time * b << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int time = t / a;
cout << time * b << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 871,075 | 871,076 | u902803949 | cpp |
p03059 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, 0, sizeof(x))
#define vll vector<ll>
#define vi vector<int>
#define vpll vector<pair<ll, ll>>
#define vpi vector<pair<int, int>>
#define mod 1000000007
#define put2darr(arr, row, col) \
rep(i, row) { \
rep(j, col) { printf("%18d", arr[i][j]); } \
cout << endl; \
}
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
/* 1..10
* rep: 0 1 2 3 4 5 6 7 8 9
* reps: 1 2 3 4 5 6 7 8 9 10
* rrep: 9 8 7 6 5 4 3 2 1 0
* rreps: 10 9 8 7 6 5 4 3 2 1
*/
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * t / a << endl;
}
| #include <algorithm>
#include <bitset>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, 0, sizeof(x))
#define vll vector<ll>
#define vi vector<int>
#define vpll vector<pair<ll, ll>>
#define vpi vector<pair<int, int>>
#define mod 1000000007
#define put2darr(arr, row, col) \
rep(i, row) { \
rep(j, col) { printf("%18d", arr[i][j]); } \
cout << endl; \
}
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
/* 1..10
* rep: 0 1 2 3 4 5 6 7 8 9
* reps: 1 2 3 4 5 6 7 8 9 10
* rrep: 9 8 7 6 5 4 3 2 1 0
* rreps: 10 9 8 7 6 5 4 3 2 1
*/
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * (t / a) << endl;
}
| [] | 871,108 | 871,109 | u926242698 | cpp |
p03059 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, 0, sizeof(x))
#define vll vector<ll>
#define vi vector<int>
#define vpll vector<pair<ll, ll>>
#define vpi vector<pair<int, int>>
#define mod 1000000007
#define put2darr(arr, row, col) \
rep(i, row) { \
rep(j, col) { printf("%18d", arr[i][j]); } \
cout << endl; \
}
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
/* 1..10
* rep: 0 1 2 3 4 5 6 7 8 9
* reps: 1 2 3 4 5 6 7 8 9 10
* rrep: 9 8 7 6 5 4 3 2 1 0
* rreps: 10 9 8 7 6 5 4 3 2 1
*/
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * t / a << endl;
}
| #include <algorithm>
#include <bitset>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, 0, sizeof(x))
#define vll vector<ll>
#define vi vector<int>
#define vpll vector<pair<ll, ll>>
#define vpi vector<pair<int, int>>
#define mod 1000000007
#define put2darr(arr, row, col) \
rep(i, row) { \
rep(j, col) { printf("%18d", arr[i][j]); } \
cout << endl; \
}
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
/* 1..10
* rep: 0 1 2 3 4 5 6 7 8 9
* reps: 1 2 3 4 5 6 7 8 9 10
* rrep: 9 8 7 6 5 4 3 2 1 0
* rreps: 10 9 8 7 6 5 4 3 2 1
*/
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * (t / a) << endl;
}
| [] | 871,108 | 871,110 | u926242698 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
int t;
cin >> a >> b >> t;
cout << ((t + 0.5) / a) * b << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
int t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
} | [] | 871,145 | 871,146 | u559112776 | cpp |
p03059 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int MOD = 1000000007;
int main() {
int A, B, T;
cin >> A >> B >> T;
int result = B * (A / T);
cout << result << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int MOD = 1000000007;
int main() {
int A, B, T;
cin >> A >> B >> T;
int result = B * (T / A);
cout << result << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 871,158 | 871,159 | u680707192 | cpp |
p03059 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / b) * a << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
}
| [
"identifier.change",
"io.output.change"
] | 871,162 | 871,163 | u806149832 | cpp |
p03059 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t + 0.5) / a * b;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << t / a * b;
}
| [] | 871,164 | 871,165 | u009870106 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * t / a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
}
| [
"io.output.change"
] | 871,180 | 871,181 | u264265458 | cpp |
p03059 | #include <iostream>
int main() {
int A, B, T;
std::cin >> A >> B >> T;
int ans = A / T * B;
std::cout << ans << std::endl;
return 0;
} | #include <iostream>
int main() {
int A, B, T;
std::cin >> A >> B >> T;
int ans = T / A * B;
/*
int ans = 0;
for (int i = 0; i <= T; i++) {
if (i % A == 0) ans += B;
}
*/
std::cout << ans << std::endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 871,189 | 871,190 | u922974720 | cpp |
p03053 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b, n) for (Int i = b; i < Int(n); i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
using Int = long long;
Int inf = 1000000000000000001LL;
using vi = vector<Int>;
using vvi = vector<vi>;
using pii = pair<Int, Int>;
Int GCD(Int a, Int b) {
if (b == 0)
return a;
if (a < b)
return GCD(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
Int H, W;
vvi done;
vector<vector<char>> A;
cin >> H >> W;
A = vector<vector<char>>(H, vector<char>(W, 0));
done = vvi(H, vi(W, -1));
rep(i, H) {
rep(j, W) { cin >> A[i][j]; }
}
Int ans = 0;
queue<pii> next_points;
rep(i, H) {
rep(j, W) {
if (A[i][j] == '#') {
next_points.push(pii(i, j));
done[i][j] = 0;
}
}
}
while (!next_points.empty()) {
pii now = next_points.front();
next_points.pop();
if (now.first + 1 != H) {
if (done[now.first + 1][now.second] == -1) {
done[now.first + 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first + 1][now.second]);
next_points.push(pii(now.first + 1, now.second));
}
}
if (now.second + 1 != W) {
if (done[now.first][now.second + 1] == -1) {
done[now.first][now.second + 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second + 1]);
next_points.push(pii(now.first, now.second + 1));
}
}
if (now.first - 1 > 0) {
if (done[now.first - 1][now.second] == -1) {
done[now.first - 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first - 1][now.second]);
next_points.push(pii(now.first - 1, now.second));
}
}
if (now.second - 1 > 0) {
if (done[now.first][now.second - 1] == -1) {
done[now.first][now.second - 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second - 1]);
next_points.push(pii(now.first, now.second - 1));
}
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b, n) for (Int i = b; i < Int(n); i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
using Int = long long;
Int inf = 1000000000000000001LL;
using vi = vector<Int>;
using vvi = vector<vi>;
using pii = pair<Int, Int>;
Int GCD(Int a, Int b) {
if (b == 0)
return a;
if (a < b)
return GCD(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
Int H, W;
vvi done;
vector<vector<char>> A;
cin >> H >> W;
A = vector<vector<char>>(H, vector<char>(W, 0));
done = vvi(H, vi(W, -1));
rep(i, H) {
rep(j, W) { cin >> A[i][j]; }
}
Int ans = 0;
queue<pii> next_points;
rep(i, H) {
rep(j, W) {
if (A[i][j] == '#') {
next_points.push(pii(i, j));
done[i][j] = 0;
}
}
}
while (!next_points.empty()) {
pii now = next_points.front();
next_points.pop();
if (now.first + 1 != H) {
if (done[now.first + 1][now.second] == -1) {
done[now.first + 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first + 1][now.second]);
next_points.push(pii(now.first + 1, now.second));
}
}
if (now.second + 1 != W) {
if (done[now.first][now.second + 1] == -1) {
done[now.first][now.second + 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second + 1]);
next_points.push(pii(now.first, now.second + 1));
}
}
if (now.first - 1 >= 0) {
if (done[now.first - 1][now.second] == -1) {
done[now.first - 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first - 1][now.second]);
next_points.push(pii(now.first - 1, now.second));
}
}
if (now.second - 1 >= 0) {
if (done[now.first][now.second - 1] == -1) {
done[now.first][now.second - 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second - 1]);
next_points.push(pii(now.first, now.second - 1));
}
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 871,239 | 871,240 | u375619974 | cpp |
p03053 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b, n) for (Int i = b; i < Int(n); i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
using Int = long long;
Int inf = 1000000000000000001LL;
using vi = vector<Int>;
using vvi = vector<vi>;
using pii = pair<Int, Int>;
Int GCD(Int a, Int b) {
if (b == 0)
return a;
if (a < b)
return GCD(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
Int H, W;
vvi done;
vector<vector<char>> A;
cin >> H >> W;
A = vector<vector<char>>(H, vector<char>(W, 0));
done = vvi(H, vi(W, -1));
rep(i, H) {
rep(j, W) { cin >> A[i][j]; }
}
Int ans = 0;
queue<pii> next_points;
rep(i, H) {
rep(j, W) {
if (A[i][j] == '#') {
next_points.push(pii(i, j));
done[i][j] = 0;
}
}
}
while (!next_points.empty()) {
pii now = next_points.front();
next_points.pop();
if (now.first + 1 != H) {
if (done[now.first + 1][now.second] == -1) {
done[now.first + 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first + 1][now.second]);
next_points.push(pii(now.first + 1, now.second));
}
}
if (now.second + 1 != W) {
if (done[now.first][now.second + 1] == -1) {
done[now.first][now.second + 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second + 1]);
next_points.push(pii(now.first, now.second + 1));
}
}
if (now.first - 1 > 0) {
if (done[now.first - 1][now.second] == -1) {
done[now.first - 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first - 1][now.second]);
next_points.push(pii(now.first - 1, now.second));
}
}
if (now.second - 1 > 0) {
if (done[now.first][now.second - 1] == -1) {
done[now.first][now.second - 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second - 1]);
next_points.push(pii(now.first, now.second - 1));
}
}
}
cout << ans;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b, n) for (Int i = b; i < Int(n); i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
using Int = long long;
Int inf = 1000000000000000001LL;
using vi = vector<Int>;
using vvi = vector<vi>;
using pii = pair<Int, Int>;
Int GCD(Int a, Int b) {
if (b == 0)
return a;
if (a < b)
return GCD(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
Int H, W;
vvi done;
vector<vector<char>> A;
cin >> H >> W;
A = vector<vector<char>>(H, vector<char>(W, 0));
done = vvi(H, vi(W, -1));
rep(i, H) {
rep(j, W) { cin >> A[i][j]; }
}
Int ans = 0;
queue<pii> next_points;
rep(i, H) {
rep(j, W) {
if (A[i][j] == '#') {
next_points.push(pii(i, j));
done[i][j] = 0;
}
}
}
while (!next_points.empty()) {
pii now = next_points.front();
next_points.pop();
if (now.first + 1 != H) {
if (done[now.first + 1][now.second] == -1) {
done[now.first + 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first + 1][now.second]);
next_points.push(pii(now.first + 1, now.second));
}
}
if (now.second + 1 != W) {
if (done[now.first][now.second + 1] == -1) {
done[now.first][now.second + 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second + 1]);
next_points.push(pii(now.first, now.second + 1));
}
}
if (now.first - 1 >= 0) {
if (done[now.first - 1][now.second] == -1) {
done[now.first - 1][now.second] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first - 1][now.second]);
next_points.push(pii(now.first - 1, now.second));
}
}
if (now.second - 1 >= 0) {
if (done[now.first][now.second - 1] == -1) {
done[now.first][now.second - 1] = done[now.first][now.second] + 1;
ans = max(ans, done[now.first][now.second - 1]);
next_points.push(pii(now.first, now.second - 1));
}
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"io.output.newline.add"
] | 871,241 | 871,240 | u375619974 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int h, w, n;
vector<string> a;
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
typedef pair<int, int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
n = h * w;
a.resize(h);
for (auto &i : a)
cin >> i;
vector<int> d(n, 1e9);
queue<P> q;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
if (a[i][j] == '#') {
d[i * h + j] = 0;
q.push(P(0, i * h + j));
}
}
while (!q.empty()) {
P p = q.front();
q.pop();
int t = p.second;
if (d[t] < p.first)
continue;
int x = t / h, y = t % h;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (0 <= nx && 0 <= ny && nx < h && ny < w) {
int u = nx * h + ny;
if (d[u] > d[t] + 1) {
d[u] = d[t] + 1;
q.push(P(d[u], u));
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
ans = max(ans, d[i]);
cout << ans << "\n";
// for(int i=0; i<n; ++i)
// cout << d[i] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int h, w, n;
vector<string> a;
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
typedef pair<int, int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
n = h * w;
a.resize(h);
for (auto &i : a)
cin >> i;
vector<int> d(n, 1e9);
queue<P> q;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
if (a[i][j] == '#') {
d[i * w + j] = 0;
q.push(P(0, i * w + j));
}
}
while (!q.empty()) {
P p = q.front();
q.pop();
int t = p.second;
if (d[t] < p.first)
continue;
int x = t / w, y = t % w;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (0 <= nx && 0 <= ny && nx < h && ny < w) {
int u = nx * w + ny;
if (d[u] > d[t] + 1) {
d[u] = d[t] + 1;
q.push(P(d[u], u));
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
ans = max(ans, d[i]);
cout << ans << "\n";
// for(int i=0; i<n; ++i)
// cout << d[i] << "\n";
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 871,246 | 871,247 | u207036582 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
int h, w, n;
vector<string> a;
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
typedef pair<int, int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
n = h * w;
a.resize(h);
for (auto &i : a)
cin >> i;
vector<int> d(n, 1e9);
queue<P> q;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
if (a[i][j] == '#') {
d[i * h + j] = 0;
q.push(P(0, i * h + j));
}
}
while (!q.empty()) {
P p = q.front();
q.pop();
int t = p.second;
if (d[t] < p.first)
continue;
int x = t / h, y = t % h;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (0 <= nx && 0 <= ny && nx < h && ny < w) {
int u = nx * w + ny;
if (d[u] > d[t] + 1) {
d[u] = d[t] + 1;
q.push(P(d[u], u));
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
ans = max(ans, d[i]);
cout << ans << "\n";
// for(int i=0; i<n; ++i)
// cout << d[i] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int h, w, n;
vector<string> a;
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
typedef pair<int, int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
n = h * w;
a.resize(h);
for (auto &i : a)
cin >> i;
vector<int> d(n, 1e9);
queue<P> q;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
if (a[i][j] == '#') {
d[i * w + j] = 0;
q.push(P(0, i * w + j));
}
}
while (!q.empty()) {
P p = q.front();
q.pop();
int t = p.second;
if (d[t] < p.first)
continue;
int x = t / w, y = t % w;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (0 <= nx && 0 <= ny && nx < h && ny < w) {
int u = nx * w + ny;
if (d[u] > d[t] + 1) {
d[u] = d[t] + 1;
q.push(P(d[u], u));
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
ans = max(ans, d[i]);
cout << ans << "\n";
// for(int i=0; i<n; ++i)
// cout << d[i] << "\n";
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 871,248 | 871,247 | u207036582 | cpp |
p03053 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, pii> state;
typedef vector<vector<ll>> matrix;
int r, c;
string g[1005];
int dp[1005][1005];
int dx[4]{-1, 0, 1, 0};
int dy[4]{0, 1, 0, -1};
void solve() {
cin >> r >> c;
for (int i = 0; i < r; i++)
cin >> g[i];
queue<pii> q;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (g[i][j] == '#') {
dp[i][j] = 0;
q.push({i, j});
} else
dp[i][j] = 1e9;
}
}
int ret = 0;
while (!q.empty()) {
pii curr = q.front();
q.pop();
ret = dp[curr.first][curr.second];
for (int k = 0; k < 4; k++) {
int nx = curr.first + dx[k];
int ny = curr.second + dy[k];
if (nx < 0 || nx >= r || ny < 0 || ny >= c)
continue;
if (dp[nx][ny] == 1e9)
continue;
dp[nx][ny] = 1 + dp[curr.first][curr.second];
q.push({nx, ny});
}
}
cout << ret << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, pii> state;
typedef vector<vector<ll>> matrix;
int r, c;
string g[1005];
int dp[1005][1005];
int dx[4]{-1, 0, 1, 0};
int dy[4]{0, 1, 0, -1};
void solve() {
cin >> r >> c;
for (int i = 0; i < r; i++)
cin >> g[i];
queue<pii> q;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (g[i][j] == '#') {
dp[i][j] = 0;
q.push({i, j});
} else
dp[i][j] = 1e9;
}
}
int ret = 0;
while (!q.empty()) {
pii curr = q.front();
q.pop();
ret = dp[curr.first][curr.second];
for (int k = 0; k < 4; k++) {
int nx = curr.first + dx[k];
int ny = curr.second + dy[k];
if (nx < 0 || nx >= r || ny < 0 || ny >= c)
continue;
if (dp[nx][ny] != 1e9)
continue;
dp[nx][ny] = 1 + dp[curr.first][curr.second];
q.push({nx, ny});
}
}
cout << ret << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 871,256 | 871,257 | u109256064 | cpp |
p03053 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define pb push_back
#define mp make_pair
#define ii pair<int, int>
#define ll long long
#define forn(i, a, b) for (int i = (int)a; i < (int)b; i++)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w;
cin >> h >> w;
vector<vector<int>> score(h, vector<int>(w));
queue<ii> q;
forn(i, 0, h) {
forn(j, 0, w) {
char x;
cin >> x;
if (x == '#') {
q.push(mp(i, j));
score[i][j] = 0;
} else {
score[i][j] = -1;
}
}
}
int depth = 0;
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
while (!q.empty()) {
ii top = q.front();
int s = score[top.first][top.second];
q.pop();
forn(i, 0, 4) {
int nx = top.first + dir[i][0];
int ny = top.second + dir[i][1];
ii ntop = mp(nx, ny);
if (nx > 0 && ny > 0 && nx < h - 1 && ny < w - 1 && score[nx][ny] < 0) {
q.push(ntop);
score[nx][ny] = s + 1;
depth = max(depth, s + 1);
}
}
}
cout << depth << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define pb push_back
#define mp make_pair
#define ii pair<int, int>
#define ll long long
#define forn(i, a, b) for (int i = (int)a; i < (int)b; i++)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w;
cin >> h >> w;
vector<vector<int>> score(h, vector<int>(w));
queue<ii> q;
forn(i, 0, h) {
forn(j, 0, w) {
char x;
cin >> x;
if (x == '#') {
q.push(mp(i, j));
score[i][j] = 0;
} else {
score[i][j] = -1;
}
}
}
int depth = 0;
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
while (!q.empty()) {
ii top = q.front();
int s = score[top.first][top.second];
q.pop();
forn(i, 0, 4) {
int nx = top.first + dir[i][0];
int ny = top.second + dir[i][1];
ii ntop = mp(nx, ny);
if (nx >= 0 && ny >= 0 && nx < h && ny < w && score[nx][ny] < 0) {
q.push(ntop);
score[nx][ny] = s + 1;
depth = max(depth, s + 1);
}
}
}
cout << depth << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 871,262 | 871,263 | u375639297 | cpp |
p03053 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define pb push_back
#define mp make_pair
#define ii pair<int, int>
#define ll long long
#define forn(i, a, b) for (int i = (int)a; i < (int)b; i++)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w;
cin >> h >> w;
vector<vector<int>> score(h, vector<int>(w));
queue<ii> q;
forn(i, 0, h) {
forn(j, 0, w) {
char x;
cin >> x;
if (x == '#') {
q.push(mp(i, j));
score[i][j] = 0;
} else {
score[i][j] = -1;
}
}
}
int depth = 0;
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
while (!q.empty()) {
ii top = q.front();
int s = score[top.first][top.second];
q.pop();
forn(i, 0, 4) {
int nx = top.first + dir[i][0];
int ny = top.second + dir[i][1];
ii ntop = mp(nx, ny);
if (nx > 0 && ny > 0 && nx < w && ny < h && score[nx][ny] < 0) {
q.push(ntop);
score[nx][ny] = s + 1;
depth = max(depth, s + 1);
}
}
}
cout << depth << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define pb push_back
#define mp make_pair
#define ii pair<int, int>
#define ll long long
#define forn(i, a, b) for (int i = (int)a; i < (int)b; i++)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w;
cin >> h >> w;
vector<vector<int>> score(h, vector<int>(w));
queue<ii> q;
forn(i, 0, h) {
forn(j, 0, w) {
char x;
cin >> x;
if (x == '#') {
q.push(mp(i, j));
score[i][j] = 0;
} else {
score[i][j] = -1;
}
}
}
int depth = 0;
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
while (!q.empty()) {
ii top = q.front();
int s = score[top.first][top.second];
q.pop();
forn(i, 0, 4) {
int nx = top.first + dir[i][0];
int ny = top.second + dir[i][1];
ii ntop = mp(nx, ny);
if (nx >= 0 && ny >= 0 && nx < h && ny < w && score[nx][ny] < 0) {
q.push(ntop);
score[nx][ny] = s + 1;
depth = max(depth, s + 1);
}
}
}
cout << depth << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 871,264 | 871,263 | u375639297 | cpp |
p03053 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <list> //双方向リスト
#include <map> //連想配列
#include <queue>
#include <set> //集合
#include <stack>
#include <string>
#include <vector> //動的配列
//小さい順から取り出すヒープ
// priority_queue<ll, vector<ll>, greater<ll> > pque1;
typedef long long ll;
using namespace std;
typedef pair<int, int> P;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
int r, c;
int main() {
cin >> r >> c;
char maze[r][c];
queue<P> que;
int d[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> maze[i][j];
if (maze[i][j] == '#') {
que.push(P(i, j));
d[i][j] = 0;
} else {
d[i][j] = 1e8;
// cout<<d[i][j]<<i<<j<<endl;
}
}
}
int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};
int ans = 0;
while (que.size()) {
P p = que.front();
// cout<<p.first<<p.second<<endl;
que.pop();
for (int i = 0; i < 4; i++) {
int nx = p.first + dx[i];
int ny = p.second + dy[i];
// cout<<nx<<ny;
if (0 <= nx && nx < c && 0 <= ny && ny < r && d[nx][ny] == 1e8) {
que.push(P(nx, ny));
d[nx][ny] = d[p.first][p.second] + 1;
// cout<<d[nx][ny]<<endl;
ans = max(ans, d[nx][ny]);
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <list> //双方向リスト
#include <map> //連想配列
#include <queue>
#include <set> //集合
#include <stack>
#include <string>
#include <vector> //動的配列
//小さい順から取り出すヒープ
// priority_queue<ll, vector<ll>, greater<ll> > pque1;
typedef long long ll;
using namespace std;
typedef pair<int, int> P;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
int r, c;
int main() {
cin >> r >> c;
char maze[r][c];
queue<P> que;
int d[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> maze[i][j];
if (maze[i][j] == '#') {
que.push(P(i, j));
d[i][j] = 0;
} else {
d[i][j] = 1e8;
// cout<<d[i][j]<<i<<j<<endl;
}
}
}
int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};
int ans = 0;
while (que.size()) {
P p = que.front();
// cout<<p.first<<p.second<<endl;
que.pop();
for (int i = 0; i < 4; i++) {
int nx = p.first + dx[i];
int ny = p.second + dy[i];
// cout<<nx<<ny;
if (0 <= nx && nx < r && 0 <= ny && ny < c && d[nx][ny] == 1e8) {
que.push(P(nx, ny));
d[nx][ny] = d[p.first][p.second] + 1;
// cout<<d[nx][ny]<<endl;
ans = max(ans, d[nx][ny]);
}
}
}
cout << ans << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 871,267 | 871,268 | u652150585 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
}
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
int main() {
int h, w;
scanf("%d %d", &h, &w);
int a[h][w];
queue<pair<int, int>> Q;
rep(i, h) {
char s[w + 1];
scanf("%s", s);
rep(j, w) {
if (s[j] == '#') {
a[i][j] = 1;
Q.push(make_pair(i, j));
} else
a[i][j] = 0;
}
}
int ctr = 0;
while (!Q.empty()) {
vector<pair<int, int>> blist;
while (!Q.empty()) {
blist.push_back(Q.front());
Q.pop();
}
for (auto au : blist) {
if (au.first + 1 < h && a[au.first + 1][au.second] == 0) {
a[au.first + 1][au.second] = 1;
Q.push(make_pair(au.first + 1, au.second));
}
if (au.first - 1 >= 0 && a[au.first - 1][au.second] == 0) {
a[au.first - 1][au.second] = 1;
Q.push(make_pair(au.first - 1, au.second));
}
if (au.second + 1 < w && a[au.first][au.second + 1] == 0) {
a[au.first][au.second + 1] = 1;
Q.push(make_pair(au.first, au.second + 1));
}
if (au.second - 1 >= 0 && a[au.first][au.second - 1] == 0) {
a[au.first][au.second - 1] = 1;
Q.push(make_pair(au.first, au.second - 1));
}
}
ctr++;
}
cout << ctr << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
}
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
int main() {
int h, w;
scanf("%d %d", &h, &w);
int a[h][w];
queue<pair<int, int>> Q;
rep(i, h) {
char s[w + 1];
scanf("%s", s);
rep(j, w) {
if (s[j] == '#') {
a[i][j] = 1;
Q.push(make_pair(i, j));
} else
a[i][j] = 0;
}
}
int ctr = 0;
while (!Q.empty()) {
vector<pair<int, int>> blist;
while (!Q.empty()) {
blist.push_back(Q.front());
Q.pop();
}
for (auto au : blist) {
if (au.first + 1 < h && a[au.first + 1][au.second] == 0) {
a[au.first + 1][au.second] = 1;
Q.push(make_pair(au.first + 1, au.second));
}
if (au.first - 1 >= 0 && a[au.first - 1][au.second] == 0) {
a[au.first - 1][au.second] = 1;
Q.push(make_pair(au.first - 1, au.second));
}
if (au.second + 1 < w && a[au.first][au.second + 1] == 0) {
a[au.first][au.second + 1] = 1;
Q.push(make_pair(au.first, au.second + 1));
}
if (au.second - 1 >= 0 && a[au.first][au.second - 1] == 0) {
a[au.first][au.second - 1] = 1;
Q.push(make_pair(au.first, au.second - 1));
}
}
ctr++;
}
cout << ctr - 1 << endl;
}
| [
"expression.operation.binary.add"
] | 871,280 | 871,281 | u564460375 | cpp |
p03053 | // AGC033 A - Darker and Darker
#include <bits/stdc++.h>
using namespace std;
using lli = int64_t;
using Pos = pair<int, int>;
using veci = vector<int>;
int h, w;
int main() {
#if LOCAL & 0
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
#endif
cin >> h >> w;
vector<string> cl(h);
for (auto &&l : cl) {
cin >> l;
}
vector<char *> map(cl.size());
for (int i = 0; i < cl.size(); ++i) {
map[i] = &cl[i][0];
}
// bfs
vector<veci> dist(h, veci(w, -1));
queue<Pos> que;
for (int y = 0; y < h; ++y) {
for (int x = 0; x < h; ++x) {
if (map[y][x] == '#') {
dist[y][x] = 0;
que.push({x, y});
}
}
}
while (!que.empty()) {
auto now = que.front();
que.pop();
int x = now.first;
int y = now.second;
int xofs[4] = {1, -1, 0, 0};
int yofs[4] = {0, 0, 1, -1};
for (int i = 0; i < 4; ++i) {
auto gx = x + xofs[i];
auto gy = y + yofs[i];
if (gx >= 0 && gx < w && gy >= 0 && gy < h && dist[gy][gx] < 0) {
dist[gy][gx] = dist[y][x] + 1;
que.push({gx, gy});
}
}
}
// max
int ans = 0;
for (auto &&dl : dist) {
for (auto &&d : dl) {
ans = std::max(d, ans);
}
}
cout << ans << endl;
return 0;
} | // AGC033 A - Darker and Darker
#include <bits/stdc++.h>
using namespace std;
using lli = int64_t;
using Pos = pair<int, int>;
using veci = vector<int>;
int h, w;
int main() {
#if LOCAL & 01
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
#endif
cin >> h >> w;
vector<string> cl(h);
for (auto &&l : cl) {
cin >> l;
}
vector<char *> map(cl.size());
for (int i = 0; i < cl.size(); ++i) {
map[i] = &cl[i][0];
}
// bfs
vector<veci> dist(h, veci(w, -1));
queue<Pos> que;
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
if (map[y][x] == '#') {
dist[y][x] = 0;
que.push({x, y});
}
}
}
while (!que.empty()) {
auto now = que.front();
que.pop();
int x = now.first;
int y = now.second;
int xofs[4] = {1, -1, 0, 0};
int yofs[4] = {0, 0, 1, -1};
for (int i = 0; i < 4; ++i) {
auto gx = x + xofs[i];
auto gy = y + yofs[i];
if (gx >= 0 && gx < w && gy >= 0 && gy < h && dist[gy][gx] < 0) {
dist[gy][gx] = dist[y][x] + 1;
que.push({gx, gy});
}
}
}
// max
int ans = 0;
for (auto &&dl : dist) {
for (auto &&d : dl) {
ans = std::max(d, ans);
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change"
] | 871,304 | 871,305 | u182321487 | cpp |
p03053 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define INF 10000001
int main() {
int H, W;
std::cin >> H >> W;
int d[1001][1001];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
std::queue<std::pair<int, int>> q;
for (int i = 0; i < H; ++i) {
std::string s;
std::cin >> s;
for (int j = 0; j < W; ++j) {
if (s[j] == '#') {
d[i][j] = 0;
q.push({i, j});
} else {
d[i][j] = INF;
}
}
}
int max_count = 0;
while (!q.empty()) {
const auto cur = q.front();
q.pop();
max_count = d[cur.first][cur.second] < max_count ? max_count
: d[cur.first][cur.second];
for (int k = 0; k < 4; ++k) {
const int ix = cur.first + dx[k];
const int iy = cur.second + dy[k];
if (ix < 0 || ix >= W || iy < 0 || iy >= H)
continue;
if (d[ix][iy] > d[cur.first][cur.second] + 1) {
d[ix][iy] = d[cur.first][cur.second] + 1;
q.push({ix, iy});
}
}
}
std::cout << max_count << std::endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define INF 10000001
int main() {
int H, W;
std::cin >> H >> W;
int d[1001][1001];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
std::queue<std::pair<int, int>> q;
for (int i = 0; i < H; ++i) {
std::string s;
std::cin >> s;
for (int j = 0; j < W; ++j) {
if (s[j] == '#') {
d[i][j] = 0;
q.push({i, j});
} else {
d[i][j] = INF;
}
}
}
int max_count = 0;
while (!q.empty()) {
const auto cur = q.front();
q.pop();
max_count = d[cur.first][cur.second] < max_count ? max_count
: d[cur.first][cur.second];
for (int k = 0; k < 4; ++k) {
const int ix = cur.first + dx[k];
const int iy = cur.second + dy[k];
if (ix < 0 || ix >= H || iy < 0 || iy >= W)
continue;
if (d[ix][iy] > d[cur.first][cur.second] + 1) {
d[ix][iy] = d[cur.first][cur.second] + 1;
q.push({ix, iy});
}
}
}
std::cout << max_count << std::endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 871,314 | 871,315 | u893523678 | cpp |
p03053 | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
inline void PaintMass(vector<vector<int>> &Mass,
queue<pair<int, int>> &Blacks) {
const auto &black = Blacks.front();
const int h = black.first, w = black.second;
// 上下左右を塗る
if (h > 0 && !Mass[h - 1][w]) {
Mass[h - 1][w] = true;
Blacks.emplace(h - 1, w);
}
if (w > 0 && !Mass[h][w - 1]) {
Mass[h][w - 1] = true;
Blacks.emplace(h, w - 1);
}
if (h < Mass.size() - 1 && !Mass[h + 1][w]) {
Mass[h + 1][w] = true;
Blacks.emplace(h + 1, w);
}
if (w < Mass[h].size() - 1 && !Mass[h][w + 1]) {
Mass[h][w + 1] = true;
Blacks.emplace(h, w + 1);
}
Blacks.pop();
}
int main() {
size_t h, w;
cin >> h >> w;
vector<vector<int>> Mass(h, vector<int>(w));
queue<pair<int, int>> Blacks;
for (size_t i = 0; i < h; ++i)
for (size_t j = 0; j < w; ++j) {
char col;
cin >> col;
if (Mass[i][j] = col == '#')
Blacks.emplace(i, j);
}
int Paint = 0;
while (!Blacks.empty()) {
size_t cnt = Blacks.size();
while (cnt--)
PaintMass(Mass, Blacks);
++Paint;
}
cout << Paint;
return 0;
}
| #include <iostream>
#include <queue>
#include <vector>
using namespace std;
inline void PaintMass(vector<vector<int>> &Mass,
queue<pair<int, int>> &Blacks) {
const auto &black = Blacks.front();
const int h = black.first, w = black.second;
// 上下左右を塗る
if (h > 0 && !Mass[h - 1][w]) {
Mass[h - 1][w] = true;
Blacks.emplace(h - 1, w);
}
if (w > 0 && !Mass[h][w - 1]) {
Mass[h][w - 1] = true;
Blacks.emplace(h, w - 1);
}
if (h < Mass.size() - 1 && !Mass[h + 1][w]) {
Mass[h + 1][w] = true;
Blacks.emplace(h + 1, w);
}
if (w < Mass[h].size() - 1 && !Mass[h][w + 1]) {
Mass[h][w + 1] = true;
Blacks.emplace(h, w + 1);
}
Blacks.pop();
}
int main() {
size_t h, w;
cin >> h >> w;
vector<vector<int>> Mass(h, vector<int>(w));
queue<pair<int, int>> Blacks;
for (size_t i = 0; i < h; ++i)
for (size_t j = 0; j < w; ++j) {
char col;
cin >> col;
if (Mass[i][j] = col == '#')
Blacks.emplace(i, j);
}
int Paint = 0;
while (!Blacks.empty()) {
size_t cnt = Blacks.size();
while (cnt--)
PaintMass(Mass, Blacks);
++Paint;
}
cout << (Paint - 1);
return 0;
}
| [] | 871,318 | 871,319 | u919919505 | cpp |
p03053 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define mod 1000000007
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define long long long
inline int rei() {
int x;
cin >> x;
return x;
}
inline long rel() {
long x;
cin >> x;
return x;
}
inline string res() {
string x;
cin >> x;
return x;
}
//-------------------------------------------------------
int dist[1000][1000];
int hp[] = {-1, 1, 0, 0};
int wp[] = {0, 0, -1, 1};
void Calc() {
queue<pair<int, int>> que;
int H = rei();
int W = rei();
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
dist[i][j] = 100000;
}
}
for (int i = 0; i < H; i++) {
string S = res();
for (int j = 0; j < W; j++) {
if (S[j] == '#') {
dist[i][j] = 0;
que.push({i, j});
}
}
}
int ans = 0;
while (!que.empty()) {
int vh = que.front().first;
int vw = que.front().second;
que.pop();
for (int i = 0; i < 4; i++) {
int th = vh + hp[i];
int tw = vw + wp[i];
if (th >= 0 && th < H && tw > 0 && tw < W) {
if (dist[th][tw] == 100000) {
dist[th][tw] = dist[vh][vw] + 1;
ans = max(ans, dist[th][tw]);
que.push({th, tw});
}
}
}
}
cout << ans << endl;
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
Calc();
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define mod 1000000007
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define long long long
inline int rei() {
int x;
cin >> x;
return x;
}
inline long rel() {
long x;
cin >> x;
return x;
}
inline string res() {
string x;
cin >> x;
return x;
}
//-------------------------------------------------------
int dist[1000][1000];
int hp[] = {-1, 1, 0, 0};
int wp[] = {0, 0, -1, 1};
void Calc() {
queue<pair<int, int>> que;
int H = rei();
int W = rei();
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
dist[i][j] = 100000;
}
}
for (int i = 0; i < H; i++) {
string S = res();
for (int j = 0; j < W; j++) {
if (S[j] == '#') {
dist[i][j] = 0;
que.push({i, j});
}
}
}
int ans = 0;
while (!que.empty()) {
int vh = que.front().first;
int vw = que.front().second;
que.pop();
for (int i = 0; i < 4; i++) {
int th = vh + hp[i];
int tw = vw + wp[i];
if (th >= 0 && th < H && tw >= 0 && tw < W) {
if (dist[th][tw] == 100000) {
dist[th][tw] = dist[vh][vw] + 1;
ans = max(ans, dist[th][tw]);
que.push({th, tw});
}
}
}
}
cout << ans << endl;
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
Calc();
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 871,328 | 871,329 | u387013436 | cpp |
p03053 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF (INT_MAX / 2 - 1)
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
int main() {
int H, W;
cin >> H >> W;
vector<string> A(H);
for (int i = 0; i < H; i++)
cin >> A[i];
vector<vector<int>> ans(H, vector<int>(W, INF));
for (int i = 0; i < H; i++) {
int a = 1;
bool b = false;
for (int j = 0; j < W; j++) {
if (A[i][j] == '#')
a = 0, b = true;
else if (b)
ans[i][j] = a;
a++;
}
b = false;
a = 1;
for (int j = W - 1; j >= 0; j--) {
if (A[i][j] == '#')
a = 0, b = true;
else if (b)
ans[i][j] = (min(ans[i][j], a));
a++;
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (A[i][j] == '#')
ans[i][j] = 0;
}
}
for (int i = 1; i < H; i++) {
for (int j = 0; j < W; j++) {
ans[i][j] = min(ans[i][j], ans[i - 1][j] + 1);
}
}
for (int i = H - 2; i > 0; i--) {
for (int j = 0; j < W; j++) {
ans[i][j] = min(ans[i][j], ans[i + 1][j] + 1);
}
}
int res = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
res = max(res, ans[i][j]);
}
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF (INT_MAX / 2 - 1)
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
int main() {
int H, W;
cin >> H >> W;
vector<string> A(H);
for (int i = 0; i < H; i++)
cin >> A[i];
vector<vector<int>> ans(H, vector<int>(W, INF));
for (int i = 0; i < H; i++) {
int a = 1;
bool b = false;
for (int j = 0; j < W; j++) {
if (A[i][j] == '#')
a = 0, b = true;
else if (b)
ans[i][j] = a;
a++;
}
b = false;
a = 1;
for (int j = W - 1; j >= 0; j--) {
if (A[i][j] == '#')
a = 0, b = true;
else if (b)
ans[i][j] = (min(ans[i][j], a));
a++;
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (A[i][j] == '#')
ans[i][j] = 0;
}
}
for (int i = 1; i < H; i++) {
for (int j = 0; j < W; j++) {
ans[i][j] = min(ans[i][j], ans[i - 1][j] + 1);
}
}
for (int i = H - 2; i >= 0; i--) {
for (int j = 0; j < W; j++) {
ans[i][j] = min(ans[i][j], ans[i + 1][j] + 1);
}
}
int res = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
res = max(res, ans[i][j]);
}
}
cout << res << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 871,334 | 871,335 | u864171425 | cpp |
p03053 | #include <bits/stdc++.h>
#define INF INT_MAX
typedef long long ll;
using namespace std;
char a[1005][1005];
int memo[1005][1005];
vector<pair<int, int>> b;
int main(void) {
int H, W;
cin >> H >> W;
queue<pair<int, int>> q;
for (int j = 0; j < H; j++) {
for (int i = 0; i < W; i++) {
cin >> a[j][i];
if (a[j][i] == '#') {
b.push_back(make_pair(j, i));
q.push(make_pair(j, i));
memo[j][i] = 0;
} else {
memo[j][i] = INF;
}
}
}
int ans = 0;
while (q.size() > 0) {
int y = q.front().first;
int x = q.front().second;
q.pop();
for (int dirY = -1; dirY <= 1; dirY++) {
for (int dirX = 0; dirX <= 1; dirX++) {
if ((dirY == dirX) || (dirY == -1 * dirX))
continue;
if (0 <= y + dirY && y + dirY < H && 0 <= x + dirX && x + dirX < W) {
if (memo[y + dirY][x + dirX] > memo[y][x] + 1) {
memo[y + dirY][x + dirX] = memo[y][x] + 1;
if (ans < memo[y + dirY][x + dirX])
ans = memo[y + dirY][x + dirX];
q.push(make_pair(y + dirY, x + dirX));
}
}
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define INF INT_MAX
typedef long long ll;
using namespace std;
char a[1005][1005];
int memo[1005][1005];
vector<pair<int, int>> b;
int main(void) {
int H, W;
cin >> H >> W;
queue<pair<int, int>> q;
for (int j = 0; j < H; j++) {
for (int i = 0; i < W; i++) {
cin >> a[j][i];
if (a[j][i] == '#') {
b.push_back(make_pair(j, i));
q.push(make_pair(j, i));
memo[j][i] = 0;
} else {
memo[j][i] = INF;
}
}
}
int ans = 0;
while (q.size() > 0) {
int y = q.front().first;
int x = q.front().second;
q.pop();
for (int dirY = -1; dirY <= 1; dirY++) {
for (int dirX = -1; dirX <= 1; dirX++) {
if ((dirY == dirX) || (dirY == -1 * dirX))
continue;
if (0 <= y + dirY && y + dirY < H && 0 <= x + dirX && x + dirX < W) {
if (memo[y + dirY][x + dirX] > memo[y][x] + 1) {
memo[y + dirY][x + dirX] = memo[y][x] + 1;
if (ans < memo[y + dirY][x + dirX])
ans = memo[y + dirY][x + dirX];
q.push(make_pair(y + dirY, x + dirX));
}
}
}
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 871,341 | 871,342 | u855087874 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / (2 * A) * B << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A * B << endl;
return 0;
}
| [] | 871,355 | 871,356 | u319179101 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (B / A) * T << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / A) * B << endl;
} | [
"identifier.change",
"io.output.change"
] | 871,357 | 871,358 | u280120599 | cpp |
p03059 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, n) for (int i = (a); i < (n); ++i)
using namespace std;
typedef long long ll;
void Main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * T / A << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, n) for (int i = (a); i < (n); ++i)
using namespace std;
typedef long long ll;
void Main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
| [] | 871,378 | 871,379 | u215692812 | cpp |
p03059 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int A, B, T;
cin >> A, B, T;
T = T / A;
B = B * T;
cout << B;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int A, B, T;
cin >> A >> B >> T;
T = T / A;
B = B * T;
cout << B;
}
| [] | 871,390 | 871,391 | u447604786 | cpp |
p03059 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define CHMAX(a, b) a = std::max(a, b)
#define CHMIN(a, b) a = std::min(a, b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std::cerr << a << std::endl
#define FOR(n) for (lli i = 0; i < n; i++)
using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using tlll = tuple<lli, lli, lli>;
lli mod197 = 1000000007LL;
// ax + by = gcd(a,b) 最大公約数
template <typename T> T extgcd(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int main(void) {
lli A, B, T;
cin >> A >> B >> T;
COUT(B * ((A + T - 1) / T));
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define CHMAX(a, b) a = std::max(a, b)
#define CHMIN(a, b) a = std::min(a, b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std::cerr << a << std::endl
#define FOR(n) for (lli i = 0; i < n; i++)
using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using tlll = tuple<lli, lli, lli>;
lli mod197 = 1000000007LL;
// ax + by = gcd(a,b) 最大公約数
template <typename T> T extgcd(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int main(void) {
lli A, B, T;
cin >> A >> B >> T;
COUT(B * ((T) / A));
}
| [
"expression.operation.binary.remove",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 871,403 | 871,404 | u155216115 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t + 0.5) / a * b << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << t / a * b << endl;
}
| [] | 871,441 | 871,442 | u974931918 | cpp |
p03059 | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
map<char, int> a;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c % a * b;
}
| #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
map<char, int> a;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c / a * b;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,458 | 871,459 | u677400065 | cpp |
p03059 | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
map<char, int> a;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c % b * a << endl;
}
| #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
map<char, int> a;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c / a * b;
}
| [
"expression.operator.arithmetic.change",
"io.output.change",
"expression.operation.binary.remove"
] | 871,460 | 871,459 | u677400065 | cpp |
p03059 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * T / A << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
return 0;
} | [] | 871,461 | 871,462 | u964124095 | cpp |
p03059 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * T / A << endl;
return 1;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
return 0;
} | [
"literal.number.change",
"function.return_value.change"
] | 871,463 | 871,462 | u964124095 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int main() {
ll A, B, T;
cin >> A >> B >> T;
printf("%lld", T * B / A);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int main() {
ll A, B, T;
cin >> A >> B >> T;
printf("%lld", (T / A) * B);
} | [
"call.arguments.change",
"expression.operation.binary.remove",
"call.arguments.add"
] | 871,466 | 871,467 | u527058497 | cpp |
p03059 | #include <algorithm>
#include <functional>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * T / A << endl;
}
| #include <algorithm>
#include <functional>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
}
| [] | 871,468 | 871,469 | u108484707 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A + B;
}
| #include <bits/stdc++.h>
using namespace std;
// atcoder125
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A * B;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,470 | 871,471 | u116136539 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A + B;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A * B;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,470 | 871,472 | u116136539 | cpp |
p03059 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll gcd(ll n, ll m) {
if (m == 0)
return n;
else
return gcd(m, n % m);
}
ll lcm(ll n, ll m) { return n / gcd(n, m) * m; }
string bit(ll n) {
string ans = "";
while (n > 0) {
char c = n % 2 + '0';
ans = c + ans;
n /= 2;
}
return ans;
}
ll order(ll n, ll p) {
ll ans = 0;
while (n % p == 0) {
ans++;
n /= p;
}
return ans;
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
ll fac[300010];
void modfac() {
fac[0] = 1;
for (ll i = 1; i < 300010; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
ll modcomb(ll n, ll k) {
return ((fac[n] * modinv(fac[k])) % mod * modinv(fac[n - k])) % mod;
}
// 仮ライブラリ（？）
int main() {
ll a, b, c;
cin >> a >> b >> c;
cout << b / a * c << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll gcd(ll n, ll m) {
if (m == 0)
return n;
else
return gcd(m, n % m);
}
ll lcm(ll n, ll m) { return n / gcd(n, m) * m; }
string bit(ll n) {
string ans = "";
while (n > 0) {
char c = n % 2 + '0';
ans = c + ans;
n /= 2;
}
return ans;
}
ll order(ll n, ll p) {
ll ans = 0;
while (n % p == 0) {
ans++;
n /= p;
}
return ans;
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
ll fac[300010];
void modfac() {
fac[0] = 1;
for (ll i = 1; i < 300010; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
ll modcomb(ll n, ll k) {
return ((fac[n] * modinv(fac[k])) % mod * modinv(fac[n - k])) % mod;
}
// 仮ライブラリ（？）
int main() {
ll a, b, c;
cin >> a >> b >> c;
cout << c / a * b << endl;
}
| [
"identifier.change",
"io.output.change"
] | 871,490 | 871,491 | u179970156 | cpp |
p03059 | //おまじない
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (a / b) * t << endl;
} | //おまじない
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
} | [
"identifier.change",
"io.output.change"
] | 871,492 | 871,493 | u277253335 | cpp |
p03059 | #include <stdio.h>
int main(void) {
int A, B, T;
scanf("%d%d%d", &A, &B, &T);
printf("%d", ((T + 0.5) / A) * B);
}
| #include <stdio.h>
int main(void) {
int A, B, T;
scanf("%d%d%d", &A, &B, &T);
printf("%d", (T / A) * B);
}
| [
"call.arguments.change"
] | 871,498 | 871,499 | u013168870 | cpp |
p03059 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define fr(i, k, N) for (ll i = k; i < N; i++)
#define rep(i, N) for (ll i = 0; i < N; i++)
#define ALL(v) v.begin(), v.end()
#define mp make_pair
using namespace std;
template <class X> void pr(X test) { cout << test << endl; }
template <class X> void prr(X test) {
for (auto it : test) {
cout << it << endl;
}
}
template <class X> void prrr(X test) {
int f = 0;
for (auto it : test) {
cout << (f++ != 0 ? " " : "") << it;
}
cout << endl;
}
template <typename X> istream &operator>>(istream &i, vector<X> &v) {
for (X &x : v)
i >> x;
return i;
}
class UF { // union find from https://github.com/kartikkukreja/blog-codes (MIT)
// [usage]
// auto uf = new UF(n);
// uf->merge(l, r); // 0 <= l, r <= n-1
// ...
public:
int *id; // inner id
int cnt; // number of all vartices
int *sz; // sz[i] means size of i's set
UF(int N) {
cnt = N;
id = new int[N];
sz = new int[N];
for (int i = 0; i < N; i++) {
id[i] = i;
sz[i] = 1;
}
}
~UF() {
delete[] id;
delete[] sz;
}
int find(int p) {
int root = p;
while (root != id[root])
root = id[root];
while (p != root) {
int newp = id[p];
id[p] = root;
p = newp;
}
return root;
}
void merge(int x, int y) {
int i = find(x);
int j = find(y);
if (i == j)
return;
if (sz[i] < sz[j]) {
id[i] = j;
sz[j] += sz[i];
} else {
id[j] = i;
sz[i] += sz[j];
}
cnt--;
}
bool connected(int x, int y) { return find(x) == find(y); }
int count() { return cnt; }
};
// return sorted 約数list 1 <= x <= n
vector<ll> divv(ll n) {
vector<ll> v;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
if (i * i != n)
v.push_back(n / i);
}
}
sort(ALL(v));
return v;
}
int main() {
ll n, b, t;
cin >> n >> b >> t;
pr(b * (t % n));
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define fr(i, k, N) for (ll i = k; i < N; i++)
#define rep(i, N) for (ll i = 0; i < N; i++)
#define ALL(v) v.begin(), v.end()
#define mp make_pair
using namespace std;
template <class X> void pr(X test) { cout << test << endl; }
template <class X> void prr(X test) {
for (auto it : test) {
cout << it << endl;
}
}
template <class X> void prrr(X test) {
int f = 0;
for (auto it : test) {
cout << (f++ != 0 ? " " : "") << it;
}
cout << endl;
}
template <typename X> istream &operator>>(istream &i, vector<X> &v) {
for (X &x : v)
i >> x;
return i;
}
class UF { // union find from https://github.com/kartikkukreja/blog-codes (MIT)
// [usage]
// auto uf = new UF(n);
// uf->merge(l, r); // 0 <= l, r <= n-1
// ...
public:
int *id; // inner id
int cnt; // number of all vartices
int *sz; // sz[i] means size of i's set
UF(int N) {
cnt = N;
id = new int[N];
sz = new int[N];
for (int i = 0; i < N; i++) {
id[i] = i;
sz[i] = 1;
}
}
~UF() {
delete[] id;
delete[] sz;
}
int find(int p) {
int root = p;
while (root != id[root])
root = id[root];
while (p != root) {
int newp = id[p];
id[p] = root;
p = newp;
}
return root;
}
void merge(int x, int y) {
int i = find(x);
int j = find(y);
if (i == j)
return;
if (sz[i] < sz[j]) {
id[i] = j;
sz[j] += sz[i];
} else {
id[j] = i;
sz[i] += sz[j];
}
cnt--;
}
bool connected(int x, int y) { return find(x) == find(y); }
int count() { return cnt; }
};
// return sorted 約数list 1 <= x <= n
vector<ll> divv(ll n) {
vector<ll> v;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
if (i * i != n)
v.push_back(n / i);
}
}
sort(ALL(v));
return v;
}
int main() {
ll n, b, t;
cin >> n >> b >> t;
pr(b * (t / n));
return 0;
}
| [
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 871,500 | 871,501 | u754514364 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int count;
count = ((c + 0.5) / a) * b;
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int count;
count = (c / a) * b;
cout << count << endl;
}
| [] | 871,508 | 871,509 | u818393512 | cpp |
p03059 | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T % A) * B << endl;
return 0;
}
| #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / A) * B << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,510 | 871,511 | u221769213 | cpp |
p03059 | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T % A * B << endl;
return 0;
} | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / A) * B << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,512 | 871,511 | u221769213 | cpp |
p03059 | #include <bits/stdc++.h>
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (begin); i > (end); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define ll long long
using namespace std;
using vec = vector<ll>;
using mat = vector<vec>;
using Pii = pair<ll, ll>;
using PiP = pair<ll, Pii>;
using PPi = pair<Pii, ll>;
int main() {
// 入力
ll A, B, T;
cin >> A >> B >> T;
cout << B * T / A << endl;
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (begin); i > (end); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define ll long long
using namespace std;
using vec = vector<ll>;
using mat = vector<vec>;
using Pii = pair<ll, ll>;
using PiP = pair<ll, Pii>;
using PPi = pair<Pii, ll>;
int main() {
// 入力
ll A, B, T;
cin >> A >> B >> T;
cout << B * (ll)(T / A) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 871,513 | 871,514 | u973797979 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T % A * B << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A * B << endl;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,515 | 871,516 | u393754572 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int a, b, t;
cin >> a;
cin >> b;
int n;
n = t / a;
cout << b * n << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, t;
cin >> a;
cin >> b;
cin >> t;
int n;
n = t / a;
cout << b * n << endl;
return 0;
}
| [] | 871,532 | 871,533 | u313043608 | cpp |
p03059 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define IREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define MOD (1000 * 1000 * 1000 + 7)
typedef long long ll;
typedef pair<int, int> pint;
int main() {
int a, b, t;
cin >> a >> b >> t;
int next = 0, cnt = -b, i = 1;
while (next <= t) {
next += a * i;
cnt = b;
}
cout << cnt;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define IREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define MOD (1000 * 1000 * 1000 + 7)
typedef long long ll;
typedef pair<int, int> pint;
int main() {
int a, b, t;
cin >> a >> b >> t;
int next = 0, cnt = -b, i = 1;
while (next <= t) {
next += a * i;
cnt += b;
}
cout << cnt;
return 0;
}
| [
"assignment.value.change"
] | 871,541 | 871,542 | u159117533 | cpp |
p03059 | ///...................................*****.................................................///
/// Mujahidul Islam ( mujahidulislam2923@gmail.com ) ///
/// Department of Ict /// Comilla University , Bangladesh. ///
///...................................*****.................................................///
#include <bits/stdc++.h>
using namespace std;
#define CIN \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define ll long long int
#define ull unsigned long long int
#define db double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sc scanf
#define pf printf
#define scin(x) scanf("%d", &(x))
#define scin2(x, y) scanf("%d %d", &(x), &(y))
#define scln(x) scanf("%lld", &(x))
#define scln2(x, y) scanf("%lld %lld", &(x), &(y))
#define min3(a, b, c) min(a, min(b, c))
#define min4(a, b, c, d) min(d, min(a, min(b, c)))
#define max3(a, b, c) max(a, max(b, c))
#define max4(a, b, c, d) max(d, max(a, max(b, c)))
#define ms(a, b) memset(a, b, sizeof(a))
#define mp make_pair
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a) * (b) / gcd(a, b))
#define input freopen("input.txt", "rt", stdin)
#define output freopen("output.txt", "wt", stdout)
#define PI 3.141592653589793238462643
#define rep(i, a, b) for (i = a; i < b; i++)
#define rev(i, a, b) for (i = a; i >= b; i--)
#define repx(i, a, b, x) for (i = a; i < b; i += x)
#define RUN_CASE(t, T) for (__typeof(t) t = 1; t <= T; t++)
#define zero(a) memset(a, 0, sizeof a)
#define all(v) v.begin(), v.end()
#define CASEL(t) printf("Case %d:\n", t)
/// priority_queue<int,vector<int>,greater<int> >pq;
///---------------Order set-------------------
/// template<typename T> using orderset
/// =tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
///#include <ext/pb_ds/assoc_container.hpp>
/// using namespace __gnu_pbds;
///*os.find_by_order(index) os.order_of_key(value)
///--------------Graph Moves--------------------------------------
/// const int fx[] = {+1,-1,+0,+0};
/// const int fy[] = {+0,+0,+1,-1};
/// const int fx[] = {+0,+0,+1,-1,-1,+1,-1,+1}; ///King's move
/// const int fy[] = {-1,+1,+0,+0,+1,+1,-1,-1}; ///king's Move
/// const int fx[] = {-2,-2,-1,-1,+1,+1,+2,+2}; ///knight's move
/// const int fy[] = {-1,+1,-2,+2,-2,+2,-1,+1}; ///knight's move
///---------------------------------------------------------------
int main() {
CIN;
int a, b, t;
cin >> a >> b >> t;
int c = t / a;
cout << a * b << endl;
return 0;
}
| ///...................................*****.................................................///
/// Mujahidul Islam ( mujahidulislam2923@gmail.com ) ///
/// Department of Ict /// Comilla University , Bangladesh. ///
///...................................*****.................................................///
#include <bits/stdc++.h>
using namespace std;
#define CIN \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define ll long long int
#define ull unsigned long long int
#define db double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sc scanf
#define pf printf
#define scin(x) scanf("%d", &(x))
#define scin2(x, y) scanf("%d %d", &(x), &(y))
#define scln(x) scanf("%lld", &(x))
#define scln2(x, y) scanf("%lld %lld", &(x), &(y))
#define min3(a, b, c) min(a, min(b, c))
#define min4(a, b, c, d) min(d, min(a, min(b, c)))
#define max3(a, b, c) max(a, max(b, c))
#define max4(a, b, c, d) max(d, max(a, max(b, c)))
#define ms(a, b) memset(a, b, sizeof(a))
#define mp make_pair
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a) * (b) / gcd(a, b))
#define input freopen("input.txt", "rt", stdin)
#define output freopen("output.txt", "wt", stdout)
#define PI 3.141592653589793238462643
#define rep(i, a, b) for (i = a; i < b; i++)
#define rev(i, a, b) for (i = a; i >= b; i--)
#define repx(i, a, b, x) for (i = a; i < b; i += x)
#define RUN_CASE(t, T) for (__typeof(t) t = 1; t <= T; t++)
#define zero(a) memset(a, 0, sizeof a)
#define all(v) v.begin(), v.end()
#define CASEL(t) printf("Case %d:\n", t)
/// priority_queue<int,vector<int>,greater<int> >pq;
///---------------Order set-------------------
/// template<typename T> using orderset
/// =tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
///#include <ext/pb_ds/assoc_container.hpp>
/// using namespace __gnu_pbds;
///*os.find_by_order(index) os.order_of_key(value)
///--------------Graph Moves--------------------------------------
/// const int fx[] = {+1,-1,+0,+0};
/// const int fy[] = {+0,+0,+1,-1};
/// const int fx[] = {+0,+0,+1,-1,-1,+1,-1,+1}; ///King's move
/// const int fy[] = {-1,+1,+0,+0,+1,+1,-1,-1}; ///king's Move
/// const int fx[] = {-2,-2,-1,-1,+1,+1,+2,+2}; ///knight's move
/// const int fy[] = {-1,+1,-2,+2,-2,+2,-1,+1}; ///knight's move
///---------------------------------------------------------------
int main() {
CIN;
int a, b, t;
cin >> a >> b >> t;
int c = t / a;
cout << c * b << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 871,554 | 871,555 | u191752096 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
cout << b * ((n + 0.5) / a);
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
cout << b * floor((n + 0.5) / a);
}
| [
"import.add",
"call.add"
] | 871,566 | 871,567 | u843985264 | cpp |
p03059 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int A, B;
float T;
cin >> A >> B >> T;
int ans;
ans = (T / A) * B;
cout << ans;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int A, B;
int T;
cin >> A >> B >> T;
int ans;
ans = (T / A) * B;
cout << ans;
} | [
"variable_declaration.type.primitive.change"
] | 871,571 | 871,572 | u475310126 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int a, b, t, n;
double tt, i;
cin >> a >> b >> t;
tt = t + 0.5;
n = 0;
while (tt > i) {
n++;
i = n * a;
}
int ans = n * b;
cout << ans << "\n";
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, t, n;
double tt, i;
cin >> a >> b >> t;
tt = t + 0.5;
n = 0;
while (tt > i) {
n++;
i = n * a;
}
int ans = (n - 1) * b;
cout << ans << "\n";
return 0;
} | [] | 871,573 | 871,574 | u271651326 | cpp |
p03059 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
//入力
int a, b, t, ans;
cin >> a >> b >> t;
//処理
ans = (t / b) * a;
//出力
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
//入力
int a, b, t, ans;
cin >> a >> b >> t;
//処理
ans = (t / a) * b;
//出力
cout << ans << endl;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 871,579 | 871,580 | u483697387 | cpp |
p03059 | #include <iostream>
using namespace std;
int main(void) {
int a, b, t;
cin >> a >> b >> t;
int createNum = a * (t / b);
cout << createNum << endl;
}
| #include <iostream>
using namespace std;
int main(void) {
int a, b, t;
cin >> a >> b >> t;
int createNum = b * (t / a);
cout << createNum << endl;
}
| [
"identifier.change",
"expression.operation.binary.change"
] | 871,585 | 871,586 | u344131382 | cpp |
p03059 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
using namespace std;
long gcd(long x, long y) {
if (x > y) {
return gcd(y, x);
}
long r;
while (y != 0) {
r = x % y;
x = y;
y = r;
}
return x;
}
long lcm(long x, long y) { return (x / gcd(x, y)) * y; }
void indexsort(long *first, long *last, long *func) {
sort(first, last, [&](long a, long b) { return func[a] < func[b]; });
}
//--------------------
int main() {
long res = 0;
long A, B, T;
cin >> A >> B >> T;
res = (A / T) * B;
cout << res << endl;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
using namespace std;
long gcd(long x, long y) {
if (x > y) {
return gcd(y, x);
}
long r;
while (y != 0) {
r = x % y;
x = y;
y = r;
}
return x;
}
long lcm(long x, long y) { return (x / gcd(x, y)) * y; }
void indexsort(long *first, long *last, long *func) {
sort(first, last, [&](long a, long b) { return func[a] < func[b]; });
}
//--------------------
int main() {
long res = 0;
long A, B, T;
cin >> A >> B >> T;
res = (T / A) * B;
cout << res << endl;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 871,595 | 871,596 | u545674098 | cpp |
p03059 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << ((t + 0.5) / a) * b << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
}
| [] | 871,616 | 871,617 | u959815036 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t + 0.5) / a * b << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << t / a * b << endl;
}
| [] | 871,598 | 871,635 | u535810324 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T % A) * B;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / A) * B;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,650 | 871,651 | u614576698 | cpp |
p03059 | #include <iostream>
int main() {
int A;
int B;
int T;
scanf("%d%d%d", &A, &B, &T);
printf("%d", (T + 0.5) / A * B);
}
| #include <iostream>
int main() {
int A;
int B;
int T;
scanf("%d%d%d", &A, &B, &T);
printf("%d", (T) / A * B);
}
| [
"expression.operation.binary.remove"
] | 871,654 | 871,655 | u077867937 | cpp |
p03059 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++) // for文マクロ
using namespace std;
typedef unsigned long ul;
typedef long long ll;
typedef pair<ul, ul> P; //ペア タイプでふ
int main() {
int A, B, T;
cin >> A;
cin >> B;
cin >> T;
cout << (int)(B * (((T + 0.5) - T % A) / A));
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++) // for文マクロ
using namespace std;
typedef unsigned long ul;
typedef long long ll;
typedef pair<ul, ul> P; //ペア タイプでふ
int main() {
int A, B, T;
cin >> A;
cin >> B;
cin >> T;
cout << (int)(B * ((T - T % A) / A));
// int A, B, C;
// cin >> A >> B >> C;
// if (A < C && C < B)
// {
// cout << "Yes";
// }
// else
// {
// cout << "No";
// }
} | [] | 871,656 | 871,657 | u369980487 | cpp |
p03059 | #include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define dbg(x) cerr << #x << " = " << x << endl
#define _ << ' ' <<
using namespace std;
using ll = long long;
using vi = vector<int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, t;
cin >> a >> b >> t;
cout << b * t / a;
}
| #include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define dbg(x) cerr << #x << " = " << x << endl
#define _ << ' ' <<
using namespace std;
using ll = long long;
using vi = vector<int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, t;
cin >> a >> b >> t;
cout << b * (t / a);
}
| [] | 871,676 | 871,677 | u562319622 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T % A) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,690 | 871,691 | u182791129 | cpp |
p03059 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int i, j, n, p, q, temp;
int a, b, t;
int time = 0;
int flag = 0;
string s;
cin >> a >> b >> t;
time = t / a;
cout << t * b;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int i, j, n, p, q, temp;
int a, b, t;
int time = 0;
int flag = 0;
string s;
cin >> a >> b >> t;
time = t / a;
cout << time * b;
return 0;
} | [
"identifier.change",
"io.output.change"
] | 871,702 | 871,703 | u942591696 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / B) * A;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / A) * B;
return 0;
} | [
"identifier.change",
"io.output.change"
] | 871,730 | 871,731 | u598952997 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int A = 0, B = 0, T = 0, C = 0;
cin >> A;
cin >> B;
cin >> T;
cout << (T % A) * B << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int A = 0, B = 0, T = 0, C = 0;
cin >> A >> B >> T;
cout << (T / A) * B << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,748 | 871,749 | u887035188 | cpp |
p03059 | #include "bits/stdc++.h"
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T) / A << endl;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A * B << endl;
} | [
"expression.operation.binary.remove"
] | 871,764 | 871,765 | u074003648 | cpp |
p03059 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define SIZE 10005
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
char str[SIZE];
int main() {
int n;
int A, B, T;
int count = 0;
std::cin >> A >> B >> T;
std::cout << B * T / A << std::endl;
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define SIZE 10005
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
char str[SIZE];
int main() {
int n;
int A, B, T;
int count = 0;
std::cin >> A >> B >> T;
std::cout << B * (T / A) << std::endl;
return 0;
} | [] | 871,799 | 871,800 | u509607636 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int a, b;
double t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b;
int t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 871,803 | 871,804 | u361344213 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T % A * B << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T / A * B << endl;
return 0;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 871,825 | 871,826 | u276588887 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << A * (B / T) << endl;
} | #include <iostream>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
} | [
"identifier.change",
"io.output.change",
"expression.operation.binary.remove"
] | 871,836 | 871,837 | u001858868 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << A * (T / B) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 871,840 | 871,841 | u539880178 | cpp |
p03059 | #include <stdio.h>
int main(void) {
int a, b, t;
scanf("%d %d %d", &a, &b, &t);
printf("%d¥n", t / a * b);
return 0;
} | #include <stdio.h>
int main() {
int a, b, t;
scanf("%d %d %d", &a, &b, &t);
printf("%d", t / a * b);
return 0;
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 871,869 | 871,870 | u679951803 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / b) * a << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << (t / a) * b << endl;
} | [
"identifier.change",
"io.output.change"
] | 871,880 | 871,881 | u798086274 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C * B / A << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C / A * B << endl;
}
| [
"expression.operation.binary.remove"
] | 871,884 | 871,885 | u764365016 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << A * B / C << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C / A * B << endl;
}
| [
"expression.operation.binary.remove"
] | 871,886 | 871,885 | u764365016 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << a * (b / t) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << b * (t / a) << endl;
return 0;
}
| [
"identifier.change",
"io.output.change",
"expression.operation.binary.remove"
] | 871,909 | 871,910 | u138245026 | cpp |
p03059 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int count = floor(t / a);
cout << a * count << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int count = floor(t / a);
cout << b * count << endl;
return 0;
} | [
"identifier.change",
"io.output.change"
] | 871,926 | 871,927 | u724169530 | cpp |
p03059 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int count = floor(t / a);
cout << count << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int count = floor(t / a);
cout << b * count << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 871,928 | 871,927 | u724169530 | cpp |
p03059 | #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, T;
int main() {
cin >> A >> B >> T;
out(B * (A / T));
}
| #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, T;
int main() {
cin >> A >> B >> T;
out(B * (T / A));
}
| [
"expression.operation.binary.remove"
] | 871,941 | 871,942 | u190907730 | cpp |
p03059 | #include <iostream>
#include <vector>
int main() {
int a, b, t;
std::cin >> a >> b >> t;
std::cout << (a / t) * b << std::endl;
} | #include <iostream>
#include <vector>
int main() {
int a, b, t;
std::cin >> a >> b >> t;
std::cout << (t / a) * b << std::endl;
} | [
"expression.operation.binary.remove"
] | 871,961 | 871,962 | u675512317 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << T * B / A << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T / A) * B << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 871,977 | 871,978 | u841641310 | cpp |
p03059 | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// const long long int MOD = 1000000007;
const int MOD = 1000000007;
// const int MOD = 998244353;
long long int N, M, K, H, W, L, R;
// int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M >> K;
cout << N / K * M << endl;
return 0;
} | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// const long long int MOD = 1000000007;
const int MOD = 1000000007;
// const int MOD = 998244353;
long long int N, M, K, H, W, L, R;
// int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M >> K;
cout << K / N * M << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 871,990 | 871,991 | u468700753 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << t / b * a << endl;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
cout << t / a * b << endl;
}
| [
"expression.operation.binary.remove"
] | 872,046 | 872,047 | u115106582 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
int C;
C == T / A;
cout << B * C << endl;
}
| #include <iostream>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
int C;
C = T / A;
cout << B * C << endl;
}
| [
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 872,048 | 872,049 | u119012830 | cpp |
p03059 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << A * (T / B) << "\n";
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << B * (T / A) << "\n";
return 0;
} | [
"identifier.change",
"io.output.change"
] | 872,071 | 872,072 | u890870565 | cpp |
p03059 | #include <stdio.h>
int main(int argc, char *argv[]) {
int A, B, T;
scanf("%d %d %d", &A, &B, &T);
int c = A / T;
printf("%d", c * B);
return 0;
} | #include <stdio.h>
int main(int argc, char *argv[]) {
int A, B, T;
scanf("%d %d %d", &A, &B, &T);
int c = T / A;
printf("%d", c * B);
return 0;
}
| [
"expression.operation.binary.remove"
] | 872,116 | 872,117 | u770567389 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int i = t % a;
i = a - i;
cout << (i / a) * b << endl;
} | #include <iostream>
using namespace std;
int main() {
int a, b, t;
cin >> a >> b >> t;
int i = t % a;
int n = t - i;
cout << (n / a) * b << endl;
} | [
"identifier.change",
"expression.operation.binary.change",
"io.output.change"
] | 872,118 | 872,119 | u766873156 | cpp |
p03059 | #include <bits/stdc++.h>
#define REP(n) for (int i = 0; i < (n); ++i)
#define RREP(n) for (int i = (n); i >= 0; --i)
#define FOR(m, n) for (int i = (m); i < (n); ++i)
#define SZ(x) ((int)(x).size())
#define BIT(n) (1LL << (n))
#define EXIST(x) ((x).find() != (x).end())
#define DEBUG(n) cerr << #n << " : " << n << '\n';
#define PB push_back
#define UB upper_bound // k <
#define LB lower_bound // k <=
#define F first
#define S second
#define INF 1.0e9
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long long> vll;
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
int r_up(const int a, const int b) { return (a + b - 1) / b; }
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
struct UFT {
vi p;
UFT() {}
UFT(int N) { p.resize(N, -1); }
int par(int a) {
if (p[a] >= 0) {
p[a] = par(p[a]);
return p[a];
}
return a;
}
int size(int a) { return -p[par(a)]; }
bool same(int a, int b) { return par(a) == par(b); }
void unite(int a, int b) {
a = par(a);
b = par(b);
if (a == b)
return;
if (size(a) < size(b))
swap(a, b);
p[a] -= size(b);
p[b] = a;
}
};
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << (c - 1) / a * b << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(n) for (int i = 0; i < (n); ++i)
#define RREP(n) for (int i = (n); i >= 0; --i)
#define FOR(m, n) for (int i = (m); i < (n); ++i)
#define SZ(x) ((int)(x).size())
#define BIT(n) (1LL << (n))
#define EXIST(x) ((x).find() != (x).end())
#define DEBUG(n) cerr << #n << " : " << n << '\n';
#define PB push_back
#define UB upper_bound // k <
#define LB lower_bound // k <=
#define F first
#define S second
#define INF 1.0e9
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long long> vll;
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
int r_up(const int a, const int b) { return (a + b - 1) / b; }
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
struct UFT {
vi p;
UFT() {}
UFT(int N) { p.resize(N, -1); }
int par(int a) {
if (p[a] >= 0) {
p[a] = par(p[a]);
return p[a];
}
return a;
}
int size(int a) { return -p[par(a)]; }
bool same(int a, int b) { return par(a) == par(b); }
void unite(int a, int b) {
a = par(a);
b = par(b);
if (a == b)
return;
if (size(a) < size(b))
swap(a, b);
p[a] -= size(b);
p[b] = a;
}
};
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c / a * b << endl;
return 0;
}
| [] | 872,126 | 872,127 | u691380397 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T + 0.5) / A * B << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, T;
cin >> A >> B >> T;
cout << (T + 1 / 2) / A * B << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 872,174 | 872,175 | u085887707 | cpp |
p03059 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fr(i, j, k) for (int i = j; i < k; i++)
#define f(n) fr(i, 0, n)
#define f1(n) fr(i, 1, n + 1)
#define ms(i) memset(i, -1, sizeof(i));
#define pb push_back
int main() {
ios_base::sync_with_stdio(0);
int a, b, t;
cin >> a >> b >> t;
cout << b * (a / t) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fr(i, j, k) for (int i = j; i < k; i++)
#define f(n) fr(i, 0, n)
#define f1(n) fr(i, 1, n + 1)
#define ms(i) memset(i, -1, sizeof(i));
#define pb push_back
int main() {
ios_base::sync_with_stdio(0);
int a, b, t;
cin >> a >> b >> t;
cout << b * (t / a) << endl;
} | [
"expression.operation.binary.remove"
] | 872,186 | 872,187 | u308590217 | cpp |
p03059 | #include <iostream>
using namespace std;
int main() {
int b, d, t;
int a, c, u;
cin >> a >> b >> t;
c = t / a;
d = a * c;
cout << d << endl;
}
| #include <iostream>
using namespace std;
int main() {
int b, d, t;
int a, c, u;
cin >> a >> b >> t;
c = t / a;
d = b * c;
cout << d << endl;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 872,198 | 872,199 | u443479321 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.