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 |
|---|---|---|---|---|---|---|---|
p03138 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, xa[100], xan, ans;
bool grdy(ll k, ll x, ll xi) {
// printf("%lld,%lld,%lld\n", k, x, xi);
if (k == 0) {
xa[xi] = x;
xan = xan < xi ? xi : xan;
return false;
}
ll ct = 0, i;
if (x + k > K) {
grdy(k >> 1, x, xi + 1);
return true;
}
fornum(i, 0, N) {
if ((A[i] & k) == 0) {
ct++;
// printf("%lld ", A[i]);
}
}
// printf("%lld\n", ct);
if (N / 2 < ct) {
if (grdy(k >> 1, x + k, xi)) {
grdy(k >> 1, x, xi + 1);
}
} else {
grdy(k >> 1, x, xi);
}
return false;
}
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
if (K != 0)
grdy(1ll << (Kp - 1), 0, 0);
// printf("%lld ", x);
fornum(i, 0, xan + 1) {
ll a = 0;
fornum(j, 0, N) { a += (xa[i] ^ A[j]); }
if (ans < a) {
ans = a;
}
}
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, xa[100], xan, ans;
bool grdy(ll k, ll x, ll xi) {
// printf("%lld,%lld,%lld\n", k, x, xi);
if (k == 0) {
xa[xi] = x;
xan = xan < xi ? xi : xan;
return false;
}
ll ct = 0, i;
if (x + k > K) {
grdy(k >> 1, x, xi);
return true;
}
fornum(i, 0, N) {
if ((A[i] & k) == 0) {
ct++;
// printf("%lld ", A[i]);
}
}
// printf("%lld\n", ct);
if (N / 2 < ct) {
if (grdy(k >> 1, x + k, xi)) {
grdy(k >> 1, x, xi + 1);
}
} else {
grdy(k >> 1, x, xi);
}
return false;
}
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
if (K != 0)
grdy(1ll << (Kp - 1), 0, 0);
// printf("%lld ", x);
fornum(i, 0, xan + 1) {
ll a = 0;
fornum(j, 0, N) { a += (xa[i] ^ A[j]); }
if (ans < a) {
ans = a;
}
}
printf("%lld", ans);
return 0;
} | [
"expression.operation.binary.remove"
] | 944,426 | 944,427 | u259396003 | cpp |
p03138 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
if (x + k < K)
continue;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
if (x + k > K)
continue;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 944,428 | 944,429 | u259396003 | cpp |
p03138 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
if (x + k <= K)
continue;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
if (x + k > K)
continue;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 944,430 | 944,429 | u259396003 | cpp |
p03138 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) < K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct && x + k <= K) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct && x + k <= K) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 944,431 | 944,432 | u259396003 | cpp |
p03138 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1 << Kp) < K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1 << (Kp - i - 1));
ll ct = 0;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct && x + k <= K) {
x += k;
}
}
fornum(i, 0, N) { ans += x ^ A[i]; }
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll N, K, A[101010];
ll Kp;
ll i, j, x, ans;
int main() {
scanf("%lld%lld", &N, &K);
fornum(i, 0, N) { scanf("%lld", &A[i]); }
for (Kp = 0; (1ll << Kp) <= K; Kp++)
;
fornum(i, 0, Kp) {
ll k = (1ll << (Kp - i - 1));
ll ct = 0;
fornum(j, 0, N) {
if ((A[j] & k) == 0) {
ct++;
}
}
if (N / 2 < ct && x + k <= K) {
x += k;
}
}
fornum(i, 0, N) { ans += (x ^ A[i]); }
printf("%lld", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 944,433 | 944,432 | u259396003 | cpp |
p03138 | #include <bitset>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> A(N);
int bit[40] = {};
for (int i = 0; i < N; ++i) {
cin >> A[i];
bitset<40> B(A[i]);
for (int j = 0; j < 40; ++j) {
bit[j] += !B.test(j);
}
}
long X = 0;
for (int i = 39; i >= 0; ++i) {
if (2 * bit[i] > N && (X | (1L << i)) <= K)
X |= (1L << i);
}
long ans = 0;
for (int i = 0; i < N; ++i)
ans += X ^ A[i];
cout << ans << endl;
} | #include <bitset>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> A(N);
int bit[40] = {};
for (int i = 0; i < N; ++i) {
cin >> A[i];
bitset<40> B(A[i]);
for (int j = 0; j < 40; ++j) {
bit[j] += !B.test(j);
}
}
long X = 0;
for (int i = 39; i >= 0; --i) {
if (2 * bit[i] > N && (X | (1L << i)) <= K)
X |= (1L << i);
}
long ans = 0;
for (int i = 0; i < N; ++i)
ans += X ^ A[i];
cout << ans << endl;
} | [] | 944,440 | 944,441 | u031178961 | cpp |
p03138 | #include <bitset>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> A(N);
int bit[40] = {};
for (int i = 0; i < N; ++i) {
cin >> A[i];
bitset<40> B(A[i]);
for (int j = 0; j < 40; ++j) {
bit[j] += !B.test(j);
}
}
long X = 0;
for (int i = 0; i < 40; ++i) {
if (2 * bit[i] > N && (X | (1L << i)) <= K)
X |= (1L << i);
}
long ans = 0;
for (int i = 0; i < N; ++i)
ans += X ^ A[i];
cout << ans << endl;
} | #include <bitset>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> A(N);
int bit[40] = {};
for (int i = 0; i < N; ++i) {
cin >> A[i];
bitset<40> B(A[i]);
for (int j = 0; j < 40; ++j) {
bit[j] += !B.test(j);
}
}
long X = 0;
for (int i = 39; i >= 0; --i) {
if (2 * bit[i] > N && (X | (1L << i)) <= K)
X |= (1L << i);
}
long ans = 0;
for (int i = 0; i < N; ++i)
ans += X ^ A[i];
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change"
] | 944,442 | 944,441 | u031178961 | cpp |
p03138 | #include <iostream>
#include <vector>
using namespace std;
#define MAX_BIT 60
uint64_t f(uint64_t x, const vector<uint64_t> &a) {
uint64_t sum = 0;
for (auto &a_i : a) {
sum += a_i ^ x;
}
return sum;
}
int main() {
uint64_t n, k;
cin >> n >> k;
vector<vector<int>> a_bit(n);
vector<uint64_t> a(n);
for (int i = 0; i < n; i++) {
a_bit[i].resize(MAX_BIT);
cin >> a[i];
for (int j = 0; j < MAX_BIT; j++)
a_bit[i][j] = (a[i] & ((uint64_t)0x1 << j)) >> j;
}
uint64_t result[MAX_BIT] = {0};
uint64_t aaa = 0;
for (int i = MAX_BIT - 1; i >= 0; i--) {
if (((uint64_t)0x1 << i) < (k - aaa)) {
int count_0 = 0;
int count_1 = 0;
for (const auto &a_i : a_bit) {
if (a_i[i] == 0) {
count_0++;
} else {
count_1++;
}
}
if (count_0 > count_1) {
result[i] = 1;
aaa += (uint64_t)0x1 << i;
}
}
}
uint64_t sum = 0;
for (int i = 0; i < MAX_BIT; i++) {
sum += result[i] << i;
}
cout << f(sum, a) << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
#define MAX_BIT 60
uint64_t f(uint64_t x, const vector<uint64_t> &a) {
uint64_t sum = 0;
for (auto &a_i : a) {
sum += a_i ^ x;
}
return sum;
}
int main() {
uint64_t n, k;
cin >> n >> k;
vector<vector<int>> a_bit(n);
vector<uint64_t> a(n);
for (int i = 0; i < n; i++) {
a_bit[i].resize(MAX_BIT);
cin >> a[i];
for (int j = 0; j < MAX_BIT; j++)
a_bit[i][j] = (a[i] & ((uint64_t)0x1 << j)) >> j;
}
uint64_t result[MAX_BIT] = {0};
uint64_t aaa = 0;
for (int i = MAX_BIT - 1; i >= 0; i--) {
if (((uint64_t)0x1 << i) <= (k - aaa)) {
int count_0 = 0;
int count_1 = 0;
for (const auto &a_i : a_bit) {
if (a_i[i] == 0) {
count_0++;
} else {
count_1++;
}
}
if (count_0 > count_1) {
result[i] = 1;
aaa += (uint64_t)0x1 << i;
}
}
}
uint64_t sum = 0;
for (int i = 0; i < MAX_BIT; i++) {
sum += result[i] << i;
}
cout << f(sum, a) << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 944,451 | 944,452 | u841641310 | cpp |
p03138 | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[42][2] = {};
for (int i = 0; i < 42; i++)
dp[i][1] = -1;
for (int i = 40; i >= 0; i--) {
int c0 = 0, c1 = 0;
for (int j = 0; j < n; j++) {
if (a[j] & (1LL << i))
c1++;
else
c0++;
}
if (k & (1LL << i)) {
dp[i][0] = dp[i + 1][0] + c0 * (1LL << i); // 1
dp[i][1] = dp[i + 1][0] + c1 * (1LL << i); // 0
if (dp[i + 1][1] >= 0)
dp[i][1] = max(dp[i][1], dp[i + 1][1] + c1 * (1LL << i)); // 0
} else {
dp[i][0] = dp[i + 1][0] + c1 * (1LL << i); // 0
if (dp[i + 1][1] >= 0)
dp[i][1] = dp[i + 1][1] + max(c0, c1) * (1LL << i); // 1, 0
}
}
cout << max(dp[0][0], dp[0][1]) << endl;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[42][2] = {};
for (int i = 0; i < 42; i++)
dp[i][1] = -1;
for (int i = 40; i >= 0; i--) {
int c0 = 0, c1 = 0;
for (int j = 0; j < n; j++) {
if (a[j] & (1LL << i))
c1++;
else
c0++;
}
if (k & (1LL << i)) {
dp[i][0] = dp[i + 1][0] + c0 * (1LL << i); // 1
dp[i][1] = dp[i + 1][0] + c1 * (1LL << i); // 0
if (dp[i + 1][1] >= 0)
dp[i][1] =
max(dp[i][1], dp[i + 1][1] + max(c0, c1) * (1LL << i)); // 1, 0
} else {
dp[i][0] = dp[i + 1][0] + c1 * (1LL << i); // 0
if (dp[i + 1][1] >= 0)
dp[i][1] = dp[i + 1][1] + max(c0, c1) * (1LL << i); // 1, 0
}
}
cout << max(dp[0][0], dp[0][1]) << endl;
} | [
"call.add",
"call.arguments.change"
] | 944,453 | 944,454 | u984730891 | cpp |
p03138 | #include <algorithm>
#include <complex>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int N;
ll K;
ll dp[2][42];
ll a[101000];
int x[64];
int n[64];
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
fill(x, x + 64, 0);
for (int i = 0; i < 42; i++) {
for (int j = 0; j < N; j++) {
x[i] += 1 - (a[j] >> i) % 2;
}
n[i] = (K >> i) % 2;
}
dp[0][41] = 0;
dp[1][41] = 0;
fill(dp[0], dp[0] + 64, 0);
fill(dp[1], dp[1] + 64, 0);
for (int i = 3; i >= 0; i--) {
if (n[i] == 0) {
dp[0][i] = dp[0][i + 1] + (N - x[i]) * (1LL << i);
if (dp[1][i + 1]) {
dp[1][i] = dp[1][i + 1] + max(N - x[i], x[i]) * (1LL << i);
}
} else {
dp[0][i] = dp[0][i + 1] + x[i] * (1LL << i);
dp[1][i] = dp[0][i + 1] + (N - x[i]) * (1LL << i);
if (dp[1][i + 1]) {
dp[1][i] = max(dp[1][i + 1] + max(N - x[i], x[i]) * (1LL << i),
dp[0][i + 1] + (N - x[i]) * (1LL << i));
}
}
}
cout << max(dp[0][0], dp[1][0]) << endl;
return 0;
}
| #include <algorithm>
#include <complex>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int N;
ll K;
ll dp[2][42];
ll a[101000];
int x[64];
int n[64];
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
fill(x, x + 64, 0);
for (int i = 0; i < 42; i++) {
for (int j = 0; j < N; j++) {
x[i] += 1 - (a[j] >> i) % 2;
}
n[i] = (K >> i) % 2;
}
dp[0][41] = 0;
dp[1][41] = 0;
fill(dp[0], dp[0] + 64, 0);
fill(dp[1], dp[1] + 64, 0);
for (int i = 40; i >= 0; i--) {
if (n[i] == 0) {
dp[0][i] = dp[0][i + 1] + (N - x[i]) * (1LL << i);
if (dp[1][i + 1]) {
dp[1][i] = dp[1][i + 1] + max(N - x[i], x[i]) * (1LL << i);
}
} else {
dp[0][i] = dp[0][i + 1] + x[i] * (1LL << i);
dp[1][i] = dp[0][i + 1] + (N - x[i]) * (1LL << i);
if (dp[1][i + 1]) {
dp[1][i] = max(dp[1][i + 1] + max(N - x[i], x[i]) * (1LL << i),
dp[0][i + 1] + (N - x[i]) * (1LL << i));
}
}
}
cout << max(dp[0][0], dp[1][0]) << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 944,455 | 944,456 | u852158538 | cpp |
p03138 | #include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, cnt;
ll k, a[100000], x[40], b[40] = {}, two[40], ans = 0, c;
scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
two[0] = 1;
for (int i = 1; i < 40; i++) {
two[i] = 2 * two[i - 1];
}
for (int i = 39; i >= 0; i--) {
cnt = 0;
for (int j = 0; j < n; j++) {
if ((two[i] & a[j])) {
cnt++;
}
}
if (2 * cnt < n) {
x[i] = two[i];
}
}
for (int i = 39; i >= 0; i--) {
if ((k & two[i])) {
for (int j = 39; j > i; j--) {
b[i] += (k & two[j]);
}
for (int j = 0; j < i; j++) {
b[i] += x[j];
}
}
}
for (int i = 0; i < n; i++) {
ans += (a[i] & k);
}
for (int i = 0; i < 40; i++) {
c = 0;
for (int j = 0; j < n; j++) {
c += (b[i] ^ a[j]);
}
ans = max(ans, c);
}
printf("%lld\n", ans);
} | #include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, cnt;
ll k, a[100000], x[40], b[40] = {}, two[40], ans = 0, c;
scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
two[0] = 1;
for (int i = 1; i < 40; i++) {
two[i] = 2 * two[i - 1];
}
for (int i = 39; i >= 0; i--) {
cnt = 0;
for (int j = 0; j < n; j++) {
if ((two[i] & a[j])) {
cnt++;
}
}
if (2 * cnt < n) {
x[i] = two[i];
}
}
for (int i = 39; i >= 0; i--) {
if ((k & two[i])) {
for (int j = 39; j > i; j--) {
b[i] += (k & two[j]);
}
for (int j = 0; j < i; j++) {
b[i] += x[j];
}
}
}
for (int i = 0; i < n; i++) {
ans += (a[i] ^ k);
}
for (int i = 0; i < 40; i++) {
c = 0;
for (int j = 0; j < n; j++) {
c += (b[i] ^ a[j]);
}
ans = max(ans, c);
}
printf("%lld\n", ans);
} | [
"assignment.value.change",
"expression.operation.binary.change"
] | 944,461 | 944,462 | u855429581 | cpp |
p03138 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll Solve() {
ll n, k;
cin >> n >> k;
int len = log2(k) + 1;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 0)
len = max(len, (int)log2(a[i]) + 1);
}
vector<ll> sum(len + 1);
vector<vector<ll>> f(len + 1, vector<ll>(2));
for (ll i = 0; i < len; ++i) {
ll value = 1ll << i;
for (ll j = 0; j < n; ++j)
f[i][!(a[j] >> i & 1ll)] += value;
sum[i] = max(f[i][0], f[i][1]);
}
for (int i = 1; i < len; ++i)
sum[i] += sum[i - 1];
ll res = 0, add = 0;
for (ll i = len - 1; 0 <= i; --i) {
if (k >> i & 1ll) { // k ใฎ i ใใใ็ฎใ 1
// 0 ใ้ธใใง i + 1 ใใใ็ฎไปฅ้่ฒชๆฌฒ็ใซ้ธใถ
ll score = add + f[i][1];
if (0 < i)
score += sum[i - 1];
res = max(res, score);
add += f[i][1];
} else { // k ใฎ i ใใใ็ฎใ 0
add += f[i][0];
}
}
return max(res, add);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << Solve() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll Solve() {
ll n, k;
cin >> n >> k;
int len = log2(k) + 1;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 0)
len = max(len, (int)log2(a[i]) + 1);
}
vector<ll> sum(len + 1);
vector<vector<ll>> f(len + 1, vector<ll>(2));
for (ll i = 0; i < len; ++i) {
ll value = 1ll << i;
for (ll j = 0; j < n; ++j)
f[i][!(a[j] >> i & 1)] += value;
sum[i] = max(f[i][0], f[i][1]);
}
for (int i = 1; i < len; ++i)
sum[i] += sum[i - 1];
ll res = 0, add = 0;
for (ll i = len - 1; 0 <= i; --i) {
if (k >> i & 1) { // k ใฎ i ใใใ็ฎใ 1
// 0 ใ้ธใใง i + 1 ใใใ็ฎไปฅ้่ฒชๆฌฒ็ใซ้ธใถ
ll score = add + f[i][0];
if (0 < i)
score += sum[i - 1];
res = max(res, score);
add += f[i][1];
} else { // k ใฎ i ใใใ็ฎใ 0
add += f[i][0];
}
}
return max(res, add);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << Solve() << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 944,463 | 944,464 | u090097090 | cpp |
p03138 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll Solve() {
ll n, k;
cin >> n >> k;
int len = log2(k) + 1;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 0)
len = max(len, (int)log2(a[i]) + 1);
}
vector<ll> sum(len + 1);
vector<vector<ll>> f(len + 1, vector<ll>(2));
for (ll i = 0; i < len; ++i) {
ll value = 1ll << i;
for (ll j = 0; j < n; ++j)
f[i][!(a[j] >> i & 1)] += value;
sum[i] = max(f[i][0], f[i][1]);
}
for (int i = 1; i < len; ++i)
sum[i] += sum[i - 1];
ll res = 0, add = 0;
for (ll i = len - 1; 0 <= i; --i) {
if (k >> i & 1) { // k ใฎ i ใใใ็ฎใ 1
// 0 ใ้ธใใง i + 1 ใใใ็ฎไปฅ้่ฒชๆฌฒ็ใซ้ธใถ
ll score = add + f[i][1];
if (0 < i)
score += sum[i - 1];
res = max(res, score);
add += f[i][1];
} else { // k ใฎ i ใใใ็ฎใ 0
add += f[i][0];
}
}
return max(res, add);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << Solve() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll Solve() {
ll n, k;
cin >> n >> k;
int len = log2(k) + 1;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 0)
len = max(len, (int)log2(a[i]) + 1);
}
vector<ll> sum(len + 1);
vector<vector<ll>> f(len + 1, vector<ll>(2));
for (ll i = 0; i < len; ++i) {
ll value = 1ll << i;
for (ll j = 0; j < n; ++j)
f[i][!(a[j] >> i & 1)] += value;
sum[i] = max(f[i][0], f[i][1]);
}
for (int i = 1; i < len; ++i)
sum[i] += sum[i - 1];
ll res = 0, add = 0;
for (ll i = len - 1; 0 <= i; --i) {
if (k >> i & 1) { // k ใฎ i ใใใ็ฎใ 1
// 0 ใ้ธใใง i + 1 ใใใ็ฎไปฅ้่ฒชๆฌฒ็ใซ้ธใถ
ll score = add + f[i][0];
if (0 < i)
score += sum[i - 1];
res = max(res, score);
add += f[i][1];
} else { // k ใฎ i ใใใ็ฎใ 0
add += f[i][0];
}
}
return max(res, add);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << Solve() << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 944,465 | 944,464 | u090097090 | cpp |
p03138 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll Solve() {
ll n, k;
cin >> n >> k;
int len = log2(k) + 1;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 0)
len = max(len, (int)log2(a[i]) + 1);
}
vector<ll> sum(len + 1);
vector<vector<ll>> f(len + 1, vector<ll>(2));
for (int i = 0; i < len; ++i) {
ll value = 1ll << i;
for (int j = 0; j < n; ++j)
f[i][!(a[j] >> i & 1)] += value;
sum[i] = max(f[i][0], f[i][1]);
}
for (int i = 1; i < len; ++i)
sum[i] += sum[i - 1];
ll res = 0, add = 0;
for (int i = len - 1; 0 <= i; --i) {
if (k >> i & 1) { // k ใฎ i ใใใ็ฎใ 1
// 0 ใ้ธใใง i + 1 ใใใ็ฎไปฅ้่ฒชๆฌฒ็ใซ้ธใถ
ll score = add + f[i][1];
if (0 < i)
score += sum[i - 1];
res = max(res, score);
add += f[i][1];
} else { // k ใฎ i ใใใ็ฎใ 0
add += f[i][0];
}
}
return max(res, add);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << Solve() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll Solve() {
ll n, k;
cin >> n >> k;
int len = log2(k) + 1;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 0)
len = max(len, (int)log2(a[i]) + 1);
}
vector<ll> sum(len + 1);
vector<vector<ll>> f(len + 1, vector<ll>(2));
for (ll i = 0; i < len; ++i) {
ll value = 1ll << i;
for (ll j = 0; j < n; ++j)
f[i][!(a[j] >> i & 1)] += value;
sum[i] = max(f[i][0], f[i][1]);
}
for (int i = 1; i < len; ++i)
sum[i] += sum[i - 1];
ll res = 0, add = 0;
for (ll i = len - 1; 0 <= i; --i) {
if (k >> i & 1) { // k ใฎ i ใใใ็ฎใ 1
// 0 ใ้ธใใง i + 1 ใใใ็ฎไปฅ้่ฒชๆฌฒ็ใซ้ธใถ
ll score = add + f[i][0];
if (0 < i)
score += sum[i - 1];
res = max(res, score);
add += f[i][1];
} else { // k ใฎ i ใใใ็ฎใ 0
add += f[i][0];
}
}
return max(res, add);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << Solve() << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 944,466 | 944,464 | u090097090 | cpp |
p03138 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF (LLONG_MAX - 1e5)
#define fcout cout << fixed << setprecision(10)
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, K;
cin >> N >> K;
vector<int> A(N);
REP(i, N) cin >> A[i];
int res = 0;
REV(d, 50, -1) {
if (d >= 0 && (1LL << d) > K)
continue;
int tmp = 0;
REV(k, 50, 0) {
if (k > d) {
tmp += ((1LL << k) & K);
} else if (k < d) {
int cnt = 0;
REP(i, A.size()) {
if ((A[i] >> k) & 1LL)
cnt++;
}
if (cnt * 2LL < A.size()) {
tmp += (1LL << k);
}
}
}
int ans = 0;
REP(i, A.size()) { ans += (tmp ^ A[i]); }
res = max(res, ans);
}
cout << res << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF (LLONG_MAX - 1e5)
#define fcout cout << fixed << setprecision(10)
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, K;
cin >> N >> K;
vector<int> A(N);
REP(i, N) cin >> A[i];
int res = 0;
REV(d, 50, -1) {
if (d >= 0 && ((1LL << d) & K) == 0)
continue;
int tmp = 0;
REV(k, 50, 0) {
if (k > d) {
tmp += ((1LL << k) & K);
} else if (k < d) {
int cnt = 0;
REP(i, A.size()) {
if ((A[i] >> k) & 1LL)
cnt++;
}
if (cnt * 2LL < A.size()) {
tmp += (1LL << k);
}
}
}
int ans = 0;
REP(i, A.size()) { ans += (tmp ^ A[i]); }
res = max(res, ans);
}
cout << res << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 944,467 | 944,468 | u516353059 | cpp |
p03138 | #include <bits/stdc++.h>
#define REP(i, a, n) for (int i = (a); i < (int)(n); ++i)
#define REPC(i, a, n) for (int i = (a); i <= (int)(n); ++i)
#define ALL(t) t.begin(), t.end()
#define RALL(t) t.rbegin(), t.rend()
#define MATINIT(type, row, col, init) \
vector<vector<type>>(row, vector<type>(col, init));
#define Yes(cond) cout << (cond ? "Yes" : "No") << endl;
#define YES(cond) cout << (cond ? "YES" : "NO") << endl;
using namespace std;
using LL = long long;
using ULL = unsigned long long;
template <class T> using VEC = std::vector<T>;
template <class T> using MAT = std::vector<std::vector<T>>;
void DUMP() { cerr << endl; }
template <class Head, class... Tail> void DUMP(Head &&head, Tail &&...tail) {
cerr << head << ", ";
DUMP(std::move(tail)...);
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, map<T1, T2> &m) {
os << "{";
for (auto p : m)
os << p << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
os << "[" << p.first << " " << p.second << "]";
return os;
}
LL N, K;
VEC<LL> A;
LL answer(LL x) {
LL sum = 0;
REP(i, 0, N) {
sum += (x xor A[i]);
// DUMP(sum, x, A[i], x xor A[i]);
}
return sum;
}
int main() {
cin >> N >> K;
A = VEC<LL>(N);
REP(i, 0, N) cin >> A[i];
LL ma = pow(2, (LL)log2(K));
// DUMP(ma);
LL x = 0;
for (LL bit = ma; bit > 0; bit >>= 1) {
// DUMP("bit: ", bit);
LL cnt = 0;
REP(i, 0, N) {
// if on
if ((bit & A[i]) > 0) {
++cnt;
}
}
// DUMP("cnt: ", cnt);
if (cnt < (double)N / 2 && x <= K)
x += bit;
}
LL ans = 0;
ans = answer(x);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, a, n) for (int i = (a); i < (int)(n); ++i)
#define REPC(i, a, n) for (int i = (a); i <= (int)(n); ++i)
#define ALL(t) t.begin(), t.end()
#define RALL(t) t.rbegin(), t.rend()
#define MATINIT(type, row, col, init) \
vector<vector<type>>(row, vector<type>(col, init));
#define Yes(cond) cout << (cond ? "Yes" : "No") << endl;
#define YES(cond) cout << (cond ? "YES" : "NO") << endl;
using namespace std;
using LL = long long;
using ULL = unsigned long long;
template <class T> using VEC = std::vector<T>;
template <class T> using MAT = std::vector<std::vector<T>>;
void DUMP() { cerr << endl; }
template <class Head, class... Tail> void DUMP(Head &&head, Tail &&...tail) {
cerr << head << ", ";
DUMP(std::move(tail)...);
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, map<T1, T2> &m) {
os << "{";
for (auto p : m)
os << p << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
os << "[" << p.first << " " << p.second << "]";
return os;
}
LL N, K;
VEC<LL> A;
LL answer(LL x) {
LL sum = 0;
REP(i, 0, N) {
sum += (x xor A[i]);
// DUMP(sum, x, A[i], x xor A[i]);
}
return sum;
}
int main() {
cin >> N >> K;
A = VEC<LL>(N);
REP(i, 0, N) cin >> A[i];
LL ma = pow(2, (LL)log2(K));
// DUMP(ma);
LL x = 0;
for (LL bit = ma; bit > 0; bit >>= 1) {
// DUMP("bit: ", bit);
LL cnt = 0;
REP(i, 0, N) {
// if on
if ((bit & A[i]) > 0) {
++cnt;
}
}
// DUMP("cnt: ", cnt);
if (cnt < (double)N / 2 && x + bit <= K)
x += bit;
}
LL ans = 0;
ans = answer(x);
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 944,471 | 944,472 | u094534482 | cpp |
p03138 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
void read(ll &a) {
a = 0;
int b = 1, c = getchar();
while (c > '9' || c < '0') {
if (c == '-')
b = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
a = (a << 3) + (a << 1) + c - 48, c = getchar();
a *= b;
}
const int N = 1e5 + 5;
ll n, k, cnt[55], ans, X, a[N];
int main() {
read(n);
read(k);
for (ll i = 0; i < n; i++) {
read(a[i]);
for (ll j = 0; j <= 40; j++)
if (a[i] & (1ll << j))
cnt[j]++;
}
for (ll i = 40; i >= 0; i--)
if (cnt[i] < n - cnt[i] && X + (1ll << i) <= k)
X += (1ll << i);
for (ll i = 1; i <= n; i++)
ans += (X ^ a[i]);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
void read(ll &a) {
a = 0;
int b = 1, c = getchar();
while (c > '9' || c < '0') {
if (c == '-')
b = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
a = (a << 3) + (a << 1) + c - 48, c = getchar();
a *= b;
}
const int N = 1e5 + 5;
ll n, k, cnt[55], ans, X, a[N];
int main() {
read(n);
read(k);
for (ll i = 1; i <= n; i++) {
read(a[i]);
for (ll j = 0; j <= 40; j++)
if (a[i] & (1ll << j))
cnt[j]++;
}
for (ll i = 40; i >= 0; i--)
if (cnt[i] < n - cnt[i] && X + (1ll << i) <= k)
X += (1ll << i);
for (ll i = 1; i <= n; i++)
ans += (X ^ a[i]);
cout << ans << '\n';
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"
] | 944,475 | 944,476 | u955678262 | cpp |
p03138 | #include <stdio.h>
int N;
long long K;
long long A[100000];
long long C[40][2];
long long max(long long x, long long y) { return x > y ? x : y; }
int main() {
scanf("%d %lld", &N, &K);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
for (int j = 0; j < 40; j++) {
C[j][A[i] >> j & 1]++;
}
}
long long ans = 0;
long long curr = 0;
for (int i = 39; i >= 0; i--) {
if (K >> i & 1) {
long long cand = curr;
cand += C[i][1] << i;
for (int j = i - 1; j >= 0; j--) {
cand += max(C[j][0], C[j][1]) << j;
}
ans = max(ans, cand);
}
curr += C[i][1] << i;
}
ans = max(ans, curr);
printf("%lld\n", ans);
return 0;
}
| #include <stdio.h>
int N;
long long K;
long long A[100000];
long long C[40][2];
long long max(long long x, long long y) { return x > y ? x : y; }
int main() {
scanf("%d %lld", &N, &K);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
for (int j = 0; j < 40; j++) {
C[j][A[i] >> j & 1]++;
}
}
long long ans = 0;
long long curr = 0;
for (int i = 39; i >= 0; i--) {
if (K >> i & 1) {
long long cand = curr;
cand += C[i][1] << i;
for (int j = i - 1; j >= 0; j--) {
cand += max(C[j][0], C[j][1]) << j;
}
ans = max(ans, cand);
}
curr += C[i][~K >> i & 1] << i;
}
ans = max(ans, curr);
printf("%lld\n", ans);
return 0;
}
| [
"assignment.change"
] | 944,481 | 944,482 | u006493569 | cpp |
p03138 | #include <iostream>
#include <vector>
using namespace std;
int main() {
long n, k;
cin >> n >> k;
vector<long> a(n);
for (auto &e : a)
cin >> e;
long res = 0;
for (long i; i = k & -k; k -= i) {
long x = k - i;
for (int j = 0; (1L << j) < i; ++j) {
int c = 0;
for (auto &e : a)
c += (e >> j) & 1;
if (2 * c < n)
x |= 1L << j;
}
long s = 0;
for (auto &e : a)
s += x ^ e;
if (res < s)
res = s;
}
cout << res << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
long n, k;
cin >> n >> k;
vector<long> a(n);
for (auto &e : a)
cin >> e;
long res = 0;
++k;
for (long i; i = k & -k; k -= i) {
long x = k - i;
for (int j = 0; (1L << j) < i; ++j) {
int c = 0;
for (auto &e : a)
c += (e >> j) & 1;
if (2 * c < n)
x |= 1L << j;
}
long s = 0;
for (auto &e : a)
s += x ^ e;
if (res < s)
res = s;
}
cout << res << endl;
}
| [
"expression.unary.arithmetic.add"
] | 944,487 | 944,488 | u503549962 | cpp |
p03138 | #include <iostream>
#include <vector>
using namespace std;
int main() {
long n, k;
cin >> n >> k;
vector<long> a(n);
for (auto &e : a)
cin >> e;
long res = 0;
auto t = ++k;
for (int i; i = k & -k; k -= i) {
long x = t - i;
for (int j = 0; (1L << j) < i; ++j) {
int c = 0;
for (auto &e : a)
c += (e >> j) & 1;
if (2 * c < n)
x |= 1L << j;
}
long s = 0;
for (auto &e : a)
s += x ^ e;
if (res < s)
res = s;
}
cout << res << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
long n, k;
cin >> n >> k;
vector<long> a(n);
for (auto &e : a)
cin >> e;
long res = 0;
++k;
for (long i; i = k & -k; k -= i) {
long x = k - i;
for (int j = 0; (1L << j) < i; ++j) {
int c = 0;
for (auto &e : a)
c += (e >> j) & 1;
if (2 * c < n)
x |= 1L << j;
}
long s = 0;
for (auto &e : a)
s += x ^ e;
if (res < s)
res = s;
}
cout << res << endl;
}
| [
"variable_declaration.remove",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change",
"identifier.change",
"expression.operation.binary.change"
] | 944,489 | 944,488 | u503549962 | cpp |
p03138 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
#define REP(i, n, m) for (int i = n; i < m; i++)
#define REPR(i, n, m) for (int i = n; i >= m; i--)
#define LREP(i, n, m) for (ll i = n; i < m; i++)
#define LREPR(i, n, m) for (ll i = n; i >= m; i--)
#define P pair<int, int>
const int INF = 1e9 + 1;
const int MOD = 1e9 + 7;
//---functions---//
int gcd(int a, int b) {
if (a < b)
swap(a, b);
return b ? gcd(b, a % b) : a;
}
int s2i(string num) {
stringstream ss;
ss << num << flush;
int n;
ss >> n;
return n;
}
string i2s(int n) {
stringstream ss;
ss << n << flush;
return ss.str();
}
bool firstCompare(const P &firstElof, const P &secondElof) {
return firstElof.first < secondElof.first;
}
bool secondCompare(const P &firstElof, const P &secondElof) {
return firstElof.second < secondElof.second;
}
//---------------//
ll N;
ll K;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> N >> K;
ll A[N];
LREP(i, 0, N) { cin >> A[i]; }
ll X = 0;
ll f = 0;
ll tmp;
LREP(bit, 0, 40) {
tmp = 0;
LREP(i, 0, N) {
if (A[i] & (1L << bit))
tmp += 1;
}
if (K >= X + (1L << bit) && tmp < N - tmp) {
X += (1L << bit);
tmp = N - tmp;
}
f += (1L << bit) * tmp;
}
cout << f << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
#define REP(i, n, m) for (int i = n; i < m; i++)
#define REPR(i, n, m) for (int i = n; i >= m; i--)
#define LREP(i, n, m) for (ll i = n; i < m; i++)
#define LREPR(i, n, m) for (ll i = n; i >= m; i--)
#define P pair<int, int>
const int INF = 1e9 + 1;
const int MOD = 1e9 + 7;
//---functions---//
int gcd(int a, int b) {
if (a < b)
swap(a, b);
return b ? gcd(b, a % b) : a;
}
int s2i(string num) {
stringstream ss;
ss << num << flush;
int n;
ss >> n;
return n;
}
string i2s(int n) {
stringstream ss;
ss << n << flush;
return ss.str();
}
bool firstCompare(const P &firstElof, const P &secondElof) {
return firstElof.first < secondElof.first;
}
bool secondCompare(const P &firstElof, const P &secondElof) {
return firstElof.second < secondElof.second;
}
//---------------//
ll N;
ll K;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> N >> K;
ll A[N];
LREP(i, 0, N) { cin >> A[i]; }
ll X = 0;
ll f = 0;
ll tmp;
REPR(bit, 40, 0) {
tmp = 0;
LREP(i, 0, N) {
if (A[i] & (1L << bit))
tmp += 1;
}
if (K >= X + (1L << bit) && tmp < N - tmp) {
X += (1L << bit);
tmp = N - tmp;
}
f += (1L << bit) * tmp;
}
cout << f << endl;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.change",
"call.arguments.add"
] | 944,493 | 944,494 | u052746401 | cpp |
p03138 | // need
#include <algorithm>
#include <iostream>
// data structure
#include <bitset>
#include <complex>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include <deque>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
// stream
//#include <istream>
#include <sstream>
//#include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
//#include <chrono>
#include <numeric>
#include <random>
// input
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T> void MACRO_VAR_Scan(T &t) { std::cin >> t; }
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &...rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) { \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T> void MACRO_VEC_ROW_Init(int n, T &t) { t.resize(n); }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &...rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T> void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &...rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
// output
#define OUT(dist) std::cout << (dist);
#define FOUT(n, dist) std::cout << std::fixed << std::setprecision(n) << (dist);
#define SOUT(n, c, dist) std::cout << std::setw(n) << std::setfill(c) << (dist);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define ENDL std::cout << std::endl;
#define FLUSH std::cout << std::flush;
#define SHOW(dist) \
{ std::cerr << #dist << "\t:" << (dist) << "\n"; }
#define SHOWVECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOWVECTOR2(v) \
{ \
std::cerr << #v << "\t:\n"; \
for (const auto &xxx : v) { \
for (const auto &yyy : xxx) { \
std::cerr << yyy << " "; \
} \
std::cerr << "\n"; \
} \
}
#define SHOWQUEUE(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.front() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
// utility
#define ALL(a) (a).begin(), (a).end()
#define FOR(w, a, n) for (int w = (a); w < (n); ++w)
#define RFOR(w, a, n) for (int w = (n)-1; w >= (a); --w)
#define REP(w, n) for (int w = 0; w < int(n); ++w)
#define RREP(w, n) for (int w = int(n) - 1; w >= 0; --w)
#define FORLL(w, a, n) for (ll w = ll(a); w < ll(n); ++w)
#define RFORLL(w, a, n) for (ll w = ll(n) - 1; w >= ll(a); --w)
#define REPLL(w, n) for (ll w = 0; w < ll(n); ++w)
#define RREPLL(w, n) for (ll w = ll(n) - 1; w >= 0; --w)
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
#define EXCEPTION(msg) \
throw std::string("Exception : " msg " [ in ") + __func__ + " : " + \
std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) \
try { \
if (cond) \
EXCEPTION(msg); \
} catch (std::string s) { \
std::cerr << s << std::endl; \
}
// void CHECKTIME(std::function<void()> f) { auto start =
// std::chrono::system_clock::now(); f(); auto end =
// std::chrono::system_clock::now(); auto res =
// std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count();
// std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template <class T> using V = std::vector<T>;
template <class T> using VV = V<V<T>>;
template <typename S, typename T>
std::ostream &operator<<(std::ostream &os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-6;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N> void FILL(T (&a)[N], const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T &val) {
for (auto &b : a)
FILL(b, val);
}
template <class T> void FILL(std::vector<T> &a, const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>> &a, const T &val) {
for (auto &b : a)
FILL(b, val);
}
// ------------>8------------------------------------->8------------
signed main() {
INIT;
VAR(int, n, k);
VEC(int, a, n);
int x = 0;
REP(i, 61) {
int cnt = 0;
REP(j, n) { cnt += !!(a[j] & 1LL << i); }
if (cnt < n - cnt)
x ^= 1LL << i;
if (k < x)
x ^= 1LL << i;
}
int ans = 0;
REP(i, n) ans += a[i] ^ x;
OUT(ans) BR;
return 0;
}
| // need
#include <algorithm>
#include <iostream>
// data structure
#include <bitset>
#include <complex>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include <deque>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
// stream
//#include <istream>
#include <sstream>
//#include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
//#include <chrono>
#include <numeric>
#include <random>
// input
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T> void MACRO_VAR_Scan(T &t) { std::cin >> t; }
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &...rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) { \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T> void MACRO_VEC_ROW_Init(int n, T &t) { t.resize(n); }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &...rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T> void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &...rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
// output
#define OUT(dist) std::cout << (dist);
#define FOUT(n, dist) std::cout << std::fixed << std::setprecision(n) << (dist);
#define SOUT(n, c, dist) std::cout << std::setw(n) << std::setfill(c) << (dist);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define ENDL std::cout << std::endl;
#define FLUSH std::cout << std::flush;
#define SHOW(dist) \
{ std::cerr << #dist << "\t:" << (dist) << "\n"; }
#define SHOWVECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOWVECTOR2(v) \
{ \
std::cerr << #v << "\t:\n"; \
for (const auto &xxx : v) { \
for (const auto &yyy : xxx) { \
std::cerr << yyy << " "; \
} \
std::cerr << "\n"; \
} \
}
#define SHOWQUEUE(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.front() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
// utility
#define ALL(a) (a).begin(), (a).end()
#define FOR(w, a, n) for (int w = (a); w < (n); ++w)
#define RFOR(w, a, n) for (int w = (n)-1; w >= (a); --w)
#define REP(w, n) for (int w = 0; w < int(n); ++w)
#define RREP(w, n) for (int w = int(n) - 1; w >= 0; --w)
#define FORLL(w, a, n) for (ll w = ll(a); w < ll(n); ++w)
#define RFORLL(w, a, n) for (ll w = ll(n) - 1; w >= ll(a); --w)
#define REPLL(w, n) for (ll w = 0; w < ll(n); ++w)
#define RREPLL(w, n) for (ll w = ll(n) - 1; w >= 0; --w)
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
#define EXCEPTION(msg) \
throw std::string("Exception : " msg " [ in ") + __func__ + " : " + \
std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) \
try { \
if (cond) \
EXCEPTION(msg); \
} catch (std::string s) { \
std::cerr << s << std::endl; \
}
// void CHECKTIME(std::function<void()> f) { auto start =
// std::chrono::system_clock::now(); f(); auto end =
// std::chrono::system_clock::now(); auto res =
// std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count();
// std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template <class T> using V = std::vector<T>;
template <class T> using VV = V<V<T>>;
template <typename S, typename T>
std::ostream &operator<<(std::ostream &os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-6;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N> void FILL(T (&a)[N], const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T &val) {
for (auto &b : a)
FILL(b, val);
}
template <class T> void FILL(std::vector<T> &a, const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>> &a, const T &val) {
for (auto &b : a)
FILL(b, val);
}
// ------------>8------------------------------------->8------------
signed main() {
INIT;
VAR(int, n, k);
VEC(int, a, n);
int x = 0;
RREP(i, 61) {
int cnt = 0;
REP(j, n) { cnt += !!(a[j] & 1LL << i); }
if (cnt < n - cnt)
x ^= 1LL << i;
if (k < x)
x ^= 1LL << i;
}
int ans = 0;
REP(i, n) ans += a[i] ^ x;
OUT(ans) BR;
return 0;
}
| [
"identifier.change",
"call.function.change"
] | 944,495 | 944,496 | u591343832 | cpp |
p03138 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
const double EPS = 1e-10;
int main() {
ll n, k;
ll an = 0;
ll an2 = 0;
cin >> n >> k;
vector<ll> a(n, 0);
vector<ll> b(43, 0);
vector<ll> c(43, 0);
for (ll i = 0; i < n; i++) {
cin >> a[i];
for (ll j = 0; j < 43; j++) {
if ((ll)((ll)a[i] >> j) & (ll)1)
b[j]++;
}
}
ll cc = 0;
for (ll j = 42; j >= 0; j--) {
if (b[j] < (n + 1) / 2) {
c[j] = 1;
cc += ((ll)1 << j);
}
}
if (cc <= k) {
ll d = cc;
for (ll t = 0; t < 43; t++) {
if ((ll)(d >> t) & (ll)1)
an2 += ((ll)(n - b[t])) * ((ll)1 << t);
else
an2 += (ll)b[t] * ((ll)1 << t);
}
cout << an2 << endl;
return 0;
}
for (ll j = 42; j >= 0; j--) {
if ((cc & ((ll)1 << j)) > k) {
cc -= ((ll)1 << j);
}
}
for (ll j = 42; j >= 0; j--) {
ll d = (ll)cc & ((ll) ~((ll)1 << j));
an2 = 0;
if (d <= k) {
for (ll t = 0; t < 43; t++) {
if ((ll)(d >> t) & (ll)1)
an2 += ((ll)(n - b[t])) * ((ll)1 << t);
else
an2 += (ll)b[t] * ((ll)1 << t);
}
an = max(an, an2);
} else {
}
}
cout << an << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
const double EPS = 1e-10;
int main() {
ll n, k;
ll an = 0;
ll an2 = 0;
cin >> n >> k;
vector<ll> a(n, 0);
vector<ll> b(43, 0);
vector<ll> c(43, 0);
for (ll i = 0; i < n; i++) {
cin >> a[i];
for (ll j = 0; j < 43; j++) {
if ((ll)((ll)a[i] >> j) & (ll)1)
b[j]++;
}
}
ll cc = 0;
for (ll j = 42; j >= 0; j--) {
if (b[j] < (n + 1) / 2) {
c[j] = 1;
cc += ((ll)1 << j);
}
}
if (cc <= k) {
ll d = cc;
for (ll t = 0; t < 43; t++) {
if ((ll)(d >> t) & (ll)1)
an2 += ((ll)(n - b[t])) * ((ll)1 << t);
else
an2 += (ll)b[t] * ((ll)1 << t);
}
cout << an2 << endl;
return 0;
}
for (ll j = 42; j >= 0; j--) {
if ((cc & ((ll)1 << j)) > k) {
cc -= ((ll)1 << j);
}
}
for (ll j = 42; j >= 0; j--) {
ll d = (ll)cc & ((ll) ~((ll)1 << j));
an2 = 0;
if (d <= k) {
for (ll t = 0; t < 43; t++) {
if ((ll)(d >> t) & (ll)1)
an2 += ((ll)(n - b[t])) * ((ll)1 << t);
else
an2 += (ll)b[t] * ((ll)1 << t);
}
an = max(an, an2);
} else {
cc = d;
}
}
cout << an << endl;
}
| [
"assignment.add"
] | 944,497 | 944,498 | u569367525 | cpp |
p03138 | #include <iostream>
using namespace std;
long foo[50] = {0};
void count(long num, long pos) {
if (num == 0)
return;
if (num % 2 == 1)
foo[pos]++;
count(num / 2, pos + 1);
}
long shift(long K, long keta) {
if (keta == 0)
return K;
return shift(K * 2, keta - 1);
}
long unshift(long K, long keta) {
if (keta == 0)
return K;
if (K == 0)
return K;
return unshift(K / 2, keta - 1);
}
long fulluse(long N, long limit) {
long ans = 0;
for (long i = 0; i <= limit; i++) {
long tmp = foo[i];
if (N - foo[i] > tmp)
tmp = N - foo[i];
ans += shift(tmp, i);
}
return ans;
}
long maxfx(long K, long N, long limit) {
if (limit < 0)
return 0;
if (unshift(K, limit) == 0) {
return shift(foo[limit], limit) + maxfx(K, N, limit - 1);
}
long tmp1 = shift(N - foo[limit], limit) + maxfx(K, N, limit - 1);
long tmp2 = shift(foo[limit], limit) + fulluse(N, limit - 1);
if (tmp1 > tmp2)
return tmp1;
return tmp2;
}
int main(void) {
long N, K;
cin >> N >> K;
for (long i = 0; i < N; i++) {
long tmp;
cin >> tmp;
count(tmp, 0);
}
cout << maxfx(K, N, 49) << endl;
return 0;
}
| #include <iostream>
using namespace std;
long foo[50] = {0};
void count(long num, long pos) {
if (num == 0)
return;
if (num % 2 == 1)
foo[pos]++;
count(num / 2, pos + 1);
}
long shift(long K, long keta) {
if (keta == 0)
return K;
return shift(K * 2, keta - 1);
}
long unshift(long K, long keta) {
if (keta == 0)
return K;
if (K == 0)
return K;
return unshift(K / 2, keta - 1);
}
long fulluse(long N, long limit) {
long ans = 0;
for (long i = 0; i <= limit; i++) {
long tmp = foo[i];
if (N - foo[i] > tmp)
tmp = N - foo[i];
ans += shift(tmp, i);
}
return ans;
}
long maxfx(long K, long N, long limit) {
if (limit < 0)
return 0;
if (unshift(K, limit) % 2 == 0) {
return shift(foo[limit], limit) + maxfx(K, N, limit - 1);
}
long tmp1 = shift(N - foo[limit], limit) + maxfx(K, N, limit - 1);
long tmp2 = shift(foo[limit], limit) + fulluse(N, limit - 1);
if (tmp1 > tmp2)
return tmp1;
return tmp2;
}
int main(void) {
long N, K;
cin >> N >> K;
for (long i = 0; i < N; i++) {
long tmp;
cin >> tmp;
count(tmp, 0);
}
cout << maxfx(K, N, 49) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 944,502 | 944,503 | u995792346 | cpp |
p03138 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define INF 1e+18
#define MOD 1000000007
using namespace std;
int main() {
ll ans = 0;
ll N, K;
cin >> N >> K;
ll A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
ll num[41][2] = {};
ll x = 1;
for (ll i = 0; i <= 40; i++) {
for (int k = 0; k < N; k++) {
if (A[k] % 2 == 0) {
num[i][1] += x;
} else {
num[i][0] += x;
}
A[k] /= 2;
}
x *= 2;
}
ll keta_K[41] = {};
ll saijoi = -1;
for (int i = 0; i < 41; i++) {
keta_K[i] += K % 2;
if (keta_K[i] == 1) {
saijoi = i;
}
K /= 2;
}
for (int i = 0; i <= saijoi; i++) {
ans += num[i][0];
}
for (int i = saijoi; i >= 0; i--) {
ll temp = 0;
if (keta_K[i] == 0) {
continue;
}
for (int j = 0; j <= saijoi; j++) {
if (j < i) {
temp += max(num[j][0], num[j][1]);
} else if (j > i) {
temp += num[j][keta_K[j]];
} else {
temp += num[j][0];
}
}
ans = max(ans, temp);
}
for (int i = saijoi + 1; i < 41; i++) {
ans += num[i][0];
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define INF 1e+18
#define MOD 1000000007
using namespace std;
int main() {
ll ans = 0;
ll N, K;
cin >> N >> K;
ll A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
ll num[41][2] = {};
ll x = 1;
for (ll i = 0; i <= 40; i++) {
for (int k = 0; k < N; k++) {
if (A[k] % 2 == 0) {
num[i][1] += x;
} else {
num[i][0] += x;
}
A[k] /= 2;
}
x *= 2;
}
ll keta_K[41] = {};
ll saijoi = -1;
for (int i = 0; i < 41; i++) {
keta_K[i] += K % 2;
if (keta_K[i] == 1) {
saijoi = i;
}
K /= 2;
}
for (int i = 0; i <= saijoi; i++) {
ans += num[i][keta_K[i]];
}
for (int i = saijoi; i >= 0; i--) {
ll temp = 0;
if (keta_K[i] == 0) {
continue;
}
for (int j = 0; j <= saijoi; j++) {
if (j < i) {
temp += max(num[j][0], num[j][1]);
} else if (j > i) {
temp += num[j][keta_K[j]];
} else {
temp += num[j][0];
}
}
ans = max(ans, temp);
}
for (int i = saijoi + 1; i < 41; i++) {
ans += num[i][0];
}
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 944,504 | 944,505 | u251433890 | cpp |
p03138 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<long long int, long long int> P;
typedef pair<P, int> PI;
void solve() {
long long int N, K;
cin >> N >> K;
vector<long long int> A(N);
for (long long int i = 0; i < N; ++i) {
cin >> A[i];
}
int c[64][2];
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 60; ++j) {
c[j][A[i] >> j & 1]++;
}
}
long long int num = 0;
for (int i = 59; i >= 0; --i) {
if (c[i][0] > c[i][1] && (num | (1ll << i)) <= K) {
num |= (1ll << i);
}
}
long long int ans = 0;
for (int i = 0; i < N; ++i) {
ans += num ^ A[i];
}
cout << ans << endl;
}
int main() {
solve();
return (0);
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<long long int, long long int> P;
typedef pair<P, int> PI;
void solve() {
long long int N, K;
cin >> N >> K;
vector<long long int> A(N);
for (long long int i = 0; i < N; ++i) {
cin >> A[i];
}
int c[64][2] = {};
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 60; ++j) {
c[j][A[i] >> j & 1]++;
}
}
long long int num = 0;
for (int i = 59; i >= 0; --i) {
if (c[i][0] > c[i][1] && (num | (1ll << i)) <= K) {
num |= (1ll << i);
}
}
long long int ans = 0;
for (int i = 0; i < N; ++i) {
ans += num ^ A[i];
}
cout << ans << endl;
}
int main() {
solve();
return (0);
} | [
"variable_declaration.value.change"
] | 944,509 | 944,510 | u057619905 | cpp |
p03138 | #include "bits/stdc++.h"
using namespace std;
long long dp[45], NoCond[45];
void PreProcess(long long Num) {
int pos = 0;
while (Num) {
if (Num % 2LL == 1LL)
++dp[pos];
++pos;
Num = Num / 2LL;
}
}
int MostSignificant(long long Num) {
int pos = -1;
while (Num) {
++pos;
Num = Num / 2LL;
}
return pos;
}
void Func1(int N, int Left) {
int i;
long long Value;
if (dp[0] > N - dp[0])
NoCond[0] = dp[0];
else
NoCond[0] = N - dp[0];
for (i = 1; i <= Left; ++i) {
Value = (1LL << i);
if (dp[i] > N - dp[i])
NoCond[i] = Value * dp[i];
else
NoCond[i] = Value * (N - dp[i]);
NoCond[i] += NoCond[i - 1];
}
}
long long FindAns(int N, long long k, int Left) {
int i;
long long Value, Pre = 0;
for (i = 40; i > Left; --i) {
Value = (1LL << i);
Pre = Pre + (Value * dp[i]);
}
long long Cur, Temp, Ans = 0LL;
for (i = Left; i >= 1; --i) {
Value = (1LL << i);
if (((k >> i) & 1LL) == 1LL) {
Temp = Value * dp[i];
Temp = Pre + Temp + NoCond[i - 1];
Ans = max(Ans, Temp);
Cur = Pre + Value * (N - dp[i]);
} else
Cur = Pre + Value * dp[i];
Pre = Cur;
}
if ((k & 1LL) == 0LL) {
Cur = Pre + Value * dp[0];
Ans = max(Ans, Cur);
} else
Ans = max(Ans, Pre + NoCond[0]);
return Ans;
}
int main() {
int N, i;
long long k, Num, Sum = 0;
scanf("%d%lld", &N, &k);
for (i = 1; i <= N; ++i) {
scanf("%lld", &Num);
PreProcess(Num);
Sum += Num;
}
int Left = MostSignificant(k);
if (Left == -1) {
printf("%lld\n", Sum);
return 0;
}
Func1(N, Left);
printf("%lld\n", FindAns(N, k, Left));
return 0;
} | #include "bits/stdc++.h"
using namespace std;
long long dp[45], NoCond[45];
void PreProcess(long long Num) {
int pos = 0;
while (Num) {
if (Num % 2LL == 1LL)
++dp[pos];
++pos;
Num = Num / 2LL;
}
}
int MostSignificant(long long Num) {
int pos = -1;
while (Num) {
++pos;
Num = Num / 2LL;
}
return pos;
}
void Func1(int N, int Left) {
int i;
long long Value;
if (dp[0] > N - dp[0])
NoCond[0] = dp[0];
else
NoCond[0] = N - dp[0];
for (i = 1; i <= Left; ++i) {
Value = (1LL << i);
if (dp[i] > N - dp[i])
NoCond[i] = Value * dp[i];
else
NoCond[i] = Value * (N - dp[i]);
NoCond[i] += NoCond[i - 1];
}
}
long long FindAns(int N, long long k, int Left) {
int i;
long long Value, Pre = 0;
for (i = 39; i > Left; --i) {
Value = (1LL << i);
Pre = Pre + (Value * dp[i]);
}
long long Cur, Temp, Ans = 0LL;
for (i = Left; i >= 1; --i) {
Value = (1LL << i);
if (((k >> i) & 1LL) == 1LL) {
Temp = Value * dp[i];
Temp = Pre + Temp + NoCond[i - 1];
Ans = max(Ans, Temp);
Cur = Pre + Value * (N - dp[i]);
} else
Cur = Pre + Value * dp[i];
Pre = Cur;
}
if ((k & 1LL) == 0LL) {
Cur = Pre + dp[0];
Ans = max(Ans, Cur);
} else
Ans = max(Ans, Pre + NoCond[0]);
return Ans;
}
int main() {
int N, i;
long long k, Num, Sum = 0;
scanf("%d%lld", &N, &k);
for (i = 1; i <= N; ++i) {
scanf("%lld", &Num);
PreProcess(Num);
Sum += Num;
}
int Left = MostSignificant(k);
if (Left == -1) {
printf("%lld\n", Sum);
return 0;
}
Func1(N, Left);
printf("%lld\n", FindAns(N, k, Left));
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.remove"
] | 944,511 | 944,512 | u843106258 | cpp |
p03138 |
#include "bits/stdc++.h"
using namespace std;
long long dp[45], NoCond[45];
void PreProcess(long long Num) {
int pos = 0;
while (Num) {
if (Num % 2LL == 1LL)
++dp[pos];
++pos;
Num = Num / 2LL;
}
}
int MostSignificant(long long Num) {
int pos = -1;
while (Num) {
++pos;
Num = Num / 2LL;
}
return pos;
}
void Func1(int N, int Left) {
int i;
long long Value;
if (dp[0] > N - dp[0])
NoCond[0] = dp[0];
else
NoCond[0] = N - dp[0];
for (i = 1; i <= Left; ++i) {
Value = (1LL << i);
if (dp[i] > N - dp[i])
NoCond[i] = Value * dp[i];
else
NoCond[i] = Value * (N - dp[i]);
NoCond[i] += NoCond[i - 1];
}
}
long long FindAns(int N, long long k, int Left) {
int i;
long long Value, Pre = 0;
for (i = 39; i > Left; --i) {
Value = (1LL << i);
Pre = Pre + (Value * dp[i]);
}
long long Cur, Temp, Ans = 0LL;
for (i = Left; i >= 1; --i) {
Value = (1LL << i);
if (((k >> i) & 1LL) == 1LL) {
Temp = Value * dp[i];
Temp = Pre + Temp + NoCond[i - 1];
Ans = max(Ans, Temp);
Cur = Pre + Value * (N - dp[i]);
} else
Cur = Pre + Value * dp[i];
Pre = Cur;
}
if ((k & 1LL) == 0LL) {
Cur = Pre + Value * dp[0];
Ans = max(Ans, Cur);
} else
Ans = max(Ans, Pre + NoCond[0]);
return Ans;
}
int main() {
int N, i;
long long k, Num, Sum = 0LL;
scanf("%d%lld", &N, &k);
for (i = 1; i <= N; ++i) {
scanf("%lld", &Num);
PreProcess(Num);
Sum += Num;
}
int Left = MostSignificant(k);
if (Left == -1) {
printf("%lld\n", Sum);
return 0;
}
Func1(N, Left);
printf("%lld\n", FindAns(N, k, Left));
return 0;
} | #include "bits/stdc++.h"
using namespace std;
long long dp[45], NoCond[45];
void PreProcess(long long Num) {
int pos = 0;
while (Num) {
if (Num % 2LL == 1LL)
++dp[pos];
++pos;
Num = Num / 2LL;
}
}
int MostSignificant(long long Num) {
int pos = -1;
while (Num) {
++pos;
Num = Num / 2LL;
}
return pos;
}
void Func1(int N, int Left) {
int i;
long long Value;
if (dp[0] > N - dp[0])
NoCond[0] = dp[0];
else
NoCond[0] = N - dp[0];
for (i = 1; i <= Left; ++i) {
Value = (1LL << i);
if (dp[i] > N - dp[i])
NoCond[i] = Value * dp[i];
else
NoCond[i] = Value * (N - dp[i]);
NoCond[i] += NoCond[i - 1];
}
}
long long FindAns(int N, long long k, int Left) {
int i;
long long Value, Pre = 0;
for (i = 39; i > Left; --i) {
Value = (1LL << i);
Pre = Pre + (Value * dp[i]);
}
long long Cur, Temp, Ans = 0LL;
for (i = Left; i >= 1; --i) {
Value = (1LL << i);
if (((k >> i) & 1LL) == 1LL) {
Temp = Value * dp[i];
Temp = Pre + Temp + NoCond[i - 1];
Ans = max(Ans, Temp);
Cur = Pre + Value * (N - dp[i]);
} else
Cur = Pre + Value * dp[i];
Pre = Cur;
}
if ((k & 1LL) == 0LL) {
Cur = Pre + dp[0];
Ans = max(Ans, Cur);
} else
Ans = max(Ans, Pre + NoCond[0]);
return Ans;
}
int main() {
int N, i;
long long k, Num, Sum = 0;
scanf("%d%lld", &N, &k);
for (i = 1; i <= N; ++i) {
scanf("%lld", &Num);
PreProcess(Num);
Sum += Num;
}
int Left = MostSignificant(k);
if (Left == -1) {
printf("%lld\n", Sum);
return 0;
}
Func1(N, Left);
printf("%lld\n", FindAns(N, k, Left));
return 0;
} | [
"expression.operation.binary.remove"
] | 944,513 | 944,512 | u843106258 | cpp |
p03138 | /*
Author: @karngyan
Team: BlundersPride
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef std::vector<ll> vll;
typedef std::pair<ll, ll> pll;
typedef std::vector<vll> vvll;
#define fast ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define endl '\n'
#define pb push_back
#define rep(i, a, b) for (ll i = a; i < b; ++i)
#define rrep(i, a, b) for (ll i = a; i > b; --i)
#define max3(a, b, c) max(a, max(b, c))
#define cres(c, n) (c).clear(), (c).resize(n)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ff first
#define ss second
#define mk make_pair
const ll M = 42;
const ll N = 1e5 + 10;
bitset<M> p(0);
bitset<M> a[N];
inline ll val() { return p.to_ulong(); }
inline ll vala(bitset<M> a) { return a.to_ulong(); }
signed main() {
fast;
////////////////////////////////////////////////////////////////////////////////////////////
ll n, k;
cin >> n >> k;
rep(i, 0, n) {
ll e;
cin >> e;
bitset<M> t(e);
a[i] = t;
}
ll x[M];
ll mxi = -1;
for (ll i = 0; i < M; ++i) {
x[i] = 0;
for (ll j = 0; j < n; ++j) {
if (a[j][i] == 0)
x[i] += 1;
}
}
bitset<M> kk(k);
rep(i, 0, M) {
if (kk[i] == 1) {
mxi = max(mxi, i);
}
}
if (mxi == -1) {
ll ans = 0;
for (auto it : a)
ans += vala(it);
cout << ans << endl;
exit(0);
}
bool alread_small = false;
rep(i, 0, mxi + 1) {
if (x[i] > (n - x[i])) {
if (kk[i] == 1) {
p[i] = 1;
} else {
if (alread_small)
p[i] = 1;
else
p[i] = 0;
}
} else {
if (kk[i] == 1)
alread_small = true;
p[i] = 0;
}
}
ll ans = 0;
rep(i, 0, n) { ans += vala(p ^ a[i]); }
cout << ans << endl;
return 0;
}
| /*
Author: @karngyan
Team: BlundersPride
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef std::vector<ll> vll;
typedef std::pair<ll, ll> pll;
typedef std::vector<vll> vvll;
#define fast ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define endl '\n'
#define pb push_back
#define rep(i, a, b) for (ll i = a; i < b; ++i)
#define rrep(i, a, b) for (ll i = a; i > b; --i)
#define max3(a, b, c) max(a, max(b, c))
#define cres(c, n) (c).clear(), (c).resize(n)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ff first
#define ss second
#define mk make_pair
const ll M = 42;
const ll N = 1e5 + 10;
bitset<M> p(0);
bitset<M> a[N];
inline ll val() { return p.to_ulong(); }
inline ll vala(bitset<M> a) { return a.to_ulong(); }
signed main() {
fast;
////////////////////////////////////////////////////////////////////////////////////////////
ll n, k;
cin >> n >> k;
rep(i, 0, n) {
ll e;
cin >> e;
bitset<M> t(e);
a[i] = t;
}
ll x[M];
ll mxi = -1;
for (ll i = 0; i < M; ++i) {
x[i] = 0;
for (ll j = 0; j < n; ++j) {
if (a[j][i] == 0)
x[i] += 1;
}
}
bitset<M> kk(k);
rep(i, 0, M) {
if (kk[i] == 1) {
mxi = max(mxi, i);
}
}
if (mxi == -1) {
ll ans = 0;
for (auto it : a)
ans += vala(it);
cout << ans << endl;
exit(0);
}
bool alread_small = false;
rrep(i, mxi, -1) {
if (x[i] > (n - x[i])) {
if (kk[i] == 1) {
p[i] = 1;
} else {
if (alread_small)
p[i] = 1;
else
p[i] = 0;
}
} else {
if (kk[i] == 1)
alread_small = true;
p[i] = 0;
}
}
ll ans = 0;
rep(i, 0, n) { ans += vala(p ^ a[i]); }
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.unary.arithmetic.add"
] | 944,517 | 944,518 | u863090510 | cpp |
p03138 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, m, n) for (long long i = (m); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
template <class T> using V = vector<T>;
template <class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll LLINF = (ll)1e18;
const ll INTINF = (ll)1e9;
const long double PI = 3.1415926535897932384626433;
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
template <template <class tmp> class T, class U>
ostream &operator<<(ostream &o, const T<U> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max<T>(a, b); }
template <class T> void chmin(T &a, const T b) { a = min<T>(a, b); }
void YN(bool flg) { cout << ((flg) ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << ((flg) ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << ((flg) ? "yes" : "no") << endl; }
int main() {
ll N, K;
cin >> N >> K;
V<ll> A(N);
REP(i, N) cin >> A[i];
V<ll> bit(60, 0), bitK(60, 0);
REP(i, N) REP(j, 60) if (A[i] & (1LL << j)) bit[j]++;
ll ans = 0;
REP(j, N) ans += (K ^ A[j]);
for (ll i = 59; 0 <= i; --i) {
if (!(K & (1LL << i)))
continue;
ll X = K;
X ^= (1LL << i);
for (int j = i - 1; 0 <= j; --j) {
if (X & (1LL << j))
X ^= (1 << j);
if (bit[i] < N - bit[i])
X ^= (1 << j);
}
ll sum = 0;
REP(j, N) sum += (X ^ A[j]);
chmax(ans, sum);
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, m, n) for (long long i = (m); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
template <class T> using V = vector<T>;
template <class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll LLINF = (ll)1e18;
const ll INTINF = (ll)1e9;
const long double PI = 3.1415926535897932384626433;
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
template <template <class tmp> class T, class U>
ostream &operator<<(ostream &o, const T<U> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max<T>(a, b); }
template <class T> void chmin(T &a, const T b) { a = min<T>(a, b); }
void YN(bool flg) { cout << ((flg) ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << ((flg) ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << ((flg) ? "yes" : "no") << endl; }
int main() {
ll N, K;
cin >> N >> K;
V<ll> A(N);
REP(i, N) cin >> A[i];
V<ll> bit(60, 0), bitK(60, 0);
REP(i, N) REP(j, 60) if (A[i] & (1LL << j)) bit[j]++;
ll ans = 0;
REP(j, N) ans += (K ^ A[j]);
for (ll i = 59; 0 <= i; --i) {
if (!(K & (1LL << i)))
continue;
ll X = K;
X ^= (1LL << i);
for (ll j = i - 1; 0 <= j; --j) {
if (X & (1LL << j))
X ^= (1LL << j);
if (bit[j] < N - bit[j])
X ^= (1LL << j);
}
ll sum = 0;
REP(j, N) sum += (X ^ A[j]);
chmax(ans, sum);
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"literal.number.type.widen.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 944,519 | 944,520 | u898651494 | cpp |
p03138 | #include <cstdint>
#include <iostream>
using namespace std; // 575
const int MAX = 100000;
const int64_t MAX2 = 1099511627776; // 2^40
int main() {
int N;
int64_t K, A[MAX];
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> A[i];
int64_t
dp1 = 0,
dp2 =
0; // bitDP,
// dp1ใฏ่ชๆใซKใใๅฐใใๅใๆนใdp2ใฏใกใใใฉKใซ้ใชใใใใชๅใๆน
for (int64_t i = MAX2; i > 0; i >>= 1) {
int c = 0;
for (int j = 0; j < N; ++j)
if (A[j] & i)
++c; // cใฏ0ใ้ธใถใจๅขใใๆฐ
if (K > i)
dp1 += max(c, N - c) * i;
if (K & i)
dp1 = max(dp1, dp2 + c * i);
dp2 += (K & i ? N - c : c) * i;
}
cout << max(dp1, dp2);
return 0;
}
/*
31536000ใฎใณใกใณใ่งฃ่ชฌๆฌ
ใใใใณใใฌใง็จๆใใฆใใใใAๅ้กใจใใ ใจใใฎๅ
็ฉบๆฌใฎๅฑ้บใใ
ใพใใใณใณใในใๅพใซ https://31536000.hatenablog.com/
ใง่งฃ่ชฌใใฆใใใจๆใใฎใงใ่ฏใใฃใใ่ชญใใงใญใผ
ใพใใๅbit็ฌ็ซใซ่ใใใใใฎใงใใใใพใ
ใพใๆๅใฎ1bitใซใคใใฆ่ใใใฐๆฎใใๅๆงใซ่งฃใใใฎใงใใใใ่ใใพใ
ใตใณใใซใฎ1, 6, 3ใ ใจ1, 0,
1ใซ็ญใใใฎใงใ1ใจxorใใใใ0ใจxorใใๆนใ1ๅๅๅพใงใ ไปฅไธๅๆงใซๆฑใใใฐ็ตไบ
dpใฎ้ท็งปใซใคใใฆ
dp1โdp1 : i=Kใชใ้ธใถใฎใฏ0ใฎใฟใใใไปฅๅคใฏๅธธใซๅฏ่ฝ
dp1โdp2 : ๅธธใซไธๅฏ่ฝ
dp2โdp1 : K&i>0ใใค้ธใถใฎใฏ0ใจใใฆใฟใ
dp2โdp2 : ๅใใฎใไธๆใซๅฎใพใ
*/ | #include <cstdint>
#include <iostream>
using namespace std; // 575
const int MAX = 100000;
const int64_t MAX2 = 1099511627776; // 2^40
int main() {
int N;
int64_t K, A[MAX];
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> A[i];
int64_t
dp1 = 0,
dp2 =
0; // bitDP,
// dp1ใฏ่ชๆใซKใใๅฐใใๅใๆนใdp2ใฏใกใใใฉKใซ้ใชใใใใชๅใๆน
for (int64_t i = MAX2; i > 0; i >>= 1) {
int c = 0;
for (int j = 0; j < N; ++j)
if (A[j] & i)
++c; // cใฏ0ใ้ธใถใจๅขใใๆฐ
if (K >= i << 1)
dp1 += max(c, N - c) * i; // dp1โdp1
if (K & i)
dp1 = max(dp1, dp2 + c * i); // dp2โdp1
dp2 += (K & i ? N - c : c) * i; // dp2โdp2
}
cout << max(dp1, dp2);
return 0;
}
/*
31536000ใฎใณใกใณใ่งฃ่ชฌๆฌ
ใใใใณใใฌใง็จๆใใฆใใใใAๅ้กใจใใ ใจใใฎๅ
็ฉบๆฌใฎๅฑ้บใใ
ใพใใใณใณใในใๅพใซ https://31536000.hatenablog.com/
ใง่งฃ่ชฌใใฆใใใจๆใใฎใงใ่ฏใใฃใใ่ชญใใงใญใผ
ใพใใๅbit็ฌ็ซใซ่ใใใใใฎใงใใใใพใ
ใพใๆๅใฎ1bitใซใคใใฆ่ใใใฐๆฎใใๅๆงใซ่งฃใใใฎใงใใใใ่ใใพใ
ใตใณใใซใฎ1, 6, 3ใ ใจ1, 0,
1ใซ็ญใใใฎใงใ1ใจxorใใใใ0ใจxorใใๆนใ1ๅๅๅพใงใ ไปฅไธๅๆงใซๆฑใใใฐ็ตไบ
dpใฎ้ท็งปใซใคใใฆ
dp1โdp1 : i=Kใชใ้ธใถใฎใฏ0ใฎใฟใใใไปฅๅคใฏๅธธใซๅฏ่ฝ
dp1โdp2 : ๅธธใซไธๅฏ่ฝ
dp2โdp1 : K&i>0ใใค้ธใถใฎใฏ0ใจใใฆใฟใ
dp2โdp2 : ๅใใฎใไธๆใซๅฎใพใ
*/ | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 944,523 | 944,524 | u550314572 | cpp |
p03138 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> an;
for (long i = 0; i < N; i++) {
long tmp = 0;
cin >> tmp;
an.push_back(tmp);
}
long bitCount[65] = {};
for (long a : an) {
long i = 1;
while (a != 0) {
long d = a % 2;
bitCount[i] += d;
a /= 2;
i++;
}
}
// 0 <= X <= K
long K2 = K;
long kbit = 0;
while (K2 != 0) {
K2 /= 2;
kbit++;
}
long X = 0;
for (long i = kbit; i >= 1; i--) {
long lastBit = 0;
if (bitCount[i] <= N / 2) {
long nextVal = (2 * X + 1) << (i - 1);
if (nextVal < K) {
lastBit = 1;
}
}
X = 2 * X + lastBit;
}
long fMax = 0;
for (long i = 0; i < N; i++) {
fMax += X ^ an[i];
}
cout << fMax << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> an;
for (long i = 0; i < N; i++) {
long tmp = 0;
cin >> tmp;
an.push_back(tmp);
}
long bitCount[65] = {};
for (long a : an) {
long i = 1;
while (a != 0) {
long d = a % 2;
bitCount[i] += d;
a /= 2;
i++;
}
}
// 0 <= X <= K
long K2 = K;
long kbit = 0;
while (K2 != 0) {
K2 /= 2;
kbit++;
}
long X = 0;
for (long i = kbit; i >= 1; i--) {
long lastBit = 0;
if (bitCount[i] <= N / 2) {
long nextVal = (2 * X + 1) << (i - 1);
if (nextVal <= K) {
lastBit = 1;
}
}
X = 2 * X + lastBit;
}
long fMax = 0;
for (long i = 0; i < N; i++) {
fMax += X ^ an[i];
}
cout << fMax << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 944,538 | 944,539 | u751964641 | cpp |
p03138 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> an;
for (long i = 0; i < N; i++) {
long tmp = 0;
cin >> tmp;
an.push_back(tmp);
}
long bitCount[65] = {};
for (long a : an) {
long i = 1;
while (a != 0) {
long d = a % 2;
bitCount[i] += d;
a /= 2;
i++;
}
}
// 0 <= X <= K
long K2 = K;
long kbit = 0;
while (K2 != 0) {
K2 /= 2;
kbit++;
}
long X = 0;
for (long i = kbit; i >= 1; i--) {
long lastBit = 0;
if (bitCount[i] <= N / 2) {
long nextVal = (2 * X + 1) << (i - 1);
if (nextVal << K) {
lastBit = 1;
}
}
X = 2 * X + lastBit;
}
long fMax = 0;
for (long i = 0; i < N; i++) {
fMax += X ^ an[i];
}
cout << fMax << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long N, K;
cin >> N >> K;
vector<long> an;
for (long i = 0; i < N; i++) {
long tmp = 0;
cin >> tmp;
an.push_back(tmp);
}
long bitCount[65] = {};
for (long a : an) {
long i = 1;
while (a != 0) {
long d = a % 2;
bitCount[i] += d;
a /= 2;
i++;
}
}
// 0 <= X <= K
long K2 = K;
long kbit = 0;
while (K2 != 0) {
K2 /= 2;
kbit++;
}
long X = 0;
for (long i = kbit; i >= 1; i--) {
long lastBit = 0;
if (bitCount[i] <= N / 2) {
long nextVal = (2 * X + 1) << (i - 1);
if (nextVal <= K) {
lastBit = 1;
}
}
X = 2 * X + lastBit;
}
long fMax = 0;
for (long i = 0; i < N; i++) {
fMax += X ^ an[i];
}
cout << fMax << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 944,540 | 944,539 | u751964641 | cpp |
p03138 | #include <iostream>
#include <stdio.h>
#define Re register int
#define LL long long
int N, M, cnt[45][2];
LL K, X, A[100005], ans;
template <typename T> inline void read(T &var) {
T x = 0;
int w = 0;
char ch = 0;
while (!isdigit(ch))
w |= ch == '-', ch = getchar();
while (isdigit(ch))
x = x * 10 + ch - '0', ch = getchar();
var = w ? -x : x;
}
inline int max(int a, int b) { return a > b ? a : b; }
int main(int argc, char const *argv[]) {
// freopen("1.in","r",stdin);
read(N), read(K);
for (Re i = 1; i <= N; ++i)
read(A[i]);
for (Re i = 1; i <= N; ++i)
for (Re j = 40; j >= 0; --j)
++cnt[j][A[i] & (1LL << j) ? 1 : 0];
for (Re i = 40; i >= 0; --i) {
if (K < (1LL << i))
continue;
if (cnt[i][1] < cnt[i][0])
if (X + (1LL << i) < K)
X += (1LL << i);
}
for (Re i = 1; i <= N; ++i)
ans += X ^ A[i];
printf("%lld\n", ans);
return 0;
} | #include <iostream>
#include <stdio.h>
#define Re register int
#define LL long long
int N, M, cnt[45][2];
LL K, X, A[100005], ans;
template <typename T> inline void read(T &var) {
T x = 0;
int w = 0;
char ch = 0;
while (!isdigit(ch))
w |= ch == '-', ch = getchar();
while (isdigit(ch))
x = x * 10 + ch - '0', ch = getchar();
var = w ? -x : x;
}
inline int max(int a, int b) { return a > b ? a : b; }
int main(int argc, char const *argv[]) {
// freopen("1.in","r",stdin);
read(N), read(K);
for (Re i = 1; i <= N; ++i)
read(A[i]);
for (Re i = 1; i <= N; ++i)
for (Re j = 40; j >= 0; --j)
++cnt[j][A[i] & (1LL << j) ? 1 : 0];
for (Re i = 40; i >= 0; --i) {
if (K < (1LL << i))
continue;
if (cnt[i][1] < cnt[i][0])
if (X + (1LL << i) <= K)
X += (1LL << i);
}
for (Re i = 1; i <= N; ++i)
ans += X ^ A[i];
printf("%lld\n", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 944,543 | 944,544 | u394337458 | cpp |
p03138 | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
using usize = unsigned int;
using u64 = unsigned long long;
static constexpr u64 Max = static_cast<u64>(1) << 40;
usize n;
u64 k;
::std::cin >> n >> k;
::std::vector<u64> a(n);
for (auto &e : a)
::std::cin >> e;
u64 x = 0, y = 0;
for (u64 i = 1; i != Max; i <<= 1) {
u64 zero = 0, one = 0;
for (const auto e : a)
e &i ? one : zero += i;
if (k & i)
x = ::std::max(x + zero, y + one);
else
x += one;
y += ::std::max(zero, one);
}
::std::cout << x << ::std::endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
int main() {
using usize = unsigned int;
using u64 = unsigned long long;
static constexpr u64 Max = static_cast<u64>(1) << 40;
usize n;
u64 k;
::std::cin >> n >> k;
::std::vector<u64> a(n);
for (auto &e : a)
::std::cin >> e;
u64 x = 0, y = 0;
for (u64 i = 1; i != Max; i <<= 1) {
u64 zero = 0, one = 0;
for (const auto e : a)
(e & i ? one : zero) += i;
if (k & i)
x = ::std::max(x + zero, y + one);
else
x += one;
y += ::std::max(zero, one);
}
::std::cout << x << ::std::endl;
return 0;
}
| [] | 944,553 | 944,554 | u708618797 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define PI 3.14159265359
int main() {
int N = 100;
vector<int> a(N, 0);
cin >> a[0];
int mini = 10000000;
for (int i = 1; i < N; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
for (int j = 0; j < i; j++) {
if (a[i] == a[j]) {
mini = min(mini, i + 1);
}
}
}
cout << mini;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define PI 3.14159265359
int main() {
int N = 10000;
vector<int> a(N, 0);
cin >> a[0];
int mini = 10000000;
for (int i = 1; i < N; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
for (int j = 0; j < i; j++) {
if (a[i] == a[j]) {
mini = min(mini, i + 1);
}
}
}
cout << mini;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 944,561 | 944,562 | u231455327 | cpp |
p03146 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int f(int m) {
if (m % 2 == 0)
return m / 2;
else
return 3 * m + 1;
}
int main() {
int s, a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000000; i++) {
a[i] = f(a[i - 1]);
bool k = 0;
for (int j = 0; j < i; j++) {
if (a[i] == a[j])
k = 1;
}
if (k == 1) {
cout << i << endl;
break;
}
}
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int f(int m) {
if (m % 2 == 0)
return m / 2;
else
return 3 * m + 1;
}
int main() {
int s, a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000000; i++) {
a[i] = f(a[i - 1]);
bool k = 0;
for (int j = 0; j < i; j++) {
if (a[i] == a[j])
k = 1;
}
if (k == 1) {
cout << i + 1 << endl;
break;
}
}
}
| [
"expression.operation.binary.add"
] | 944,563 | 944,564 | u120050685 | cpp |
p03146 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int f(int m) {
if (m % 2 == 0)
return m / 2;
else
return 3 * m + 1;
}
int main() {
int s, a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000000; i++) {
a[i] = f(a[i - 1]);
bool k = 0;
for (int j = 0; j < i; j++) {
if (a[i] == a[j])
k = 1;
}
if (k == 0) {
cout << i + 1 << endl;
break;
}
}
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int f(int m) {
if (m % 2 == 0)
return m / 2;
else
return 3 * m + 1;
}
int main() {
int s, a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000000; i++) {
a[i] = f(a[i - 1]);
bool k = 0;
for (int j = 0; j < i; j++) {
if (a[i] == a[j])
k = 1;
}
if (k == 1) {
cout << i + 1 << endl;
break;
}
}
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 944,565 | 944,564 | u120050685 | cpp |
p03146 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int f(int m) {
if (m % 2 == 0)
return m / 2;
else
return 3 * m + 1;
}
int main() {
int s, a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000000; i++) {
a[i] = f(a[i - 1]);
bool k = 0;
for (int j = 0; j < i; j++) {
if (a[i] == a[j])
k = 1;
}
if (k == 0) {
cout << i << endl;
break;
}
}
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int f(int m) {
if (m % 2 == 0)
return m / 2;
else
return 3 * m + 1;
}
int main() {
int s, a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000000; i++) {
a[i] = f(a[i - 1]);
bool k = 0;
for (int j = 0; j < i; j++) {
if (a[i] == a[j])
k = 1;
}
if (k == 1) {
cout << i + 1 << endl;
break;
}
}
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 944,566 | 944,564 | u120050685 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int s;
cin >> s;
set<int> st;
int x = s;
int cnt = 0;
while (st.count(x) == 0) {
cnt++;
st.insert(x);
if (x % 2 == 0)
x /= 2;
else
x = 3 * x + 1;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int s;
cin >> s;
set<int> st;
int x = s;
int cnt = 1;
while (st.count(x) == 0) {
cnt++;
st.insert(x);
if (x % 2 == 0)
x /= 2;
else
x = 3 * x + 1;
}
cout << cnt << endl;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 944,569 | 944,570 | u726957641 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int s;
cin >> s;
vector<int> f(1000000);
f.at(0) = s;
rep(i, 1000000) {
if (f.at(i) % 2 == 0)
f.at(i + 1) = f.at(i) / 2;
else
f.at(i + 1) = 3 * f.at(i) + 1;
}
for (int i = 0; i < 1000000 - 1; i++) {
for (int j = i + 1; j < 1000000; j++) {
if (f.at(i) == f.at(j)) {
cout << j + 1 << endl;
return 0;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int s;
cin >> s;
vector<int> f(1000000);
f.at(0) = s;
rep(i, 1000000 - 1) {
if (f.at(i) % 2 == 0)
f.at(i + 1) = f.at(i) / 2;
else
f.at(i + 1) = 3 * f.at(i) + 1;
}
for (int i = 0; i < 1000000 - 1; i++) {
for (int j = i + 1; j < 1000000; j++) {
if (f.at(i) == f.at(j)) {
cout << j + 1 << endl;
return 0;
}
}
}
} | [
"expression.operation.binary.add"
] | 944,571 | 944,572 | u726957641 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A;
cin >> A;
int counter = 0;
if (A == 1 || A == 2) {
cout << 4 << endl;
} else {
while (A != 4) {
if (A % 2 == 0) {
A /= 2;
} else {
A = A * 3 + 1;
}
counter++;
}
}
cout << (counter + 4) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A;
cin >> A;
int counter = 0;
if (A == 1 || A == 2) {
cout << 4 << endl;
} else {
while (A != 4) {
if (A % 2 == 0) {
A /= 2;
} else {
A = A * 3 + 1;
}
counter++;
}
cout << (counter + 4) << endl;
}
} | [] | 944,577 | 944,578 | u325294447 | cpp |
p03146 | #include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
int main(void) {
int s;
cin >> s;
vector<int> a(1000000);
a[0] = s;
for (int i = 1; i < 1000000; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
}
// for (int i = 0; i < 100; i++)
// {
// cout << a[i] << " ";
// }
int i, j;
bool found = false;
int location;
for (i = 1; i < 1000000 - 1; i++) {
for (j = i + 1; j < 1000000; j++) {
if (a[i] == a[j])
found = true;
if (found == true) {
location = j + 1;
break;
}
}
if (found == true) {
break;
}
}
cout << location << endl;
return (0);
} | #include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
int main(void) {
int s;
cin >> s;
vector<int> a(1000000);
a[0] = s;
for (int i = 1; i <= 1000000; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
}
// for (int i = 0; i < 100; i++)
// {
// cout << a[i] << " ";
// }
int i, j;
bool found = false;
int location = 0;
for (i = 0; i < 1000000 - 1; i++) {
for (j = i + 1; j < 1000000; j++) {
if (a[i] == a[j])
found = true;
if (found == true) {
location = j + 1;
break;
}
}
if (found == true) {
break;
}
}
cout << location << endl;
return (0);
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.value.change",
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change"
] | 944,591 | 944,592 | u027946359 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int fff(int a) {
int rt;
if (a % 2 == 1) {
rt = 3 * a + 1;
} else {
rt = a / 2;
}
return rt;
}
int main() {
int s;
cin >> s;
int bb = 0;
vector<int> m(10000, 0);
m.at(0) = s;
for (int i = 1; i < 10001; i++) {
m.at(i) = fff(m.at(i - 1));
for (int j = 0; j < i; j++) {
if (m.at(i) == m.at(j)) {
cout << i << endl;
return 0;
}
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int fff(int a) {
int rt;
if (a % 2 == 1) {
rt = 3 * a + 1;
} else {
rt = a / 2;
}
return rt;
}
int main() {
int s;
cin >> s;
int bb = 0;
vector<int> m(10000, 0);
m.at(0) = s;
for (int i = 1; i < 10001; i++) {
m.at(i) = fff(m.at(i - 1));
for (int j = 0; j < i; j++) {
if (m.at(i) == m.at(j)) {
cout << i + 1 << endl;
return 0;
}
}
}
}
| [
"expression.operation.binary.add"
] | 944,595 | 944,596 | u323864528 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
int count = 0;
while (s > 4 || s == 3) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
count++;
}
cout << count + 3 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
int count = 1;
while (s > 4 || s == 3) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
count++;
}
cout << count + 3 << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 944,599 | 944,600 | u629548179 | cpp |
p03146 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i < n + 1; 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 INF 2e9
#define ALL(v) v.begin(), v.end()
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))
using namespace std;
typedef long long ll;
int f(int n) {
if (n % 2 == 0)
return n / 2;
else
return 3 * n + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int s;
cin >> s;
/* vector<int>a(1000000);
a[0] = s;
int ans;
REP1(i,1000000){
a[i]= f(a[i-1]);
bool flag = true;
REP(j,i){
REP(k,j){
if(a[k]==a[j] ){
flag = false;
ans = j;
cout << ans +1 << endl;
return 0;
}
}
}
}*/
set<int> st;
int ans = 0;
st.insert(s);
while (st.size() == ans) {
if (s % 2 == 0)
s /= 2;
else
s = 3 * s + 1;
st.insert(s);
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i < n + 1; 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 INF 2e9
#define ALL(v) v.begin(), v.end()
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))
using namespace std;
typedef long long ll;
int f(int n) {
if (n % 2 == 0)
return n / 2;
else
return 3 * n + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int s;
cin >> s;
/* vector<int>a(1000000);
a[0] = s;
int ans;
REP1(i,1000000){
a[i]= f(a[i-1]);
bool flag = true;
REP(j,i){
REP(k,j){
if(a[k]==a[j] ){
flag = false;
ans = j;
cout << ans +1 << endl;
return 0;
}
}
}
}*/
set<int> st;
int ans = 1;
st.insert(s);
while (st.size() == ans) {
if (s % 2 == 0)
s /= 2;
else
s = 3 * s + 1;
st.insert(s);
ans++;
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 944,601 | 944,602 | u635381086 | cpp |
p03146 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> a;
a.push_back(s);
for (int i = 1;; i++) {
if (a.at(i - 1) % 2 == 0)
a.push_back(a.at(i - 1) / 2);
else
a.push_back(3 * a.at(i - 1) + 1);
for (int j = 0; j < i; j++) {
if (a.at(j) == a.at(i)) {
cout << i << endl;
return 0;
}
}
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> a;
a.push_back(s);
for (int i = 1;; i++) {
if (a.at(i - 1) % 2 == 0)
a.push_back(a.at(i - 1) / 2);
else
a.push_back(3 * a.at(i - 1) + 1);
for (int j = 0; j < i; j++) {
if (a.at(j) == a.at(i)) {
cout << i + 1 << endl;
return 0;
}
}
}
return 0;
} | [
"expression.operation.binary.add"
] | 944,605 | 944,606 | u660112829 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
set<int> st;
while (st.count(a) != 0) {
st.insert(a);
if (a % 2 == 0)
a /= 2;
else {
a = a * 3 + 1;
}
}
cout << st.size() + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
set<int> st;
while (st.count(a) == 0) {
st.insert(a);
if (a % 2 == 0)
a /= 2;
else {
a = a * 3 + 1;
}
}
cout << st.size() + 1 << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 944,616 | 944,617 | u613960672 | cpp |
p03146 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// pair sort
bool compare_by_b(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
std::uint32_t euclidean_gcd(std::uint32_t a, std::uint32_t b) {
return b != 0 ? euclidean_gcd(b, a % b) : a;
}
void solve(long long s) {
int cnt = 0;
if (s == 1 || s == 2 || s == 4) {
cout << 1 << endl;
return;
}
while (s != 4) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
cnt++;
}
cout << cnt + 4 << endl;
}
int main() {
long long s;
scanf("%lld", &s);
solve(s);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// pair sort
bool compare_by_b(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
std::uint32_t euclidean_gcd(std::uint32_t a, std::uint32_t b) {
return b != 0 ? euclidean_gcd(b, a % b) : a;
}
void solve(long long s) {
int cnt = 0;
if (s == 1 || s == 2 || s == 4) {
cout << 4 << endl;
return;
}
while (s != 4) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
cnt++;
}
cout << cnt + 4 << endl;
}
int main() {
long long s;
scanf("%lld", &s);
solve(s);
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 944,632 | 944,633 | u978109511 | cpp |
p03146 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// pair sort
bool compare_by_b(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
std::uint32_t euclidean_gcd(std::uint32_t a, std::uint32_t b) {
return b != 0 ? euclidean_gcd(b, a % b) : a;
}
void solve(long long s) {
int cnt = 0;
if (s == 1 || s == 2 || s == 4) {
cout << 1 << endl;
}
while (s != 4) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
cnt++;
}
cout << cnt + 4 << endl;
}
int main() {
long long s;
scanf("%lld", &s);
solve(s);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// pair sort
bool compare_by_b(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
std::uint32_t euclidean_gcd(std::uint32_t a, std::uint32_t b) {
return b != 0 ? euclidean_gcd(b, a % b) : a;
}
void solve(long long s) {
int cnt = 0;
if (s == 1 || s == 2 || s == 4) {
cout << 4 << endl;
return;
}
while (s != 4) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
cnt++;
}
cout << cnt + 4 << endl;
}
int main() {
long long s;
scanf("%lld", &s);
solve(s);
return 0;
}
| [
"literal.number.change",
"io.output.change",
"control_flow.return.add"
] | 944,634 | 944,633 | u978109511 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int curr;
cin >> curr;
map<int, int> m;
m[curr] = 1;
int i = 0;
while (true) {
i++;
if (curr & 1)
curr = (3 * curr) + 1;
else
curr *= 2;
m[curr]++;
if (m[curr] == 2)
return cout << i, 0;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int curr;
cin >> curr;
map<int, int> m;
m[curr] = 1;
int i = 1;
while (true) {
i++;
if (curr & 1)
curr = (3 * curr) + 1;
else
curr /= 2;
m[curr]++;
if (m[curr] == 2)
return cout << i, 0;
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.change"
] | 944,671 | 944,672 | u901813121 | cpp |
p03146 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
using namespace std;
void solve() {
int s;
cin >> s;
int i = 1;
vector<int> a;
a.push_back(s);
while (true) {
int tmp;
if (a[i - 1] % 2 == 0) {
tmp = a[i - 1] / 2;
} else {
tmp = 3 * a[i - 1] + 1;
}
auto it = find(a.begin(), a.end(), tmp);
if (it != a.end()) {
cout << tmp + 1 << endl;
break;
} else {
a.push_back(tmp);
i++;
}
}
}
int main() {
solve();
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
using namespace std;
void solve() {
int s;
cin >> s;
int i = 1;
vector<int> a;
a.push_back(s);
// cout << "0: " << s << endl;
while (true) {
int tmp;
if (a[i - 1] % 2 == 0) {
tmp = a[i - 1] / 2;
} else {
tmp = 3 * a[i - 1] + 1;
}
// cout << i << ": " << tmp << endl;
auto it = find(a.begin(), a.end(), tmp);
if (it != a.end()) {
cout << i + 1 << endl;
break;
} else {
a.push_back(tmp);
i++;
}
}
}
int main() {
solve();
return 0;
} | [
"identifier.change",
"io.output.change"
] | 944,681 | 944,682 | u008078348 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define tii tuple<int, int, int>
signed main() {
int S;
cin >> S;
int ans = 1;
bitset<1000> A;
A.set(S);
while (1) {
ans++;
if (S % 2 == 0) {
S /= 2;
} else {
S = 3 * S + 1;
}
if (A.test(S)) {
cout << ans << endl;
break;
}
A.set(S);
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define tii tuple<int, int, int>
signed main() {
int S;
cin >> S;
int ans = 1;
bitset<100000> A;
A.set(S);
while (1) {
ans++;
if (S % 2 == 0) {
S /= 2;
} else {
S = 3 * S + 1;
}
if (A.test(S)) {
cout << ans << endl;
break;
}
A.set(S);
}
} | [
"literal.number.change"
] | 944,691 | 944,692 | u347057617 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define tii tuple<int, int, int>
signed main() {
int S;
cin >> S;
int ans = 1;
bitset<300> A;
A.set(S);
while (1) {
ans++;
if (S % 2 == 0) {
S /= 2;
} else {
S = 3 * S + 1;
}
if (A.test(S)) {
cout << ans << endl;
break;
}
A.set(S);
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define tii tuple<int, int, int>
signed main() {
int S;
cin >> S;
int ans = 1;
bitset<100000> A;
A.set(S);
while (1) {
ans++;
if (S % 2 == 0) {
S /= 2;
} else {
S = 3 * S + 1;
}
if (A.test(S)) {
cout << ans << endl;
break;
}
A.set(S);
}
} | [
"literal.number.change"
] | 944,693 | 944,692 | u347057617 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
vector<int> A(1000000, 0), count(1000001, 0);
A.at(0) = N;
for (int i = 1; i < A.size(); i++) {
count.at(A.at(i - 1))++;
if (count.at(A.at(i - 1)) == 2) {
cout << i - 1 << endl;
return 0;
} else if (A.at(i - 1) % 2 == 0) {
A.at(i) = A.at(i - 1) / 2;
} else {
A.at(i) = 3 * A.at(i - 1) + 1;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
vector<int> A(1000000, 0), count(1000001, 0);
A.at(0) = N;
for (int i = 1; i < A.size(); i++) {
count.at(A.at(i - 1))++;
if (count.at(A.at(i - 1)) == 2) {
cout << i << endl;
return 0;
} else if (A.at(i - 1) % 2 == 0) {
A.at(i) = A.at(i - 1) / 2;
} else {
A.at(i) = 3 * A.at(i - 1) + 1;
}
}
} | [
"expression.operation.binary.remove"
] | 944,694 | 944,695 | u822169805 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
vector<int> A(1000000, 0), count(1000001, 0);
A.at(0) = N;
for (int i = 1; i < A.size(); i++) {
count.at(A.at(i - 1))++;
if (count.at(A.at(i - 1) == 2)) {
cout << i - 1 << endl;
return 0;
} else if (A.at(i - 1) % 2 == 0) {
A.at(i) = A.at(i - 1) / 2;
} else {
A.at(i) = 3 * A.at(i - 1) + 1;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
vector<int> A(1000000, 0), count(1000001, 0);
A.at(0) = N;
for (int i = 1; i < A.size(); i++) {
count.at(A.at(i - 1))++;
if (count.at(A.at(i - 1)) == 2) {
cout << i << endl;
return 0;
} else if (A.at(i - 1) % 2 == 0) {
A.at(i) = A.at(i - 1) / 2;
} else {
A.at(i) = 3 * A.at(i - 1) + 1;
}
}
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 944,696 | 944,695 | u822169805 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
vector<int> A(1000000, 0), count(1000000, 0);
A.at(0) = N;
for (int i = 1; i < A.size(); i++) {
count.at(A.at(i - 1))++;
if (count.at(A.at(i - 1) == 2)) {
cout << i - 1 << endl;
return 0;
} else if (A.at(i - 1) % 2 == 0) {
A.at(i) = A.at(i - 1) / 2;
} else {
A.at(i) = 3 * A.at(i - 1) + 1;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
vector<int> A(1000000, 0), count(1000001, 0);
A.at(0) = N;
for (int i = 1; i < A.size(); i++) {
count.at(A.at(i - 1))++;
if (count.at(A.at(i - 1)) == 2) {
cout << i << endl;
return 0;
} else if (A.at(i - 1) % 2 == 0) {
A.at(i) = A.at(i - 1) / 2;
} else {
A.at(i) = 3 * A.at(i - 1) + 1;
}
}
} | [
"literal.number.change",
"call.arguments.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 944,697 | 944,695 | u822169805 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll INF = 1LL << 60;
const ll MOD = (ll)1e9 + 7;
int main() {
int n;
cin >> n;
map<int, int> m;
m[n] = 1;
for (int i = 2;; i++) {
if (n % 2 == 0)
n /= 2;
else
n = n * 3 + 1;
if (m[n] > 1) {
cout << i << "\n";
return 0;
} else {
m[n] = i;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll INF = 1LL << 60;
const ll MOD = (ll)1e9 + 7;
int main() {
int n;
cin >> n;
map<int, int> m;
m[n] = 1;
for (int i = 2;; i++) {
if (n % 2 == 0)
n /= 2;
else
n = n * 3 + 1;
if (m[n] > 0) {
cout << i << "\n";
return 0;
} else {
m[n] = i;
}
}
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 944,698 | 944,699 | u422029490 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int S;
cin >> S;
int num;
vector<int> a(10000005);
a[0] = S;
int num2;
if (S == 2) {
num = 3;
} else if (S == 1) {
num = 3;
} else {
for (int i = 0; i < 1000005; ++i) {
if (a[i] % 2 == 0) {
a[i + 1] = a[i] / 2;
} else {
a[i + 1] = a[i] * 3 + 1;
}
if (a[i] == 4) {
num = i + 4;
break;
}
}
}
cout << num << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int S;
cin >> S;
int num;
vector<int> a(10000005);
a[0] = S;
int num2;
if (S == 2) {
num = 4;
} else if (S == 1) {
num = 4;
} else {
for (int i = 0; i < 1000005; ++i) {
if (a[i] % 2 == 0) {
a[i + 1] = a[i] / 2;
} else {
a[i + 1] = a[i] * 3 + 1;
}
if (a[i] == 4) {
num = i + 4;
break;
}
}
}
cout << num << endl;
}
| [
"literal.number.change",
"assignment.value.change"
] | 944,706 | 944,707 | u091026689 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout << d << endl;
#define coutd(d) cout << std::setprecision(10) << d << endl;
#define cinline(n) getline(cin, n);
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
template <class T, class C> void chmax(T &a, C b) { a > b ?: a = b; }
template <class T, class C> void chmin(T &a, C b) { a < b ?: a = b; }
const int mod = 1e9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int n, int k) { return c[n][k]; }
bool IsPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
map<ll, ll> primeFact(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n]++;
return res;
}
void printv(vi &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
void printv(vll &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
int vtotal(vi &v) {
int total = 0;
rep(i, v.size()) total += v[i];
return total;
}
int main() {
// init(); // mintๅๆๅ
cin.tie(0);
ios::sync_with_stdio(false);
int s;
cin >> s;
vi v(500, 0);
v[s] = 1;
int ans = 0;
int before = s;
for (int i = 2;; i++) {
int a;
if (before % 2 == 0)
a = before / 2;
else
a = 3 * before + 1;
if (v[a] == 1) {
ans = i;
break;
}
v[a] = 1;
before = a;
}
cout(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout << d << endl;
#define coutd(d) cout << std::setprecision(10) << d << endl;
#define cinline(n) getline(cin, n);
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
template <class T, class C> void chmax(T &a, C b) { a > b ?: a = b; }
template <class T, class C> void chmin(T &a, C b) { a < b ?: a = b; }
const int mod = 1e9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int n, int k) { return c[n][k]; }
bool IsPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
map<ll, ll> primeFact(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n]++;
return res;
}
void printv(vi &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
void printv(vll &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
int vtotal(vi &v) {
int total = 0;
rep(i, v.size()) total += v[i];
return total;
}
int main() {
// init(); // mintๅๆๅ
cin.tie(0);
ios::sync_with_stdio(false);
int s;
cin >> s;
vi v(100000, 0);
v[s] = 1;
int ans = 0;
int before = s;
for (int i = 2;; i++) {
int a;
if (before % 2 == 0)
a = before / 2;
else
a = 3 * before + 1;
if (v[a] == 1) {
ans = i;
break;
}
v[a] = 1;
before = a;
}
cout(ans);
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 944,716 | 944,717 | u530107518 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout << d << endl;
#define coutd(d) cout << std::setprecision(10) << d << endl;
#define cinline(n) getline(cin, n);
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
template <class T, class C> void chmax(T &a, C b) { a > b ?: a = b; }
template <class T, class C> void chmin(T &a, C b) { a < b ?: a = b; }
const int mod = 1e9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int n, int k) { return c[n][k]; }
bool IsPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
map<ll, ll> primeFact(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n]++;
return res;
}
void printv(vi &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
void printv(vll &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
int vtotal(vi &v) {
int total = 0;
rep(i, v.size()) total += v[i];
return total;
}
int main() {
// init(); // mintๅๆๅ
cin.tie(0);
ios::sync_with_stdio(false);
int s;
cin >> s;
vi v(302, 0);
v[s] = 1;
int ans = 0;
int before = s;
for (int i = 2;; i++) {
int a;
if (before % 2 == 0)
a = before / 2;
else
a = 3 * before + 1;
if (v[a] == 1) {
ans = i;
break;
}
v[a] = 1;
before = a;
}
cout(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout << d << endl;
#define coutd(d) cout << std::setprecision(10) << d << endl;
#define cinline(n) getline(cin, n);
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
template <class T, class C> void chmax(T &a, C b) { a > b ?: a = b; }
template <class T, class C> void chmin(T &a, C b) { a < b ?: a = b; }
const int mod = 1e9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int n, int k) { return c[n][k]; }
bool IsPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
map<ll, ll> primeFact(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n]++;
return res;
}
void printv(vi &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
void printv(vll &v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
int vtotal(vi &v) {
int total = 0;
rep(i, v.size()) total += v[i];
return total;
}
int main() {
// init(); // mintๅๆๅ
cin.tie(0);
ios::sync_with_stdio(false);
int s;
cin >> s;
vi v(100000, 0);
v[s] = 1;
int ans = 0;
int before = s;
for (int i = 2;; i++) {
int a;
if (before % 2 == 0)
a = before / 2;
else
a = 3 * before + 1;
if (v[a] == 1) {
ans = i;
break;
}
v[a] = 1;
before = a;
}
cout(ans);
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 944,718 | 944,717 | u530107518 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int s;
cin >> s;
int ans;
int v[100] = {0};
v[s]++;
for (int i = 1;; i++) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
if (v[s] == 0)
v[s]++;
else {
ans = i + 1;
break;
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int s;
cin >> s;
int ans;
int v[1000000] = {0};
v[s]++;
for (int i = 1;; i++) {
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
if (v[s] == 0)
v[s]++;
else {
ans = i + 1;
break;
}
}
cout << ans;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 944,721 | 944,722 | u561143568 | cpp |
p03146 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<ll> sv(101);
unordered_set<ll> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<ll> sv(1000005);
unordered_set<ll> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 944,723 | 944,724 | u620269708 | cpp |
p03146 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<int> sv(101);
unordered_set<int> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<ll> sv(1000005);
unordered_set<ll> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 944,725 | 944,724 | u620269708 | cpp |
p03146 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<int> sv(101);
unordered_set<int> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (int i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<ll> sv(1000005);
unordered_set<ll> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 944,726 | 944,724 | u620269708 | cpp |
p03146 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<int> sv(101);
unordered_set<int> us;
sv[1] = s;
us.emplace(s);
int ans = 0;
for (int i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<ll> sv(1000005);
unordered_set<ll> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 944,727 | 944,724 | u620269708 | cpp |
p03146 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<int> sv(101);
unordered_set<int> us;
sv[1] = s;
us.emplace(s);
int ans = 0;
for (int i = 2; i <= 10000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
int s;
cin >> s;
vector<ll> sv(1000005);
unordered_set<ll> us;
sv[1] = s;
us.emplace(s);
ll ans = 0;
for (ll i = 2; i <= 1000000; ++i) {
if (sv[i - 1] % 2 == 0) {
sv[i] = sv[i - 1] / 2;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
} else {
sv[i] = 3 * sv[i - 1] + 1;
if (us.find(sv[i]) == us.end()) {
us.emplace(sv[i]);
} else {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 944,728 | 944,724 | u620269708 | cpp |
p03146 | #include <bits/stdc++.h>
#include <iostream>
#include <string>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> ss(1000001);
ss[0] = s;
for (int i = 1; i < 1000001; i++) {
if (ss[i - 1] % 2 == 0) {
ss[i] = ss[i - 1] / 2;
} else if (ss[i - 1] % 2 != 0) {
ss[i] = ss[i - 1] * 3 + 1;
}
for (int j = 1; j < i; j++) {
if (ss[i] == ss[j]) {
cout << i + 1 << "\n";
return 0;
}
}
}
}
| #include <bits/stdc++.h>
#include <iostream>
#include <string>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> ss(1000001);
ss[0] = s;
for (int i = 1; i < 1000001; i++) {
if (ss[i - 1] % 2 == 0) {
ss[i] = ss[i - 1] / 2;
} else if (ss[i - 1] % 2 != 0) {
ss[i] = ss[i - 1] * 3 + 1;
}
for (int j = 0; j < i; j++) {
if (ss[i] == ss[j]) {
cout << i + 1 << "\n";
return 0;
}
}
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 944,732 | 944,733 | u904995051 | cpp |
p03146 |
#include <bits/stdc++.h>
#include <iostream>
#include <string>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> ss(1000001);
ss[0] = s;
for (int i = 1; i < 1000001; i++) {
if (ss[i - 1] % 2 == 0) {
ss[i] = ss[i - 1] / 2;
} else if (ss[i - 1] % 2 != 0) {
ss[i] = ss[i - 1] * 3 + 1;
}
for (int j = 1; j < i; j++) {
if (ss[i] == ss[j]) {
cout << i << "\n";
return 0;
}
}
}
} | #include <bits/stdc++.h>
#include <iostream>
#include <string>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> ss(1000001);
ss[0] = s;
for (int i = 1; i < 1000001; i++) {
if (ss[i - 1] % 2 == 0) {
ss[i] = ss[i - 1] / 2;
} else if (ss[i - 1] % 2 != 0) {
ss[i] = ss[i - 1] * 3 + 1;
}
for (int j = 0; j < i; j++) {
if (ss[i] == ss[j]) {
cout << i + 1 << "\n";
return 0;
}
}
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 944,734 | 944,733 | u904995051 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long> x(10000);
x[0] = n;
for (int i = 1; i < 10000; i++) {
if (n % 2 == 0) {
n /= 2;
} else {
n = 3 * n + 1;
}
for (int j = 0; j < i; j++) {
if (n == x[j]) {
cout << i << endl;
return 0;
}
}
x[i] = n;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long> x(10000);
x[0] = n;
for (int i = 1; i < 10000; i++) {
if (n % 2 == 0) {
n /= 2;
} else {
n = 3 * n + 1;
}
for (int j = 0; j < i; j++) {
if (n == x[j]) {
cout << i + 1 << endl;
return 0;
}
}
x[i] = n;
}
}
| [
"expression.operation.binary.add"
] | 944,742 | 944,743 | u503170128 | cpp |
p03146 | #include <bits/stdc++.h>
#define inf 0x3f3f3f3f
#define pb push_back
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ull> vu;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
int s;
void read() { cin >> s; }
bitset<302> bs;
void solve() {
bs[s] = 1;
int cnt = 1;
while (true) {
s = (1 - s % 2) * s / 2 + s % 2 * (3 * s + 1);
++cnt;
if (bs[s]) {
cout << cnt;
return;
} else
bs[s] = 1;
}
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
// cin >> t; //please do not forget to comment this if there are no queries
while (t) {
--t;
read();
solve();
}
return 0;
}
| #include <bits/stdc++.h>
#define inf 0x3f3f3f3f
#define pb push_back
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ull> vu;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
int s;
void read() { cin >> s; }
bitset<1000002> bs;
void solve() {
bs[s] = 1;
int cnt = 1;
while (true) {
s = (1 - s % 2) * s / 2 + (s % 2) * (3 * s + 1);
++cnt;
if (bs[s]) {
cout << cnt;
return;
} else
bs[s] = 1;
}
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
// cin >> t; //please do not forget to comment this if there are no queries
while (t) {
--t;
read();
solve();
}
return 0;
}
| [
"literal.number.change"
] | 944,744 | 944,745 | u519883882 | cpp |
p03146 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int findIndex(vector<int> vec, int value) {
vector<int>::iterator iter = std::find(vec.begin(), vec.end(), value);
size_t index = distance(vec.begin(), iter);
if (index == vec.size()) {
return -1;
}
return index;
}
int main() {
int s;
int a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000001; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
}
vector<int> v;
v.push_back(s);
int ans = 1;
for (int i = 1; i < 1000001; i++) {
if (findIndex(v, a[i]) > 0) {
ans = i + 1;
break;
}
v.push_back(a[i]);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int findIndex(vector<int> vec, int value) {
vector<int>::iterator iter = std::find(vec.begin(), vec.end(), value);
size_t index = distance(vec.begin(), iter);
if (index == vec.size()) {
return -1;
}
return index;
}
int main() {
int s;
int a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000001; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
}
vector<int> v;
v.push_back(s);
int ans = 0;
for (int i = 1; i < 1000001; i++) {
if (findIndex(v, a[i]) >= 0) {
ans = i + 1;
break;
} else {
v.push_back(a[i]);
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else.add"
] | 944,758 | 944,759 | u900267897 | cpp |
p03146 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int findIndex(vector<int> vec, int value) {
vector<int>::iterator iter = std::find(vec.begin(), vec.end(), value);
size_t index = distance(vec.begin(), iter);
if (index == vec.size()) {
return -1;
}
return index;
}
int main() {
int s;
int a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000001; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
}
vector<int> v;
v.push_back(s);
int ans = 0;
for (int i = 1; i < 1000001; i++) {
if (findIndex(v, a[i]) > 0) {
ans = i + 1;
break;
}
v.push_back(a[i]);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int findIndex(vector<int> vec, int value) {
vector<int>::iterator iter = std::find(vec.begin(), vec.end(), value);
size_t index = distance(vec.begin(), iter);
if (index == vec.size()) {
return -1;
}
return index;
}
int main() {
int s;
int a[1000000];
cin >> s;
a[0] = s;
for (int i = 1; i < 1000001; i++) {
if (a[i - 1] % 2 == 0) {
a[i] = a[i - 1] / 2;
} else {
a[i] = 3 * a[i - 1] + 1;
}
}
vector<int> v;
v.push_back(s);
int ans = 0;
for (int i = 1; i < 1000001; i++) {
if (findIndex(v, a[i]) >= 0) {
ans = i + 1;
break;
} else {
v.push_back(a[i]);
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else.add"
] | 944,760 | 944,759 | u900267897 | cpp |
p03146 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
long long int __lcm(long long int a, long long int b) {
long long int n;
n = a * b / __gcd(a, b);
return n;
}
//__gcd ๆๅคงๅ
ฌ็ดๆฐ
//__lcm ๆๅฐๅ
ฌๅๆฐ
int main() {
int a;
cin >> a;
if (a == 1)
cout << 3;
else if (a == 2)
cout << 3;
else {
for (int i = 0; i < 100000; i++) {
if (a == 4) {
cout << i + 4;
break;
} else if (a % 2 == 0)
a = a / 2;
else
a = 3 * a + 1;
}
}
} | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
long long int __lcm(long long int a, long long int b) {
long long int n;
n = a * b / __gcd(a, b);
return n;
}
//__gcd ๆๅคงๅ
ฌ็ดๆฐ
//__lcm ๆๅฐๅ
ฌๅๆฐ
int main() {
int a;
cin >> a;
if (a == 1)
cout << 4;
else if (a == 2)
cout << 4;
else {
for (int i = 0; i < 100000; i++) {
if (a == 4) {
cout << i + 4;
break;
} else if (a % 2 == 0)
a = a / 2;
else
a = 3 * a + 1;
}
}
} | [
"literal.number.change",
"io.output.change"
] | 944,773 | 944,774 | u191594139 | cpp |
p03146 | #include <iostream>
using namespace std;
int main() {
int s;
cin >> s;
int a = s, ans = 1;
int h[1000000] = {};
while (h[a] == 0) {
h[a] = 1;
if (a % 2 != 0) {
a = a * 3 + 1;
} else {
a = a / 2;
}
ans++;
}
cout << ans + 1 << endl;
}
| #include <iostream>
using namespace std;
int main() {
int s;
cin >> s;
int a = s, ans = 1;
int h[1000000] = {};
while (h[a] == 0) {
h[a] = 1;
if (a % 2 != 0) {
a = a * 3 + 1;
} else {
a = a / 2;
}
ans++;
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 944,779 | 944,780 | u930705402 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int s, num;
cin >> s;
vector<int> a(101);
int tmp = s;
a[tmp]++;
for (int i = 1;; i++) {
if (tmp % 2 == 0)
tmp /= 2;
else
tmp = 3 * tmp + 1;
a[tmp]++;
if (a[tmp] == 2) {
cout << i + 1;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int s, num;
cin >> s;
vector<int> a(1000001);
int tmp = s;
a[tmp]++;
for (int i = 1;; i++) {
if (tmp % 2 == 0)
tmp /= 2;
else
tmp = 3 * tmp + 1;
a[tmp]++;
if (a[tmp] == 2) {
cout << i + 1;
return 0;
}
}
} | [
"literal.number.change",
"call.arguments.change"
] | 944,781 | 944,782 | u710135612 | cpp |
p03146 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int S;
long ANS;
vector<int> A;
cin >> S;
A.push_back(S);
for (long i = 1;; i++) {
if (A[i - 1] % 2 == 0) {
A.push_back(A[i - 1] / 2);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i;
break;
}
}
if (A[i - 1] % 2 == 1) {
A.push_back(3 * A[i - 1] + 1);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i + 1;
break;
}
}
}
cout << ANS << endl;
} | #include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int S;
long ANS;
vector<int> A;
cin >> S;
A.push_back(S);
for (long i = 1;; i++) {
if (A[i - 1] % 2 == 0) {
A.push_back(A[i - 1] / 2);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i + 1;
break;
}
}
if (A[i - 1] % 2 == 1) {
A.push_back(3 * A[i - 1] + 1);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i + 1;
break;
}
}
}
cout << ANS << endl;
} | [
"assignment.change"
] | 944,783 | 944,784 | u230139835 | cpp |
p03146 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int S, ANS;
vector<int> A;
cin >> S;
A.push_back(S);
for (long i = 1;; i++) {
if (A[i - 1] % 2 == 0) {
A.push_back(A[i - 1] / 2);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i;
break;
}
}
if (A[i - 1] % 2 == 1) {
A.push_back(3 * A[i - 1] + 1);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i + 1;
break;
}
}
}
cout << ANS << endl;
} | #include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int S;
long ANS;
vector<int> A;
cin >> S;
A.push_back(S);
for (long i = 1;; i++) {
if (A[i - 1] % 2 == 0) {
A.push_back(A[i - 1] / 2);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i + 1;
break;
}
}
if (A[i - 1] % 2 == 1) {
A.push_back(3 * A[i - 1] + 1);
size_t Acount = count(A.begin(), A.end(), A[i]);
if (Acount == 2) {
ANS = i + 1;
break;
}
}
}
cout << ANS << endl;
} | [
"variable_declaration.type.widen.change",
"assignment.change"
] | 944,785 | 944,784 | u230139835 | cpp |
p03146 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
auto &errStream = cerr;
#ifdef LOCAL
#define cerr (cerr << "-- line " << __LINE__ << " -- ")
#else
class CerrDummy {
} cerrDummy;
template <class T> CerrDummy &operator<<(CerrDummy &cd, const T &) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy &operator<<(CerrDummy &cd,
basic_ostream<charTDummy, traitsDummy> &(
basic_ostream<charTDummy, traitsDummy> &)) {
return cd;
}
#define cerr cerrDummy
#endif
#define REACH cerr << "reached" << endl
#define DMP(x) cerr << #x << ":" << x << endl
#define ZERO(x) memset(x, 0, sizeof(x))
#define ONE(x) memset(x, -1, sizeof(x))
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("ยฅn"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
#define CAPITAL
void Yes(bool ex = true) {
#ifdef CAPITAL
cout << "YES" << endl;
#else
cout << "Yes" << endl;
#endif
if (ex)
exit(0);
}
void No(bool ex = true) {
#ifdef CAPITAL
cout << "NO" << endl;
#else
cout << "No" << endl;
#endif
if (ex)
exit(0);
}
const ll infLL = LLONG_MAX / 3;
#ifdef int
const int inf = infLL;
#else
const int inf = INT_MAX / 2 - 100;
#endif
signed main() {
int s = read();
vi a;
a.PB(s);
REP(i, s) {
if (a[i] % 2 == 0)
a.PB(a[i] / 2);
else
a.PB((a[i] * 3) + 1);
FOR(j, 0, a.size() - 2) {
if (a[j] == a[i + 1]) {
print(i + 2, 0);
return 0;
}
}
}
}
| #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
auto &errStream = cerr;
#ifdef LOCAL
#define cerr (cerr << "-- line " << __LINE__ << " -- ")
#else
class CerrDummy {
} cerrDummy;
template <class T> CerrDummy &operator<<(CerrDummy &cd, const T &) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy &operator<<(CerrDummy &cd,
basic_ostream<charTDummy, traitsDummy> &(
basic_ostream<charTDummy, traitsDummy> &)) {
return cd;
}
#define cerr cerrDummy
#endif
#define REACH cerr << "reached" << endl
#define DMP(x) cerr << #x << ":" << x << endl
#define ZERO(x) memset(x, 0, sizeof(x))
#define ONE(x) memset(x, -1, sizeof(x))
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("ยฅn"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
#define CAPITAL
void Yes(bool ex = true) {
#ifdef CAPITAL
cout << "YES" << endl;
#else
cout << "Yes" << endl;
#endif
if (ex)
exit(0);
}
void No(bool ex = true) {
#ifdef CAPITAL
cout << "NO" << endl;
#else
cout << "No" << endl;
#endif
if (ex)
exit(0);
}
const ll infLL = LLONG_MAX / 3;
#ifdef int
const int inf = infLL;
#else
const int inf = INT_MAX / 2 - 100;
#endif
signed main() {
int s = read();
vi a;
a.PB(s);
REP(i, 1000000) {
if (a[i] % 2 == 0)
a.PB(a[i] / 2);
else
a.PB((a[i] * 3) + 1);
FOR(j, 0, a.size() - 2) {
if (a[j] == a[i + 1]) {
print(i + 2, 0);
return 0;
}
}
}
}
| [] | 944,790 | 944,791 | u700484101 | cpp |
p03146 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
auto &errStream = cerr;
#ifdef LOCAL
#define cerr (cerr << "-- line " << __LINE__ << " -- ")
#else
class CerrDummy {
} cerrDummy;
template <class T> CerrDummy &operator<<(CerrDummy &cd, const T &) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy &operator<<(CerrDummy &cd,
basic_ostream<charTDummy, traitsDummy> &(
basic_ostream<charTDummy, traitsDummy> &)) {
return cd;
}
#define cerr cerrDummy
#endif
#define REACH cerr << "reached" << endl
#define DMP(x) cerr << #x << ":" << x << endl
#define ZERO(x) memset(x, 0, sizeof(x))
#define ONE(x) memset(x, -1, sizeof(x))
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("ยฅn"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
#define CAPITAL
void Yes(bool ex = true) {
#ifdef CAPITAL
cout << "YES" << endl;
#else
cout << "Yes" << endl;
#endif
if (ex)
exit(0);
}
void No(bool ex = true) {
#ifdef CAPITAL
cout << "NO" << endl;
#else
cout << "No" << endl;
#endif
if (ex)
exit(0);
}
const ll infLL = LLONG_MAX / 3;
#ifdef int
const int inf = infLL;
#else
const int inf = INT_MAX / 2 - 100;
#endif
signed main() {
int s = read();
vi a;
a.PB(s);
REP(i, s) {
if (a[i] % 2 == 0)
a.PB(a[i] / 2);
else
a.PB((a[i] * 3) + 1);
FOR(j, 0, a.size() - 2) {
if (a[j] == a[i + 1]) {
print(i + 2);
return 0;
}
}
}
}
| #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
auto &errStream = cerr;
#ifdef LOCAL
#define cerr (cerr << "-- line " << __LINE__ << " -- ")
#else
class CerrDummy {
} cerrDummy;
template <class T> CerrDummy &operator<<(CerrDummy &cd, const T &) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy &operator<<(CerrDummy &cd,
basic_ostream<charTDummy, traitsDummy> &(
basic_ostream<charTDummy, traitsDummy> &)) {
return cd;
}
#define cerr cerrDummy
#endif
#define REACH cerr << "reached" << endl
#define DMP(x) cerr << #x << ":" << x << endl
#define ZERO(x) memset(x, 0, sizeof(x))
#define ONE(x) memset(x, -1, sizeof(x))
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("ยฅn"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
#define CAPITAL
void Yes(bool ex = true) {
#ifdef CAPITAL
cout << "YES" << endl;
#else
cout << "Yes" << endl;
#endif
if (ex)
exit(0);
}
void No(bool ex = true) {
#ifdef CAPITAL
cout << "NO" << endl;
#else
cout << "No" << endl;
#endif
if (ex)
exit(0);
}
const ll infLL = LLONG_MAX / 3;
#ifdef int
const int inf = infLL;
#else
const int inf = INT_MAX / 2 - 100;
#endif
signed main() {
int s = read();
vi a;
a.PB(s);
REP(i, 1000000) {
if (a[i] % 2 == 0)
a.PB(a[i] / 2);
else
a.PB((a[i] * 3) + 1);
FOR(j, 0, a.size() - 2) {
if (a[j] == a[i + 1]) {
print(i + 2, 0);
return 0;
}
}
}
}
| [
"call.arguments.add"
] | 944,792 | 944,791 | u700484101 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
int s, f, n;
vector<int> a;
cin >> s;
a.push_back(s);
for (int i = 0; i < 100; i++) {
if (a[i] % 2 == 0) {
f = a[i] / 2;
} else {
f = 3 * a[i] + 1;
}
a.push_back(f);
for (int j = 0; j < i + 1; j++) {
if (a[j] == a[i + 1]) {
cout << i + 2;
return 0;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
int s, f, n;
vector<int> a;
cin >> s;
a.push_back(s);
for (int i = 0; i < 1000; i++) {
if (a[i] % 2 == 0) {
f = a[i] / 2;
} else {
f = 3 * a[i] + 1;
}
a.push_back(f);
for (int j = 0; j < i + 1; j++) {
if (a[j] == a[i + 1]) {
cout << i + 2;
return 0;
}
}
}
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 944,795 | 944,796 | u591779169 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> a = {s};
while (true) {
int ai;
if (a.back() % 2 == 0) {
ai = a.back() / 2;
} else {
ai = a.back() * 3 + 1;
}
for (int i = 0; i < a.size(); i++) {
if (a.at(i) == ai) {
cout << a.size() << endl;
return 0;
}
}
a.push_back(ai);
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> a = {s};
while (true) {
int ai;
if (a.back() % 2 == 0) {
ai = a.back() / 2;
} else {
ai = a.back() * 3 + 1;
}
for (int i = 0; i < a.size(); i++) {
if (a.at(i) == ai) {
cout << a.size() + 1 << endl;
return 0;
}
}
a.push_back(ai);
}
} | [
"expression.operation.binary.add"
] | 944,811 | 944,812 | u732546570 | cpp |
p03146 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main() {
int s;
cin >> s;
int ans;
if (s == 1 || s == 2 || s == 4)
ans = 4;
else {
int cnt = 0;
int tmp = s;
while (tmp != 4) {
if (tmp & 1) {
tmp = tmp * 3 + 1;
cnt++;
} else {
tmp /= 2;
cnt++;
}
}
ans = cnt + 3;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main() {
int s;
cin >> s;
int ans;
if (s == 1 || s == 2 || s == 4)
ans = 4;
else {
int cnt = 0;
int tmp = s;
while (tmp != 4) {
if (tmp & 1) {
tmp = tmp * 3 + 1;
cnt++;
} else {
tmp /= 2;
cnt++;
}
}
ans = cnt + 4;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 944,822 | 944,823 | u506858457 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int s, ans = 1;
cin >> s;
while (!(s == 1 || s == 2 || s == 4)) {
if (s % 2 == 0) {
s /= 2;
} else {
s = s * 3 + 1;
}
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int s, ans = 1;
cin >> s;
while (!(s == 1 || s == 2 || s == 4)) {
if (s % 2 == 0) {
s /= 2;
} else {
s = s * 3 + 1;
}
ans++;
}
cout << ans + 3 << endl;
} | [
"expression.operation.binary.add"
] | 944,824 | 944,825 | u028572059 | cpp |
p03146 | #include <iostream>
#include <vector>
using namespace std;
int F(int n) {
if (n % 2) {
return n / 2;
} else {
return n * 3 + 1;
}
}
int main() {
int s;
cin >> s;
vector<int> vct;
vct.push_back(s);
int i = 1;
while (true) {
vct.push_back(F(vct[i - 1]));
for (int checkI = 0; checkI < i; ++checkI) {
if (vct[checkI] == vct[i]) {
goto outWhile;
}
}
++i;
}
outWhile:
cout << i + 1 << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int F(int n) {
if (n % 2 == 0) {
return n / 2;
} else {
return n * 3 + 1;
}
}
int main() {
int s;
cin >> s;
vector<int> vct;
vct.push_back(s);
int i = 1;
while (true) {
vct.push_back(F(vct[i - 1]));
for (int checkI = 0; checkI < i; ++checkI) {
if (vct[checkI] == vct[i]) {
goto outWhile;
}
}
++i;
}
outWhile:
cout << i + 1 << endl;
} | [
"control_flow.branch.if.condition.change"
] | 944,832 | 944,833 | u460401508 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define co(a) cout << a << endl
#define sz size()
#define bgn begin()
#define en end()
#define pb(a) push_back(a)
#define pp() pop_back()
#define V vector
#define P pair
#define V2(a, b, c) V<V<int>> a(b, V<int>(c))
#define V2a(a, b, c, d) V<V<int>> a(b, V<int>(c, d))
#define incin(a) \
int a; \
cin >> a
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
//#define min min<int>
//#define max max<int>
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
/*template<>
void cou(vector<vector<char>> a){
int b=a.size();
int c=a[0].size();
fo(i,b){
fo(j,c){
cout<<a[i][j];
if(j==c-1)
cout<<endl;
else
cout<<' ';
}
}
}*/
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
/*int lcm(int a,int b){
int d=a,e=b,f;
if(a<b)
swap(a,b);
int c,m=1;
while(m){
c=a%b;
if(c==0){
f=b;
m--;
}
else{
a=b;
b=c;
}
}
return d*e/f;
}
int gcm(int a,int b){
int d=a,e=b,f;
if(a<b)
swap(a,b);
int c,m=1;
while(m){
c=a%b;
if(c==0){
f=b;
m--;
}
else{
a=b;
b=c;
}
}
return f;
}*/
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double b = sqrt(a);
for (int i = 3; i <= b; i += 2) {
if (a % i == 0) {
return false;
}
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
int gcm(int a, int b) {
if (b == 0)
return a;
return gcm(b, a % b);
}
int lcm(int a, int b) { return a / gcm(a, b) * b; }
/*struct aa{
vector<int> gt;
aa(int n){
gt= vector<int>(n, 1);
}
void c(V<int> d,int b){
if(d[b]==0){
gt[d[b]-1]++;
gt[gt.sz-1]++;
}
else{
gt[d[b]-1]++;
c(d,d[d[b]]-1);
}
}
void cok(int a){
cout<<gt[a-1]<<endl;
fo(i,a-1)
cout<<gt[i]<<endl;
}
};
*/
/*struct dfs(){
}*/
signed main() {
int a;
cin >> a;
int b, c, d, e;
b = 0;
c = 0;
d = 0;
for (int i = 0; 1; i++) {
if ((a == 1 && b) || (a == 2 && c) || (a == 4 && d)) {
e = i;
break;
}
if (a == 1)
b = 1;
if (a == 2)
c = 1;
if (a == 4)
d = 1;
if (a % 2 == 0)
a /= 2;
else
a = a * 3 + 1;
}
cout << e << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define co(a) cout << a << endl
#define sz size()
#define bgn begin()
#define en end()
#define pb(a) push_back(a)
#define pp() pop_back()
#define V vector
#define P pair
#define V2(a, b, c) V<V<int>> a(b, V<int>(c))
#define V2a(a, b, c, d) V<V<int>> a(b, V<int>(c, d))
#define incin(a) \
int a; \
cin >> a
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
//#define min min<int>
//#define max max<int>
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
/*template<>
void cou(vector<vector<char>> a){
int b=a.size();
int c=a[0].size();
fo(i,b){
fo(j,c){
cout<<a[i][j];
if(j==c-1)
cout<<endl;
else
cout<<' ';
}
}
}*/
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
/*int lcm(int a,int b){
int d=a,e=b,f;
if(a<b)
swap(a,b);
int c,m=1;
while(m){
c=a%b;
if(c==0){
f=b;
m--;
}
else{
a=b;
b=c;
}
}
return d*e/f;
}
int gcm(int a,int b){
int d=a,e=b,f;
if(a<b)
swap(a,b);
int c,m=1;
while(m){
c=a%b;
if(c==0){
f=b;
m--;
}
else{
a=b;
b=c;
}
}
return f;
}*/
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double b = sqrt(a);
for (int i = 3; i <= b; i += 2) {
if (a % i == 0) {
return false;
}
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
int gcm(int a, int b) {
if (b == 0)
return a;
return gcm(b, a % b);
}
int lcm(int a, int b) { return a / gcm(a, b) * b; }
/*struct aa{
vector<int> gt;
aa(int n){
gt= vector<int>(n, 1);
}
void c(V<int> d,int b){
if(d[b]==0){
gt[d[b]-1]++;
gt[gt.sz-1]++;
}
else{
gt[d[b]-1]++;
c(d,d[d[b]]-1);
}
}
void cok(int a){
cout<<gt[a-1]<<endl;
fo(i,a-1)
cout<<gt[i]<<endl;
}
};
*/
/*struct dfs(){
}*/
signed main() {
int a;
cin >> a;
int b, c, d, e;
b = 0;
c = 0;
d = 0;
for (int i = 1; 1; i++) {
if ((a == 1 && b) || (a == 2 && c) || (a == 4 && d)) {
e = i;
break;
}
if (a == 1)
b = 1;
if (a == 2)
c = 1;
if (a == 4)
d = 1;
if (a % 2 == 0)
a /= 2;
else
a = a * 3 + 1;
}
cout << e << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 944,837 | 944,838 | u322177979 | cpp |
p03146 | #include <bits/stdc++.h>
#define mod 1000000007
#define rep(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
int main(void) {
int a[100000];
cin >> a[0];
rep(i, 100000) {
if (a[i - 1] % 2 == 0)
a[i] = a[i - 1] / 2;
else
a[i] = 3 * a[i - 1] + 1;
for (int j = 0; j < i; j++) {
if (a[j] == a[i]) {
cout << i;
return 0;
}
}
}
} | #include <bits/stdc++.h>
#define mod 1000000007
#define rep(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
int main(void) {
int a[100000];
cin >> a[0];
rep(i, 100000) {
if (a[i - 1] % 2 == 0)
a[i] = a[i - 1] / 2;
else
a[i] = 3 * a[i - 1] + 1;
for (int j = 0; j < i; j++) {
if (a[j] == a[i]) {
cout << i + 1;
return 0;
}
}
}
} | [
"expression.operation.binary.add"
] | 944,877 | 944,878 | u895536055 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000000];
cin >> a[0];
int s;
for (int i = 0; i < 1000000; ++i) {
if (a[i] % 2 == 0)
a[i + 1] = a[i] / 2;
else
a[i + 1] = 3 * a[i] + 1;
bool b = 0;
for (int j = 0; j < i; ++j) {
if (a[j] == a[i + 1]) {
s = i + 2;
break;
}
}
if (b)
break;
}
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000000];
cin >> a[0];
int s;
for (int i = 0; i < 1000000; ++i) {
if (a[i] % 2 == 0)
a[i + 1] = a[i] / 2;
else
a[i + 1] = 3 * a[i] + 1;
bool b = 0;
for (int j = 0; j < i; ++j) {
if (a[j] == a[i + 1]) {
s = i + 2;
b = 1;
break;
}
}
if (b)
break;
}
cout << s << endl;
}
| [
"assignment.add"
] | 944,879 | 944,880 | u757584836 | cpp |
p03146 | #include <iostream>
using namespace std;
int main() {
int a[100000], i, j;
cin >> a[0];
for (i = 0;; i++) {
if (a[i] % 2 == 0)
a[i + 1] = a[i] / 2;
else
a[i + 1] = 3 * a[i] + 1;
for (j = 0; j < i + 1; j++) {
if (a[i + 1] == a[j]) {
cout << i + 1;
return 0;
}
}
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a[100000], i, j;
cin >> a[0];
for (i = 0;; i++) {
if (a[i] % 2 == 0)
a[i + 1] = a[i] / 2;
else
a[i + 1] = 3 * a[i] + 1;
for (j = 0; j < i + 1; j++) {
if (a[i + 1] == a[j]) {
cout << i + 2;
return 0;
}
}
}
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 944,902 | 944,903 | u340494803 | cpp |
p03146 | #include <iostream>
using namespace std;
int main() {
int a[100000], i, j;
cin >> a[0];
for (i = 0;; i++) {
if (a[i] % 2 == 0)
a[i + 1] = a[i] / 2;
else
a[i + 1] = 3 * a[i] + 1;
for (j = 0; j < i + 1; j++) {
if (a[i + 1] == a[j]) {
cout << i + 1;
break;
}
}
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a[100000], i, j;
cin >> a[0];
for (i = 0;; i++) {
if (a[i] % 2 == 0)
a[i + 1] = a[i] / 2;
else
a[i + 1] = 3 * a[i] + 1;
for (j = 0; j < i + 1; j++) {
if (a[i + 1] == a[j]) {
cout << i + 2;
return 0;
}
}
}
return 0;
}
| [
"literal.number.change",
"io.output.change",
"control_flow.break.remove",
"control_flow.return.add",
"control_flow.return.0.add"
] | 944,904 | 944,903 | u340494803 | cpp |
p03146 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main(int argc, char *argv[]) {
long long S;
int cnt = 1;
int flg1 = 2;
int flg2 = 2;
int flg4 = 2;
cin >> S;
do {
if (S == 4) {
flg4--;
}
if (S == 2) {
flg2--;
}
if (S == 1) {
flg1--;
}
if (S % 2 == 0) {
S /= 2;
} else {
S = 3 * S + 1;
}
cnt++;
} while (flg1 > 0 && flg2 > 0 && flg4 > 0);
cout << cnt << endl;
return 0;
} |
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main(int argc, char *argv[]) {
long long S;
int cnt = 0;
int flg1 = 2;
int flg2 = 2;
int flg4 = 2;
cin >> S;
do {
if (S == 4) {
flg4--;
}
if (S == 2) {
flg2--;
}
if (S == 1) {
flg1--;
}
if (S % 2 == 0) {
S /= 2;
} else {
S = 3 * S + 1;
}
cnt++;
} while (flg1 > 0 && flg2 > 0 && flg4 > 0);
cout << cnt << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 944,915 | 944,916 | u335104842 | cpp |
p03146 | #include <bits/stdc++.h>
#define FI first
#define SE second
#define EPS 1e-9
#define ALL(a) a.begin(), a.end()
#define SZ(a) int((a).size())
#define MS(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORE(i, a, b) for (int i = (a); i >= (b); i--)
#define FORALL(it, a) \
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define WHATIS(x) cout << #x << " is " << x << endl;
#define ERROR(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
//__builtin_ffs(x) return 1 + index of least significant 1-bit of x
//__builtin_clz(x) return number of leading zeros of x
//__builtin_ctz(x) return number of trailing zeros of x
using namespace std;
using ll = long long;
using ld = double;
typedef pair<int, int> II;
typedef pair<ll, II> III;
typedef complex<ld> cd;
typedef vector<cd> vcd;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const ll MODBASE = 1000000007LL;
const int MAXN = 100010;
const int MAXM = 100010;
const int MAXK = 510;
int n;
set<int> s;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n;
s.insert(n);
int cnt = 1;
while (1) {
cnt++;
int p = 0;
if (n % 2 == 0)
p = n / 2;
else
p = 3 * p + 1;
if (s.count(p)) {
cout << cnt;
return 0;
}
s.insert(p);
n = p;
}
return 0;
} | #include <bits/stdc++.h>
#define FI first
#define SE second
#define EPS 1e-9
#define ALL(a) a.begin(), a.end()
#define SZ(a) int((a).size())
#define MS(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORE(i, a, b) for (int i = (a); i >= (b); i--)
#define FORALL(it, a) \
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define WHATIS(x) cout << #x << " is " << x << endl;
#define ERROR(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
//__builtin_ffs(x) return 1 + index of least significant 1-bit of x
//__builtin_clz(x) return number of leading zeros of x
//__builtin_ctz(x) return number of trailing zeros of x
using namespace std;
using ll = long long;
using ld = double;
typedef pair<int, int> II;
typedef pair<ll, II> III;
typedef complex<ld> cd;
typedef vector<cd> vcd;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const ll MODBASE = 1000000007LL;
const int MAXN = 100010;
const int MAXM = 100010;
const int MAXK = 510;
int n;
set<int> s;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n;
s.insert(n);
int cnt = 1;
while (1) {
cnt++;
int p = 0;
if (n % 2 == 0)
p = n / 2;
else
p = 3 * n + 1;
if (s.count(p)) {
cout << cnt;
return 0;
}
s.insert(p);
n = p;
}
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 944,917 | 944,918 | u131020584 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
// input
int s, i = 0;
cin >> s;
while (s > 4) {
if (s % 2 == 0)
s /= 2;
else
s = 3 * s + 1;
i++;
}
cout << i + 4 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
// input
int s, i = 0;
cin >> s;
while (s > 4 || s == 3) {
if (s % 2 == 0)
s /= 2;
else
s = 3 * s + 1;
i++;
}
cout << i + 4 << endl;
}
| [
"control_flow.loop.condition.change"
] | 944,919 | 944,920 | u371149954 | cpp |
p03146 | #include <iostream>
using namespace std;
int main(void) {
long long s, ans = 0;
cin >> s;
if (s <= 4)
cout << "4494"[s] << endl;
else {
while (s > 1) {
ans++;
if (s & 1) {
s *= 3;
s++;
} else {
s >>= 1;
}
}
cout << ans + 2 << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
long long s, ans = 0;
cin >> s;
if (s <= 4)
cout << "04494"[s] << endl;
else {
while (s > 1) {
ans++;
if (s & 1) {
s *= 3;
s++;
} else {
s >>= 1;
}
}
cout << ans + 2 << endl;
}
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 944,925 | 944,926 | u898331860 | cpp |
p03146 | #include <iostream>
using namespace std;
int main(void) {
long long s, ans = 0;
cin >> s;
if (s <= 4)
cout << "4494"[s] << endl;
else {
while (s > 1) {
ans++;
if (s & 1) {
s *= 3;
s++;
} else {
s >>= 1;
}
}
cout << ans + 1 << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
long long s, ans = 0;
cin >> s;
if (s <= 4)
cout << "04494"[s] << endl;
else {
while (s > 1) {
ans++;
if (s & 1) {
s *= 3;
s++;
} else {
s >>= 1;
}
}
cout << ans + 2 << endl;
}
return 0;
}
| [
"literal.string.change",
"io.output.change",
"literal.number.change"
] | 944,927 | 944,926 | u898331860 | cpp |
p03146 | #include <iostream>
using namespace std;
int main(void) {
long long s, ans = 0;
cin >> s;
if (s <= 4)
cout << "4494"[s] << endl;
else {
while (s > 4) {
ans++;
if (s & 1) {
s *= 3;
s++;
} else {
s >>= 1;
}
}
cout << ans + 4 << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
long long s, ans = 0;
cin >> s;
if (s <= 4)
cout << "04494"[s] << endl;
else {
while (s > 1) {
ans++;
if (s & 1) {
s *= 3;
s++;
} else {
s >>= 1;
}
}
cout << ans + 2 << endl;
}
return 0;
}
| [
"literal.string.change",
"io.output.change",
"literal.number.change",
"control_flow.loop.condition.change"
] | 944,928 | 944,926 | u898331860 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int N = 100010;
int main() {
int s;
cin >> s;
vector<int> v(N);
v[0] = s;
for (int i = 1; i <= N; i++) {
if (v[i - 1] & 1)
v[i] = 3 * v[i - 1] + 1;
else
v[i] = v[i - 1] / 2;
}
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++)
if (v[j] == v[i])
return cout << (j + 1) << endl, 0;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int N = 1000010;
int main() {
int s;
cin >> s;
vector<int> v(N);
v[0] = s;
for (int i = 1; i <= N; i++) {
if (v[i - 1] & 1)
v[i] = 3 * v[i - 1] + 1;
else
v[i] = v[i - 1] / 2;
}
for (int i = 0; i <= N; i++)
for (int j = i + 1; j <= N; j++)
if (v[j] == v[i])
return cout << (j + 1) << endl, 0;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 944,929 | 944,930 | u459121100 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int N = 1000010;
int main() {
int s;
cin >> s;
vector<int> v(N);
v[0] = s;
for (int i = 1; i <= N; i++) {
if (v[i - 1] & 1)
v[i] = 3 * v[i - 1] + 1;
else
v[i] = v[i - 1] / 2;
}
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++)
if (v[j] == v[i])
return cout << (j + 1) << endl, 0;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int N = 1000010;
int main() {
int s;
cin >> s;
vector<int> v(N);
v[0] = s;
for (int i = 1; i <= N; i++) {
if (v[i - 1] & 1)
v[i] = 3 * v[i - 1] + 1;
else
v[i] = v[i - 1] / 2;
}
for (int i = 0; i <= N; i++)
for (int j = i + 1; j <= N; j++)
if (v[j] == v[i])
return cout << (j + 1) << endl, 0;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 944,931 | 944,930 | u459121100 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int f(int a) {
if (a % 2 == 0) {
return a / 2;
} else {
return 3 * a + 1;
}
}
int main() {
int s;
cin >> s;
bool found_once = false;
int count = 1;
if (s == 1) {
cout << 4 << endl;
return 0;
} else if (s == 2) {
cout << 5 << endl;
return 0;
}
while (true) {
if (s == 4) {
if (found_once) {
break;
} else {
found_once = true;
}
}
s = f(s);
++count;
}
cout << count << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int f(int a) {
if (a % 2 == 0) {
return a / 2;
} else {
return 3 * a + 1;
}
}
int main() {
int s;
cin >> s;
bool found_once = false;
int count = 1;
if (s == 1) {
cout << 4 << endl;
return 0;
} else if (s == 2) {
cout << 4 << endl;
return 0;
}
while (true) {
if (s == 4) {
if (found_once) {
break;
} else {
found_once = true;
}
}
s = f(s);
++count;
}
cout << count << endl;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 944,938 | 944,939 | u866992281 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> ans;
int cnt = 1;
while (1) {
cnt++;
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
auto itr = find(ans.begin(), ans.end(), s);
if (itr == ans.end())
ans.push_back(s);
else {
cout << cnt << endl;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
vector<int> ans(1, s);
int cnt = 1;
while (1) {
cnt++;
if (s % 2 == 0) {
s /= 2;
} else {
s = 3 * s + 1;
}
auto itr = find(ans.begin(), ans.end(), s);
if (itr == ans.end())
ans.push_back(s);
else {
cout << cnt << endl;
return 0;
}
}
} | [
"call.arguments.add"
] | 944,945 | 944,946 | u655975843 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.