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 |
|---|---|---|---|---|---|---|---|
p03139 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define FOR(I, A, B) for (int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B;
cin >> N >> A >> B;
cout << B << " " << max(0, A + B - N) << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define FOR(I, A, B) for (int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B;
cin >> N >> A >> B;
cout << min(A, B) << " " << max(0, A + B - N) << endl;
} | [
"call.add",
"call.arguments.change"
] | 940,492 | 940,491 | u310790595 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define vl vector<long long>
using pll = pair<long long, long long>;
#define __ << '\n'
#define _ << ' '
#define all(x) (x).begin(), (x).end()
void error() {
cout << "-1";
exit(0);
}
#define flush fflush(stdout)
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
ll n, a, b;
cin >> n >> a >> b;
if (a > b)
swap(a, b);
cout << a _;
a += b;
if (a > n)
cout << n - a;
else
cout << 0;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define vl vector<long long>
using pll = pair<long long, long long>;
#define __ << '\n'
#define _ << ' '
#define all(x) (x).begin(), (x).end()
void error() {
cout << "-1";
exit(0);
}
#define flush fflush(stdout)
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
ll n, a, b;
cin >> n >> a >> b;
if (a > b)
swap(a, b);
cout << a _;
a += b;
if (a > n)
cout << a - n;
else
cout << 0;
return 0;
}
| [
"expression.operation.binary.remove"
] | 940,498 | 940,499 | u879931038 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, r0, r1;
cin >> N >> A >> B;
r0 = min(A, B);
r1 = A + B - N;
cout << r0 << " " << r1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, r0, r1;
cin >> N >> A >> B;
r0 = min(A, B);
r1 = max(A + B - N, 0);
cout << r0 << " " << r1 << endl;
} | [
"call.add",
"call.arguments.add"
] | 940,500 | 940,501 | u335278042 | cpp |
p03139 | #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 LL;
typedef pair<LL, LL> P;
const LL mod = 1e9 + 7;
const LL LINF = 1LL << 62;
const int INF = 1000000000;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << min(a, b) - (n - max(a, b)) << 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 LL;
typedef pair<LL, LL> P;
const LL mod = 1e9 + 7;
const LL LINF = 1LL << 62;
const int INF = 1000000000;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, min(a, b) - (n - max(a, b))) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 940,504 | 940,505 | u640323045 | cpp |
p03139 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 100000007
#define SIZE 10005
#define PI 3.14159265358979323846
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << max(0, a + b - n) << endl;
return 0;
} | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 100000007
#define SIZE 10005
#define PI 3.14159265358979323846
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, a + b - n) << endl;
return 0;
} | [
"io.output.change"
] | 940,506 | 940,507 | u288432959 | cpp |
p03139 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (long long i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(i, a, b) for (long long i = (a); i >= (b); --i)
#define REPR(i, n) FORR(i, n, 0)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, n - (a + b)) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (long long i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(i, a, b) for (long long i = (a); i >= (b); --i)
#define REPR(i, n) FORR(i, n, 0)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, (a + b) - n) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 940,508 | 940,509 | u128676584 | cpp |
p03139 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
//---------------------------------------------------
// library zone!!!!!
typedef long long ll;
typedef long double ld;
#define rep(i, j) for (ll i = 0; i < (long long)(j); i++)
#define all(a) (a).begin(), (a).end()
const ll Mod = 1000000007;
struct P {
ll pos, cost;
};
bool operator<(P a, P b) { return a.cost < b.cost; }
bool operator>(P a, P b) { return a.cost > b.cost; }
struct B {
ll to, cost;
};
struct E {
ll from, to, cost;
};
bool operator<(E a, E b) { return a.cost < b.cost; }
struct H {
ll x, y;
};
bool operator<(H a, H b) {
if (a.x != b.x)
return a.x < b.x;
return a.y < b.y;
}
bool operator>(H a, H b) {
if (a.x != b.x)
return a.x > b.x;
return a.y > b.y;
}
bool operator==(H a, H b) { return a.x == b.x && a.y == b.y; }
bool operator!=(H a, H b) { return a.x != b.x || a.y != b.y; }
ll gcd(ll i, ll j) {
if (i > j)
swap(i, j);
if (i == 0)
return j;
return gcd(j % i, i);
}
ld mod_pow(ld x, ll n, ll p) {
ld res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
} // x^n%p
const ll Inf = 3023372036854775807;
const int inf = 1500000000;
#define int long long
//----------------------------------------------------
signed main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << (a + b) - n << endl;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
//---------------------------------------------------
// library zone!!!!!
typedef long long ll;
typedef long double ld;
#define rep(i, j) for (ll i = 0; i < (long long)(j); i++)
#define all(a) (a).begin(), (a).end()
const ll Mod = 1000000007;
struct P {
ll pos, cost;
};
bool operator<(P a, P b) { return a.cost < b.cost; }
bool operator>(P a, P b) { return a.cost > b.cost; }
struct B {
ll to, cost;
};
struct E {
ll from, to, cost;
};
bool operator<(E a, E b) { return a.cost < b.cost; }
struct H {
ll x, y;
};
bool operator<(H a, H b) {
if (a.x != b.x)
return a.x < b.x;
return a.y < b.y;
}
bool operator>(H a, H b) {
if (a.x != b.x)
return a.x > b.x;
return a.y > b.y;
}
bool operator==(H a, H b) { return a.x == b.x && a.y == b.y; }
bool operator!=(H a, H b) { return a.x != b.x || a.y != b.y; }
ll gcd(ll i, ll j) {
if (i > j)
swap(i, j);
if (i == 0)
return j;
return gcd(j % i, i);
}
ld mod_pow(ld x, ll n, ll p) {
ld res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
} // x^n%p
const ll Inf = 3023372036854775807;
const int inf = 1500000000;
#define int long long
//----------------------------------------------------
signed main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0ll, (a + b) - n) << endl;
} | [
"call.add",
"call.arguments.change"
] | 940,510 | 940,511 | u811004127 | cpp |
p03140 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e9)
#define PI (acos(-1))
// const double PI = acos(-1);
// const double EPS = 1e-15;
// long long INF=(long long)1E17;
#define i_7 (long long)(1e9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
using namespace std;
bool prime_(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd_(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long lcm_(long long x, long long y) { return (x / gcd_(x, y)) * y; }
int main() {
int n;
cin >> n;
string a, b, c;
cin >> a;
cin >> b;
cin >> c;
int ans = 0;
REP(i, n) {
if (a[i] == b[i] && b[i] == c[i]) {
continue;
} else if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
ans++;
}
ans += 2;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e9)
#define PI (acos(-1))
// const double PI = acos(-1);
// const double EPS = 1e-15;
// long long INF=(long long)1E17;
#define i_7 (long long)(1e9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
using namespace std;
bool prime_(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd_(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long lcm_(long long x, long long y) { return (x / gcd_(x, y)) * y; }
int main() {
int n;
cin >> n;
string a, b, c;
cin >> a;
cin >> b;
cin >> c;
int ans = 0;
REP(i, n) {
if (a[i] == b[i] && b[i] == c[i]) {
continue;
} else if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
ans++;
continue;
}
ans += 2;
}
cout << ans << endl;
return 0;
}
| [] | 940,536 | 940,537 | u222293734 | cpp |
p03140 | /*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int> &f, const pair<int, int> &s) {
return f.second > s.second;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll nCr(ll n, ll r) {
if (r == 0 || r == n) {
return 1;
} else if (r == 1) {
return n;
}
return (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r) {
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--)
ret *= i;
return ret;
}
//-----------------------ここから-----------
int main(void) {
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && b[i] == c[i])
continue;
if (a[i] == b[i] || b[i] == c[i] || a[i] == b[i]) {
ans++;
} else if (a[i] != b[i] && b[i] != c[i] && a[i] != c[i]) {
ans += 2;
}
}
cout << ans << endl;
}
| /*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int> &f, const pair<int, int> &s) {
return f.second > s.second;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll nCr(ll n, ll r) {
if (r == 0 || r == n) {
return 1;
} else if (r == 1) {
return n;
}
return (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r) {
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--)
ret *= i;
return ret;
}
//-----------------------ここから-----------
int main(void) {
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && b[i] == c[i])
continue;
if (a[i] == b[i] || b[i] == c[i] || a[i] == c[i]) {
ans++;
} else if (a[i] != b[i] && b[i] != c[i] && a[i] != c[i]) {
ans += 2;
}
}
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 940,538 | 940,539 | u845000384 | cpp |
p03140 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#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()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string &s, int k) {
if (k == 0)
return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1)
p += s;
return p;
}
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
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;
}
// 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) // O(V(V+E))
{
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) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xと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;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
ll _sum(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
SumSegTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
ll sum(ll a, ll b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
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());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
bool z_algorithm(string &str, vector<int> &z,
ll s) { // s&tを渡してtにsが含まれるかを返す
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
if (z[i] == s)
return true;
}
return false;
}
bool z_algorithm(string &str,
vector<int> &z) { // z[i]==|s|のときstr[i]からsが含まれる
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
}
return true;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
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; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
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]); }
}
};
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; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
string a, b, c;
cin >> a >> b >> c;
ll cnt = 0;
REP(i, n) {
if (a[i] == b[i] && a[i] == c[i]) {
} else if (a[i] != b[i] && a[i] != c[i] && b[i] != c[i]) {
cnt += 2;
} else {
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#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()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string &s, int k) {
if (k == 0)
return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1)
p += s;
return p;
}
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
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;
}
// 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) // O(V(V+E))
{
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) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xと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;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
ll _sum(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
SumSegTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
ll sum(ll a, ll b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
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());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
bool z_algorithm(string &str, vector<int> &z,
ll s) { // s&tを渡してtにsが含まれるかを返す
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
if (z[i] == s)
return true;
}
return false;
}
bool z_algorithm(string &str,
vector<int> &z) { // z[i]==|s|のときstr[i]からsが含まれる
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
}
return true;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
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; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
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]); }
}
};
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; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
ll cnt = 0;
REP(i, n) {
if (a[i] == b[i] && a[i] == c[i]) {
} else if (a[i] != b[i] && a[i] != c[i] && b[i] != c[i]) {
cnt += 2;
} else {
cnt++;
}
}
cout << cnt << endl;
return 0;
} | [] | 940,540 | 940,541 | u051493691 | cpp |
p03140 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#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()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string &s, int k) {
if (k == 0)
return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1)
p += s;
return p;
}
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
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;
}
// 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) // O(V(V+E))
{
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) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xと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;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
ll _sum(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
SumSegTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
ll sum(ll a, ll b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
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());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
bool z_algorithm(string &str, vector<int> &z,
ll s) { // s&tを渡してtにsが含まれるかを返す
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
if (z[i] == s)
return true;
}
return false;
}
bool z_algorithm(string &str,
vector<int> &z) { // z[i]==|s|のときstr[i]からsが含まれる
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
}
return true;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
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; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
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]); }
}
};
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; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
string a, b, c;
cin >> a >> b >> c;
ll cnt = 0;
REP(i, n) {
if (a[i] == b[i] && a[i] == b[i]) {
} else if (a[i] != b[i] && a[i] != c[i] && b[i] != c[i]) {
cnt += 2;
} else {
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#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()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string &s, int k) {
if (k == 0)
return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1)
p += s;
return p;
}
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
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;
}
// 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) // O(V(V+E))
{
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) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && 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;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xと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;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
ll _sum(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
SumSegTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
ll sum(ll a, ll b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
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());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
bool z_algorithm(string &str, vector<int> &z,
ll s) { // s&tを渡してtにsが含まれるかを返す
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
if (z[i] == s)
return true;
}
return false;
}
bool z_algorithm(string &str,
vector<int> &z) { // z[i]==|s|のときstr[i]からsが含まれる
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
}
return true;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
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; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
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]); }
}
};
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; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
ll cnt = 0;
REP(i, n) {
if (a[i] == b[i] && a[i] == c[i]) {
} else if (a[i] != b[i] && a[i] != c[i] && b[i] != c[i]) {
cnt += 2;
} else {
cnt++;
}
}
cout << cnt << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 940,542 | 940,541 | u051493691 | cpp |
p03140 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] == c[i])
continue;
if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i])
ans++;
else
ans += 2;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && b[i] == c[i])
continue;
if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i])
ans++;
else
ans += 2;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 940,545 | 940,546 | u370447425 | cpp |
p03140 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, c[26][100] = {};
string S[3];
cin >> N;
int ans = N * 3;
for (int i = 0; i < 3; i++)
cin >> S[i];
for (int i = 0; i < N; i++) {
if (S[1][i] == S[0][i] && S[0][i] == S[2][i])
ans -= 3;
else if (S[1][i] == S[0][i] || S[1][i] == S[2][i] || S[2][i] == S[0][i])
ans -= 2;
}
cout << ans;
}
| #include <algorithm>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, c[26][100] = {};
string S[3];
cin >> N;
int ans = N * 3;
for (int i = 0; i < 3; i++)
cin >> S[i];
for (int i = 0; i < N; i++) {
if (S[1][i] == S[0][i] && S[0][i] == S[2][i])
ans -= 3;
else if (S[1][i] == S[0][i] || S[1][i] == S[2][i] || S[2][i] == S[0][i])
ans -= 2;
else
ans--;
}
cout << ans;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"expression.unary.arithmetic.add"
] | 940,551 | 940,552 | u444349080 | cpp |
p03140 | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e2 + 10;
int n, a[N], b[N], c[N], ans;
int main() {
scanf("%d", &n);
scanf("%s%s%s", a + 1, b + 1, c + 1);
for (register int i = 1; i <= n; i++) {
if (a[i] == b[i] && b[i] == c[i])
continue;
else if (a[i] == b[i] || a[i] == c[i] || c[i] == b[i])
ans++;
else
ans += 2;
}
printf("%d\n", ans);
return 0;
} | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e2 + 10;
int n, ans;
char a[N], b[N], c[N];
int main() {
scanf("%d", &n);
scanf("%s%s%s", a + 1, b + 1, c + 1);
for (register int i = 1; i <= n; i++) {
if (a[i] == b[i] && b[i] == c[i])
continue;
else if (a[i] == b[i] || a[i] == c[i] || c[i] == b[i])
ans++;
else
ans += 2;
}
printf("%d\n", ans);
return 0;
} | [
"variable_declaration.add",
"variable_declaration.remove"
] | 940,561 | 940,562 | u917335077 | cpp |
p03140 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define allR(v) v.rbegin(), v.rend()
#define PRINT(v) \
for (auto x : (v)) \
cout << x << " "; \
cout << endl;
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
typedef pair<int, int> Pi;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
const int inf = 1001001001;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
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;
}
template <class T> inline T powerM(T a, T b) {
if (b == 0)
return 1;
T tmp = powerM(a, b / 2);
if (b % 2 == 0)
return tmp * tmp % MOD;
else
return tmp * tmp % MOD * a % MOD;
}
template <class T> inline T power(T a, T b, T m = numeric_limits<T>::max()) {
if (b == 0)
return 1;
T tmp = power(a, b / 2, m);
if (b % 2 == 0)
return tmp * tmp % m;
else
return tmp * tmp % m * a % m;
}
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ax+by=gcd(a,b)を解く
template <class T> inline T extgcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
void hey() { cout << "hey" << endl; }
template <class T> struct edge {
int to;
T cost;
};
int main() {
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int res = 0;
rep(i, n) {
if (a[i] == b[i] && a[i] == c[i])
continue;
res++;
if (a[i] == b[i] || b[i] == c[i] && c[i] == a[i])
continue;
res++;
}
cout << res << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define allR(v) v.rbegin(), v.rend()
#define PRINT(v) \
for (auto x : (v)) \
cout << x << " "; \
cout << endl;
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
typedef pair<int, int> Pi;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
const int inf = 1001001001;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
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;
}
template <class T> inline T powerM(T a, T b) {
if (b == 0)
return 1;
T tmp = powerM(a, b / 2);
if (b % 2 == 0)
return tmp * tmp % MOD;
else
return tmp * tmp % MOD * a % MOD;
}
template <class T> inline T power(T a, T b, T m = numeric_limits<T>::max()) {
if (b == 0)
return 1;
T tmp = power(a, b / 2, m);
if (b % 2 == 0)
return tmp * tmp % m;
else
return tmp * tmp % m * a % m;
}
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ax+by=gcd(a,b)を解く
template <class T> inline T extgcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
void hey() { cout << "hey" << endl; }
template <class T> struct edge {
int to;
T cost;
};
int main() {
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int res = 0;
rep(i, n) {
if (a[i] == b[i] && a[i] == c[i])
continue;
res++;
if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i])
continue;
res++;
}
cout << res << endl;
} | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 940,573 | 940,574 | u195132800 | cpp |
p03140 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, long long>
#define uni(e) e.erase(unique(e.begin(), e.end()), e.end())
#define double long double
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int INF = 1e10;
int MOD = 1e9 + 7;
template <class T> void out(T a) { cout << a << '\n'; }
template <class T> void yesno(T b) {
if (b)
out("yes");
else
out("no");
}
template <class T> void YesNo(T b) {
if (b)
out("Yes");
else
out("No");
}
template <class T> void YESNO(T b) {
if (b)
out("YES");
else
out("NO");
}
template <class T> void noyes(T b) {
if (b)
out("no");
else
out("yes");
}
template <class T> void NoYes(T b) {
if (b)
out("No");
else
out("Yes");
}
template <class T> void NOYES(T b) {
if (b)
out("NO");
else
out("YES");
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int kurai(int a, int b) {
int m = pow(10, b), n = pow(10, b - 1);
return (a % m) / n;
}
int ketawa(int a) {
int k = 0;
rep(i, keta(a)) { k += kurai(a, i + 1); }
return k;
}
int gcd(int a, int b) {
if (a % b == 0)
return b;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int mid(int a, int b, int c) {
vector<int> k(3);
k[0] = a;
k[1] = b;
k[2] = c;
sort(all(k));
return k[1];
}
bool sosuu(int a) {
bool b = 1;
if (a <= 1)
return 0;
else {
rep1(i, sqrt(a) - 1) {
if (a % (i + 1) == 0)
b = 0;
}
return b;
}
}
int modpow(int a, int b, int m = MOD) {
if (!b)
return 1;
if (b & 1)
return modpow(a, b - 1, m) * a % m;
int memo = modpow(a, b >> 1, m);
return memo * memo % m;
}
int fact_mod(int n) {
int f = 1;
for (int i = 2; i < n + 1; i++)
f = f * (i % MOD) % MOD;
return f;
}
int mod_pow(int x, int n) {
int res = 1;
while (n > 0) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
int c_mod(int n, int r) {
if (r > n - r)
r = n - r;
if (r == 0)
return 1;
int a = 1;
rep(i, r) a = a * ((n - i) % MOD) % MOD;
int b = mod_pow(fact_mod(r), MOD - 2);
return (a % MOD) * (b % MOD) % MOD;
}
signed main() {
int a;
string b, c, d;
cin >> b >> c >> d;
int g = 0;
rep(i, a) {
if (b[i] == c[i] && c[i] == d[i])
g += 0;
else if (b[i] != c[i] && c[i] != d[i] && d[i] != b[i])
g += 2;
else
g += 1;
}
out(g);
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, long long>
#define uni(e) e.erase(unique(e.begin(), e.end()), e.end())
#define double long double
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int INF = 1e10;
int MOD = 1e9 + 7;
template <class T> void out(T a) { cout << a << '\n'; }
template <class T> void yesno(T b) {
if (b)
out("yes");
else
out("no");
}
template <class T> void YesNo(T b) {
if (b)
out("Yes");
else
out("No");
}
template <class T> void YESNO(T b) {
if (b)
out("YES");
else
out("NO");
}
template <class T> void noyes(T b) {
if (b)
out("no");
else
out("yes");
}
template <class T> void NoYes(T b) {
if (b)
out("No");
else
out("Yes");
}
template <class T> void NOYES(T b) {
if (b)
out("NO");
else
out("YES");
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int kurai(int a, int b) {
int m = pow(10, b), n = pow(10, b - 1);
return (a % m) / n;
}
int ketawa(int a) {
int k = 0;
rep(i, keta(a)) { k += kurai(a, i + 1); }
return k;
}
int gcd(int a, int b) {
if (a % b == 0)
return b;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int mid(int a, int b, int c) {
vector<int> k(3);
k[0] = a;
k[1] = b;
k[2] = c;
sort(all(k));
return k[1];
}
bool sosuu(int a) {
bool b = 1;
if (a <= 1)
return 0;
else {
rep1(i, sqrt(a) - 1) {
if (a % (i + 1) == 0)
b = 0;
}
return b;
}
}
int modpow(int a, int b, int m = MOD) {
if (!b)
return 1;
if (b & 1)
return modpow(a, b - 1, m) * a % m;
int memo = modpow(a, b >> 1, m);
return memo * memo % m;
}
int fact_mod(int n) {
int f = 1;
for (int i = 2; i < n + 1; i++)
f = f * (i % MOD) % MOD;
return f;
}
int mod_pow(int x, int n) {
int res = 1;
while (n > 0) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
int c_mod(int n, int r) {
if (r > n - r)
r = n - r;
if (r == 0)
return 1;
int a = 1;
rep(i, r) a = a * ((n - i) % MOD) % MOD;
int b = mod_pow(fact_mod(r), MOD - 2);
return (a % MOD) * (b % MOD) % MOD;
}
signed main() {
int a;
cin >> a;
string b, c, d;
cin >> b >> c >> d;
int g = 0;
rep(i, a) {
if (b[i] == c[i] && c[i] == d[i])
g += 0;
else if (b[i] != c[i] && c[i] != d[i] && d[i] != b[i])
g += 2;
else
g += 1;
}
out(g);
}
| [] | 940,575 | 940,576 | u341447450 | cpp |
p03140 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, ans = 0;
string A, B, C;
cin >> N >> A >> B >> C;
if (A == B && A == C) {
cout << ans << endl;
} else {
for (int i = 0; i < N; i++) {
if (A.at(i) == B.at(i) && A.at(i) != C.at(i)) {
C.at(i) = A.at(i);
ans++;
} else if (A.at(i) != B.at(i) && A.at(i) == C.at(i)) {
B.at(i) = A.at(i);
ans++;
} else if (B.at(i) == C.at(i) && A.at(i) != C.at(i)) {
A.at(i) = B.at(i);
ans++;
} else if (A.at(i) == B.at(i) && A.at(i) == C.at(i)) {
continue;
} else {
B.at(i) = A.at(i);
ans++;
C.at(i) = A.at(i);
ans++;
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, ans = 0;
string A, B, C;
cin >> N >> A >> B >> C;
if (A == B && A == C) {
ans = 0;
} else {
for (int i = 0; i < N; i++) {
if (A.at(i) == B.at(i) && A.at(i) != C.at(i)) {
C.at(i) = A.at(i);
ans++;
} else if (A.at(i) != B.at(i) && A.at(i) == C.at(i)) {
B.at(i) = A.at(i);
ans++;
} else if (B.at(i) == C.at(i) && A.at(i) != C.at(i)) {
A.at(i) = B.at(i);
ans++;
} else if (A.at(i) == B.at(i) && A.at(i) == C.at(i)) {
continue;
} else {
B.at(i) = A.at(i);
ans++;
C.at(i) = A.at(i);
ans++;
}
}
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 940,577 | 940,578 | u799751074 | cpp |
p03140 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <list>
#include <numeric>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
using namespace std;
using INT = long long;
using UINT = unsigned long long;
int main() {
int n;
string a, b, c;
cin >> n >> a >> b >> c;
INT ans = 0;
for (size_t i = 0; i < n; i++) {
if (a[i] == b[i] == c[i]) {
continue;
} else if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
ans++;
} else {
ans += 2;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <list>
#include <numeric>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
using namespace std;
using INT = long long;
using UINT = unsigned long long;
int main() {
int n;
string a, b, c;
cin >> n >> a >> b >> c;
INT ans = 0;
for (size_t i = 0; i < n; i++) {
if (a[i] == b[i] && b[i] == c[i]) {
continue;
} else if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
ans++;
} else {
ans += 2;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 940,582 | 940,583 | u275797573 | cpp |
p03140 | #include <iostream>
#include <string>
int main() {
int N;
std::cin >> N;
int res{0};
std::string A, B, C;
std::cin >> A >> B >> C;
for (int i = 0; i < N; i++) {
char a{A[i]}, b{B[i]}, c{C[i]};
if (a == b && b == c)
continue;
else if (a != b && b != c)
res += 2;
else
res++;
}
std::cout << res << std::endl;
} | #include <iostream>
#include <string>
int main() {
int N;
std::cin >> N;
int res{0};
std::string A, B, C;
std::cin >> A >> B >> C;
for (int i = 0; i < N; i++) {
char a{A[i]}, b{B[i]}, c{C[i]};
if (a == b && b == c)
continue;
else if (a != b && b != c && c != a)
res += 2;
else
res++;
}
std::cout << res << std::endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 940,592 | 940,593 | u821432765 | cpp |
p03140 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
ans += (a[i] == b[i] && b[i] == c[i]) +
(a[i] = b[i] || b[i] == c[i] || c[i] == a[i]);
}
cout << 2 * n - ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
ans += (a[i] == b[i] && b[i] == c[i]) +
(a[i] == b[i] || b[i] == c[i] || c[i] == a[i]);
}
cout << 2 * n - ans << endl;
}
| [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 940,594 | 940,595 | u754114382 | cpp |
p03140 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, c))
#define pb push_back
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int inf = 1001001001;
const ll linf = 1001001001001001001;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
string a, b, c;
cin >> a >> b >> c;
int ans = 0;
rep(i, n) {
set<char> se;
se.insert(a[i]);
se.insert(b[i]);
se.insert(c[i]);
ans += se.size() - 1;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, c))
#define pb push_back
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int inf = 1001001001;
const ll linf = 1001001001001001001;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
set<char> se;
se.insert(a[i]);
se.insert(b[i]);
se.insert(c[i]);
ans += se.size() - 1;
}
cout << ans << endl;
}
| [
"expression.operation.binary.add"
] | 940,596 | 940,597 | u853721692 | cpp |
p03140 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, i, ans = 0;
string a, b, c;
cin >> a >> b >> c;
for (i = 0; i < n; i++) {
if (a[i] != b[i] && b[i] != c[i] && a[i] != c[i])
ans += 2;
else if (!(a[i] == b[i] && b[i] == c[i]))
ans += 1;
}
cout << ans << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, i, ans = 0;
string a, b, c;
cin >> n >> a >> b >> c;
for (i = 0; i < n; i++) {
if (a[i] != b[i] && b[i] != c[i] && a[i] != c[i])
ans += 2;
else if (!(a[i] == b[i] && b[i] == c[i]))
ans += 1;
}
cout << ans << endl;
}
| [
"expression.operation.binary.add"
] | 940,598 | 940,599 | u881116515 | cpp |
p03140 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
char a[100], b[100], c[100];
for (int i = 0; i != n; i++) {
cin >> a[i];
}
for (int i = 0; i != n; i++) {
cin >> b[i];
}
for (int i = 0; i != n; i++) {
cin >> c[i];
}
int ans = 0;
for (int i = 0; i != n; i++) {
if (a[i] == b[i] && b[i] == c[i]) {
continue;
}
if (a[i] != b[i] && b[i] != c[i] && a[i] != c[i]) {
ans += 3;
continue;
}
ans += 1;
}
cout << ans << '\n';
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
char a[100], b[100], c[100];
for (int i = 0; i != n; i++) {
cin >> a[i];
}
for (int i = 0; i != n; i++) {
cin >> b[i];
}
for (int i = 0; i != n; i++) {
cin >> c[i];
}
int ans = 0;
for (int i = 0; i != n; i++) {
if (a[i] == b[i] && b[i] == c[i]) {
continue;
}
if (a[i] != b[i] && b[i] != c[i] && a[i] != c[i]) {
ans += 2;
continue;
}
ans += 1;
}
cout << ans << '\n';
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 940,619 | 940,620 | u589810630 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a, b, n;
cin >> n >> a >> b;
cout << min(a, b) << max(0, (a + b - n)) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a, b, n;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, (a + b - n)) << endl;
return 0;
} | [
"io.output.change"
] | 940,514 | 940,515 | u617380180 | cpp |
p03139 | #include <bits/stdc++.h>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
//#define int long long
typedef long long ll;
using namespace std;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
const pair<int, int> fd[] = {make_pair(1, 0), make_pair(-1, 0), make_pair(0, 1),
make_pair(0, -1)};
signed main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << a + b - n << endl;
}
| #include <bits/stdc++.h>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
//#define int long long
typedef long long ll;
using namespace std;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
const pair<int, int> fd[] = {make_pair(1, 0), make_pair(-1, 0), make_pair(0, 1),
make_pair(0, -1)};
signed main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(a + b - n, 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 940,516 | 940,517 | u317754719 | cpp |
p03139 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << (a + b) - n << endl;
return 0;
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max((a + b) - n, 0) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 940,520 | 940,521 | u772304668 | cpp |
p03139 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tiii = tuple<int, int, int>;
#define mod7 1000000007
#define mod9 1000000009
#define forall(v) v.begin(), v.end()
#define prec(x) setprecision(x) << fixed
/* [💭] [💡] [🎈] */
int main() {
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
cout << max(a, b) << ' ' << max(0, a + b - n);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tiii = tuple<int, int, int>;
#define mod7 1000000007
#define mod9 1000000009
#define forall(v) v.begin(), v.end()
#define prec(x) setprecision(x) << fixed
/* [💭] [💡] [🎈] */
int main() {
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << ' ' << max(0, a + b - n);
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 940,522 | 940,523 | u953074801 | cpp |
p03140 | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<int, ld> Pid;
typedef pair<int, string> Pis;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repm(i, s, n) for (int i = s; i < n; i++)
#define all(a) (a).begin(), (a).end()
const int INF = 1 << 30;
const ll INF_L = 1LL << 60;
const int MOD = 1e9 + 7; // 998244353;
void coi(ll i) { cout << i << endl; }
void cois(ll i) { cout << i << " "; }
void cod(ld d) {
cout << fixed << setprecision(16);
cout << d << endl;
}
void cods(ld d) {
cout << fixed << setprecision(16);
cout << d << " ";
}
void coc(char c) { cout << c << endl; }
void cocs(char c) { cout << c << " "; }
void cos(string s) { cout << s << endl; }
void coss(string s) { cout << s << " "; }
void coynl(bool b) { cos(b ? "Yes" : "No"); }
void coYNU(bool b) { cos(b ? "YES" : "NO"); }
// ----------------------------------------------------------------
// String Functions
// ----------------------------------------------------------------
int ctoi(char c) {
if (isdigit(c))
return c - '0';
else if (islower(c))
return c - 'a';
else if (isupper(c))
return c - 'A';
else
return -1;
}
char itocd(int i) {
char c = i + '0';
if (isdigit(c))
return c;
else
return 0x00;
}
char itocl(int i) {
char c = i + 'a';
if (islower(c))
return c;
else
return 0x00;
}
char itocu(int i) {
char c = i + 'A';
if (isupper(c))
return c;
else
return 0x00;
}
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// Dynamical Programming
// ----------------------------------------------------------------
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;
}
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// Graph Theory
// ----------------------------------------------------------------
struct edge {
ll to, cost;
};
struct GraphList {
ll V;
vector<vector<edge>> graph;
vector<ll> dist;
GraphList(ll N) { init(N); }
void init(ll N) {
V = N;
graph.resize(V);
dist.resize(V);
for (int i = 0; i < V; i++) {
dist[i] = INF_L;
}
}
void add_edge(ll from, ll to, ll cost) {
edge e;
e.to = to;
e.cost = cost;
graph[from].push_back(e);
}
void dijkstra(ll s) {
for (int i = 0; i < V; i++) {
dist[i] = INF_L;
}
dist[s] = 0;
priority_queue<Pll, vector<Pll>, greater<Pll>> que;
que.push(Pll(0, s));
while (!que.empty()) {
Pll p = que.top();
que.pop();
ll v = p.second;
if (dist[v] < p.first)
continue;
for (auto e : graph[v]) {
if (dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
que.push(Pll(dist[e.to], e.to));
}
}
}
}
void bellman_ford(ll s) {
for (int i = 0; i < V; i++) {
dist[i] = INF_L;
}
dist[s] = 0;
/* Under construction */
}
};
struct GraphMatrix {
ll vertex;
vector<vector<edge>> graph;
vector<ll> dist;
GraphMatrix(ll N) { init(N); }
void init(ll N) {
vertex = N;
graph.resize(vertex);
dist.resize(vertex);
for (int i = 0; i < vertex; i++) {
dist[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost) {
edge e;
e.to = t;
e.cost = cost;
graph[s].push_back(e);
}
void warshall_floyd(ll s) {
for (int i = 0; i < vertex; i++) {
dist[i] = INF;
}
dist[s] = 0;
/* Under construction */
}
};
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// Mathematical Functions
// ----------------------------------------------------------------
ll gcd(ll A, ll B) {
if (A % B == 0) {
return (B);
} else {
return (gcd(B, A % B));
}
}
ll lcm(ll A, ll B) { return A * B / gcd(A, B); }
ll getDigit(ll N) { return (ll)(to_string(N).length()); }
ll getDigitForBase(ll N, ll B) {
if (B < 2) {
return -1;
} else if (B == 10) {
return getDigit(N);
} else {
ll r = 0;
while (N != 0) {
N /= B;
r++;
}
return r;
}
}
ll getDigitSum(ll N) {
ll r = 0;
string Ns = to_string(N);
for (int i = 0; i < getDigit(N); i++) {
r += ctoi(Ns[i]);
}
return r;
}
ll getDivTimes(ll N, ll D) {
ll r = 0;
while (N % D == 0) {
N /= D;
r++;
}
return r;
}
ll powMod(ll B, ll P) {
if (P == 0)
return 1;
if (P % 2 == 0) {
ll t = powMod(B, P / 2);
return t * t % MOD;
}
return B * powMod(B, P - 1) % MOD;
}
ll invMod(ll N) { return powMod(N, MOD - 2); }
/* ----------------------------------
Factorial, Permutation, Combination
---------------------------------- */
const ll FPC_INIT_SIZE_MAX = 1e6 + 9;
struct FPCMod {
ll size;
vector<ll> inv, fac, finv;
FPCMod(ll N) { init(N); }
void init(ll N) {
size = (N > 1 && N < FPC_INIT_SIZE_MAX) ? N : FPC_INIT_SIZE_MAX;
inv.resize(size);
fac.resize(size);
finv.resize(size);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < size; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll inverseMod(ll N) { return inv[N] % MOD; }
ll factrialMod(ll N) { return fac[N] % MOD; }
ll factrialInverseMod(ll N) { return finv[N] % MOD; }
ll permutationMod(ll N, ll K) {
if (N < 0 || K < 0 || N < K)
return 0;
else
return factrialMod(N) * factrialInverseMod(N - K) % MOD;
}
ll combinationMod(ll N, ll K) {
if (N < 0 || K < 0 || N < K)
return 0;
else if (N < size) {
return factrialMod(N) *
(factrialInverseMod(K) * factrialInverseMod(N - K) % MOD) % MOD;
} else {
ll ans = 1;
ll Ks = K < N - K ? K : N - K;
for (ll i = N; i > N - Ks; i--) {
ans *= i;
ans %= MOD;
}
return ans * factrialInverseMod(Ks) % MOD;
}
}
};
/* ----------------------------------
Sieve Theory
---------------------------------- */
const ll SIEVE_SIZE_MAX = 1e9 + 9;
struct SieveEratosthenes {
SieveEratosthenes() {}
SieveEratosthenes(ll N) {
sieve_fg = true;
sievingp_fg = true;
init(N);
}
SieveEratosthenes(ll N, int c) {
switch (c) {
case 1:
sieve_fg = true;
sievingp_fg = true;
break;
default:
sieve_fg = true;
sievingp_fg = false;
break;
}
init(N);
}
bool isPrime(ll N) {
if (!sieve_fg)
return false;
if (N < 2 || N >= N_max)
return false;
for (auto p : skipPrimes) {
if (N == p)
return true;
if (N % p == 0)
return false;
}
return sieve[numtoidx(N)];
}
ll getSievingPrime(ll N) {
if (!sievingp_fg)
return -1;
if (N < 2 || N >= N_max)
return -1;
for (auto p : skipPrimes) {
if (N % p == 0)
return p;
}
if (isPrime(N))
return N;
return sievingp[numtoidx(N)];
}
private:
ll N_max;
ll size, size_sqrt;
vector<bool> sieve;
bool sieve_fg;
vector<ll> sievingp;
bool sievingp_fg;
vector<ll> primes;
bool primes_fg;
vector<int> skipPrimes = {2, 3, 5};
vector<int> standReminders = {1, 7, 11, 13, 17, 19, 23, 29};
vector<int> invidxStandReminders = {-1, 0, -1, -1, -1, -1, -1, 1, -1, -1,
-1, 2, -1, 3, -1, -1, -1, 4, -1, 5,
-1, -1, -1, 6, -1, -1, -1, -1, -1, 7};
const int SP_prod = 2 * 3 * 5;
int SR_size = 8;
void init(ll N) {
N_max = (N > 1 && N < SIEVE_SIZE_MAX) ? N : SIEVE_SIZE_MAX;
size = (N_max / SP_prod + 1) * SR_size;
size_sqrt = ((ll)sqrt(N_max) / SP_prod + 1) * SR_size;
sieve = vector<bool>(size, true);
sievingp = vector<ll>(size, 0);
primes.clear();
sieveInit();
}
void sieveInit() {
for (ll i = 1; i < size_sqrt; i++) {
if (!sieve[i])
continue;
ll num_i = idxtonum(i);
for (ll j = num_i * num_i; j < N_max; j += num_i) {
ll idx_j = numtoidx(j);
if (idx_j > 0) {
sieve[idx_j] = false;
sievingp[idx_j] = num_i;
}
}
}
}
ll idxtonum(ll idx) {
return (idx / SR_size) * SP_prod + standReminders[idx % SR_size];
}
ll numtoidx(ll num) {
int iiSR = invidxStandReminders[num % SP_prod];
return iiSR < 0 ? -1 : (num / SP_prod) * SR_size + iiSR;
}
};
struct SieveAtkinBernstein {
SieveAtkinBernstein() {}
SieveAtkinBernstein(ll N) { init(N); }
bool isPrime(ll N) {
if (N < 0 || N >= N_max)
return false;
return sieve[N];
}
private:
ll N_max;
ll size, size_sqrt;
vector<bool> sieve;
void init(ll N) {
N_max = (N > 1 && N < SIEVE_SIZE_MAX) ? N : SIEVE_SIZE_MAX;
size = N_max;
size_sqrt = (ll)sqrt(size + 0.1);
sieve.resize(size);
sieveInit(N);
}
void sieveInit(ll N) {
sieve[2] = sieve[3] = true;
int n = 0;
for (int z = 1; z <= 5; z += 4) {
for (int y = z; y <= size_sqrt; y += 6) {
for (int x = 1; x <= size_sqrt && (n = 4 * x * x + y * y) < size; x++)
sieve[n] = !sieve[n];
for (int x = y + 1; x <= size_sqrt && (n = 3 * x * x - y * y) < size;
x += 2)
sieve[n] = !sieve[n];
}
}
for (int z = 2; z <= 4; z += 2) {
for (int y = z; y <= size_sqrt; y += 6) {
for (int x = 1; x <= size_sqrt && (n = 3 * x * x + y * y) < size;
x += 2)
sieve[n] = !sieve[n];
for (int x = y + 1; x <= size_sqrt && (n = 3 * x * x - y * y) < size;
x += 2)
sieve[n] = !sieve[n];
}
}
for (int z = 1; z <= 2; z++) {
for (int y = 3; y <= size_sqrt; y += 6) {
for (int x = z; x <= size_sqrt && (n = 4 * x * x + y * y) < size;
x += 3)
sieve[n] = !sieve[n];
}
}
for (int k = 5; k <= size_sqrt; k++)
if (sieve[k])
for (int n = k * k; n < size; n += k * k)
sieve[n] = false;
}
};
/* ----------------------------------
Prime Factorization
---------------------------------- */
const ll PRIME_FACTORIZATION_SIZE_MAX = 1e9 + 9;
struct primeFactrization {
primeFactrization(){};
primeFactrization(ll N_max) { init(N_max, false); }
void add_vec(ll N) {
if (N < 2 || N > PRIME_FACTORIZATION_SIZE_MAX)
return;
if (sieve_fg && N > SIEVE_SIZE_MAX)
return;
ll idx = (int)idxVec.size();
idxVec[N] = ++idx;
if (sieve_fg)
add_vec_withSieve(idx);
else
add_vec_withoutSieve(idx);
sort(primeFactorVec[idx].begin(), primeFactorVec[idx].end());
}
void add_map(ll N) {
if (N < 2 || N > PRIME_FACTORIZATION_SIZE_MAX)
return;
if (sieve_fg && N > SIEVE_SIZE_MAX)
return;
ll idx = (int)idxMap.size();
idxMap[N] = ++idx;
if (sieve_fg)
add_map_withSieve(idx);
else
add_vec_withoutSieve(idx);
}
vector<ll> getPrimeFactorizeVec(ll N) {
if (idxVec[N] == 0)
return vector<ll>();
return primeFactorVec[idxVec[N]];
}
map<ll, ll> getPrimeFactorizeMap(ll N) {
if (idxMap[N] == 0)
return map<ll, ll>();
return primeFactorMap[idxMap[N]];
}
private:
map<ll, ll> idxVec, idxMap;
vector<vector<ll>> primeFactorVec;
vector<map<ll, ll>> primeFactorMap;
bool sieve_fg;
SieveEratosthenes sieve;
void init(ll N_max, bool fg) {
idxVec.clear();
idxMap.clear();
primeFactorVec.clear();
primeFactorMap.clear();
sieve_fg = fg;
if (sieve_fg)
SieveEratosthenes sieve(N_max);
}
void add_vec_withSieve(ll idx) {
ll N = idxVec[idx];
ll Nc = N;
while (Nc > 1) {
ll div = sieve.getSievingPrime(Nc);
ll mul = 1;
while (Nc % div == 0) {
mul *= div;
primeFactorVec[idx].push_back(mul);
primeFactorVec[idx].push_back(N / mul);
Nc /= div;
}
}
}
void add_vec_withoutSieve(ll idx) {
ll N = idxVec[idx];
ll Nc = N;
primeFactorVec[idx].push_back(1);
primeFactorVec[idx].push_back(N);
while (Nc > 1) {
for (ll div = 2; div <= (ll)sqrt(N + 0.1); div++) {
ll mul = 1;
while (Nc % div == 0) {
mul *= div;
primeFactorVec[idx].push_back(mul);
primeFactorVec[idx].push_back(N / mul);
Nc /= div;
}
}
}
}
void add_map_withSieve(ll idx) {
ll N = idxMap[idx];
ll Nc = N;
while (Nc > 1) {
ll div = sieve.getSievingPrime(Nc);
primeFactorMap[idx][div]++;
Nc /= div;
}
}
void add_map_withoutSieve(ll idx) {
ll N = idxMap[idx];
ll Nc = N;
while (Nc > 1) {
for (ll div = 2; div <= (ll)sqrt(N + 0.1); div++) {
while (N % div == 0) {
primeFactorMap[idx][div]++;
Nc /= div;
}
}
if (Nc > 1) {
primeFactorMap[idx][Nc]++;
Nc /= Nc;
}
}
}
};
// ----------------------------------------------------------------
//* **************** GLOBAL VARIABLES **************** *//
//* **************************************************** *//
void input() {}
void solve() {
int N;
string A[3];
cin >> N >> A[0] >> A[1] >> A[2];
int ans = 0;
rep(i, N) {
if (A[0][i] == A[1][i] && A[1][i] == A[2][i])
continue;
else if (A[0][i] != A[1][i] && A[1][i] != A[2][i] && A[2][i] == A[0][i])
ans += 2;
else
ans++;
}
coi(ans);
}
int main() {
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
input();
solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<int, ld> Pid;
typedef pair<int, string> Pis;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repm(i, s, n) for (int i = s; i < n; i++)
#define all(a) (a).begin(), (a).end()
const int INF = 1 << 30;
const ll INF_L = 1LL << 60;
const int MOD = 1e9 + 7; // 998244353;
void coi(ll i) { cout << i << endl; }
void cois(ll i) { cout << i << " "; }
void cod(ld d) {
cout << fixed << setprecision(16);
cout << d << endl;
}
void cods(ld d) {
cout << fixed << setprecision(16);
cout << d << " ";
}
void coc(char c) { cout << c << endl; }
void cocs(char c) { cout << c << " "; }
void cos(string s) { cout << s << endl; }
void coss(string s) { cout << s << " "; }
void coynl(bool b) { cos(b ? "Yes" : "No"); }
void coYNU(bool b) { cos(b ? "YES" : "NO"); }
// ----------------------------------------------------------------
// String Functions
// ----------------------------------------------------------------
int ctoi(char c) {
if (isdigit(c))
return c - '0';
else if (islower(c))
return c - 'a';
else if (isupper(c))
return c - 'A';
else
return -1;
}
char itocd(int i) {
char c = i + '0';
if (isdigit(c))
return c;
else
return 0x00;
}
char itocl(int i) {
char c = i + 'a';
if (islower(c))
return c;
else
return 0x00;
}
char itocu(int i) {
char c = i + 'A';
if (isupper(c))
return c;
else
return 0x00;
}
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// Dynamical Programming
// ----------------------------------------------------------------
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;
}
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// Graph Theory
// ----------------------------------------------------------------
struct edge {
ll to, cost;
};
struct GraphList {
ll V;
vector<vector<edge>> graph;
vector<ll> dist;
GraphList(ll N) { init(N); }
void init(ll N) {
V = N;
graph.resize(V);
dist.resize(V);
for (int i = 0; i < V; i++) {
dist[i] = INF_L;
}
}
void add_edge(ll from, ll to, ll cost) {
edge e;
e.to = to;
e.cost = cost;
graph[from].push_back(e);
}
void dijkstra(ll s) {
for (int i = 0; i < V; i++) {
dist[i] = INF_L;
}
dist[s] = 0;
priority_queue<Pll, vector<Pll>, greater<Pll>> que;
que.push(Pll(0, s));
while (!que.empty()) {
Pll p = que.top();
que.pop();
ll v = p.second;
if (dist[v] < p.first)
continue;
for (auto e : graph[v]) {
if (dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
que.push(Pll(dist[e.to], e.to));
}
}
}
}
void bellman_ford(ll s) {
for (int i = 0; i < V; i++) {
dist[i] = INF_L;
}
dist[s] = 0;
/* Under construction */
}
};
struct GraphMatrix {
ll vertex;
vector<vector<edge>> graph;
vector<ll> dist;
GraphMatrix(ll N) { init(N); }
void init(ll N) {
vertex = N;
graph.resize(vertex);
dist.resize(vertex);
for (int i = 0; i < vertex; i++) {
dist[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost) {
edge e;
e.to = t;
e.cost = cost;
graph[s].push_back(e);
}
void warshall_floyd(ll s) {
for (int i = 0; i < vertex; i++) {
dist[i] = INF;
}
dist[s] = 0;
/* Under construction */
}
};
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// Mathematical Functions
// ----------------------------------------------------------------
ll gcd(ll A, ll B) {
if (A % B == 0) {
return (B);
} else {
return (gcd(B, A % B));
}
}
ll lcm(ll A, ll B) { return A * B / gcd(A, B); }
ll getDigit(ll N) { return (ll)(to_string(N).length()); }
ll getDigitForBase(ll N, ll B) {
if (B < 2) {
return -1;
} else if (B == 10) {
return getDigit(N);
} else {
ll r = 0;
while (N != 0) {
N /= B;
r++;
}
return r;
}
}
ll getDigitSum(ll N) {
ll r = 0;
string Ns = to_string(N);
for (int i = 0; i < getDigit(N); i++) {
r += ctoi(Ns[i]);
}
return r;
}
ll getDivTimes(ll N, ll D) {
ll r = 0;
while (N % D == 0) {
N /= D;
r++;
}
return r;
}
ll powMod(ll B, ll P) {
if (P == 0)
return 1;
if (P % 2 == 0) {
ll t = powMod(B, P / 2);
return t * t % MOD;
}
return B * powMod(B, P - 1) % MOD;
}
ll invMod(ll N) { return powMod(N, MOD - 2); }
/* ----------------------------------
Factorial, Permutation, Combination
---------------------------------- */
const ll FPC_INIT_SIZE_MAX = 1e6 + 9;
struct FPCMod {
ll size;
vector<ll> inv, fac, finv;
FPCMod(ll N) { init(N); }
void init(ll N) {
size = (N > 1 && N < FPC_INIT_SIZE_MAX) ? N : FPC_INIT_SIZE_MAX;
inv.resize(size);
fac.resize(size);
finv.resize(size);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < size; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll inverseMod(ll N) { return inv[N] % MOD; }
ll factrialMod(ll N) { return fac[N] % MOD; }
ll factrialInverseMod(ll N) { return finv[N] % MOD; }
ll permutationMod(ll N, ll K) {
if (N < 0 || K < 0 || N < K)
return 0;
else
return factrialMod(N) * factrialInverseMod(N - K) % MOD;
}
ll combinationMod(ll N, ll K) {
if (N < 0 || K < 0 || N < K)
return 0;
else if (N < size) {
return factrialMod(N) *
(factrialInverseMod(K) * factrialInverseMod(N - K) % MOD) % MOD;
} else {
ll ans = 1;
ll Ks = K < N - K ? K : N - K;
for (ll i = N; i > N - Ks; i--) {
ans *= i;
ans %= MOD;
}
return ans * factrialInverseMod(Ks) % MOD;
}
}
};
/* ----------------------------------
Sieve Theory
---------------------------------- */
const ll SIEVE_SIZE_MAX = 1e9 + 9;
struct SieveEratosthenes {
SieveEratosthenes() {}
SieveEratosthenes(ll N) {
sieve_fg = true;
sievingp_fg = true;
init(N);
}
SieveEratosthenes(ll N, int c) {
switch (c) {
case 1:
sieve_fg = true;
sievingp_fg = true;
break;
default:
sieve_fg = true;
sievingp_fg = false;
break;
}
init(N);
}
bool isPrime(ll N) {
if (!sieve_fg)
return false;
if (N < 2 || N >= N_max)
return false;
for (auto p : skipPrimes) {
if (N == p)
return true;
if (N % p == 0)
return false;
}
return sieve[numtoidx(N)];
}
ll getSievingPrime(ll N) {
if (!sievingp_fg)
return -1;
if (N < 2 || N >= N_max)
return -1;
for (auto p : skipPrimes) {
if (N % p == 0)
return p;
}
if (isPrime(N))
return N;
return sievingp[numtoidx(N)];
}
private:
ll N_max;
ll size, size_sqrt;
vector<bool> sieve;
bool sieve_fg;
vector<ll> sievingp;
bool sievingp_fg;
vector<ll> primes;
bool primes_fg;
vector<int> skipPrimes = {2, 3, 5};
vector<int> standReminders = {1, 7, 11, 13, 17, 19, 23, 29};
vector<int> invidxStandReminders = {-1, 0, -1, -1, -1, -1, -1, 1, -1, -1,
-1, 2, -1, 3, -1, -1, -1, 4, -1, 5,
-1, -1, -1, 6, -1, -1, -1, -1, -1, 7};
const int SP_prod = 2 * 3 * 5;
int SR_size = 8;
void init(ll N) {
N_max = (N > 1 && N < SIEVE_SIZE_MAX) ? N : SIEVE_SIZE_MAX;
size = (N_max / SP_prod + 1) * SR_size;
size_sqrt = ((ll)sqrt(N_max) / SP_prod + 1) * SR_size;
sieve = vector<bool>(size, true);
sievingp = vector<ll>(size, 0);
primes.clear();
sieveInit();
}
void sieveInit() {
for (ll i = 1; i < size_sqrt; i++) {
if (!sieve[i])
continue;
ll num_i = idxtonum(i);
for (ll j = num_i * num_i; j < N_max; j += num_i) {
ll idx_j = numtoidx(j);
if (idx_j > 0) {
sieve[idx_j] = false;
sievingp[idx_j] = num_i;
}
}
}
}
ll idxtonum(ll idx) {
return (idx / SR_size) * SP_prod + standReminders[idx % SR_size];
}
ll numtoidx(ll num) {
int iiSR = invidxStandReminders[num % SP_prod];
return iiSR < 0 ? -1 : (num / SP_prod) * SR_size + iiSR;
}
};
struct SieveAtkinBernstein {
SieveAtkinBernstein() {}
SieveAtkinBernstein(ll N) { init(N); }
bool isPrime(ll N) {
if (N < 0 || N >= N_max)
return false;
return sieve[N];
}
private:
ll N_max;
ll size, size_sqrt;
vector<bool> sieve;
void init(ll N) {
N_max = (N > 1 && N < SIEVE_SIZE_MAX) ? N : SIEVE_SIZE_MAX;
size = N_max;
size_sqrt = (ll)sqrt(size + 0.1);
sieve.resize(size);
sieveInit(N);
}
void sieveInit(ll N) {
sieve[2] = sieve[3] = true;
int n = 0;
for (int z = 1; z <= 5; z += 4) {
for (int y = z; y <= size_sqrt; y += 6) {
for (int x = 1; x <= size_sqrt && (n = 4 * x * x + y * y) < size; x++)
sieve[n] = !sieve[n];
for (int x = y + 1; x <= size_sqrt && (n = 3 * x * x - y * y) < size;
x += 2)
sieve[n] = !sieve[n];
}
}
for (int z = 2; z <= 4; z += 2) {
for (int y = z; y <= size_sqrt; y += 6) {
for (int x = 1; x <= size_sqrt && (n = 3 * x * x + y * y) < size;
x += 2)
sieve[n] = !sieve[n];
for (int x = y + 1; x <= size_sqrt && (n = 3 * x * x - y * y) < size;
x += 2)
sieve[n] = !sieve[n];
}
}
for (int z = 1; z <= 2; z++) {
for (int y = 3; y <= size_sqrt; y += 6) {
for (int x = z; x <= size_sqrt && (n = 4 * x * x + y * y) < size;
x += 3)
sieve[n] = !sieve[n];
}
}
for (int k = 5; k <= size_sqrt; k++)
if (sieve[k])
for (int n = k * k; n < size; n += k * k)
sieve[n] = false;
}
};
/* ----------------------------------
Prime Factorization
---------------------------------- */
const ll PRIME_FACTORIZATION_SIZE_MAX = 1e9 + 9;
struct primeFactrization {
primeFactrization(){};
primeFactrization(ll N_max) { init(N_max, false); }
void add_vec(ll N) {
if (N < 2 || N > PRIME_FACTORIZATION_SIZE_MAX)
return;
if (sieve_fg && N > SIEVE_SIZE_MAX)
return;
ll idx = (int)idxVec.size();
idxVec[N] = ++idx;
if (sieve_fg)
add_vec_withSieve(idx);
else
add_vec_withoutSieve(idx);
sort(primeFactorVec[idx].begin(), primeFactorVec[idx].end());
}
void add_map(ll N) {
if (N < 2 || N > PRIME_FACTORIZATION_SIZE_MAX)
return;
if (sieve_fg && N > SIEVE_SIZE_MAX)
return;
ll idx = (int)idxMap.size();
idxMap[N] = ++idx;
if (sieve_fg)
add_map_withSieve(idx);
else
add_vec_withoutSieve(idx);
}
vector<ll> getPrimeFactorizeVec(ll N) {
if (idxVec[N] == 0)
return vector<ll>();
return primeFactorVec[idxVec[N]];
}
map<ll, ll> getPrimeFactorizeMap(ll N) {
if (idxMap[N] == 0)
return map<ll, ll>();
return primeFactorMap[idxMap[N]];
}
private:
map<ll, ll> idxVec, idxMap;
vector<vector<ll>> primeFactorVec;
vector<map<ll, ll>> primeFactorMap;
bool sieve_fg;
SieveEratosthenes sieve;
void init(ll N_max, bool fg) {
idxVec.clear();
idxMap.clear();
primeFactorVec.clear();
primeFactorMap.clear();
sieve_fg = fg;
if (sieve_fg)
SieveEratosthenes sieve(N_max);
}
void add_vec_withSieve(ll idx) {
ll N = idxVec[idx];
ll Nc = N;
while (Nc > 1) {
ll div = sieve.getSievingPrime(Nc);
ll mul = 1;
while (Nc % div == 0) {
mul *= div;
primeFactorVec[idx].push_back(mul);
primeFactorVec[idx].push_back(N / mul);
Nc /= div;
}
}
}
void add_vec_withoutSieve(ll idx) {
ll N = idxVec[idx];
ll Nc = N;
primeFactorVec[idx].push_back(1);
primeFactorVec[idx].push_back(N);
while (Nc > 1) {
for (ll div = 2; div <= (ll)sqrt(N + 0.1); div++) {
ll mul = 1;
while (Nc % div == 0) {
mul *= div;
primeFactorVec[idx].push_back(mul);
primeFactorVec[idx].push_back(N / mul);
Nc /= div;
}
}
}
}
void add_map_withSieve(ll idx) {
ll N = idxMap[idx];
ll Nc = N;
while (Nc > 1) {
ll div = sieve.getSievingPrime(Nc);
primeFactorMap[idx][div]++;
Nc /= div;
}
}
void add_map_withoutSieve(ll idx) {
ll N = idxMap[idx];
ll Nc = N;
while (Nc > 1) {
for (ll div = 2; div <= (ll)sqrt(N + 0.1); div++) {
while (N % div == 0) {
primeFactorMap[idx][div]++;
Nc /= div;
}
}
if (Nc > 1) {
primeFactorMap[idx][Nc]++;
Nc /= Nc;
}
}
}
};
// ----------------------------------------------------------------
//* **************** GLOBAL VARIABLES **************** *//
//* **************************************************** *//
void input() {}
void solve() {
int N;
string A[3];
cin >> N >> A[0] >> A[1] >> A[2];
int ans = 0;
rep(i, N) {
if (A[0][i] == A[1][i] && A[1][i] == A[2][i])
continue;
else if (A[0][i] != A[1][i] && A[1][i] != A[2][i] && A[2][i] != A[0][i])
ans += 2;
else
ans++;
}
coi(ans);
}
int main() {
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
input();
solve();
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 940,530 | 940,531 | u947236878 | cpp |
p03140 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, ans;
string A, B, C;
cin >> N >> A >> B >> C;
ans = 2 * N;
for (int i = 0; i < N; ++i) {
if (A[i] == B[i] == C[i])
ans -= 2;
else if (A[i] == B[i] && B[i] != C[i])
ans -= 1;
else if (B[i] == C[i] && C[i] != A[i])
ans -= 1;
else if (C[i] == A[i] && A[i] != B[i])
ans -= 1;
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, ans;
string A, B, C;
cin >> N >> A >> B >> C;
ans = 2 * N;
for (int i = 0; i < N; ++i) {
if (A[i] == B[i] && B[i] == C[i])
ans -= 2;
else if (A[i] == B[i] && B[i] != C[i])
ans -= 1;
else if (B[i] == C[i] && C[i] != A[i])
ans -= 1;
else if (C[i] == A[i] && A[i] != B[i])
ans -= 1;
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 940,627 | 940,628 | u041282550 | cpp |
p03140 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> p;
const int inf = (1 << 30);
#define rep(i, a, n) for (int i = a; i < n; i++)
#define rrep(i, a, n) for (int i = (a - 1); i >= n; i--)
int main() {
ll n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
ll ans = 0;
rep(i, 0, n) {
if (a[i] == b[i] == c[i])
continue;
else if (a[i] == b[i])
ans++;
else if (b[i] == c[i])
ans++;
else if (c[i] == a[i])
ans++;
else
ans += 2;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> p;
const int inf = (1 << 30);
#define rep(i, a, n) for (int i = a; i < n; i++)
#define rrep(i, a, n) for (int i = (a - 1); i >= n; i--)
int main() {
ll n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
ll ans = 0;
rep(i, 0, n) {
if (a[i] == b[i] && b[i] == c[i])
continue;
else if (a[i] == b[i])
ans++;
else if (b[i] == c[i])
ans++;
else if (c[i] == a[i])
ans++;
else
ans += 2;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 940,638 | 940,639 | u075865455 | cpp |
p03140 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int i, j, k;
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int result = 0;
int temp;
for (i = 0; i < n; i++) {
temp = 0;
if (a[i] == b[i]) {
temp = 1;
if (a[i] == c[i]) {
temp = 2;
}
} else {
if (a[i] == c[i]) {
temp = 1;
} else {
if (b[i] == c[i]) {
temp = 1;
}
}
}
if (temp == 0) {
result += 2;
} else if (temp == 1) {
temp++;
}
}
printf("%d", result);
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int i, j, k;
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int result = 0;
int temp;
for (i = 0; i < n; i++) {
temp = 0;
if (a[i] == b[i]) {
temp = 1;
if (a[i] == c[i]) {
temp = 2;
}
} else {
if (a[i] == c[i]) {
temp = 1;
} else {
if (b[i] == c[i]) {
temp = 1;
}
}
}
if (temp == 0) {
result += 2;
} else if (temp == 1) {
result++;
}
}
printf("%d", result);
return 0;
}
| [
"identifier.change"
] | 940,640 | 940,641 | u649220991 | cpp |
p03140 |
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <vector>
//#include "boost/variant.hpp"
// #include "bits/stdc++.h"
using namespace std;
#define rep(i, N, M) for (ll i = N, i##_len = (M); i < i##_len; ++i)
#define rep_skip(i, N, M, ...) \
for (ll i = N, i##_len = (M); i < i##_len; i += (skip))
#define rrep(i, N, M) for (ll i = (M)-1, i##_len = (N - 1); i > i##_len; --i)
#define pb push_back
typedef pair<double, double> pd;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef tuple<ll, ll, ll> tll;
typedef tuple<ll, ll, ll, ll> tll4;
typedef tuple<ll, ll, ll, ll, ll> tll5;
typedef tuple<ll, ll, ll, ll, ll, ll> tll6;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template <typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define vec(a) vector<a>
#define perm(c) \
sort(all(c)); \
for (bool c##perm = 1; c##perm; c##perm = next_permutation(all(c)))
template <typename T1, typename T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
constexpr ll POW_(ll n, ll m) {
ll res = 1;
rep(i, 0, m) { res *= n; }
return res;
}
template <int mod = 0> constexpr ll POW(ll x, ll n) {
if (x == 2) {
return (1LL << n) % mod;
}
if (n == 0)
return 1;
if (n == 1)
return x % mod;
if (n % 2 == 0)
return POW_(POW<mod>(x, n / 2), 2LL) % mod;
return ((POW_(POW<mod>(x, n / 2, mod), 2LL) % mod) * (x % mod)) % mod;
}
template <> constexpr ll POW<0>(ll x, ll n) {
if (x == 2) {
return 1LL << n;
}
if (n == 0)
return 1;
if (n == 1)
return x;
if (n % 2 == 0)
return POW_(POW(x, n / 2), 2);
return (POW_(POW(x, n / 2), 2)) * x;
}
template <ll bit> ll at_bit(ll n, ll i) { return n / POW(bit, i) % bit; }
template <> ll at_bit<2>(ll n, ll i) { return (n >> i) % 2LL; }
template <ll bit> ll get_bit(ll i) { return POW(bit, i); }
template <> ll get_bit<2>(ll i) { return 1LL << i; }
template <ll bit> ll get_max_bit(ll n) {
ll tmp = bit;
ll at = 0;
while (tmp <= n) {
at++;
tmp *= bit;
}
return at;
}
template <> ll get_max_bit<2>(ll n) {
ll tmp = 2;
ll at = 0;
while (tmp <= n) {
at++;
tmp <<= 1;
}
return at;
}
vll getDivisors(ll n) {
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
res.push_back(i);
res.push_back(n / i);
}
}
if (i * i == n)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
vll getDivisors(ll n, ll m) {
if (n > m)
swap(n, m);
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
if (m % i == 0)
res.push_back(i);
if (m % (n / i) == 0)
res.push_back(n / i);
}
}
if (i * i == n)
if (m % i == 0)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs &inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs &inputs, Functor f) {
std::stable_sort(
std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
// Functor is expected to be functional<val ,bool>
// This function returns the maximum iterator that stisfies f(*it) == f(*
// inputs.begin())
template <typename Inputs, typename Functor,
typename ValType = typename Inputs::value_type>
pair<typename Inputs::iterator, typename Inputs::iterator>
binary_solve(Inputs &inputs, Functor f) {
auto left = inputs.begin();
auto right = inputs.end();
auto n = inputs.size();
auto left_val = f(*left);
auto right_val = f(*(right - 1));
// check
assert(n >= 2);
assert(left_val != right_val);
while (left + 1 != right) {
auto mid = left + (right - left) / 2;
if (f(*mid) == left_val) {
left = mid;
} else {
right = mid;
}
}
return {left, right};
}
template <int I> vll proj(vpll v) {
vll res(v.size());
rep(i, 0, v.size()) {
if (!I)
res[i] = v[i].first;
else
res[i] = v[i].second;
}
return res;
}
template <int I, class T> vll proj(T v) {
vll res(v.size());
rep(i, 0, v.size()) { res[i] = get<I>(v[i]); }
return res;
}
vector<pll> prime_factorize(ll n) {
vector<pll> res;
for (ll p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
ll num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back({p, num});
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
ll MOD = 1000000007;
ll INF = 1LL << 60;
ll n;
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename Monoid> struct segment_tree {
using underlying_type = typename Monoid::underlying_type;
segment_tree(ll a_n) : size_original(a_n) {
vector<underlying_type> initial_value =
vector<underlying_type>(a_n, Monoid::unit());
segment_tree_impl(a_n, initial_value);
}
segment_tree(ll a_n, vector<underlying_type> &initial_value)
: size_original(a_n) {
segment_tree_impl(a_n, initial_value);
}
void update(int i, underlying_type z) { // 0-based
assert(0 <= i && i < 2 * n - 1);
a[i + n - 1] = z;
for (i = (i + n) / 2; i > 0; i /= 2) { // 1-based
a[i - 1] = Monoid::append(a[2 * i - 1], a[2 * i]);
}
}
underlying_type query(ll l, ll r) { // 0-based, [l, r)
underlying_type lacc = Monoid::unit(), racc = Monoid::unit();
assert(l <= r && r <= n);
l += n;
r += n;
for (; l < r; l /= 2, r /= 2) { // 1-based loop, 2x faster than recursion
if (l % 2 == 1)
lacc = Monoid::append(lacc, a[(l++) - 1]);
if (r % 2 == 1)
racc = Monoid::append(a[(--r) - 1], racc);
}
return Monoid::append(lacc, racc);
}
ll size() { return size_original; }
private:
ll size_original;
ll n;
vector<underlying_type> a;
void segment_tree_impl(ll a_n, vector<underlying_type> &initial_value) {
assert(a_n == initial_value.size());
n = 1;
while (n < a_n)
n *= 2;
a.resize(2 * n - 1, Monoid::unit());
rep(i, 0, initial_value.size()) { a[i + (n - 1)] = initial_value[i]; }
rrep(i, 0, n - 1) a[i] =
Monoid::append(a[2 * i + 1], a[2 * i + 2]); // propagate initial values
}
};
template <typename T> struct min_indexed_t {
typedef pair<T, ll> underlying_type;
static underlying_type make_indexed(vector<T> v) {
underlying_type w(v.size());
rep(i, 0, v.size()) { w[i] = {v[i], i}; }
return w;
}
static underlying_type unit() {
return make_pair(numeric_limits<T>::max(), -1);
}
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
template <typename T> struct min_t {
typedef T underlying_type;
static underlying_type unit() { return numeric_limits<T>::max(); }
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
struct linear_t {
typedef pd underlying_type;
static underlying_type unit() { return underlying_type{1., 0.}; }
static underlying_type append(underlying_type a, underlying_type b) {
return underlying_type{a.first * b.first, b.first * a.second + b.second};
}
};
int main() {
ll N;
string A, B, C;
cin >> N >> A >> B >> C;
ll cnt = 0;
rep(i, 0, N) {
if (A[i] == B[i] && B[i] == C[i])
;
else if (A[i] == B[i] || A[i] == C[i] || B[i] == C[i])
cnt++;
else
cnt++;
}
cout << cnt;
label_:;
return 0;
}
|
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <vector>
//#include "boost/variant.hpp"
// #include "bits/stdc++.h"
using namespace std;
#define rep(i, N, M) for (ll i = N, i##_len = (M); i < i##_len; ++i)
#define rep_skip(i, N, M, ...) \
for (ll i = N, i##_len = (M); i < i##_len; i += (skip))
#define rrep(i, N, M) for (ll i = (M)-1, i##_len = (N - 1); i > i##_len; --i)
#define pb push_back
typedef pair<double, double> pd;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef tuple<ll, ll, ll> tll;
typedef tuple<ll, ll, ll, ll> tll4;
typedef tuple<ll, ll, ll, ll, ll> tll5;
typedef tuple<ll, ll, ll, ll, ll, ll> tll6;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template <typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define vec(a) vector<a>
#define perm(c) \
sort(all(c)); \
for (bool c##perm = 1; c##perm; c##perm = next_permutation(all(c)))
template <typename T1, typename T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
constexpr ll POW_(ll n, ll m) {
ll res = 1;
rep(i, 0, m) { res *= n; }
return res;
}
template <int mod = 0> constexpr ll POW(ll x, ll n) {
if (x == 2) {
return (1LL << n) % mod;
}
if (n == 0)
return 1;
if (n == 1)
return x % mod;
if (n % 2 == 0)
return POW_(POW<mod>(x, n / 2), 2LL) % mod;
return ((POW_(POW<mod>(x, n / 2, mod), 2LL) % mod) * (x % mod)) % mod;
}
template <> constexpr ll POW<0>(ll x, ll n) {
if (x == 2) {
return 1LL << n;
}
if (n == 0)
return 1;
if (n == 1)
return x;
if (n % 2 == 0)
return POW_(POW(x, n / 2), 2);
return (POW_(POW(x, n / 2), 2)) * x;
}
template <ll bit> ll at_bit(ll n, ll i) { return n / POW(bit, i) % bit; }
template <> ll at_bit<2>(ll n, ll i) { return (n >> i) % 2LL; }
template <ll bit> ll get_bit(ll i) { return POW(bit, i); }
template <> ll get_bit<2>(ll i) { return 1LL << i; }
template <ll bit> ll get_max_bit(ll n) {
ll tmp = bit;
ll at = 0;
while (tmp <= n) {
at++;
tmp *= bit;
}
return at;
}
template <> ll get_max_bit<2>(ll n) {
ll tmp = 2;
ll at = 0;
while (tmp <= n) {
at++;
tmp <<= 1;
}
return at;
}
vll getDivisors(ll n) {
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
res.push_back(i);
res.push_back(n / i);
}
}
if (i * i == n)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
vll getDivisors(ll n, ll m) {
if (n > m)
swap(n, m);
vll res;
ll i = 1;
for (; i * i < n; i++) {
if (n % i == 0) {
if (m % i == 0)
res.push_back(i);
if (m % (n / i) == 0)
res.push_back(n / i);
}
}
if (i * i == n)
if (m % i == 0)
res.push_back(i);
sort(res.begin(), res.end());
return res;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs &inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs &inputs, Functor f) {
std::stable_sort(
std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
// Functor is expected to be functional<val ,bool>
// This function returns the maximum iterator that stisfies f(*it) == f(*
// inputs.begin())
template <typename Inputs, typename Functor,
typename ValType = typename Inputs::value_type>
pair<typename Inputs::iterator, typename Inputs::iterator>
binary_solve(Inputs &inputs, Functor f) {
auto left = inputs.begin();
auto right = inputs.end();
auto n = inputs.size();
auto left_val = f(*left);
auto right_val = f(*(right - 1));
// check
assert(n >= 2);
assert(left_val != right_val);
while (left + 1 != right) {
auto mid = left + (right - left) / 2;
if (f(*mid) == left_val) {
left = mid;
} else {
right = mid;
}
}
return {left, right};
}
template <int I> vll proj(vpll v) {
vll res(v.size());
rep(i, 0, v.size()) {
if (!I)
res[i] = v[i].first;
else
res[i] = v[i].second;
}
return res;
}
template <int I, class T> vll proj(T v) {
vll res(v.size());
rep(i, 0, v.size()) { res[i] = get<I>(v[i]); }
return res;
}
vector<pll> prime_factorize(ll n) {
vector<pll> res;
for (ll p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
ll num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back({p, num});
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
ll MOD = 1000000007;
ll INF = 1LL << 60;
ll n;
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename Monoid> struct segment_tree {
using underlying_type = typename Monoid::underlying_type;
segment_tree(ll a_n) : size_original(a_n) {
vector<underlying_type> initial_value =
vector<underlying_type>(a_n, Monoid::unit());
segment_tree_impl(a_n, initial_value);
}
segment_tree(ll a_n, vector<underlying_type> &initial_value)
: size_original(a_n) {
segment_tree_impl(a_n, initial_value);
}
void update(int i, underlying_type z) { // 0-based
assert(0 <= i && i < 2 * n - 1);
a[i + n - 1] = z;
for (i = (i + n) / 2; i > 0; i /= 2) { // 1-based
a[i - 1] = Monoid::append(a[2 * i - 1], a[2 * i]);
}
}
underlying_type query(ll l, ll r) { // 0-based, [l, r)
underlying_type lacc = Monoid::unit(), racc = Monoid::unit();
assert(l <= r && r <= n);
l += n;
r += n;
for (; l < r; l /= 2, r /= 2) { // 1-based loop, 2x faster than recursion
if (l % 2 == 1)
lacc = Monoid::append(lacc, a[(l++) - 1]);
if (r % 2 == 1)
racc = Monoid::append(a[(--r) - 1], racc);
}
return Monoid::append(lacc, racc);
}
ll size() { return size_original; }
private:
ll size_original;
ll n;
vector<underlying_type> a;
void segment_tree_impl(ll a_n, vector<underlying_type> &initial_value) {
assert(a_n == initial_value.size());
n = 1;
while (n < a_n)
n *= 2;
a.resize(2 * n - 1, Monoid::unit());
rep(i, 0, initial_value.size()) { a[i + (n - 1)] = initial_value[i]; }
rrep(i, 0, n - 1) a[i] =
Monoid::append(a[2 * i + 1], a[2 * i + 2]); // propagate initial values
}
};
template <typename T> struct min_indexed_t {
typedef pair<T, ll> underlying_type;
static underlying_type make_indexed(vector<T> v) {
underlying_type w(v.size());
rep(i, 0, v.size()) { w[i] = {v[i], i}; }
return w;
}
static underlying_type unit() {
return make_pair(numeric_limits<T>::max(), -1);
}
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
template <typename T> struct min_t {
typedef T underlying_type;
static underlying_type unit() { return numeric_limits<T>::max(); }
static underlying_type append(underlying_type a, underlying_type b) {
return min(a, b);
}
};
struct linear_t {
typedef pd underlying_type;
static underlying_type unit() { return underlying_type{1., 0.}; }
static underlying_type append(underlying_type a, underlying_type b) {
return underlying_type{a.first * b.first, b.first * a.second + b.second};
}
};
int main() {
ll N;
string A, B, C;
cin >> N >> A >> B >> C;
ll cnt = 0;
rep(i, 0, N) {
if (A[i] == B[i] && B[i] == C[i])
;
else if (A[i] == B[i] || A[i] == C[i] || B[i] == C[i])
cnt++;
else
cnt += 2;
}
cout << cnt;
label_:;
return 0;
}
| [] | 940,648 | 940,649 | u304121198 | cpp |
p03140 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
using namespace std;
int main() {
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
int cnt = 0;
char x[3] = {a[i], b[i], c[i]};
sort(x, x + 3);
if (x[0] == x[2])
cnt = 0;
else if (x[0] == x[1] || x[1] == x[2])
cnt = 1;
ans += cnt;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
using namespace std;
int main() {
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
int cnt = 0;
char x[3] = {a[i], b[i], c[i]};
sort(x, x + 3);
if (x[0] == x[2])
cnt = 0;
else if (x[0] == x[1] || x[1] == x[2])
cnt = 1;
else
cnt = 2;
ans += cnt;
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 940,650 | 940,651 | u906208439 | cpp |
p03140 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const int INF = 1 << 28;
const double EPS = 1e-10;
// cout << fixed << std::setprecision(9)
// memset(a, 0, sizeof(a));
//--------------------------
int n;
string a, b, c;
int main() {
cin >> n;
cin >> a >> b >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
set<char> st;
st.insert(a[i]);
st.insert(b[i]);
st.insert(c[i]);
ans += st.size();
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const int INF = 1 << 28;
const double EPS = 1e-10;
// cout << fixed << std::setprecision(9)
// memset(a, 0, sizeof(a));
//--------------------------
int n;
string a, b, c;
int main() {
cin >> n;
cin >> a >> b >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
set<char> st;
st.insert(a[i]);
st.insert(b[i]);
st.insert(c[i]);
ans += (st.size() - 1);
}
cout << ans << endl;
return 0;
}
| [] | 940,652 | 940,653 | u089869622 | cpp |
p03140 | #include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repeat(i, s, n) for (int(i) = s; (i) < (n); (i)++)
#define revrep(i, n) for (int(i) = (n)-1; i >= 0; i--)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(std::numeric_limits<float>::max_digits10);
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
if (a[i] == b[i] && b[i] == c[i]) {
ans += 0;
} else if (a[i] == b[i] || b[i] == c[i] && c[i] == a[i]) {
ans += 1;
} else {
ans += 2;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repeat(i, s, n) for (int(i) = s; (i) < (n); (i)++)
#define revrep(i, n) for (int(i) = (n)-1; i >= 0; i--)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(std::numeric_limits<float>::max_digits10);
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n) {
if (a[i] == b[i] && b[i] == c[i]) {
ans += 0;
} else if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
ans += 1;
} else {
ans += 2;
}
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 940,654 | 940,655 | u817142576 | cpp |
p03140 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char const *argv[]) {
int N;
string A, B, C;
cin >> N >> A >> B >> C;
int answer;
for (int i = 0; i < N; ++i) {
bool ab = A[i] == B[i];
bool bc = B[i] == C[i];
bool ca = C[i] == A[i];
int matched = ab + bc + ca;
if (matched == 1)
answer++;
else if (matched == 0)
answer += 2;
}
cout << answer << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char const *argv[]) {
int N;
string A, B, C;
cin >> N >> A >> B >> C;
int answer = 0;
for (int i = 0; i < N; ++i) {
bool ab = A[i] == B[i];
bool bc = B[i] == C[i];
bool ca = C[i] == A[i];
int matched = ab + bc + ca;
if (matched == 1)
answer++;
else if (matched == 0)
answer += 2;
}
cout << answer << endl;
return 0;
}
| [
"variable_declaration.value.change"
] | 940,656 | 940,657 | u505240349 | cpp |
p03140 | #include <iostream>
#include <math.h>
#include <stdexcept>
#include <stdlib.h>
#include <utility>
using namespace std;
int int_sort(const void *a, const void *b) {
return *(int *)b - *(int *)a;
// qsort(b, a, sizeof(long long int), int_sort);
}
int main() {
int N, count = 0;
cin >> N;
char a[N], b[N], c[N];
cin >> a >> b >> c;
for (int i = 0; i < N; i++) {
if (a[i] == b[i] && a[i] == c[i])
count += 0;
else if ((a[i] == b[i] && a[i] != c[i]) || (a[i] == c[i] && a[i] != b[i]) ||
(c[i] == b[i] && a[i] != c[i])) {
count += 1;
} else
count + 2;
}
printf("%d", count);
return 0;
}
| #include <iostream>
#include <math.h>
#include <stdexcept>
#include <stdlib.h>
#include <utility>
using namespace std;
int int_sort(const void *a, const void *b) {
return *(int *)b - *(int *)a;
// qsort(b, a, sizeof(long long int), int_sort);
}
int main() {
int N, count = 0;
cin >> N;
char a[N], b[N], c[N];
cin >> a >> b >> c;
for (int i = 0; i < N; i++) {
if (a[i] == b[i] && a[i] == c[i])
count += 0;
else if ((a[i] == b[i] && a[i] != c[i]) || (a[i] == c[i] && a[i] != b[i]) ||
(c[i] == b[i] && a[i] != c[i])) {
count += 1;
} else
count += 2;
}
printf("%d", count);
return 0;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 940,664 | 940,665 | u696415377 | cpp |
p03140 | #include <cmath>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
string a, b, c;
int n, count;
cin >> n;
cin >> a;
cin >> b;
cin >> c;
count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] != c[i]) {
count++;
} else if (a[i] != b[i] && a[i] == c[i]) {
count++;
} else if (a[i] != b[i] && b[i] == c[i]) {
count++;
} else if (a[i] != b[i] && a[i] != c[i]) {
} else {
count += 2;
}
}
cout << count << endl;
return 0;
} | #include <cmath>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
string a, b, c;
int n, count;
cin >> n;
cin >> a;
cin >> b;
cin >> c;
count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] != c[i]) {
count++;
} else if (a[i] != b[i] && a[i] == c[i]) {
count++;
} else if (a[i] != b[i] && b[i] == c[i]) {
count++;
} else if (a[i] != b[i] && a[i] != c[i]) {
count += 2;
} else {
}
}
cout << count << endl;
return 0;
} | [
"control_flow.branch.else.add"
] | 940,670 | 940,671 | u519950235 | cpp |
p03140 | #include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
char a[100], b[100], c[100];
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] == b[i])
continue;
if (a[i] == b[i] || a[i] == c[i] || c[i] == b[i]) {
count++;
continue;
}
count += 2;
}
printf("%d", count);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
char a[100], b[100], c[100];
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] == c[i])
continue;
if (a[i] == b[i] || a[i] == c[i] || c[i] == b[i]) {
count++;
continue;
}
count += 2;
}
printf("%d", count);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 940,691 | 940,692 | u051981922 | cpp |
p03140 | #include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
char a[100], b[100], c[100];
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] == b[i])
continue;
if (a[i] == b[i] || a[i] == b[i] || c[i] == b[i]) {
count++;
continue;
}
count += 2;
}
printf("%d", count);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
char a[100], b[100], c[100];
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] == c[i])
continue;
if (a[i] == b[i] || a[i] == c[i] || c[i] == b[i]) {
count++;
continue;
}
count += 2;
}
printf("%d", count);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 940,693 | 940,692 | u051981922 | cpp |
p03140 | #include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
char a[100], b[100], c[100];
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] == b[i])
continue;
if (a[i] == b[i] || a[i] == b[i] || a[i] == b[i]) {
count++;
continue;
}
count += 2;
}
printf("%d", count);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
char a[100], b[100], c[100];
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] && a[i] == c[i])
continue;
if (a[i] == b[i] || a[i] == c[i] || c[i] == b[i]) {
count++;
continue;
}
count += 2;
}
printf("%d", count);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 940,694 | 940,692 | u051981922 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
int N;
pair<int, int> S[100010];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
S[i] = make_pair(a, b);
}
sort(S, S + N,
[](auto a, auto b) { return a.first + a.second < b.first + b.second; });
long tak = 0, aok = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
tak += S[i].first;
else
aok += S[i].second;
}
cout << tak - aok << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int N;
pair<int, int> S[100010];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
S[i] = make_pair(a, b);
}
sort(S, S + N,
[](auto a, auto b) { return a.first + a.second > b.first + b.second; });
long tak = 0, aok = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
tak += S[i].first;
else
aok += S[i].second;
}
cout << tak - aok << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,695 | 940,696 | u521712919 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
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;
}
bool comp(pair<ll, ll> l, pair<ll, ll> r) {
return l.first + l.second > r.first + r.second;
}
int main() {
int n;
cin >> n;
vector<pair<ll, ll>> dish(n);
REP(i, n) cin >> dish[i].first >> dish[i].second;
sort(dish.begin(), dish.end());
ll taka = 0, ao = 0;
REP(i, n) {
if (i % 2 == 0) {
taka += dish[i].first;
} else {
ao += dish[i].second;
}
}
cout << taka - ao << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
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;
}
bool comp(pair<ll, ll> l, pair<ll, ll> r) {
return l.first + l.second > r.first + r.second;
}
int main() {
int n;
cin >> n;
vector<pair<ll, ll>> dish(n);
REP(i, n) cin >> dish[i].first >> dish[i].second;
sort(dish.begin(), dish.end(), comp);
ll taka = 0, ao = 0;
REP(i, n) {
if (i % 2 == 0) {
taka += dish[i].first;
} else {
ao += dish[i].second;
}
}
cout << taka - ao << endl;
return 0;
} | [
"call.arguments.add"
] | 940,697 | 940,698 | u450883456 | cpp |
p03141 | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
vector<pair<long long, long long>> prime_factorize(long long p); // 素因数分解
vector<pair<char, long long>> runLengthEncoding(string s); // ランレングス圧縮
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block); // gridのbfs
bool is_prime(const unsigned n);
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
map<long long, map<long long, long long>> memo;
long long n_num;
long long k_num;
};
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (long long(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (long long(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long long> vll;
#include <cstdint>
template <long long Modulus> class modint {
public:
long long val;
modint(long long v = 0) : val(v % Modulus) {
if (val < 0)
val += Modulus;
}
// =付きの演算子に処理を任せる
constexpr modint operator+(const modint &rhs) { return modint(*this) += rhs; }
constexpr modint operator-(const modint &rhs) { return modint(*this) -= rhs; }
constexpr modint operator*(const modint &rhs) { return modint(*this) *= rhs; }
constexpr modint operator/(const modint &rhs) { return modint(*this) /= rhs; }
constexpr modint operator=(const long long &rhs) {
val = rhs;
val = val % Modulus;
cout << "a" << endl;
return modint(*this);
}
constexpr modint &operator+=(const modint &rhs) {
// まず足してみて、Modulusを超えてくるようなら引く
val += rhs.val;
if (val >= Modulus)
val -= Modulus;
return *this;
}
constexpr modint &operator-=(const modint &rhs) {
// 負になっちゃったら足す
val -= rhs.val;
if (val < 0)
val += Modulus;
return *this;
}
constexpr modint &operator*=(const modint &rhs) {
// modintな時点でvalは %Modulus しているのでこれでよい。
val = val * rhs.val % Modulus;
return *this;
}
constexpr modint &operator/=(const modint &rhs) { return *this *= inv(rhs); }
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return 0;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
constexpr modint inv(const modint &rhs) {
ll u, v;
extGCD(rhs.val, Modulus, u, v);
return modint(u);
}
friend constexpr modint modpow(const modint &rhs, long long n) {
if (n == 0)
return 1;
auto t = modpow(rhs, n / 2);
t = t * t;
if (n & 1)
t = t * rhs;
return t;
}
constexpr bool operator==(const modint &rhs) { return this->val == rhs.val; }
constexpr bool operator!=(const modint &rhs) { return this->val != rhs.val; }
// TODO: iostreamをつくっておく？
};
using mint = modint<998244353>;
// code
// ------------------------------------------------
int main() {
ll n;
cin >> n;
vector<ll> dish(n);
ll bot = 0;
rep(i, n) {
ll A, B;
cin >> A >> B;
dish[i] = A + B;
bot -= B;
}
vsort(dish);
ll ans = bot;
rep(i, n) {
if ((i & 1))
ans += dish[i];
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 0)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
ll ret;
if (memo[n][k] != 0) {
ret = memo[n][k];
} else if (n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for (long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
vector<pair<long long, long long>> prime_factorize(long long p) {
vector<pair<long long, long long>> ret;
for (long long x = 2; x * x <= p; ++x) {
if (p % x != 0)
continue;
long long num = 0;
while (p % x == 0) {
num++;
p /= x;
}
ret.push_back(make_pair(x, num));
}
if (p != 1)
ret.push_back(make_pair(p, 1));
return ret;
}
vector<pair<char, long long>> runLengthEncoding(string s) {
vector<pair<char, long long>> ret;
for (long long i = 0; i < s.length(); i++) {
char cur = s[i];
long long cnt = 1;
for (long long j = i + 1; j < s.length(); j++) {
if (cur != s[j])
break;
cnt++;
}
ret.emplace_back(make_pair(cur, cnt));
i += cnt - 1;
}
return ret;
}
// bfsをしてgoalまでの距離を調べる
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block = '#') {
// 訪問済み管理テーブルを作る
long long r = sz(m);
long long c = sz(m[0]);
vector<vector<long long>> dist(r, vector<long long>(c, -1));
// queueを使ってbfsをする。
queue<pair<long long, long long>> q;
long long grid_dict[][2] = {
{1, 0}, // up
{-1, 0}, // down
{0, 1}, // right
{0, -1} // left
};
q.push(make_pair(s_r, s_c));
dist[s_r][s_c] = 0;
while (!q.empty()) {
auto cur = q.front();
q.pop();
rep(i, 4) {
long long ver = cur.first + grid_dict[i][0];
long long hor = cur.second + grid_dict[i][1];
// mapの範囲内で、壁じゃなくて、訪問済じゃない場合は、
// 距離を記録して訪問予定リストに追加する
if ((0 <= ver && ver < r) && (0 <= hor && hor < c) &&
(m[ver][hor] != block) && (dist[ver][hor] == -1)) {
dist[ver][hor] = dist[cur.first][cur.second] + 1;
q.push(make_pair(ver, hor));
}
}
}
return dist[g_r][g_c];
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1:
return false;
case 2: // fall-through
case 3:
return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0)
return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0)
return false; // (6の倍数)-1
if (n % (i + 2) == 0)
return false; // (6の倍数)+1
}
return true;
} | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
vector<pair<long long, long long>> prime_factorize(long long p); // 素因数分解
vector<pair<char, long long>> runLengthEncoding(string s); // ランレングス圧縮
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block); // gridのbfs
bool is_prime(const unsigned n);
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
map<long long, map<long long, long long>> memo;
long long n_num;
long long k_num;
};
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (long long(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (long long(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long long> vll;
#include <cstdint>
template <long long Modulus> class modint {
public:
long long val;
modint(long long v = 0) : val(v % Modulus) {
if (val < 0)
val += Modulus;
}
// =付きの演算子に処理を任せる
constexpr modint operator+(const modint &rhs) { return modint(*this) += rhs; }
constexpr modint operator-(const modint &rhs) { return modint(*this) -= rhs; }
constexpr modint operator*(const modint &rhs) { return modint(*this) *= rhs; }
constexpr modint operator/(const modint &rhs) { return modint(*this) /= rhs; }
constexpr modint operator=(const long long &rhs) {
val = rhs;
val = val % Modulus;
cout << "a" << endl;
return modint(*this);
}
constexpr modint &operator+=(const modint &rhs) {
// まず足してみて、Modulusを超えてくるようなら引く
val += rhs.val;
if (val >= Modulus)
val -= Modulus;
return *this;
}
constexpr modint &operator-=(const modint &rhs) {
// 負になっちゃったら足す
val -= rhs.val;
if (val < 0)
val += Modulus;
return *this;
}
constexpr modint &operator*=(const modint &rhs) {
// modintな時点でvalは %Modulus しているのでこれでよい。
val = val * rhs.val % Modulus;
return *this;
}
constexpr modint &operator/=(const modint &rhs) { return *this *= inv(rhs); }
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return 0;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
constexpr modint inv(const modint &rhs) {
ll u, v;
extGCD(rhs.val, Modulus, u, v);
return modint(u);
}
friend constexpr modint modpow(const modint &rhs, long long n) {
if (n == 0)
return 1;
auto t = modpow(rhs, n / 2);
t = t * t;
if (n & 1)
t = t * rhs;
return t;
}
constexpr bool operator==(const modint &rhs) { return this->val == rhs.val; }
constexpr bool operator!=(const modint &rhs) { return this->val != rhs.val; }
// TODO: iostreamをつくっておく？
};
using mint = modint<998244353>;
// code
// ------------------------------------------------
int main() {
ll n;
cin >> n;
vector<ll> dish(n);
ll bot = 0;
rep(i, n) {
ll A, B;
cin >> A >> B;
dish[i] = A + B;
bot -= B;
}
rvsort(dish);
ll ans = bot;
rep(i, n) {
if (!(i & 1))
ans += dish[i];
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 0)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
ll ret;
if (memo[n][k] != 0) {
ret = memo[n][k];
} else if (n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for (long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
vector<pair<long long, long long>> prime_factorize(long long p) {
vector<pair<long long, long long>> ret;
for (long long x = 2; x * x <= p; ++x) {
if (p % x != 0)
continue;
long long num = 0;
while (p % x == 0) {
num++;
p /= x;
}
ret.push_back(make_pair(x, num));
}
if (p != 1)
ret.push_back(make_pair(p, 1));
return ret;
}
vector<pair<char, long long>> runLengthEncoding(string s) {
vector<pair<char, long long>> ret;
for (long long i = 0; i < s.length(); i++) {
char cur = s[i];
long long cnt = 1;
for (long long j = i + 1; j < s.length(); j++) {
if (cur != s[j])
break;
cnt++;
}
ret.emplace_back(make_pair(cur, cnt));
i += cnt - 1;
}
return ret;
}
// bfsをしてgoalまでの距離を調べる
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block = '#') {
// 訪問済み管理テーブルを作る
long long r = sz(m);
long long c = sz(m[0]);
vector<vector<long long>> dist(r, vector<long long>(c, -1));
// queueを使ってbfsをする。
queue<pair<long long, long long>> q;
long long grid_dict[][2] = {
{1, 0}, // up
{-1, 0}, // down
{0, 1}, // right
{0, -1} // left
};
q.push(make_pair(s_r, s_c));
dist[s_r][s_c] = 0;
while (!q.empty()) {
auto cur = q.front();
q.pop();
rep(i, 4) {
long long ver = cur.first + grid_dict[i][0];
long long hor = cur.second + grid_dict[i][1];
// mapの範囲内で、壁じゃなくて、訪問済じゃない場合は、
// 距離を記録して訪問予定リストに追加する
if ((0 <= ver && ver < r) && (0 <= hor && hor < c) &&
(m[ver][hor] != block) && (dist[ver][hor] == -1)) {
dist[ver][hor] = dist[cur.first][cur.second] + 1;
q.push(make_pair(ver, hor));
}
}
}
return dist[g_r][g_c];
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1:
return false;
case 2: // fall-through
case 3:
return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0)
return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0)
return false; // (6の倍数)-1
if (n % (i + 2) == 0)
return false; // (6の倍数)+1
}
return true;
} | [
"identifier.change",
"call.function.change",
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 940,707 | 940,708 | u610897920 | cpp |
p03141 | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
vector<pair<long long, long long>> prime_factorize(long long p); // 素因数分解
vector<pair<char, long long>> runLengthEncoding(string s); // ランレングス圧縮
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block); // gridのbfs
bool is_prime(const unsigned n);
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
map<long long, map<long long, long long>> memo;
long long n_num;
long long k_num;
};
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (long long(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (long long(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long long> vll;
#include <cstdint>
template <long long Modulus> class modint {
public:
long long val;
modint(long long v = 0) : val(v % Modulus) {
if (val < 0)
val += Modulus;
}
// =付きの演算子に処理を任せる
constexpr modint operator+(const modint &rhs) { return modint(*this) += rhs; }
constexpr modint operator-(const modint &rhs) { return modint(*this) -= rhs; }
constexpr modint operator*(const modint &rhs) { return modint(*this) *= rhs; }
constexpr modint operator/(const modint &rhs) { return modint(*this) /= rhs; }
constexpr modint operator=(const long long &rhs) {
val = rhs;
val = val % Modulus;
cout << "a" << endl;
return modint(*this);
}
constexpr modint &operator+=(const modint &rhs) {
// まず足してみて、Modulusを超えてくるようなら引く
val += rhs.val;
if (val >= Modulus)
val -= Modulus;
return *this;
}
constexpr modint &operator-=(const modint &rhs) {
// 負になっちゃったら足す
val -= rhs.val;
if (val < 0)
val += Modulus;
return *this;
}
constexpr modint &operator*=(const modint &rhs) {
// modintな時点でvalは %Modulus しているのでこれでよい。
val = val * rhs.val % Modulus;
return *this;
}
constexpr modint &operator/=(const modint &rhs) { return *this *= inv(rhs); }
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return 0;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
constexpr modint inv(const modint &rhs) {
ll u, v;
extGCD(rhs.val, Modulus, u, v);
return modint(u);
}
friend constexpr modint modpow(const modint &rhs, long long n) {
if (n == 0)
return 1;
auto t = modpow(rhs, n / 2);
t = t * t;
if (n & 1)
t = t * rhs;
return t;
}
constexpr bool operator==(const modint &rhs) { return this->val == rhs.val; }
constexpr bool operator!=(const modint &rhs) { return this->val != rhs.val; }
// TODO: iostreamをつくっておく？
};
using mint = modint<998244353>;
// code
// ------------------------------------------------
int main() {
ll n;
cin >> n;
vector<ll> dish(n);
ll bot = 0;
rep(i, n) {
ll A, B;
cin >> A >> B;
dish[i] = A + B;
bot -= B;
}
vsort(dish);
ll ans = 0;
rep(i, n) {
if (!(i & 1))
ans += dish[i];
}
cout << ans + bot << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 0)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
ll ret;
if (memo[n][k] != 0) {
ret = memo[n][k];
} else if (n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for (long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
vector<pair<long long, long long>> prime_factorize(long long p) {
vector<pair<long long, long long>> ret;
for (long long x = 2; x * x <= p; ++x) {
if (p % x != 0)
continue;
long long num = 0;
while (p % x == 0) {
num++;
p /= x;
}
ret.push_back(make_pair(x, num));
}
if (p != 1)
ret.push_back(make_pair(p, 1));
return ret;
}
vector<pair<char, long long>> runLengthEncoding(string s) {
vector<pair<char, long long>> ret;
for (long long i = 0; i < s.length(); i++) {
char cur = s[i];
long long cnt = 1;
for (long long j = i + 1; j < s.length(); j++) {
if (cur != s[j])
break;
cnt++;
}
ret.emplace_back(make_pair(cur, cnt));
i += cnt - 1;
}
return ret;
}
// bfsをしてgoalまでの距離を調べる
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block = '#') {
// 訪問済み管理テーブルを作る
long long r = sz(m);
long long c = sz(m[0]);
vector<vector<long long>> dist(r, vector<long long>(c, -1));
// queueを使ってbfsをする。
queue<pair<long long, long long>> q;
long long grid_dict[][2] = {
{1, 0}, // up
{-1, 0}, // down
{0, 1}, // right
{0, -1} // left
};
q.push(make_pair(s_r, s_c));
dist[s_r][s_c] = 0;
while (!q.empty()) {
auto cur = q.front();
q.pop();
rep(i, 4) {
long long ver = cur.first + grid_dict[i][0];
long long hor = cur.second + grid_dict[i][1];
// mapの範囲内で、壁じゃなくて、訪問済じゃない場合は、
// 距離を記録して訪問予定リストに追加する
if ((0 <= ver && ver < r) && (0 <= hor && hor < c) &&
(m[ver][hor] != block) && (dist[ver][hor] == -1)) {
dist[ver][hor] = dist[cur.first][cur.second] + 1;
q.push(make_pair(ver, hor));
}
}
}
return dist[g_r][g_c];
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1:
return false;
case 2: // fall-through
case 3:
return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0)
return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0)
return false; // (6の倍数)-1
if (n % (i + 2) == 0)
return false; // (6の倍数)+1
}
return true;
} | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
vector<pair<long long, long long>> prime_factorize(long long p); // 素因数分解
vector<pair<char, long long>> runLengthEncoding(string s); // ランレングス圧縮
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block); // gridのbfs
bool is_prime(const unsigned n);
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
map<long long, map<long long, long long>> memo;
long long n_num;
long long k_num;
};
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (long long(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (long long(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long long> vll;
#include <cstdint>
template <long long Modulus> class modint {
public:
long long val;
modint(long long v = 0) : val(v % Modulus) {
if (val < 0)
val += Modulus;
}
// =付きの演算子に処理を任せる
constexpr modint operator+(const modint &rhs) { return modint(*this) += rhs; }
constexpr modint operator-(const modint &rhs) { return modint(*this) -= rhs; }
constexpr modint operator*(const modint &rhs) { return modint(*this) *= rhs; }
constexpr modint operator/(const modint &rhs) { return modint(*this) /= rhs; }
constexpr modint operator=(const long long &rhs) {
val = rhs;
val = val % Modulus;
cout << "a" << endl;
return modint(*this);
}
constexpr modint &operator+=(const modint &rhs) {
// まず足してみて、Modulusを超えてくるようなら引く
val += rhs.val;
if (val >= Modulus)
val -= Modulus;
return *this;
}
constexpr modint &operator-=(const modint &rhs) {
// 負になっちゃったら足す
val -= rhs.val;
if (val < 0)
val += Modulus;
return *this;
}
constexpr modint &operator*=(const modint &rhs) {
// modintな時点でvalは %Modulus しているのでこれでよい。
val = val * rhs.val % Modulus;
return *this;
}
constexpr modint &operator/=(const modint &rhs) { return *this *= inv(rhs); }
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return 0;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
constexpr modint inv(const modint &rhs) {
ll u, v;
extGCD(rhs.val, Modulus, u, v);
return modint(u);
}
friend constexpr modint modpow(const modint &rhs, long long n) {
if (n == 0)
return 1;
auto t = modpow(rhs, n / 2);
t = t * t;
if (n & 1)
t = t * rhs;
return t;
}
constexpr bool operator==(const modint &rhs) { return this->val == rhs.val; }
constexpr bool operator!=(const modint &rhs) { return this->val != rhs.val; }
// TODO: iostreamをつくっておく？
};
using mint = modint<998244353>;
// code
// ------------------------------------------------
int main() {
ll n;
cin >> n;
vector<ll> dish(n);
ll bot = 0;
rep(i, n) {
ll A, B;
cin >> A >> B;
dish[i] = A + B;
bot -= B;
}
rvsort(dish);
ll ans = bot;
rep(i, n) {
if (!(i & 1))
ans += dish[i];
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 0)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
ll ret;
if (memo[n][k] != 0) {
ret = memo[n][k];
} else if (n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for (long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
vector<pair<long long, long long>> prime_factorize(long long p) {
vector<pair<long long, long long>> ret;
for (long long x = 2; x * x <= p; ++x) {
if (p % x != 0)
continue;
long long num = 0;
while (p % x == 0) {
num++;
p /= x;
}
ret.push_back(make_pair(x, num));
}
if (p != 1)
ret.push_back(make_pair(p, 1));
return ret;
}
vector<pair<char, long long>> runLengthEncoding(string s) {
vector<pair<char, long long>> ret;
for (long long i = 0; i < s.length(); i++) {
char cur = s[i];
long long cnt = 1;
for (long long j = i + 1; j < s.length(); j++) {
if (cur != s[j])
break;
cnt++;
}
ret.emplace_back(make_pair(cur, cnt));
i += cnt - 1;
}
return ret;
}
// bfsをしてgoalまでの距離を調べる
long long grid_bfs(vector<string> &m, long long s_r, long long s_c,
long long g_r, long long g_c, char block = '#') {
// 訪問済み管理テーブルを作る
long long r = sz(m);
long long c = sz(m[0]);
vector<vector<long long>> dist(r, vector<long long>(c, -1));
// queueを使ってbfsをする。
queue<pair<long long, long long>> q;
long long grid_dict[][2] = {
{1, 0}, // up
{-1, 0}, // down
{0, 1}, // right
{0, -1} // left
};
q.push(make_pair(s_r, s_c));
dist[s_r][s_c] = 0;
while (!q.empty()) {
auto cur = q.front();
q.pop();
rep(i, 4) {
long long ver = cur.first + grid_dict[i][0];
long long hor = cur.second + grid_dict[i][1];
// mapの範囲内で、壁じゃなくて、訪問済じゃない場合は、
// 距離を記録して訪問予定リストに追加する
if ((0 <= ver && ver < r) && (0 <= hor && hor < c) &&
(m[ver][hor] != block) && (dist[ver][hor] == -1)) {
dist[ver][hor] = dist[cur.first][cur.second] + 1;
q.push(make_pair(ver, hor));
}
}
}
return dist[g_r][g_c];
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1:
return false;
case 2: // fall-through
case 3:
return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0)
return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0)
return false; // (6の倍数)-1
if (n % (i + 2) == 0)
return false; // (6の倍数)+1
}
return true;
} | [
"identifier.change",
"call.function.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.remove"
] | 940,710 | 940,708 | u610897920 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using ll = long long;
using ull = unsigned long long;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; (i) < ((int)(n)); ++(i))
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
// const int dx[4] = { 1, 0, -1, 0 };
// const int dy[4] = { 0, 1, 0, -1 };
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
} // 桁数
template <typename T> inline T SUM(vector<T> vec) {
return accumulate(all(vec), (T)0);
} // vectorの中身を全部足す
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
} // 最大公約数
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
} // 最小公倍数
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
} // 累乗
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;
}
template <typename T> inline void print(T &&x) {
cout << setprecision(32) << x << endl;
}
// TODO: write
int main() {
int n;
cin >> n;
vector<pair<int, pair<int, int>>> a(n);
rep(i, n) {
int l, r;
cin >> l >> r;
a[i].fi = l + r;
a[i].se.fi = l;
a[i].se.se = r;
}
sort(all(a), [](auto l, auto r) { return l.fi - r.fi; });
ll l = 0, r = 0;
rep(i, n) {
if (i % 2) {
r += a[i].second.second;
} else {
l += a[i].second.first;
}
}
print(l - r);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using ll = long long;
using ull = unsigned long long;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; (i) < ((int)(n)); ++(i))
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
// const int dx[4] = { 1, 0, -1, 0 };
// const int dy[4] = { 0, 1, 0, -1 };
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
} // 桁数
template <typename T> inline T SUM(vector<T> vec) {
return accumulate(all(vec), (T)0);
} // vectorの中身を全部足す
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
} // 最大公約数
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
} // 最小公倍数
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
} // 累乗
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;
}
template <typename T> inline void print(T &&x) {
cout << setprecision(32) << x << endl;
}
// TODO: write
int main() {
int n;
cin >> n;
vector<pair<int, pair<int, int>>> a(n);
rep(i, n) {
int l, r;
cin >> l >> r;
a[i].fi = l + r;
a[i].se.fi = l;
a[i].se.se = r;
}
sort(all(a), [](auto l, auto r) { return l.fi > r.fi; });
ll l = 0, r = 0;
rep(i, n) {
if (i % 2) {
r += a[i].second.second;
} else {
l += a[i].second.first;
}
}
print(l - r);
return 0;
} | [
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,711 | 940,712 | u184572586 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using ll = long long;
using ull = unsigned long long;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; (i) < ((int)(n)); ++(i))
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
// const int dx[4] = { 1, 0, -1, 0 };
// const int dy[4] = { 0, 1, 0, -1 };
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
} // 桁数
template <typename T> inline T SUM(vector<T> vec) {
return accumulate(all(vec), (T)0);
} // vectorの中身を全部足す
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
} // 最大公約数
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
} // 最小公倍数
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
} // 累乗
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;
}
template <typename T> inline void print(T &&x) {
cout << setprecision(32) << x << endl;
}
// TODO: write
int main() {
int n;
cin >> n;
vector<pair<int, pair<int, int>>> a(n);
rep(i, n) {
int l, r;
cin >> l >> r;
a[i].fi = l + r;
a[i].se.fi = l;
a[i].se.se = r;
}
sort(all(a), [](auto l, auto r) { return l.fi = r.fi; });
ll l = 0, r = 0;
rep(i, n) {
if (i % 2) {
r += a[i].second.second;
} else {
l += a[i].second.first;
}
}
print(l - r);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using ll = long long;
using ull = unsigned long long;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; (i) < ((int)(n)); ++(i))
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
// const int dx[4] = { 1, 0, -1, 0 };
// const int dy[4] = { 0, 1, 0, -1 };
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
} // 桁数
template <typename T> inline T SUM(vector<T> vec) {
return accumulate(all(vec), (T)0);
} // vectorの中身を全部足す
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
} // 最大公約数
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
} // 最小公倍数
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
} // 累乗
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;
}
template <typename T> inline void print(T &&x) {
cout << setprecision(32) << x << endl;
}
// TODO: write
int main() {
int n;
cin >> n;
vector<pair<int, pair<int, int>>> a(n);
rep(i, n) {
int l, r;
cin >> l >> r;
a[i].fi = l + r;
a[i].se.fi = l;
a[i].se.se = r;
}
sort(all(a), [](auto l, auto r) { return l.fi > r.fi; });
ll l = 0, r = 0;
rep(i, n) {
if (i % 2) {
r += a[i].second.second;
} else {
l += a[i].second.first;
}
}
print(l - r);
return 0;
} | [
"call.arguments.change",
"function.return_value.change"
] | 940,713 | 940,712 | u184572586 | cpp |
p03141 |
// C - Different Strokes
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const ll MOD = 1e9 + 7;
int main() {
int N;
cin >> N;
vector<pair<int, int>> P(N);
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
P[i] = make_pair(A, B);
}
sort(P.begin(), P.end(),
[](const pair<int, int> &a, const pair<int, int> &b) {
return a.first + a.second < b.first + b.second;
});
ll ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ans += P[i].first;
else
ans -= P[i].second;
}
cout << ans << endl;
return 0;
} |
// C - Different Strokes
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const ll MOD = 1e9 + 7;
int main() {
int N;
cin >> N;
vector<pair<int, int>> P(N);
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
P[i] = make_pair(A, B);
}
sort(P.begin(), P.end(),
[](const pair<int, int> &a, const pair<int, int> &b) {
return a.first + a.second > b.first + b.second;
});
// **** debug ****
/*
for (int i=0; i<N; i++) {
cout << P[i].first << " " << P[i].second << endl;
}
*/
ll ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ans += P[i].first;
else
ans -= P[i].second;
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,720 | 940,721 | u790272146 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
long long MOD = 10000000000 + 7;
int main() {
cout << setprecision(10);
int N;
cin >> N;
vector<ll> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<ll, int>> C(N);
for (int i = 0; i < N; i++) {
C[i] = make_pair(A[i] + B[i], i);
}
sort(C.rbegin(), C.rend());
ll a_val = 0;
ll b_val = 0;
for (int i = 0; i < N; i++) {
int index = C[i].second;
// cerr << C[i].first << " " << C[i].second << endl;
if (i % 2 == 0) {
a_val += A[i];
} else {
b_val += B[i];
}
}
cout << a_val - b_val << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
long long MOD = 10000000000 + 7;
int main() {
cout << setprecision(10);
int N;
cin >> N;
vector<ll> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<ll, int>> C(N);
for (int i = 0; i < N; i++) {
C[i] = make_pair(A[i] + B[i], i);
}
sort(C.rbegin(), C.rend());
ll a_val = 0;
ll b_val = 0;
for (int i = 0; i < N; i++) {
int index = C[i].second;
// cerr << C[i].first << " " << C[i].second << endl;
if (i % 2 == 0) {
a_val += A[index];
} else {
b_val += B[index];
}
}
cout << a_val - b_val << endl;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 940,724 | 940,725 | u190875453 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int nm = 1e5;
int n, a, b;
ll ans = 0;
vector<P> v;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
v.emplace_back(a, b);
}
sort(v.begin(), v.end(), [](auto &x, auto &y) {
return x.first - x.second > y.first - y.second;
});
for (int i = 0; i < n; ++i)
if (!(i & 1))
ans += v[i].first;
else
ans -= v[i].second;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int nm = 1e5;
int n, a, b;
ll ans = 0;
vector<P> v;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
v.emplace_back(a, b);
}
sort(v.begin(), v.end(), [](auto &x, auto &y) {
return x.first + x.second > y.first + y.second;
});
for (int i = 0; i < n; ++i)
if (!(i & 1))
ans += v[i].first;
else
ans -= v[i].second;
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,730 | 940,731 | u154898295 | cpp |
p03141 | #include <bits/stdc++.h>
#define REP(i, n) for (long i = 0; i < n; ++i)
#define FOR(i, b, n) for (long i = b; i < n; ++i)
using namespace std;
using ll = long long;
using P = pair<long, long>;
void solve(long N, vector<long> A, vector<long> B) {
// the best strategy is to eat max(max(Ai, Bi))
// create max(Ai, Bi) list
vector<P> ryouri(N);
REP(i, N)
ryouri[i] = P(max(A[i], B[i]), i);
// sort the list
sort(ryouri.rbegin(), ryouri.rend());
// simulate
ll taka(0), aoki(0);
REP(i, N)
if (i % 2)
aoki += B[ryouri[i].second];
else
taka += A[ryouri[i].second];
// get the answer
cout << taka - aoki << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long N;
cin >> N;
vector<long> A(N);
vector<long> B(N);
REP(i, N)
cin >> A[i] >> B[i];
solve(N, move(A), move(B));
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (long i = 0; i < n; ++i)
#define FOR(i, b, n) for (long i = b; i < n; ++i)
using namespace std;
using ll = long long;
using P = pair<long, long>;
void solve(long N, vector<long> A, vector<long> B) {
// the best strategy is to eat max(Ai + Bi)
// create Ai + Bi list
vector<P> ryouri(N);
REP(i, N)
ryouri[i] = P(A[i] + B[i], i);
// sort the list
sort(ryouri.rbegin(), ryouri.rend());
// simulate
ll taka(0), aoki(0);
REP(i, N)
if (i % 2)
aoki += B[ryouri[i].second];
else
taka += A[ryouri[i].second];
// get the answer
cout << taka - aoki << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long N;
cin >> N;
vector<long> A(N);
vector<long> B(N);
REP(i, N)
cin >> A[i] >> B[i];
solve(N, move(A), move(B));
return 0;
}
| [
"call.remove",
"assignment.value.change",
"call.arguments.change"
] | 940,735 | 940,736 | u280941196 | cpp |
p03139 | #include "bits/stdc++.h"
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
const double pi = 3.141592653589793238;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b + c >= a) {
cout << min(b, c) << " " << 0 << endl;
} else {
cout << min(b, c) << " " << abs(max(0, a - (b + c))) << endl;
}
} | #include "bits/stdc++.h"
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
const double pi = 3.141592653589793238;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b + c <= a) {
cout << min(b, c) << " " << 0 << endl;
} else {
cout << min(b, c) << " " << abs(min(0, a - (b + c))) << endl;
}
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"call.function.change",
"io.output.change"
] | 940,739 | 940,740 | u539402331 | cpp |
p03139 | #include "bits/stdc++.h"
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
const double pi = 3.141592653589793238;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b + c >= a) {
cout << min(b, c) << " " << 0 << endl;
} else {
cout << min(b, c) << " " << abs(max(0, a - (b + c))) << endl;
}
} | #include "bits/stdc++.h"
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
const double pi = 3.141592653589793238;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b + c <= a) {
cout << min(b, c) << " " << 0 << endl;
} else {
cout << min(b, c) << " " << abs(min(0, a - (b + c))) << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"call.function.change",
"io.output.change"
] | 940,739 | 940,741 | u539402331 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << max(0, a + b - n) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, a + b - n) << endl;
return 0;
} | [
"io.output.change"
] | 940,744 | 940,745 | u823112986 | cpp |
p03139 | #include <iostream>
using namespace std;
int main() {
int n, a, b, x;
cin >> n >> a >> b;
if (a >= b) {
x = b;
} else if (a < b) {
x = a;
}
int y;
if (n > a + b) {
y = 0;
} else if (n <= a + b) {
y = a + b - n;
}
cout << x << y << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, a, b, x;
cin >> n >> a >> b;
if (a >= b) {
x = b;
} else if (a < b) {
x = a;
}
int y;
if (n > a + b) {
y = 0;
} else if (n <= a + b) {
y = a + b - n;
}
cout << x << " " << y << endl;
}
| [
"io.output.change"
] | 940,754 | 940,755 | u127856129 | cpp |
p03139 | #include <iostream>
using namespace std;
int main() {
int n, a, b, x, y;
cin >> n >> a >> b;
if (a >= b and n > a + b) {
x = b;
y = 0;
} else if (a < b and n > a + b) {
x = a;
y = 0;
} else if (n <= a + b and a >= b) {
y = a + b - n;
x = b;
} else if (n <= a + b and a < b) {
y = a + b - n;
x = a;
}
cout << x << "" << y << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, a, b, x, y;
cin >> n >> a >> b;
if (a >= b and n > a + b) {
x = b;
y = 0;
} else if (a < b and n > a + b) {
x = a;
y = 0;
} else if (n <= a + b and a >= b) {
y = a + b - n;
x = b;
} else if (n <= a + b and a < b) {
y = a + b - n;
x = a;
}
cout << x << " " << y << endl;
} | [
"literal.string.change",
"io.output.change"
] | 940,756 | 940,757 | u127856129 | cpp |
p03139 | #include <iostream>
using namespace std;
int main() {
int n, a, b, x, y;
cin >> n >> a >> b;
if (a >= b and n > a + b) {
x = b;
y = 0;
} else if (a < b and n > a + b) {
x = a;
y = 0;
} else if (n <= a + b and a >= b) {
y = a + b - n;
x = b;
} else if (n <= a + b and a < b) {
y = a + b - n;
x = a;
}
cout << x << y << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, a, b, x, y;
cin >> n >> a >> b;
if (a >= b and n > a + b) {
x = b;
y = 0;
} else if (a < b and n > a + b) {
x = a;
y = 0;
} else if (n <= a + b and a >= b) {
y = a + b - n;
x = b;
} else if (n <= a + b and a < b) {
y = a + b - n;
x = a;
}
cout << x << " " << y << endl;
} | [
"io.output.change"
] | 940,758 | 940,757 | u127856129 | cpp |
p03139 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int max = 0;
if (A > B) {
max = B;
}
if (A < B) {
max = A;
}
if (A == B) {
max = A;
}
int min = 0;
if (10 >= (A + B)) {
min = 0;
} else {
if (A > B) {
min = A - (N - B);
}
if (A < B) {
min = B - (N - A);
}
if (A == B) {
min = A - (N - B);
}
}
cout << max << " " << min << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int max = 0;
if (A > B) {
max = B;
}
if (A < B) {
max = A;
}
if (A == B) {
max = A;
}
int min = 0;
if (N >= (A + B)) {
min = 0;
} else {
if (A > B) {
min = A - (N - B);
}
if (A < B) {
min = B - (N - A);
}
if (A == B) {
min = A - (N - B);
}
}
cout << max << " " << min << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 940,759 | 940,760 | u918022685 | cpp |
p03139 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int max = 0;
if (A > B) {
max = B;
}
if (A < B) {
max = A;
}
if (A == B) {
max = A;
}
int min = 0;
if (10 >= (A + B)) {
min = 0;
} else {
if (A > B) {
min = A - (N - B);
}
if (A < B) {
min = B - (N - A);
}
if (A == B) {
min = A - (N - A);
}
}
cout << max << " " << min << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int max = 0;
if (A > B) {
max = B;
}
if (A < B) {
max = A;
}
if (A == B) {
max = A;
}
int min = 0;
if (N >= (A + B)) {
min = 0;
} else {
if (A > B) {
min = A - (N - B);
}
if (A < B) {
min = B - (N - A);
}
if (A == B) {
min = A - (N - B);
}
}
cout << max << " " << min << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 940,761 | 940,760 | u918022685 | cpp |
p03139 | #include <bits/stdc++.h>
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define MOD 100000007
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << a + b - n << endl;
}
| #include <bits/stdc++.h>
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define MOD 100000007
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(a + b - n, 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 940,762 | 940,763 | u506320030 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define F first
#define S second
#define ld long double
#define built __builtin_popcountll
#define mst(a, i) memset(a, i, sizeof(a))
#define all(x) x.begin(), x.end()
#define itit(it, a) for (auto it = (a).begin(); it != (a).end(); it++)
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define reprr(i, a, b) for (ll i = a; i >= b; i--)
#define pi 3.14159265358979323846264338327950288419716939937510582097494459230
ll max3(ll x, ll y, ll z) { return max(max(x, y), z); }
ll min3(ll x, ll y, ll z) { return min(min(x, y), z); }
const ll M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7, inf = 1e17 + 10;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, a, b;
cin >> n >> a >> b;
ll x, y;
x = min(a, b);
y = a + b - n;
cout << x << " " << y;
return 0;
}
/* The judge is never wrong! Your code is buggy
Look for:
* * Read the problem carefully.
* * Don't forget to sort(), mod, ll!!!!
* * Initial value = +/- infinity instead of zero!!!
* * an easier and alternate approach
* * read the problem statement carefully
* * if concept is correct and still WA, try with a different implementation
* * special cases (n=1?)
* * overflow (ll vs int?)
* * array bounds
* * if you have no idea just guess the appropriate well-known algorithm instead
of doing nothing :/
*/ | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define F first
#define S second
#define ld long double
#define built __builtin_popcountll
#define mst(a, i) memset(a, i, sizeof(a))
#define all(x) x.begin(), x.end()
#define itit(it, a) for (auto it = (a).begin(); it != (a).end(); it++)
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define reprr(i, a, b) for (ll i = a; i >= b; i--)
#define pi 3.14159265358979323846264338327950288419716939937510582097494459230
ll max3(ll x, ll y, ll z) { return max(max(x, y), z); }
ll min3(ll x, ll y, ll z) { return min(min(x, y), z); }
const ll M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7, inf = 1e17 + 10;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, a, b;
cin >> n >> a >> b;
ll x, y;
x = min(a, b);
y = max(0LL, a + b - n);
cout << x << " " << y;
return 0;
}
/* The judge is never wrong! Your code is buggy
Look for:
* * Read the problem carefully.
* * Don't forget to sort(), mod, ll!!!!
* * Initial value = +/- infinity instead of zero!!!
* * an easier and alternate approach
* * read the problem statement carefully
* * if concept is correct and still WA, try with a different implementation
* * special cases (n=1?)
* * overflow (ll vs int?)
* * array bounds
* * if you have no idea just guess the appropriate well-known algorithm instead
of doing nothing :/
*/
| [
"call.add",
"call.arguments.change"
] | 940,764 | 940,765 | u394634573 | cpp |
p03139 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << ' ' << a + b - n;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << ' ' << max(a + b - n, 0);
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 940,766 | 940,767 | u809153881 | cpp |
p03139 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B;
int Max, Min;
cin >> N >> A >> B;
if (A < B) {
cout << A << " ";
} else {
cout << A << " ";
}
Min = A + B - N;
if (Min < 0) {
cout << 0 << endl;
} else {
cout << Min << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B;
int Max, Min;
cin >> N >> A >> B;
if (A < B) {
cout << A << " ";
} else {
cout << B << " ";
}
Min = A + B - N;
if (Min < 0) {
cout << 0 << endl;
} else {
cout << Min << endl;
}
} | [
"identifier.change",
"io.output.change"
] | 940,779 | 940,780 | u889812821 | cpp |
p03139 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int maxa = min(a, b);
int min = 0;
if (a + b > 100) {
min = a + b - 100;
}
cout << maxa << " " << min << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int maxa = min(a, b);
int min = 0;
if (a + b > n) {
min = a + b - n;
}
cout << maxa << " " << min << endl;
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 940,789 | 940,790 | u023751250 | cpp |
p03139 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int maxa = max(a, b);
int min = 0;
if (a + b > 100) {
min = a + b - 100;
}
cout << maxa << " " << min << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int maxa = min(a, b);
int min = 0;
if (a + b > n) {
min = a + b - n;
}
cout << maxa << " " << min << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 940,791 | 940,790 | u023751250 | cpp |
p03139 | #include <iostream>
using namespace std;
int main() {
// std::cout << "Hello World!\n";
int N, a, b;
cin >> N >> a >> b;
// cout << a << "," << b << "," << c;
int max = a;
if (b < a) {
max = b;
}
int min = 0;
if (N < a + b) {
min = a + b - N;
}
cout << max << "," << min;
} | #include <iostream>
using namespace std;
int main() {
// std::cout << "Hello World!\n";
int N, a, b;
cin >> N >> a >> b;
// cout << a << "," << b << "," << c;
int max = a;
if (b < a) {
max = b;
}
int min = 0;
if (N < a + b) {
min = a + b - N;
}
cout << max << " " << min;
} | [
"literal.string.change",
"io.output.change"
] | 940,792 | 940,793 | u791964314 | cpp |
p03139 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
int maxSub = min(x, y);
int minSub = n - y + x;
if (minSub < 0)
minSub = 0;
cout << maxSub << " " << minSub << endl;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
int maxSub = min(x, y);
int minSub = y + x - n;
if (minSub < 0)
minSub = 0;
cout << maxSub << " " << minSub << endl;
} | [
"expression.operation.binary.remove"
] | 940,796 | 940,797 | u708595514 | cpp |
p03139 | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int n, a, b;
int ma, mi;
scanf("%d %d %d", &n, &a, &b);
ma = min(a, b);
if (n - a - b > 0)
mi = n - a - b;
else
mi = 0;
printf("%d %d\n", ma, mi);
} | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int n, a, b;
int ma, mi;
scanf("%d %d %d", &n, &a, &b);
ma = min(a, b);
if (n - a - b < 0)
mi = abs(n - a - b);
else
mi = 0;
printf("%d %d\n", ma, mi);
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add",
"call.arguments.change"
] | 940,807 | 940,808 | u857348954 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n, m, k;
cin >> n >> m >> k;
cout << min(m, k) << " " << min(0ll, (m + k - n)) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n, m, k;
cin >> n >> m >> k;
cout << min(m, k) << " " << max(0ll, (m + k - n)) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 940,809 | 940,810 | u906536200 | cpp |
p03139 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << (a + b) - n << endl;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max((a + b) - n, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 940,815 | 940,816 | u199912250 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
#define trav(a, x) for (auto &a : x)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long double ld;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int n, a, b;
cin >> n >> a >> b;
cout << max(a, b) << " " << max(0, a + b - n) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
#define trav(a, x) for (auto &a : x)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long double ld;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int n, a, b;
cin >> n >> a >> b;
cout << min(a, b) << " " << max(0, a + b - n) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 940,821 | 940,822 | u841408819 | cpp |
p03139 | #include <iostream>
int max(int a, int b);
int minn(int n, int a, int b);
int main() {
int N, A, B;
std::cin >> N >> A >> B;
std::cout << max(A, B) << minn(N, A, B) << std::endl;
return 0;
}
int max(int a, int b) {
if (a > b) {
return b;
} else {
return a;
}
}
int minn(int n, int a, int b) {
int temp = a + b - n;
if (temp > 0) {
return temp;
} else {
return 0;
}
}
| #include <iostream>
int max(int a, int b);
int minn(int n, int a, int b);
int main() {
int N, A, B;
std::cin >> N >> A >> B;
std::cout << max(A, B) << " " << minn(N, A, B) << std::endl;
return 0;
}
int max(int a, int b) {
if (a > b) {
return b;
} else {
return a;
}
}
int minn(int n, int a, int b) {
int temp = a + b - n;
if (temp > 0) {
return temp;
} else {
return 0;
}
}
| [
"expression.operation.binary.add"
] | 940,840 | 940,841 | u892351900 | cpp |
p03139 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define fi first
#define se second
#define pb push_back
int a, b, n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
cout << min(a, b) << ' ' << min(n, a + b);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define fi first
#define se second
#define pb push_back
int a, b, n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
cout << min(a, b) << ' ' << max(0, a + b - n);
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"identifier.replace.remove",
"literal.replace.add"
] | 940,842 | 940,843 | u060105478 | cpp |
p03139 | #include <iostream>
using namespace std;
int main() {
int N;
int A;
int B;
cin >> N >> A >> B;
int max;
int min;
if (A == B) {
max = A;
min = B;
}
if (A + B < N) {
min = 0;
max = (A < B) ? A : B;
}
if (A + B > N) {
max = (A > B) ? B : A;
min = A + B - N;
}
cout << max << ' ' << min << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
int A;
int B;
cin >> N >> A >> B;
int max;
int min;
if (A == B) {
max = A;
min = B;
}
if (A + B < N) {
min = 0;
max = (A < B) ? A : B;
}
if (A + B >= N) {
max = (A > B) ? B : A;
min = A + B - N;
}
cout << max << ' ' << min << endl;
} | [
"import.add",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 940,850 | 940,851 | u176986694 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define RREP(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define rrep(i, n) RREP(i, n - 1, 0)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const ld eps = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> A(n), B(n);
vector<int> id(n);
rep(i, n) {
cin >> A[i] >> B[i];
id[i] = i;
}
sort(all(id), [&](int i, int j) { return A[i] + B[i] > A[j] + B[j]; });
ll ans = -accumulate(all(B), 0LL);
rep(i, n) if (i % 2 == 0) ans += A[i] + B[i];
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define RREP(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define rrep(i, n) RREP(i, n - 1, 0)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const ld eps = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> A(n), B(n);
vector<int> id(n);
rep(i, n) {
cin >> A[i] >> B[i];
id[i] = i;
}
sort(all(id), [&](int i, int j) { return A[i] + B[i] > A[j] + B[j]; });
ll ans = -accumulate(all(B), 0LL);
rep(i, n) if (i % 2 == 0) ans += A[id[i]] + B[id[i]];
cout << ans << "\n";
return 0;
}
| [] | 940,855 | 940,856 | u137747137 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<P> table;
for (int i = 0; i < N; ++i) {
int A, B;
cin >> A >> B;
table.emplace_back(A, B);
}
sort(table.begin(), table.end(), [](const P &p1, const P &p2) {
return p1.first - p1.second < p2.first - p2.second;
});
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2)
ans -= table[i].second;
else
ans += table[i].first;
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<P> table;
for (int i = 0; i < N; ++i) {
int A, B;
cin >> A >> B;
table.emplace_back(A, B);
}
sort(table.begin(), table.end(), [](const P &p1, const P &p2) {
return p1.first - p2.second > p2.first - p1.second;
});
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2)
ans -= table[i].second;
else
ans += table[i].first;
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 940,857 | 940,858 | u190018920 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<P> table;
for (int i = 0; i < N; ++i) {
int A, B;
cin >> A >> B;
table.emplace_back(A, B);
}
sort(table.begin(), table.end(), [](const P &p1, const P &p2) {
return p1.first - p1.second > p2.first - p2.second;
});
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2)
ans -= table[i].second;
else
ans += table[i].first;
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<P> table;
for (int i = 0; i < N; ++i) {
int A, B;
cin >> A >> B;
table.emplace_back(A, B);
}
sort(table.begin(), table.end(), [](const P &p1, const P &p2) {
return p1.first - p2.second > p2.first - p1.second;
});
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2)
ans -= table[i].second;
else
ans += table[i].first;
}
cout << ans << endl;
} | [
"identifier.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,859 | 940,858 | u190018920 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using lint = long long;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), b(n);
rep(i, n) scanf("%d%d", &a[i], &b[i]);
vector<int> sum(n);
rep(i, n) sum[i] = a[i] + b[i];
sort(sum.begin(), sum.end());
lint ans = 0;
rep(i, n) ans += a[i];
for (int i = 1; i < n; i += 2)
ans -= sum[i];
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using lint = long long;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), b(n);
rep(i, n) scanf("%d%d", &a[i], &b[i]);
vector<int> sum(n);
rep(i, n) sum[i] = a[i] + b[i];
sort(sum.rbegin(), sum.rend());
lint ans = 0;
rep(i, n) ans += a[i];
for (int i = 1; i < n; i += 2)
ans -= sum[i];
printf("%lld\n", ans);
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 940,872 | 940,873 | u781095600 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long N;
vector<long long> s(N);
long long ans = 0;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
ans -= b;
s[i] = a + b;
}
sort(s.begin(), s.end());
int f = 0;
for (int i = 0; i < N; i++) {
if (f % 2 == 0)
ans += s[N - 1 - i];
f++;
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> s(N);
long long ans = 0;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
ans -= b;
s[i] = a + b;
}
sort(s.begin(), s.end());
int f = 0;
for (int i = 0; i < N; i++) {
if (f % 2 == 0)
ans += s[N - 1 - i];
f++;
}
cout << ans << endl;
} | [] | 940,892 | 940,893 | u503221936 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100005;
int n;
bitset<N> eaten;
ll ans;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
eaten.reset();
cin >> n;
// A for takashi ordering, b for aoki
vector<pair<int, pair<int, int>>> a, b;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back({y, {x, i}});
b.push_back({x, {y, i}});
}
sort(a.begin(), a.end(), greater<pair<int, pair<int, int>>>());
sort(b.begin(), b.end(), greater<pair<int, pair<int, int>>>());
int ai = 0, bi = 0;
for (int i = 0; i < n; i++) {
if (!(i % 2)) {
while (eaten[a[ai].second.second])
ai++;
eaten[a[ai].second.second] = true;
ans += a[ai].second.first;
} else {
while (eaten[b[bi].second.second])
bi++;
eaten[b[bi].second.second] = true;
ans -= b[bi].second.first;
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100005;
int n;
bitset<N> eaten;
ll ans;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
eaten.reset();
cin >> n;
// A for takashi ordering, b for aoki
vector<pair<int, pair<int, int>>> a, b;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back({x + y, {x, i}});
b.push_back({x + y, {y, i}});
}
sort(a.begin(), a.end(), greater<pair<int, pair<int, int>>>());
sort(b.begin(), b.end(), greater<pair<int, pair<int, int>>>());
int ai = 0, bi = 0;
for (int i = 0; i < n; i++) {
if (!(i % 2)) {
while (eaten[a[ai].second.second])
ai++;
eaten[a[ai].second.second] = true;
ans += a[ai].second.first;
} else {
while (eaten[b[bi].second.second])
bi++;
eaten[b[bi].second.second] = true;
ans -= b[bi].second.first;
}
}
cout << ans;
}
| [
"expression.operation.binary.add"
] | 940,894 | 940,895 | u736647947 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int LL;
LL t[2][100005];
vector<pair<LL, int>> v1;
int main() {
int n;
int i, j, k;
LL a = 0, b = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t[0][i] >> t[1][i];
a = t[1][i] + t[0][i];
v1.push_back(make_pair(a, i));
}
sort(v1.begin(), v1.end());
a = 0, b = 0;
for (i = 0; i < n; i++) {
k = v1[i].second;
if (i % 2 == 0)
a += t[0][k];
else
b += t[1][k];
}
a -= b;
cout << a << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int LL;
LL t[2][100005];
vector<pair<LL, int>> v1;
int main() {
int n;
int i, j, k;
LL a = 0, b = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t[0][i] >> t[1][i];
a = t[1][i] + t[0][i];
v1.push_back(make_pair(a, i));
}
sort(v1.rbegin(), v1.rend());
a = 0, b = 0;
for (i = 0; i < n; i++) {
k = v1[i].second;
if (i % 2 == 0)
a += t[0][k];
else
b += t[1][k];
}
a -= b;
cout << a << endl;
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 940,896 | 940,897 | u464804957 | cpp |
p03141 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
int n;
cin >> n;
vector<ll> A(n);
vector<ll> B(n);
vector<ll> wa(n);
rep(i, n) {
cin >> A[i] >> B[i];
wa[i] = A[i] + B[i];
}
vector<P> wawa(n);
rep(i, n) { wawa[i] = make_pair(wa[i], i); }
sort(wawa.begin(), wawa.end());
ll sente = 0;
for (ll i = 0; 2 * i < n; i++) {
sente += A[wawa[i * 2].second];
}
ll gote = 0;
for (ll i = 0; 2 * i + 1 < n; i++) {
gote += B[wawa[i * 2 + 1].second];
}
cout << sente - gote << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
int n;
cin >> n;
vector<ll> A(n);
vector<ll> B(n);
vector<ll> wa(n);
rep(i, n) {
cin >> A[i] >> B[i];
wa[i] = A[i] + B[i];
}
vector<P> wawa(n);
rep(i, n) { wawa[i] = make_pair(wa[i], i); }
sort(wawa.rbegin(), wawa.rend());
ll sente = 0;
for (ll i = 0; 2 * i < n; i++) {
sente += A[wawa[i * 2].second];
}
ll gote = 0;
for (ll i = 0; 2 * i + 1 < n; i++) {
gote += B[wawa[i * 2 + 1].second];
}
cout << sente - gote << endl;
return 0;
} | [
"call.function.change",
"call.arguments.change"
] | 940,900 | 940,901 | u449123607 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPR(i, n) for (int i = n; i > -1; --i)
#define ALL(a) (a).begin(), (a).end()
#define FILL(a, n, x) \
; \
REP(i, (n)) { (a)[i] = (x); }
#define CINA(a, n) \
; \
REP(i, (n)) { cin >> (a)[i]; }
#define FILL2(a, n, m, x) \
; \
REP(i, (n)) { \
REP(j, (m)) { (a)[i][j] = (x); } \
}
#define CINA2(a, n, m) \
; \
REP(i, (n)) { \
REP(j, (m)) { cin >> (a)[i][j]; } \
}
#define Liny "Yes\n"
#define Linn "No\n"
#define LINY "YES\n"
#define LINN "NO\n"
// cout << setfill('0') << right << setw(4) << 12; // "0012"
int keta(ll x) {
if (x < 10) {
return 1;
} else {
return keta(x / 10) + 1;
}
}
int keta_wa(ll x) {
if (x < 10) {
return x;
} else {
return keta_wa(x / 10) + x % 10;
}
}
int ctoi(char c) { return ((c >= '0' && c <= '9') ? c - '0' : 0); }
int __stoi(string s) { return atoi(s.c_str()); }
ll sum(ll a[], ll N) { return accumulate(a, a + N, 0LL); }
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) {
if (a < b) {
swap(a, b);
}
return a / gcd(a, b) * b;
}
template <class T> void chmax(T &a, T b) {
if (a < b) {
a = b;
}
}
template <class T> void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
const ll MOD = 1e9 + 7;
#define pii pair<int, int>
#define pll pair<ll, ll>
struct info {
int idx;
ll a;
ll b;
};
bool func(info u, info v) { return u.a + u.b > v.a + u.b; }
int main() {
int N;
cin >> N;
info p[N];
REP(i, N) {
ll a, b;
cin >> a >> b;
p[i] = {i, a, b};
}
sort(p, p + N, func);
ll ans = 0;
REP(i, N) {
if (i % 2 == 0) {
ans += p[i].a;
} else {
ans -= p[i].b;
}
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPR(i, n) for (int i = n; i > -1; --i)
#define ALL(a) (a).begin(), (a).end()
#define FILL(a, n, x) \
; \
REP(i, (n)) { (a)[i] = (x); }
#define CINA(a, n) \
; \
REP(i, (n)) { cin >> (a)[i]; }
#define FILL2(a, n, m, x) \
; \
REP(i, (n)) { \
REP(j, (m)) { (a)[i][j] = (x); } \
}
#define CINA2(a, n, m) \
; \
REP(i, (n)) { \
REP(j, (m)) { cin >> (a)[i][j]; } \
}
#define Liny "Yes\n"
#define Linn "No\n"
#define LINY "YES\n"
#define LINN "NO\n"
// cout << setfill('0') << right << setw(4) << 12; // "0012"
int keta(ll x) {
if (x < 10) {
return 1;
} else {
return keta(x / 10) + 1;
}
}
int keta_wa(ll x) {
if (x < 10) {
return x;
} else {
return keta_wa(x / 10) + x % 10;
}
}
int ctoi(char c) { return ((c >= '0' && c <= '9') ? c - '0' : 0); }
int __stoi(string s) { return atoi(s.c_str()); }
ll sum(ll a[], ll N) { return accumulate(a, a + N, 0LL); }
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) {
if (a < b) {
swap(a, b);
}
return a / gcd(a, b) * b;
}
template <class T> void chmax(T &a, T b) {
if (a < b) {
a = b;
}
}
template <class T> void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
const ll MOD = 1e9 + 7;
#define pii pair<int, int>
#define pll pair<ll, ll>
struct info {
int idx;
ll a;
ll b;
};
bool func(info u, info v) { return u.a + u.b > v.a + v.b; }
int main() {
int N;
cin >> N;
info p[N];
REP(i, N) {
ll a, b;
cin >> a >> b;
p[i] = {i, a, b};
}
sort(p, p + N, func);
ll ans = 0;
REP(i, N) {
if (i % 2 == 0) {
ans += p[i].a;
} else {
ans -= p[i].b;
}
}
cout << ans << "\n";
} | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,902 | 940,903 | u168017191 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
ll a, b;
vector<tuple<ll, ll, ll>> ab(n);
for (int i = 0; i < n; i++) {
cin >> a >> b;
ab[i] = make_tuple(a - b, a, b);
}
sort(ab.begin(), ab.end());
ll ans = 0LL;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += get<1>(ab[i]);
else
ans -= get<2>(ab[i]);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
ll a, b;
vector<tuple<ll, ll, ll>> ab(n);
for (int i = 0; i < n; i++) {
cin >> a >> b;
ab[i] = make_tuple(a + b, a, b);
}
sort(ab.rbegin(), ab.rend());
ll ans = 0LL;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += get<1>(ab[i]);
else
ans -= get<2>(ab[i]);
}
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"call.function.change"
] | 940,906 | 940,907 | u759987571 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
const ll mod = 1000000007;
int main() {
ll n;
cin >> n;
vll l(n);
ll sum = 0;
rep(i, n) {
ll a, b;
cin >> a >> b;
sum += b;
l[i] = a + b;
}
Sort(l);
ll ans = 0;
for (ll i = 0; i < n; i += 2) {
ans += l[i];
}
ans -= sum;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
const ll mod = 1000000007;
int main() {
ll n;
cin >> n;
vll l(n);
ll sum = 0;
rep(i, n) {
ll a, b;
cin >> a >> b;
sum += b;
l[i] = a + b;
}
Sort(l);
Reverse(l);
ll ans = 0;
for (ll i = 0; i < n; i += 2) {
ans += l[i];
}
ans -= sum;
cout << ans << endl;
return 0;
}
| [
"call.add"
] | 940,908 | 940,909 | u714724786 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
const ll p = 1000000007;
int main() {
ll n;
cin >> n;
ll bb = 0;
ll k[n];
rep(i, n) {
ll a, b;
cin >> a >> b;
bb += b;
k[i] = a + b;
}
sort(k, k + n);
ll ans = 0;
rep(i, n - n / 2) { ans += k[n - 1 - i]; }
cout << ans - bb << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
const ll p = 1000000007;
int main() {
ll n;
cin >> n;
ll bb = 0;
ll k[n];
rep(i, n) {
ll a, b;
cin >> a >> b;
bb += b;
k[i] = a + b;
}
sort(k, k + n);
ll ans = 0;
rep(i, n - n / 2) { ans += k[n - 1 - 2 * i]; }
cout << ans - bb << endl;
}
| [
"assignment.change"
] | 940,910 | 940,911 | u525560003 | cpp |
p03141 | #pragma GCC target("avx")
//#pragma GCC target("avx512f,avx512dq,avx512cd,avx512bw,avx512vl")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define PA pair<LL, LL>
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL, LL>>
#define VVL vector<vector<LL>>
#define PQ priority_queue
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define EB emplace_back
#define TS to_string
#define TU to_ullong
#define BPL __builtin_popcountll
#define FOR(i, a, n) for (i = a; i < n; i++)
#define FORR(i, a, n) for (i = n - 1; i >= a; i--)
#define rep(i, n) FOR(i, 0, n)
#define repr(i, n) FORR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a, n) *upper_bound(ALL(a), n)
#define LB(a, n) *lower_bound(ALL(a), n)
#define INF 1145141919810364364
#define PI 3.14159265358979
#define MOD 1000000007
//#define MOD 998244353
#define ERR 0.00000001
#define NUM 200010
#define FAST \
cin.tie(0); \
ios::sync_with_stdio(false)
void Yn(LL a) {
if (a)
printf("Yes\n");
else
printf("No\n");
}
void YN(LL a) {
if (a)
printf("YES\n");
else
printf("NO\n");
}
LL pwmn(LL a, LL n) {
LL ans = 1;
while (ans < a)
ans *= n;
return ans;
}
LL dig(LL n) {
LL ret = 0;
while (n)
n /= 10, ret++;
return ret;
}
LL LBn(VL &v, LL a) {
LL mx = v.size(), mn = -1, md;
while (mx - mn > 1) {
md = (mx + mn) / 2;
if (v[md] < a)
mn = md;
else
mx = md;
}
return mx;
}
LL GCD(LL a, LL b) {
LL c = 1, tmp = max(a, b);
b = min(a, b);
a = tmp;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
LL LCM(LL a, LL b) { return a * b / GCD(a, b); }
int lcmp(const void *a, const void *b) {
if (*(LL *)a > *(LL *)b)
return 1;
if (*(LL *)a < *(LL *)b)
return -1;
return 0;
}
int lcmpr(const void *a, const void *b) {
if (*(LL *)a > *(LL *)b)
return -1;
if (*(LL *)a < *(LL *)b)
return 1;
return 0;
}
int ccmp(const void *a, const void *b) { return *(char *)a - *(char *)b; }
int ccmpr(const void *a, const void *b) { return *(char *)b - *(char *)a; }
int scmp(const void *a, const void *b) { return strcmp((char *)a, (char *)b); }
int scmpr(const void *a, const void *b) { return strcmp((char *)b, (char *)a); }
LL mod(LL a, LL m) {
if (a % m < 0)
return a % m + abs(m);
else
return a % m;
}
LL DIV(LL a, LL d) {
LL m = MOD, x = 1, y = 0, k;
while (m) {
k = d / m;
d -= k * m;
swap(m, d);
x -= k * y;
swap(x, y);
}
return mod(a * mod(x, MOD), MOD);
}
LL POW(LL a, LL n) {
LL ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
LL fact[NUM], finv[NUM], inv[NUM];
void comi() {
LL i;
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NUM) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
LL com(LL n, LL k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool cmps(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
FAST;
LL i, ans = 0, N;
cin >> N;
VL A(N), B(N);
VP d(N);
rep(i, N) {
cin >> A[i] >> B[i];
d[i].first = A[i] + B[i];
d[i].second = i;
}
SORT(d);
rep(i, N) {
if (i % 2 == 0)
ans += A[d[i].second];
else
ans -= B[d[i].second];
}
cout << ans << endl;
}
| #pragma GCC target("avx")
//#pragma GCC target("avx512f,avx512dq,avx512cd,avx512bw,avx512vl")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define PA pair<LL, LL>
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL, LL>>
#define VVL vector<vector<LL>>
#define PQ priority_queue
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define EB emplace_back
#define TS to_string
#define TU to_ullong
#define BPL __builtin_popcountll
#define FOR(i, a, n) for (i = a; i < n; i++)
#define FORR(i, a, n) for (i = n - 1; i >= a; i--)
#define rep(i, n) FOR(i, 0, n)
#define repr(i, n) FORR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a, n) *upper_bound(ALL(a), n)
#define LB(a, n) *lower_bound(ALL(a), n)
#define INF 1145141919810364364
#define PI 3.14159265358979
#define MOD 1000000007
//#define MOD 998244353
#define ERR 0.00000001
#define NUM 200010
#define FAST \
cin.tie(0); \
ios::sync_with_stdio(false)
void Yn(LL a) {
if (a)
printf("Yes\n");
else
printf("No\n");
}
void YN(LL a) {
if (a)
printf("YES\n");
else
printf("NO\n");
}
LL pwmn(LL a, LL n) {
LL ans = 1;
while (ans < a)
ans *= n;
return ans;
}
LL dig(LL n) {
LL ret = 0;
while (n)
n /= 10, ret++;
return ret;
}
LL LBn(VL &v, LL a) {
LL mx = v.size(), mn = -1, md;
while (mx - mn > 1) {
md = (mx + mn) / 2;
if (v[md] < a)
mn = md;
else
mx = md;
}
return mx;
}
LL GCD(LL a, LL b) {
LL c = 1, tmp = max(a, b);
b = min(a, b);
a = tmp;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
LL LCM(LL a, LL b) { return a * b / GCD(a, b); }
int lcmp(const void *a, const void *b) {
if (*(LL *)a > *(LL *)b)
return 1;
if (*(LL *)a < *(LL *)b)
return -1;
return 0;
}
int lcmpr(const void *a, const void *b) {
if (*(LL *)a > *(LL *)b)
return -1;
if (*(LL *)a < *(LL *)b)
return 1;
return 0;
}
int ccmp(const void *a, const void *b) { return *(char *)a - *(char *)b; }
int ccmpr(const void *a, const void *b) { return *(char *)b - *(char *)a; }
int scmp(const void *a, const void *b) { return strcmp((char *)a, (char *)b); }
int scmpr(const void *a, const void *b) { return strcmp((char *)b, (char *)a); }
LL mod(LL a, LL m) {
if (a % m < 0)
return a % m + abs(m);
else
return a % m;
}
LL DIV(LL a, LL d) {
LL m = MOD, x = 1, y = 0, k;
while (m) {
k = d / m;
d -= k * m;
swap(m, d);
x -= k * y;
swap(x, y);
}
return mod(a * mod(x, MOD), MOD);
}
LL POW(LL a, LL n) {
LL ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
LL fact[NUM], finv[NUM], inv[NUM];
void comi() {
LL i;
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NUM) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
LL com(LL n, LL k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool cmps(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
FAST;
LL i, ans = 0, N;
cin >> N;
VL A(N), B(N);
VP d(N);
rep(i, N) {
cin >> A[i] >> B[i];
d[i].first = A[i] + B[i];
d[i].second = i;
}
SORT(d);
REV(d);
rep(i, N) {
if (i % 2 == 0)
ans += A[d[i].second];
else
ans -= B[d[i].second];
}
cout << ans << endl;
}
| [
"call.add"
] | 940,914 | 940,915 | u596117821 | cpp |
p03141 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using lint = long long;
int main() {
lint n;
scanf("%lld", &n);
std::vector<lint> a(n);
std::vector<lint> b(n);
std::vector<std::pair<lint, lint>> ab(n);
for (int i = 0; i < n; ++i) {
lint a_e, b_e;
scanf("%lld", &a_e);
scanf("%lld", &b_e);
a[i] = a_e;
b[i] = b_e;
ab[i] = std::make_pair(a_e + b_e, i);
}
std::sort(ab.begin(), ab.end());
lint ans_a = 0;
lint ans_b = 0;
for (int i = 0; i < n; ++i) {
lint idx = ab[i].second;
if (i % 2 == 0) {
ans_a += a[idx];
} else {
ans_b += b[idx];
}
}
printf("%lld", ans_a - ans_b);
return 0;
}
| #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using lint = long long;
int main() {
lint n;
scanf("%lld", &n);
std::vector<lint> a(n);
std::vector<lint> b(n);
std::vector<std::pair<lint, lint>> ab(n);
for (int i = 0; i < n; ++i) {
lint a_e, b_e;
scanf("%lld", &a_e);
scanf("%lld", &b_e);
a[i] = a_e;
b[i] = b_e;
ab[i] = std::make_pair(-a_e - b_e, i);
}
std::sort(ab.begin(), ab.end());
lint ans_a = 0;
lint ans_b = 0;
for (int i = 0; i < n; ++i) {
lint idx = ab[i].second;
if (i % 2 == 0) {
ans_a += a[idx];
} else {
ans_b += b[idx];
}
}
printf("%lld", ans_a - ans_b);
return 0;
}
| [
"expression.operation.unary.add",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 940,918 | 940,919 | u353402627 | cpp |
p03141 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
// ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
int main() {
int n, a, b;
ll s = 0, sb = 0;
cin >> n;
vector<int> v(n);
rep(i, 0, n) cin >> a >> b, v[i] = a + b, sb += (ll)b;
r_sort(v);
for (int i = v.size() - 1; i >= 0; i -= 2)
s += (ll)v[i];
printf("%lld\n", s - sb);
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
// ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
int main() {
int n, a, b;
ll s = 0, sb = 0;
cin >> n;
vector<int> v(n);
rep(i, 0, n) cin >> a >> b, v[i] = a + b, sb += (ll)b;
sort(all(v));
for (int i = v.size() - 1; i >= 0; i -= 2)
s += (ll)v[i];
printf("%lld\n", s - sb);
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.add",
"call.arguments.change"
] | 940,920 | 940,921 | u128572736 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
signed main(void) {
int n;
vector<int> a, b;
long long sum;
cin >> n;
a.resize(n);
b.resize(n);
sum = 0;
rep(i, n) {
cin >> a[i] >> b[i];
a[i] += b[i];
sum += b[i];
}
sum *= -1;
sort(a.begin(), a.end());
for (int i = 0; i < n; i += 2)
sum += a[i];
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
signed main(void) {
int n;
vector<long long> a, b;
long long sum;
cin >> n;
a.resize(n);
b.resize(n);
sum = 0;
rep(i, n) {
cin >> a[i] >> b[i];
a[i] += b[i];
sum += b[i];
}
sum *= -1;
sort(a.rbegin(), a.rend());
for (int i = 0; i < n; i += 2)
sum += a[i];
cout << sum << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"call.function.change",
"call.arguments.change"
] | 940,922 | 940,923 | u890331732 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
// output
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
// utility
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define RFOR(i, a, n) for (int i = (n)-1; i >= (a); --i)
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define IN(a, x, b) (a <= x && x < b)
#define OUT(a, x, b) (x < a || b <= x)
template <class T> inline T chmax(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T chmin(T &a, const T b) {
return a = (a > b) ? b : a;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
/* const int MOD = 998244353; */
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT {
INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}
} INIT;
signed main() {
int N;
cin >> N;
vector<int> A(N), B(N);
REP(i, N) cin >> A[i] >> B[i];
vector<int> o(N);
iota(ALL(o), 0);
sort(ALL(o), [&](int l, int r) { return A[l] - B[l] > A[r] - B[r]; });
int ans = 0;
REP(i, N) {
if (i % 2 == 0)
ans += A[o[i]];
else
ans -= B[o[i]];
}
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
// output
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
// utility
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define RFOR(i, a, n) for (int i = (n)-1; i >= (a); --i)
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define IN(a, x, b) (a <= x && x < b)
#define OUT(a, x, b) (x < a || b <= x)
template <class T> inline T chmax(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T chmin(T &a, const T b) {
return a = (a > b) ? b : a;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
/* const int MOD = 998244353; */
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT {
INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}
} INIT;
signed main() {
int N;
cin >> N;
vector<int> A(N), B(N);
REP(i, N) cin >> A[i] >> B[i];
vector<int> o(N);
iota(ALL(o), 0);
sort(ALL(o), [&](int l, int r) { return A[l] + B[l] > A[r] + B[r]; });
int ans = 0;
REP(i, N) {
if (i % 2 == 0)
ans += A[o[i]];
else
ans -= B[o[i]];
}
cout << ans << "\n";
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,930 | 940,931 | u812973725 | cpp |
p03141 | //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using intpair = pair<int, int>;
using intpv = vector<intpair>;
using llpair = pair<ll, ll>;
using llpv = vector<llpair>;
using intvec = vector<int>;
using llvec = vector<ll>;
using intq = queue<int>;
using llq = queue<ll>;
using intmat = vector<intvec>;
using llmat = vector<llvec>;
using pairmat = vector<llpv>;
#define matrix(T) vector<vector<T>>
#define PI 3.141592653589793
#define INTINF 1 << 30
#define LLINF 1LL << 60
#define MPRIME 1000000007
#define pqueue priority_queue
#define pushb push_back
#define all(name) name.begin(), name.end()
#define rall(name) name.rbegin(), name.rend()
#define ABS(x) ((x) > 0 ? (x) : -(x))
#define gsort(vbeg, vend) sort(vbeg, vend, greater<>())
#define init(v) \
for (auto &a : v) \
cin >> a
#define out(n) cout << n << endl
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;
}
ll GCD(ll a, ll b) { //最大公約数
if (a == 0 || b == 0)
return 0;
if (a < b)
swap(a, b);
ll tmp = a % b;
while (tmp != 0) {
a = b;
b = tmp;
tmp = a % b;
}
return b;
}
ll binpow(ll a, ll ex, ll p) { //繰り返し二乗法
ll result = 1LL;
while (ex > 0) {
if (ex & 1)
result = result * a % p;
ex >>= 1;
a = a * a % p;
}
return result;
}
ll Fact(ll x, ll p) { //階乗
ll f = 1;
for (ll i = 2; i <= x; i++) {
f *= i;
f %= p;
}
return f;
}
ll nPr(ll n, ll r) {
if (n < r)
return 0;
ll result = 1LL;
for (ll i = 0; i < r; i++)
result *= n - i;
return result;
}
ll nPrP(ll n, ll r, ll p) { // mod pにおけるnPr
if (n < r)
return 0;
ll result = 1LL;
for (int i = 0; i < r; i++) {
result *= n - i;
result %= p;
}
return result;
}
ll nCr(ll n, ll r) {
if (n == r) {
return 1;
}
if (r > n) {
return 0;
}
if (r > n / 2) {
r = n - r;
}
if (n == 0) {
return 0;
}
if (r == 0) {
return 1;
}
if (r == 1) {
return n;
}
double result = 1;
for (double i = 1; i <= r; i++) {
result *= (n - i + 1) / i;
}
return (ll)result;
}
llvec fact, inv, factinv;
void prenCrP(ll n, ll p) {
fact.resize(n + 1);
inv.resize(n + 1);
factinv.resize(n + 1);
fact[0] = fact[1] = inv[1] = factinv[0] = factinv[1] = 1LL;
for (ll i = 2LL; i <= n; i++) {
fact[i] = fact[i - 1] * i % p;
inv[i] = p - inv[p % i] * (p / i) % p;
factinv[i] = factinv[i - 1] * inv[i] % p;
}
}
ll nCrP(ll n, ll r, ll p) { // mod pにおけるnCr
if (r > n)
return 0;
return fact[n] * factinv[r] % p * factinv[n - r] % p;
}
llvec fact2, inv2, factinv2;
void prenCrP2(ll n, ll r, ll p) { // nがバカでかいときに使う, 計算量はr依存
fact2.resize(r + 1);
inv2.resize(r + 1);
factinv2.resize(r + 1);
fact2[0] = n % p, fact2[1] = n % p * (n - 1) % p;
inv2[1] = factinv2[0] = factinv2[1] = 1LL;
for (ll i = 2LL; i <= r; i++) {
fact2[i] = fact2[i - 1] * (n - i) % p;
inv2[i] = p - inv2[p % i] * (p / i) % p;
factinv2[i] = factinv2[i - 1] * inv2[i] % p;
}
}
ll nCrP2(ll r, ll p) { return fact2[r - 1] * factinv2[r] % p; }
ll LowerBinarySearch(llvec array, ll key, ll max, ll min) { //にぶたんlower
if (max > min) {
return -1LL;
} else {
ll mid = max + (min - max) / 2;
if (array[mid] > key) {
return LowerBinarySearch(array, key, max, mid - 1);
}
if (array[mid] < key) {
return LowerBinarySearch(array, key, mid + 1, min);
} else {
return mid;
}
}
}
ll GreaterBinarySearch(llvec array, ll key, ll max, ll min) { //にぶたんgreater
if (max > min) {
return -1LL;
} else {
ll mid = max + (min - max) / 2;
if (array[mid] < key) {
return GreaterBinarySearch(array, key, max, mid - 1);
}
if (array[mid] > key) {
return GreaterBinarySearch(array, key, mid + 1, min);
} else {
return mid;
}
}
}
int DigitNum(ll n) { //桁数
int digit = 0;
ll wari = 1LL;
while (n / wari) {
digit++;
wari *= 10;
}
return digit;
}
bool IsPrime(ll num) { //素数判定
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
vector<ll> Divisor(ll x) { // 約数列挙
vector<ll> result;
ll i = 1LL;
for (; i * i < x; i++) {
if (x % i)
continue;
result.push_back(i);
result.push_back(x / i);
}
if (i * i == x && x % i == 0)
result.push_back(i);
sort(result.begin(), result.end());
return result;
}
vector<llpair> PrimeFact(ll x) { // 素因数分解 {素因数,指数}
vector<llpair> result;
ll ex = 0LL;
if (x % 2 == 0) {
while (x % 2 == 0) {
x /= 2;
ex++;
}
result.push_back({2, ex});
}
for (ll i = 3LL; i * i <= x; i += 2) {
if (x % i)
continue;
ex = 0LL;
while (x % i == 0) {
x /= i;
ex++;
}
result.push_back({i, ex});
}
if (x != 1)
result.push_back({x, 1});
return result;
}
bool Palind(string s) { //回文判定
return s == string(s.rbegin(), s.rend());
}
struct Union_Find {
vector<int> parent; //親
vector<int> num; //根としたときの木サイズ
Union_Find(int N) : parent(N), num(N, 1) {
for (int i = 0; i < N; i++) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x)
return x;
return parent[x] = root(parent[x]);
}
void merge(int x, int y) {
int xrt = root(x);
int yrt = root(y);
if (xrt == yrt)
return;
parent[xrt] = yrt;
num[yrt] += num[xrt];
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return num[root(x)]; }
};
struct Ford_Fulkerson {
struct _edge {
int next;
int rev; // 逆辺の_edgeがG[next][rev]に存在する
ll cap;
};
vector<vector<_edge>> G;
vector<bool> used;
Ford_Fulkerson(int N) : G(N), used(N) {}
void add_edge(int from, int to, ll cap) {
G[from].push_back((_edge){to, (int)G[to].size(), cap});
G[to].push_back((_edge){from, (int)G[from].size() - 1, 0});
}
ll f_dfs(int s, int t, ll flow) {
if (s == t)
return flow;
used[s] = true;
for (_edge &ed : G[s]) {
if (!used[ed.next] && ed.cap > 0) {
ll captmp = f_dfs(ed.next, t, min(flow, ed.cap));
if (captmp > 0) {
ed.cap -= captmp;
G[ed.next][ed.rev].cap += captmp;
return captmp;
}
}
}
return 0LL;
}
ll max_flow(int s, int t) {
ll res = 0LL;
while (1) { // 最大になるまで繰り返し
used.assign(used.size(), false);
ll restmp = f_dfs(s, t, LLINF);
if (restmp == 0)
return res;
res += restmp;
}
}
};
int main() {
int N;
cin >> N;
llpair AB[N];
for (int i = 0; i < N; i++) {
cin >> AB[i].first >> AB[i].second;
}
sort(AB, AB + N, [&](llpair a, llpair b) {
return a.first + a.second > b.first + b.second;
});
ll taka = 0LL, aoki = 0LL;
for (int i = 0; i < N / 2; i++) {
taka += AB[i].first;
aoki += AB[i + 1].second;
}
if (N % 2) {
taka += AB[N - 1].first;
}
cout << taka - aoki << endl;
}
| //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using intpair = pair<int, int>;
using intpv = vector<intpair>;
using llpair = pair<ll, ll>;
using llpv = vector<llpair>;
using intvec = vector<int>;
using llvec = vector<ll>;
using intq = queue<int>;
using llq = queue<ll>;
using intmat = vector<intvec>;
using llmat = vector<llvec>;
using pairmat = vector<llpv>;
#define matrix(T) vector<vector<T>>
#define PI 3.141592653589793
#define INTINF 1 << 30
#define LLINF 1LL << 60
#define MPRIME 1000000007
#define pqueue priority_queue
#define pushb push_back
#define all(name) name.begin(), name.end()
#define rall(name) name.rbegin(), name.rend()
#define ABS(x) ((x) > 0 ? (x) : -(x))
#define gsort(vbeg, vend) sort(vbeg, vend, greater<>())
#define init(v) \
for (auto &a : v) \
cin >> a
#define out(n) cout << n << endl
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;
}
ll GCD(ll a, ll b) { //最大公約数
if (a == 0 || b == 0)
return 0;
if (a < b)
swap(a, b);
ll tmp = a % b;
while (tmp != 0) {
a = b;
b = tmp;
tmp = a % b;
}
return b;
}
ll binpow(ll a, ll ex, ll p) { //繰り返し二乗法
ll result = 1LL;
while (ex > 0) {
if (ex & 1)
result = result * a % p;
ex >>= 1;
a = a * a % p;
}
return result;
}
ll Fact(ll x, ll p) { //階乗
ll f = 1;
for (ll i = 2; i <= x; i++) {
f *= i;
f %= p;
}
return f;
}
ll nPr(ll n, ll r) {
if (n < r)
return 0;
ll result = 1LL;
for (ll i = 0; i < r; i++)
result *= n - i;
return result;
}
ll nPrP(ll n, ll r, ll p) { // mod pにおけるnPr
if (n < r)
return 0;
ll result = 1LL;
for (int i = 0; i < r; i++) {
result *= n - i;
result %= p;
}
return result;
}
ll nCr(ll n, ll r) {
if (n == r) {
return 1;
}
if (r > n) {
return 0;
}
if (r > n / 2) {
r = n - r;
}
if (n == 0) {
return 0;
}
if (r == 0) {
return 1;
}
if (r == 1) {
return n;
}
double result = 1;
for (double i = 1; i <= r; i++) {
result *= (n - i + 1) / i;
}
return (ll)result;
}
llvec fact, inv, factinv;
void prenCrP(ll n, ll p) {
fact.resize(n + 1);
inv.resize(n + 1);
factinv.resize(n + 1);
fact[0] = fact[1] = inv[1] = factinv[0] = factinv[1] = 1LL;
for (ll i = 2LL; i <= n; i++) {
fact[i] = fact[i - 1] * i % p;
inv[i] = p - inv[p % i] * (p / i) % p;
factinv[i] = factinv[i - 1] * inv[i] % p;
}
}
ll nCrP(ll n, ll r, ll p) { // mod pにおけるnCr
if (r > n)
return 0;
return fact[n] * factinv[r] % p * factinv[n - r] % p;
}
llvec fact2, inv2, factinv2;
void prenCrP2(ll n, ll r, ll p) { // nがバカでかいときに使う, 計算量はr依存
fact2.resize(r + 1);
inv2.resize(r + 1);
factinv2.resize(r + 1);
fact2[0] = n % p, fact2[1] = n % p * (n - 1) % p;
inv2[1] = factinv2[0] = factinv2[1] = 1LL;
for (ll i = 2LL; i <= r; i++) {
fact2[i] = fact2[i - 1] * (n - i) % p;
inv2[i] = p - inv2[p % i] * (p / i) % p;
factinv2[i] = factinv2[i - 1] * inv2[i] % p;
}
}
ll nCrP2(ll r, ll p) { return fact2[r - 1] * factinv2[r] % p; }
ll LowerBinarySearch(llvec array, ll key, ll max, ll min) { //にぶたんlower
if (max > min) {
return -1LL;
} else {
ll mid = max + (min - max) / 2;
if (array[mid] > key) {
return LowerBinarySearch(array, key, max, mid - 1);
}
if (array[mid] < key) {
return LowerBinarySearch(array, key, mid + 1, min);
} else {
return mid;
}
}
}
ll GreaterBinarySearch(llvec array, ll key, ll max, ll min) { //にぶたんgreater
if (max > min) {
return -1LL;
} else {
ll mid = max + (min - max) / 2;
if (array[mid] < key) {
return GreaterBinarySearch(array, key, max, mid - 1);
}
if (array[mid] > key) {
return GreaterBinarySearch(array, key, mid + 1, min);
} else {
return mid;
}
}
}
int DigitNum(ll n) { //桁数
int digit = 0;
ll wari = 1LL;
while (n / wari) {
digit++;
wari *= 10;
}
return digit;
}
bool IsPrime(ll num) { //素数判定
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
vector<ll> Divisor(ll x) { // 約数列挙
vector<ll> result;
ll i = 1LL;
for (; i * i < x; i++) {
if (x % i)
continue;
result.push_back(i);
result.push_back(x / i);
}
if (i * i == x && x % i == 0)
result.push_back(i);
sort(result.begin(), result.end());
return result;
}
vector<llpair> PrimeFact(ll x) { // 素因数分解 {素因数,指数}
vector<llpair> result;
ll ex = 0LL;
if (x % 2 == 0) {
while (x % 2 == 0) {
x /= 2;
ex++;
}
result.push_back({2, ex});
}
for (ll i = 3LL; i * i <= x; i += 2) {
if (x % i)
continue;
ex = 0LL;
while (x % i == 0) {
x /= i;
ex++;
}
result.push_back({i, ex});
}
if (x != 1)
result.push_back({x, 1});
return result;
}
bool Palind(string s) { //回文判定
return s == string(s.rbegin(), s.rend());
}
struct Union_Find {
vector<int> parent; //親
vector<int> num; //根としたときの木サイズ
Union_Find(int N) : parent(N), num(N, 1) {
for (int i = 0; i < N; i++) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x)
return x;
return parent[x] = root(parent[x]);
}
void merge(int x, int y) {
int xrt = root(x);
int yrt = root(y);
if (xrt == yrt)
return;
parent[xrt] = yrt;
num[yrt] += num[xrt];
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return num[root(x)]; }
};
struct Ford_Fulkerson {
struct _edge {
int next;
int rev; // 逆辺の_edgeがG[next][rev]に存在する
ll cap;
};
vector<vector<_edge>> G;
vector<bool> used;
Ford_Fulkerson(int N) : G(N), used(N) {}
void add_edge(int from, int to, ll cap) {
G[from].push_back((_edge){to, (int)G[to].size(), cap});
G[to].push_back((_edge){from, (int)G[from].size() - 1, 0});
}
ll f_dfs(int s, int t, ll flow) {
if (s == t)
return flow;
used[s] = true;
for (_edge &ed : G[s]) {
if (!used[ed.next] && ed.cap > 0) {
ll captmp = f_dfs(ed.next, t, min(flow, ed.cap));
if (captmp > 0) {
ed.cap -= captmp;
G[ed.next][ed.rev].cap += captmp;
return captmp;
}
}
}
return 0LL;
}
ll max_flow(int s, int t) {
ll res = 0LL;
while (1) { // 最大になるまで繰り返し
used.assign(used.size(), false);
ll restmp = f_dfs(s, t, LLINF);
if (restmp == 0)
return res;
res += restmp;
}
}
};
int main() {
int N;
cin >> N;
llpair AB[N];
for (int i = 0; i < N; i++) {
cin >> AB[i].first >> AB[i].second;
}
sort(AB, AB + N, [&](llpair a, llpair b) {
return a.first + a.second > b.first + b.second;
});
ll taka = 0LL, aoki = 0LL;
for (int i = 0; i < N / 2; i++) {
taka += AB[2 * i].first;
aoki += AB[2 * i + 1].second;
}
if (N % 2) {
taka += AB[N - 1].first;
}
cout << taka - aoki << endl;
}
| [
"assignment.change"
] | 940,934 | 940,935 | u195036695 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int64_t min(int64_t a, int64_t b) {
if (a > b) {
return b;
} else {
return a;
}
}
int main() {
int n;
cin >> n;
vector<vector<int64_t>> p(n, vector<int64_t>(3));
int64_t a, b;
for (size_t i = 0; i < n; i++) {
cin >> a >> b;
p.at(i).at(0) = a + b;
p.at(i).at(1) = a;
p.at(i).at(2) = b;
}
sort(p.begin(), p.end());
int64_t ans = 0;
for (size_t i = 0; i < n; i += 2) {
ans += p.at(i).at(1);
}
for (size_t i = 1; i < n; i += 2) {
ans -= p.at(i).at(2);
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int64_t min(int64_t a, int64_t b) {
if (a > b) {
return b;
} else {
return a;
}
}
int main() {
int n;
cin >> n;
vector<vector<int64_t>> p(n, vector<int64_t>(3));
int64_t a, b;
for (size_t i = 0; i < n; i++) {
cin >> a >> b;
p.at(i).at(0) = -1 * (a + b);
p.at(i).at(1) = a;
p.at(i).at(2) = b;
}
sort(p.begin(), p.end());
int64_t ans = 0;
for (size_t i = 0; i < n; i += 2) {
ans += p.at(i).at(1);
}
for (size_t i = 1; i < n; i += 2) {
ans -= p.at(i).at(2);
}
cout << ans << endl;
} | [
"assignment.change"
] | 940,938 | 940,939 | u229148215 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vs = vector<string>;
using vll = vector<long long>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vll a(n), b(n), c(n);
rep(i, n) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
}
sort(c.begin(), c.end());
ll ans = 0;
rep(i, n) if (~i & 1) ans += c[i];
rep(i, n) ans -= b[i];
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vs = vector<string>;
using vll = vector<long long>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vll a(n), b(n), c(n);
rep(i, n) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
}
sort(c.rbegin(), c.rend());
ll ans = 0;
rep(i, n) if (~i & 1) ans += c[i];
rep(i, n) ans -= b[i];
cout << ans << endl;
} | [
"call.function.change",
"call.arguments.change"
] | 940,940 | 940,941 | u009414205 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
int a, b;
ll sum_a = 0;
vi c(n);
rep(i, n) {
cin >> a >> b;
c[i] = a + b;
sum_a += a;
}
Sort(c);
rep(i, n) {
if ((n - i) % 2 == 1) {
sum_a -= c[n - i];
}
}
cout << sum_a << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
int a, b;
ll sum_a = 0;
vi c(n);
rep(i, n) {
cin >> a >> b;
c[i] = a + b;
sum_a += a;
}
Sort(c);
rep(i, n) {
if (i % 2 == 1) {
sum_a -= c[n - i - 1];
}
}
cout << sum_a << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 940,942 | 940,943 | u690475097 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
int a, b;
ll sum_a = 0;
vi c(n);
rep(i, n) {
cin >> a >> b;
c[i] = a + b;
sum_a += a;
}
Sort(c);
rep(i, n) {
if (i % 2 == 1) {
sum_a -= c[n - i];
}
}
cout << sum_a << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
int a, b;
ll sum_a = 0;
vi c(n);
rep(i, n) {
cin >> a >> b;
c[i] = a + b;
sum_a += a;
}
Sort(c);
rep(i, n) {
if (i % 2 == 1) {
sum_a -= c[n - i - 1];
}
}
cout << sum_a << endl;
return 0;
} | [
"assignment.change"
] | 940,944 | 940,943 | u690475097 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
int a, b;
ll sum_a = 0;
vi c(n);
rep(i, n) {
cin >> a >> b;
c[i] = a + b;
sum_a += a;
}
Sort(c);
rep(i, n) {
if (i % 2 == 1) {
sum_a -= c[i];
}
}
cout << sum_a << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
int a, b;
ll sum_a = 0;
vi c(n);
rep(i, n) {
cin >> a >> b;
c[i] = a + b;
sum_a += a;
}
Sort(c);
rep(i, n) {
if (i % 2 == 1) {
sum_a -= c[n - i - 1];
}
}
cout << sum_a << endl;
return 0;
} | [
"assignment.change"
] | 940,945 | 940,943 | u690475097 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int num[1000000001];
/*--- クイックソート ---*/
void quick(int sum[], int left, int right) {
int pl = left; /* 左カーソル */
int pr = right; /* 右カーソル */
int x = sum[(pl + pr) / 2]; /* 枢軸は中央の要素 */
do {
while (sum[pl] < x)
pl++;
while (sum[pr] > x)
pr--;
if (pl <= pr) {
swap(sum[pl], sum[pr]);
swap(num[pl], num[pr]);
pl++;
pr--;
}
} while (pl <= pr);
if (left < pr)
quick(sum, left, pr);
if (pl < right)
quick(sum, pl, right);
}
int main(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
long long int takahasi = 0, aoki = 0;
int n, i;
cin >> n;
int food[n][2], sum[n];
for (i = 0; i < n; i++)
num[i] = i;
for (i = 0; i < n; i++)
cin >> food[i][0] >> food[i][1];
for (i = 0; i < n; i++)
sum[i] = food[i][0] + food[i][1];
quick(sum, 0, n - 1);
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
takahasi += food[num[n - 1 - i]][0];
}
if (i % 2 == 1) {
aoki += food[num[n - 1 - i]][1];
}
}
cout << takahasi - aoki << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int num[100001];
/*--- クイックソート ---*/
void quick(int sum[], int left, int right) {
int pl = left; /* 左カーソル */
int pr = right; /* 右カーソル */
int x = sum[(pl + pr) / 2]; /* 枢軸は中央の要素 */
do {
while (sum[pl] < x)
pl++;
while (sum[pr] > x)
pr--;
if (pl <= pr) {
swap(sum[pl], sum[pr]);
swap(num[pl], num[pr]);
pl++;
pr--;
}
} while (pl <= pr);
if (left < pr)
quick(sum, left, pr);
if (pl < right)
quick(sum, pl, right);
}
int main(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
long long int takahasi = 0, aoki = 0;
int n, i;
cin >> n;
int food[n][2], sum[n];
for (i = 0; i < n; i++)
num[i] = i;
for (i = 0; i < n; i++)
cin >> food[i][0] >> food[i][1];
for (i = 0; i < n; i++)
sum[i] = food[i][0] + food[i][1];
quick(sum, 0, n - 1);
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
takahasi += food[num[n - 1 - i]][0];
}
if (i % 2 == 1) {
aoki += food[num[n - 1 - i]][1];
}
}
cout << takahasi - aoki << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 940,946 | 940,947 | u903311413 | cpp |
p03141 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define reps(i, s, n) for (int i = s, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
using namespace std;
int main(void) {
ll N;
cin >> N;
vector<pair<ll, ll>> A, B, Asur, Bsur;
ll a, b;
vector<pair<bool, ll>> se;
rep(i, N) cin >> a >> b, A.push_back({a, i}), B.push_back({b, i});
rep(i, N) {
Asur.push_back({A[i].first + B[i].first, i});
Bsur.push_back({B[i].first + A[i].first, i});
se.push_back({false, i});
}
sort(all(A));
sort(all(B));
ll anum = N - 1, bnum = N - 1;
ll asum = 0, bsum = 0;
rep(i, N) {
if (i % 2 == 0) {
while (se[Asur[anum].second].first)
anum--;
asum += A[Asur[anum].second].first;
se[Asur[anum].second].first = true;
}
if (i % 2 != 0) {
while (se[Bsur[bnum].second].first)
bnum--;
bsum += B[Bsur[bnum].second].first;
se[Bsur[bnum].second].first = true;
}
// cout<<asum<<sp<<bsum<<endl;
}
cout << asum - bsum << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define reps(i, s, n) for (int i = s, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
using namespace std;
int main(void) {
ll N;
cin >> N;
vector<pair<ll, ll>> A, B, Asur, Bsur;
ll a, b;
vector<pair<bool, ll>> se;
rep(i, N) cin >> a >> b, A.push_back({a, i}), B.push_back({b, i});
rep(i, N) {
Asur.push_back({A[i].first + B[i].first, i});
Bsur.push_back({B[i].first + A[i].first, i});
se.push_back({false, i});
}
sort(all(Asur));
sort(all(Bsur));
ll anum = N - 1, bnum = N - 1;
ll asum = 0, bsum = 0;
rep(i, N) {
if (i % 2 == 0) {
while (se[Asur[anum].second].first)
anum--;
asum += A[Asur[anum].second].first;
se[Asur[anum].second].first = true;
}
if (i % 2 != 0) {
while (se[Bsur[bnum].second].first)
bnum--;
bsum += B[Bsur[bnum].second].first;
se[Bsur[bnum].second].first = true;
}
// cout<<asum<<sp<<bsum<<endl;
}
cout << asum - bsum << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 940,950 | 940,951 | u563743611 | cpp |
p03141 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define reps(i, s, n) for (int i = s, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
using namespace std;
int main(void) {
ll N;
cin >> N;
vector<pair<ll, ll>> A, B, Asur, Bsur;
ll a, b;
vector<pair<bool, ll>> se;
rep(i, N) cin >> a >> b, A.push_back({a, i}), B.push_back({b, i});
rep(i, N) {
Asur.push_back({A[i].first - B[i].first, i});
Bsur.push_back({B[i].first - A[i].first, i});
se.push_back({false, i});
}
sort(all(A));
sort(all(B));
ll anum = N - 1, bnum = N - 1;
ll asum = 0, bsum = 0;
rep(i, N) {
if (i % 2 == 0) {
while (se[Asur[anum].second].first)
anum--;
asum += A[Asur[anum].second].first;
se[Asur[anum].second].first = true;
}
if (i % 2 != 0) {
while (se[Bsur[bnum].second].first)
bnum--;
bsum += B[Bsur[bnum].second].first;
se[Bsur[bnum].second].first = true;
}
// cout<<asum<<sp<<bsum<<endl;
}
cout << asum - bsum << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define reps(i, s, n) for (int i = s, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
using namespace std;
int main(void) {
ll N;
cin >> N;
vector<pair<ll, ll>> A, B, Asur, Bsur;
ll a, b;
vector<pair<bool, ll>> se;
rep(i, N) cin >> a >> b, A.push_back({a, i}), B.push_back({b, i});
rep(i, N) {
Asur.push_back({A[i].first + B[i].first, i});
Bsur.push_back({B[i].first + A[i].first, i});
se.push_back({false, i});
}
sort(all(Asur));
sort(all(Bsur));
ll anum = N - 1, bnum = N - 1;
ll asum = 0, bsum = 0;
rep(i, N) {
if (i % 2 == 0) {
while (se[Asur[anum].second].first)
anum--;
asum += A[Asur[anum].second].first;
se[Asur[anum].second].first = true;
}
if (i % 2 != 0) {
while (se[Bsur[bnum].second].first)
bnum--;
bsum += B[Bsur[bnum].second].first;
se[Bsur[bnum].second].first = true;
}
// cout<<asum<<sp<<bsum<<endl;
}
cout << asum - bsum << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change"
] | 940,952 | 940,951 | u563743611 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.