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 |
|---|---|---|---|---|---|---|---|
p02970 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
const long long MOD = 1000000007;
using namespace std;
typedef long long ll;
map<ll, int> mp;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, d;
cin >> n >> d;
int tmp = d * 2 + 1;
cout << n / tmp << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
const long long MOD = 1000000007;
using namespace std;
typedef long long ll;
map<ll, int> mp;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, d;
cin >> n >> d;
int tmp = d * 2 + 1;
cout << (n + tmp - 1) / tmp << endl;
return 0;
} | [] | 773,681 | 773,682 | u809967037 | cpp |
p02970 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << ceil(n / (d * 2 + 1)) << endl;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
double n, d;
cin >> n >> d;
cout << ceil(n / (d * 2 + 1)) << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 773,689 | 773,690 | u993074316 | cpp |
p02970 | /* B */
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << n + 2 * d / (2 * d + 1) << endl;
} | /* B */
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (n + 2 * d) / (2 * d + 1) << endl;
} | [] | 773,691 | 773,692 | u147762850 | cpp |
p02966 |
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int Max_N(505);
typedef long long int LL;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
#define gc() \
(iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin), \
(iS == iT ? EOF : *iS++)) \
: *iS++)
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT)
flush();
}
template <class I> inline void gi(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc())
if (c == '-')
f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc())
x = x * 10 + (c & 15);
x *= f;
}
template <class I> inline void print(I x) {
if (!x)
putc('0');
if (x < 0)
putc('-'), x = -x;
while (x)
qu[++qr] = x % 10 + '0', x /= 10;
while (qr)
putc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gi;
using io::print;
using io::putc;
int N;
LL A[Max_N][Max_N], Sum1[Max_N][Max_N], Sum2[Max_N][Max_N], F[Max_N][Max_N],
Ans;
inline LL query1(int l1, int r1, int l2, int r2) {
return Sum1[r1][r2] - Sum1[l1 - 1][r2] - Sum1[r1][l2 - 1] +
Sum1[l1 - 1][l2 - 1];
}
inline LL query2(int l1, int r1, int l2, int r2) {
return Sum2[r1][r2] - Sum2[l1 - 1][r2] - Sum2[r1][l2 - 1] +
Sum2[l1 - 1][l2 - 1];
}
inline void upd(LL &a, LL b) { a = min(a, b); }
int main() {
gi(N);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) {
if (i != j)
gi(A[i][j]);
Sum1[i][j] = Sum1[i - 1][j] + Sum1[i][j - 1] - Sum1[i - 1][j - 1] +
A[i][j] * (i < j);
Sum2[i][j] = Sum2[i - 1][j] + Sum2[i][j - 1] - Sum2[i - 1][j - 1] +
A[i][j] * (i > j);
}
Ans = Sum1[N][N];
for (int x = 1; x <= N - 1; ++x)
Ans = min(Ans, query1(1, x, 1, x) + query2(x + 1, N, x + 1, N));
memset(F, 0X3F, sizeof(F));
for (int a = 1; a <= N - 1; ++a)
for (int b = a + 1; b <= N - 1; ++b) {
upd(F[a][b], query1(1, a, 1, a) + query1(a + 1, b, a + 1, b) +
query2(b + 1, N, 1, a));
for (int c = b + 1; c <= N - 1; ++c)
upd(F[b][c],
F[a][b] + query1(b + 1, c, b + 1, c) + query2(c + 1, N, a + 1, b));
upd(Ans, F[a][b] + query1(b + 1, N, b + 1, N));
}
print(Ans);
return 0;
} |
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int Max_N(505);
typedef long long int LL;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
#define gc() \
(iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin), \
(iS == iT ? EOF : *iS++)) \
: *iS++)
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT)
flush();
}
template <class I> inline void gi(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc())
if (c == '-')
f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc())
x = x * 10 + (c & 15);
x *= f;
}
template <class I> inline void print(I x) {
if (!x)
putc('0');
if (x < 0)
putc('-'), x = -x;
while (x)
qu[++qr] = x % 10 + '0', x /= 10;
while (qr)
putc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gi;
using io::print;
using io::putc;
int N;
LL A[Max_N][Max_N], Sum1[Max_N][Max_N], Sum2[Max_N][Max_N], F[Max_N][Max_N],
Ans;
inline LL query1(int l1, int r1, int l2, int r2) {
return Sum1[r1][r2] - Sum1[l1 - 1][r2] - Sum1[r1][l2 - 1] +
Sum1[l1 - 1][l2 - 1];
}
inline LL query2(int l1, int r1, int l2, int r2) {
return Sum2[r1][r2] - Sum2[l1 - 1][r2] - Sum2[r1][l2 - 1] +
Sum2[l1 - 1][l2 - 1];
}
inline void upd(LL &a, LL b) { a = min(a, b); }
int main() {
gi(N);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) {
if (i != j)
gi(A[i][j]);
Sum1[i][j] = Sum1[i - 1][j] + Sum1[i][j - 1] - Sum1[i - 1][j - 1] +
A[i][j] * (i < j);
Sum2[i][j] = Sum2[i - 1][j] + Sum2[i][j - 1] - Sum2[i - 1][j - 1] +
A[i][j] * (i > j);
}
Ans = Sum1[N][N];
for (int x = 1; x <= N - 1; ++x)
Ans = min(Ans, query1(1, x, 1, x) + query1(x + 1, N, x + 1, N));
memset(F, 0X3F, sizeof(F));
for (int a = 1; a <= N - 1; ++a)
for (int b = a + 1; b <= N - 1; ++b) {
upd(F[a][b], query1(1, a, 1, a) + query1(a + 1, b, a + 1, b) +
query2(b + 1, N, 1, a));
for (int c = b + 1; c <= N - 1; ++c)
upd(F[b][c],
F[a][b] + query1(b + 1, c, b + 1, c) + query2(c + 1, N, a + 1, b));
upd(Ans, F[a][b] + query1(b + 1, N, b + 1, N));
}
print(Ans);
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 773,744 | 773,745 | u710399266 | cpp |
p02966 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
template <typename tn> void read(tn &a) {
tn x = 0, f = 1;
char c = ' ';
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
a = x * f;
}
int main() {
int n;
read(n);
int a[n + 1][n + 1] = {}, b[n + 1][n + 1] = {};
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++)
read(a[i][j]);
for (int j = i + 1; j <= n; j++)
read(b[i][j]);
}
ll s[2][510][510] = {};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
s[0][i][j] =
s[0][i - 1][j] + s[0][i][j - 1] - s[0][i - 1][j - 1] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
s[1][i][j] =
s[1][i - 1][j] + s[1][i][j - 1] - s[1][i - 1][j - 1] + b[i][j];
ll f[n + 1][n + 1];
memset(f, 63, sizeof(f));
auto calc = [&](int k, int a, int b, int c, int d) {
if (a > b || c > d)
return 0ll;
return s[k][b][d] - s[k][a - 1][d] - s[k][b][c - 1] + s[k][a - 1][c - 1];
};
auto chmin = [](ll &a, ll b) {
if (b < a)
a = b;
};
for (int i = 1; i <= n; i++)
f[1][i] = calc(1, 1, i, 2, i);
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++) {
for (int k = i + 1; k <= n; k++)
chmin(f[i + 1][k], f[j][i] + calc(1, i + 1, k, i + 2, k) +
calc(0, i + 1, k, 1, j - 1));
}
ll ans = 1e18;
for (int i = 1; i <= n; i++)
chmin(ans, f[i][n]);
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
template <typename tn> void read(tn &a) {
tn x = 0, f = 1;
char c = ' ';
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
a = x * f;
}
int main() {
int n;
read(n);
int a[n + 1][n + 1] = {}, b[n + 1][n + 1] = {};
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++)
read(a[i][j]);
for (int j = i + 1; j <= n; j++)
read(b[i][j]);
}
ll s[2][510][510] = {};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
s[0][i][j] =
s[0][i - 1][j] + s[0][i][j - 1] - s[0][i - 1][j - 1] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
s[1][i][j] =
s[1][i - 1][j] + s[1][i][j - 1] - s[1][i - 1][j - 1] + b[i][j];
ll f[n + 1][n + 1];
memset(f, 63, sizeof(f));
auto calc = [&](int k, int a, int b, int c, int d) {
if (a > b || c > d)
return 0ll;
return s[k][b][d] - s[k][a - 1][d] - s[k][b][c - 1] + s[k][a - 1][c - 1];
};
auto chmin = [](ll &a, ll b) {
if (b < a)
a = b;
};
for (int i = 1; i <= n; i++)
f[1][i] = calc(1, 1, i, 2, i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) {
for (int k = i + 1; k <= n; k++)
chmin(f[i + 1][k], f[j][i] + calc(1, i + 1, k, i + 2, k) +
calc(0, i + 1, k, 1, j - 1));
}
ll ans = 1e18;
for (int i = 1; i <= n; i++)
chmin(ans, f[i][n]);
cout << ans << '\n';
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 773,748 | 773,749 | u684730254 | cpp |
p02966 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
#define inc(x, y) \
{ \
x += (y); \
if (x >= mod) \
x -= mod; \
}
#define dec(x, y) \
{ \
x -= (y); \
if (x < 0) \
x += mod; \
}
using namespace std;
long long n, m, i, j, k, dp[505][505], w1[505][505], w2[505][505], a[505][505],
ans;
int main() {
scanf("%lld", &n);
fz1(i, n) {
fz1(j, n) if (i != j) { scanf("%lld", &a[i][j]); }
}
fz1(i, n) {
fd(j, n, i + 1) {
w1[i][j] = w1[i + 1][j];
fz1(k, i) { w1[i][j] += a[j][k]; }
}
}
fz1(i, n) {
fz(j, i, n + 1) {
w2[i][j] = w2[i][j - 1];
fz(k, i, j - 1) { w2[i][j] += a[k][j]; }
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
fz0g(i, n) {
fz(j, i, n) if (dp[i][j] < 0x3f3f3f3f3f3f3f3fll) {
fz(k, j + 1, n + 1) {
long long f = dp[i][j];
f += w2[j + 1][k];
f += w1[j][k + 1] - w1[i][k + 1];
dp[j][k] = min(dp[j][k], f);
}
}
}
ans = 0x3f3f3f3f3f3f3f3fll;
fz0g(i, n) { ans = min(ans, dp[i][n + 1]); }
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
#define inc(x, y) \
{ \
x += (y); \
if (x >= mod) \
x -= mod; \
}
#define dec(x, y) \
{ \
x -= (y); \
if (x < 0) \
x += mod; \
}
using namespace std;
long long n, m, i, j, k, dp[505][505], w1[505][505], w2[505][505], a[505][505],
ans;
int main() {
scanf("%lld", &n);
fz1(i, n) {
fz1(j, n) if (i != j) { scanf("%lld", &a[i][j]); }
}
fz1(i, n) {
fd(j, n, i + 1) {
w1[i][j] = w1[i][j + 1];
fz1(k, i) { w1[i][j] += a[j][k]; }
}
}
fz1(i, n) {
fz(j, i, n + 1) {
w2[i][j] = w2[i][j - 1];
fz(k, i, j - 1) { w2[i][j] += a[k][j]; }
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
fz0g(i, n) {
fz(j, i, n) if (dp[i][j] < 0x3f3f3f3f3f3f3f3fll) {
fz(k, j + 1, n + 1) {
long long f = dp[i][j];
f += w2[j + 1][k];
f += w1[j][k + 1] - w1[i][k + 1];
dp[j][k] = min(dp[j][k], f);
}
}
}
ans = 0x3f3f3f3f3f3f3f3fll;
fz0g(i, n) { ans = min(ans, dp[i][n + 1]); }
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 773,752 | 773,753 | u083440680 | cpp |
p02967 | #include <cstdio>
#include <cstdlib>
using namespace std;
int main() {
char *s = new char[1000010];
scanf("%s", s);
char *s_compr = new char[1000010];
int N = 0, N_compr = 0;
while (s[N]) {
if (N == 0 || s_compr[N_compr - 1] != s[N])
s_compr[N_compr++] = s[N];
N++;
}
delete[] s;
int cnt[3] = {};
for (int i = 0; i < N_compr; i++)
cnt[s_compr[i] - 'A']++;
int c_max = (cnt[1] > cnt[0]) ? 1 : 0;
if (cnt[2] >= cnt[c_max])
c_max = 2;
int c_min = (cnt[1] > cnt[0]) ? 0 : 1;
if (cnt[2] <= cnt[c_min])
c_min = 2;
if (cnt[0] > cnt[1]) {
cnt[0] ^= cnt[1];
cnt[1] ^= cnt[0];
cnt[0] ^= cnt[1];
}
if (cnt[0] > cnt[2]) {
cnt[0] ^= cnt[2];
cnt[2] ^= cnt[0];
cnt[0] ^= cnt[2];
}
if (cnt[1] > cnt[2]) {
cnt[1] ^= cnt[2];
cnt[2] ^= cnt[1];
cnt[1] ^= cnt[2];
}
if (cnt[0] == cnt[2]) {
printf("%s\n", s_compr);
delete[] s_compr;
return 0;
}
int d = cnt[2] - cnt[1];
for (int i = 0; i < N_compr; i++)
if (s_compr[i] - 'A' == c_max && d > 0)
if (i == 0 || i == N_compr - 1 || s_compr[i - 1] != s_compr[i + 1])
d--, cnt[2]--, s_compr[i] = 'Z';
for (int i = 1; i < N_compr - 1; i++)
if (s_compr[i] - 'A' == c_max && d > 0)
if (s_compr[i - 1] - 'A' == c_min)
d--, cnt[0]--, cnt[2]--, s_compr[i] = s_compr[i - 1] = 'Z';
if (d)
return 1;
N = N_compr = 0;
while (s_compr[N]) {
if (s_compr[N] <= 'C')
s_compr[N_compr++] = s_compr[N];
N++;
}
s_compr[N_compr] = 0;
d = cnt[1] - cnt[0];
int last = -1;
for (int i = 0; i < N_compr - 1; i++) {
if (d == 0)
break;
if (s_compr[i] - 'A' == c_max || s_compr[i + 1] - 'A' == c_max)
if (s_compr[i] - 'A' != c_min && s_compr[i + 1] - 'A' != c_min)
if (last == -1 || i == N_compr - 2 || s_compr[last] == s_compr[i + 2])
s_compr[i] += 4, s_compr[i + 1] += 4, d--;
if (s_compr[i] <= 'C')
last = i;
}
N = N_compr = 0;
while (s_compr[N]) {
if (s_compr[N] <= 'C')
s_compr[N_compr++] = s_compr[N];
N++;
}
s_compr[N_compr] = 0;
printf("%s\n", s_compr);
delete[] s_compr;
}
| #include <cstdio>
#include <cstdlib>
using namespace std;
int main() {
char *s = new char[1000010];
scanf("%s", s);
char *s_compr = new char[1000010];
int N = 0, N_compr = 0;
while (s[N]) {
if (N == 0 || s_compr[N_compr - 1] != s[N])
s_compr[N_compr++] = s[N];
N++;
}
delete[] s;
int cnt[3] = {};
for (int i = 0; i < N_compr; i++)
cnt[s_compr[i] - 'A']++;
int c_max = (cnt[1] > cnt[0]) ? 1 : 0;
if (cnt[2] >= cnt[c_max])
c_max = 2;
int c_min = (cnt[1] > cnt[0]) ? 0 : 1;
if (cnt[2] <= cnt[c_min])
c_min = 2;
if (cnt[0] > cnt[1]) {
cnt[0] ^= cnt[1];
cnt[1] ^= cnt[0];
cnt[0] ^= cnt[1];
}
if (cnt[0] > cnt[2]) {
cnt[0] ^= cnt[2];
cnt[2] ^= cnt[0];
cnt[0] ^= cnt[2];
}
if (cnt[1] > cnt[2]) {
cnt[1] ^= cnt[2];
cnt[2] ^= cnt[1];
cnt[1] ^= cnt[2];
}
if (cnt[0] == cnt[2]) {
printf("%s\n", s_compr);
delete[] s_compr;
return 0;
}
int d = cnt[2] - cnt[1];
for (int i = 0; i < N_compr; i++)
if (s_compr[i] - 'A' == c_max && d > 0)
if (i == 0 || i == N_compr - 1 || s_compr[i - 1] != s_compr[i + 1])
d--, cnt[2]--, s_compr[i] = 'Z';
for (int i = 1; i < N_compr - 1; i++)
if (s_compr[i] - 'A' == c_max && d > 0)
if (s_compr[i - 1] - 'A' == c_min)
d--, cnt[0]--, cnt[2]--, s_compr[i] = s_compr[i - 1] = 'Z';
if (d)
return 1;
N = N_compr = 0;
while (s_compr[N]) {
if (s_compr[N] <= 'C')
s_compr[N_compr++] = s_compr[N];
N++;
}
s_compr[N_compr] = 0;
d = cnt[1] - cnt[0];
int last = -1;
for (int i = 0; i < N_compr - 1; i++) {
if (d == 0)
break;
if (s_compr[i] - 'A' == c_max || s_compr[i + 1] - 'A' == c_max)
if (s_compr[i] - 'A' != c_min && s_compr[i + 1] - 'A' != c_min)
if (last == -1 || i == N_compr - 2 || s_compr[last] != s_compr[i + 2])
s_compr[i] += 4, s_compr[i + 1] += 4, d--;
if (s_compr[i] <= 'C')
last = i;
else
i++;
}
N = N_compr = 0;
while (s_compr[N]) {
if (s_compr[N] <= 'C')
s_compr[N_compr++] = s_compr[N];
N++;
}
s_compr[N_compr] = 0;
printf("%s\n", s_compr);
delete[] s_compr;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"expression.unary.arithmetic.add"
] | 773,772 | 773,771 | u642082255 | cpp |
p02968 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define N 505
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
const int n = read(), mod = read();
int dp[N][N >> 1], ans;
pair<int, int> p[N];
int getF(int x) {
int tmp = 2 * n - 1;
while (x * x + tmp * tmp > 4 * n * n)
--tmp;
return tmp + 1;
}
int getG(int x) {
int tmp = 2 * n - 1;
while (x * x + tmp * tmp >= n * n)
--tmp;
return tmp + 1;
}
int main() {
for (int i = 0; i < (n << 1); ++i) {
if (i < n)
p[i] = make_pair(getG(i), getF(i));
else
p[i] = make_pair(getF(i), 0);
}
sort(p, p + (n << 1));
for (int k = 0; k <= n; ++k) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int c1 = 0, c2 = 0;
for (int i = 0; i < (n << 1); ++i) {
if (!p[i].second) {
for (int j = 0; j <= k; ++j) {
dp[i + 1][j] =
(dp[i + 1][j] + 1LL * dp[i][j] * (p[i].first - j - c1)) % mod;
}
++c1;
} else {
for (int j = 0; j <= k; ++j) {
dp[i + 1][j] = (dp[i + 1][j] +
1LL * dp[i][j] * (p[i].second - k - n - (c2 - j))) %
mod;
dp[i + 1][j + 1] =
(dp[i + 1][j + 1] + 1LL * dp[i][j] * (p[i].first - c1 - j)) % mod;
}
++c2;
}
}
ans = (ans + (k & 1 ? -1 : 1) * dp[n << 1][k]) % mod;
}
printf("%d\n", ans);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define N 505
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
const int n = read(), mod = read();
int dp[N][N >> 1], ans;
pair<int, int> p[N];
int getF(int x) {
int tmp = 2 * n - 1;
while (x * x + tmp * tmp > 4 * n * n)
--tmp;
return tmp + 1;
}
int getG(int x) {
int tmp = 2 * n - 1;
while (x * x + tmp * tmp >= n * n)
--tmp;
return tmp + 1;
}
int main() {
for (int i = 0; i < (n << 1); ++i) {
if (i < n)
p[i] = make_pair(getG(i), getF(i));
else
p[i] = make_pair(getF(i), 0);
}
sort(p, p + (n << 1));
for (int k = 0; k <= n; ++k) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int c1 = 0, c2 = 0;
for (int i = 0; i < (n << 1); ++i) {
if (!p[i].second) {
for (int j = 0; j <= k; ++j) {
dp[i + 1][j] =
(dp[i + 1][j] + 1LL * dp[i][j] * (p[i].first - j - c1)) % mod;
}
++c1;
} else {
for (int j = 0; j <= k; ++j) {
dp[i + 1][j] = (dp[i + 1][j] +
1LL * dp[i][j] * (p[i].second - k - n - (c2 - j))) %
mod;
dp[i + 1][j + 1] =
(dp[i + 1][j + 1] + 1LL * dp[i][j] * (p[i].first - c1 - j)) % mod;
}
++c2;
}
}
ans = (ans + (k & 1 ? -1 : 1) * dp[n << 1][k]) % mod;
}
printf("%d\n", (ans + mod) % mod);
return 0;
}
| [
"call.arguments.change"
] | 773,773 | 773,774 | u979500307 | cpp |
p02968 | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;
const int N = 502;
int n, M, i, j, k, L[N], R[N], o, t;
ll f[N][N], Ans;
struct Uzi {
int id, u, v;
bool operator<(const Uzi &k) const {
if (u != k.u)
return u < k.u;
return v < k.v;
}
} p[N];
void init() {
scanf("%d%d", &n, &M);
for (i = 0; i < 2 * n; i++) {
L[i] = R[i] = -1;
for (j = 0; j < 2 * n; j++)
if (n * n <= i * i + j * j && i * i + j * j <= n * n * 4) {
if (L[i] == -1)
L[i] = j;
R[i] = j;
}
if (i < n)
p[i + 1] = (Uzi){i, L[i] - 1, R[i]};
else
p[i + 1] = (Uzi){i, R[i], L[i]};
}
sort(p + 1, p + 2 * n + 1);
}
void work() {
for (k = 0; k <= n; k++) {
memset(f, 0, sizeof(f));
f[0][0] = 1;
t = 0;
for (i = 1; i <= n * 2; i++) {
o = p[i].id;
for (j = 0; j <= k; j++) {
if (o >= n) {
f[i][j] = f[i - 1][j] * (R[o] + 1 - t - j);
} else {
f[i][j] = f[i - 1][j] * (R[o] + 1 - (2 * n - 1 - o) - (k - j)) % M;
if (j && L[o] > t + j - 1)
f[i][j] = (f[i][j] + f[i - 1][j - 1] * (L[o] - t - j + 1)) % M;
}
}
if (o >= n)
t++;
}
Ans = (Ans + f[n * 2][k] * (k % 2 ? -1 : 1) + M) % M;
}
printf("%lld", Ans);
}
int main() {
init();
work();
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;
const int N = 502;
int n, M, i, j, k, L[N], R[N], o, t;
ll f[N][N], Ans;
struct Uzi {
int id, u, v;
bool operator<(const Uzi &k) const {
if (u != k.u)
return u < k.u;
return v < k.v;
}
} p[N];
void init() {
scanf("%d%d", &n, &M);
for (i = 0; i < 2 * n; i++) {
L[i] = R[i] = -1;
for (j = 0; j < 2 * n; j++)
if (n * n <= i * i + j * j && i * i + j * j <= n * n * 4) {
if (L[i] == -1)
L[i] = j;
R[i] = j;
}
if (i < n)
p[i + 1] = (Uzi){i, L[i] - 1, R[i]};
else
p[i + 1] = (Uzi){i, R[i], L[i]};
}
sort(p + 1, p + 2 * n + 1);
}
void work() {
for (k = 0; k <= n; k++) {
memset(f, 0, sizeof(f));
f[0][0] = 1;
t = 0;
for (i = 1; i <= n * 2; i++) {
o = p[i].id;
for (j = 0; j <= k; j++) {
if (o >= n) {
f[i][j] = f[i - 1][j] * (R[o] + 1 - t - j) % M;
} else {
f[i][j] = f[i - 1][j] * (R[o] + 1 - (2 * n - 1 - o) - (k - j)) % M;
if (j && L[o] > t + j - 1)
f[i][j] = (f[i][j] + f[i - 1][j - 1] * (L[o] - t - j + 1)) % M;
}
}
if (o >= n)
t++;
}
Ans = (Ans + f[n * 2][k] * (k % 2 ? -1 : 1) + M) % M;
}
printf("%lld", Ans);
}
int main() {
init();
work();
return 0;
} | [
"assignment.change"
] | 773,779 | 773,780 | u517245163 | cpp |
p02968 | /*Lucky_Glass*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int N = 300;
int n, mod, Nf, Ng;
vector<pair<int, int>> Epr;
int Ef[N + 3][N + 3];
int main() {
scanf("%d%d", &n, &mod);
Nf = 2 * n - 1;
Ng = 2 * n - 1;
for (int i = 0; i < 2 * n; i++) {
while (i * i + Nf * Nf > 4 * n * n && Nf >= 0)
Nf--;
while (i * i + Ng * Ng >= n * n && Ng >= 0)
Ng--;
if (Ng == -1)
Epr.push_back(make_pair(Nf + 1, 0));
else
Epr.push_back(make_pair(Ng + 1, Nf + 1));
// printf("%d %d\n",Epr.back().first,Epr.back().second);
}
sort(Epr.begin(), Epr.end());
int Vans = 0;
long long typ = 1;
for (int k = 0; k <= n; k++) {
memset(Ef, 0, sizeof Ef);
Ef[0][0] = 1;
for (int i = 0, Ctf = 0, Ctg = 0; i < (int)Epr.size();
Ctg += Epr[i].second == 0, Ctf += Epr[i].second != 0, i++) {
for (int j = 0; j <= k; j++) {
int tmp = Ef[i][j];
if (Epr[i].second) {
if (j != k)
Ef[i + 1][j + 1] = (Ef[i + 1][j + 1] +
1ll * tmp * (Epr[i].first - j - Ctg) % mod) %
mod;
Ef[i + 1][j] =
(Ef[i + 1][j] +
1ll * tmp * (Epr[i].second - k - n - (Ctf - j)) % mod) %
mod;
} else
Ef[i + 1][j] =
(Ef[i + 1][j] + 1ll * tmp * (Epr[i].first - j - Ctg) % mod) % mod;
}
// printf("%d %d\n",Ctf,Ctg);
}
// printf("%d\n",Ef[Epr.size()][k]);
Vans = (Vans + typ * Ef[Epr.size()][k] + mod) % mod;
typ *= -1;
}
printf("%d\n", Vans);
return 0;
} | /*Lucky_Glass*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int N = 700;
int n, mod, Nf, Ng;
vector<pair<int, int>> Epr;
int Ef[N + 3][N + 3];
int main() {
scanf("%d%d", &n, &mod);
Nf = 2 * n - 1;
Ng = 2 * n - 1;
for (int i = 0; i < 2 * n; i++) {
while (i * i + Nf * Nf > 4 * n * n && Nf >= 0)
Nf--;
while (i * i + Ng * Ng >= n * n && Ng >= 0)
Ng--;
if (i >= n)
Epr.push_back(make_pair(Nf + 1, 0));
else
Epr.push_back(make_pair(Ng + 1, Nf + 1));
// printf("%d %d\n",Epr.back().first,Epr.back().second);
}
sort(Epr.begin(), Epr.end());
int Vans = 0;
long long typ = 1;
for (int k = 0; k <= n; k++) {
memset(Ef, 0, sizeof Ef);
Ef[0][0] = 1;
for (int i = 0, Ctf = 0, Ctg = 0; i < (int)Epr.size();
Ctg += Epr[i].second == 0, Ctf += Epr[i].second != 0, i++) {
for (int j = 0; j <= k; j++) {
int tmp = Ef[i][j];
if (Epr[i].second) {
if (j != k)
Ef[i + 1][j + 1] = (Ef[i + 1][j + 1] +
1ll * tmp * (Epr[i].first - j - Ctg) % mod) %
mod;
Ef[i + 1][j] =
(Ef[i + 1][j] +
1ll * tmp * (Epr[i].second - k - n - (Ctf - j)) % mod) %
mod;
} else
Ef[i + 1][j] =
(Ef[i + 1][j] + 1ll * tmp * (Epr[i].first - j - Ctg) % mod) % mod;
}
// printf("%d %d\n",Ctf,Ctg);
}
// printf("%d\n",Ef[Epr.size()][k]);
Vans = (Vans + typ * Ef[Epr.size()][k] + mod) % mod;
typ *= -1;
}
printf("%d\n", Vans);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"control_flow.branch.if.condition.change"
] | 773,790 | 773,791 | u414712570 | cpp |
p02968 | /*Lucky_Glass*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int N = 300;
int n, mod, Nf, Ng;
vector<pair<int, int>> Epr;
int Ef[N + 3][N + 3];
int main() {
scanf("%d%d", &n, &mod);
Nf = 2 * n - 1;
Ng = 2 * n - 1;
for (int i = 0; i < 2 * n; i++) {
while (i * i + Nf * Nf > 4 * n * n && Nf >= 0)
Nf--;
while (i * i + Ng * Ng >= n * n && Ng >= 0)
Ng--;
if (Ng == -1)
Epr.push_back(make_pair(Nf + 1, 0));
else
Epr.push_back(make_pair(Ng + 1, Nf + 1));
// printf("%d %d\n",Epr.back().first,Epr.back().second);
}
sort(Epr.begin(), Epr.end());
int Vans = 0;
long long typ = 1;
for (int k = 0; k <= n; k++) {
memset(Ef, 0, sizeof Ef);
Ef[0][0] = 1;
for (int i = 0, Ctf = 0, Ctg = 0; i < (int)Epr.size();
Ctg += Epr[i].second == 0, Ctf += Epr[i].second != 0, i++) {
for (int j = 0; j <= k; j++) {
int tmp = Ef[i][j];
if (Epr[i].second) {
if (j != k)
Ef[i + 1][j + 1] = (Ef[i + 1][j + 1] +
1ll * tmp * (Epr[i].first - j - Ctg) % mod) %
mod;
Ef[i + 1][j] =
(Ef[i + 1][j] +
1ll * tmp * (Epr[i].second - k - n - (Ctf - j)) % mod) %
mod;
} else
Ef[i + 1][j] =
(Ef[i + 1][j] + 1ll * tmp * (Epr[i].first - j - Ctg) % mod) % mod;
}
// printf("%d %d\n",Ctf,Ctg);
}
// printf("%d\n",Ef[Epr.size()][k]);
Vans = (Vans + typ * Ef[Epr.size()][k] + mod) % mod;
typ *= -1;
}
printf("%d\n", Vans);
return 0;
} | /*Lucky_Glass*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int N = 700;
int n, mod, Nf, Ng;
vector<pair<int, int>> Epr;
int Ef[N + 3][N + 3];
int main() {
scanf("%d%d", &n, &mod);
Nf = 2 * n - 1;
Ng = 2 * n - 1;
for (int i = 0; i < 2 * n; i++) {
while (i * i + Nf * Nf > 4 * n * n && Nf >= 0)
Nf--;
while (i * i + Ng * Ng >= n * n && Ng >= 0)
Ng--;
if (Ng == -1)
Epr.push_back(make_pair(Nf + 1, 0));
else
Epr.push_back(make_pair(Ng + 1, Nf + 1));
// printf("%d %d\n",Epr.back().first,Epr.back().second);
}
sort(Epr.begin(), Epr.end());
int Vans = 0;
long long typ = 1;
for (int k = 0; k <= n; k++) {
memset(Ef, 0, sizeof Ef);
Ef[0][0] = 1;
for (int i = 0, Ctf = 0, Ctg = 0; i < (int)Epr.size();
Ctg += Epr[i].second == 0, Ctf += Epr[i].second != 0, i++) {
for (int j = 0; j <= k; j++) {
int tmp = Ef[i][j];
if (Epr[i].second) {
if (j != k)
Ef[i + 1][j + 1] = (Ef[i + 1][j + 1] +
1ll * tmp * (Epr[i].first - j - Ctg) % mod) %
mod;
Ef[i + 1][j] =
(Ef[i + 1][j] +
1ll * tmp * (Epr[i].second - k - n - (Ctf - j)) % mod) %
mod;
} else
Ef[i + 1][j] =
(Ef[i + 1][j] + 1ll * tmp * (Epr[i].first - j - Ctg) % mod) % mod;
}
// printf("%d %d\n",Ctf,Ctg);
}
// printf("%d\n",Ef[Epr.size()][k]);
Vans = (Vans + typ * Ef[Epr.size()][k] + mod) % mod;
typ *= -1;
}
printf("%d\n", Vans);
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 773,790 | 773,792 | u414712570 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int cnt = 0;
while (n < 0) {
cnt++;
n -= 2 * d + 1;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int cnt = 0;
while (n > 0) {
cnt++;
n -= 2 * d + 1;
}
cout << cnt << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 773,797 | 773,798 | u796877631 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int ans;
ans = N / (2 * D + 1);
if (ans * (2 * D + 1) > N)
ans++;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int ans;
ans = N / (2 * D + 1);
if (ans * (2 * D + 1) < N)
ans++;
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 773,799 | 773,800 | u429665788 | cpp |
p02970 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
#define INF 1001001001
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int x = 2 * d - 1;
int ans = (n + x - 1) / x;
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
#define INF 1001001001
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int x = 2 * d + 1;
int ans = (n + x - 1) / x;
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 773,809 | 773,810 | u971166345 | cpp |
p02970 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using llint = long long;
using vint = vector<int>;
int main() {
int n, d;
cin >> n >> d;
cout << ceil(n / (2 * d + 1)) << endl;
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using llint = long long;
using vint = vector<int>;
int main() {
int n, d;
cin >> n >> d;
cout << ceil((double)n / (2 * d + 1)) << endl;
return 0;
} | [
"type_conversion.add"
] | 773,825 | 773,826 | u932319885 | cpp |
p02970 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using llint = long long;
using vint = vector<int>;
int main() {
int n, d;
cin >> n >> d;
cout << floor(n / (2 * d + 1)) << endl;
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using llint = long long;
using vint = vector<int>;
int main() {
int n, d;
cin >> n >> d;
cout << ceil((double)n / (2 * d + 1)) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 773,827 | 773,826 | u932319885 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, h, ans;
cin >> n >> d;
h = d * 1;
ans = n / h;
if (n % h > 0) {
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, h, ans;
cin >> n >> d;
h = d * 2 + 1;
ans = n / h;
if (n % h > 0) {
ans++;
}
cout << ans << endl;
} | [
"assignment.change"
] | 773,836 | 773,837 | u442754977 | cpp |
p02970 | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << ceil(n / (2 * d + 1)) << endl;
} | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main() {
float n, d;
cin >> n >> d;
cout << ceil(n / (2 * d + 1)) << endl;
} | [
"variable_declaration.type.primitive.change"
] | 773,848 | 773,849 | u267222408 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define ll long long // long long省略
#define pb push_back // push_back省略
#define mp make_pair // make_pair省略
#define fi first // first省略
#define se second // second省略
#define itn int // int誤字保険
#define count cout // cout誤字保険
#define vecotr vector // vector誤字保険
#define ednl endl // endl誤字保険
#define opt() \
cin.tie(0); \
ios::sync_with_stdio(false) // 入出力速度改善
#define rep(i, l, r) \
for (ll i = (l); i < (r); i++) // 範囲[l, r)で刻み1のfor文(順方向)
#define repp(i, l, r, k) \
for (ll i = (l); i < (r); i += (k)) // 範囲[l, r)で刻みkのfor文(順方向)
#define rrep(i, l, r) \
for (ll i = (r - 1); i >= (l); i--) // 範囲[l, r)で刻み1のfor文(逆方向)
#define rrepp(i, l, r, k) \
for (ll i = (r - 1); i >= (l); i -= (k)) // 範囲[l, r)で刻みkのfor文(逆方向)
#define all(x) (x).begin(), (x).end() // vectorのポインタ位置指定用
#define max(p, q) ((p) > (q) ? (p) : (q)) // max拡張
#define min(p, q) ((p) < (q) ? (p) : (q)) // min拡張
#define bit(n, m) (((n) >> (m)) & 1) // 変数nのm番目のbitを取り出す
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 dy[] = {0, 1, 0, -1}; // 4方向近傍
int dx[] = {1, 0, -1, 0}; // 4方向近傍
int main() {
ll a, b;
cin >> a >> b;
cout << (a + 2 * b + 1 - 1) / (2 * b + 1) + 1 << ednl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long // long long省略
#define pb push_back // push_back省略
#define mp make_pair // make_pair省略
#define fi first // first省略
#define se second // second省略
#define itn int // int誤字保険
#define count cout // cout誤字保険
#define vecotr vector // vector誤字保険
#define ednl endl // endl誤字保険
#define opt() \
cin.tie(0); \
ios::sync_with_stdio(false) // 入出力速度改善
#define rep(i, l, r) \
for (ll i = (l); i < (r); i++) // 範囲[l, r)で刻み1のfor文(順方向)
#define repp(i, l, r, k) \
for (ll i = (l); i < (r); i += (k)) // 範囲[l, r)で刻みkのfor文(順方向)
#define rrep(i, l, r) \
for (ll i = (r - 1); i >= (l); i--) // 範囲[l, r)で刻み1のfor文(逆方向)
#define rrepp(i, l, r, k) \
for (ll i = (r - 1); i >= (l); i -= (k)) // 範囲[l, r)で刻みkのfor文(逆方向)
#define all(x) (x).begin(), (x).end() // vectorのポインタ位置指定用
#define max(p, q) ((p) > (q) ? (p) : (q)) // max拡張
#define min(p, q) ((p) < (q) ? (p) : (q)) // min拡張
#define bit(n, m) (((n) >> (m)) & 1) // 変数nのm番目のbitを取り出す
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 dy[] = {0, 1, 0, -1}; // 4方向近傍
int dx[] = {1, 0, -1, 0}; // 4方向近傍
int main() {
ll a, b;
cin >> a >> b;
cout << (a + 2 * b) / (2 * b + 1) << ednl;
}
| [
"expression.operation.binary.remove"
] | 773,852 | 773,853 | u547754910 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, d;
cin >> n >> d;
b = 2 * d + 1;
cout << (n + d - 1) / d;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, d;
cin >> n >> d;
b = 2 * d + 1;
cout << (n + b - 1) / b;
} | [
"identifier.change",
"io.output.change"
] | 773,858 | 773,859 | u930243369 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, d;
cin >> n >> d;
b = 2 * d + 1;
cout << n + d - 1 / d;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, d;
cin >> n >> d;
b = 2 * d + 1;
cout << (n + b - 1) / b;
} | [
"identifier.change",
"io.output.change"
] | 773,860 | 773,859 | u930243369 | cpp |
p02970 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
long long int gcd(long long int x, long long int y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
int main(void) {
double n, d;
cin >> n >> d;
cout << ceil(n / d * 2.0 + 1.0) << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
long long int gcd(long long int x, long long int y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
int main(void) {
double n, d;
cin >> n >> d;
cout << ceil(n / (d * 2.0 + 1.0)) << endl;
return 0;
} | [
"call.arguments.change"
] | 773,864 | 773,865 | u114838227 | cpp |
p02970 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int a, b, i;
cin >> a >> b;
for (i = 0;; i++) {
if (a < (1 + 2 * b) * i)
break;
}
cout << i << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int a, b, i;
cin >> a >> b;
for (i = 0;; i++) {
if (a <= (1 + 2 * b) * i)
break;
}
cout << i << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 773,875 | 773,876 | u937275419 | cpp |
p02970 | #include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
int n, d, m;
cin >> n >> d;
d *= 2;
m = n / d;
if (n % d > 0) {
m++;
}
cout << m;
return 0;
} | #include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
int n, d, m;
cin >> n >> d;
d *= 2;
d++;
m = n / d;
if (n % d > 0) {
m++;
}
cout << m;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 773,889 | 773,890 | u834488582 | cpp |
p02970 | #include <stdio.h>
int solve(int n, int d);
int main() {
int n, d;
//入力
scanf("%d%d", &n, &d);
int ans = solve(n, d);
printf("%d\n", ans);
return 0;
}
int solve(int n, int d) {
if (n < 0)
return 0;
else
return solve(n - (2 * d + 1), d) + 1;
} | #include <stdio.h>
int solve(int n, int d);
int main() {
int n, d;
//入力
scanf("%d%d", &n, &d);
int ans = solve(n, d);
printf("%d\n", ans);
return 0;
}
int solve(int n, int d) {
if (n <= 0)
return 0;
else
return solve(n - (2 * d + 1), d) + 1;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 773,900 | 773,901 | u469783285 | cpp |
p02970 | #include <stdio.h>
int solve(int n, int d);
int main() {
int n, d;
//入力
scanf("%d%d", &n, &d);
int ans = solve(n, d);
printf("%d\n", ans);
return 0;
}
int solve(int n, int d) {
if (n > 0)
return 0;
else
return solve(n - (2 * d + 1), d) + 1;
} | #include <stdio.h>
int solve(int n, int d);
int main() {
int n, d;
//入力
scanf("%d%d", &n, &d);
int ans = solve(n, d);
printf("%d\n", ans);
return 0;
}
int solve(int n, int d) {
if (n <= 0)
return 0;
else
return solve(n - (2 * d + 1), d) + 1;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 773,902 | 773,901 | u469783285 | cpp |
p02970 | #include <stdio.h>
int solve(int n, int d);
int main() {
int n, d;
//入力
scanf("%d%d", &n, &d);
int ans = solve(n, d);
printf("%d\n", ans);
return 0;
}
int solve(int n, int d) {
if (n > 0)
return 0;
else
solve(n - (2 * d + 1), d) + 1;
} | #include <stdio.h>
int solve(int n, int d);
int main() {
int n, d;
//入力
scanf("%d%d", &n, &d);
int ans = solve(n, d);
printf("%d\n", ans);
return 0;
}
int solve(int n, int d) {
if (n <= 0)
return 0;
else
return solve(n - (2 * d + 1), d) + 1;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.return.add"
] | 773,903 | 773,901 | u469783285 | cpp |
p02970 | // C
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <forward_list>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// Others
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int dx[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
const int dy[8] = {1, 1, 1, 0, 0, -1, -1, -1};
// LOVE NyantakoGG https://www.youtube.com/channel/UC6XdFs8T6Ei54O0FYl3PVVA
using namespace std;
int main() {
int N, D;
cin >> N >> D;
D = D * 2 + 1;
cout << ceil(N / D) << endl;
}
| // C
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <forward_list>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// Others
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int dx[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
const int dy[8] = {1, 1, 1, 0, 0, -1, -1, -1};
// LOVE NyantakoGG https://www.youtube.com/channel/UC6XdFs8T6Ei54O0FYl3PVVA
using namespace std;
int main() {
double N, D;
cin >> N >> D;
D = D * 2 + 1;
cout << ceil(N / D) << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 773,904 | 773,905 | u685346012 | cpp |
p02970 | #include <algorithm>
#include <bitset>
#include <cfenv>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
ll dp[100010];
ll cost[12];
int main() {
double n = 0, k, m = 0;
ll ans = 0;
ll t = 0;
vector<ll> v;
string s;
cin >> n >> k;
cout << ceil(n / (k + 1));
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cfenv>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
ll dp[100010];
ll cost[12];
int main() {
double n = 0, k, m = 0;
ll ans = 0;
ll t = 0;
vector<ll> v;
string s;
cin >> n >> k;
cout << ceil(n / (k * 2 + 1));
return 0;
}
| [
"expression.operation.binary.add"
] | 773,906 | 773,907 | u143100985 | cpp |
p02970 | #include <algorithm>
#include <bitset>
#include <cfenv>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
ll dp[100010];
ll cost[12];
int main() {
double n = 0, k, m = 0;
ll ans = 0;
ll t = 0;
vector<ll> v;
string s;
cin >> n >> k;
cout << round(n / (k * 2 + 1));
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cfenv>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
ll dp[100010];
ll cost[12];
int main() {
double n = 0, k, m = 0;
ll ans = 0;
ll t = 0;
vector<ll> v;
string s;
cin >> n >> k;
cout << ceil(n / (k * 2 + 1));
return 0;
}
| [
"identifier.change",
"call.function.near.change",
"io.output.change"
] | 773,908 | 773,907 | u143100985 | cpp |
p02970 | #include <algorithm>
#include <bitset>
#include <cfenv>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
ll dp[100010];
ll cost[12];
int main() {
double n = 0, k, m = 0;
ll ans = 0;
ll t = 0;
vector<ll> v;
string s;
cin >> n >> k;
cout << round(n / (k + 1));
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cfenv>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
ll dp[100010];
ll cost[12];
int main() {
double n = 0, k, m = 0;
ll ans = 0;
ll t = 0;
vector<ll> v;
string s;
cin >> n >> k;
cout << ceil(n / (k * 2 + 1));
return 0;
}
| [
"identifier.change",
"call.function.near.change",
"io.output.change"
] | 773,909 | 773,907 | u143100985 | cpp |
p02970 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main(void) {
int n, d;
cin >> n >> d;
cout << (n + 2 * d - 1) / (2 * d);
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main(void) {
int n, d;
cin >> n >> d;
cout << (n + 2 * d) / (2 * d + 1);
}
| [
"expression.operation.binary.remove"
] | 773,912 | 773,913 | u243407720 | cpp |
p02970 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define PB push_back
#define MP make_pairA
#define REP(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, d;
cin >> n >> d;
cout << n / (d * 2 + 1) << endl;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define PB push_back
#define MP make_pairA
#define REP(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, d;
cin >> n >> d;
cout << (n + d * 2) / (d * 2 + 1) << endl;
}
| [] | 773,918 | 773,919 | u572537642 | cpp |
p02970 | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort(ALL(V)) //小さい方からソート
#define REV(V) reverse(ALL(V)) //リバース
#define RSORT(V) REV(SORT(V)) //大きい方からソート
#define NPN(V) next_permutation(ALL(V)) //順列
#define pb(n) push_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define RAPID \
cin.tie(0); \
ios::sync_with_stdio(false)
#define IN(n) cin >> n
#define IN2(a, b) cin >> a >> b
#define IN3(a, b, c) cin >> a >> b >> c
#define VIN(V) \
for (int i = 0; i < (V).size(); i++) { \
cin >> (V).at(i); \
}
#define OUT(n) cout << n << endl
#define VOUT(V) \
REP(i, (V).size()) { cout << (V)[i] << endl; }
#define VOUT2(V) \
REP(i, (V).size()) { cout << (V)[i] << " "; } \
cout << endl;
// 型マクロ定義
#define int long long
#define P pair<ll, ll>
#define Vi vector<ll>
#define Vd vector<double>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll, ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue < ll, V, greater<ll>
//
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最小公倍数
// デフォルト変数定義
int n, m, a, b, c, x, y, z;
double d, e, f;
string s, t;
//
signed main() {
RAPID;
IN2(n, a);
OUT(ceil(n / (2 * a + 1)));
} | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort(ALL(V)) //小さい方からソート
#define REV(V) reverse(ALL(V)) //リバース
#define RSORT(V) REV(SORT(V)) //大きい方からソート
#define NPN(V) next_permutation(ALL(V)) //順列
#define pb(n) push_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define RAPID \
cin.tie(0); \
ios::sync_with_stdio(false)
#define IN(n) cin >> n
#define IN2(a, b) cin >> a >> b
#define IN3(a, b, c) cin >> a >> b >> c
#define VIN(V) \
for (int i = 0; i < (V).size(); i++) { \
cin >> (V).at(i); \
}
#define OUT(n) cout << n << endl
#define VOUT(V) \
REP(i, (V).size()) { cout << (V)[i] << endl; }
#define VOUT2(V) \
REP(i, (V).size()) { cout << (V)[i] << " "; } \
cout << endl;
// 型マクロ定義
#define int long long
#define P pair<ll, ll>
#define Vi vector<ll>
#define Vd vector<double>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll, ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue < ll, V, greater<ll>
//
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最小公倍数
// デフォルト変数定義
double n, m, a, b, c, x, y, z;
double d, e, f;
string s, t;
//
signed main() {
RAPID;
IN2(n, a);
OUT(ceil(n / (2 * a + 1)));
} | [
"variable_declaration.type.primitive.change"
] | 773,933 | 773,934 | u154645927 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, d;
cin >> n >> d;
d *= 2;
cout << ll(ceil(1.0 * n / d));
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, d;
cin >> n >> d;
d = 2 * d + 1;
cout << ll(ceil(1.0 * n / d));
}
| [
"assignment.value.change",
"assignment.change"
] | 773,935 | 773,936 | u193637378 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, x;
cin >> n >> x;
cout << (n + 2 * x - 1) / (2 * x) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, x;
cin >> n >> x;
cout << (n + 2 * x) / (2 * x + 1) << '\n';
return 0;
}
| [
"expression.operation.binary.remove"
] | 773,941 | 773,942 | u577246184 | cpp |
p02970 | // shan61916
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dll;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl "\n"
#define pll pair<ll, ll>
#define all(x) x.begin(), x.end()
#define vll vector<ll>
const ll inf = (ll)(1e17 + 17);
const ll mod = (ll)(1e9 + 7);
int main() {
IOS
#ifdef SHAN
freopen("input.txt", "r", stdin);
#endif
ll n, d;
cin >> n >> d;
cout << (n + (2 * d) - 1) / (2 * d);
return 0;
} // good night. | // shan61916
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dll;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl "\n"
#define pll pair<ll, ll>
#define all(x) x.begin(), x.end()
#define vll vector<ll>
const ll inf = (ll)(1e17 + 17);
const ll mod = (ll)(1e9 + 7);
int main() {
IOS
#ifdef SHAN
freopen("input.txt", "r", stdin);
#endif
ll n, d;
cin >> n >> d;
cout << (n + (2 * d)) / (2 * d + 1);
return 0;
} // good night. | [
"expression.operation.binary.remove"
] | 773,943 | 773,944 | u032226420 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int ans = 0;
int range = d * 2 + 1;
for (int i = 0; n > 1; i++) {
ans++;
n -= range;
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int ans = 0;
int range = d * 2 + 1;
for (int i = 0; n > 0; i++) {
ans++;
n -= range;
}
cout << ans;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 773,960 | 773,961 | u260907804 | cpp |
p02970 | #include <algorithm>
#include <cassert>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int N, D, X_beta;
int X = 0;
int count = 0;
cin >> N >> D;
X_beta = 2 * D + 1;
while (N >= X) {
++count;
X = X_beta * count;
// cout << X << endl;
}
cout << count << endl;
}
| #include <algorithm>
#include <cassert>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int N, D, X_beta;
int X = 0;
int count = 0;
cin >> N >> D;
X_beta = 2 * D + 1;
while (N > X) {
++count;
X = X_beta * count;
// cout << X << endl;
}
cout << count << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 773,964 | 773,965 | u949097771 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << int(ceil(n / (d + d + 1)));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int n, d;
cin >> n >> d;
cout << int(ceil((float)n / float(d + d + 1)));
return 0;
}
| [
"type_conversion.add",
"call.add",
"call.arguments.change"
] | 773,970 | 773,971 | u767871438 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int d;
cin >> d;
cout << (n - (d * 2)) / (d * 2 + 1);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int d;
cin >> d;
cout << (n + (d * 2)) / (d * 2 + 1);
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 773,985 | 773,986 | u901813121 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define what_is(x) cerr << #x << " is " << x << "\n";
#define rep(i, a, n) for (int i = a; i <= n; ++i)
#define rep1(i, a, n) for (int i = a; i >= n; --i)
#define pb push_back
#define mp make_pair
#define int long long
#define fr first
#define sc second
#define vc vector
#define sz(v) (int)v.size()
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define M 1000000007
#define MM 998244353
#define PI 3.14159265358979
#define INF 1000000000000000
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef map<int, int> mii;
int n, m, ans;
string str;
int solve() {
cin >> n >> m;
m *= 2;
m++;
cout << (n - m + 1) / m;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int t = 1;
// cin>>t;
while (t--)
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define what_is(x) cerr << #x << " is " << x << "\n";
#define rep(i, a, n) for (int i = a; i <= n; ++i)
#define rep1(i, a, n) for (int i = a; i >= n; --i)
#define pb push_back
#define mp make_pair
#define int long long
#define fr first
#define sc second
#define vc vector
#define sz(v) (int)v.size()
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define M 1000000007
#define MM 998244353
#define PI 3.14159265358979
#define INF 1000000000000000
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef map<int, int> mii;
int n, m, ans;
string str;
int solve() {
cin >> n >> m;
m *= 2;
m++;
cout << (n + m - 1) / m;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int t = 1;
// cin>>t;
while (t--)
solve();
return 0;
} | [
"expression.operation.binary.remove"
] | 773,991 | 773,992 | u177897754 | cpp |
p02970 | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int count = 0;
int tree[20];
for (int i = 0; i < n; i++) {
tree[i] = 0;
}
for (int i = 0; i < n; i++) {
if (tree[i] == 0) {
for (int j = i; j <= i + 2 * d; j++) {
tree[j] = 1;
}
count++;
}
}
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int count = 0;
int tree[100];
for (int i = 0; i < n; i++) {
tree[i] = 0;
}
for (int i = 0; i < n; i++) {
if (tree[i] == 0) {
for (int j = i; j <= i + 2 * d; j++) {
tree[j] = 1;
}
count++;
}
}
cout << count << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 773,995 | 773,996 | u738164318 | cpp |
p02970 | #include <iostream>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
int main(void) {
int N, D;
cin >> N >> D;
cout << (N + (2 * D - 1)) / (2 * D) << endl;
return 0;
} | #include <iostream>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
int main(void) {
int N, D;
cin >> N >> D;
cout << (N + 2 * D) / (2 * D + 1) << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 774,005 | 774,006 | u664652017 | cpp |
p02970 | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main() {
int n, d;
cin >> n >> d;
int ans = (n + 2 * d) / 2 * d + 1;
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main() {
int n, d;
cin >> n >> d;
int ans = (n + 2 * d) / (2 * d + 1);
cout << ans << endl;
}
| [] | 774,007 | 774,008 | u902803949 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define _GLIBCXX_DEBUG
static const int MAX = 20;
int main() {
int N, D, ans;
cin >> N >> D;
rep(i, N) {
if ((2 * D + 1) * i >= N) {
ans = i;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define _GLIBCXX_DEBUG
static const int MAX = 20;
int main() {
int N, D, ans;
cin >> N >> D;
rep2(i, 1, N + 1) {
if ((2 * D + 1) * i >= N) {
ans = i;
break;
}
}
cout << ans << endl;
} | [
"call.arguments.add"
] | 774,029 | 774,030 | u378125390 | cpp |
p02970 | #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 n, d;
cin >> n >> d;
int a;
a = 0;
int enp;
enp = 0;
rep(i, n) {
a += 2 * d;
enp++;
if (a >= n) {
break;
}
}
cout << enp << 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 n, d;
cin >> n >> d;
int a;
a = 0;
int enp;
enp = 0;
rep(i, n) {
a += 2 * d + 1;
enp++;
if (a >= n) {
break;
}
}
cout << enp << endl;
}
| [
"assignment.change"
] | 774,068 | 774,069 | u274883254 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, d;
cin >> n >> d;
cout << ceil((n - 1) / float(2 * d)) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, d;
cin >> n >> d;
cout << ceil(n / float(2 * d + 1)) << endl;
return 0;
}
| [
"call.arguments.change"
] | 774,074 | 774,075 | u006425112 | cpp |
p02970 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
int D;
cin >> N >> D;
int ans = (N + (2 * D) - 1) / (2 * D);
cout << ans << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
int D;
cin >> N >> D;
int ans = (N + (2 * D + 1) - 1) / (2 * D + 1);
cout << ans << endl;
} | [
"assignment.change"
] | 774,084 | 774,085 | u419501474 | cpp |
p02970 | #include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long int ll;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, d;
cin >> n >> d;
cout << ceil(n / float(2 * d)) << endl;
// system("pause");
return 0;
} | #include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long int ll;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, d;
cin >> n >> d;
cout << ceil(n / float(2 * d + 1)) << endl;
// system("pause");
return 0;
} | [
"expression.operation.binary.add"
] | 774,092 | 774,093 | u438265890 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int i = d + 1, count = 0;
while ((i - d) <= n) {
count += 2;
i += 2 * d + 1;
}
cout << count << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int i = d + 1, count = 0;
while ((i - d) <= n) {
count++;
i += 2 * d + 1;
}
cout << count << endl;
return 0;
}
| [] | 774,108 | 774,109 | u006279390 | cpp |
p02970 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<bool> vb;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define in insert
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define speed \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const int INF = 1e9 + 5;
int main() {
int n, d;
cin >> n >> d;
cout << ceil(n / (d * 2 + 1));
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<bool> vb;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define in insert
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define speed \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const int INF = 1e9 + 5;
int main() {
int n, d;
cin >> n >> d;
cout << ceil((double)n / (double)(d * 2 + 1));
} | [
"type_conversion.add"
] | 774,110 | 774,111 | u843739531 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int s = 2 * d + 1;
int a = n / s;
if (n % s > 0) {
s = s + 1;
}
cout << s;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int s = 2 * d + 1;
int a = n / s;
if (n % s > 0) {
a = a + 1;
}
cout << a;
} | [
"assignment.variable.change",
"identifier.change",
"assignment.value.change",
"expression.operation.binary.change",
"io.output.change"
] | 774,123 | 774,124 | u069273180 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
cout << floor((n * 1.0) / (2 * d + 1)) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
cout << ceil((n * 1.0) / (2 * d + 1)) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 774,125 | 774,126 | u708590262 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, D;
cin >> N >> D;
int ans;
rep(i, N) { // i人を置くとする
if ((2 * D + 1) * i >= N) {
ans = i;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < (int)(n); i++)
int main() {
int N, D;
cin >> N >> D;
int ans;
rep(i, N + 1) { // i人を置くとする(1~N人)
if ((2 * D + 1) * i >= N) {
ans = i;
break;
}
}
cout << ans << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 774,137 | 774,138 | u319179101 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int a = 2 * d + 1;
int ans = n / d;
if (n % d > 0)
ans++;
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int a = 2 * d + 1;
int ans = n / a;
if (n % a > 0)
ans++;
cout << ans << endl;
return 0;
} | [
"identifier.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 774,141 | 774,142 | u367199607 | cpp |
p02970 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999999
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef vector<llong> LV;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int main() {
int n, d;
cin >> n >> d;
cout << ceil((float)n / (2 * d)) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999999
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef vector<llong> LV;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int main() {
int n, d;
cin >> n >> d;
cout << ceil((float)n / (2 * d + 1)) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 774,161 | 774,162 | u186359321 | cpp |
p02970 | /**************************************
Author : Susanka Majumder ( bingobong )
***************************************/
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#include <bits/stdc++.h>
using namespace std;
/* Template file for Online Algorithmic Competitions */
/* Typedefs */
/* Basic types */
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
/* STL containers */
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<vpii> vvpii;
typedef set<int> si;
/* Macros */
/* Loops */
#define fl(i, a, b) for (int i(a); i <= (b); i++)
#define rep(i, n) fl(i, 1, (n))
#define loop(i, n) fl(i, 0, (n)-1)
#define rfl(i, a, b) for (int i(a); i >= (b); i--)
#define rrep(i, n) rfl(i, (n), 1)
/* Algorithmic functions */
#define pow2(x) ((x) * (x))
#define mod(x, m) ((((x) % (m)) + (m)) % (m))
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define srt(v) sort((v).begin(), (v).end())
/* STL container methods */
#define pb push_back
#define mp make_pair
#define eb emplace_back
/* String methods */
#define dig(i) (s[i] - '0')
#define slen(s) s.length()
/* Shorthand notations */
#define fr first
#define sc second
#define re return
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define sqr(x) ((x) * (x))
#define fill(x, y) memset(x, y, sizeof(x))
#define clr(a) fill(a, 0)
#define endl '\n'
/* Mathematical */
#define IINF 0x3f3f3f3f
#define LLINF 1000111000111000111LL
#define PI 3.14159265358979323
#define NIL -1
/* Debugging purpose */
#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
/* Fast Input Output */
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
/* Constants */
const ll MOD = 1000000007LL;
const ll MAX = 100010LL;
/* Templates */
template <class T> T abs(T x) { re x > 0 ? x : -x; }
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T power(T x, T y, ll m = MOD) {
T ans = 1;
x %= m;
while (y > 0) {
if (y & 1LL)
ans = (ans * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return ans % m;
}
/* additional*/
#define tr(c, i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
int main() {
/* #ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
freopen("error.txt","w",stderr);
#endif
*/
int n, d;
cin >> n >> d;
float res = (float)n / 2 * d;
cout << ceil(res);
/* #ifndef ONLINE_JUDGE
cout<<"\nTime Elapsed: " << 1.0*clock() / CLOCKS_PER_SEC << " sec\n";
#endif
*/
return 0;
} | /**************************************
Author : Susanka Majumder ( bingobong )
***************************************/
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#include <bits/stdc++.h>
using namespace std;
/* Template file for Online Algorithmic Competitions */
/* Typedefs */
/* Basic types */
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
/* STL containers */
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<vpii> vvpii;
typedef set<int> si;
/* Macros */
/* Loops */
#define fl(i, a, b) for (int i(a); i <= (b); i++)
#define rep(i, n) fl(i, 1, (n))
#define loop(i, n) fl(i, 0, (n)-1)
#define rfl(i, a, b) for (int i(a); i >= (b); i--)
#define rrep(i, n) rfl(i, (n), 1)
/* Algorithmic functions */
#define pow2(x) ((x) * (x))
#define mod(x, m) ((((x) % (m)) + (m)) % (m))
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define srt(v) sort((v).begin(), (v).end())
/* STL container methods */
#define pb push_back
#define mp make_pair
#define eb emplace_back
/* String methods */
#define dig(i) (s[i] - '0')
#define slen(s) s.length()
/* Shorthand notations */
#define fr first
#define sc second
#define re return
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define sqr(x) ((x) * (x))
#define fill(x, y) memset(x, y, sizeof(x))
#define clr(a) fill(a, 0)
#define endl '\n'
/* Mathematical */
#define IINF 0x3f3f3f3f
#define LLINF 1000111000111000111LL
#define PI 3.14159265358979323
#define NIL -1
/* Debugging purpose */
#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
/* Fast Input Output */
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
/* Constants */
const ll MOD = 1000000007LL;
const ll MAX = 100010LL;
/* Templates */
template <class T> T abs(T x) { re x > 0 ? x : -x; }
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T power(T x, T y, ll m = MOD) {
T ans = 1;
x %= m;
while (y > 0) {
if (y & 1LL)
ans = (ans * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return ans % m;
}
/* additional*/
#define tr(c, i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
int main() {
/* #ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
freopen("error.txt","w",stderr);
#endif
*/
int n, d;
cin >> n >> d;
float res = (float)n / (2 * d + 1);
cout << ceil(res);
/* #ifndef ONLINE_JUDGE
cout<<"\nTime Elapsed: " << 1.0*clock() / CLOCKS_PER_SEC << " sec\n";
#endif
*/
return 0;
} | [] | 774,167 | 774,168 | u562820818 | cpp |
p02970 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, d;
cin >> n >> d;
d = 2 * n + 1;
cout << (n + d - 1) / d << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, d;
cin >> n >> d;
d = 2 * d + 1;
cout << (n + d - 1) / d << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 774,173 | 774,174 | u525288965 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << N / (2 * D + 1) << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << (N + 2 * D) / (2 * D + 1) << endl;
return 0;
} | [] | 774,196 | 774,197 | u152315108 | cpp |
p02970 | #include <iostream>
#include <math.h>
using namespace std;
main() {
float n, d, ans;
cin >> n >> d;
ans = ceil(n / (2 * d));
cout << ans << endl;
} | #include <iostream>
#include <math.h>
using namespace std;
main() {
float n, d, ans;
cin >> n >> d;
ans = ceil(n / (2 * d + 1));
cout << ans << endl;
} | [
"assignment.change"
] | 774,220 | 774,221 | u703537155 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
int count = 0;
cin >> n;
cin >> d;
count = ceil(n / (2 * d + 1));
cout << count;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
float n, d;
int count = 0;
cin >> n;
cin >> d;
count = ceil(n / (2 * d + 1));
cout << count;
} | [
"variable_declaration.type.primitive.change"
] | 774,322 | 774,323 | u793276813 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
double tmpdou;
int tmpint;
int n, d;
cin >> n >> d;
tmpint = n / (1 + 2 * d);
tmpdou = n / (1 + 2 * d);
if (tmpint < tmpdou)
tmpint++;
cout << tmpint << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
double tmpdou;
int tmpint;
int n, d;
cin >> n >> d;
tmpint = n / (1.0 + 2 * d);
tmpdou = n / (1.0 + 2 * d);
if (tmpint < tmpdou)
tmpint++;
cout << tmpint << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 774,328 | 774,329 | u059207724 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
double tmpdou;
int tmpint;
int n, d;
cin >> n >> d;
tmpint = n / (1 + 2 * d);
tmpdou = n / (1 + 2 * d);
if (tmpint < tmpdou)
tmpint + 1;
cout << tmpint << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
double tmpdou;
int tmpint;
int n, d;
cin >> n >> d;
tmpint = n / (1.0 + 2 * d);
tmpdou = n / (1.0 + 2 * d);
if (tmpint < tmpdou)
tmpint++;
cout << tmpint << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 774,330 | 774,329 | u059207724 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define MOD 1000000007
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define FOR(i, s, e) for (int i = s, i##_l = (e); i < i##_l; i++)
#define LLI long long int
#define _min(a, b) ((a < b) ? a : b)
#define _max(a, b) ((a < b) ? b : a)
#define chmax(a, b) a = _max(a, b)
#define chmin(a, b) a = _min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define pm(a) ((a) ? 1 : -1)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort((v).rbegin(), (v).rend())
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
cout << fixed << setprecision(10);
int N, D;
cin >> N >> D;
cout << (int)ceil(1.0 * N / D / 2);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define MOD 1000000007
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define FOR(i, s, e) for (int i = s, i##_l = (e); i < i##_l; i++)
#define LLI long long int
#define _min(a, b) ((a < b) ? a : b)
#define _max(a, b) ((a < b) ? b : a)
#define chmax(a, b) a = _max(a, b)
#define chmin(a, b) a = _min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define pm(a) ((a) ? 1 : -1)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort((v).rbegin(), (v).rend())
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
cout << fixed << setprecision(10);
int N, D;
cin >> N >> D;
cout << (int)ceil(1.0 * N / (D * 2 + 1));
return 0;
} | [
"call.arguments.change",
"expression.operator.arithmetic.change",
"io.output.change"
] | 774,347 | 774,348 | u840105874 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int res;
res = (N + D * 2) / (D * 2 + 1) + 1;
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int res;
res = (N + D * 2) / (D * 2 + 1);
cout << res << endl;
} | [
"expression.operation.binary.remove"
] | 774,349 | 774,350 | u650773146 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << ceil(N / (2 * (D + 1))) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << ceil((double)N / (2 * D + 1)) << endl;
} | [
"call.arguments.change"
] | 774,360 | 774,361 | u656368720 | cpp |
p02970 | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, D;
int n = 0;
cin >> N >> D;
while ((2 * D * n + n) <= N)
n++;
cout << n << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, D;
int n = 0;
cin >> N >> D;
while ((2 * D * n + n) < N)
n++;
cout << n << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 774,381 | 774,382 | u297292406 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
d = 2 * d + 1;
cout << ceil(n / d);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
d = 2 * d + 1;
cout << ceil(n / (float)d);
} | [
"type_conversion.add"
] | 774,397 | 774,398 | u085643978 | cpp |
p02970 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
constexpr static ll MOD = 1000000007ll;
constexpr static int INF = 1 << 28; // for x <= 10^9
constexpr static ll INFL = 1ll << 60; // for x <= 10^19
constexpr static double EPS = 1e-10;
int main() {
int n, d;
cin >> n >> d;
int ans = ceil((double)n / (2 * d - 1));
cout << ans << endl;
}
| #include <bits/stdc++.h>
using ll = long long;
using namespace std;
constexpr static ll MOD = 1000000007ll;
constexpr static int INF = 1 << 28; // for x <= 10^9
constexpr static ll INFL = 1ll << 60; // for x <= 10^19
constexpr static double EPS = 1e-10;
int main() {
int n, d;
cin >> n >> d;
int ans = ceil((double)n / (2 * d + 1));
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 774,402 | 774,403 | u784448849 | cpp |
p02970 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
constexpr static ll MOD = 1000000007ll;
constexpr static int INF = 1 << 28; // for x <= 10^9
constexpr static ll INFL = 1ll << 60; // for x <= 10^19
constexpr static double EPS = 1e-10;
int main() {
int n, d;
cin >> n >> d;
int ans = ceil((double)n / d);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using ll = long long;
using namespace std;
constexpr static ll MOD = 1000000007ll;
constexpr static int INF = 1 << 28; // for x <= 10^9
constexpr static ll INFL = 1ll << 60; // for x <= 10^19
constexpr static double EPS = 1e-10;
int main() {
int n, d;
cin >> n >> d;
int ans = ceil((double)n / (2 * d + 1));
cout << ans << endl;
}
| [] | 774,404 | 774,403 | u784448849 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int n, d;
int main() {
cin >> n >> d;
cout << (n + 2 * d - 1) / (2 * d + 1);
} | #include <bits/stdc++.h>
using namespace std;
int n, d;
int main() {
cin >> n >> d;
cout << (n + 2 * d) / (2 * d + 1);
}
| [
"expression.operation.binary.remove"
] | 774,408 | 774,409 | u709966987 | cpp |
p02970 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (int)ceil(1.0 * n / (2 * d - 1)) << endl;
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (int)ceil(1.0 * n / (2 * d + 1)) << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 774,415 | 774,416 | u338990986 | cpp |
p02970 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
#define ALL(obj) (obj).begin(), (obj).end() //昇順
#define RALL(obj) (obj).rbegin(), (obj).rend() //降順
#define print(obj) cout << obj << endl
#define scan(obj) cin >> obj
typedef long long ll;
using namespace std;
int main(void) {
int n, d;
cin >> n >> d;
int ans = (int)ceil((double)n / (double)(2 * d));
print(ans);
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
#define ALL(obj) (obj).begin(), (obj).end() //昇順
#define RALL(obj) (obj).rbegin(), (obj).rend() //降順
#define print(obj) cout << obj << endl
#define scan(obj) cin >> obj
typedef long long ll;
using namespace std;
int main(void) {
int n, d;
cin >> n >> d;
int ans = (int)ceil((double)n / (double)(2 * d + 1));
print(ans);
}
| [
"assignment.change"
] | 774,427 | 774,428 | u650565403 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << N / (2 * D) + (N % (2 * D) > 0) << endl;
} | #include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << N / (2 * D + 1) + (N % (2 * D + 1) > 0) << endl;
} | [
"expression.operation.binary.add"
] | 774,456 | 774,457 | u498467508 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N, D;
cout << N / (2 * D) + (N % (2 * D) > 0) << endl;
} | #include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << N / (2 * D + 1) + (N % (2 * D + 1) > 0) << endl;
} | [
"expression.operation.binary.add"
] | 774,458 | 774,457 | u498467508 | cpp |
p02970 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
double n, d;
cin >> n >> d;
cout << floor(n / (2 * d + 1)) << endl;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
double n, d;
cin >> n >> d;
cout << ceil(n / (2 * d + 1)) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 774,465 | 774,466 | u689193446 | cpp |
p02970 | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, d;
scanf("%d %d", &n, &d);
d *= 2;
printf("%d\n", (n + d - 1) / d);
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, d;
scanf("%d %d", &n, &d);
d = 2 * d + 1;
printf("%d\n", (n + d - 1) / d);
return 0;
} | [
"assignment.value.change",
"assignment.change"
] | 774,469 | 774,470 | u315350841 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int i = 0;
while (((D * 2) + 1) * i <= N) {
i++;
}
cout << i << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int i = 0;
while (((D * 2) + 1) * i < N) {
i++;
}
cout << i << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 774,477 | 774,478 | u337024735 | cpp |
p02970 | #define REP(i, t, n) for (int i = t; i < n; i++)
#define ALL(n) (n).begin(), (n).end()
#include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef bool BOOL;
typedef short WORD;
typedef unsigned short U_WORD;
typedef long DWORD;
typedef unsigned long U_DWORD;
typedef long long QWORD;
typedef unsigned long long U_QWORD;
void solve_main() {
DWORD N, D;
DWORD dwAns = 0;
DWORD dwNowTree = 1;
cin >> N >> D;
while (dwNowTree < N) {
dwAns++;
dwNowTree += ((2 * D) + 1);
}
cout << dwAns << endl;
}
int main() {
#ifdef FOR_IDE
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
solve_main();
return 0;
}
| #define REP(i, t, n) for (int i = t; i < n; i++)
#define ALL(n) (n).begin(), (n).end()
#include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef bool BOOL;
typedef short WORD;
typedef unsigned short U_WORD;
typedef long DWORD;
typedef unsigned long U_DWORD;
typedef long long QWORD;
typedef unsigned long long U_QWORD;
void solve_main() {
DWORD N, D;
DWORD dwAns = 0;
DWORD dwNowTree = 0;
cin >> N >> D;
while (dwNowTree < N) {
dwAns++;
dwNowTree += ((2 * D) + 1);
}
cout << dwAns << endl;
}
int main() {
#ifdef FOR_IDE
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
solve_main();
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 774,502 | 774,503 | u717315282 | cpp |
p02970 |
#include <iostream>
#include <math.h>
int main() {
int n, d;
std::cin >> n >> d;
int num = (int)ceil((double)n / (2 * d));
std::cout << num;
return 0;
} |
#include <iostream>
#include <math.h>
int main() {
int n, d;
std::cin >> n >> d;
int num = (int)ceil((double)n / (2 * d + 1));
std::cout << num;
return 0;
} | [
"assignment.change"
] | 774,519 | 774,520 | u889915625 | cpp |
p02970 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
#define mod 1000000007
int main() {
int n, d;
cin >> n >> d;
int ans = 0;
int r = 0;
while (r <= n) {
ans++;
r += 2 * d + 1;
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
#define mod 1000000007
int main() {
int n, d;
cin >> n >> d;
int ans = 0;
int r = 0;
while (r < n) {
ans++;
r += 2 * d + 1;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 774,528 | 774,529 | u261965335 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ll long long
#define pb(a) push_back(a)
#define eb(a) emplace_back(a)
#define xx first
#define yy second
#define mp make_pair
//#define end "\n"
#define pll pair<ll, ll>
#define mll map<ll, ll>
#define vll vector<ll>
#define pdd pair<double, double>
#define ALL(v) (v).begin(), (v).end()
const ll MOD = 998244353;
const ll inf = 1e18;
#define MODSET(d) \
if ((d) >= MOD) \
d %= MOD;
#define MODNEGSET(d) \
if ((d) < 0) \
d = ((d % MOD) + MOD) % MOD;
ll power(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a);
n >>= 1;
a = (a * a);
}
return ans;
}
ll powerMod(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % MOD;
n >>= 1;
a = (a * a) % MOD;
}
return ans;
}
ll lcm(ll a, ll b) { return a * (b / __gcd(a, b)); }
ll sumdigit(ll n) {
ll sum = 0;
while (n) {
sum += n % 10;
n = n / 10;
}
return sum;
}
ll countSetBit(ll a) { return __builtin_popcount(a); }
const long sz = 1e5 + 10;
ll length(ll a) {
ll ans = 0;
while (a) {
ans++;
a = a / 10;
}
return ans;
}
int main() {
fast;
ll t;
// cin>>t;
t = 1;
while (t--) {
ll n, d;
cin >> n >> d;
cout << ceil(1.0 * n / (2 * d));
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ll long long
#define pb(a) push_back(a)
#define eb(a) emplace_back(a)
#define xx first
#define yy second
#define mp make_pair
//#define end "\n"
#define pll pair<ll, ll>
#define mll map<ll, ll>
#define vll vector<ll>
#define pdd pair<double, double>
#define ALL(v) (v).begin(), (v).end()
const ll MOD = 998244353;
const ll inf = 1e18;
#define MODSET(d) \
if ((d) >= MOD) \
d %= MOD;
#define MODNEGSET(d) \
if ((d) < 0) \
d = ((d % MOD) + MOD) % MOD;
ll power(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a);
n >>= 1;
a = (a * a);
}
return ans;
}
ll powerMod(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % MOD;
n >>= 1;
a = (a * a) % MOD;
}
return ans;
}
ll lcm(ll a, ll b) { return a * (b / __gcd(a, b)); }
ll sumdigit(ll n) {
ll sum = 0;
while (n) {
sum += n % 10;
n = n / 10;
}
return sum;
}
ll countSetBit(ll a) { return __builtin_popcount(a); }
const long sz = 1e5 + 10;
ll length(ll a) {
ll ans = 0;
while (a) {
ans++;
a = a / 10;
}
return ans;
}
int main() {
fast;
ll t;
// cin>>t;
t = 1;
while (t--) {
ll n, d;
cin >> n >> d;
cout << ceil(1.0 * n / (2 * d + 1));
}
return 0;
}
| [
"expression.operation.binary.add"
] | 774,542 | 774,543 | u630231163 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int d = b * 2 + 1;
cout << (a - (d - 1)) / d << '\n';
}
| #include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int d = b * 2 + 1;
cout << (a + (d - 1)) / d << '\n';
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 774,551 | 774,552 | u603234915 | cpp |
p02970 | #pragma region include
#include "bits/stdc++.h"
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPR(i, n) for (int i = (int)(n); i >= 0; i--)
#define FOR(i, n, m) for (int i = (int)(n); i < int(m); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll LLINF = 4e18;
void input() {}
template <typename... R> void input(int &f, R &...r) {
scanf("%d", &f);
input(r...);
}
template <typename... R> void input(double &f, R &...r) {
scanf("%lf", &f);
input(r...);
}
template <typename... R> void input(ll &f, R &...r) {
scanf("%lld", &f);
input(r...);
}
template <typename... R> void input(char &f, R &...r) {
scanf("%c", &f);
input(r...);
}
template <typename T, typename... R> void input(vector<T> &f, R &...r) {
REP(i, f.size()) input(f[i]);
input(r...);
}
#pragma endregion
int main() {
int N, D;
input(N, D);
D <<= 1;
cout << (N + D - 1) / D << endl;
getchar();
getchar();
} | #pragma region include
#include "bits/stdc++.h"
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPR(i, n) for (int i = (int)(n); i >= 0; i--)
#define FOR(i, n, m) for (int i = (int)(n); i < int(m); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll LLINF = 4e18;
void input() {}
template <typename... R> void input(int &f, R &...r) {
scanf("%d", &f);
input(r...);
}
template <typename... R> void input(double &f, R &...r) {
scanf("%lf", &f);
input(r...);
}
template <typename... R> void input(ll &f, R &...r) {
scanf("%lld", &f);
input(r...);
}
template <typename... R> void input(char &f, R &...r) {
scanf("%c", &f);
input(r...);
}
template <typename T, typename... R> void input(vector<T> &f, R &...r) {
REP(i, f.size()) input(f[i]);
input(r...);
}
#pragma endregion
int main() {
int N, D;
input(N, D);
D <<= 1;
D++;
cout << (N + D - 1) / D << endl;
getchar();
getchar();
} | [
"expression.unary.arithmetic.add"
] | 774,564 | 774,565 | u165374901 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << n / (2 * d + 1) + 1;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double n, d;
cin >> n >> d;
cout << ceil(n / (2 * d + 1));
return 0;
} | [
"variable_declaration.type.primitive.change",
"call.add",
"io.output.change"
] | 774,568 | 774,569 | u152997492 | cpp |
p02970 | #include <iostream>
#include <math.h>
using namespace std;
void func_b(int N, int D) {
int range = 2 * D + 1;
cout << ceil(N / range);
}
int main() {
int N, D;
cin >> N >> D;
func_b(N, D);
}
| #include <iostream>
#include <math.h>
using namespace std;
void func_b(int N, int D) {
double range = 2 * D + 1;
cout << (int)ceil(N / range);
}
int main() {
int N, D;
cin >> N >> D;
func_b(N, D);
}
| [
"variable_declaration.type.primitive.change"
] | 774,583 | 774,584 | u096502015 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
long long ab = 2 * d;
cout << ceil((n * 1.0) / ab);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
long long ab = 2 * d + 1;
cout << ceil((n * 1.0) / ab);
} | [
"assignment.change"
] | 774,587 | 774,588 | u870168650 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int ans;
ans = ceil(N / (2 * D + 1));
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
float N, D;
cin >> N >> D;
float ans;
ans = ceil(N / (2 * D + 1));
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 774,599 | 774,600 | u349117935 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
double N, D;
cin >> N >> D;
// cout << N << ";" << D << endl;
cout << ceil(N / (2 * D)) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
double N, D;
cin >> N >> D;
// cout << N << ";" << D << endl;
cout << ceil(N / ((2 * D) + 1)) << endl;
}
| [
"call.arguments.change"
] | 774,603 | 774,604 | u995485610 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int n, d;
int main(void) {
// Here your code !
scanf("%d %d", &n, &d);
printf("%d", (n - 1 + 2 * d) / (2 * d));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
int n, d;
int main(void) {
// Here your code !
scanf("%d %d", &n, &d);
printf("%d", (n - 1 + 2 * d + 1) / (2 * d + 1));
return 0;
}
| [
"expression.operation.binary.add"
] | 774,621 | 774,622 | u497422208 | cpp |
p02970 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define all(a) a.begin(), a.end()
#define pb push_back
#define vi vector<int>
#define vl vector<long long>
#define MOD 1000000007
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define forn(i, n) for (int i = 0; i < n; i++)
#define br cout << endl;
#define testc() \
int t; \
cin >> t; \
while (t--)
#define ll long long
#define printv(v) \
for (auto x : v) \
cout << x << ' '; \
br;
#define ff first
#define ss second
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define vb vector<bool>
#define INF INT_MAX
#define INFL LLONG_MAX
using namespace std;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
vi prime_generator() {
vector<int> pr;
const int N = 10000000;
vi lp(N + 1);
for (int i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
}
vi z_function(string t) {
int n = t.size();
vi z(t.size());
for (int i = 1, r = 0, l = 0; i < n; i++) {
if (i <= r)
z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && t[z[i]] == t[i + z[i]])
z[i]++;
if (i + z[i] - 1 > r)
r = i + z[i] - 1, l = i;
}
return z;
}
ll power(ll a, ll b, ll mod) {
ll res = 1;
a = a % mod;
while (b) {
if (b & 1)
res = (res * a) % mod;
b = b >> 1;
a = (a * a) % mod;
}
return res;
}
template <typename T> void answer(T s) {
cout << s << endl;
exit(0);
}
// use for string in strcpy([string],s.c_str())
// stringstream fs---->fs>>string_name**this will copy the value from fs to
// string_name
/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
int main() {
fast int n, d;
cin >> n >> d;
int x = 0;
int y = 1;
while (y < n) {
x++;
y += 2 * d + 1;
}
cout << x << endl;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define all(a) a.begin(), a.end()
#define pb push_back
#define vi vector<int>
#define vl vector<long long>
#define MOD 1000000007
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define forn(i, n) for (int i = 0; i < n; i++)
#define br cout << endl;
#define testc() \
int t; \
cin >> t; \
while (t--)
#define ll long long
#define printv(v) \
for (auto x : v) \
cout << x << ' '; \
br;
#define ff first
#define ss second
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define vb vector<bool>
#define INF INT_MAX
#define INFL LLONG_MAX
using namespace std;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
vi prime_generator() {
vector<int> pr;
const int N = 10000000;
vi lp(N + 1);
for (int i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
}
vi z_function(string t) {
int n = t.size();
vi z(t.size());
for (int i = 1, r = 0, l = 0; i < n; i++) {
if (i <= r)
z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && t[z[i]] == t[i + z[i]])
z[i]++;
if (i + z[i] - 1 > r)
r = i + z[i] - 1, l = i;
}
return z;
}
ll power(ll a, ll b, ll mod) {
ll res = 1;
a = a % mod;
while (b) {
if (b & 1)
res = (res * a) % mod;
b = b >> 1;
a = (a * a) % mod;
}
return res;
}
template <typename T> void answer(T s) {
cout << s << endl;
exit(0);
}
// use for string in strcpy([string],s.c_str())
// stringstream fs---->fs>>string_name**this will copy the value from fs to
// string_name
/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
int main() {
fast int n, d;
cin >> n >> d;
int x = 0;
int y = 1;
while (y <= n) {
x++;
y += 2 * d + 1;
}
cout << x << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 774,625 | 774,626 | u391675729 | cpp |
p02970 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int m;
m = 2 * d + 1;
int p = 0;
for (int i = 0; i < n; i++) {
if (n <= m * i) {
p = i;
break;
}
}
cout << p << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int m;
m = 2 * d + 1;
int p = 0;
for (int i = 1; i <= n; i++) {
if (n <= m * i) {
p = i;
break;
}
}
cout << p << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 774,629 | 774,630 | u208102827 | cpp |
p02970 | #include <iostream>
using namespace std;
typedef long long ll;
int main() {
int N, D;
cin >> N >> D;
int r = N % (2 * D);
int ans = N / (2 * D);
if (r > 0)
ans++;
cout << ans << endl;
}
| #include <iostream>
using namespace std;
typedef long long ll;
int main() {
int N, D;
cin >> N >> D;
int r = N % (2 * D + 1);
int ans = N / (2 * D + 1);
if (r > 0)
ans++;
cout << ans << endl;
}
| [
"assignment.change"
] | 774,639 | 774,640 | u904131021 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (n + 2 * d - 2) / (2 * d - 1);
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (n + 2 * d) / (2 * d + 1);
}
| [
"expression.operation.binary.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 774,650 | 774,651 | u115838990 | cpp |
p02970 | /*input
9 5
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<long long, null_type, less<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC optimize("unroll-loops,no-stack-protector")
// order_of_key #of elements less than x
// find_by_order kth element
typedef long long int ll;
#define ld long double
#define pii pair<int, int>
#define f first
#define s second
#define pb emplace_back
#define REP(i, n) for (ll i = 0; i < n; i++)
#define sz(_a) (ll)(_a.size())
#define FILL(n) memset(n, 0, sizeof(n))
#define ALL(_a) _a.begin(), _a.end()
const ll maxn = 100005;
const ll maxlg = __lg(maxn) + 2;
const ll INF64 = 8000000000000000000LL;
const int INF = 0x3f3f3f3f;
const ll MOD = ll(1e9 + 7);
const ld PI = acos(-1);
const ld eps = 1e-9;
ll mypow(ll a, ll b) {
ll res = 1LL;
while (b) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
int arr[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
cout << n / (2 * k + 1);
} | /*input
9 5
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<long long, null_type, less<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC optimize("unroll-loops,no-stack-protector")
// order_of_key #of elements less than x
// find_by_order kth element
typedef long long int ll;
#define ld long double
#define pii pair<int, int>
#define f first
#define s second
#define pb emplace_back
#define REP(i, n) for (ll i = 0; i < n; i++)
#define sz(_a) (ll)(_a.size())
#define FILL(n) memset(n, 0, sizeof(n))
#define ALL(_a) _a.begin(), _a.end()
const ll maxn = 100005;
const ll maxlg = __lg(maxn) + 2;
const ll INF64 = 8000000000000000000LL;
const int INF = 0x3f3f3f3f;
const ll MOD = ll(1e9 + 7);
const ld PI = acos(-1);
const ld eps = 1e-9;
ll mypow(ll a, ll b) {
ll res = 1LL;
while (b) {
if (b & 1)
res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
int arr[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
double n, k;
cin >> n >> k;
cout << ceil(n / (2 * k + 1));
} | [
"variable_declaration.type.primitive.change",
"call.add",
"call.arguments.change"
] | 774,686 | 774,687 | u110464018 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int n, d, a, b, c = 0, cnt = 0, i;
cin >> n >> d;
for (i = 1; i < n; i++) {
a = i - d;
b = i + d;
c += b - a + 1;
cnt++;
if (c >= n) {
// cnt++;
break;
}
}
cout << cnt << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, d, a, b, c = 0, cnt = 0, i;
cin >> n >> d;
for (i = 1; i <= n; i++) {
a = i - d;
b = i + d;
c += b - a + 1;
cnt++;
if (c >= n) {
// cnt++;
break;
}
}
cout << cnt << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 774,695 | 774,696 | u358577903 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int n, d, a, b, c = 0, cnt = 0, i;
cin >> n >> d;
for (i = 1; i < n; i++) {
a = i - d;
b = i + d;
c += b - a + 1;
cnt++;
if (c > n) {
// cnt++;
break;
}
}
cout << cnt << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, d, a, b, c = 0, cnt = 0, i;
cin >> n >> d;
for (i = 1; i <= n; i++) {
a = i - d;
b = i + d;
c += b - a + 1;
cnt++;
if (c >= n) {
// cnt++;
break;
}
}
cout << cnt << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 774,697 | 774,696 | u358577903 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
float n, d;
cin >> n >> d;
int x = ceil(n / (2 * d));
cout << x << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
float n, d;
cin >> n >> d;
int x = ceil(n / ((2 * d) + 1));
cout << x << endl;
} | [
"call.arguments.change"
] | 774,708 | 774,709 | u673058289 | cpp |
p02970 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
float result = (n * (1.0)) / (2 * d);
cout << round(result);
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
float result = (n * (1.0)) / (2 * d + 1);
cout << ceil(result);
} | [
"identifier.change",
"call.function.near.change",
"io.output.change"
] | 774,716 | 774,717 | u055711678 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.