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 |
|---|---|---|---|---|---|---|---|
p03050 | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long x, y, z, n, p, ans;
x = y = z = p = ans = 0;
cin >> n;
for (long long i = 2; i * i < n; i++) {
if (n % i == 0) {
x = n / i;
if (n / (i - 1) == n % (i - 1))
ans += i - 1;
if (n / (x - 1) == n % (x - 1))
ans += x - 1;
}
}
ans += n - 1;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long x, y, z, n, p, ans;
x = y = z = p = ans = 0;
cin >> n;
for (long long i = 2; i * i < n; i++) {
if (n % i == 0) {
x = n / i;
if (n / (i - 1) == n % (i - 1))
ans += i - 1;
if (n / (x - 1) == n % (x - 1))
ans += x - 1;
}
}
if (n > 2)
ans += n - 1;
cout << ans << endl;
} | [
"control_flow.branch.if.add"
] | 867,643 | 867,644 | u532894762 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N;
cin >> N;
ll ans = 0;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
ll q = i;
ll m1 = N / q;
if (q < m1) {
// cout << q << " " << m1 << '\n';
ans += m1 - 1;
}
}
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N;
cin >> N;
ll ans = 0;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
ll q = i;
ll m1 = N / q;
if (q < m1 - 1) {
// cout << q << " " << m1 << '\n';
ans += m1 - 1;
}
}
}
cout << ans << '\n';
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 867,645 | 867,646 | u833150479 | cpp |
p03050 | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
int main() {
ll N, ans = 0;
cin >> N;
for (ll i = 0; i * i < N; i++) {
if (N % i == 0) {
continue;
}
ll t = N / i;
t--;
if (i < N) {
ans += t;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
int main() {
ll N, ans = 0;
cin >> N;
for (ll i = 1; i * i <= N; i++) {
if (N % i != 0) {
continue;
}
ll t = N / i;
t--;
if (i < t) {
ans += t;
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.opposites",
"control_flow.branch.if.condition... | 867,668 | 867,669 | u946378574 | cpp |
p03050 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<long long int, long long int> P;
long long int INF = 1e18;
long long int MOD = 1e9 + 7;
int main() {
long long int N;
cin >> N;
long long int ans = 0;
for (long long int i = 1; i * i < N; i++) {
if ((N - i) % i == 0) {
ans += (N - i) / i;
}
}
cout << ans << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef pair<long long int, long long int> P;
long long int INF = 1e18;
long long int MOD = 1e9 + 7;
int main() {
long long int N;
cin >> N;
long long int ans = 0;
for (long long int i = 1; i * i < N - i; i++) {
if ((N - i) % i == 0) {
ans += (N - i) / i;
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 867,672 | 867,673 | u997521090 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
long long int answer = 0;
for (long long int i = 1;; i++) {
if (N / i <= i) {
break;
}
if ((N - i) % i == 0) {
answer += (N - i) / i;
}
}
cout << answer << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
long long int answer = 0;
for (long long int i = 1;; i++) {
// これや
if ((N - i) / i <= i) {
break;
}
if ((N - i) % i == 0) {
answer += (N - i) / i;
}
}
cout << answer << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 867,681 | 867,682 | u412989489 | cpp |
p03050 | #include "bits/stdc++.h"
using namespace std;
void solve(void) {
long n;
cin >> n;
long ans = 0;
for (long i = 1; i * i + i <= n; i++) {
long m = (n - i) / i;
if (i * m + i == n) {
ans += m;
}
}
cout << ans << endl;
}
int main() {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
void solve(void) {
long n;
cin >> n;
long ans = 0;
for (long i = 1; i * i + i <= n; i++) {
long m = (n - i) / i;
if (i < m && i * m + i == n) {
ans += m;
}
}
cout << ans << endl;
}
int main() {
solve();
// cout << "yui(*-v・)yui" << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 867,683 | 867,684 | u344412812 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define MOD (1000000007)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> yakusu;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
yakusu.push_back(i);
if (i * i != n) {
yakusu.push_back(n / i);
}
}
}
sort(yakusu.begin(), yakusu.end());
ll ans = 0;
ll sz = yakusu.size();
for (ll i = 0; i < sz; i++) {
if (yakusu[i] <= (ll)sqrt(n)) {
continue;
} else {
ans += yakusu[i] - 1;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define MOD (1000000007)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> yakusu;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
yakusu.push_back(i);
if (i * i != n) {
yakusu.push_back(n / i);
}
}
}
sort(yakusu.begin(), yakusu.end());
ll ans = 0;
ll sz = yakusu.size();
for (ll i = 0; i < sz; i++) {
if (yakusu[i] <= (ll)sqrt(n) + 1) {
continue;
} else {
ans += yakusu[i] - 1;
}
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 867,687 | 867,688 | u551351897 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
long long N;
cin >> N;
long long ans = 0;
// N = m * n + n を満たす m, n の組が存在するかどうか
// N = n(m+1)
// m > n > 0
for (long long i = 1; i * i <= N; i++) {
// n = i, m = N / i - 1
if (N % i == 0 && N / i - 1 != i) {
ans += N / i - 1;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
long long N;
cin >> N;
long long ans = 0;
// N = m * n + n を満たす m, n の組が存在するかどうか
// N = n(m+1)
// m > n > 0
for (long long i = 1; i * i < N; i++) {
// n = i, m = N / i - 1
if (N % i == 0 && N / i - 1 != i) {
ans += N / i - 1;
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 867,689 | 867,690 | u883982500 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
long long N;
cin >> N;
long long ans = 0;
// N = m * n + n を満たす m, n の組が存在するかどうか
// N = n(m+1)
// m > n > 0
for (long long i = 1; i * i <= N; i++) {
// n = i, m = N / i - 1
if (N % i == 0 && N / i != i) {
ans += N / i - 1;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
long long N;
cin >> N;
long long ans = 0;
// N = m * n + n を満たす m, n の組が存在するかどうか
// N = n(m+1)
// m > n > 0
for (long long i = 1; i * i < N; i++) {
// n = i, m = N / i - 1
if (N % i == 0 && N / i - 1 != i) {
ans += N / i - 1;
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 867,691 | 867,690 | u883982500 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
LL N;
cin >> N;
LL ans = 0;
for (LL i = 1; i * i < N; i++) {
if (N % i == 0) {
LL m = N / i - 1;
LL p = i;
ans += m;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
LL N;
cin >> N;
LL ans = 0;
for (LL i = 1; i * i < N; i++) {
if (N % i == 0) {
LL m = N / i - 1;
LL p = i;
if (m > p)
ans += m;
}
}
cout << ans << endl;
} | [
"control_flow.branch.if.add"
] | 867,692 | 867,693 | u510175787 | cpp |
p03050 | #include <iostream>
int main() {
long long N;
std::cin >> N;
long long ans = 0;
for (long long i = 1; i * i < N; ++i) {
if (N % i == 0) {
ans += N / i - 1;
}
}
std::cout << ans << "\n";
return 0;
}
| #include <iostream>
int main() {
long long N;
std::cin >> N;
long long ans = 0;
for (long long i = 1; i * (i + 1) < N; ++i) {
if (N % i == 0) {
ans += N / i - 1;
}
}
std::cout << ans << "\n";
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 867,699 | 867,700 | u982753571 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N;
scanf("%lld", &N);
ll res = 0;
for (ll p = 1; p * p < N; p++) {
ll m = N / p - 1;
ll r = N % p;
if (r == 0) {
res += m;
}
}
printf("%lld\n", res);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N;
scanf("%lld", &N);
ll res = 0;
for (ll p = 1; p * p < N; p++) {
ll m = N / p - 1;
ll r = N % p;
if (p < m && r == 0) {
res += m;
}
}
printf("%lld\n", res);
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 867,707 | 867,708 | u697421413 | cpp |
p03050 | #include <algorithm>
#include <climits>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define MAX 1000000007
using namespace std;
#define ll long long
#define dbg if (0)
#define ISRANGE(val, lo, hi) ((lo <= val) && (val < hi))
// nanndeya
int main() {
ll ans, n;
cin >> n;
// for(int debug=1;debug<100000;debug++){n=debug,ans=0;
// ll ans2=0;
if (n < 3)
ans = 0;
else {
for (ll i = 1; i * i < n; i++) {
if (n % i == 0) {
// cout <<n/i-1<<endl;;
if (n % (n / i - 1) == n / (n / i - 1)) {
ans += (n / i - 1);
}
}
}
}
// for(ll i=1;i<n;i++){
// if(n%i==n/i){
// ans2+=(i);
// }
// }
// if(ans!=ans2) cout <<n<<": "<<ans<<" "<<ans2 <<" error!"<<endl;
// }
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define MAX 1000000007
using namespace std;
#define ll long long
#define dbg if (0)
#define ISRANGE(val, lo, hi) ((lo <= val) && (val < hi))
/*
変数宣言
作詞 Ry0um4
唄 任意のユーザー
歌詞：
お前がコードを貼り付ける前に 言っておきたい事がある
かなり厳しい話もするが 俺の本音を聴いておけ
初期化より先に計算してはいけない
初期化より先に計算してはいけない
まとめて定義するな いつも=0にしろ
出来る範囲で 構わないから
忘れてくれるな 文脈も読めないマシンに
未初期化変数を0にできる はずなどないってことを
マシンにはマシンしか できないこともあるけど
それ以外は全部 黙ってお前が書いてこい
(飽きたので省略)
*/
int main() {
ll ans = 0, n; //ここ
cin >> n;
if (n < 3)
ans = 0;
else {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (n % (n / i - 1) == n / (n / i - 1)) {
ans += (n / i - 1);
}
}
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,716 | 867,717 | u828752458 | cpp |
p03050 | #include <algorithm>
#include <climits>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define MAX 1000000007
using namespace std;
#define ll long long
#define dbg if (0)
#define ISRANGE(val, lo, hi) ((lo <= val) && (val < hi))
int main() {
ll ans, n;
cin >> n;
// for(int debug=1;debug<1000;debug++){n=debug,ans=0;
// ll ans2=0;
if (n < 3)
ans = 0;
else {
for (ll i = 1; i * i < n; i++) {
if (n % i == 0) {
// cout <<n/i-1<<endl;;
if (n % (n / i - 1) == n / (n / i - 1)) {
ans += (n / i - 1);
}
}
}
}
/* for(ll i=1;i<n;i++){
if(n%i==n/i){
//cout <<n/i-1<<endl;;
ans2+=(i);
}
}
if(ans!=ans2) cout <<n<<": "<<ans<<" "<<ans2 <<" error!"<<endl;
}*/
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define MAX 1000000007
using namespace std;
#define ll long long
#define dbg if (0)
#define ISRANGE(val, lo, hi) ((lo <= val) && (val < hi))
/*
変数宣言
作詞 Ry0um4
唄 任意のユーザー
歌詞：
お前がコードを貼り付ける前に 言っておきたい事がある
かなり厳しい話もするが 俺の本音を聴いておけ
初期化より先に計算してはいけない
初期化より先に計算してはいけない
まとめて定義するな いつも=0にしろ
出来る範囲で 構わないから
忘れてくれるな 文脈も読めないマシンに
未初期化変数を0にできる はずなどないってことを
マシンにはマシンしか できないこともあるけど
それ以外は全部 黙ってお前が書いてこい
(飽きたので省略)
*/
int main() {
ll ans = 0, n; //ここ
cin >> n;
if (n < 3)
ans = 0;
else {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (n % (n / i - 1) == n / (n / i - 1)) {
ans += (n / i - 1);
}
}
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,718 | 867,717 | u828752458 | cpp |
p03050 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, p, n) for (int i = p; i < n; ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long int;
using pll = pair<ll, ll>;
int main() {
ll N;
cin >> N;
ll ans = 0;
for (ll i = 1; i * i < N; ++i) {
if ((N % i) == 0) {
ans += (N / i) - 1;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, p, n) for (int i = p; i < n; ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long int;
using pll = pair<ll, ll>;
int main() {
ll N;
cin >> N;
ll ans = 0;
for (ll i = 1; (i + 1) * i < N; ++i) {
if ((N % i) == 0) {
ans += (N / i) - 1;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 867,719 | 867,720 | u039041830 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
int main() {
uint64_t n;
cin >> n;
uint64_t ret = 0;
for (uint64_t i = 1; i <= sqrt(n) + 1; ++i) {
if (n % i == 0) {
if (i <= (n / i - 1)) {
ret += (n / i - 1);
}
}
}
cout << ret << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
uint64_t n;
cin >> n;
uint64_t ret = 0;
for (uint64_t i = 1; i <= sqrt(n) + 1; ++i) {
if (n % i == 0) {
if (i < (n / i - 1)) {
ret += (n / i - 1);
}
}
}
cout << ret << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,721 | 867,722 | u627431737 | cpp |
p03050 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
vector<ll> vec;
int main() {
ll n;
cin >> n;
ll cnt = 0;
for (ll i = 1; i * i < n; i++) {
if (n % i == 0)
cnt += n / i - 1;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
vector<ll> vec;
int main() {
ll n;
cin >> n;
ll cnt = 0;
for (ll i = 1; i < n / i - 1; i++) {
if (n % i == 0)
cnt += n / i - 1;
}
cout << cnt << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 867,725 | 867,726 | u620866522 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = 0;
long long mx = sqrt(N);
for (long long x = 1; x < mx; x++) {
if (N % x == 0 && N / x - 1 > x)
ans += N / x - 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = 0;
long long mx = sqrt(N);
for (long long x = 1; x < mx + 1; x++) {
if (N % x == 0 && N / x - 1 > x)
ans += N / x - 1;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 867,732 | 867,733 | u475503988 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef DEBUG
std::ifstream in("/home/share/inputf.in");
std::cin.rdbuf(in.rdbuf());
#endif
int64_t N, ans = 0;
cin >> N;
for (int64_t k = 1; k * k < N; k++) {
if (N % k == 0) {
ans += N / k - 1;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef DEBUG
std::ifstream in("/home/share/inputf.in");
std::cin.rdbuf(in.rdbuf());
#endif
int64_t N, ans = 0;
cin >> N;
for (int64_t k = 1; k * (k + 1) < N; k++) {
if (N % k == 0) {
ans += N / k - 1;
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 867,734 | 867,735 | u936555566 | cpp |
p03050 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
ll tot = 0;
for (ll i = 2; n >= i * i; i++) {
if (n % i == 0) {
ll m = n / i;
if (m - 1 > i) {
tot += m - 1;
}
if (i - 1 > m) {
tot += i - 1;
}
}
}
cout << tot;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
ll tot = 0;
for (ll i = 1; n >= i * i; i++) {
if (n % i == 0) {
ll m = n / i;
if (m - 1 > i) {
tot += m - 1;
}
if (i - 1 > m) {
tot += i - 1;
}
}
}
cout << tot;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 867,748 | 867,749 | u337054478 | cpp |
p03050 | /*
ll used[10];
ll maxi;
ll dfs(Graph& graph, ll v, ll deep) {
used[v] = 1;
vector<ll> maxd;
maxd.push_back(deep);
for (int i = 0; i < graph[v].size(); i++) {
if (used[graph[v][i].to] == 0) {
maxd.push_back(dfs(graph, graph[v][i].to, deep + 1));
}
}
sort(all(maxd), greater<ll>());
if (maxd.size() > 2) {
chmax(maxi, maxd[0] - deep + maxd[1] - deep);
}
else {
chmax(maxi, maxd[0] - deep);
}
return maxd[0];
}
*///dfs
/*
REP(i, n) {
REP(j, n) {
dp[i][j] = INF;
}
}
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
dp[a][b] = c;
dp[b][a] = c;
}
REP(i, n) {
REP(j, n) {
REP(k, n) {
chmin(dp[j][k], dp[j][i] + dp[i][k]);
}
}
}
*///warshall floyd
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// sortは初期で昇順 greater<hoge>()で降順
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) {
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class UnionFind {
vector<int> data;
public:
UnionFind(int size) : data(size, -1) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
int main() {
ll n;
cin >> n;
ull ans = 0;
ll i = 1;
while (true) {
if (i * i > n)
break;
if ((n - i) % i == 0) {
if (i % ((n - i) / i) != 0) {
ans += (ull)((n - i) / i);
}
}
i++;
}
cout << ans;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// sortは初期で昇順 greater<hoge>()で降順
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) {
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class UnionFind {
vector<int> data;
public:
UnionFind(int size) : data(size, -1) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
int main() {
ll n;
cin >> n;
ull ans = 0;
ll i = 1;
while (true) {
if (i * i >= n)
break;
if ((n - i) % i == 0) {
if (i % ((n - i) / i) != 0) {
ans += (ull)((n - i) / i);
}
}
i++;
}
cout << ans;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,752 | 867,753 | u051493691 | cpp |
p03050 | /*
ll used[10];
ll maxi;
ll dfs(Graph& graph, ll v, ll deep) {
used[v] = 1;
vector<ll> maxd;
maxd.push_back(deep);
for (int i = 0; i < graph[v].size(); i++) {
if (used[graph[v][i].to] == 0) {
maxd.push_back(dfs(graph, graph[v][i].to, deep + 1));
}
}
sort(all(maxd), greater<ll>());
if (maxd.size() > 2) {
chmax(maxi, maxd[0] - deep + maxd[1] - deep);
}
else {
chmax(maxi, maxd[0] - deep);
}
return maxd[0];
}
*///dfs
/*
REP(i, n) {
REP(j, n) {
dp[i][j] = INF;
}
}
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
dp[a][b] = c;
dp[b][a] = c;
}
REP(i, n) {
REP(j, n) {
REP(k, n) {
chmin(dp[j][k], dp[j][i] + dp[i][k]);
}
}
}
*///warshall floyd
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// sortは初期で昇順 greater<hoge>()で降順
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) {
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class UnionFind {
vector<int> data;
public:
UnionFind(int size) : data(size, -1) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
int main() {
ll n;
cin >> n;
ull ans = 0;
ll i = 1;
while (true) {
if (i * i > n)
break;
if ((n - i) % i == 0) {
if (i % ((n - i) / i) != 0) {
ans += (ull)((n - i) / i);
}
}
i++;
}
cout << ans;
return 0;
}
| /*
ll used[10];
ll maxi;
ll dfs(Graph& graph, ll v, ll deep) {
used[v] = 1;
vector<ll> maxd;
maxd.push_back(deep);
for (int i = 0; i < graph[v].size(); i++) {
if (used[graph[v][i].to] == 0) {
maxd.push_back(dfs(graph, graph[v][i].to, deep + 1));
}
}
sort(all(maxd), greater<ll>());
if (maxd.size() > 2) {
chmax(maxi, maxd[0] - deep + maxd[1] - deep);
}
else {
chmax(maxi, maxd[0] - deep);
}
return maxd[0];
}
*///dfs
/*
REP(i, n) {
REP(j, n) {
dp[i][j] = INF;
}
}
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
dp[a][b] = c;
dp[b][a] = c;
}
REP(i, n) {
REP(j, n) {
REP(k, n) {
chmin(dp[j][k], dp[j][i] + dp[i][k]);
}
}
}
*///warshall floyd
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// sortは初期で昇順 greater<hoge>()で降順
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) {
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class UnionFind {
vector<int> data;
public:
UnionFind(int size) : data(size, -1) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
int main() {
ll n;
cin >> n;
ull ans = 0;
ll i = 1;
while (true) {
if (i * i >= n)
break;
if ((n - i) % i == 0) {
if (i % ((n - i) / i) != 0) {
ans += (ull)((n - i) / i);
}
}
i++;
}
cout << ans;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,752 | 867,754 | u051493691 | cpp |
p03050 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define chmin(a, b) ((a) = min((a), (b)))
#define chmax(a, b) ((a) = max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const double pi = acos(-1);
const double eps = 1e-10;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
int main() {
ll n;
cin >> n;
ll ans = 0;
for (int i = 1;; i++) {
ll num = n;
num -= i;
if (i > num / i)
break;
if (num % i == 0)
ans += num / i;
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define chmin(a, b) ((a) = min((a), (b)))
#define chmax(a, b) ((a) = max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const double pi = acos(-1);
const double eps = 1e-10;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
int main() {
ll n;
cin >> n;
ll ans = 0;
for (ll i = 1;; i++) {
ll num = n;
num -= i;
if (i >= num / i)
break;
if (num % i == 0)
ans += num / i;
}
cout << ans << endl;
} | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,759 | 867,760 | u049420296 | cpp |
p03050 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drep2(j, n) for (int j = (n)-1; j >= 0; --j)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define srep2(j, s, t) for (int j = s; j < t; ++j)
#define srep3(k, s, t) for (int k = s; k < t; ++k)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
int main() {
ll N;
cin >> N;
vi yakusuu;
ll ans = 0;
int sqN = (int)sqrt(N);
show(sqN);
for (int i = 1; i <= sqN; i++) {
if (N % i == 0) {
yakusuu.push_back(i);
}
}
rep(i, sz(yakusuu)) {
ll b = (N / yakusuu[i]) - 1;
if (b > yakusuu[i])
ans += b;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drep2(j, n) for (int j = (n)-1; j >= 0; --j)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define srep2(j, s, t) for (int j = s; j < t; ++j)
#define srep3(k, s, t) for (int k = s; k < t; ++k)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
int main() {
ll N;
cin >> N;
vi yakusuu;
ll ans = 0;
int sqN = (int)sqrt(N);
for (int i = 1; i <= sqN; i++) {
if (N % i == 0) {
yakusuu.push_back(i);
}
}
rep(i, sz(yakusuu)) {
ll b = (N / yakusuu[i]) - 1;
if (b > yakusuu[i])
ans += b;
}
cout << ans << endl;
return 0;
} | [
"call.remove"
] | 867,769 | 867,770 | u340293807 | cpp |
p03050 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = 0;
for (long long i = 1; i * i < N; ++i) {
if ((N - i) % i == 0) {
ans += (N - i) / i;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = 0;
for (long long i = 1; i * i + i < N; ++i) {
if ((N - i) % i == 0) {
ans += (N - i) / i;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 867,786 | 867,787 | u493610446 | cpp |
p03050 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
constexpr ll siz = 1e6 + 10;
vector<ll> make_primes() {
vector<bool> can(siz, true);
can[0] = can[1] = false;
vector<ll> primes;
REP(i, siz) if (can[i]) {
primes.push_back(i);
ll times = 2;
while (times * i < siz) {
can[times * i] = false;
times++;
}
}
return primes;
}
int main() {
// auto primes = make_primes();
ll N;
set<ll> st;
cin >> N;
FOR(i, 1, sqrt(N) + 10) {
if (N % i == 0) {
st.insert(i);
st.insert(N / i);
}
}
ll res = 0;
for (auto num : st) {
if (num > sqrt(N))
res += num - 1;
}
cout << res << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
constexpr ll siz = 1e6 + 10;
vector<ll> make_primes() {
vector<bool> can(siz, true);
can[0] = can[1] = false;
vector<ll> primes;
REP(i, siz) if (can[i]) {
primes.push_back(i);
ll times = 2;
while (times * i < siz) {
can[times * i] = false;
times++;
}
}
return primes;
}
int main() {
// auto primes = make_primes();
ll N;
set<ll> st;
cin >> N;
FOR(i, 1, sqrt(N) + 10) {
if (N % i == 0) {
st.insert(i);
st.insert(N / i);
}
}
ll res = 0;
for (auto num : st) {
if (num - 1 > sqrt(N))
res += num - 1;
}
cout << res << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,793 | 867,794 | u692632484 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<LL, LL> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 60;
const int INF = 1 << 30;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
vector<LL> divi(LL K) {
vector<LL> v;
for (LL i = 1; i * i <= K; i++) {
if (K % i)
continue;
v.pb(i);
v.pb(K / i);
}
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
return v;
}
int main() {
LL n;
cin >> n;
LL ans = 0;
auto p = divi(n);
for (int i = p.size() - 1; i > 0; i--) {
LL m = p[i];
LL a = n / m;
if (a < m)
ans += m - 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<LL, LL> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 60;
const int INF = 1 << 30;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
vector<LL> divi(LL K) {
vector<LL> v;
for (LL i = 1; i * i <= K; i++) {
if (K % i)
continue;
v.pb(i);
v.pb(K / i);
}
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
return v;
}
int main() {
LL n;
cin >> n;
LL ans = 0;
auto p = divi(n);
for (int i = p.size() - 1; i > 0; i--) {
LL m = p[i] - 1;
LL a = n / m;
if (a < m)
ans += m;
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 867,801 | 867,802 | u640323045 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll N;
vector<ll> dvs;
void divisor(ll n) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
dvs.push_back(i);
if (i != n / i) {
dvs.push_back(n / i);
}
}
}
}
void solve() {
divisor(N);
sort(dvs.begin(), dvs.end());
ll n = dvs.size();
ll res = 0;
for (ll i = 0; i < n; i++) {
if (N / dvs[i] <= dvs[i] - 1) {
res += dvs[i] - 1;
}
}
cout << res << '\n';
}
int main() {
cin >> N;
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll N;
vector<ll> dvs;
void divisor(ll n) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
dvs.push_back(i);
if (i != n / i) {
dvs.push_back(n / i);
}
}
}
}
void solve() {
divisor(N);
sort(dvs.begin(), dvs.end());
ll n = dvs.size();
ll res = 0;
for (ll i = 0; i < n; i++) {
if (N / dvs[i] < dvs[i] - 1) {
res += dvs[i] - 1;
}
}
cout << res << '\n';
}
int main() {
cin >> N;
solve();
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,803 | 867,804 | u319242216 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll N;
vector<ll> dvs;
void divisor(ll n) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
dvs.push_back(i);
if (i != n / i) {
dvs.push_back(n / i);
}
}
}
}
void solve() {
divisor(N);
sort(dvs.begin(), dvs.end());
ll n = dvs.size();
ll res = 0;
for (ll i = 0; i < n; i++) {
if (N / dvs[i] < dvs[i]) {
res += dvs[i] - 1;
}
}
cout << res << '\n';
}
int main() {
cin >> N;
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll N;
vector<ll> dvs;
void divisor(ll n) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
dvs.push_back(i);
if (i != n / i) {
dvs.push_back(n / i);
}
}
}
}
void solve() {
divisor(N);
sort(dvs.begin(), dvs.end());
ll n = dvs.size();
ll res = 0;
for (ll i = 0; i < n; i++) {
if (N / dvs[i] < dvs[i] - 1) {
res += dvs[i] - 1;
}
}
cout << res << '\n';
}
int main() {
cin >> N;
solve();
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 867,805 | 867,804 | u319242216 | cpp |
p03050 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define COUT(x) cout << (x) << endl
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
/*------------------ the end of the template -----------------------*/
int main() {
IOS; /* making cin faster */
lli N;
lli cnt = 0;
SCANLLD(N);
lli m1;
FOR(n, 1, sqrt(N) + 2) {
if (N % n == 0) {
m1 = N / n;
if (m1 > n) {
cnt += m1 - 1;
}
}
}
PRINTLLD(cnt);
}
| #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define COUT(x) cout << (x) << endl
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
/*------------------ the end of the template -----------------------*/
int main() {
IOS; /* making cin faster */
lli N;
lli cnt = 0;
SCANLLD(N);
lli m1;
FOR(n, 1, sqrt(N) + 2) {
if (N % n == 0) {
m1 = N / n;
if (m1 > n + 1) {
cnt += m1 - 1;
}
}
}
PRINTLLD(cnt);
}
| [
"control_flow.branch.if.condition.change"
] | 867,808 | 867,809 | u900727536 | cpp |
p03050 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define COUT(x) cout << (x) << endl
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
/*------------------ the end of the template -----------------------*/
int main() {
IOS; /* making cin faster */
lli N;
lli cnt = 0;
SCANLLD(N);
lli m1;
FOR(n, 1, sqrt(N) + 1) {
if (N % n == 0) {
m1 = N / n;
if (m1 > n) {
cnt += m1 - 1;
}
}
}
PRINTLLD(cnt);
}
| #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define COUT(x) cout << (x) << endl
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
/*------------------ the end of the template -----------------------*/
int main() {
IOS; /* making cin faster */
lli N;
lli cnt = 0;
SCANLLD(N);
lli m1;
FOR(n, 1, sqrt(N) + 2) {
if (N % n == 0) {
m1 = N / n;
if (m1 > n + 1) {
cnt += m1 - 1;
}
}
}
PRINTLLD(cnt);
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 867,810 | 867,809 | u900727536 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for (int i = 0; i < n; i++)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll MOD = 1e9 + 7;
//約数列挙 O(n**1/2)
vector<ll> divisor(ll n) {
vector<ll> res;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i)
res.push_back(n / i);
}
}
return res;
}
int main() {
ll N;
cin >> N;
auto div = divisor(N);
ll ans = 0;
for (auto q : div) {
// cout << q << endl;
ll n = N / q;
if (q >= n)
continue;
if (n > 0)
n--;
ans += n;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for (int i = 0; i < n; i++)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll MOD = 1e9 + 7;
//約数列挙 O(n**1/2)
vector<ll> divisor(ll n) {
vector<ll> res;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i)
res.push_back(n / i);
}
}
return res;
}
int main() {
ll N;
cin >> N;
auto div = divisor(N);
ll ans = 0;
for (auto q : div) {
ll n = N / q;
if (q + 1 >= n)
continue;
// cout << q << endl;
if (n > 0)
n--;
ans += n;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,811 | 867,812 | u666394517 | cpp |
p03050 | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int ll;
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, a) repi(i, 0, a)
#define rrep(i, a) for (ll i = a - 1; i >= 0; i--)
int main() {
ll N;
cin >> N;
ll ans = 0;
for (ll n = 1; n * n < N; n++)
if (N % n == 0)
ans += N / n - 1;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int ll;
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, a) repi(i, 0, a)
#define rrep(i, a) for (ll i = a - 1; i >= 0; i--)
int main() {
ll N;
cin >> N;
ll ans = 0;
for (ll n = 1; n * (n + 1) < N; n++)
if (N % n == 0)
ans += N / n - 1;
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 867,817 | 867,818 | u336721073 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MIN(a) *min_element(all(a))
#define MAX(a) *max_element(all(a))
#define SUM(a, b) accumulate(all(a), b)
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); i++)
#define FORR(i, m, n) for (int(i) = (n)-1; (i) >= (m); i--)
#define ios() cin.tie(0), ios::sync_with_stdio(false)
#define debug(x) cerr << #x << " = " << x << endl
//#define int long long
typedef long long ll;
typedef unsigned long long ull;
// ll const MOD = 998244353;
ll const MOD = 1e9 + 7;
ll const INF = 1e18;
template <typename T> int size(const T &a) { return (int)a.size(); }
template <typename T> T Div(T a, T b) { return (a + b - 1) / b; }
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
signed main() {
ll n;
cin >> n;
ll ans = 0;
for (ll i = 1; i * i + 1 <= n; i++) {
if (n % i == 0) {
ans += n / i - 1;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MIN(a) *min_element(all(a))
#define MAX(a) *max_element(all(a))
#define SUM(a, b) accumulate(all(a), b)
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); i++)
#define FORR(i, m, n) for (int(i) = (n)-1; (i) >= (m); i--)
#define ios() cin.tie(0), ios::sync_with_stdio(false)
#define debug(x) cerr << #x << " = " << x << endl
//#define int long long
typedef long long ll;
typedef unsigned long long ull;
// ll const MOD = 998244353;
ll const MOD = 1e9 + 7;
ll const INF = 1e18;
template <typename T> int size(const T &a) { return (int)a.size(); }
template <typename T> T Div(T a, T b) { return (a + b - 1) / b; }
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
signed main() {
ll n;
cin >> n;
ll ans = 0;
for (ll i = 1; i * (i + 1) < n; i++) {
if (n % i == 0) {
ans += n / i - 1;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 867,819 | 867,820 | u994831328 | cpp |
p03050 | #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
// iteration helper
#define FOR(i, l, r) for (int i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, l, r) for (int i = (r)-1; i >= (l); --i)
#define RREP(i, n) RFOR(i, 0, n)
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define PB push_back
// MyVector
template <typename T>
class MyVector : private std::vector<T, std::allocator<T>> {
public:
using basetype = std::vector<T, std::allocator<T>>;
using basetype::vector; // constractor
using basetype::operator=;
using basetype::begin;
using basetype::capacity;
using basetype::cbegin;
using basetype::cend;
using basetype::crbegin;
using basetype::crend;
using basetype::empty;
using basetype::end;
using basetype::max_size;
using basetype::rbegin;
using basetype::rend;
using basetype::reserve;
using basetype::resize;
using basetype::shrink_to_fit;
using basetype::size;
// []のかわりに at をつかう
typename MyVector<T>::reference operator[](typename basetype::size_type n) {
basetype::at(n);
}
typename MyVector<T>::const_reference
operator[](typename basetype::size_type n) const {
basetype::at(n);
};
using basetype::assign;
using basetype::at;
using basetype::back;
using basetype::clear;
using basetype::data;
using basetype::emplace;
using basetype::emplace_back;
using basetype::erase;
using basetype::front;
using basetype::insert;
using basetype::pop_back;
using basetype::push_back;
using basetype::swap;
};
#ifdef _DEBUG
#define vector MyVector
#else
#define vector std::vector
#endif
// typedefs
#define ll long long
#define vi vector<int>
#define vi2 vector<vi>
// input
#define ci(x) \
int x; \
cin >> x
#define cs(x) \
string x; \
cin >> x
#define cd(x) \
double x; \
cin >> x
#define cvi(x, n) \
vi x(n); \
REP(i, n) { cin >> x[i]; }
// const input
#define cci(x) \
const int x = []() { \
int t; \
cin >> t; \
return t; \
}()
#define ccs(x) \
const string x = []() { \
string t; \
cin >> t; \
return t; \
}()
#define ccd(x) \
const double x = []() { \
double t; \
cin >> t; \
return t; \
}()
// output
#define pr(x) cout << x << endl
#define prvec(v) REP(i, v.size()) pr(v[i])
#define ppr(x) cout << x
#define lf() cout << endl
// debug methods
// usage: debug(x,y);
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0, a1, a2, a3, a4, x, ...) x
#define debug_1(x1) cout << #x1 << ": " << x1 << endl
#define debug_2(x1, x2) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << endl
#define debug_3(x1, x2, x3) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << endl
#define debug_4(x1, x2, x3, x4) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << endl
#define debug_5(x1, x2, x3, x4, x5) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << ", " #x5 << ": " << x5 << endl
#ifdef _DEBUG
#define debug(...) \
CHOOSE((__VA_ARGS__, debug_5, debug_4, debug_3, debug_2, debug_1, ~)) \
(__VA_ARGS__)
#else
#define debug(...)
#endif
// const number
const double PI = acos(-1.0);
const double EPS = 1e-10;
int powint(int a, int x) {
int res = 1;
REP(i, x) { res = res * a; }
return res;
}
#pragma endregion
#define int long long
signed main() {
#ifdef _DEBUG
try {
#endif
// main program ---------------------------------------------
cci(N);
int ans = 0;
for (int i = 1;; ++i) {
int j = N - i;
int a = j / i;
if (j % i == 0 && N % a == N / a) {
ans += a;
}
if (i > a)
break;
}
pr(ans);
// end main program -----------------------------------------
#ifdef _DEBUG
} catch (std::out_of_range &ex) {
pr("out of range");
}
#endif
return 0;
}
| #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
// iteration helper
#define FOR(i, l, r) for (int i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, l, r) for (int i = (r)-1; i >= (l); --i)
#define RREP(i, n) RFOR(i, 0, n)
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define PB push_back
// MyVector
template <typename T>
class MyVector : private std::vector<T, std::allocator<T>> {
public:
using basetype = std::vector<T, std::allocator<T>>;
using basetype::vector; // constractor
using basetype::operator=;
using basetype::begin;
using basetype::capacity;
using basetype::cbegin;
using basetype::cend;
using basetype::crbegin;
using basetype::crend;
using basetype::empty;
using basetype::end;
using basetype::max_size;
using basetype::rbegin;
using basetype::rend;
using basetype::reserve;
using basetype::resize;
using basetype::shrink_to_fit;
using basetype::size;
// []のかわりに at をつかう
typename MyVector<T>::reference operator[](typename basetype::size_type n) {
basetype::at(n);
}
typename MyVector<T>::const_reference
operator[](typename basetype::size_type n) const {
basetype::at(n);
};
using basetype::assign;
using basetype::at;
using basetype::back;
using basetype::clear;
using basetype::data;
using basetype::emplace;
using basetype::emplace_back;
using basetype::erase;
using basetype::front;
using basetype::insert;
using basetype::pop_back;
using basetype::push_back;
using basetype::swap;
};
#ifdef _DEBUG
#define vector MyVector
#else
#define vector std::vector
#endif
// typedefs
#define ll long long
#define vi vector<int>
#define vi2 vector<vi>
// input
#define ci(x) \
int x; \
cin >> x
#define cs(x) \
string x; \
cin >> x
#define cd(x) \
double x; \
cin >> x
#define cvi(x, n) \
vi x(n); \
REP(i, n) { cin >> x[i]; }
// const input
#define cci(x) \
const int x = []() { \
int t; \
cin >> t; \
return t; \
}()
#define ccs(x) \
const string x = []() { \
string t; \
cin >> t; \
return t; \
}()
#define ccd(x) \
const double x = []() { \
double t; \
cin >> t; \
return t; \
}()
// output
#define pr(x) cout << x << endl
#define prvec(v) REP(i, v.size()) pr(v[i])
#define ppr(x) cout << x
#define lf() cout << endl
// debug methods
// usage: debug(x,y);
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0, a1, a2, a3, a4, x, ...) x
#define debug_1(x1) cout << #x1 << ": " << x1 << endl
#define debug_2(x1, x2) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << endl
#define debug_3(x1, x2, x3) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << endl
#define debug_4(x1, x2, x3, x4) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << endl
#define debug_5(x1, x2, x3, x4, x5) \
cout << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << ", " #x5 << ": " << x5 << endl
#ifdef _DEBUG
#define debug(...) \
CHOOSE((__VA_ARGS__, debug_5, debug_4, debug_3, debug_2, debug_1, ~)) \
(__VA_ARGS__)
#else
#define debug(...)
#endif
// const number
const double PI = acos(-1.0);
const double EPS = 1e-10;
int powint(int a, int x) {
int res = 1;
REP(i, x) { res = res * a; }
return res;
}
#pragma endregion
#define int long long
signed main() {
#ifdef _DEBUG
try {
#endif
// main program ---------------------------------------------
cci(N);
int ans = 0;
for (int i = 1;; ++i) {
int j = N - i;
int a = j / i;
if (j % i == 0 && a != 0 && N % a == N / a) {
ans += a;
}
if (i > a)
break;
}
pr(ans);
// end main program -----------------------------------------
#ifdef _DEBUG
} catch (std::out_of_range &ex) {
pr("out of range");
}
#endif
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 867,821 | 867,822 | u820612421 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
vector<i64> divisor(i64 n) {
vector<i64> res;
for (i64 i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i)
res.push_back(n / i);
}
}
return res;
}
int main() {
i64 n;
cin >> n;
auto v = divisor(n);
i64 ans = 0;
for (auto e : v) {
i64 d = n / e;
if (d > e)
ans += d - 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
vector<i64> divisor(i64 n) {
vector<i64> res;
for (i64 i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i)
res.push_back(n / i);
}
}
return res;
}
int main() {
i64 n;
cin >> n;
auto v = divisor(n);
i64 ans = 0;
for (auto e : v) {
i64 d = n / e;
if (d > e + 1)
ans += d - 1;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,823 | 867,824 | u823112986 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, ans = 0;
cin >> n;
for (long long i = 1; i < n; ++i) {
if (n / i < i + 1) {
break;
}
if ((n - i) % i == 0)
ans += (n - i) / i;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, ans = 0;
cin >> n;
for (long long i = 1; i < n; ++i) {
if ((n - i) / i < i + 1) {
break;
}
if ((n - i) % i == 0)
ans += (n - i) / i;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 867,825 | 867,826 | u314988220 | cpp |
p03050 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iterator>
#include <map>
#include <queue>
#include <vector>
using namespace std;
long long n;
long long sum;
int main() {
sum = 0;
scanf("%I64d", &n);
long long d = 1;
long long dx;
while (d * d < n) //平方数无效
{
dx = n / d;
if ((n / (dx - 1)) == (n % (dx - 1)))
sum = sum + (dx - 1);
// printf("%d %d %d\n", dx, sum / dx, sum % dx, sum);
// printf("%I64d\n", sum);
d++;
}
printf("%I64d\n", sum);
return 0;
}
//设指定数为x
//那么商q = N / x;
//余数r = N % x;
//就有如下属性q*x + r = N
//由于q==r
//所以q * (x + 1) = N
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iterator>
#include <map>
#include <queue>
#include <vector>
using namespace std;
long long n;
long long sum;
int main() {
sum = 0;
scanf("%lld", &n);
long long d = 1;
long long dx;
while (d * d < n) //平方数无效
{
dx = n / d;
if ((n / (dx - 1)) == (n % (dx - 1)))
sum = sum + (dx - 1);
// printf("%d %d %d\n", dx, sum / dx, sum % dx, sum);
// printf("%I64d\n", sum);
d++;
}
printf("%lld\n", sum);
return 0;
}
//设指定数为x
//那么商q = N / x;
//余数r = N % x;
//就有如下属性q*x + r = N
//由于q==r
//所以q * (x + 1) = N
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 867,827 | 867,828 | u127473726 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void solve() {
ll n, ret = 0;
cin >> n;
set<ll> s;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == n / i) {
// ret += i;
s.insert(i);
}
}
ll g = 0, u = 0;
ll v = 0;
for (ll i = 1; i * i <= n; ++i) {
ll y = n / i;
ll x = n / (i + 1) + 1;
x = max(x, i + 1);
if (x <= y) {
ll u = n - x * i, v = n - y * i;
// cout<<n/x<<" "<<n/y<<" "<<i<<endl;
// cout<<x<<" "<<y<<endl;
if (v > i) {
continue;
}
ll g = (u - i);
if (g % i == 0) {
g /= i;
ll cur = (x + g);
s.insert(cur);
}
}
}
for (set<ll>::iterator it = s.begin(); it != s.end(); ++it) {
ret += (*it);
}
cout << ret << endl;
}
int main() {
// freopen("input.txt","r",stdin);
solve();
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void solve() {
ll n, ret = 0;
cin >> n;
set<ll> s;
for (ll i = 1; i * i <= n * 2; ++i) {
if (n % i == n / i) {
// ret += i;
s.insert(i);
}
}
ll g = 0, u = 0;
ll v = 0;
for (ll i = 1; i * i <= n; ++i) {
ll y = n / i;
ll x = n / (i + 1) + 1;
x = max(x, i + 1);
if (x <= y) {
ll u = n - x * i, v = n - y * i;
// cout<<n/x<<" "<<n/y<<" "<<i<<endl;
// cout<<x<<" "<<y<<endl;
if (v > i || i > u) {
continue;
}
ll g = (u - i);
if (g % i == 0) {
g /= i;
ll cur = (x + g);
s.insert(cur);
}
}
}
for (set<ll>::iterator it = s.begin(); it != s.end(); ++it) {
ret += (*it);
}
cout << ret << endl;
}
int main() {
// freopen("input.txt","r",stdin);
solve();
} | [
"control_flow.loop.for.condition.change",
"control_flow.branch.if.condition.change"
] | 867,831 | 867,832 | u651636556 | cpp |
p03050 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#define _overload(a, b, c, d, ...) d
#define _rep1(X, A, Y) for (int(X) = (A); (X) <= (Y); ++(X))
#define _rep2(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rep(...) _overload(__VA_ARGS__, _rep1, _rep2)(__VA_ARGS__)
#define rrep(X, Y) for (int(X) = Y - 1; (X) >= 0; --(X))
#define all(X) (X).begin(), (X).end()
#define len(X) ((int)(X).size())
#define mod(n, m) (((n) % (m) + (m)) % m)
#define fi first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
const int INFINT = 1 << 30; // 1.07x10^ 9
const ll INFLL = 1LL << 60; // 1.15x10^18
const double EPS = 1e-10;
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
ll N;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> N;
ll ans = N - 1;
for (ll k = 2; k * k <= N; ++k) {
if (N % k == 0) {
ll mp1 = N / k;
if (k < mp1 - 1) {
ans += mp1 - 1;
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#define _overload(a, b, c, d, ...) d
#define _rep1(X, A, Y) for (int(X) = (A); (X) <= (Y); ++(X))
#define _rep2(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rep(...) _overload(__VA_ARGS__, _rep1, _rep2)(__VA_ARGS__)
#define rrep(X, Y) for (int(X) = Y - 1; (X) >= 0; --(X))
#define all(X) (X).begin(), (X).end()
#define len(X) ((int)(X).size())
#define mod(n, m) (((n) % (m) + (m)) % m)
#define fi first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
const int INFINT = 1 << 30; // 1.07x10^ 9
const ll INFLL = 1LL << 60; // 1.15x10^18
const double EPS = 1e-10;
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
ll N;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> N;
ll ans = 0;
for (ll k = 1; k * k <= N; ++k) {
if (N % k == 0) {
ll mp1 = N / k;
if (k < mp1 - 1) {
ans += mp1 - 1;
}
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 867,837 | 867,838 | u630941334 | cpp |
p03050 | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#include "ext/rope"
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); ++i)
#define pb push_back
#define sz size
#define f first
#define s second
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
vector<ll> factors(ll x) {
vector<ll> result;
ll i = 1;
while (i * i <= x) {
if (x % i == 0) {
result.pb(i);
if (x / i != i) {
result.pb(x / i);
}
}
i++;
}
return result;
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
vector<ll> fac = factors(n);
ll res = 0;
F0R(i, fac.sz()) {
if (fac[i] > sqrt(n) - 1) {
res += fac[i] - 1;
}
}
cout << res;
return 0;
} | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#include "ext/rope"
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); ++i)
#define pb push_back
#define sz size
#define f first
#define s second
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
vector<ll> factors(ll x) {
vector<ll> result;
ll i = 1;
while (i * i <= x) {
if (x % i == 0) {
result.pb(i);
if (x / i != i) {
result.pb(x / i);
}
}
i++;
}
return result;
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
vector<ll> fac = factors(n);
ll res = 0;
F0R(i, fac.sz()) {
if (fac[i] > sqrt(n) + 1) {
res += fac[i] - 1;
}
}
cout << res;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 867,845 | 867,846 | u712630284 | cpp |
p03050 | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#include "ext/rope"
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); ++i)
#define pb push_back
#define sz size
#define f first
#define s second
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
vector<ll> factors(ll x) {
vector<ll> result;
ll i = 1;
while (i * i <= x) {
if (x % i == 0) {
result.pb(i);
if (x / i != i) {
result.pb(x / i);
}
}
i++;
}
return result;
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
vector<ll> fac = factors(n);
ll res = 0;
F0R(i, fac.sz()) {
if (fac[i] > sqrt(n)) {
res += fac[i] - 1;
}
}
cout << res;
return 0;
} | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#include "ext/rope"
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); ++i)
#define pb push_back
#define sz size
#define f first
#define s second
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
vector<ll> factors(ll x) {
vector<ll> result;
ll i = 1;
while (i * i <= x) {
if (x % i == 0) {
result.pb(i);
if (x / i != i) {
result.pb(x / i);
}
}
i++;
}
return result;
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
vector<ll> fac = factors(n);
ll res = 0;
F0R(i, fac.sz()) {
if (fac[i] > sqrt(n) + 1) {
res += fac[i] - 1;
}
}
cout << res;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,847 | 867,846 | u712630284 | cpp |
p03050 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define f first
#define s second
#define inf 999999999999
#define N 500009
#define M (L + R) / 2
#define ll long long
#define pb push_back
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
ll n, ans;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i * i <= 50 * n; i++) {
if (i > n / i - 1)
break;
if (n % i == 0)
ans += n / i - 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define f first
#define s second
#define inf 999999999999
#define N 500009
#define M (L + R) / 2
#define ll long long
#define pb push_back
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
ll n, ans;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i * i <= 100 * n; i++) {
if (i >= (n / i - 1))
break;
if (n % i == 0)
ans += n / i - 1;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,852 | 867,853 | u866987395 | cpp |
p03050 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define f first
#define s second
#define inf 999999999999
#define N 500009
#define M (L + R) / 2
#define ll long long
#define pb push_back
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
ll n, ans;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i * i <= 2 * n; i++) {
if (i > n / i - 1)
break;
if (n % i == 0)
ans += n / i - 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define f first
#define s second
#define inf 999999999999
#define N 500009
#define M (L + R) / 2
#define ll long long
#define pb push_back
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
ll n, ans;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i * i <= 100 * n; i++) {
if (i >= (n / i - 1))
break;
if (n % i == 0)
ans += n / i - 1;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 867,854 | 867,853 | u866987395 | cpp |
p03049 | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y)-1; (X) >= 0; --(X))
#define all(X) (X).begin(), (X).end()
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define print(x) cout << x << endl
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
void solve(long long N, std::vector<std::string> s) {
ll ans = 0;
ll bStart = 0;
ll aEnd = 0;
ll bStartAEnd = 0;
for (auto str : s) {
ull last = str.size() - 1;
if (str[0] == 'B' && str[last] == 'A') {
bStartAEnd++;
} else {
if (str[0] == 'B') {
bStart++;
}
if (str[last] == 'A') {
aEnd++;
}
}
rep(i, last) {
if (str[i] == 'A' && str[i + 1] == 'B') {
ans++;
}
}
}
if (aEnd > 0 && bStartAEnd > 0) {
aEnd--;
ans += bStartAEnd;
if (bStart > 0) {
ans++;
bStart--;
}
ans += min(aEnd, bStart);
} else if (aEnd == 0) {
ans += bStartAEnd - 1;
if (bStart > 0) {
ans++;
}
} else {
ans += min(aEnd, bStart);
}
print(ans);
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<std::string> s(N);
for (int i = 0; i < N; i++) {
std::cin >> s[i];
}
solve(N, std::move(s));
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y)-1; (X) >= 0; --(X))
#define all(X) (X).begin(), (X).end()
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define print(x) cout << x << endl
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
void solve(long long N, std::vector<std::string> s) {
ll ans = 0;
ll bStart = 0;
ll aEnd = 0;
ll bStartAEnd = 0;
for (auto str : s) {
ull last = str.size() - 1;
if (str[0] == 'B' && str[last] == 'A') {
bStartAEnd++;
} else {
if (str[0] == 'B') {
bStart++;
}
if (str[last] == 'A') {
aEnd++;
}
}
rep(i, last) {
if (str[i] == 'A' && str[i + 1] == 'B') {
ans++;
}
}
}
if (aEnd > 0 && bStartAEnd > 0) {
aEnd--;
ans += bStartAEnd;
if (bStart > 0) {
ans++;
bStart--;
}
ans += min(aEnd, bStart);
} else if (aEnd == 0 && bStartAEnd > 0) {
ans += bStartAEnd - 1;
if (bStart > 0) {
ans++;
}
} else {
ans += min(aEnd, bStart);
}
print(ans);
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<std::string> s(N);
for (int i = 0; i < N; i++) {
std::cin >> s[i];
}
solve(N, std::move(s));
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,855 | 867,856 | u925940521 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
const int MOD = 1e9 + 7;
// 4近傍、8近傍
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
int main() {
int N;
cin >> N;
string s;
ll ans = 0;
ll same = 0;
ll aonly = 0;
ll bonly = 0;
for (int i = 0; i < N; i++) {
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
same++;
if (s[0] != 'B' && s[s.size() - 1] == 'A')
aonly++;
if (s[0] == 'B' && s[s.size() - 1] != 'A')
bonly++;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
if (aonly > 0 || bonly > 0) {
ans += same + min(aonly, bonly);
} else {
ans += same - 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
const int MOD = 1e9 + 7;
// 4近傍、8近傍
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
int main() {
int N;
cin >> N;
string s;
ll ans = 0;
ll same = 0;
ll aonly = 0;
ll bonly = 0;
for (int i = 0; i < N; i++) {
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
same++;
if (s[0] != 'B' && s[s.size() - 1] == 'A')
aonly++;
if (s[0] == 'B' && s[s.size() - 1] != 'A')
bonly++;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
if (aonly > 0 || bonly > 0) {
ans += same + min(aonly, bonly);
} else if (same > 0) {
ans += same - 1;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.add"
] | 867,857 | 867,858 | u063020782 | cpp |
p03049 | #include <bits/stdc++.h>
#define Rint register int
using namespace std;
char s[10004][11];
int n, ans, tmp, c1, c2, c3, len[10004];
int main() {
scanf("%d", &n);
for (Rint i = 1; i <= n; i++)
scanf("%s", s + i), len[i] = strlen(s[i]);
for (Rint i = 1; i <= n; i++)
for (Rint j = 0; j < len[i] - 1; j++)
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
++ans;
for (Rint i = 1; i <= n; i++)
if (s[i][0] == 'B' && s[i][len[i] - 1] == 'A')
++c1;
else if (s[i][0] == 'B')
++c2;
else if (s[i][len[i] - 1] == 'A')
++c3;
if (c2 && c3)
tmp = max(tmp, c1 + 1 + min(c2, c3));
tmp = max(tmp, min(c3 - 1, c2) + c1);
tmp = max(tmp, min(c2 - 1, c3) + c1);
if (c2 == 0 && c3 == 0)
tmp = max(tmp, c1 - 1);
printf("%d", ans + tmp);
} | #include <bits/stdc++.h>
#define Rint register int
using namespace std;
char s[10004][11];
int n, ans, tmp, c1, c2, c3, len[10004];
int main() {
scanf("%d", &n);
for (Rint i = 1; i <= n; i++)
scanf("%s", s + i), len[i] = strlen(s[i]);
for (Rint i = 1; i <= n; i++)
for (Rint j = 0; j < len[i] - 1; j++)
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
++ans;
for (Rint i = 1; i <= n; i++)
if (s[i][0] == 'B' && s[i][len[i] - 1] == 'A')
++c1;
else if (s[i][0] == 'B')
++c2;
else if (s[i][len[i] - 1] == 'A')
++c3;
if (c2 && c3)
tmp = max(tmp, c1 + 1 + min(c2 - 1, c3 - 1));
tmp = max(tmp, min(c3 - 1, c2) + c1);
tmp = max(tmp, min(c2 - 1, c3) + c1);
if (c2 == 0 && c3 == 0)
tmp = max(tmp, c1 - 1);
printf("%d", ans + tmp);
} | [
"assignment.change"
] | 867,861 | 867,862 | u680164084 | cpp |
p03049 | #include <bits/stdc++.h>
#define foreach(i, v) \
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i)
#define BETWEEN(a, x, b) (a <= x && x < b)
using namespace std;
typedef long long ll;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int a = 0;
int b = 0;
int ba = 0;
int res = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
res++;
}
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
ba++;
}
res += min(b, a);
if (b == a && ba == b)
res--;
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
#define foreach(i, v) \
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i)
#define BETWEEN(a, x, b) (a <= x && x < b)
using namespace std;
typedef long long ll;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int a = 0;
int b = 0;
int ba = 0;
ll res = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
res++;
}
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
ba++;
}
res += min(b, a);
if (b == a && ba == b && ba > 0)
res--;
cout << res << endl;
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change"
] | 867,863 | 867,864 | u440032761 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
string tmp;
int midab = 0, aend = 0, bstart = 0, baside = 0;
for (int i = 0; i < N; i++) {
cin >> tmp;
if (tmp[0] == 'B' && tmp[tmp.size() - 1] == 'A')
baside++;
else {
if (tmp[0] == 'B')
bstart++;
if (tmp[tmp.size() - 1] == 'A')
aend++;
}
for (int j = 0; j < tmp.size() - 1; j++) {
if (tmp[j] == 'A' && tmp[j + 1] == 'B')
midab++;
}
}
int merge = baside;
if (aend == 0 && bstart == 0)
merge--;
if (aend > 0 && bstart > 0)
merge += (1 + min(bstart - 1, aend - 1));
cout << midab + merge << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
string tmp;
int midab = 0, aend = 0, bstart = 0, baside = 0;
for (int i = 0; i < N; i++) {
cin >> tmp;
if (tmp[0] == 'B' && tmp[tmp.size() - 1] == 'A')
baside++;
else {
if (tmp[0] == 'B')
bstart++;
if (tmp[tmp.size() - 1] == 'A')
aend++;
}
for (int j = 0; j < tmp.size() - 1; j++) {
if (tmp[j] == 'A' && tmp[j + 1] == 'B')
midab++;
}
}
int merge = baside;
if (aend == 0 && bstart == 0 && baside > 0)
merge--;
if (aend > 0 && bstart > 0)
merge += (1 + min(bstart - 1, aend - 1));
cout << midab + merge << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,865 | 867,866 | u854831509 | cpp |
p03049 | #define _CRT_SECURE_NO_WARNINGS
/* include ***********************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* define *************************/
// for
#define REP(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define REPS(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; 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 FOR(i, s, n) \
for (int i = (int)(s), i##_len = (int)(n); i < i##_len; i++)
#define RFOR(i, s, n) \
for (int i = (int)(n)-1, i##_len = (int)(s); i >= i##_len; i--)
// printf
#define PRINTD(d) printf("%d\n", (d))
#define PRINTL(d) printf("%lld\n", (d))
// memset
#define m0(s) memset(s, 0, sizeof(s))
#define ml(s) memset(s, 63, sizeof(s))
#define fill(s, c) memset(s, c, sizeof(s))
#define INF 1e9
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int diff[4][2] = {
{0, -1},
{-1, 0},
{1, 0},
{0, 1},
};
//今回の変数
int n[1000][1000];
int v[1000][1000];
int Min(int a, int b) { return (a) < (b) ? (a) : (b); }
int Max(int a, int b) { return (a) > (b) ? (a) : (b); }
ll Minl(ll a, ll b) { return (a) < (b) ? (a) : (b); }
ll Maxl(ll a, ll b) { return (a) > (b) ? (a) : (b); }
int main() {
int n;
scanf("%d", &n);
int ans = 0;
int a = 0, b = 0, ab = 0;
REP(i, n) {
char s[11];
scanf("%s", s);
if (s[0] == 'B')
b++;
if (s[strlen(s) - 1] == 'A')
a++;
if (s[0] == 'B' && s[strlen(s) - 1] == 'A')
ab++;
REP(j, strlen(s) - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
ans += (Min(a, b));
if (a == b && a == ab)
ans--;
PRINTD(ans);
}
| #define _CRT_SECURE_NO_WARNINGS
/* include ***********************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* define *************************/
// for
#define REP(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define REPS(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; 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 FOR(i, s, n) \
for (int i = (int)(s), i##_len = (int)(n); i < i##_len; i++)
#define RFOR(i, s, n) \
for (int i = (int)(n)-1, i##_len = (int)(s); i >= i##_len; i--)
// printf
#define PRINTD(d) printf("%d\n", (d))
#define PRINTL(d) printf("%lld\n", (d))
// memset
#define m0(s) memset(s, 0, sizeof(s))
#define ml(s) memset(s, 63, sizeof(s))
#define fill(s, c) memset(s, c, sizeof(s))
#define INF 1e9
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int diff[4][2] = {
{0, -1},
{-1, 0},
{1, 0},
{0, 1},
};
//今回の変数
int n[1000][1000];
int v[1000][1000];
int Min(int a, int b) { return (a) < (b) ? (a) : (b); }
int Max(int a, int b) { return (a) > (b) ? (a) : (b); }
ll Minl(ll a, ll b) { return (a) < (b) ? (a) : (b); }
ll Maxl(ll a, ll b) { return (a) > (b) ? (a) : (b); }
int main() {
int n;
scanf("%d", &n);
int ans = 0;
int a = 0, b = 0, ab = 0;
REP(i, n) {
char s[11];
scanf("%s", s);
if (s[0] == 'B')
b++;
if (s[strlen(s) - 1] == 'A')
a++;
if (s[0] == 'B' && s[strlen(s) - 1] == 'A')
ab++;
REP(j, strlen(s) - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
ans += (Min(a, b));
if (a == b && a == ab && a != 0)
ans--;
PRINTD(ans);
}
| [
"control_flow.branch.if.condition.change"
] | 867,869 | 867,870 | u539339654 | cpp |
p03049 | #include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int n;
cin >> n;
int ae = 0, bs = 0, ct = 0, both = 0;
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
if (tmp[0] == 'B') {
bs++;
}
if (tmp[tmp.size() - 1] == 'A') {
ae++;
}
if (tmp[tmp.size() - 1] == 'A' && tmp[0] == 'B') {
both++;
}
for (int j = 0; j < tmp.size() - 1; j++) {
if (tmp[j] == 'A' && tmp[j + 1] == 'B') {
ct++;
}
}
}
if (ae == bs && ae == both) {
printf("%d\n", ct + min(ae, bs) - 1);
} else {
printf("%d\n", ct + min(ae, bs));
}
return 0;
} | #include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int n;
cin >> n;
int ae = 0, bs = 0, ct = 0, both = 0;
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
if (tmp[0] == 'B') {
bs++;
}
if (tmp[tmp.size() - 1] == 'A') {
ae++;
}
if (tmp[tmp.size() - 1] == 'A' && tmp[0] == 'B') {
both++;
}
for (int j = 0; j < tmp.size() - 1; j++) {
if (tmp[j] == 'A' && tmp[j + 1] == 'B') {
ct++;
}
}
}
if (ae == bs && ae == both && both != 0) {
printf("%d\n", ct + min(ae, bs) - 1);
} else {
printf("%d\n", ct + min(ae, bs));
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,871 | 867,872 | u553807330 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, sum = 0, a = 1;
int an = 0, bn = 0;
cin >> N;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
sum++;
}
}
if (s.at(0) == 'B' && s.at(s.size() - 1) != 'A') {
bn++;
a = 0;
}
if (s.at(s.size() - 1) == 'A' && s.at(0) != 'B') {
an++;
a = 0;
}
if (s.at(s.size() - 1) == 'A' && s.at(0) == 'B') {
an++;
bn++;
}
}
if (a == 0) {
cout << sum + min(an, bn) << endl;
} else {
if (sum + min(an, bn) == 0) {
cout << 0 << endl;
} else {
cout << sum + min(an, bn) - 1 << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, sum = 0, a = 1;
int an = 0, bn = 0;
cin >> N;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
sum++;
}
}
if (s.at(0) == 'B' && s.at(s.size() - 1) != 'A') {
bn++;
a = 0;
}
if (s.at(s.size() - 1) == 'A' && s.at(0) != 'B') {
an++;
a = 0;
}
if (s.at(s.size() - 1) == 'A' && s.at(0) == 'B') {
an++;
bn++;
}
}
if (a == 0) {
cout << sum + min(an, bn) << endl;
} else {
if (min(an, bn) == 0) {
cout << sum << endl;
} else {
cout << sum + min(an, bn) - 1 << endl;
}
}
} | [
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 867,873 | 867,874 | u501008235 | cpp |
p03049 | #include <bits/stdc++.h>
const int INF = 1e9, MOD = 1e9 + 7;
const long long LINF = 1e18;
using namespace std;
#define int long long
// template
// main
signed main() {
int N;
cin >> N;
std::vector<string> s(N);
for (int i = 0; i < N; i++)
cin >> s[i];
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
int a = 0;
int b = 0;
int sta = 0;
int goa = 0;
for (int i = 0; i < N; i++) {
if (s[i][0] == 'B')
b++;
if (s[i][s[i].size() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] != 'A')
sta++;
if (s[i][0] != 'B' && s[i][s[i].size() - 1] == 'A')
goa++;
}
int k = 0;
if (sta && goa)
cout << min(a, b) + ans << endl;
if (sta && goa == 0)
cout << a + ans << endl;
if (sta == 0 && goa)
cout << b + ans << endl;
if (sta == 0 && goa == 0)
cout << ans + a - 1 << endl;
}
| #include <bits/stdc++.h>
const int INF = 1e9, MOD = 1e9 + 7;
const long long LINF = 1e18;
using namespace std;
#define int long long
// template
// main
signed main() {
int N;
cin >> N;
std::vector<string> s(N);
for (int i = 0; i < N; i++)
cin >> s[i];
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
int a = 0;
int b = 0;
int sta = 0;
int goa = 0;
for (int i = 0; i < N; i++) {
if (s[i][0] == 'B')
b++;
if (s[i][s[i].size() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] != 'A')
sta++;
if (s[i][0] != 'B' && s[i][s[i].size() - 1] == 'A')
goa++;
}
int k = 0;
if (sta && goa)
cout << min(a, b) + ans << endl;
if (sta && goa == 0)
cout << a + ans << endl;
if (sta == 0 && goa)
cout << b + ans << endl;
if (sta == 0 && goa == 0)
cout << ans + max(0LL, a - 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 867,892 | 867,893 | u942774736 | cpp |
p03049 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int a = 0, b = 0, count = 0, t = 0;
for (int i = 0; i < n; i++) {
int k = s[i].size();
if (s[i].at(0) == 'B')
b++;
if (s[i].at(k - 1) == 'A')
a++;
if (s[i].at(0) == 'B' && s[i].at(k - 1) == 'A')
t++;
for (int j = 0; j < k - 1; j++) {
if (s[i].at(j) == 'A' && s[i].at(j + 1) == 'B') {
count++;
}
}
}
if (t == a && t == b)
count--;
cout << count + min(a, b) << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int a = 0, b = 0, count = 0, t = 0;
for (int i = 0; i < n; i++) {
int k = s[i].size();
if (s[i].at(0) == 'B')
b++;
if (s[i].at(k - 1) == 'A')
a++;
if (s[i].at(0) == 'B' && s[i].at(k - 1) == 'A')
t++;
for (int j = 0; j < k - 1; j++) {
if (s[i].at(j) == 'A' && s[i].at(j + 1) == 'B') {
count++;
}
}
}
if (t == a && t == b && t != 0)
count--;
cout << count + min(a, b) << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 867,894 | 867,895 | u179970156 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int ans = 0, cnta = 0, cntb = 0, cntab = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
cntab++;
break;
} else if (s[i][s[i].size() - 1] == 'A') {
cnta++;
break;
} else if (s[i][0] == 'B') {
cntb++;
break;
}
}
ans += max(0, cntab - 1);
if (cntab >= 1) {
if (cnta >= 1) {
ans++;
cnta--;
}
if (cntb >= 1) {
ans++;
cntb--;
}
}
ans += min(cnta, cntb);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int ans = 0, cnta = 0, cntb = 0, cntab = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
cntab++;
} else if (s[i][s[i].size() - 1] == 'A') {
cnta++;
} else if (s[i][0] == 'B') {
cntb++;
}
}
ans += max(0, cntab - 1);
if (cntab >= 1) {
if (cnta >= 1) {
ans++;
cnta--;
}
if (cntb >= 1) {
ans++;
cntb--;
}
}
ans += min(cnta, cntb);
cout << ans << endl;
return 0;
} | [] | 867,898 | 867,899 | u167161639 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c = 0, a = 0, b = 0, d = 0;
string s;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
for (j = 0; j < s.length() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
c++;
}
}
if (s[0] == 'B')
b++;
if (s[s.length() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
d++;
}
if (d == a && d == b) {
cout << c + d - 1;
} else {
cout << c + min(a, b);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c = 0, a = 0, b = 0, d = 0;
string s;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
for (j = 0; j < s.length() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
c++;
}
}
if (s[0] == 'B')
b++;
if (s[s.length() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
d++;
}
if (d == a && d == b && d != 0) {
cout << c + d - 1;
} else {
cout << c + min(a, b);
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,903 | 867,904 | u058348416 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
long long n, ans = 0, a = 0, b = 0, c = 0, A, B;
string s[200000];
cin >> n;
rep(i, n) cin >> s[i];
rep(i, n) rep(j, s[i].size() - 1) if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
rep(i, n) {
if (s[i][0] == 'B')
b++;
if (s[i][s[i].size() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
c++;
}
if (c > 0) {
A = a - c;
B = b - c;
c--;
if (a > 0)
c++, A--;
if (b > 0)
c++, B--;
cout << ans + min(A, B) + c;
} else
cout << ans + min(a, b);
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
long long n, ans = 0, a = 0, b = 0, c = 0, A, B;
string s[200000];
cin >> n;
rep(i, n) cin >> s[i];
rep(i, n) rep(j, s[i].size() - 1) if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
rep(i, n) {
if (s[i][0] == 'B')
b++;
if (s[i][s[i].size() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
c++;
}
if (c > 0) {
A = a - c;
B = b - c;
c--;
if (A > 0)
c++, A--;
if (B > 0)
c++, B--;
cout << ans + min(A, B) + c;
} else
cout << ans + min(a, b);
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 867,905 | 867,906 | u441296840 | cpp |
p03049 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef vector<vector<int>> v2int;
typedef vector<ll> vll;
typedef vector<vector<ll>> v2ll;
typedef list<int> liint;
typedef pair<int, int> pint;
const int INF = int(2e9);
const ll LINF = ll(2e9) * ll(2e9);
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
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; }
int main() {
int N;
cin >> N;
vector<string> S(N);
int count_AB = 0;
int tail_A = 0;
int head_B = 0;
int hB_tA = 0;
rep(i, N) {
cin >> S[i];
auto s = S[i];
if (s[0] == 'B' && s[s.size() - 1] == 'A')
hB_tA++;
else if (s[0] == 'B')
head_B++;
else if (s[s.size() - 1] == 'A')
tail_A++;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B') {
count_AB++;
}
}
}
if (hB_tA > 0)
count_AB += (hB_tA - 1);
hB_tA = 1;
int triple = min(min(hB_tA, tail_A), head_B);
count_AB += (triple * 2);
head_B -= triple;
tail_A -= triple;
hB_tA -= triple;
if (hB_tA == 0)
count_AB += min(tail_A, head_B);
else if (tail_A == 0)
count_AB += min(hB_tA, head_B);
else if (head_B == 0)
count_AB += min(tail_A, hB_tA);
cout << count_AB << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef vector<vector<int>> v2int;
typedef vector<ll> vll;
typedef vector<vector<ll>> v2ll;
typedef list<int> liint;
typedef pair<int, int> pint;
const int INF = int(2e9);
const ll LINF = ll(2e9) * ll(2e9);
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
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; }
int main() {
int N;
cin >> N;
vector<string> S(N);
int count_AB = 0;
int tail_A = 0;
int head_B = 0;
int hB_tA = 0;
rep(i, N) {
cin >> S[i];
auto s = S[i];
if (s[0] == 'B' && s[s.size() - 1] == 'A')
hB_tA++;
else if (s[0] == 'B')
head_B++;
else if (s[s.size() - 1] == 'A')
tail_A++;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B') {
count_AB++;
}
}
}
if (hB_tA > 0) {
count_AB += (hB_tA - 1);
hB_tA = 1;
}
int triple = min(min(hB_tA, tail_A), head_B);
count_AB += (triple * 2);
head_B -= triple;
tail_A -= triple;
hB_tA -= triple;
if (hB_tA == 0)
count_AB += min(tail_A, head_B);
else if (tail_A == 0)
count_AB += min(hB_tA, head_B);
else if (head_B == 0)
count_AB += min(tail_A, hB_tA);
cout << count_AB << endl;
return 0;
} | [] | 867,911 | 867,912 | u391331433 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
int A = 0, B = 0, AB = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 1; j < s.size(); j++) {
if (s[j - 1] == 'A' && s[j] == 'B') {
ans++;
}
}
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
AB++;
} else if (s[0] == 'B') {
B++;
} else if (s[s.size() - 1] == 'A') {
A++;
}
}
// cout << A << " " << B << " " << AB << " " << ans << endl;
if (AB > 1) {
ans += AB - 1;
}
if (A > 0) {
ans++;
A--;
}
if (B > 0) {
ans++;
B--;
}
ans += min(A, B);
/* ans += min(A, B);
if (A != B) {
ans += min(abs(A-B), AB);
AB -= abs(A-B);
}
cout << ans << endl;
if (AB > 0) {
ans += AB/2;
} */
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
int A = 0, B = 0, AB = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 1; j < s.size(); j++) {
if (s[j - 1] == 'A' && s[j] == 'B') {
ans++;
}
}
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
AB++;
} else if (s[0] == 'B') {
B++;
} else if (s[s.size() - 1] == 'A') {
A++;
}
}
// cout << A << " " << B << " " << AB << " " << ans << endl;
if (AB > 0) {
ans += AB - 1;
if (A > 0) {
ans++;
A--;
}
if (B > 0) {
ans++;
B--;
}
}
ans += min(A, B);
/* ans += min(A, B);
if (A != B) {
ans += min(abs(A-B), AB);
AB -= abs(A-B);
}
cout << ans << endl;
if (AB > 0) {
ans += AB/2;
} */
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 867,913 | 867,914 | u905270643 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#ifdef _DEBUG
#define DMP(x) cerr << #x << ": " << x << "\n"
#else
#define DMP(x) ((void)0)
#endif
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
typedef long long lint;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++)
cin >> s[i];
int alast = 0, bfirst = 0, both = 0, ans = 0;
for (int i = 0; i < N; i++) {
if (s[i][0] == 'B')
bfirst++;
if (s[i].back() == 'A')
alast++;
if (s[i][0] == 'B' && s[i].back() == 'A')
both++;
for (int j = 1; j < s[i].length(); j++) {
if (s[i][j] == 'B' && s[i][j - 1] == 'A')
ans++;
}
}
cout << ans + min(alast, bfirst) + min(0, max(alast, bfirst) - both - 1);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#ifdef _DEBUG
#define DMP(x) cerr << #x << ": " << x << "\n"
#else
#define DMP(x) ((void)0)
#endif
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
typedef long long lint;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++)
cin >> s[i];
int alast = 0, bfirst = 0, both = 0, ans = 0;
for (int i = 0; i < N; i++) {
if (s[i][0] == 'B')
bfirst++;
if (s[i].back() == 'A')
alast++;
if (s[i][0] == 'B' && s[i].back() == 'A')
both++;
for (int j = 1; j < s[i].length(); j++) {
if (s[i][j] == 'B' && s[i][j - 1] == 'A')
ans++;
}
}
cout << ans + min(alast, bfirst) +
min(0, max(max(alast, bfirst), 1) - both - 1);
return 0;
} | [
"call.add",
"call.arguments.add"
] | 867,915 | 867,916 | u532573979 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; i++) {
cin >> S[i];
}
int ans = 0, A = 0, B = 0, AB = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j + 1 < (int)S[i].size(); j++) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
ans++;
}
if (S[i][0] == 'B')
B++;
if (S[i][(int)S[i].size() - 1] == 'A')
A++;
if (S[i][0] == 'B' && S[i][(int)S[i].size() - 1] == 'A')
AB++;
}
ans += min(A, B);
if (A == AB && B == AB)
ans--;
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; i++) {
cin >> S[i];
}
int ans = 0, A = 0, B = 0, AB = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j + 1 < (int)S[i].size(); j++) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
ans++;
}
if (S[i][0] == 'B')
B++;
if (S[i][(int)S[i].size() - 1] == 'A')
A++;
if (S[i][0] == 'B' && S[i][(int)S[i].size() - 1] == 'A')
AB++;
}
ans += min(A, B);
if (A == AB && B == AB && AB)
ans--;
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 867,919 | 867,920 | u650243369 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int ans = 0;
int cntA = 0;
int cntB = 0;
int same = 0;
for (int i = 0; i < N; i++) {
string str = s[i];
for (int j = 1; j < (int)str.size(); j++) {
if (str[j - 1] == 'A' && str[j] == 'B') {
ans++;
}
}
if (str[0] == 'B') {
cntB++;
}
if (str[(int)str.size() - 1] == 'A') {
cntA++;
}
if (str[0] == 'B' && str[(int)str.size() - 1] == 'A') {
same++;
}
}
if (cntA == N && cntB == N) {
ans += (N - 1);
} else if (cntA == cntB && cntA == same) {
ans += (cntA - 1);
} else {
ans += min(cntA, cntB);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int ans = 0;
int cntA = 0;
int cntB = 0;
int same = 0;
for (int i = 0; i < N; i++) {
string str = s[i];
for (int j = 1; j < (int)str.size(); j++) {
if (str[j - 1] == 'A' && str[j] == 'B') {
ans++;
}
}
if (str[0] == 'B') {
cntB++;
}
if (str[(int)str.size() - 1] == 'A') {
cntA++;
}
if (str[0] == 'B' && str[(int)str.size() - 1] == 'A') {
same++;
}
}
/*if(same > 0){
ans += (same - 1);
}
if(same >= 1 && cntA > 0){
ans++;
cntA--;
}
if(same >= 1 && cntB > 0){
ans++;
cntB--;
}*/
// ans += min(cntA, cntB);
if (cntA == N && cntB == N) {
ans += (N - 1);
} else if (same >= 1 && cntA == cntB && cntA == same) {
ans += (cntA - 1);
} else {
ans += min(cntA, cntB);
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,921 | 867,922 | u048945791 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define FOR(x, to) for (x = 0; x < (to); x++)
int main() {
int N, i, k;
vector<string> s;
cin >> N;
s.resize(N);
FOR(i, N)
cin >> s[i];
int count = 0, acount = 0, bcount = 0, abcount = 0;
bool flag_b;
FOR(i, N) {
flag_b = false;
if (s[i][0] == 'B') {
bcount++;
flag_b = true;
}
if (s[i][s[i].size() - 1] == 'A') {
acount++;
if (flag_b)
abcount++;
}
FOR(k, s[i].size()) {
if (k + 1 < s[i].size() && s[i][k] == 'A' && s[i][k + 1] == 'B')
count++;
}
}
if (abcount == acount && abcount == bcount)
cout << count + abcount - 1 << endl;
else
cout << count + min(acount, bcount) << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define FOR(x, to) for (x = 0; x < (to); x++)
int main() {
int N, i, k;
vector<string> s;
cin >> N;
s.resize(N);
FOR(i, N)
cin >> s[i];
int count = 0, acount = 0, bcount = 0, abcount = 0;
bool flag_b;
FOR(i, N) {
flag_b = false;
if (s[i][0] == 'B') {
bcount++;
flag_b = true;
}
if (s[i][s[i].size() - 1] == 'A') {
acount++;
if (flag_b)
abcount++;
}
FOR(k, s[i].size()) {
if (k + 1 < s[i].size() && s[i][k] == 'A' && s[i][k + 1] == 'B')
count++;
}
}
if (abcount > 0 && abcount == acount && abcount == bcount)
cout << count + abcount - 1 << endl;
else
cout << count + min(acount, bcount) << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,923 | 867,924 | u225891650 | cpp |
p03049 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
// int X[100000], Y[100000];
//
// void solve() {
// int P, Q, x, y;
// char d;
// cin>>P>>Q;
// memset(X, 0, sizeof(X));
// memset(Y, 0, sizeof(Y));
// for (int i=0; i<P; i++) {
// cin>>x>>y>>d;
// if (d == 'N') for (int j= y+1; j<=Q; j++) Y[j]++;
// if (d == 'S') for (int j= 0; j<y; j++) Y[j]++;
// if (d == 'E') for (int j= x+1; x<=Q; j++) X[j]++;
// if (d == 'W') for (int j= 0; j<x; j++) X[j]++;
// }
// int ans = 0;
// for (int i=0; i<=Q; i++) {
// if (X[i])
// }
//
//}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, a = 0, b = 0, ba = 0, ans = 0;
string s;
for (cin >> n; n; n--) {
cin >> s;
for (int i = 0; i + 1 < s.length(); i++) {
if (s.substr(i, 2) == "AB")
ans++;
}
if (s[0] == 'B')
b++;
if (s[s.length() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
ba++;
}
if (a == ba && b == ba)
ans += a - 1;
else
ans += min(a, b);
cout << ans << endl;
// int T;
// cin>>T;
// for (int t=1; t<=T; t++) {
// cout<<"Case #"<<t<<": ";
// solve();
// }
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
// int X[100000], Y[100000];
//
// void solve() {
// int P, Q, x, y;
// char d;
// cin>>P>>Q;
// memset(X, 0, sizeof(X));
// memset(Y, 0, sizeof(Y));
// for (int i=0; i<P; i++) {
// cin>>x>>y>>d;
// if (d == 'N') for (int j= y+1; j<=Q; j++) Y[j]++;
// if (d == 'S') for (int j= 0; j<y; j++) Y[j]++;
// if (d == 'E') for (int j= x+1; x<=Q; j++) X[j]++;
// if (d == 'W') for (int j= 0; j<x; j++) X[j]++;
// }
// int ans = 0;
// for (int i=0; i<=Q; i++) {
// if (X[i])
// }
//
//}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, a = 0, b = 0, ba = 0, ans = 0;
string s;
for (cin >> n; n; n--) {
cin >> s;
for (int i = 0; i + 1 < s.length(); i++) {
if (s.substr(i, 2) == "AB")
ans++;
}
if (s[0] == 'B')
b++;
if (s[s.length() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
ba++;
}
if (a && a == ba && b == ba)
ans += a - 1;
else
ans += min(a, b);
cout << ans << endl;
// int T;
// cin>>T;
// for (int t=1; t<=T; t++) {
// cout<<"Case #"<<t<<": ";
// solve();
// }
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,925 | 867,926 | u111434987 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll a = 0, b = 0, ans = 0, m = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 1; j < s.size(); j++) {
if (s[j - 1] == 'A' && s[j] == 'B')
ans++;
}
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
m++;
}
ll mm = min(a, b);
if (mm == a && mm == b && mm == m)
ans += mm - 1;
else
ans += mm;
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll a = 0, b = 0, ans = 0, m = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 1; j < s.size(); j++) {
if (s[j - 1] == 'A' && s[j] == 'B')
ans++;
}
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
m++;
}
ll mm = min(a, b);
if (mm == a && mm == b && mm == m && a != 0)
ans += mm - 1;
else
ans += mm;
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 867,937 | 867,938 | u012298376 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
string str;
int count = 0;
int count_b_a = 0;
int count_start_b = 0;
int count_end_a = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str;
if (str[0] == 'B' && str[str.length() - 1] == 'A') {
count_b_a++;
} else if (str[0] == 'B') {
count_start_b++;
} else if (str[str.length() - 1] == 'A') {
count_end_a++;
}
for (int j = 0; j < str.length() - 2; j++) {
if (str.substr(j, 2) == "AB") {
count++;
}
}
}
while (1) {
if (count_b_a >= 2) {
count_b_a--;
count++;
} else if (count_b_a >= 1 && count_end_a >= 1) {
count_b_a--;
count++;
} else if (count_b_a >= 1 && count_start_b >= 1) {
count_start_b--;
count++;
} else if (count_end_a >= 1 && count_start_b >= 1) {
count_end_a--;
count_start_b--;
count++;
} else {
break;
}
}
cout << count << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
string str;
int count = 0;
int count_b_a = 0;
int count_start_b = 0;
int count_end_a = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str;
if (str[0] == 'B' && str[str.length() - 1] == 'A') {
count_b_a++;
} else if (str[0] == 'B') {
count_start_b++;
} else if (str[str.length() - 1] == 'A') {
count_end_a++;
}
for (int j = 0; j <= str.length() - 2; j++) {
if (str.substr(j, 2) == "AB") {
count++;
}
}
}
while (1) {
if (count_b_a >= 2) {
count_b_a--;
count++;
} else if (count_b_a >= 1 && count_end_a >= 1) {
count_b_a--;
count++;
} else if (count_b_a >= 1 && count_start_b >= 1) {
count_b_a--;
count++;
} else if (count_end_a >= 1 && count_start_b >= 1) {
count_end_a--;
count_start_b--;
count++;
} else {
break;
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change"
] | 867,941 | 867,940 | u137523493 | cpp |
p03049 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
#define ll long long
#define pii pair<int, int>
#define ull unsigned ll
#define f first
#define s second
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n - 1); i >= 0; i--)
#define ALL(x) x.begin(), x.end()
#define SZ(x) x.size()
#define MNTO(a, b) a = min(a, (__typeof__(a))(b))
#define MXTO(a, b) a = max(a, (__typeof__(a))(b))
#define pb push_back
#define debug(x) cerr << #x << " is " << x << endl
using namespace std;
// #define int ll
const int maxn = 1e5 + 5;
const int iinf = 1 << 29;
const ll inf = 1ll << 60;
const ll mod = 1e9 + 7;
void GG() {
cout << "No\n";
exit(0);
}
main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int re = 0;
int BA = 0, B = 0, A = 0;
REP(i, n) {
string s;
cin >> s;
REP(j, s.length() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
re++;
}
bool b = s[0] == 'B', a = s[s.length() - 1] == 'A';
if (b && a)
BA++;
else if (b)
B++;
else if (a)
A++;
}
if (A > 0 || B > 0) {
re += BA;
} else {
re += BA - 1;
}
int x = min(B, A);
A -= x;
B -= x;
re += x;
if (A < B)
swap(A, B);
cout << re << endl;
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
#define ll long long
#define pii pair<int, int>
#define ull unsigned ll
#define f first
#define s second
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n - 1); i >= 0; i--)
#define ALL(x) x.begin(), x.end()
#define SZ(x) x.size()
#define MNTO(a, b) a = min(a, (__typeof__(a))(b))
#define MXTO(a, b) a = max(a, (__typeof__(a))(b))
#define pb push_back
#define debug(x) cerr << #x << " is " << x << endl
using namespace std;
// #define int ll
const int maxn = 1e5 + 5;
const int iinf = 1 << 29;
const ll inf = 1ll << 60;
const ll mod = 1e9 + 7;
void GG() {
cout << "No\n";
exit(0);
}
main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int re = 0;
int BA = 0, B = 0, A = 0;
REP(i, n) {
string s;
cin >> s;
REP(j, s.length() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
re++;
}
bool b = s[0] == 'B', a = s[s.length() - 1] == 'A';
if (b && a)
BA++;
else if (b)
B++;
else if (a)
A++;
}
// debug(BA);
if (A > 0 || B > 0) {
re += BA;
} else {
if (BA)
re += BA - 1;
}
int x = min(B, A);
A -= x;
B -= x;
re += x;
if (A < B)
swap(A, B);
cout << re << endl;
} | [
"control_flow.branch.if.add"
] | 867,944 | 867,945 | u796538370 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string buf;
int num;
cin >> num;
int ans = 0, leftNum = 0, rightNum = 0, tatNum = 0;
for (int i = 0; i < num; i++) {
cin >> buf;
for (int i = 0; i < (int)buf.size() - 1; i++)
if (buf[i] == 'A' && buf[i + 1] == 'B')
ans++;
if (buf[0] == 'B')
rightNum++;
if (buf[buf.size() - 1] == 'A')
leftNum++;
if (buf[0] == 'B' || buf[buf.size() - 1] == 'A')
tatNum++;
}
if (leftNum == tatNum)
leftNum--;
if (rightNum == tatNum)
rightNum--;
cout << ans + min(leftNum, rightNum) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string buf;
int num;
cin >> num;
int ans = 0, leftNum = 0, rightNum = 0, tatNum = 0;
for (int i = 0; i < num; i++) {
cin >> buf;
for (int i = 0; i < (int)buf.size() - 1; i++)
if (buf[i] == 'A' && buf[i + 1] == 'B')
ans++;
if (buf[0] == 'B')
rightNum++;
if (buf[buf.size() - 1] == 'A')
leftNum++;
if (buf[0] == 'B' || buf[buf.size() - 1] == 'A')
tatNum++;
}
if (leftNum == tatNum)
leftNum--;
if (rightNum == tatNum)
rightNum--;
cout << ans + max(0, min(leftNum, rightNum)) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 867,946 | 867,947 | u567383713 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, a = 0, b = 0, c = 0, t = 0, n, m;
string temp;
cin >> n;
for (i = 0; i < n; i++) {
cin >> temp;
m = temp.size();
for (j = 0; j < m; j++) {
if (temp[j] == 'A' && temp[j + 1] == 'B')
t++;
}
if (temp[0] == 'B') {
if (temp[j - 1] == 'A')
c++;
else
b++;
}
if (temp[j - 1] == 'A')
a++;
}
if (a && b)
printf("%d", c + min(a, b) + t);
else
printf("%d", max(c - 1 + (a || b), 0) + t);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, a = 0, b = 0, c = 0, t = 0, n, m;
string temp;
cin >> n;
for (i = 0; i < n; i++) {
cin >> temp;
m = temp.size();
for (j = 0; j < m; j++) {
if (temp[j] == 'A' && temp[j + 1] == 'B')
t++;
}
if (temp[0] == 'B') {
if (temp[j - 1] == 'A')
c++;
else
b++;
} else if (temp[j - 1] == 'A')
a++;
}
if (a && b)
printf("%d", c + min(a, b) + t);
else
printf("%d", max(c - 1 + (a || b), 0) + t);
return 0;
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 867,950 | 867,951 | u565087015 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
int cnt = 0;
int cnta = 0;
int cntb = 0;
int cntab = 0;
int cntaa = 0;
int cntbb = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int i = 0; i < n; i++) {
int m = v[i].size() - 1;
for (int j = 0; j < v[i].size() - 1; j++) {
if (v[i].substr(j, 2) == "AB")
cnt++;
}
if (v[i].front() == 'B')
cntb++;
if (v[i].back() == 'A')
cnta++;
if (v[i].front() == 'B' && v[i].back() == 'A')
cntab++;
}
// cout << cnt << " " << cntab << endl;
cnt += cntab - 1;
cnta -= cntab;
cntb -= cntab;
// cout << cnt << " " << cnta << " " << cntb << endl;
if (cnta)
cnta--, cnt++;
if (cntb)
cntb--, cnt++;
cnt += min(cnta, cntb);
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
int cnt = 0;
int cnta = 0;
int cntb = 0;
int cntab = 0;
int cntaa = 0;
int cntbb = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int i = 0; i < n; i++) {
int m = v[i].size() - 1;
for (int j = 0; j < v[i].size() - 1; j++) {
if (v[i].substr(j, 2) == "AB")
cnt++;
}
if (v[i].front() == 'B')
cntb++;
if (v[i].back() == 'A')
cnta++;
if (v[i].front() == 'B' && v[i].back() == 'A')
cntab++;
}
// cout << cnt << " " << cntab << endl;
if (cntab) {
cnt += cntab - 1;
cnta -= cntab;
cntb -= cntab;
if (cnta)
cnta--, cnt++;
if (cntb)
cntb--, cnt++;
}
// cout << cnt << " " << cnta << " " << cntb << endl;
cnt += min(cnta, cntb);
cout << cnt << endl;
return 0;
} | [
"control_flow.branch.if.add"
] | 867,954 | 867,955 | u521364030 | cpp |
p03049 | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int main() {
int n, ans = 0, ca = 0, cb = 0, score[10000], l, a = 0, b = 0, c = 0;
char s[10000][11];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
l = strlen(s[i]);
if (s[i][0] == 'B') {
b++;
}
if (s[i][l - 1] == 'A') {
a++;
}
if (s[i][0] == 'B' && s[i][l - 1] == 'A') {
c++;
}
for (int j = 0; j < l; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
}
if (a == c && b == c && c) {
printf("%d\n", ans + c - 1);
}
printf("%d\n", ans + min(a, b));
} | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int main() {
int n, ans = 0, ca = 0, cb = 0, score[10000], l, a = 0, b = 0, c = 0;
char s[10000][11];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
l = strlen(s[i]);
if (s[i][0] == 'B') {
b++;
}
if (s[i][l - 1] == 'A') {
a++;
}
if (s[i][0] == 'B' && s[i][l - 1] == 'A') {
c++;
}
for (int j = 0; j < l; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
}
if (a == c && b == c && c) {
printf("%d\n", ans + c - 1);
} else {
printf("%d\n", ans + min(a, b));
}
}
| [
"control_flow.branch.else.add"
] | 867,956 | 867,957 | u855429581 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
int a = 0, b = 0, ab = 0, b_a = 0;
for (int i = 0; i < N; ++i) {
string s;
cin >> s;
if (s[0] == 'B')
++b;
if (s.back() == 'A')
++a;
if (s[0] == 'B' && s.back() == 'A')
++b_a;
for (int i = 0; i + 1 < s.size(); ++i) {
if (s.substr(i, 2) == "AB")
++ab;
}
}
if (a == b_a && b == b_a)
cout << ab + b_a - 1 << endl;
else
cout << ab + min(a, b) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
int a = 0, b = 0, ab = 0, b_a = 0;
for (int i = 0; i < N; ++i) {
string s;
cin >> s;
if (s[0] == 'B')
++b;
if (s.back() == 'A')
++a;
if (s[0] == 'B' && s.back() == 'A')
++b_a;
for (int i = 0; i + 1 < s.size(); ++i) {
if (s.substr(i, 2) == "AB")
++ab;
}
}
if (a == b_a && b == b_a && b_a > 0)
cout << ab + b_a - 1 << endl;
else
cout << ab + min(a, b) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,958 | 867,959 | u297367372 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 200000
int main() {
char a[N][20];
f(i, N) { f(j, 20) a[i][j] = 0; }
int n, k;
int x, y, z, w;
long long s, ans;
bool v = true;
ans = 0;
scanf("%d", &n);
f(i, n) scanf("%s", a[i]);
x = 0;
y = 0;
z = 0;
f(i, n) {
k = strlen(a[i]);
if (a[i][0] == 'B' && a[i][k - 1] == 'A')
z++;
else if (a[i][0] == 'B')
x++;
else if (a[i][k - 1] == 'A')
y++;
f(j, k - 1) {
if (a[i][j] == 'A' && a[i][j + 1] == 'B')
ans++;
}
}
if (x == 0 && y == 0)
ans += (z - 1);
else
ans += min(x + z, y + z);
printf("%lld\n", ans);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 200000
int main() {
char a[N][20];
f(i, N) { f(j, 20) a[i][j] = 0; }
int n, k;
int x, y, z, w;
long long s, ans;
bool v = true;
ans = 0;
scanf("%d", &n);
f(i, n) scanf("%s", a[i]);
x = 0;
y = 0;
z = 0;
f(i, n) {
k = strlen(a[i]);
if (a[i][0] == 'B' && a[i][k - 1] == 'A')
z++;
else if (a[i][0] == 'B')
x++;
else if (a[i][k - 1] == 'A')
y++;
f(j, k - 1) {
if (a[i][j] == 'A' && a[i][j + 1] == 'B')
ans++;
}
}
if (x == 0 && y == 0 && z > 0)
ans += (z - 1);
else
ans += min(x + z, y + z);
printf("%lld\n", ans);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,960 | 867,961 | u527748649 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
//#define int long long
using ll = long long;
const int INF = 1 << 29;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#ifdef LOCAL_ENV
#define debug(var) std::cout << #var " = " << var << std::endl
#else
#define debug(var)
#endif
#define p(var) std::cout << var << std::endl
#define PI (acos(-1))
#define rep(i, n) for (int i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (int i = 1, i##_length = (n); i <= i##_length; ++i)
#define all(a) (a).begin(), (a).end()
#define pb push_back
inline bool isnatural(double a) { return a >= 0 && ceil(a) == floor(a); }
template <typename T> inline T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (int i = 0, len = v.size(); i < len; ++i) {
s << v[i];
if (i < len - 1)
s << "\t";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
for (int i = 0, len = vv.size(); i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr) {
s << "\t" << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
/*-----8<-----8<-----*/
signed main() {
int N;
cin >> N;
int abcount = 0, beginb = 0, enda = 0, aandb = 0;
vector<string> a(N, "");
rep(i, N) {
cin >> a[i];
if (a[i][0] == 'B')
beginb++;
if (a[i][a[i].size() - 1] == 'A')
enda++;
if (a[i][0] == 'B' && a[i][a[i].size() - 1] == 'A')
aandb++;
rep(j, a[i].size() - 1) {
if (a[i][j] == 'A' && a[i][j + 1] == 'B')
abcount++;
}
}
if (N > 1) {
abcount += min(beginb, enda);
if (beginb == enda && beginb == aandb)
abcount--;
}
p(abcount);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#define int long long
using ll = long long;
const int INF = 1 << 29;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#ifdef LOCAL_ENV
#define debug(var) std::cout << #var " = " << var << std::endl
#else
#define debug(var)
#endif
#define p(var) std::cout << var << std::endl
#define PI (acos(-1))
#define rep(i, n) for (int i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (int i = 1, i##_length = (n); i <= i##_length; ++i)
#define all(a) (a).begin(), (a).end()
#define pb push_back
inline bool isnatural(double a) { return a >= 0 && ceil(a) == floor(a); }
template <typename T> inline T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (int i = 0, len = v.size(); i < len; ++i) {
s << v[i];
if (i < len - 1)
s << "\t";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
for (int i = 0, len = vv.size(); i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr) {
s << "\t" << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
/*-----8<-----8<-----*/
signed main() {
int N;
cin >> N;
int abcount = 0, beginb = 0, enda = 0, aandb = 0;
vector<string> a(N, "");
rep(i, N) {
cin >> a[i];
if (a[i][0] == 'B')
beginb++;
if (a[i][a[i].size() - 1] == 'A')
enda++;
if (a[i][0] == 'B' && a[i][a[i].size() - 1] == 'A')
aandb++;
rep(j, a[i].size() - 1) {
if (a[i][j] == 'A' && a[i][j + 1] == 'B')
abcount++;
}
}
if (N > 1) {
abcount += min(beginb, enda);
if (aandb > 0 && beginb == enda && beginb == aandb)
abcount--;
}
p(abcount);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 867,964 | 867,965 | u061071198 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
//#define T_ int
using namespace std;
// struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_
// y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int
// i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}}; struct seg{struct treedot{int
// l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void
// pushdown(int id){if
// (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void
// pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int
// l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r)
// c[id].sum=0;else{int
// mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void
// update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if
// (le<=c[id].l&&c[id].r<=ri)
// c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_
// query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if
// (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_
// ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return
// ans;}}; struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void
// add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for
// (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_
// s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return
// s;}T_ query(int x,int y,int xx,int yy){return
// query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
int n, m, i, j, c1, c2, c3, s;
string st, sss;
int main() {
scanf("%d", &n);
fz1(i, n) {
rdst(st, 18);
if (st[0] == 'B' && st[st.length() - 1] == 'A')
c3++;
else if (st[0] == 'B')
c2++;
else if (st[st.length() - 1] == 'A')
c1++;
for (j = 1; j < st.length(); j++)
if (st[j - 1] == 'A' && st[j] == 'B')
s++;
}
if (!(c1 + c2))
cout << max(0, s + c3 - 1) << endl;
else
cout << s + min(c1, c2) + c3 << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
//#define T_ int
using namespace std;
// struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_
// y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int
// i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}}; struct seg{struct treedot{int
// l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void
// pushdown(int id){if
// (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void
// pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int
// l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r)
// c[id].sum=0;else{int
// mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void
// update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if
// (le<=c[id].l&&c[id].r<=ri)
// c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_
// query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if
// (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_
// ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return
// ans;}}; struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void
// add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for
// (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_
// s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return
// s;}T_ query(int x,int y,int xx,int yy){return
// query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
int n, m, i, j, c1, c2, c3, s;
string st, sss;
int main() {
scanf("%d", &n);
fz1(i, n) {
rdst(st, 18);
if (st[0] == 'B' && st[st.length() - 1] == 'A')
c3++;
else if (st[0] == 'B')
c2++;
else if (st[st.length() - 1] == 'A')
c1++;
for (j = 1; j < st.length(); j++)
if (st[j - 1] == 'A' && st[j] == 'B')
s++;
}
if (!(c1 + c2))
cout << s + max(0, c3 - 1) << endl;
else
cout << s + min(c1, c2) + c3 << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 867,975 | 867,976 | u083440680 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
//#define T_ int
using namespace std;
// struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_
// y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int
// i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}}; struct seg{struct treedot{int
// l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void
// pushdown(int id){if
// (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void
// pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int
// l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r)
// c[id].sum=0;else{int
// mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void
// update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if
// (le<=c[id].l&&c[id].r<=ri)
// c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_
// query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if
// (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_
// ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return
// ans;}}; struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void
// add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for
// (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_
// s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return
// s;}T_ query(int x,int y,int xx,int yy){return
// query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
int n, m, i, j, c1, c2, c3, s;
string st, sss;
int main() {
scanf("%d", &n);
fz1(i, n) {
rdst(st, 18);
if (st[0] == 'B' && st[st.length() - 1] == 'A')
c3++;
else if (st[0] == 'B')
c2++;
else if (st[st.length() - 1] == 'A')
c1++;
for (j = 1; j < st.length(); j++)
if (st[j - 1] == 'A' && st[j] == 'B')
s++;
}
if (!(c1 + c2))
cout << s + c3 - 1 << endl;
else
cout << s + min(c1, c2) + c3 << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
//#define T_ int
using namespace std;
// struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_
// y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int
// i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}}; struct seg{struct treedot{int
// l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void
// pushdown(int id){if
// (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void
// pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int
// l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r)
// c[id].sum=0;else{int
// mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void
// update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if
// (le<=c[id].l&&c[id].r<=ri)
// c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_
// query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if
// (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_
// ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return
// ans;}}; struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void
// add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for
// (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_
// s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return
// s;}T_ query(int x,int y,int xx,int yy){return
// query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
int n, m, i, j, c1, c2, c3, s;
string st, sss;
int main() {
scanf("%d", &n);
fz1(i, n) {
rdst(st, 18);
if (st[0] == 'B' && st[st.length() - 1] == 'A')
c3++;
else if (st[0] == 'B')
c2++;
else if (st[st.length() - 1] == 'A')
c1++;
for (j = 1; j < st.length(); j++)
if (st[j - 1] == 'A' && st[j] == 'B')
s++;
}
if (!(c1 + c2))
cout << s + max(0, c3 - 1) << endl;
else
cout << s + min(c1, c2) + c3 << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 867,977 | 867,976 | u083440680 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
//#define T_ int
using namespace std;
// struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_
// y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int
// i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}}; struct seg{struct treedot{int
// l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void
// pushdown(int id){if
// (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void
// pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int
// l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r)
// c[id].sum=0;else{int
// mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void
// update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if
// (le<=c[id].l&&c[id].r<=ri)
// c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_
// query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if
// (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_
// ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return
// ans;}}; struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void
// add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for
// (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_
// s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return
// s;}T_ query(int x,int y,int xx,int yy){return
// query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
int n, m, i, j, c1, c2, c3, s;
string st, sss;
int main() {
scanf("%d", &n);
fz1(i, n) {
rdst(st, 18);
if (st[0] == 'B' && st[st.length() - 1] == 'A')
c3++;
else if (st[0] == 'B')
c2++;
else if (st[st.length() - 1] == 'A')
c1++;
for (j = 1; j < st.length(); j++)
if (st[j - 1] == 'A' && st[j] == 'B')
s++;
}
if (!(c1 + c2))
cout << s + c3 - 1 << endl;
cout << s + min(c1, c2) + c3 << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define sqr(x) ((x) * (x))
#define fz1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define fd1(i, n) for ((i) = (n); (i) >= 1; (i)--)
#define fz0g(i, n) for ((i) = 0; (i) <= (n); (i)++)
#define fd0g(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define fz0k(i, n) for ((i) = 0; (i) < (n); (i)++)
#define fd0k(i, n) for ((i) = (long long)((n)-1); (i) >= 0; (i)--)
#define fz(i, x, y) for ((i) = (x); (i) <= (y); (i)++)
#define fd(i, y, x) for ((i) = (y); (i) >= (x); (i)--)
#define fzin fz1(i, n)
#define fzim fz1(i, m)
#define fzjn fz1(j, n)
#define fzjm fz1(j, m)
#define ff(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
#define rdst(st, len) \
{ \
static char ss[len]; \
scanf(" %s", ss); \
(st) = ss; \
}
//#define T_ int
using namespace std;
// struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_
// y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int
// i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}}; struct seg{struct treedot{int
// l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void
// pushdown(int id){if
// (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void
// pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int
// l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r)
// c[id].sum=0;else{int
// mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void
// update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if
// (le<=c[id].l&&c[id].r<=ri)
// c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_
// query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if
// (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_
// ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return
// ans;}}; struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void
// add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for
// (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_
// s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return
// s;}T_ query(int x,int y,int xx,int yy){return
// query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
int n, m, i, j, c1, c2, c3, s;
string st, sss;
int main() {
scanf("%d", &n);
fz1(i, n) {
rdst(st, 18);
if (st[0] == 'B' && st[st.length() - 1] == 'A')
c3++;
else if (st[0] == 'B')
c2++;
else if (st[st.length() - 1] == 'A')
c1++;
for (j = 1; j < st.length(); j++)
if (st[j - 1] == 'A' && st[j] == 'B')
s++;
}
if (!(c1 + c2))
cout << s + max(0, c3 - 1) << endl;
else
cout << s + min(c1, c2) + c3 << endl;
return 0;
}
| [
"call.add",
"call.arguments.change",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 867,978 | 867,976 | u083440680 | cpp |
p03049 | // Author:- Yatin Patel
// Mail:- yatinpatel.gt@gmail.com
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define FILEIN \
ifstream fin; \
fin.open("input.txt");
#define FILEOUT \
ofstream fout; \
fout.open("output.txt");
using namespace std;
using namespace __gnu_pbds;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
err(++it, args...);
}
#define FAST \
ios::sync_with_stdio(false); \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define ld long double
#define pb push_back
#define ff first
#define ss second
#define precision(x, d) cout << fixed << setprecision(d) << x
#define minQueue priority_queue<ll, vector<ll>, greater<ll>>
#define maxQueue priority_queue<ll, vector<ll>, less<ll>>
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define RFOR(i, a, b) for (ll i = a; i > b; i--)
#define FILL(a, b) memset((a), (b), sizeof((a)))
#define MOD 1000000007
#define INF LONG_MAX
#define MINF LONG_MIN
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
ll power(ll x, unsigned ll y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
//#define fin cin
//#define fout cout
int main() {
FAST;
ll n;
cin >> n;
ll c1 = 0;
ll c2 = 0;
ll c3 = 0;
ll ans = 0;
for (ll i = 0; i < n; i++) {
string tmp;
cin >> tmp;
for (ll j = 1; j < tmp.length(); j++) {
if (tmp[j] == 'B' && tmp[j - 1] == 'A') {
ans++;
}
}
if (tmp[0] == 'B' && tmp[tmp.length() - 1] == 'A') {
c3++;
} else if (tmp[0] == 'B') {
c1++;
} else if (tmp[tmp.length() - 1] == 'A') {
c2++;
}
}
if (c3 >= 2)
ans += (c3 - 1);
if (c1 >= 1 && c3 != 0) {
ans++;
c1--;
}
if (c2 >= 1 && c3 != 0) {
ans++;
c2--;
}
ans += min(c2, c2);
cout << ans;
return 0;
}
| // Author:- Yatin Patel
// Mail:- yatinpatel.gt@gmail.com
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define FILEIN \
ifstream fin; \
fin.open("input.txt");
#define FILEOUT \
ofstream fout; \
fout.open("output.txt");
using namespace std;
using namespace __gnu_pbds;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
err(++it, args...);
}
#define FAST \
ios::sync_with_stdio(false); \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define ld long double
#define pb push_back
#define ff first
#define ss second
#define precision(x, d) cout << fixed << setprecision(d) << x
#define minQueue priority_queue<ll, vector<ll>, greater<ll>>
#define maxQueue priority_queue<ll, vector<ll>, less<ll>>
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define RFOR(i, a, b) for (ll i = a; i > b; i--)
#define FILL(a, b) memset((a), (b), sizeof((a)))
#define MOD 1000000007
#define INF LONG_MAX
#define MINF LONG_MIN
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
ll power(ll x, unsigned ll y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
//#define fin cin
//#define fout cout
int main() {
FAST;
ll n;
cin >> n;
ll c1 = 0;
ll c2 = 0;
ll c3 = 0;
ll ans = 0;
for (ll i = 0; i < n; i++) {
string tmp;
cin >> tmp;
for (ll j = 1; j < tmp.length(); j++) {
if (tmp[j] == 'B' && tmp[j - 1] == 'A') {
ans++;
}
}
if (tmp[0] == 'B' && tmp[tmp.length() - 1] == 'A') {
c3++;
} else if (tmp[0] == 'B') {
c1++;
} else if (tmp[tmp.length() - 1] == 'A') {
c2++;
}
}
if (c3 >= 2)
ans += (c3 - 1);
if (c1 >= 1 && c3 != 0) {
ans++;
c1--;
}
if (c2 >= 1 && c3 != 0) {
ans++;
c2--;
}
ans += min(c1, c2);
cout << ans;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 867,979 | 867,980 | u646513066 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> Pi;
typedef long long int ll;
const int INF = (ll)(1 << 30) - 1;
const ll INFl = (ll)9223372036854775807;
const int MAX = 10000;
const ll MOD = (ll)1e9 + 7;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int n;
string s[10100];
int as = 0;
int bs = 0;
int absa = 0;
int ans = 0;
int main() {
cin >> n;
REP(i, n) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
absa++;
} else if (s[i][0] == 'B') {
bs++;
} else if (s[i][s[i].size() - 1] == 'A') {
as++;
}
}
if (as == 0 && bs == 0) {
if (absa >= 1) {
cout << absa - 1 << endl;
return 0;
} else {
cout << 0 << endl;
return 0;
}
}
as += absa;
bs += absa;
cout << min(as, bs) + ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> Pi;
typedef long long int ll;
const int INF = (ll)(1 << 30) - 1;
const ll INFl = (ll)9223372036854775807;
const int MAX = 10000;
const ll MOD = (ll)1e9 + 7;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int n;
string s[10100];
int as = 0;
int bs = 0;
int absa = 0;
int ans = 0;
int main() {
cin >> n;
REP(i, n) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
absa++;
} else if (s[i][0] == 'B') {
bs++;
} else if (s[i][s[i].size() - 1] == 'A') {
as++;
}
}
if (as == 0 && bs == 0) {
if (absa >= 1) {
cout << absa - 1 + ans << endl;
return 0;
} else {
cout << ans << endl;
return 0;
}
}
as += absa;
bs += absa;
cout << min(as, bs) + ans << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 867,987 | 867,988 | u055303078 | cpp |
p03049 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
string s;
int ab = 0, a = 0, b = 0, c = 0;
for (int o = 0; o < n; o++) {
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
c++;
else if (s[0] == 'B')
b++;
else if (s[s.size() - 1] == 'A')
a++;
for (int i = 0; i < (int)s.size() - 1; i++)
if (s[i] == 'A' && s[i + 1] == 'B')
ab++;
}
if (min(a, b) > 0)
cout << ab + min(a, b) + c << endl;
else if (max(a, b) > 0)
cout << ab + c << endl;
else
cout << ab + c - 1 << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
string s;
int ab = 0, a = 0, b = 0, c = 0;
for (int o = 0; o < n; o++) {
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
c++;
else if (s[0] == 'B')
b++;
else if (s[s.size() - 1] == 'A')
a++;
for (int i = 0; i < (int)s.size() - 1; i++)
if (s[i] == 'A' && s[i + 1] == 'B')
ab++;
}
if (min(a, b) > 0)
cout << ab + min(a, b) + c << endl;
else if (max(a, b) > 0)
cout << ab + c << endl;
else
cout << ab + max(0, c - 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 867,989 | 867,990 | u535008646 | cpp |
p03049 | // written by NewbieChd
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 10003;
char s[N];
int main() {
int n, len, i, a = 0, b = 0, c = 0, ans = 0;
scanf("%d", &n);
while (n--) {
scanf("%s", s + 1), len = strlen(s + 1);
for (i = 1; i <= len; ++i)
if (s[i] == 'B' && s[i - 1] == 'A')
++ans;
if (s[len] == 'A')
s[1] == 'B' ? ++c : ++a;
else if (s[1] == 'B')
++b;
}
if (c)
ans += c - 1;
if (a)
++ans, --a;
if (b)
++ans, --b;
ans += min(a, b);
printf("%d\n", ans);
return 0;
}
| // written by NewbieChd
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 10003;
char s[N];
int main() {
int n, len, i, a = 0, b = 0, c = 0, ans = 0;
scanf("%d", &n);
while (n--) {
scanf("%s", s + 1), len = strlen(s + 1);
for (i = 1; i <= len; ++i)
if (s[i] == 'B' && s[i - 1] == 'A')
++ans;
if (s[len] == 'A')
s[1] == 'B' ? ++c : ++a;
else if (s[1] == 'B')
++b;
}
if (c) {
ans += c - 1;
if (a)
++ans, --a;
if (b)
++ans, --b;
}
ans += min(a, b);
printf("%d\n", ans);
return 0;
}
| [] | 867,997 | 867,998 | u305668100 | cpp |
p03049 | #include <bits/stdc++.h>
#define ARC(i, a, b) for (int i = (a); i < (b); ++i)
#define RC(i, n) ARC(i, 0, n)
#define ARCH(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define RCH(i, n) ARCH(i, n, 0)
template <class T> T ant(const T &a, const T &b) { return a > b ? a : b; }
template <class T> T ont(const T &a, const T &b) { return a < b ? a : b; }
template <class T> T &anth(T &a, const T &b) { return a = ant(a, b); }
template <class T> T &onth(T &a, const T &b) { return a = ont(a, b); }
int ans;
int x, y, z;
int main() {
int n;
scanf("%d", &n);
RC(i, n) {
char ch[20];
scanf("%s", ch);
int len = strlen(ch);
if (ch[len - 1] == 'A' && ch[0] == 'B')
++y;
else if (ch[len - 1] == 'A')
++x;
else if (ch[0] == 'B')
++z;
RC(j, len - 1) if (ch[j] == 'A' && ch[j + 1] == 'B')++ ans;
}
if (x == 0 && z == 0)
ans += y - 1;
else
ans += ont(x, z) + y;
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
#define ARC(i, a, b) for (int i = (a); i < (b); ++i)
#define RC(i, n) ARC(i, 0, n)
#define ARCH(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define RCH(i, n) ARCH(i, n, 0)
template <class T> T ant(const T &a, const T &b) { return a > b ? a : b; }
template <class T> T ont(const T &a, const T &b) { return a < b ? a : b; }
template <class T> T &anth(T &a, const T &b) { return a = ant(a, b); }
template <class T> T &onth(T &a, const T &b) { return a = ont(a, b); }
int ans;
int x, y, z;
int main() {
int n;
scanf("%d", &n);
RC(i, n) {
char ch[20];
scanf("%s", ch);
int len = strlen(ch);
if (ch[len - 1] == 'A' && ch[0] == 'B')
++y;
else if (ch[len - 1] == 'A')
++x;
else if (ch[0] == 'B')
++z;
RC(j, len - 1) if (ch[j] == 'A' && ch[j + 1] == 'B')++ ans;
}
if (x == 0 && z == 0) {
if (y)
ans += y - 1;
} else
ans += ont(x, z) + y;
printf("%d\n", ans);
}
| [
"control_flow.branch.if.add"
] | 868,009 | 868,010 | u826438738 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = numeric_limits<ll>::max() / 3;
const ll mod = 998244353;
int main(void) {
int n;
cin >> n;
int res = 0;
int cnta = 0, cntb = 0, cntba = 0;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j + 1 < (int)s.size(); ++j) {
if (s.substr(j, 2) == "AB")
++res;
}
char begin = s[0], end = s[s.size() - 1];
if (begin == 'B' && end == 'A')
++cntba;
else if (begin == 'B')
++cntb;
else if (end == 'A')
++cnta;
}
if (cnta + cntb > 0) {
res += cntba;
res += min(cnta, cntb);
} else {
res += cntba - 1;
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = numeric_limits<ll>::max() / 3;
const ll mod = 998244353;
int main(void) {
int n;
cin >> n;
int res = 0;
int cnta = 0, cntb = 0, cntba = 0;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j + 1 < (int)s.size(); ++j) {
if (s.substr(j, 2) == "AB")
++res;
}
char begin = s[0], end = s[s.size() - 1];
if (begin == 'B' && end == 'A')
++cntba;
else if (begin == 'B')
++cntb;
else if (end == 'A')
++cnta;
}
if (cnta + cntb > 0) {
res += cntba;
res += min(cnta, cntb);
} else {
res += max(cntba - 1, 0);
}
cout << res << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 868,011 | 868,012 | u488078009 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (const T &i : a)
out << i << ',';
out << ']';
return out;
}
template <class T> ostream &operator<<(ostream &out, const set<T> &a) {
out << '{';
for (const T &i : a)
out << i << ',';
out << '}';
return out;
}
template <class T, class S>
ostream &operator<<(ostream &out, const map<T, S> &a) {
out << '{';
for (auto &i : a)
out << i << ',';
out << '}';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<string> s(n);
REP(i, n) cin >> s[i];
bool fa = false, fb = false;
ll ret = 0, a = 0, b = 0;
REP(i, n) {
REP(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ret++;
}
if (s[i][0] == 'B' && s[i].back() == 'A')
a++, b++;
else if (s[i][0] == 'B')
b++, fb = true;
else if (s[i].back() == 'A')
a++, fa = true;
}
if (!fb)
a--;
if (!fa)
b--;
ll tmp = min(a, b);
// if(a == 1 && b == 1 && flag) tmp = 0;
cout << ret + tmp << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (const T &i : a)
out << i << ',';
out << ']';
return out;
}
template <class T> ostream &operator<<(ostream &out, const set<T> &a) {
out << '{';
for (const T &i : a)
out << i << ',';
out << '}';
return out;
}
template <class T, class S>
ostream &operator<<(ostream &out, const map<T, S> &a) {
out << '{';
for (auto &i : a)
out << i << ',';
out << '}';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<string> s(n);
REP(i, n) cin >> s[i];
bool fa = false, fb = false;
ll ret = 0, a = 0, b = 0;
REP(i, n) {
REP(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ret++;
}
if (s[i][0] == 'B' && s[i].back() == 'A')
a++, b++;
else if (s[i][0] == 'B')
b++, fb = true;
else if (s[i].back() == 'A')
a++, fa = true;
}
// cout << ret << endl;
if (!fb)
a--;
if (!fa)
b--;
ll tmp = max(0LL, min(a, b));
// if(a == 1 && b == 1 && flag) tmp = 0;
cout << ret + tmp << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 868,013 | 868,014 | u333917945 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int ans = 0;
int cnt[4] = {0};
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int i = 0; i < s.size() - 1; ++i) {
ans += s[i] == 'A' and s[i + 1] == 'B';
}
int hs = 0;
hs += (s.back() == 'A') * 1;
hs += (s[0] == 'B') * 2;
++cnt[hs];
}
if (cnt[1] or cnt[2]) {
ans += cnt[3], cnt[3] = 0;
ans += min(cnt[1], cnt[2]);
} else
ans += cnt[3] - 1;
cout << ans << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int ans = 0;
int cnt[4] = {0};
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int i = 0; i < s.size() - 1; ++i) {
ans += s[i] == 'A' and s[i + 1] == 'B';
}
int hs = 0;
hs += (s.back() == 'A') * 1;
hs += (s[0] == 'B') * 2;
++cnt[hs];
}
if (cnt[1] or cnt[2]) {
ans += cnt[3], cnt[3] = 0;
ans += min(cnt[1], cnt[2]);
} else
ans += max(0, cnt[3] - 1);
cout << ans << '\n';
}
| [
"call.add",
"call.arguments.change"
] | 868,015 | 868,016 | u459737327 | cpp |
p03049 | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
using db = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / (T)1024;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832795028841971;
constexpr long double Golden = 1.61803398874989484820;
constexpr long double eps = 1e-15;
#define iostream_untie true
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 6
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << fixed << setprecision(stdout_precision);
std::cerr << fixed << setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("input.txt", "rt", stdin)) {
cerr << "Failed to open the input file.\n";
exit(EXIT_FAILURE);
}
// if(!freopen("output.txt","wt",stdout)) {
// cerr << "Failed to open the output file.\n"; exit(EXIT_FAILURE);
// }
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
// atexit((void(*)())fclose(stdin));
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = i64> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, uint8_t e) { return (n >> e) & 1; }
constexpr i64 mask(i64 n, uint8_t e) { return n & ((1 << e) - 1); }
constexpr int ilog(uint64_t x, uint64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
template <class F> int64_t binry(int64_t ok, int64_t ng, const F &fn) {
while (abs(ok - ng) > 1) {
int64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class A> void cmprs(A ary[], size_t n) {
vector<A> tmp(ary, ary + n);
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (A *i = ary; i != ary + n; ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class T> void cmprs(vector<T> &v) {
vector<T> tmp = v;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (auto i = begin(v); i != end(v); ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
int n;
string s[10010];
i64 ans;
int bcnt, acnt, ccnt;
signed main() {
cin >> n;
rep(i, n) {
bool both = true;
cin >> s[i];
rep(j, s[i].size()) {
if (j + 1 < s[i].size()) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
} else {
if (s[i][j] == 'A')
acnt++;
else
both = false;
}
}
if (s[i][0] == 'B')
bcnt++;
else
both = false;
if (both)
ccnt++;
}
if (acnt == bcnt) {
if (ccnt == acnt) {
if (ans + ccnt - 1 < 0)
esc(0);
esc(ans + ccnt - 1);
}
}
esc(ans + min(acnt, bcnt));
}
| #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
using db = long double;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
using pdi = pair<double, int>;
template <class T> using vct = vector<T>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> constexpr T inf = numeric_limits<T>::max() / (T)1024;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832795028841971;
constexpr long double Golden = 1.61803398874989484820;
constexpr long double eps = 1e-15;
#define iostream_untie true
#define mod 1000000007LL
#define stdout_precision 10
#define stderr_precision 6
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define rsz resize
#define ers erase
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << fixed << setprecision(stdout_precision);
std::cerr << fixed << setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("input.txt", "rt", stdin)) {
cerr << "Failed to open the input file.\n";
exit(EXIT_FAILURE);
}
// if(!freopen("output.txt","wt",stdout)) {
// cerr << "Failed to open the output file.\n"; exit(EXIT_FAILURE);
// }
// std::cerr << "\n---stderr---\n";
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
// atexit((void(*)())fclose(stdin));
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class Tup, size_t index = tuple_size<Tup>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, Tup const &tup) {
hashval_calc<Tup, index - 1>::apply(seed, tup);
hash_combine(seed, get<index>(tup));
}
};
template <class Tup> struct hashval_calc<Tup, 0> {
static void apply(size_t &seed, Tup const &tup) {
hash_combine(seed, get<0>(tup));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &tup) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, tup);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i)
s << (i ? " " : "") << v[i];
return s;
}
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T = i64> T read() {
T x;
return cin >> x, x;
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, uint8_t e) { return (n >> e) & 1; }
constexpr i64 mask(i64 n, uint8_t e) { return n & ((1 << e) - 1); }
constexpr int ilog(uint64_t x, uint64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
template <class F> int64_t binry(int64_t ok, int64_t ng, const F &fn) {
while (abs(ok - ng) > 1) {
int64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class A> void cmprs(A ary[], size_t n) {
vector<A> tmp(ary, ary + n);
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (A *i = ary; i != ary + n; ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class T> void cmprs(vector<T> &v) {
vector<T> tmp = v;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (auto i = begin(v); i != end(v); ++i)
*i = l_bnd(all(tmp), *i) - begin(tmp);
}
template <class F> void for_subset(uint_fast64_t s, const F &fn) {
uint_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
int n;
string s[10010];
i64 ans;
int bcnt, acnt, ccnt;
signed main() {
cin >> n;
rep(i, n) {
bool both = true;
cin >> s[i];
rep(j, s[i].size()) {
if (j + 1 < s[i].size()) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
} else {
if (s[i][j] == 'A')
acnt++;
else
both = false;
}
}
if (s[i][0] == 'B')
bcnt++;
else
both = false;
if (both)
ccnt++;
}
if (acnt == bcnt) {
if (ccnt == acnt) {
if (ccnt == 0)
esc(ans);
esc(ans + ccnt - 1);
}
}
esc(ans + min(acnt, bcnt));
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 868,017 | 868,018 | u629015299 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int r = 0, xa = 0, bx = 0, ba = 0;
for (; n > 0; n--) {
string s;
cin >> s;
for (int i = 0; i + 1 < s.size(); i++) {
r += s[i] == 'A' && s[i + 1] == 'B';
}
xa += s.back() == 'A';
bx += s.front() == 'B';
ba += s.back() == 'A' && s.front() == 'B';
}
cout << r + min(xa, bx) - (xa == ba && bx == ba) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int r = 0, xa = 0, bx = 0, ba = 0;
for (; n > 0; n--) {
string s;
cin >> s;
for (int i = 0; i + 1 < s.size(); i++) {
r += s[i] == 'A' && s[i + 1] == 'B';
}
xa += s.back() == 'A';
bx += s.front() == 'B';
ba += s.back() == 'A' && s.front() == 'B';
}
cout << r + min(xa, bx) - (ba && xa == ba && bx == ba) << endl;
}
| [
"expression.operation.binary.add"
] | 868,019 | 868,020 | u848737670 | cpp |
p03049 | #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;
/////////////////////////////////////////////////////
int N;
char s[10101][30];
int bs, ae, aa;
int i, j, k, ans;
int main() {
scanf("%d", &N);
fornum(i, 0, N) {
scanf("%s", s[i]);
if (s[i][0] == 'B') {
bs++;
}
for (j = 1; s[i][j]; j++) {
if (s[i][j - 1] == 'A' && s[i][j] == 'B') {
ans++;
}
}
if (s[i][j - 1] == 'A') {
ae++;
if (s[i][0] != 'B') {
aa = 1;
}
}
}
if (ae != bs) {
ans += ae > bs ? bs : ae;
} else {
ans += ae;
if (aa == 0) {
ans--;
}
}
printf("%d", 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;
/////////////////////////////////////////////////////
int N;
char s[10101][30];
int bs, ae, aa;
int i, j, k, ans;
int main() {
scanf("%d", &N);
fornum(i, 0, N) {
scanf("%s", s[i]);
if (s[i][0] == 'B') {
bs++;
}
for (j = 1; s[i][j]; j++) {
if (s[i][j - 1] == 'A' && s[i][j] == 'B') {
ans++;
}
}
if (s[i][j - 1] == 'A') {
ae++;
if (s[i][0] != 'B') {
aa = 1;
}
}
}
if (ae != bs) {
ans += ae > bs ? bs : ae;
} else {
ans += ae;
if (ae != 0 && aa == 0) {
ans--;
}
}
printf("%d", ans);
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 868,027 | 868,028 | u259396003 | cpp |
p03049 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define popcount __builtin_popcount
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
string s[10001];
int cnt = 0;
int ca = 0, cb = 0, cba = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
cnt++;
}
if (s[i][0] == 'B' && s[i].back() == 'A')
cba++;
else if (s[i][0] == 'B')
cb++;
else if (s[i].back() == 'A')
ca++;
}
if (ca == 0 && cb == 0)
cnt += (cba - 1);
else
cnt += min(ca, cb) + cba;
cout << cnt << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define popcount __builtin_popcount
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
string s[10001];
int cnt = 0;
int ca = 0, cb = 0, cba = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
cnt++;
}
if (s[i][0] == 'B' && s[i].back() == 'A')
cba++;
else if (s[i][0] == 'B')
cb++;
else if (s[i].back() == 'A')
ca++;
}
if (ca == 0 && cb == 0)
cnt += max(0, (cba - 1));
else
cnt += min(ca, cb) + cba;
cout << cnt << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 868,029 | 868,030 | u930898631 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define MOD 1000000007 // 10^9 + 7
#define INF 1000000000 // 10^9
#define LLINF 1LL << 60
string S[10000];
int num[10000]; // S[i]に含まれるABの数
// bool topB[10000];
// bool lastA[10000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int topB = 0;
int lastA = 0;
int BA = 0;
for (int i = 0; i < N; i++) {
cin >> S[i];
for (int j = 0; j < S[i].size() - 1; j++) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
num[i]++;
}
if (S[i][0] == 'B') {
// topB[i] = true;
topB++;
}
if (S[i][S[i].size() - 1] == 'A') {
// lastA[i] = true;
lastA++;
}
if (S[i][0] == 'B' && S[i][S[i].size() - 1] == 'A')
BA++;
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += num[i];
// cout << num[i] << " ";
}
if (BA == topB && BA == lastA)
ans += topB - 1;
else
ans += min(lastA, topB);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define MOD 1000000007 // 10^9 + 7
#define INF 1000000000 // 10^9
#define LLINF 1LL << 60
string S[10000];
int num[10000]; // S[i]に含まれるABの数
// bool topB[10000];
// bool lastA[10000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int topB = 0;
int lastA = 0;
int BA = 0;
for (int i = 0; i < N; i++) {
cin >> S[i];
for (int j = 0; j < S[i].size() - 1; j++) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
num[i]++;
}
if (S[i][0] == 'B') {
// topB[i] = true;
topB++;
}
if (S[i][S[i].size() - 1] == 'A') {
// lastA[i] = true;
lastA++;
}
if (S[i][0] == 'B' && S[i][S[i].size() - 1] == 'A')
BA++;
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += num[i];
// cout << num[i] << " ";
}
if (BA == topB && BA == lastA && BA != 0)
ans += topB - 1;
else
ans += min(lastA, topB);
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 868,033 | 868,034 | u774652316 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl((lint)(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T = string, class U = char>
int character_count(T text, U character) {
int ans = 0;
for (U i : text) {
ans += (i == character);
}
return ans;
}
lint power(lint base, lint exponent, lint module) {
if (exponent % 2) {
return power(base, exponent - 1, module) * base % module;
} else if (exponent) {
lint root_ans = power(base, exponent / 2, module);
return root_ans * root_ans % module;
} else {
return 1;
}
}
struct position {
int y, x;
};
position mv[4] = {
{0, -1},
{1, 0},
{0, 1},
{-1, 0}}; // double euclidean(position first, position second){ return
// sqrt((second.x - first.x) * (second.x - first.x) + (second.y -
// first.y) * (second.y - first.y)); }
template <class T, class U> string to_string(pair<T, U> x) {
return to_string(x.first) + "," + to_string(x.second);
}
string to_string(string x) { return x; }
template <class itr> void array_output(itr start, itr goal) {
string ans;
for (auto i = start; i != goal; i++)
ans += to_string(*i) + " ";
if (!ans.empty())
ans.pop_back();
cout << ans << endl;
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct combination {
vector<lint> fact, inv;
combination(int sz) : fact(sz + 1), inv(sz + 1) {
fact[0] = 1;
for (int i = 1; i <= sz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[sz] = power(fact[sz], mod - 2, mod);
for (int i = sz - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
lint C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return (fact[p] * inv[q] % mod * inv[p - q] % mod);
}
};
template <class itr> bool next_sequence(itr first, itr last, int max_bound) {
itr now = last;
while (now != first) {
now--;
(*now)++;
if ((*now) == max_bound) {
(*now) = 0;
} else {
return true;
}
}
return false;
}
int main() {
int N;
cin >> N;
int B = 0, A = 0, BA = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 1; j < s.size(); j++) {
if (s.substr(j - 1, 2) == "AB") {
ans++;
}
}
if (s[0] == 'B' && s.back() == 'A') {
BA++;
} else if (s[0] == 'B') {
B++;
} else if (s.back() == 'A') {
A++;
}
}
if (B || A) {
cout << ans + min(B, A) + BA << endl;
} else {
cout << max(0, ans + BA - 1) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint mod = 1e9 + 7;
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl((lint)(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T = string, class U = char>
int character_count(T text, U character) {
int ans = 0;
for (U i : text) {
ans += (i == character);
}
return ans;
}
lint power(lint base, lint exponent, lint module) {
if (exponent % 2) {
return power(base, exponent - 1, module) * base % module;
} else if (exponent) {
lint root_ans = power(base, exponent / 2, module);
return root_ans * root_ans % module;
} else {
return 1;
}
}
struct position {
int y, x;
};
position mv[4] = {
{0, -1},
{1, 0},
{0, 1},
{-1, 0}}; // double euclidean(position first, position second){ return
// sqrt((second.x - first.x) * (second.x - first.x) + (second.y -
// first.y) * (second.y - first.y)); }
template <class T, class U> string to_string(pair<T, U> x) {
return to_string(x.first) + "," + to_string(x.second);
}
string to_string(string x) { return x; }
template <class itr> void array_output(itr start, itr goal) {
string ans;
for (auto i = start; i != goal; i++)
ans += to_string(*i) + " ";
if (!ans.empty())
ans.pop_back();
cout << ans << endl;
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct combination {
vector<lint> fact, inv;
combination(int sz) : fact(sz + 1), inv(sz + 1) {
fact[0] = 1;
for (int i = 1; i <= sz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[sz] = power(fact[sz], mod - 2, mod);
for (int i = sz - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
lint C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return (fact[p] * inv[q] % mod * inv[p - q] % mod);
}
};
template <class itr> bool next_sequence(itr first, itr last, int max_bound) {
itr now = last;
while (now != first) {
now--;
(*now)++;
if ((*now) == max_bound) {
(*now) = 0;
} else {
return true;
}
}
return false;
}
int main() {
int N;
cin >> N;
int B = 0, A = 0, BA = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 1; j < s.size(); j++) {
if (s.substr(j - 1, 2) == "AB") {
ans++;
}
}
if (s[0] == 'B' && s.back() == 'A') {
BA++;
} else if (s[0] == 'B') {
B++;
} else if (s.back() == 'A') {
A++;
}
}
if (B || A) {
cout << ans + min(B, A) + BA << endl;
} else {
cout << ans + max(0, BA - 1) << endl;
}
}
| [
"expression.operation.binary.remove"
] | 868,035 | 868,036 | u115888500 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
int answer = 0;
int a = 0, b = 0, c = 0;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0, length = s.length(); j < length - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++answer;
}
if (s[s.length() - 1] == 'A')
++a;
if (s[0] == 'B')
++b;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
++c;
}
answer += min(a, b);
if (a == b && b == c) {
--answer;
}
cout << answer << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
int answer = 0;
int a = 0, b = 0, c = 0;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0, length = s.length(); j < length - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++answer;
}
if (s[s.length() - 1] == 'A')
++a;
if (s[0] == 'B')
++b;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
++c;
}
answer += min(a, b);
if (a == b && b == c && a > 0) {
--answer;
}
cout << answer << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 868,040 | 868,041 | u532096498 | cpp |
p03050 | #include <algorithm>
#include <cmath>
#include <cstdio>
#define ll long long
using namespace std;
int main() {
ll n;
scanf("%lld", &n);
ll dap = 0;
for (ll i = 1; i <= n; i++) {
if ((n - i) / i < i)
break;
if ((n - i) % i == 0) {
dap += (n - i) / i;
}
}
printf("%lld\n", dap);
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#define ll long long
using namespace std;
int main() {
ll n;
scanf("%lld", &n);
ll dap = 0;
for (ll i = 1; i <= n; i++) {
if ((n - i) / i <= i)
break;
if ((n - i) % i == 0) {
dap += (n - i) / i;
}
}
printf("%lld\n", dap);
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,044 | 868,045 | u266602249 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, n, m) for (int i = (n); i < (m); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, n) for (int i = (n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using P = pair<ll, ll>;
using PP = pair<ll, P>;
using vp = vector<P>;
using vpp = vector<PP>;
using vs = vector<string>;
#define fi first
#define se second
#define pb push_back
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename A, typename B>
istream &operator>>(istream &is, pair<A, B> &p) {
is >> p.fi >> p.se;
return is;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << "(" << p.fi << "," << p.se << ")";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &t) {
REP(i, t.size()) is >> t[i];
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
REP(i, t.size()) {
if (i)
os << ",";
os << t[i];
}
cout << "}";
return os;
}
const ll MOD = 1000000007LL;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
ll divisor(ll n) {
ll res = 0;
for (ll i = 1; i * i < n; i++) {
if (n % i == 0) {
if (n % (n / i - i))
res += (n / i) - 1;
}
}
return res;
}
int main() {
ll n;
cin >> n;
cout << divisor(n) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, n, m) for (int i = (n); i < (m); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, n) for (int i = (n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using P = pair<ll, ll>;
using PP = pair<ll, P>;
using vp = vector<P>;
using vpp = vector<PP>;
using vs = vector<string>;
#define fi first
#define se second
#define pb push_back
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename A, typename B>
istream &operator>>(istream &is, pair<A, B> &p) {
is >> p.fi >> p.se;
return is;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << "(" << p.fi << "," << p.se << ")";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &t) {
REP(i, t.size()) is >> t[i];
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
REP(i, t.size()) {
if (i)
os << ",";
os << t[i];
}
cout << "}";
return os;
}
const ll MOD = 1000000007LL;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
ll divisor(ll n) {
ll res = 0;
for (ll i = 1; i * i < n; i++) {
if (n % i == 0) {
if (n % (n / i - 1))
res += (n / i) - 1;
}
}
return res;
}
int main() {
ll n;
cin >> n;
cout << divisor(n) << endl;
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 868,048 | 868,049 | u437391064 | cpp |
p03050 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
unsigned long long n;
cin >> n;
unsigned long long sum = 0;
for (unsigned long long i = 1; i < sqrt(n); i++) {
if (n % i == 0) {
unsigned long long m = n / i - 1;
sum += m;
}
}
cout << sum << endl;
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
unsigned long long n;
cin >> n;
unsigned long long sum = 0;
for (unsigned long long i = 1; i < sqrt(n); i++) {
if (n % i == 0) {
unsigned long long m = n / i - 1;
if (i < m)
sum += m;
}
}
cout << sum << endl;
return 0;
} | [
"control_flow.branch.if.add"
] | 868,052 | 868,053 | u754144235 | cpp |
p03050 | /////////////////////////////////////////Info/////////////////////////////////////////////////
// Problem:
// Date:
// Skill:
// Bug:
/////////////////////////////////////////Definations/////////////////////////////////////////////////
//循环控制
#define CLR(a) memset((a), 0, sizeof(a))
#define F(i, a, b) for (int i = a; i <= int(b); ++i)
#define F2(i, a, b) for (int i = a; i >= int(b); --i)
#define RE(i, n) for (int i = 0; i < int(n); i++)
#define RE2(i, n) for (int i = 1; i <= int(n); i++)
//简化敲击
#define PII pair<int, int>
#define PLL pari<long long, long long>
#define PB push_back
#define ENDL '\n'
#define x first
#define y second
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
////////////////////////////////////////Options//////////////////////////////////////////////////////
#define stdcpph
#define CPP_IO
#ifdef stdcpph
#include <bits/stdc++.h>
#else
#include <algorithm>
#include <ctype.h>
#include <functional>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
#ifdef CPP_IO
#include <iomanip>
#include <iostream>
#include <string>
#else
#include <stdio.h>
#endif
#endif
////////////////////////////////////////Basic
///Functions//////////////////////////////////////////////
template <typename INint> inline void IN(INint &x) {
x = 0;
int f = 1;
char c;
cin.get(c);
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
cin.get(c);
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
cin.get(c);
}
x *= f;
}
template <typename INint> inline void OUT(INint x) {
if (x > 9)
OUT(x / 10);
cout.put(x % 10 + '0');
}
////////////////////////////////////////Added
///Functions//////////////////////////////////////////////
const int maxn = int(20);
////////////////////////////////////////////Code/////////////////////////////////////////////////////
int main() {
// freopen("C:\\Users\\VULCAN\\Desktop\\data.in", "r", stdin);
int T(1), times(0);
#ifdef CPP_IO // CPP_IO
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// cin >> T;
#else
// IN(T);
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////
while (++times, T--) {
ll N;
cin >> N;
ll i = 1;
ll ans(0);
while (i * i <= N) {
if (N % i == 0 && i < (N / i))
ans += N / i - 1;
++i;
}
cout << ans << endl;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
return 0;
} | /////////////////////////////////////////Info/////////////////////////////////////////////////
// Problem:
// Date:
// Skill:
// Bug:
/////////////////////////////////////////Definations/////////////////////////////////////////////////
//循环控制
#define CLR(a) memset((a), 0, sizeof(a))
#define F(i, a, b) for (int i = a; i <= int(b); ++i)
#define F2(i, a, b) for (int i = a; i >= int(b); --i)
#define RE(i, n) for (int i = 0; i < int(n); i++)
#define RE2(i, n) for (int i = 1; i <= int(n); i++)
//简化敲击
#define PII pair<int, int>
#define PLL pari<long long, long long>
#define PB push_back
#define ENDL '\n'
#define x first
#define y second
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
////////////////////////////////////////Options//////////////////////////////////////////////////////
#define stdcpph
#define CPP_IO
#ifdef stdcpph
#include <bits/stdc++.h>
#else
#include <algorithm>
#include <ctype.h>
#include <functional>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
#ifdef CPP_IO
#include <iomanip>
#include <iostream>
#include <string>
#else
#include <stdio.h>
#endif
#endif
////////////////////////////////////////Basic
///Functions//////////////////////////////////////////////
template <typename INint> inline void IN(INint &x) {
x = 0;
int f = 1;
char c;
cin.get(c);
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
cin.get(c);
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
cin.get(c);
}
x *= f;
}
template <typename INint> inline void OUT(INint x) {
if (x > 9)
OUT(x / 10);
cout.put(x % 10 + '0');
}
////////////////////////////////////////Added
///Functions//////////////////////////////////////////////
const int maxn = int(20);
////////////////////////////////////////////Code/////////////////////////////////////////////////////
int main() {
// freopen("C:\\Users\\VULCAN\\Desktop\\data.in", "r", stdin);
int T(1), times(0);
#ifdef CPP_IO // CPP_IO
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// cin >> T;
#else
// IN(T);
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////
while (++times, T--) {
ll N;
cin >> N;
ll i = 1;
ll ans(0);
while (i * i <= N) {
if (N % i == 0 && i < (N / i - 1))
ans += N / i - 1;
++i;
}
cout << ans << endl;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 868,054 | 868,055 | u738285256 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) obj.begin(), obj.end()
#define pb(obj) push_back(obj)
#define REP(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll count = 0;
ll N;
cin >> N;
ll n = floor((-1 + sqrt(1 + 4 * N)) / 2);
vector<int> div;
for (int i = 1; i <= n; i++) {
if (N % i == 0)
count += N / i - 1;
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ALL(obj) obj.begin(), obj.end()
#define pb(obj) push_back(obj)
#define REP(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll count = 0;
ll N;
cin >> N;
ll n = ceil((-1 + sqrt(1 + 4 * N)) / 2) - 1;
vector<int> div;
for (int i = 1; i <= n; i++) {
if (N % i == 0)
count += N / i - 1;
}
cout << count << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change"
] | 868,060 | 868,061 | u892438699 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
int32_t main() {
IOS;
int n;
cin >> n;
int ans = 0;
for (int i = 1; i * i < n; i++) {
if (n % i == 0 && n / i < i) {
ans += (n / i - 1);
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
int32_t main() {
IOS;
int n;
cin >> n;
int ans = 0;
for (int i = 1; i * i < n; i++) {
if (n % i == 0 && i < (n / i - 1)) {
ans += (n / i - 1);
}
}
cout << ans;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 868,074 | 868,075 | u901862155 | cpp |
p03050 | #include <bits/stdc++.h>
#define rep(a, b, c) for (int a = (b); a <= (c); ++a)
#define per(a, b, c) for (int a = (b); a >= (c); --a)
using namespace std;
template <class T> void rd(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
x *= f;
}
typedef long long ll;
ll n, ans;
int main() {
rd(n);
if (n <= 100) {
for (int i = 1; i <= n; ++i) {
if (n / i == n % i)
ans++;
}
} else {
for (ll i = 1; i <= n / i; ++i) {
if (n % i == 0) {
if (i * i == n)
continue;
ans += n / i - 1;
}
}
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
#define rep(a, b, c) for (int a = (b); a <= (c); ++a)
#define per(a, b, c) for (int a = (b); a >= (c); --a)
using namespace std;
template <class T> void rd(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
x *= f;
}
typedef long long ll;
ll n, ans;
int main() {
rd(n);
if (n <= 100) {
for (int i = 1; i <= n; ++i) {
if (n / i == n % i)
ans += i;
}
} else {
for (ll i = 1; i <= n / i; ++i) {
if (n % i == 0) {
if (i * i == n)
continue;
ans += n / i - 1;
}
}
}
printf("%lld\n", ans);
return 0;
}
| [] | 868,076 | 868,077 | u383898108 | cpp |
p03050 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define inf 1000000007
typedef pair<int, int> P;
bool prime(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
signed main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
if ((n - i) / i < i)
break;
if ((n - i) % i == 0)
ans += (n - i) / i;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define inf 1000000007
typedef pair<int, int> P;
bool prime(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
signed main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
if ((n - i) / i <= i)
break;
if ((n - i) % i == 0)
ans += (n - i) / i;
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 868,078 | 868,079 | u452009494 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.