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 |
|---|---|---|---|---|---|---|---|
p02994 | #include <algorithm>
#include <forward_list>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
#define mod 1000000007
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (L <= 0 && N + L - 1 < 0) { // 0をまたがずに負からはじまる
cout << (N - 1) * (L + N + L - 1 - 1) / 2 << endl;
} else if (L < 0) { // 0を跨いで負から始まる
cout << (N - 1) * (L + N + L - 1) / 2 << endl;
} else if (L >= 0) { //正からはじまる
cout << (N - 1) * (L + 1 + N + L - 1) / 2 << endl;
}
}
| #include <algorithm>
#include <forward_list>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
#define mod 1000000007
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (L <= 0 && N + L - 1 <= 0) { // 0をまたがずに負からはじまる
cout << (N - 1) * (L + N + L - 1 - 1) / 2 << endl;
} else if (L < 0) { // 0を跨いで負から始まる
cout << (N) * (L + N + L - 1) / 2 << endl;
} else if (L >= 0) { //正からはじまる
cout << (N - 1) * (L + 1 + N + L - 1) / 2 << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 804,221 | 804,220 | u998203751 | cpp |
p02994 | #include <algorithm>
#include <forward_list>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
#define mod 1000000007
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (L <= 0 && N + L - 1 <= 0) { // 0をまたがずに負からはじまる
cout << (N - 1) * (L + N + L - 1 - 1) / 2 << endl;
} else if (L < 0) { // 0を跨いで負から始まる
cout << (N - 1) * (L + N + L - 1) / 2 << endl;
} else if (L > 0) { //正からはじまる
cout << (N - 1) * (L + 1 + N + L - 1) / 2 << endl;
}
}
| #include <algorithm>
#include <forward_list>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
#define mod 1000000007
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (L <= 0 && N + L - 1 <= 0) { // 0をまたがずに負からはじまる
cout << (N - 1) * (L + N + L - 1 - 1) / 2 << endl;
} else if (L < 0) { // 0を跨いで負から始まる
cout << (N) * (L + N + L - 1) / 2 << endl;
} else if (L >= 0) { //正からはじまる
cout << (N - 1) * (L + 1 + N + L - 1) / 2 << endl;
}
}
| [
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 804,223 | 804,220 | u998203751 | cpp |
p02994 | #include <algorithm>
#include <forward_list>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
#define mod 1000000007
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (L < 0 && N + L - 1 < 0) { // 0をまたがずに負からはじまる
cout << (N - 1) * (L + N + L - 1 - 1) / 2 << endl;
} else if (L <= 0) { // 0を跨いで負から始まる
cout << (N - 1) * (L + N + L - 1) / 2 << endl;
} else if (L > 0) { //正からはじまる
cout << (N - 1) * (L + 1 + N + L - 1) / 2 << endl;
}
}
| #include <algorithm>
#include <forward_list>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
#define mod 1000000007
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (L <= 0 && N + L - 1 <= 0) { // 0をまたがずに負からはじまる
cout << (N - 1) * (L + N + L - 1 - 1) / 2 << endl;
} else if (L < 0) { // 0を跨いで負から始まる
cout << (N) * (L + N + L - 1) / 2 << endl;
} else if (L >= 0) { //正からはじまる
cout << (N - 1) * (L + 1 + N + L - 1) / 2 << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 804,224 | 804,220 | u998203751 | cpp |
p02994 |
#include "iostream"
#include "vector"
using namespace std;
int main() {
int N = 0;
int L = 0;
cin >> N;
cin >> L;
int sum = 0;
for (int i = 1; i <= N; ++i) {
auto temp = L + i - 1;
sum += temp;
}
int tsumamiIndex = 0;
if (L >= 1) {
tsumamiIndex = 1;
} else if (L < -N) {
tsumamiIndex = N;
} else {
tsumamiIndex = 1 - L;
}
auto aji = tsumamiIndex - 1 + L;
sum -= aji;
cout << sum;
cin >> aji;
return 0;
}
|
#include "iostream"
#include "vector"
using namespace std;
int main() {
int N = 0;
int L = 0;
cin >> N;
cin >> L;
int sum = 0;
for (int i = 1; i <= N; ++i) {
auto temp = L + i - 1;
sum += temp;
}
int tsumamiIndex = 0;
if (L >= 1) {
tsumamiIndex = 1;
} else if (L <= -N) {
tsumamiIndex = N;
} else {
tsumamiIndex = 1 - L;
}
auto aji = tsumamiIndex - 1 + L;
sum -= aji;
cout << sum;
cin >> aji;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 804,227 | 804,228 | u884331834 | cpp |
p02994 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n, l;
std::cin >> n >> l;
int first = l, last = l + n - 1;
int sum;
if (n % 2) {
sum = (first + last) * (n / 2) + (first + last) / 2;
} else {
sum = (first + last) * n / 2;
}
if (first < 0 and last < 0) {
std::cout << sum - last << std::endl;
} else if (first < 0 and last > 0) {
std::cout << sum << std::endl;
} else {
std::cout << sum - first << std::endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n, l;
std::cin >> n >> l;
int first = l, last = l + n - 1;
int sum;
if (n % 2) {
sum = (first + last) * (n / 2) + (first + last) / 2;
} else {
sum = (first + last) * (n / 2);
}
if (first < 0 and last < 0) {
std::cout << sum - last << std::endl;
} else if (first < 0 and last >= 0) {
std::cout << sum << std::endl;
} else {
std::cout << sum - first << std::endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 804,229 | 804,230 | u832726997 | cpp |
p02994 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define whole(f, x, ...) \
([&](decltype((x)) whole) { \
return (f)(begin(whole), end(whole), ##__VA_ARGS__); \
})(x) // decltypeで型取得、引数があればva_argsのところに入れる
using namespace std;
typedef long long ll; // long longをllでかけるようにした
const int INF = 1e9;
int main(void) {
int n, l;
cin >> n >> l;
vector<int> apple(n);
REP(i, n) apple[i] = l + i;
int ans = 0;
REP(i, n) ans += apple[i];
int hiki;
if (l < 0 and l + n >= 0)
hiki = 0;
else if (l < 0 and l + n < 0)
hiki = l + n - 1;
else if (l > 0)
hiki = l;
cout << ans - hiki << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define whole(f, x, ...) \
([&](decltype((x)) whole) { \
return (f)(begin(whole), end(whole), ##__VA_ARGS__); \
})(x) // decltypeで型取得、引数があればva_argsのところに入れる
using namespace std;
typedef long long ll; // long longをllでかけるようにした
const int INF = 1e9;
int main(void) {
int n, l;
cin >> n >> l;
vector<int> apple(n);
REP(i, n) apple[i] = l + i;
int ans = 0;
REP(i, n) ans += apple[i];
int hiki;
if (l <= 0 and l + n - 1 >= 0)
hiki = 0;
else if (l < 0 and l + n - 1 < 0)
hiki = l + n - 1;
else if (l > 0)
hiki = l;
cout << ans - hiki << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 804,231 | 804,232 | u369212307 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define ll long long
int main() {
int N, L;
cin >> N >> L;
ll ans = N * (N - 1) / 2 + L * N;
if (L <= 0 && L - N + 1 >= 0)
cout << ans << endl;
else if (L > 0)
cout << ans - L << endl;
else
cout << ans - L - N + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define ll long long
int main() {
int N, L;
cin >> N >> L;
ll ans = N * (N - 1) / 2 + L * N;
if (L <= 0 && L + N - 1 >= 0)
cout << ans << endl;
else if (L > 0)
cout << ans - L << endl;
else
cout << ans - L - N + 1 << endl;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 804,235 | 804,236 | u154756110 | cpp |
p02994 | // #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC
// target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
#define BOOST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) (int)(a).size()
#define FOR(a, b, c) for (int a = (b); a < (c); a++)
#define FORR(a, b, c) for (int a = (b); a >= (c); a--)
#define TRAV(a, b) for (auto &a : b)
#define ELO exit(0)
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define SORTR(a) SORT(a), REV(a)
#define PB push_back
using ll = long long;
using ld = long double; // 'long double' is 2.2 times slower than double
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
template <class T> inline bool setmin(T &a, T b) {
if (a > b)
return a = b, 1;
return 0;
}
template <class T> inline bool setmax(T &a, T b) {
if (a < b)
return a = b, 1;
return 0;
}
namespace fastio {
template <class T> istream &operator>>(istream &os, vector<T> &vec) {
for (auto &u : vec)
os >> u;
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &u : vec)
os << u << " ";
return os;
}
template <class T1, class T2>
inline istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, set<T> &con) {
for (auto &u : con)
os << u << " ";
return os;
}
void re() {}
template <typename T, typename... args> void re(T &x, args &...tail) {
cin >> x;
re(tail...);
}
void pr() {}
template <typename T, typename... args> void pr(T x, args... tail) {
cout << x << " ";
pr(tail...);
}
template <typename... args> void prln(args... tail) {
pr(tail...);
cout << "\n";
}
} // namespace fastio
using namespace fastio;
namespace debug {
template <typename _T> inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',')
cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
#if 1
#define debug(...) _debug(#__VA_ARGS__, __VA_ARGS__)
#define cerr cout
#else
#define debug(...) 1999
#define cerr \
if (0) \
cout
#endif
} // namespace debug
using namespace debug;
//////////////_________CODE_________//////////////
constexpr int MOD = 1e9 + 7; // 998244353
constexpr int INF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
int main() {
BOOST;
int n, l;
re(n, l);
pii res{INF, -1};
FOR(i, 1, n + 1) { setmin(res, {l + i - 1, i}); }
int sum = 0;
FOR(i, 1, n + 1) if (i != res.second) { sum += l + i - 1; }
prln(sum);
ELO;
} | // #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC
// target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
#define BOOST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) (int)(a).size()
#define FOR(a, b, c) for (int a = (b); a < (c); a++)
#define FORR(a, b, c) for (int a = (b); a >= (c); a--)
#define TRAV(a, b) for (auto &a : b)
#define ELO exit(0)
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define SORTR(a) SORT(a), REV(a)
#define PB push_back
using ll = long long;
using ld = long double; // 'long double' is 2.2 times slower than double
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
template <class T> inline bool setmin(T &a, T b) {
if (a > b)
return a = b, 1;
return 0;
}
template <class T> inline bool setmax(T &a, T b) {
if (a < b)
return a = b, 1;
return 0;
}
namespace fastio {
template <class T> istream &operator>>(istream &os, vector<T> &vec) {
for (auto &u : vec)
os >> u;
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &u : vec)
os << u << " ";
return os;
}
template <class T1, class T2>
inline istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, set<T> &con) {
for (auto &u : con)
os << u << " ";
return os;
}
void re() {}
template <typename T, typename... args> void re(T &x, args &...tail) {
cin >> x;
re(tail...);
}
void pr() {}
template <typename T, typename... args> void pr(T x, args... tail) {
cout << x << " ";
pr(tail...);
}
template <typename... args> void prln(args... tail) {
pr(tail...);
cout << "\n";
}
} // namespace fastio
using namespace fastio;
namespace debug {
template <typename _T> inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',')
cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
#if 1
#define debug(...) _debug(#__VA_ARGS__, __VA_ARGS__)
#define cerr cout
#else
#define debug(...) 1999
#define cerr \
if (0) \
cout
#endif
} // namespace debug
using namespace debug;
//////////////_________CODE_________//////////////
constexpr int MOD = 1e9 + 7; // 998244353
constexpr int INF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
int main() {
BOOST;
int n, l;
re(n, l);
pii res{INF, -1};
FOR(i, 1, n + 1) { setmin(res, {abs(l + i - 1), i}); }
int sum = 0;
FOR(i, 1, n + 1) if (i != res.second) { sum += l + i - 1; }
prln(sum);
ELO;
} | [
"call.add",
"call.arguments.change"
] | 804,239 | 804,240 | u691350599 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const long long INF = 1e18;
#define len(x) ((int)(x).size())
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define foreps(i, m, n) for (int i = m; i < n; i++)
#define ALL(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll GCD(ll X, ll Y) { return Y ? GCD(Y, X % Y) : X; }
ll num(ll N, ll C, ll D) {
ll G = GCD(C, D);
ll L = D / G * D;
return N - N / C - N / D + N / L;
}
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << num(B, C, D) - num(A - 1, C, D) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const long long INF = 1e18;
#define len(x) ((int)(x).size())
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define foreps(i, m, n) for (int i = m; i < n; i++)
#define ALL(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll GCD(ll X, ll Y) { return Y ? GCD(Y, X % Y) : X; }
ll num(ll N, ll C, ll D) {
ll G = GCD(C, D);
ll L = C / G * D;
return N - N / C - N / D + N / L;
}
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << num(B, C, D) - num(A - 1, C, D) << endl;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 804,245 | 804,246 | u043589043 | cpp |
p02995 | #include <iostream>
using namespace std;
long long GCD(long long x, long long y) {
if (x < y)
swap(x, y);
if (x % y == 0) {
return y;
} else {
return (y, x % y);
}
}
long long num(long long n, long long c, long long d) {
long long G = GCD(c, d);
long long L = c / G * d;
return n - n / c - n / d + n / L;
}
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << num(b, c, d) - num(a - 1, c, d) << endl;
} | #include <iostream>
using namespace std;
long long GCD(long long x, long long y) {
if (x < y)
swap(x, y);
if (x % y == 0) {
return y;
} else {
return GCD(y, x % y);
}
}
long long num(long long n, long long c, long long d) {
long long G = GCD(c, d);
long long L = c / G * d;
return n - n / c - n / d + n / L;
}
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << num(b, c, d) - num(a - 1, c, d) << endl;
} | [
"call.add",
"function.return_value.change"
] | 804,249 | 804,250 | u682413606 | cpp |
p02995 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPS(I, a, b) for (int i = (a); i < (b); ++i)
using namespace std;
using ll = long long;
int main() {
ll a, b;
cin >> a >> b;
ll c, d;
cin >> c >> d;
ll sum = 0, dif = 0;
ll gc = gcd(c, d);
ll e = d / gc;
e *= c;
sum += b;
sum -= b / c;
sum -= b / d;
sum += b / e;
dif += a;
dif -= a / c;
dif -= a / d;
dif += a / e;
ll ans = sum - dif;
cout << ans + 1 << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPS(I, a, b) for (int i = (a); i < (b); ++i)
using namespace std;
using ll = long long;
int main() {
ll a, b;
cin >> a >> b;
ll c, d;
cin >> c >> d;
a--;
ll sum = 0, dif = 0;
ll gc = gcd(c, d);
ll e = d / gc;
e *= c;
sum += b;
sum -= b / c;
sum -= b / d;
sum += b / e;
dif += a;
dif -= a / c;
dif -= a / d;
dif += a / e;
ll ans = sum - dif;
cout << ans << endl;
} | [
"expression.unary.arithmetic.add",
"expression.operation.binary.remove"
] | 804,251 | 804,252 | u514896542 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using pii = pair<int, int>;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll l = lcm(c, d);
ll x = b / c - a / c + (a % c == 0);
ll y = b / d - a / d + (a % b == 0);
ll z = b / l - a / l + (a % l == 0);
ll ans = (b - a + 1) - (x + y - z);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using pii = pair<int, int>;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll l = lcm(c, d);
ll x = b / c - a / c + (a % c == 0);
ll y = b / d - a / d + (a % d == 0);
ll z = b / l - a / l + (a % l == 0);
ll ans = (b - a + 1) - (x + y - z);
cout << ans << endl;
return 0;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 804,257 | 804,258 | u801916231 | cpp |
p02995 | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
ll f(ll x, ll y) {
if (x % y == 0) {
return y;
} else {
return f(y, x % y);
}
}
ll g(ll x, ll y) { return (x - x % y) / y; }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll gcd = f(c, d);
ll p;
p = c * d / gcd;
ll m, n, l;
m = g(b, c) - g(a, c);
n = g(b, d) - g(a, d);
l = g(b, p) - g(a, p);
ll ans = b - a + 1 - m - n + l;
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
ll f(ll x, ll y) {
if (x % y == 0) {
return y;
} else {
return f(y, x % y);
}
}
ll g(ll x, ll y) { return (x - x % y) / y; }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll gcd = f(c, d);
ll p;
p = c * d / gcd;
ll m, n, l;
m = g(b, c) - g(a - 1, c);
n = g(b, d) - g(a - 1, d);
l = g(b, p) - g(a - 1, p);
ll ans = b - a + 1 - m - n + l;
cout << ans << "\n";
return 0;
} | [
"assignment.change"
] | 804,259 | 804,260 | u936877713 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y);
ll a, b;
ll f(ll c) {
ll res = b / c - (a - 1) / c;
return res;
}
int main() {
ll c, d;
cin >> a >> b >> c >> d;
ll cd = c * d / __gcd(c, d);
ll dis = f(c) + f(d) - f(cd);
ll ans = a - b + 1 - dis;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y);
ll a, b;
ll f(ll c) {
ll res = b / c - (a - 1) / c;
return res;
}
int main() {
ll c, d;
cin >> a >> b >> c >> d;
ll cd = c * d / __gcd(c, d);
ll dis = f(c) + f(d) - f(cd);
ll ans = b - a + 1 - dis;
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 804,263 | 804,264 | u005006157 | cpp |
p02995 | // ConsoleApplication1.cpp : このファイルには 'main'
// 関数が含まれています。プログラム実行の開始と終了がそこで行われます。
//
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define pi 3.14159265359;
// %llu %lf
// double result = 0;
// printf("%.12f\n", result);
// v:vector type:型 order:greater(大きい順) or less(小さい順)
#define _sort(v, type, order) \
do { \
sort(v.begin(), v.end(), order<type>()); \
} while (0)
/*
◆pairでもソートは可能
vector<pair<int32_t, bool>> pr(n);
sort(pr.begin(), pr.end(),_compare);
bool _compare(pair<int32_t, bool> a, pair<int32_t, bool> b) {
// firstで比較する場合
if (a.first != b.first) {
return a.first < b.first; // 昇順
return a.first > b.first; // 降順
}
// どちらも同じ
return true;
// secondで比較する場合
if (a.second != b.second) {
return a.second < b.second; // 昇順
return a.second > b.second; // 降順
}
// どちらも同じ
return true;
}
*/
// vector 要素の総和算出
// v:vector default_value:初期値
#define _sum(v, default_value) accumulate(v.begin(), v.end(), default_value)
// vector 最大値( return ite )
#define _max_element(v) max_element(v.begin(), v.end())
// vector 最小値( return ite )
#define _min_element(v) min_element(v.begin(), v.end())
// vector 最大値が格納されている要素値
#define _max_element_number(v) \
distance(v.begin(), max_element(v.begin(), v.end()))
// 特定コンテナの中から特定の値をカウントする
#define _count(v, value) count(v.begin(), v.end(), value)
// set<uint32_t> member; // 重複するデータを保持する事はできない
// member.insert(2) member.insert(2) ⇒ member.count(2)は1
// member.emplace(2)とかも同じ
// member.size()で確認すると同じ値の挿入ではサイズ変化はない
// multiset<uint32_t> v; // 重複するデータも保持する事はできる
// member.insert(2) member.insert(2) ⇒ member.count(2)は2
// 丸め
#define _round(v) round(v)
// 2乗 / 3乗
#define _square(v) pow(v, 2)
#define _cube(v) pow(v, 3)
// 大小判定
#define _max(x, y) max(x, y)
#define _min(x, y) min(x, y)
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;
}
// string ⇒ int
#define _stringtoi(s) stoi(s)
// double 平方根
#define _sqrt(x) sqrt(x)
// double 引数 x 以上で最小の整数値 ex) 3.30303 ⇒ 4
#define _ceil(x) ceil(x)
// 指定された要素 【以上の】 値が現れる最初の位置のイテレータを取得する
#define _lower_bound(v, min) lower_bound(v.begin(), v.end(), min)
// 指定された要素 【より大きい】値が現れる最初の位置のイテレータを取得する
#define _upper_bound(v, min) upper_bound(v.begin(), v.end(), min)
// 順列 n個の数が与えられる
// 0,1,2,...,n-1
// 全ての並べ方を1行ごとに出力する
// ex 0 1 2 / 0 2 1 / 1 0 2 / 1 2 0 / 2 0 1 / 2 1 0
#define _next_permutation(v) \
do { \
for (auto num : v) { \
printf("%d ", num); \
} \
printf("\n"); \
/* ※ 昇順である必要がある */ \
/* ※ pair も pair.firstで可能 */ \
} while (next_permutation(v.begin(), v.end()))
// ■bitset
// 100 桁の 2 進数を定義する。
// bitset<100> bs;
//
// 8桁 の 2進数を定義し、10進数 131で初期化
// bitset<8> bs(131); // 7 ビット目から 0
// ビット目への順番で、10000011 になる
//
// 8桁 の 2進数を定義し、2進数で初期化
// bitset<8> bs("10000011"); // 7 ビット目から 0 ビット目への順番で、10000011
// となる。 string _bs; cin >> _bs; bitset<100> bs(_bs); _bs =
// "10000011"であれば上記と同様
//
// 与えられる数値について、それぞれの和を算出する場合
// 下記コードでビットが立っている要素値＝和の値となる
// ex.) AGC 020 C https://atcoder.jp/contests/agc020/tasks/agc020_c
// bitset<1000> dp;
// p[0] = 1;
// for (int i = 0; i < N; ++i) {
// dp |= (dp << A[i]);
// }
// 絶対値
template <typename T> static T _abs(const T x) { return (x > 0 ? x : -x); }
// 最大公約数
int64_t gcd(int64_t a, int64_t b) {
while (b) {
int64_t c = b;
b = a % b;
a = c;
}
return a;
}
// 最小公倍数
int64_t lcm(int64_t a, int64_t b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
// 多次元 std::vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
// ex) auto dp = make_vec<uint64_t>(SIZE + 1, 2, 2);
//
// 2次元 vector の初期化
// vector< vector<int> > s( n, vector<int>(m, 0) );
// pair
// vector<vector<pair<int32_t,int32_t>>> f(n);
// ⇒ 挿入 f[i].push_back(make_pair(x, y));
// Union Find Tree
class UnionFind {
public:
vector<int32_t> par; // 各元の親を表す配列
vector<int32_t> siz; // 素集合のサイズを表す配列(1 で初期化)
// Constructor 初期では親は自分自身
UnionFind(int32_t sz_) : par(sz_), siz(sz_, 1LL) {
for (int32_t i = 0; i < sz_; ++i)
par[i] = i;
}
void init(int32_t sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (int32_t i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Find
int32_t root(int32_t x) {
// x の親の親を x の親とする
while (par[x] != x) {
x = par[x] = par[par[x]];
// printf("%d\n", x);
}
return x;
}
// Union(Unite, Merge)
bool merge(int32_t x, int32_t y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
// 連結判定
bool is_same(int32_t x, int32_t y) { return root(x) == root(y); }
// 素集合のサイズ
int32_t size(int32_t x) { return siz[root(x)]; }
// 参照
void view(void) {
for (size_t i = 0; i < par.size(); i++) {
printf("%d\n", par[i]);
}
}
};
// ■
// UINT32_MAX
// 4294967295 ≒ 4 * 1e9
// ■
// 割り算した結果との比較での丸め対処時
// ABC 161 B
// https://atcoder.jp/contests/abc161/tasks/abc161_b
// double border = _sum(v, 0 / (double)(4 * m);
// ↓
// uint32_t border = (_sum(v, 0) + (4 * m) - 1) / (4 * m);
/*************************************************************/
// ABC 131
// C - Anti-Division
// https://atcoder.jp/contests/abc131/tasks/abc131_c
/*
■問題文
整数 A,B,C,D が与えられます。
A 以上 B 以下の整数のうち、C でも D
でも割り切れないものの個数を求めてください。
■制約
・1 ≤ A ≤ B ≤ 1e18
・1 ≤ C,D ≤ 1e9
・入力はすべて整数である
■入力
A B C D
■出力
A 以上 B 以下の整数のうち、C でも D
でも割り切れないものの個数を出力せよ。
■入力例
4 9 2 3
■出力例
2
5,7 が条件を満たします。
*/
int main() {
int64_t a, b;
int32_t c, d;
cin >> a >> b >> c >> d;
int64_t result = b - a + 1;
result = result - (b / c - (a - 1) / c) - (b / d - (a - 1) / d);
int64_t temp = lcm(c, d);
result += (b / temp - (a - 1) / temp);
cout << result << endl;
return 0;
}
// プログラムの実行: Ctrl + F5 または [デバッグ] > [デバッグなしで開始] メニュー
// プログラムのデバッグ: F5 または [デバッグ] > [デバッグの開始] メニュー
// 作業を開始するためのヒント:
// 1. ソリューション エクスプローラー
// ウィンドウを使用してファイルを追加/管理します
// 2. チーム エクスプローラー ウィンドウを使用してソース管理に接続します
// 3. 出力ウィンドウを使用して、ビルド出力とその他のメッセージを表示します
// 4. エラー一覧ウィンドウを使用してエラーを表示します
// 5. [プロジェクト] > [新しい項目の追加] と移動して新しいコード
// ファイルを作成するか、[プロジェクト] > [既存の項目の追加]
// と移動して既存のコード ファイルをプロジェクトに追加します
// 6. 後ほどこのプロジェクトを再び開く場合、[ファイル] > [開く] >
// [プロジェクト] と移動して .sln ファイルを選択します
| // ConsoleApplication1.cpp : このファイルには 'main'
// 関数が含まれています。プログラム実行の開始と終了がそこで行われます。
//
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define pi 3.14159265359;
// %llu %lf
// double result = 0;
// printf("%.12f\n", result);
// v:vector type:型 order:greater(大きい順) or less(小さい順)
#define _sort(v, type, order) \
do { \
sort(v.begin(), v.end(), order<type>()); \
} while (0)
/*
◆pairでもソートは可能
vector<pair<int32_t, bool>> pr(n);
sort(pr.begin(), pr.end(),_compare);
bool _compare(pair<int32_t, bool> a, pair<int32_t, bool> b) {
// firstで比較する場合
if (a.first != b.first) {
return a.first < b.first; // 昇順
return a.first > b.first; // 降順
}
// どちらも同じ
return true;
// secondで比較する場合
if (a.second != b.second) {
return a.second < b.second; // 昇順
return a.second > b.second; // 降順
}
// どちらも同じ
return true;
}
*/
// vector 要素の総和算出
// v:vector default_value:初期値
#define _sum(v, default_value) accumulate(v.begin(), v.end(), default_value)
// vector 最大値( return ite )
#define _max_element(v) max_element(v.begin(), v.end())
// vector 最小値( return ite )
#define _min_element(v) min_element(v.begin(), v.end())
// vector 最大値が格納されている要素値
#define _max_element_number(v) \
distance(v.begin(), max_element(v.begin(), v.end()))
// 特定コンテナの中から特定の値をカウントする
#define _count(v, value) count(v.begin(), v.end(), value)
// set<uint32_t> member; // 重複するデータを保持する事はできない
// member.insert(2) member.insert(2) ⇒ member.count(2)は1
// member.emplace(2)とかも同じ
// member.size()で確認すると同じ値の挿入ではサイズ変化はない
// multiset<uint32_t> v; // 重複するデータも保持する事はできる
// member.insert(2) member.insert(2) ⇒ member.count(2)は2
// 丸め
#define _round(v) round(v)
// 2乗 / 3乗
#define _square(v) pow(v, 2)
#define _cube(v) pow(v, 3)
// 大小判定
#define _max(x, y) max(x, y)
#define _min(x, y) min(x, y)
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;
}
// string ⇒ int
#define _stringtoi(s) stoi(s)
// double 平方根
#define _sqrt(x) sqrt(x)
// double 引数 x 以上で最小の整数値 ex) 3.30303 ⇒ 4
#define _ceil(x) ceil(x)
// 指定された要素 【以上の】 値が現れる最初の位置のイテレータを取得する
#define _lower_bound(v, min) lower_bound(v.begin(), v.end(), min)
// 指定された要素 【より大きい】値が現れる最初の位置のイテレータを取得する
#define _upper_bound(v, min) upper_bound(v.begin(), v.end(), min)
// 順列 n個の数が与えられる
// 0,1,2,...,n-1
// 全ての並べ方を1行ごとに出力する
// ex 0 1 2 / 0 2 1 / 1 0 2 / 1 2 0 / 2 0 1 / 2 1 0
#define _next_permutation(v) \
do { \
for (auto num : v) { \
printf("%d ", num); \
} \
printf("\n"); \
/* ※ 昇順である必要がある */ \
/* ※ pair も pair.firstで可能 */ \
} while (next_permutation(v.begin(), v.end()))
// ■bitset
// 100 桁の 2 進数を定義する。
// bitset<100> bs;
//
// 8桁 の 2進数を定義し、10進数 131で初期化
// bitset<8> bs(131); // 7 ビット目から 0
// ビット目への順番で、10000011 になる
//
// 8桁 の 2進数を定義し、2進数で初期化
// bitset<8> bs("10000011"); // 7 ビット目から 0 ビット目への順番で、10000011
// となる。 string _bs; cin >> _bs; bitset<100> bs(_bs); _bs =
// "10000011"であれば上記と同様
//
// 与えられる数値について、それぞれの和を算出する場合
// 下記コードでビットが立っている要素値＝和の値となる
// ex.) AGC 020 C https://atcoder.jp/contests/agc020/tasks/agc020_c
// bitset<1000> dp;
// p[0] = 1;
// for (int i = 0; i < N; ++i) {
// dp |= (dp << A[i]);
// }
// 絶対値
template <typename T> static T _abs(const T x) { return (x > 0 ? x : -x); }
// 最大公約数
int64_t gcd(int64_t a, int64_t b) {
while (b) {
int64_t c = b;
b = a % b;
a = c;
}
return a;
}
// 最小公倍数
int64_t lcm(int64_t a, int64_t b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
// 多次元 std::vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
// ex) auto dp = make_vec<uint64_t>(SIZE + 1, 2, 2);
//
// 2次元 vector の初期化
// vector< vector<int> > s( n, vector<int>(m, 0) );
// pair
// vector<vector<pair<int32_t,int32_t>>> f(n);
// ⇒ 挿入 f[i].push_back(make_pair(x, y));
// Union Find Tree
class UnionFind {
public:
vector<int32_t> par; // 各元の親を表す配列
vector<int32_t> siz; // 素集合のサイズを表す配列(1 で初期化)
// Constructor 初期では親は自分自身
UnionFind(int32_t sz_) : par(sz_), siz(sz_, 1LL) {
for (int32_t i = 0; i < sz_; ++i)
par[i] = i;
}
void init(int32_t sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (int32_t i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Find
int32_t root(int32_t x) {
// x の親の親を x の親とする
while (par[x] != x) {
x = par[x] = par[par[x]];
// printf("%d\n", x);
}
return x;
}
// Union(Unite, Merge)
bool merge(int32_t x, int32_t y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
// 連結判定
bool is_same(int32_t x, int32_t y) { return root(x) == root(y); }
// 素集合のサイズ
int32_t size(int32_t x) { return siz[root(x)]; }
// 参照
void view(void) {
for (size_t i = 0; i < par.size(); i++) {
printf("%d\n", par[i]);
}
}
};
// ■
// UINT32_MAX
// 4294967295 ≒ 4 * 1e9
// ■
// 割り算した結果との比較での丸め対処時
// ABC 161 B
// https://atcoder.jp/contests/abc161/tasks/abc161_b
// double border = _sum(v, 0 / (double)(4 * m);
// ↓
// uint32_t border = (_sum(v, 0) + (4 * m) - 1) / (4 * m);
/*************************************************************/
// ABC 131
// C - Anti-Division
// https://atcoder.jp/contests/abc131/tasks/abc131_c
/*
■問題文
整数 A,B,C,D が与えられます。
A 以上 B 以下の整数のうち、C でも D
でも割り切れないものの個数を求めてください。
■制約
・1 ≤ A ≤ B ≤ 1e18
・1 ≤ C,D ≤ 1e9
・入力はすべて整数である
■入力
A B C D
■出力
A 以上 B 以下の整数のうち、C でも D
でも割り切れないものの個数を出力せよ。
■入力例
4 9 2 3
■出力例
2
5,7 が条件を満たします。
*/
int main() {
int64_t a, b;
int64_t c, d;
cin >> a >> b >> c >> d;
int64_t result = b - a + 1;
result = result - (b / c - (a - 1) / c) - (b / d - (a - 1) / d);
int64_t temp = lcm(c, d);
result += (b / temp - (a - 1) / temp);
cout << result << endl;
return 0;
}
// プログラムの実行: Ctrl + F5 または [デバッグ] > [デバッグなしで開始] メニュー
// プログラムのデバッグ: F5 または [デバッグ] > [デバッグの開始] メニュー
// 作業を開始するためのヒント:
// 1. ソリューション エクスプローラー
// ウィンドウを使用してファイルを追加/管理します
// 2. チーム エクスプローラー ウィンドウを使用してソース管理に接続します
// 3. 出力ウィンドウを使用して、ビルド出力とその他のメッセージを表示します
// 4. エラー一覧ウィンドウを使用してエラーを表示します
// 5. [プロジェクト] > [新しい項目の追加] と移動して新しいコード
// ファイルを作成するか、[プロジェクト] > [既存の項目の追加]
// と移動して既存のコード ファイルをプロジェクトに追加します
// 6. 後ほどこのプロジェクトを再び開く場合、[ファイル] > [開く] >
// [プロジェクト] と移動して .sln ファイルを選択します
| [
"variable_declaration.type.primitive.change"
] | 804,274 | 804,275 | u065467277 | cpp |
p02995 | #include <algorithm>
#include <ciso646>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
ll Max = 10 + 1e12;
int N = 5 + 1e5;
int gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
ll a, b;
ll c, d;
cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ll bc = b / c;
ll bd = b / d;
ll ac = (a - 1) / c;
ll ad = (a - 1) / d;
ll t = lcm(c, d);
ll bt = b / t;
ll at = (a - 1) / t;
ans -= (bc + bd);
ans += bt;
ans += (ac + ad);
ans -= at;
cout << ans;
}
| #include <algorithm>
#include <ciso646>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
ll Max = 10 + 1e12;
int N = 5 + 1e5;
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); }
int main() {
ll a, b;
ll c, d;
cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ll bc = b / c;
ll bd = b / d;
ll ac = (a - 1) / c;
ll ad = (a - 1) / d;
ll t = lcm(c, d);
ll bt = b / t;
ll at = (a - 1) / t;
ans -= (bc + bd);
ans += bt;
ans += (ac + ad);
ans -= at;
cout << ans;
} | [] | 804,281 | 804,282 | u510989601 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define repi(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2i(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define deg2rad(deg) (((deg) / 360) * 2 * M_PI)
#define rad2deg(rad) (((rad) / 2 / M_PI) * 360)
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
const ll INF = (1LL << 60);
const int INFi = (1 << 29);
/*素数判定*/
bool is_prime(ll n) {
if (n == 1)
return false;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
/*約数列挙*/
vll enum_divisors(ll n) {
vll l;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
l.push_back(i);
if (n / i != i)
l.push_back(n / i);
}
}
sort(all(l));
return l;
}
/*素因数分解*/
vector<P> prime_factorize(ll n) {
vector<P> l;
for (ll i = 2; i * i <= n; i++) {
if (n % i != 0)
continue;
ll e = 0;
while (n % i == 0) {
e++;
n /= i;
}
l.push_back({i, e});
}
if (n != 1)
l.push_back({n, 1});
return l;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
b++;
cout << (b - ((b / c + b / d) - (b / (c * d / __gcd(c, d))))) -
(a - ((a / c + a / d) - (a / (c * d / __gcd(c, d)))))
<< endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define repi(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2i(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define deg2rad(deg) (((deg) / 360) * 2 * M_PI)
#define rad2deg(rad) (((rad) / 2 / M_PI) * 360)
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
const ll INF = (1LL << 60);
const int INFi = (1 << 29);
/*素数判定*/
bool is_prime(ll n) {
if (n == 1)
return false;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
/*約数列挙*/
vll enum_divisors(ll n) {
vll l;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
l.push_back(i);
if (n / i != i)
l.push_back(n / i);
}
}
sort(all(l));
return l;
}
/*素因数分解*/
vector<P> prime_factorize(ll n) {
vector<P> l;
for (ll i = 2; i * i <= n; i++) {
if (n % i != 0)
continue;
ll e = 0;
while (n % i == 0) {
e++;
n /= i;
}
l.push_back({i, e});
}
if (n != 1)
l.push_back({n, 1});
return l;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
cout << (b - ((b / c + b / d) - (b / (c * d / __gcd(c, d))))) -
(a - ((a / c + a / d) - (a / (c * d / __gcd(c, d)))))
<< endl;
return 0;
} | [] | 804,290 | 804,291 | u994630752 | cpp |
p02995 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
static const double PI = acos(-1);
ll lcm(ll x, ll y) {
ll ans;
ans = x / __gcd(x, y) * y;
return ans;
}
int main() {
ll a, b;
ll c, d;
cin >> a >> b >> c >> d;
ll x, y, xy;
x = b / c - (a - 1) / c;
y = b / d - (a - 1) / d;
ll e = lcm(c, d);
xy = b / e - a / e;
// cout << x << " " << y << " " << xy << endl;
ll ans;
ans = b - a + 1 - x - y + xy;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
static const double PI = acos(-1);
ll lcm(ll x, ll y) {
ll ans;
ans = x / __gcd(x, y) * y;
return ans;
}
int main() {
ll a, b;
ll c, d;
cin >> a >> b >> c >> d;
ll x, y, xy;
x = b / c - (a - 1) / c;
y = b / d - (a - 1) / d;
ll e = lcm(c, d);
xy = b / e - (a - 1) / e;
// cout << x << " " << y << " " << xy << endl;
ll ans;
ans = b - a + 1 - x - y + xy;
cout << ans << endl;
return 0;
}
| [] | 804,302 | 804,303 | u849151695 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
string char_to_string(char val) { return string(1, val); }
int char_to_int(char val) { return val - '0'; }
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;
}
int vector_finder(std::vector<ll> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance(vec.begin(), itr);
if (index != vec.size()) { // 発見できたとき
return 1;
} else { // 発見できなかったとき
return 0;
}
}
// 最大公約数
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 / gcd(a, b) * b; }
int main() {
ll A, B;
cin >> A >> B;
ll C, D;
cin >> C >> D;
ll ALL = B - A + 1;
ll c = B / C - (A - 1) / C;
ll d = B / D - (A - 1) / D;
ll cd = B / lcm(C, D) - A / lcm(C, D);
cout << ALL - c - d + cd << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
string char_to_string(char val) { return string(1, val); }
int char_to_int(char val) { return val - '0'; }
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;
}
int vector_finder(std::vector<ll> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance(vec.begin(), itr);
if (index != vec.size()) { // 発見できたとき
return 1;
} else { // 発見できなかったとき
return 0;
}
}
// 最大公約数
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 / gcd(a, b) * b; }
int main() {
ll A, B;
cin >> A >> B;
ll C, D;
cin >> C >> D;
ll ALL = B - A + 1;
ll c = B / C - (A - 1) / C;
ll d = B / D - (A - 1) / D;
ll cd = B / lcm(C, D) - (A - 1) / lcm(C, D);
cout << ALL - c - d + cd << endl;
} | [] | 804,325 | 804,326 | u308463793 | cpp |
p02995 | #include <bits/stdc++.h>
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define ll long long
#define ara(A, N) sort(A, A + N)
#define rev(A, N) sort(A, A + N, greater<long long>())
using namespace std;
int main() {
speed_up;
int a, b, c, d;
cin >> a >> b >> c >> d;
int x, i, j, k;
x = (c * d) / __gcd(c, d);
if (a % c == 0) {
i = b / c - a / c + 1;
} else if (a % c != 0) {
i = b / c - a / c;
}
if (a % d == 0) {
j = b / d - a / d + 1;
} else if (a % d != 0) {
j = b / d - a / d;
}
if (a % x == 0) {
k = b / x - a / x + 1;
} else if (a % x != 0) {
k = b / x - a / x;
}
cout << b - a - i - j + k + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define ll long long
#define ara(A, N) sort(A, A + N)
#define rev(A, N) sort(A, A + N, greater<long long>())
using namespace std;
int main() {
speed_up;
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll x, i, j, k;
x = (c * d) / __gcd(c, d);
if (a % c == 0) {
i = b / c - a / c + 1;
} else if (a % c != 0) {
i = b / c - a / c;
}
if (a % d == 0) {
j = b / d - a / d + 1;
} else if (a % d != 0) {
j = b / d - a / d;
}
if (a % x == 0) {
k = b / x - a / x + 1;
} else if (a % x != 0) {
k = b / x - a / x;
}
cout << b - a - i - j + k + 1 << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 804,331 | 804,332 | u782695198 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
ll gcd(ll a, ll b) {
if (0 < b)
return gcd(b, a % b);
else
return a;
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll f(ll a, ll b, ll c) {
int ans = a;
ans -= a / b;
ans -= a / c;
ans += a / lcm(b, c);
return ans;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
ll gcd(ll a, ll b) {
if (0 < b)
return gcd(b, a % b);
else
return a;
// return b ? gcd(b, a%b) : a;
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll f(ll a, ll b, ll c) {
ll ans = a;
ans -= a / b;
ans -= a / c;
ans += a / lcm(b, c);
return ans;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 804,372 | 804,373 | u442855610 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c * d / gcd(c, d); }
ll f(ll x, ll c, ll d) {
ll ans = x;
ans -= x / c;
ans -= x / d;
ans += lcm(c, d);
return ans;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c * d / gcd(c, d); }
ll f(ll x, ll c, ll d) {
ll ans = x;
ans -= x / c;
ans -= x / d;
ans += x / lcm(c, d);
return ans;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 804,374 | 804,375 | u442855610 | cpp |
p02995 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, k) for (int i = n; i < k; i++)
#define P(p) cout << (p) << endl;
#define sP(p) cout << setprecision(24) << fixed << p << endl;
#define vi vector<int>
#define printv(v) \
for (int i = 0; i < v.size(); i++) \
P(v[i]);
#define printt(a, b) cout << a << " " << b << endl;
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int MOD = 1e9 + 7;
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; //先に割り算をして掛けられる数を小さくして掛け算を行う
}
bool pairCompare(const pair<int, int> &firstElof,
const pair<int, int> &secondElof) {
return firstElof.second < secondElof.second;
}
void solve() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll cdlcm = lcm(c, d);
ll cm = (b / c) - (a / c), dm = (b / d) - (a / d),
cdm = (b / cdlcm) - (a / cdlcm);
if (a % c == 0)
cm++;
if (a % c == 0)
dm++;
if (a % cdlcm == 0)
cdm++;
P((b - a + 1) - (cm + dm - cdm));
}
int main() {
solve();
return 0;
}
| #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, k) for (int i = n; i < k; i++)
#define P(p) cout << (p) << endl;
#define sP(p) cout << setprecision(24) << fixed << p << endl;
#define vi vector<int>
#define printv(v) \
for (int i = 0; i < v.size(); i++) \
P(v[i]);
#define printt(a, b) cout << a << " " << b << endl;
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int MOD = 1e9 + 7;
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; //先に割り算をして掛けられる数を小さくして掛け算を行う
}
bool pairCompare(const pair<int, int> &firstElof,
const pair<int, int> &secondElof) {
return firstElof.second < secondElof.second;
}
void solve() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll cdlcm = lcm(c, d);
ll cm = (b / c) - (a / c), dm = (b / d) - (a / d),
cdm = (b / cdlcm) - (a / cdlcm);
if (a % c == 0)
cm++;
if (a % d == 0)
dm++;
if (a % cdlcm == 0)
cdm++;
P((b - a + 1) - (cm + dm - cdm));
}
int main() {
solve();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 804,383 | 804,384 | u687470137 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(s, t) \
for (int s = 0; s < t; s++) \
;
using namespace std;
using ll = long long;
int gcd(ll c, ll d) {
if (d == 0)
return c;
return gcd(d, c % d);
}
int lcm(ll c, ll d) { return c / gcd(c, d) * d; }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll koubai = lcm(c, d);
ll ans = 0;
ll count = b - a + 1;
ll canc, cand, cancd;
canc = (b / c) - ((a - 1) / c);
cand = (b / d) - ((a - 1) / d);
cancd = (b / (koubai)) - ((a - 1) / (koubai));
ans += count - (canc + cand - cancd);
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(s, t) \
for (int s = 0; s < t; s++) \
;
using namespace std;
using ll = long long;
ll gcd(ll c, ll d) {
if (d == 0)
return c;
return gcd(d, c % d);
}
ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll koubai = lcm(c, d);
ll ans = 0;
ll count = b - a + 1;
ll canc, cand, cancd;
canc = (b / c) - ((a - 1) / c);
cand = (b / d) - ((a - 1) / d);
cancd = (b / (koubai)) - ((a - 1) / (koubai));
ans += count - (canc + cand - cancd);
cout << ans << endl;
} | [] | 804,404 | 804,405 | u712098017 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
// 131_C
long long A, B, CD;
int C, D;
int gcd(int c, int d) {
if (c % d == 0)
return d;
else
return gcd(d, c % d);
}
int main() {
cin >> A >> B >> C >> D;
long long a, b;
CD = C * D / gcd(C, D);
b = (B / C) + (B / D) - (B / CD);
a = ((A - 1) / C) + ((A - 1) / D) - ((A - 1) / CD);
cout << (B - A + 1) - (b - a) << endl;
} | #include <bits/stdc++.h>
using namespace std;
// 131_C
long long A, B, CD;
long long C, D;
int gcd(int c, int d) {
if (c % d == 0)
return d;
else
return gcd(d, c % d);
}
int main() {
cin >> A >> B >> C >> D;
long long a, b;
CD = C * D / gcd(C, D);
b = (B / C) + (B / D) - (B / CD);
a = ((A - 1) / C) + ((A - 1) / D) - ((A - 1) / CD);
cout << (B - A + 1) - (b - a) << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,418 | 804,419 | u455586058 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl = vector<ll>;
using VV = vector<vector<int>>;
using VVl = vector<vector<ll>>;
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll g = __gcd(c, d);
ll lcm = c * d / g;
a--;
ll ctc = b / c - a / c;
ll ctd = b / d - a / c;
ll ctl = b / lcm - a / lcm;
ll U = b - a;
ll ans = U - (ctc + ctd - ctl);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl = vector<ll>;
using VV = vector<vector<int>>;
using VVl = vector<vector<ll>>;
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll g = __gcd(c, d);
ll lcm = c * d / g;
a--;
ll ctc = b / c - a / c;
ll ctd = b / d - a / d;
ll ctl = b / lcm - a / lcm;
ll U = b - a;
ll ans = U - (ctc + ctd - ctl);
cout << ans << endl;
}
| [
"identifier.change",
"expression.operation.binary.change"
] | 804,426 | 804,427 | u525008368 | cpp |
p02995 | #include <cstdint>
#include <iostream>
#include <numeric>
using namespace std;
int main() {
int64_t a, b, c, d;
cin >> a >> b >> c >> d;
// CとDの最小公倍数
auto lcmn = lcm(c, d);
// A以上、B未満の間に存在するCの倍数の数 (B以下に存在する倍数の数 -
// A未満に存在する倍数の数)
auto cn = b / c - (a - 1) / c;
// A以上、B未満の間に存在するDの倍数の数
auto dn = b / d - (a - 1) / d;
// A以上。B未満の間に存在するCとDの最小公倍数の倍数の数
auto cdn = b / lcmn - a / lcmn;
// 全体 - Cの倍数の数 - Dの倍数の数 - CとDの最小公倍数の数
cout << (b - a + 1) - cn - dn + cdn << endl;
}
| #include <cstdint>
#include <iostream>
#include <numeric>
using namespace std;
int main() {
int64_t a, b, c, d;
cin >> a >> b >> c >> d;
// CとDの最小公倍数
auto lcmn = lcm(c, d);
// A以上、B未満の間に存在するCの倍数の数 (B以下に存在する倍数の数 -
// A未満に存在する倍数の数)
auto cn = b / c - (a - 1) / c;
// A以上、B未満の間に存在するDの倍数の数
auto dn = b / d - (a - 1) / d;
// A以上。B未満の間に存在するCとDの最小公倍数の倍数の数
auto cdn = b / lcmn - (a - 1) / lcmn;
// 全体 - Cの倍数の数 - Dの倍数の数 + CとDの最小公倍数の倍数の数
cout << (b - a + 1) - cn - dn + cdn << endl;
}
| [] | 804,428 | 804,429 | u967915578 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using namespace std;
int main() {
ll a, b, c, d, lcm;
cin >> a >> b >> c >> d;
lcm = c / __gcd(c, d) * d;
// cerr << "lcm" << lcm << endl;
ll e = b;
e -= b / c;
e -= b / d;
e += b / lcm;
ll f = a - 1;
f -= (a - 1) / c;
f -= (a - 1) / d;
f -= (a - 1) / lcm;
cout << e - f << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using namespace std;
int main() {
ll a, b, c, d, lcm;
cin >> a >> b >> c >> d;
lcm = c / __gcd(c, d) * d;
// cerr << "lcm" << lcm << endl;
ll e = b;
e -= b / c;
e -= b / d;
e += b / lcm;
ll f = a - 1;
f -= (a - 1) / c;
f -= (a - 1) / d;
f += (a - 1) / lcm;
cout << e - f << endl;
return 0;
} | [
"expression.operator.change"
] | 804,432 | 804,433 | u617826263 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < (N); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int inf{int(1e9)};
int main(void) {
ll A, B, C, D;
cin >> A >> B >> C >> D;
auto f = [&](ll N) { return N - (N / C + N / D - N / gcd(C, D)); };
cout << f(B) - f(A - 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < (N); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int inf{int(1e9)};
int main(void) {
ll A, B, C, D;
cin >> A >> B >> C >> D;
auto f = [&](ll N) { return N - (N / C + N / D - N / lcm(C, D)); };
cout << f(B) - f(A - 1) << endl;
return 0;
}
| [
"identifier.change",
"call.function.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 804,438 | 804,439 | u437633151 | cpp |
p02995 | #include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;
using P = pair<int, int>;
#include <algorithm>
#include <map>
#include <math.h>
#include <queue>
#include <set>
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll cntd = b / d - a / d;
ll cntc = b / c - a / c;
ll g = lcm(c, d);
ll cntcd = b / g - a / g;
ll sum = cntd + cntc - cntcd;
cout << b - a - sum;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;
using P = pair<int, int>;
#include <algorithm>
#include <map>
#include <math.h>
#include <queue>
#include <set>
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); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll cntd = b / d - a / d;
ll cntc = b / c - a / c;
ll g = lcm(c, d);
ll cntcd = b / g - a / g;
ll sum = cntd + cntc - cntcd;
cout << b - a - sum;
return 0;
} | [] | 804,440 | 804,441 | u872982453 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
// cout << setprecision(20) <<
ll gcd(ll x, ll y) { return y ? __gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / __gcd(x, y) * y; }
ll count(ll R, ll mul) { return floor((double)R / mul); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll bcount = B - count(B, C) - count(B, D) + count(B, lcm(C, D));
ll acount =
A - 1 - count(A - 1, C) - count(A - 1, D) + count(A - 1, lcm(C, D));
cout << bcount - acount << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
// cout << setprecision(20) <<
ll gcd(ll x, ll y) { return y ? __gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / __gcd(x, y) * y; }
ll count(ll R, ll mul) { return R / mul; }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll bcount = B - count(B, C) - count(B, D) + count(B, lcm(C, D));
ll acount =
A - 1 - count(A - 1, C) - count(A - 1, D) + count(A - 1, lcm(C, D));
cout << bcount - acount << endl;
} | [
"call.remove",
"call.arguments.change"
] | 804,444 | 804,445 | u185821641 | cpp |
p02995 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int A = 0, B = 0, C = 0, D = 0;
cin >> A >> B >> C >> D;
long long int a = 0, b = 0, c = 0, g = 0, l = 0;
long long int aa = 0, bb = 0, cc = 0, dd = 1;
aa = C, bb = D;
while (dd != 0) {
cc = aa / bb;
dd = aa % bb;
aa = bb;
bb = dd;
}
l = aa;
a = B / C;
b = B / D;
g = C * D / l;
c = B / g;
// cout << g << endl;
// cout << a << b << c << endl;
long long int answer = B - (a + b - c);
a = (A - 1) / C;
b = (A - 1) / D;
// g = C*D/l;
c = A / g;
// cout << a << b << c << endl;
answer = answer - (A - (a + b - c));
cout << answer + 1 << endl;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int A = 0, B = 0, C = 0, D = 0;
cin >> A >> B >> C >> D;
long long int a = 0, b = 0, c = 0, g = 0, l = 0;
long long int aa = 0, bb = 0, cc = 0, dd = 1;
aa = C, bb = D;
while (dd != 0) {
cc = aa / bb;
dd = aa % bb;
aa = bb;
bb = dd;
}
l = aa;
a = B / C;
b = B / D;
g = C * D / l;
c = B / g;
// cout << g << endl;
// cout << a << b << c << endl;
long long int answer = B - (a + b - c);
a = (A - 1) / C;
b = (A - 1) / D;
// g = C*D/l;
c = (A - 1) / g;
// cout << a << b << c << endl;
answer = answer - (A - (a + b - c));
cout << answer + 1 << endl;
}
/*#include<bits/stdc++.h>
using namespace std ;
#define rep(i,N) for(int i = 0 ; i <(N) ; i++)
typedef long long ll;
ll f(ll x , ll C , ll D){
ll res = x ;
res -= x/C ;
res -= x/D ;
res += x/lcm(C,D) ;
return res ;
}
int main(){
ll A , B ;
ll C , D ;
cin >> A >> B >> C >> D ;
ll ans = f(B, C ,D) - f(A-1,C,D) ;
cout << ans << endl ;
return 0 ;
}*/
| [] | 804,450 | 804,451 | u944804272 | cpp |
p02995 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int A = 0, B = 0, C = 0, D = 0;
cin >> A >> B >> C >> D;
long long int a = 0, b = 0, c = 0, g = 0, l = 0;
long long int aa = 0, bb = 0, cc = 0, dd = 0;
aa = C, bb = D;
while (dd != 0) {
cc = aa / bb;
dd = aa % bb;
aa = bb;
bb = dd;
}
l = aa;
a = B / C;
b = B / D;
g = C * D / l;
c = B / g;
// cout << g << endl;
// cout << a << b << c << endl;
long long int answer = B - (a + b - c);
a = (A - 1) / C;
b = (A - 1) / D;
// g = C*D/l;
c = A / g;
// cout << a << b << c << endl;
answer = answer - (A - (a + b - c));
cout << answer + 1 << endl;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int A = 0, B = 0, C = 0, D = 0;
cin >> A >> B >> C >> D;
long long int a = 0, b = 0, c = 0, g = 0, l = 0;
long long int aa = 0, bb = 0, cc = 0, dd = 1;
aa = C, bb = D;
while (dd != 0) {
cc = aa / bb;
dd = aa % bb;
aa = bb;
bb = dd;
}
l = aa;
a = B / C;
b = B / D;
g = C * D / l;
c = B / g;
// cout << g << endl;
// cout << a << b << c << endl;
long long int answer = B - (a + b - c);
a = (A - 1) / C;
b = (A - 1) / D;
// g = C*D/l;
c = (A - 1) / g;
// cout << a << b << c << endl;
answer = answer - (A - (a + b - c));
cout << answer + 1 << endl;
}
/*#include<bits/stdc++.h>
using namespace std ;
#define rep(i,N) for(int i = 0 ; i <(N) ; i++)
typedef long long ll;
ll f(ll x , ll C , ll D){
ll res = x ;
res -= x/C ;
res -= x/D ;
res += x/lcm(C,D) ;
return res ;
}
int main(){
ll A , B ;
ll C , D ;
cin >> A >> B >> C >> D ;
ll ans = f(B, C ,D) - f(A-1,C,D) ;
cout << ans << endl ;
return 0 ;
}*/
| [
"literal.number.change",
"variable_declaration.value.change"
] | 804,452 | 804,451 | u944804272 | cpp |
p02995 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int A = 0, B = 0, C = 0, D = 0;
cin >> A >> B >> C >> D;
long long int a = 0, b = 0, c = 0, g = 0, l = 0;
long long int aa = 0, bb = 0, cc = 1, dd = 1;
aa = C, bb = D;
while (dd != 0) {
cc = aa / bb;
dd = aa % bb;
aa = bb;
bb = dd;
}
l = aa;
a = B / C;
b = B / D;
g = C * D / l;
c = B / g;
// cout << g << endl;
// cout << a << b << c << endl;
long long int answer = B - (a + b - c);
a = (A - 1) / C;
b = (A - 1) / D;
// g = C*D/l;
c = A / g;
// cout << a << b << c << endl;
answer = answer - (A - (a + b - c));
cout << answer + 1 << endl;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int A = 0, B = 0, C = 0, D = 0;
cin >> A >> B >> C >> D;
long long int a = 0, b = 0, c = 0, g = 0, l = 0;
long long int aa = 0, bb = 0, cc = 0, dd = 1;
aa = C, bb = D;
while (dd != 0) {
cc = aa / bb;
dd = aa % bb;
aa = bb;
bb = dd;
}
l = aa;
a = B / C;
b = B / D;
g = C * D / l;
c = B / g;
// cout << g << endl;
// cout << a << b << c << endl;
long long int answer = B - (a + b - c);
a = (A - 1) / C;
b = (A - 1) / D;
// g = C*D/l;
c = (A - 1) / g;
// cout << a << b << c << endl;
answer = answer - (A - (a + b - c));
cout << answer + 1 << endl;
}
/*#include<bits/stdc++.h>
using namespace std ;
#define rep(i,N) for(int i = 0 ; i <(N) ; i++)
typedef long long ll;
ll f(ll x , ll C , ll D){
ll res = x ;
res -= x/C ;
res -= x/D ;
res += x/lcm(C,D) ;
return res ;
}
int main(){
ll A , B ;
ll C , D ;
cin >> A >> B >> C >> D ;
ll ans = f(B, C ,D) - f(A-1,C,D) ;
cout << ans << endl ;
return 0 ;
}*/
| [
"literal.number.change",
"variable_declaration.value.change"
] | 804,453 | 804,451 | u944804272 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
typedef long long ll;
ll f(ll x, int C, int D) {
ll res = x;
res -= x / C;
res -= x / D;
res += x / lcm(C, D);
return res;
}
int main() {
ll A, B;
int C, D;
cin >> A >> B >> C >> D;
ll ans = f(B, C, D) - f(A - 1, C, D);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
typedef long long ll;
ll f(ll x, ll C, ll D) {
ll res = x;
res -= x / C;
res -= x / D;
res += x / lcm(C, D);
return res;
}
int main() {
ll A, B;
ll C, D;
cin >> A >> B >> C >> D;
ll ans = f(B, C, D) - f(A - 1, C, D);
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 804,457 | 804,458 | u714624983 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define endl '\n'
#define pii pair<int, int>
#define all(a) a.begin(), a.end()
template <typename T> inline T gcd(T a, T b) {
while (b != 0)
swap(b, a %= b);
return a;
}
ll f(ll n, ll x) {
if (n >= 0)
return n / x + 1;
else
return 0;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll lcm = (c * d) / gcd(c, d);
ll dc = f(b, c) - f(a - 1, c);
ll dd = f(b, d) - f(a - 1, d);
ll l = f(b, lcm) - f(a - 1, lcm);
cout << (b - a) - (dc + dd - l);
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define endl '\n'
#define pii pair<int, int>
#define all(a) a.begin(), a.end()
template <typename T> inline T gcd(T a, T b) {
while (b != 0)
swap(b, a %= b);
return a;
}
ll f(ll n, ll x) {
if (n >= 0)
return n / x + 1;
else
return 0;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll lcm = (c * d) / gcd(c, d);
ll dc = f(b, c) - f(a - 1, c);
ll dd = f(b, d) - f(a - 1, d);
ll l = f(b, lcm) - f(a - 1, lcm);
cout << (b - a) - (dc + dd - l) + 1;
} | [
"expression.operation.binary.add"
] | 804,461 | 804,462 | u324973749 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
int main() {
long A, B;
cin >> A >> B;
int C, D;
cin >> C >> D;
int ans = 0;
ans += B / C;
ans += B / D;
ans -= (A - 1) / C;
ans -= (A - 1) / D;
long S = gcd(C, D);
ans -= ((B / C) * S) / D;
ans += (((A - 1) / C) * S) / D;
cout << B - A + 1 - ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long A, B;
cin >> A >> B;
long C, D;
cin >> C >> D;
long ans = 0;
ans += B / C;
ans += B / D;
ans -= (A - 1) / C;
ans -= (A - 1) / D;
long S = gcd(C, D);
ans -= ((B / C) * S) / D;
ans += (((A - 1) / C) * S) / D;
cout << B - A + 1 - ans << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 804,480 | 804,481 | u430394202 | cpp |
p02995 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
bool compare(int i, int j) { return i > j; }
long long num(long long A, long long B, long long M) {
// Add 1 explicitly as A is divisible by M
if (A % M == 0)
return (B / M) - (A / M) + 1;
// A is not divisible by M
return (B / M) - (A / M);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll P = (C * D) / __gcd(C, D);
ll solution = num(A, B, C) + num(A, B, D) - num(A, B, P);
cout << (B - A - 1) - solution;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
bool compare(int i, int j) { return i > j; }
long long num(long long A, long long B, long long M) {
// Add 1 explicitly as A is divisible by M
if (A % M == 0)
return (B / M) - (A / M) + 1;
// A is not divisible by M
return (B / M) - (A / M);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll P = (C * D) / __gcd(C, D);
ll solution = num(A, B, C) + num(A, B, D) - num(A, B, P);
cout << (B - A + 1) - solution;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 804,482 | 804,483 | u863370423 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
/* function */
ll gcd(ll x, ll y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll g(ll x, ll y) { return x / y; }
ll f(ll x, ll m, ll n) { return x - g(x, m) + g(x, n) - g(x, lcm(m, n)); }
/* main */
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << f(B, C, D) - f(A - 1, C, D) << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
/* function */
ll gcd(ll x, ll y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll g(ll x, ll y) { return x / y; }
ll f(ll x, ll m, ll n) { return x - (g(x, m) + g(x, n) - g(x, lcm(m, n))); }
/* main */
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << f(B, C, D) - f(A - 1, C, D) << '\n';
}
| [
"function.return_value.change"
] | 804,484 | 804,485 | u603234915 | cpp |
p02995 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) { return (!b ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return ((a * b) / gcd(a, b)); }
bool cmp(int a, int b) { return a > b; }
const ll mod = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod) {
if (k == 0)
return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1)
r = r * n % mod;
return r;
}
void solve() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll r = b - a + 1;
if (c > d)
swap(c, d);
ll db = b / c + b / d - b / lcm(d, c);
a--;
ll da = a / c + a / d + a / lcm(d, c);
ll ans = r - (db - da);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) { return (!b ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return ((a * b) / gcd(a, b)); }
bool cmp(int a, int b) { return a > b; }
const ll mod = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod) {
if (k == 0)
return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1)
r = r * n % mod;
return r;
}
void solve() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll r = b - a + 1;
if (c > d)
swap(c, d);
ll db = b / c + b / d - b / lcm(d, c);
a--;
ll da = a / c + a / d - a / lcm(d, c);
ll ans = r - (db - da);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 804,492 | 804,493 | u633066470 | cpp |
p02995 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) { return (!b ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
bool cmp(int a, int b) { return a > b; }
const ll mod = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod) {
if (k == 0)
return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1)
r = r * n % mod;
return r;
}
void solve() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll r = b - a + 1;
if (c > d)
swap(c, d);
ll db = b / c + b / d - b / lcm(d, c);
a--;
ll da = a / c + a / d + a / lcm(d, c);
ll ans = r - (db - da);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) { return (!b ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return ((a * b) / gcd(a, b)); }
bool cmp(int a, int b) { return a > b; }
const ll mod = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod) {
if (k == 0)
return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1)
r = r * n % mod;
return r;
}
void solve() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll r = b - a + 1;
if (c > d)
swap(c, d);
ll db = b / c + b / d - b / lcm(d, c);
a--;
ll da = a / c + a / d - a / lcm(d, c);
ll ans = r - (db - da);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| [
"function.return_value.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 804,494 | 804,493 | u633066470 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ll cd = lcm(c, d);
ll cnt =
b / c + b / d - ((a - 1) / c + (a - 1) / d) - (b / cd + ((a - 1) / cd));
cout << ans - cnt << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ll cd = lcm(c, d);
ll cnt =
b / c + b / d - ((a - 1) / c + (a - 1) / d) - (b / cd - (a - 1) / cd);
cout << ans - cnt << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 804,495 | 804,496 | u735909278 | cpp |
p02995 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 201010;
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
char c[310][310];
ll dp[101];
// long longしか使わない
//素数は1より大きい
// lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
// upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = b;
ll res = a - 1;
res -= a / c + a / d;
res += a / lcm(c, d);
ans -= b / c + b / d;
ans += b / lcm(c, d);
ans -= res;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 201010;
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
char c[310][310];
ll dp[101];
// long longしか使わない
//素数は1より大きい
// lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
// upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll ans = b;
ll res = a;
res -= a / c + a / d;
res += a / lcm(c, d);
ans -= b / c + b / d;
ans += b / lcm(c, d);
ans -= res;
cout << ans << endl;
return 0;
}
| [
"expression.unary.arithmetic.add",
"expression.operation.binary.remove"
] | 804,508 | 804,509 | u631558039 | cpp |
p02995 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9 + 7);
template <typename T> T gcd(T a, T b) {
if (a < b)
swap(a, b);
T r;
while (r = a % b) {
a = b;
b = r;
}
return b;
}
template <typename T> T lcm(T a, T b) { return (a / gcd(a, b)) * b; }
int main(void) {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll l = lcm(c, d);
ll na = a - 1LL;
na -= ((a - 1LL) / c + (a - 1LL) / d);
na += a / l;
ll nb = b;
nb -= (b / c + b / d);
nb += b / l;
cout << nb - na << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9 + 7);
template <typename T> T gcd(T a, T b) {
if (a < b)
swap(a, b);
T r;
while (r = a % b) {
a = b;
b = r;
}
return b;
}
template <typename T> T lcm(T a, T b) { return (a / gcd(a, b)) * b; }
int main(void) {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll l = lcm(c, d);
ll na = a - 1LL;
na -= ((a - 1LL) / c + (a - 1LL) / d);
na += (a - 1LL) / l;
ll nb = b;
nb -= (b / c + b / d);
nb += b / l;
cout << nb - na << endl;
return 0;
}
| [] | 804,521 | 804,522 | u835805357 | cpp |
p02995 | #include <bits/stdc++.h>
#include <string>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
typedef pair<long long, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) for (long long i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
long long n, h[100005];
ll dp[100005];
#define ALL(v) (v).begin(), (v).end()
std::set<long long> st;
//#define MAX(a,b) if(a>b)
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
/* ペア関連
//vector<pair<long long, long long> > pairs(N);
for(long long i=0; i<N; i++){
long long a, b;
cin >> a >> b;
pairs[i] = make_pair(a, b);
}
//sort(pairs.begin(), pairs.end(),greater<pair<long long,long long> >());
sort(pairs.begin(), pairs.end());
*/
// stack<long long> sta;
// queue<long long> que;
int main() {
long long A, B, C, D, E, F, G, H, I, J, L, N, M, K, O, P, Q, R, S, T, U, V, W,
X, Y, Z;
long long ans;
ans = 0;
string s;
long long sum, sum1, sum2, sum3;
sum = 0;
sum1 = 0;
long long flg, flg1, cnt, cnt1;
flg = 0;
flg1 = 0;
cnt = 0;
cnt1 = 0;
long long max;
long long max1;
max = 0;
max1 = 0;
long long min;
long long min1;
min = INF;
min1 = INF;
long long work, work1, work2, work3, work4;
work = 0;
work1 = 0;
work2 = 0;
work3 = 0;
work4 = 0;
std::cin >> A >> B >> C >> D;
// std::cin >> N >> M;
// std::cin >> N >> M >> K;
// std::vector<long long> v(N);
// std::vector<long long> w(N);
// std::cin >> s;
// 配列入力1
/*
for(long long i=0; i<N; i++){
std::cin >> v[i];
}
*/
// 配列入力2
/*
for(long long i=0; i<N; i++){
std::cin >> w[i];
}
*/
long long sum4, sum5;
//通常
long long ans1;
sum = (A - 1) / C;
sum1 = (A - 1) / D;
sum2 = B / C;
sum3 = B / D;
work = __gcd(C, D);
// printf("%d\n",C*D/work);
sum4 = A / (C * D / work);
sum5 = B / (C * D / work);
ans = sum2 + sum3 - sum - sum1 - (sum5 - sum4);
// printf("%d\n",ans);
/*
for(long long i=A; i<=B; i++){
if(i % C==0 || i % D==0){
cnt++;
}
}
*/
//文字列入力
/*
for(long long i=0; i<s.length(); i++){
if(s[i]!='1'){
}
*/
//ソート
// std::sort(v.begin(),v.end());//昇順ソート
// std::sort(v.begin(),v.end(),std::greater<long long>());//降順ソート
// std::sort(w.begin(),w.end());//昇順ソート
// std::sort(w.begin(),w.end(),std::greater<long long>());//降順ソート
/*
//S.substr(i, 5);
//S.size();
for(long long i=0; i<N; i++){
std::cin >> v[i];
if(st.find(v[i])==st.end()){
st.insert(v[i]);
}
else{
st.erase(v[i]);
}
}
*/
/*
long long a[4];
long long value;
value=0;
a[0] = (value % 10);
value /= 10;// 1桁目を取り出す
a[1] = (value % 10);
value /= 10;// 2桁目を取り出す
a[2] = (value % 10);
value /= 10;// 3桁目を取り出す
a[3] = (value % 10);
value /= 10;// 4桁目を取り出す
work1=a[0]+10*a[1];
work2=a[2]+10*a[3];
*/
if (1) {
printf("%lld", B - A + 1 - ans);
// printf("%lld",N);
// puts("Yes");
// printf("%d",st.size());
//文字列の出力
// std::cout << s << std::endl;
// printf("%.12f\n",ret);
// cout << sum << endl;
} else {
// puts("No");
}
return 0;
}
| #include <bits/stdc++.h>
#include <string>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
typedef pair<long long, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) for (long long i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
long long n, h[100005];
ll dp[100005];
#define ALL(v) (v).begin(), (v).end()
std::set<long long> st;
//#define MAX(a,b) if(a>b)
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
/* ペア関連
//vector<pair<long long, long long> > pairs(N);
for(long long i=0; i<N; i++){
long long a, b;
cin >> a >> b;
pairs[i] = make_pair(a, b);
}
//sort(pairs.begin(), pairs.end(),greater<pair<long long,long long> >());
sort(pairs.begin(), pairs.end());
*/
// stack<long long> sta;
// queue<long long> que;
int main() {
long long A, B, C, D, E, F, G, H, I, J, L, N, M, K, O, P, Q, R, S, T, U, V, W,
X, Y, Z;
long long ans;
ans = 0;
string s;
long long sum, sum1, sum2, sum3;
sum = 0;
sum1 = 0;
long long flg, flg1, cnt, cnt1;
flg = 0;
flg1 = 0;
cnt = 0;
cnt1 = 0;
long long max;
long long max1;
max = 0;
max1 = 0;
long long min;
long long min1;
min = INF;
min1 = INF;
long long work, work1, work2, work3, work4;
work = 0;
work1 = 0;
work2 = 0;
work3 = 0;
work4 = 0;
std::cin >> A >> B >> C >> D;
// std::cin >> N >> M;
// std::cin >> N >> M >> K;
// std::vector<long long> v(N);
// std::vector<long long> w(N);
// std::cin >> s;
// 配列入力1
/*
for(long long i=0; i<N; i++){
std::cin >> v[i];
}
*/
// 配列入力2
/*
for(long long i=0; i<N; i++){
std::cin >> w[i];
}
*/
long long sum4, sum5;
//通常
long long ans1;
sum = (A - 1) / C;
sum1 = (A - 1) / D;
sum2 = B / C;
sum3 = B / D;
work = __gcd(C, D);
// printf("%d\n",C*D/work);
sum4 = (A - 1) / (C * D / work);
sum5 = B / (C * D / work);
ans = sum2 + sum3 - sum - sum1 - (sum5 - sum4);
// printf("%d\n",ans);
/*
for(long long i=A; i<=B; i++){
if(i % C==0 || i % D==0){
cnt++;
}
}
*/
//文字列入力
/*
for(long long i=0; i<s.length(); i++){
if(s[i]!='1'){
}
*/
//ソート
// std::sort(v.begin(),v.end());//昇順ソート
// std::sort(v.begin(),v.end(),std::greater<long long>());//降順ソート
// std::sort(w.begin(),w.end());//昇順ソート
// std::sort(w.begin(),w.end(),std::greater<long long>());//降順ソート
/*
//S.substr(i, 5);
//S.size();
for(long long i=0; i<N; i++){
std::cin >> v[i];
if(st.find(v[i])==st.end()){
st.insert(v[i]);
}
else{
st.erase(v[i]);
}
}
*/
/*
long long a[4];
long long value;
value=0;
a[0] = (value % 10);
value /= 10;// 1桁目を取り出す
a[1] = (value % 10);
value /= 10;// 2桁目を取り出す
a[2] = (value % 10);
value /= 10;// 3桁目を取り出す
a[3] = (value % 10);
value /= 10;// 4桁目を取り出す
work1=a[0]+10*a[1];
work2=a[2]+10*a[3];
*/
if (1) {
printf("%lld", B - A + 1 - ans);
// printf("%lld",N);
// puts("Yes");
// printf("%d",st.size());
//文字列の出力
// std::cout << s << std::endl;
// printf("%.12f\n",ret);
// cout << sum << endl;
} else {
// puts("No");
}
return 0;
}
| [] | 804,523 | 804,524 | u069521477 | cpp |
p02995 | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
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;
}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
const ll mod = 1000000007ll;
// const ll mod = 1000003;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define brep(n) for (int bit = 0; bit < (1 << n); bit++)
#define bbrep(n) for (int bbit = 0; bbit < (1 << n); bbit++)
#define erep(i, container) for (auto &i : container)
#define itrep(i, container) for (auto i : container)
#define irep(i, n) for (ll i = n - 1; i >= (ll)0ll; i--)
#define rrep(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define reprep(i, j, h, w) rep(i, h) rep(j, w)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define VEC(type, name, n) \
std::vector<type> name(n); \
rep(i, n) std::cin >> name[i];
#define pb push_back
#define pf push_front
#define query \
int qq; \
std::cin >> qq; \
rep(qqq, qq)
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a), 0ll)
#define keta fixed << setprecision
#define vout(a) \
erep(qxqxqx, a) std::cout << qxqxqx << ' '; \
std::cout << std::endl;
#define vvector(name, typ, m, n, a) \
vector<vector<typ>> name(m, vector<typ>(n, a))
//#define vvector(name,typ,m,n)vector<vector<typ> > name(m,vector<typ> (n))
#define vvvector(name, t, l, m, n, a) \
vector<vector<vector<t>>> name(l, vector<vector<t>>(m, vector<t>(n, a)));
#define vvvvector(name, t, k, l, m, n, a) \
vector<vector<vector<vector<t>>>> name( \
k, vector<vector<vector<t>>>(l, vector<vector<t>>(m, vector<t>(n, a))));
#define case std::cout << "Case #" << qqq + 1 << ": "
#define res resize
#define as assign
#define ffor for (;;)
#define ppri(a, b) std::cout << a << " " << b << std::endl
#define pppri(a, b, c) std::cout << a << " " << b << " " << c << std::endl
#define aall(x, n) (x).begin(), (x).begin() + (n)
#define ssum(a) accumulate(a, 0ll)
#define stirng string
//#define grid_input(a,type) int h,w;std::cin >>
//h>>w;vvector(a,type,h,w,0);reprep(i,j,h,w)std::cin >> a[i][j];
// typedef long long T;
ll ceil(ll a, ll b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
// const ll INF64 =3223372036854775807ll;
// const ll INF64 = 9223372036854775807ll;
const ll INF64 = 9223372036854775ll;
const ll MOD = 1000000007ll;
// const ll MOD = 1000003ll;
const ll OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n) { //累乗の余剰
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
//メモ
// tuple<hoge,huga,foo> tのget関数はget<i>(t)
// resizeはメンバ関数
//三項演算子を覚えよう
// a?b:cと書くと aならばbの処理をする
// i本目にbitをたてる -> (1<<i)
ll ggd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0) {
return a;
}
return ggd(b, a % b);
}
ll lcm(ll number1, ll number2) {
return number1 / ggd(number1, number2) * number2;
}
ll cnt(ll a, ll b, ll d) {
ll dd = b / d - a / d;
return dd;
}
int main() {
ll a, b, c, d;
std::cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ans -= cnt(a, b, c);
ans -= cnt(a, b, d);
ans += cnt(a, b, lcm(c, d));
std::cout << ans << std::endl;
} | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
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;
}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
const ll mod = 1000000007ll;
// const ll mod = 1000003;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define brep(n) for (int bit = 0; bit < (1 << n); bit++)
#define bbrep(n) for (int bbit = 0; bbit < (1 << n); bbit++)
#define erep(i, container) for (auto &i : container)
#define itrep(i, container) for (auto i : container)
#define irep(i, n) for (ll i = n - 1; i >= (ll)0ll; i--)
#define rrep(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define reprep(i, j, h, w) rep(i, h) rep(j, w)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define VEC(type, name, n) \
std::vector<type> name(n); \
rep(i, n) std::cin >> name[i];
#define pb push_back
#define pf push_front
#define query \
int qq; \
std::cin >> qq; \
rep(qqq, qq)
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a), 0ll)
#define keta fixed << setprecision
#define vout(a) \
erep(qxqxqx, a) std::cout << qxqxqx << ' '; \
std::cout << std::endl;
#define vvector(name, typ, m, n, a) \
vector<vector<typ>> name(m, vector<typ>(n, a))
//#define vvector(name,typ,m,n)vector<vector<typ> > name(m,vector<typ> (n))
#define vvvector(name, t, l, m, n, a) \
vector<vector<vector<t>>> name(l, vector<vector<t>>(m, vector<t>(n, a)));
#define vvvvector(name, t, k, l, m, n, a) \
vector<vector<vector<vector<t>>>> name( \
k, vector<vector<vector<t>>>(l, vector<vector<t>>(m, vector<t>(n, a))));
#define case std::cout << "Case #" << qqq + 1 << ": "
#define res resize
#define as assign
#define ffor for (;;)
#define ppri(a, b) std::cout << a << " " << b << std::endl
#define pppri(a, b, c) std::cout << a << " " << b << " " << c << std::endl
#define aall(x, n) (x).begin(), (x).begin() + (n)
#define ssum(a) accumulate(a, 0ll)
#define stirng string
//#define grid_input(a,type) int h,w;std::cin >>
//h>>w;vvector(a,type,h,w,0);reprep(i,j,h,w)std::cin >> a[i][j];
// typedef long long T;
ll ceil(ll a, ll b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
// const ll INF64 =3223372036854775807ll;
// const ll INF64 = 9223372036854775807ll;
const ll INF64 = 9223372036854775ll;
const ll MOD = 1000000007ll;
// const ll MOD = 1000003ll;
const ll OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n) { //累乗の余剰
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
//メモ
// tuple<hoge,huga,foo> tのget関数はget<i>(t)
// resizeはメンバ関数
//三項演算子を覚えよう
// a?b:cと書くと aならばbの処理をする
// i本目にbitをたてる -> (1<<i)
ll ggd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0) {
return a;
}
return ggd(b, a % b);
}
ll lcm(ll number1, ll number2) {
return number1 / ggd(number1, number2) * number2;
}
ll cnt(ll a, ll b, ll d) {
ll dd = b / d - (a - 1) / d;
return dd;
}
int main() {
ll a, b, c, d;
std::cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ans -= cnt(a, b, c);
ans -= cnt(a, b, d);
ans += cnt(a, b, lcm(c, d));
std::cout << ans << std::endl;
} | [] | 804,525 | 804,526 | u539011156 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
if (a < b)
return gcd(b, a);
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll f(ll x, int c, int d) {
ll res = x;
res -= x / c;
res -= x / d;
res += x / lcm(c, d);
return res;
}
int main() {
ll a, b;
int c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
if (a < b)
return gcd(b, a);
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll f(ll x, ll c, ll d) {
ll res = x;
res -= x / c;
res -= x / d;
res += x / lcm(c, d);
return res;
}
int main() {
ll a, b;
ll c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 804,531 | 804,532 | u161892443 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { \
cout << i << " "; \
} \
cout << endl; \
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
int C, D;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll F(ll x) {
ll res = x;
res -= (x / C + x / D - x / lcm(C, D));
return res;
}
int main() {
ll A, B;
cin >> A >> B >> C >> D;
ll ans = F(B) - F(A - 1);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { \
cout << i << " "; \
} \
cout << endl; \
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
ll C, D;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll F(ll x) {
ll res = x;
res -= (x / C + x / D - x / lcm(C, D));
return res;
}
int main() {
ll A, B;
cin >> A >> B >> C >> D;
ll ans = F(B) - F(A - 1);
cout << ans << '\n';
return 0;
} | [
"variable_declaration.type.change"
] | 804,535 | 804,536 | u600402037 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, j, n) for (int i = (j); i < (n); i++)
#define per(i, n, j) for (int i = (n); i >= (j); i--)
using ll = long long;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return (a % b) ? gcd(b, a % b) : b; }
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
const ll INF = 1LL << 60;
ll a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
ll cnt = b - a + 1;
;
cnt -= b / c;
cnt -= b / d;
cnt += (a - 1) / c;
cnt += (a - 1) / d;
ll num = lcm(c, d);
cnt += (b / num);
cnt += (a - 1) / num;
cout << cnt << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, j, n) for (int i = (j); i < (n); i++)
#define per(i, n, j) for (int i = (n); i >= (j); i--)
using ll = long long;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return (a % b) ? gcd(b, a % b) : b; }
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
const ll INF = 1LL << 60;
ll a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
ll cnt = b - a + 1;
;
cnt -= b / c;
cnt -= b / d;
cnt += (a - 1) / c;
cnt += (a - 1) / d;
ll num = lcm(c, d);
cnt += (b / num);
cnt -= (a - 1) / num;
cout << cnt << "\n";
return 0;
}
| [
"expression.operator.change"
] | 804,547 | 804,548 | u437739548 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll c, ll d) {
if (d == 0) {
return c;
}
gcd(d, c % d);
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll c1 = (a + c - 1) / c;
ll c2 = b / c;
ll d1 = (a + c - 1) / d;
ll d2 = b / d;
ll Gcd = gcd(min(c, d), max(c, d));
ll lcm = c / Gcd * d;
ll l1 = (a + lcm - 1) / lcm;
ll l2 = b / lcm;
cout << b - a - (c2 - c1 + 1 + d2 - d1 + 1 - (l2 - l1 + 1)) + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll c, ll d) {
if (d == 0) {
return c;
}
gcd(d, c % d);
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll c1 = (a + c - 1) / c;
ll c2 = b / c;
ll d1 = (a + d - 1) / d;
ll d2 = b / d;
ll Gcd = gcd(min(c, d), max(c, d));
ll lcm = c / Gcd * d;
ll l1 = (a + lcm - 1) / lcm;
ll l2 = b / lcm;
cout << b - a - (c2 - c1 + 1 + d2 - d1 + 1 - (l2 - l1 + 1)) + 1 << endl;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 804,549 | 804,550 | u166378830 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
ll GCD(ll c, ll d) {
if (c < d)
swap(c, d);
if (c % d == 0)
return c;
else {
return GCD(c % d, d);
}
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll g = GCD(c, d);
ll l = c * d / g;
a--;
ll a_ = a / c + a / d - a / l;
ll b_ = b / c + b / d - b / l;
ll ans = (b - b_) - (a - a_);
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
ll GCD(ll c, ll d) {
if (c < d)
swap(c, d);
if (c % d == 0)
return d;
else {
return GCD(c % d, d);
}
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll g = GCD(c, d);
ll l = c * d / g;
a--;
ll a_ = a / c + a / d - a / l;
ll b_ = b / c + b / d - b / l;
ll ans = (b - b_) - (a - a_);
cout << ans;
}
| [
"identifier.change",
"function.return_value.change"
] | 804,563 | 804,564 | u007463213 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll e = __gcd(c, d);
ll ans = b - (b / c) - (b / d) + (b / e) - a + (a / c) + (a / d) - (a / e);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll e = c * d / __gcd(c, d);
ll ans = b - (b / c) - (b / d) + (b / e) - a + (a / c) + (a / d) - (a / e);
cout << ans << endl;
} | [
"assignment.change"
] | 804,573 | 804,574 | u582684800 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using str = string;
using ll = long long;
#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 FOR(i, f, t) for (int i = int(f); i <= int(t); i++)
#define RFOR(i, f, t) for (int i = int(f); i >= int(t); i--)
#define ALL(vec) (vec).begin(), (vec).end()
#define ASORT(vec) sort(ALL(vec))
#define DSORT(vec) sort(ALL(vec), greater<int>());
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define INF 1000000000000
#define NOD 1000000007
#define PI 3.141592653589793238462643
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); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
cout << b - b / c - b / d + b / lcm(c, d) - (a - 1) + (a - 1) / c +
(a - 1) / d + (a - 1) / lcm(c, d)
<< endl;
}
| #include <bits/stdc++.h>
using namespace std;
using str = string;
using ll = long long;
#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 FOR(i, f, t) for (int i = int(f); i <= int(t); i++)
#define RFOR(i, f, t) for (int i = int(f); i >= int(t); i--)
#define ALL(vec) (vec).begin(), (vec).end()
#define ASORT(vec) sort(ALL(vec))
#define DSORT(vec) sort(ALL(vec), greater<int>());
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define INF 1000000000000
#define NOD 1000000007
#define PI 3.141592653589793238462643
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); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
cout << b - b / c - b / d + b / lcm(c, d) - (a - 1) + (a - 1) / c +
(a - 1) / d - (a - 1) / lcm(c, d)
<< endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 804,605 | 804,606 | u644495446 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using str = string;
using ll = long long;
#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 FOR(i, f, t) for (int i = int(f); i <= int(t); i++)
#define RFOR(i, f, t) for (int i = int(f); i >= int(t); i--)
#define ALL(vec) (vec).begin(), (vec).end()
#define ASORT(vec) sort(ALL(vec))
#define DSORT(vec) sort(ALL(vec), greater<int>());
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define INF 1000000000000
#define NOD 1000000007
#define PI 3.141592653589793238462643
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); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
cout << b - b / c - b / d + b / (lcm(c, d)) - (a - 1) + (a - 1) / c +
(a - 1) / d + (a - 1) / (lcm(c, d))
<< endl;
}
| #include <bits/stdc++.h>
using namespace std;
using str = string;
using ll = long long;
#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 FOR(i, f, t) for (int i = int(f); i <= int(t); i++)
#define RFOR(i, f, t) for (int i = int(f); i >= int(t); i--)
#define ALL(vec) (vec).begin(), (vec).end()
#define ASORT(vec) sort(ALL(vec))
#define DSORT(vec) sort(ALL(vec), greater<int>());
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define INF 1000000000000
#define NOD 1000000007
#define PI 3.141592653589793238462643
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); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
cout << b - b / c - b / d + b / lcm(c, d) - (a - 1) + (a - 1) / c +
(a - 1) / d - (a - 1) / lcm(c, d)
<< endl;
}
| [
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 804,607 | 804,606 | u644495446 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
typedef long long ll;
#define _GLIBCXX_DEBUG
typedef vector<int> vec;
typedef vector<ll> lvec;
typedef vector<char> cvec;
typedef vector<double> dvec;
typedef pair<ll, ll> LP;
typedef tuple<ll, ll, ll> LT;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
#define fs first
#define sc second
ll gcm(ll c, ll d) {
if (d == 0)
return c;
else
return gcm(d, c % d);
}
ll lcm(ll c, ll d) { return c * d / gcm(c, d); }
ll f(ll x, ll c, ll d) {
ll ans = x;
ans -= x / c;
ans -= x / d;
ans += x / lcm(c, d);
cout << ans << endl;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
typedef long long ll;
#define _GLIBCXX_DEBUG
typedef vector<int> vec;
typedef vector<ll> lvec;
typedef vector<char> cvec;
typedef vector<double> dvec;
typedef pair<ll, ll> LP;
typedef tuple<ll, ll, ll> LT;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
#define fs first
#define sc second
ll gcm(ll c, ll d) {
if (d == 0)
return c;
else
return gcm(d, c % d);
}
ll lcm(ll c, ll d) { return c * d / gcm(c, d); }
ll f(ll x, ll c, ll d) {
ll ans = x;
ans -= x / c;
ans -= x / d;
ans += x / lcm(c, d);
return ans;
}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = f(b, c, d) - f(a - 1, c, d);
cout << ans << endl;
} | [
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 804,643 | 804,644 | u981759938 | cpp |
p02995 | #define _GLIBCXX_DEBUG
#include "bits/stdc++.h"
using namespace std;
// loops
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define OneToN(i, n) for (ll i = 1; i < (ll)(n + 1); i++)
#define ZeroToN(i, n) for (ll i = 0; i < (ll)(n + 1); i++)
#define AToB(i, a, b) for (ll i = a; i < (ll)(b + 1); i++)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
// bitsearch
#define BITSEARCH(bit, n) for (int bit = 0; bit < (1 << n); ++bit)
#define isOne(bit, i) bit &(1 << i)
// arrays
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define add push_back
template <typename T>
std::vector<T> slice(std::vector<T> const &v, int m, int n) {
auto first = v.cbegin() + m;
auto last = v.cbegin() + n + 1;
std::vector<T> vec(first, last);
return vec;
}
// v need to be sorted
#define remove_unique(v) v.erase(unique(ALL(v)), v.end())
// comparision
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// pair
#define fir first
#define sec second
#define mp make_pair
// types
#define ll long long
#define vec vector
#define cord2d pair<int, int>
#define intP pair<int, int>
// UNCOMMENT WHEN NEEDED
//#define int ll
// input
template <class T> T get() {
T s;
cin >> s;
return (s);
}
#define gi get<int>()
#define gs get<string>()
#define gll get<ll>()
template <class T> vector<T> getv(int n) {
vec<T> v(n);
REP(i, n) cin >> v[i];
return v;
}
#define gim(n) getv<int>(n)
#define gsm(n) getv<string>(n)
#define gllm(n) getv<ll>(n)
// output
void print(int a) { cout << a << endl; }
void print(long long a) { cout << a << endl; }
void print(string a) { cout << a; }
void print(char a) { cout << a << endl; }
void print(double a) { cout << a << endl; }
void print(double a, int dig) { cout << std::setprecision(dig) << a << endl; }
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
template <class T = int> void print(vec<T> v) { cout << v << endl; }
template <class T = int> void print2dVec(vec<vec<T>> v2d) {
for (vec<T> v : v2d) {
print(v);
}
}
void YesNo1(bool i = true) { return print(i ? "Yes" : "No"); }
void YESNO2(bool i = true) { return print(i ? "YES" : "NO"); }
// debug output
#define var_name(var) #var
template <class T> void debug(T &var, int nest = 0, string before = "") {
cout << string(" ", nest) << before;
print(var);
}
// name replacement
#define y0 y0__
#define y1 y1__
#define j0 j0__
#define j1 j1__
// bool lambdas
#define lamb(exp) [](auto i) { return exp; }
#define isEven [](int i) { return i % 2 == 0; }
#define isOdd [](int i) { return i % 2 != 0; }
// constants
const ll INF = 1e18;
const int MOD = 1000000007;
// maths
int factorial(int k) {
int sum = 1;
for (int i = 1; i <= k; ++i) {
sum *= i;
}
return sum;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
////////////////////
void Main() {
// code here
ll a = gll, b = gll, c = gll, d = gll;
ll a_div = a - (a / c) - (a / d) + (a / (c / gcd(c, d) * d));
ll b_div = b - (b / c) - (b / d) + (b / (c / gcd(c, d) * d));
print(b_div - a_div + 1);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
Main();
} | #define _GLIBCXX_DEBUG
#include "bits/stdc++.h"
using namespace std;
// loops
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define OneToN(i, n) for (ll i = 1; i < (ll)(n + 1); i++)
#define ZeroToN(i, n) for (ll i = 0; i < (ll)(n + 1); i++)
#define AToB(i, a, b) for (ll i = a; i < (ll)(b + 1); i++)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
// bitsearch
#define BITSEARCH(bit, n) for (int bit = 0; bit < (1 << n); ++bit)
#define isOne(bit, i) bit &(1 << i)
// arrays
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define add push_back
template <typename T>
std::vector<T> slice(std::vector<T> const &v, int m, int n) {
auto first = v.cbegin() + m;
auto last = v.cbegin() + n + 1;
std::vector<T> vec(first, last);
return vec;
}
// v need to be sorted
#define remove_unique(v) v.erase(unique(ALL(v)), v.end())
// comparision
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// pair
#define fir first
#define sec second
#define mp make_pair
// types
#define ll long long
#define vec vector
#define cord2d pair<int, int>
#define intP pair<int, int>
// UNCOMMENT WHEN NEEDED
//#define int ll
// input
template <class T> T get() {
T s;
cin >> s;
return (s);
}
#define gi get<int>()
#define gs get<string>()
#define gll get<ll>()
template <class T> vector<T> getv(int n) {
vec<T> v(n);
REP(i, n) cin >> v[i];
return v;
}
#define gim(n) getv<int>(n)
#define gsm(n) getv<string>(n)
#define gllm(n) getv<ll>(n)
// output
void print(int a) { cout << a << endl; }
void print(long long a) { cout << a << endl; }
void print(string a) { cout << a; }
void print(char a) { cout << a << endl; }
void print(double a) { cout << a << endl; }
void print(double a, int dig) { cout << std::setprecision(dig) << a << endl; }
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
template <class T = int> void print(vec<T> v) { cout << v << endl; }
template <class T = int> void print2dVec(vec<vec<T>> v2d) {
for (vec<T> v : v2d) {
print(v);
}
}
void YesNo1(bool i = true) { return print(i ? "Yes" : "No"); }
void YESNO2(bool i = true) { return print(i ? "YES" : "NO"); }
// debug output
#define var_name(var) #var
template <class T> void debug(T &var, int nest = 0, string before = "") {
cout << string(" ", nest) << before;
print(var);
}
// name replacement
#define y0 y0__
#define y1 y1__
#define j0 j0__
#define j1 j1__
// bool lambdas
#define lamb(exp) [](auto i) { return exp; }
#define isEven [](int i) { return i % 2 == 0; }
#define isOdd [](int i) { return i % 2 != 0; }
// constants
const ll INF = 1e18;
const int MOD = 1000000007;
// maths
int factorial(int k) {
int sum = 1;
for (int i = 1; i <= k; ++i) {
sum *= i;
}
return sum;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
////////////////////
void Main() {
// code here
ll a = gll, b = gll, c = gll, d = gll;
a--;
ll a_div = a - (a / c) - (a / d) + (a / (c / gcd(c, d) * d));
ll b_div = b - (b / c) - (b / d) + (b / (c / gcd(c, d) * d));
print(b_div - a_div);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
Main();
} | [
"expression.unary.arithmetic.add",
"expression.operation.binary.remove"
] | 804,661 | 804,662 | u105001881 | cpp |
p02995 |
// C
#include <bits/stdc++.h>
using namespace std;
long long A, B, C, D;
// nで割り切れるものの個数
int div(long long n) {
long long ans;
ans = B / n - (A - 1) / n;
return ans;
}
int LCM(long long a, long long b) {
long long tmp, r;
long long x = a * b;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return x / b;
}
int main() {
cin >> A >> B >> C >> D;
long long ans, l;
l = LCM(C, D);
// cout << l << endl;
ans = (B - A + 1) - div(C) - div(D) + div(l);
cout << ans << endl;
}
|
// C
#include <bits/stdc++.h>
using namespace std;
long long A, B, C, D;
// nで割り切れるものの個数
long long div(long long n) {
long long ans;
ans = B / n - (A - 1) / n;
return ans;
}
long long LCM(long long a, long long b) {
long long tmp, r;
long long x = a * b;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return x / b;
}
int main() {
cin >> A >> B >> C >> D;
long long ans, l;
l = LCM(C, D);
// cout << l << endl;
ans = (B - A + 1) - div(C) - div(D) + div(l);
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,663 | 804,664 | u583701239 | cpp |
p02995 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long int gcd(long long int c, long long int d) {
if (max(c, d) % min(c, d) == 0)
return min(c, d);
return gcd(min(c, d), max(c, d) % min(c, d));
}
long long int LCM(long long int c, long long int d) {
return c * d / gcd(c, d);
}
long long int devide(long long int a, long long int s) {
if (a % s == 0)
return a / s;
else
return a / s + 1;
}
int solv(long long int a, long long int b, long long int c, long long int d) {
long long int min_c, min_d, max_c, max_d, min_lcm, max_lcm, lcm;
lcm = LCM(c, d);
min_c = devide(a, c);
max_c = b / c;
min_d = devide(a, d);
max_d = b / d;
min_lcm = devide(a, lcm);
max_lcm = b / lcm;
// std::cout << "min_c" << min_c << '\n';
// std::cout << "max_c" << max_c << '\n';
// std::cout << "min_d" << min_d << '\n';
// std::cout << "max_d" << max_d << '\n';
// std::cout << "lcm" << lcm << '\n';
// std::cout << "min_lcm" << min_lcm << '\n';
// std::cout << "max_lcm" << max_lcm << '\n';
return max_c + max_d - max_lcm - min_c - min_d + min_lcm + 1;
}
int main(int argc, char const *argv[]) {
long long int a, b, c, d;
std::cin >> a >> b >> c >> d;
std::cout << b - a - solv(a, b, c, d) + 1 << '\n';
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long int gcd(long long int c, long long int d) {
if (max(c, d) % min(c, d) == 0)
return min(c, d);
return gcd(min(c, d), max(c, d) % min(c, d));
}
long long int LCM(long long int c, long long int d) {
return c * d / gcd(c, d);
}
long long int devide(long long int a, long long int s) {
if (a % s == 0)
return a / s;
else
return a / s + 1;
}
long long int solv(long long int a, long long int b, long long int c,
long long int d) {
long long int min_c, min_d, max_c, max_d, min_lcm, max_lcm, lcm;
lcm = LCM(c, d);
min_c = devide(a, c);
max_c = b / c;
min_d = devide(a, d);
max_d = b / d;
min_lcm = devide(a, lcm);
max_lcm = b / lcm;
return max_c + max_d - max_lcm - min_c - min_d + min_lcm + 1;
}
int main(int argc, char const *argv[]) {
long long int a, b, c, d;
std::cin >> a >> b >> c >> d;
std::cout << b - a - solv(a, b, c, d) + 1 << '\n';
return 0;
}
// std::cout << "min_c" << min_c << '\n';
// std::cout << "max_c" << max_c << '\n';
// std::cout << "min_d" << min_d << '\n';
// std::cout << "max_d" << max_d << '\n';
// std::cout << "lcm" << lcm << '\n';
// std::cout << "min_lcm" << min_lcm << '\n';
// std::cout << "max_lcm" << max_lcm << '\n';
| [
"variable_declaration.type.widen.change"
] | 804,680 | 804,681 | u053035261 | cpp |
p02995 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long int gcd(long long int c, long long int d) {
if (max(c, d) % min(c, d) == 0)
return min(c, d);
return gcd(min(c, d), max(c, d) % min(c, d));
}
long long int LCM(long long int c, long long int d) {
return c * d / gcd(c, d);
}
long long int devide(long long int a, long long int s) {
if (a % s == 0)
return a / s;
else
return a / s + 1;
}
int solv(long long int a, long long int b, long long int c, long long int d) {
long long int min_c, min_d, max_c, max_d, min_lcm, max_lcm, lcm;
lcm = LCM(c, d);
min_c = devide(a, c);
max_c = b / c;
min_d = devide(a, d);
max_d = b / d;
min_lcm = devide(a, lcm);
max_lcm = b / lcm;
// std::cout << "min_c" << min_c << '\n';
// std::cout << "max_c" << max_c << '\n';
// std::cout << "min_d" << min_d << '\n';
// std::cout << "max_d" << max_d << '\n';
// std::cout << "lcm" << lcm << '\n';
// std::cout << "min_lcm" << min_lcm << '\n';
// std::cout << "max_lcm" << max_lcm << '\n';
return max_c + max_d - max_lcm - min_c - min_d + min_lcm + 1;
}
int main(int argc, char const *argv[]) {
long long a, b, c, d;
std::cin >> a >> b >> c >> d;
std::cout << b - a - solv(a, b, c, d) + 1 << '\n';
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long int gcd(long long int c, long long int d) {
if (max(c, d) % min(c, d) == 0)
return min(c, d);
return gcd(min(c, d), max(c, d) % min(c, d));
}
long long int LCM(long long int c, long long int d) {
return c * d / gcd(c, d);
}
long long int devide(long long int a, long long int s) {
if (a % s == 0)
return a / s;
else
return a / s + 1;
}
long long int solv(long long int a, long long int b, long long int c,
long long int d) {
long long int min_c, min_d, max_c, max_d, min_lcm, max_lcm, lcm;
lcm = LCM(c, d);
min_c = devide(a, c);
max_c = b / c;
min_d = devide(a, d);
max_d = b / d;
min_lcm = devide(a, lcm);
max_lcm = b / lcm;
return max_c + max_d - max_lcm - min_c - min_d + min_lcm + 1;
}
int main(int argc, char const *argv[]) {
long long int a, b, c, d;
std::cin >> a >> b >> c >> d;
std::cout << b - a - solv(a, b, c, d) + 1 << '\n';
return 0;
}
// std::cout << "min_c" << min_c << '\n';
// std::cout << "max_c" << max_c << '\n';
// std::cout << "min_d" << min_d << '\n';
// std::cout << "max_d" << max_d << '\n';
// std::cout << "lcm" << lcm << '\n';
// std::cout << "min_lcm" << min_lcm << '\n';
// std::cout << "max_lcm" << max_lcm << '\n';
| [
"variable_declaration.type.widen.change"
] | 804,682 | 804,681 | u053035261 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<typename T> using gpp_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; template<typename T, typename L> using
gpp_map = tree<T, L, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T> using gpp_multiset = tree<T, null_type, less_equal<T>,
rb_tree_tag, tree_order_statistics_node_update>;*/
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#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))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
{ \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl; \
}
#define mdebug(m) \
{ \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
} \
}
#define Return(ans) \
{ \
cout << (ans) << endl; \
return 0; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void Ans(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
// const int mod = 998244353;
//#define Add(x, y) x = (x + (y)) % mod
//#define Mult(x, y) x = (x * (y)) % mod
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
signed main() {
int A, B, C, D;
cin >> A >> B >> C >> D;
A--;
int ans = B - B / C / -B / D + B / (C * D / GCD(C, D));
ans -= A - A / C / -A / D + A / (C * D / GCD(C, D));
Out(ans);
}
| #include <bits/stdc++.h>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<typename T> using gpp_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; template<typename T, typename L> using
gpp_map = tree<T, L, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T> using gpp_multiset = tree<T, null_type, less_equal<T>,
rb_tree_tag, tree_order_statistics_node_update>;*/
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#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))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
{ \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl; \
}
#define mdebug(m) \
{ \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
} \
}
#define Return(ans) \
{ \
cout << (ans) << endl; \
return 0; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void Ans(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
// const int mod = 998244353;
//#define Add(x, y) x = (x + (y)) % mod
//#define Mult(x, y) x = (x * (y)) % mod
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
signed main() {
int A, B, C, D;
cin >> A >> B >> C >> D;
A--;
int ans = B - B / C - B / D + B / (C * D / GCD(C, D));
ans -= A - A / C - A / D + A / (C * D / GCD(C, D));
Out(ans);
}
| [] | 804,699 | 804,700 | u088608223 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, c, d, total = 0;
cin >> a >> b >> c >> d;
long a1 = (a - 1) / c, a2 = (a - 1) / d;
long b1 = b / c, b2 = b / d;
long r, cr = c, dr = d;
if (cr < dr) {
swap(cr, dr);
}
r = cr % dr;
while (r > 0) {
cr = dr;
dr = r; //最大公約数
r = cr % dr;
}
r = c * d / dr; //最小公倍数
total = -a1 + b1 - a2 + b2 - b / r - (a - 1) / r;
cout << b - (a - 1) - total << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, c, d, total = 0;
cin >> a >> b >> c >> d;
long a1 = (a - 1) / c, a2 = (a - 1) / d;
long b1 = b / c, b2 = b / d;
long r, cr = c, dr = d;
if (cr < dr) {
swap(cr, dr);
}
r = cr % dr;
while (r > 0) {
cr = dr;
dr = r; //最大公約数
r = cr % dr;
}
r = c * d / dr; //最小公倍数
total = -a1 + b1 - a2 + b2 - (b / r - (a - 1) / r);
cout << b - (a - 1) - total << endl;
}
| [] | 804,701 | 804,702 | u475471747 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, e) for (int i = s; i < e; ++i)
#define sort_(a) stable_sort(a.begin(), a.end())
#define rsort(a) stable_sort(a.rbegin(), a.rend())
#define sum(a) accumulate(a.begin(), a.end(), 0LL)
#define join(a, d) \
accumulate(a.begin() + 1, a.end(), a[0], \
[](string s, string t) { return s + d + t; })
#define all(a) a.begin(), a.end()
typedef long long ll;
const long mod = 1e9 + 7;
int lcm(ll x, ll y) { return x / __gcd(x, y) * y; }
int main(void) {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll a, b, l;
l = lcm(C, D);
a = (A - 1) / C;
a += (A - 1) / D;
a -= (A - 1) / l;
b = B / C;
b += B / D;
b -= B / l;
ll ans;
ans = B - (A - 1) - (b - a);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, e) for (int i = s; i < e; ++i)
#define sort_(a) stable_sort(a.begin(), a.end())
#define rsort(a) stable_sort(a.rbegin(), a.rend())
#define sum(a) accumulate(a.begin(), a.end(), 0LL)
#define join(a, d) \
accumulate(a.begin() + 1, a.end(), a[0], \
[](string s, string t) { return s + d + t; })
#define all(a) a.begin(), a.end()
typedef long long ll;
const long mod = 1e9 + 7;
ll lcm(ll x, ll y) { return x / __gcd(x, y) * y; }
int main(void) {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll a, b, l;
l = lcm(C, D);
a = (A - 1) / C;
a += (A - 1) / D;
a -= (A - 1) / l;
b = B / C;
b += B / D;
b -= B / l;
ll ans;
ans = B - (A - 1) - (b - a);
cout << ans << endl;
return 0;
}
| [] | 804,707 | 804,708 | u125205981 | cpp |
p02995 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <climits>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip> //setprecision
#include <iostream>
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
long long gcd(long long int a, long long int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
long long lcm(long long int a, long long int b) { return a * b / gcd(a, b); }
int main() {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int e = b - a + 1;
long long int f =
e - (b / c - a / c) - (b / d - a / d) + (b / lcm(c, d) - a / lcm(c, d));
if (a % c == 0 || a % d == 0)
f--;
cout << e - f;
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <climits>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip> //setprecision
#include <iostream>
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
long long gcd(long long int a, long long int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
long long lcm(long long int a, long long int b) { return a * b / gcd(a, b); }
int main() {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int e = b - a + 1;
long long int f =
e - (b / c - a / c) - (b / d - a / d) + (b / lcm(c, d) - a / lcm(c, d));
if (a % c == 0 || a % d == 0)
f--;
cout << f;
}
| [
"expression.operation.binary.remove"
] | 804,709 | 804,710 | u683078179 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gd(ll x, ll y) {
if (x <= y)
return gd(y, x);
if (x % y == 0)
return y;
else
return gd(min(x, y), max(x, y) % min(x, y));
}
ll lm(ll x, ll y) { return (x * y) / gd(x, y); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
cout << b - a + 1 - (b / c - (a - 1) / c) - (b / d - (a - 1) / d) +
(b / lm(c, d) - (a - 1) / lm(c, d))
<< endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gd(ll x, ll y) {
if (x < y)
return gd(y, x);
if (x % y == 0)
return y;
else
return gd(min(x, y), max(x, y) % min(x, y));
}
ll lm(ll x, ll y) { return (x * y) / gd(x, y); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
cout << b - a + 1 - (b / c - (a - 1) / c) - (b / d - (a - 1) / d) +
(b / lm(c, d) - (a - 1) / lm(c, d))
<< endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 804,717 | 804,718 | u573433204 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (int)n; i++)
using namespace std;
typedef long long ll;
ll findGCD(ll c, ll d) {
if (d == 0)
return c;
return findGCD(d, c % d);
}
ll findLCM(ll c, ll d) { return c * d / findGCD(c, d); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
// cでもdでも割り切れないもの
// c,dで割り切れるもの以外 - c,dの最小公約数
ll lcm = findLCM(c, d);
a--;
ll cc = b / c - a / c;
ll dd = b / d - a / d;
ll lcmlcm = b / lcm + a / lcm;
ll ans = b - a - cc - dd + lcmlcm;
cout << ans;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (int)n; i++)
using namespace std;
typedef long long ll;
ll findGCD(ll c, ll d) {
if (d == 0)
return c;
return findGCD(d, c % d);
}
ll findLCM(ll c, ll d) { return c * d / findGCD(c, d); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
// cでもdでも割り切れないもの
// c,dで割り切れるもの以外 - c,dの最小公約数
ll lcm = findLCM(c, d);
a--;
ll cc = b / c - a / c;
ll dd = b / d - a / d;
ll lcmlcm = b / lcm - a / lcm;
ll ans = b - a - cc - dd + lcmlcm;
cout << ans;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 804,727 | 804,728 | u862412671 | cpp |
p02995 | #include <iostream>
//#include <iomanip>
//#include <string>
//#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
// using vll = vector<ll> ;
// using vvll = vector<vll> ;
// using vc = vector<char> ;
// using vvc = vector<vc> ;
// using vb = vector<bool> ;
// using vvb = vector<vb> ;
// using pll = pair<ll,ll> ;
//#define all(v) v.begin(),v.end()
// ll mod = 1000000007 ;
// long double pie = acos(-1) ;
// ll INF = 1000000000000 ;
// void yorn(bool a){if(a) cout << "Yes" << endl ; else cout << "No" << endl ;}
// void YorN(bool a){if(a) cout << "YES" << endl ; else cout << "NO" << endl ;}
ll gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(long long a, long long b) { return a / gcd(a, b) * b; }
// ll sa(long long a,long long b){if(a>b) return a-b ; return b-a ;}
// void fix_cout(){cout << fixed << setprecision(20) ;}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll ans = b - a;
ans -= b / c - a / c;
ans -= b / d - a / d;
ll e = lcm(c, d);
ans += b / e + c / e;
cout << ans << endl;
}
| #include <iostream>
//#include <iomanip>
//#include <string>
//#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
// using vll = vector<ll> ;
// using vvll = vector<vll> ;
// using vc = vector<char> ;
// using vvc = vector<vc> ;
// using vb = vector<bool> ;
// using vvb = vector<vb> ;
// using pll = pair<ll,ll> ;
//#define all(v) v.begin(),v.end()
// ll mod = 1000000007 ;
// long double pie = acos(-1) ;
// ll INF = 1000000000000 ;
// void yorn(bool a){if(a) cout << "Yes" << endl ; else cout << "No" << endl ;}
// void YorN(bool a){if(a) cout << "YES" << endl ; else cout << "NO" << endl ;}
ll gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(long long a, long long b) { return a / gcd(a, b) * b; }
// ll sa(long long a,long long b){if(a>b) return a-b ; return b-a ;}
// void fix_cout(){cout << fixed << setprecision(20) ;}
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
a--;
ll ans = b - a;
ans -= b / c - a / c;
ans -= b / d - a / d;
ll e = lcm(c, d);
ans += b / e - a / e;
cout << ans << endl;
}
| [] | 804,735 | 804,736 | u993074316 | cpp |
p02995 | #include <iostream>
using namespace std;
long long gcd(long long a, long long b) {
long long temp;
while (a % b != 0) {
temp = b;
b = a % b;
a = temp;
}
return b;
}
int main() {
long long A, B, C, D;
cin >> A >> B >> C >> D;
int count = 0;
count += (B / C) - ((A - 1) / C);
count += (B / D) - ((A - 1) / D);
long long g = C * D / gcd(C, D);
count -= (B / g) - ((A - 1) / g);
cout << (B - A + 1) - count << endl;
return 0;
} | #include <iostream>
using namespace std;
long long gcd(long long a, long long b) {
long long temp;
while (a % b != 0) {
temp = b;
b = a % b;
a = temp;
}
return b;
}
int main() {
long long A, B, C, D;
cin >> A >> B >> C >> D;
long long count = 0;
count += (B / C) - ((A - 1) / C);
count += (B / D) - ((A - 1) / D);
long long g = C * D / gcd(C, D);
count -= (B / g) - ((A - 1) / g);
cout << (B - A + 1 - count) << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,737 | 804,738 | u041513069 | cpp |
p02995 | #include <iostream>
using namespace std;
long long gcd(long long a, long long b) {
long long temp;
while (a % b != 0) {
temp = b;
b = a % b;
a = temp;
}
return b;
}
int main() {
long long A, B, C, D;
cin >> A >> B >> C >> D;
int count = 0;
count += (B / C) - ((A - 1) / C);
count += (B / D) - ((A - 1) / D);
long long g = max(C, D) / gcd(max(C, D), min(C, D)) * min(C, D);
count -= (B / g) - ((A - 1) / g);
cout << (B - A + 1) - count << endl;
return 0;
} | #include <iostream>
using namespace std;
long long gcd(long long a, long long b) {
long long temp;
while (a % b != 0) {
temp = b;
b = a % b;
a = temp;
}
return b;
}
int main() {
long long A, B, C, D;
cin >> A >> B >> C >> D;
long long count = 0;
count += (B / C) - ((A - 1) / C);
count += (B / D) - ((A - 1) / D);
long long g = max(C, D) / gcd(max(C, D), min(C, D)) * min(C, D);
count -= (B / g) - ((A - 1) / g);
cout << (B - A + 1 - count) << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,739 | 804,740 | u041513069 | cpp |
p02995 | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
const double PI = acos(-1);
long gcd(long a, long b) {
if (b > a) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
while (b != 0) {
long t = b;
b = a % b;
a = t;
}
return a;
}
int main() {
long a, b, c, d;
cin >> a >> b >> c >> d;
long abc = b / c - (a - 1) / c, abd = b / d - (a - 1) / d;
long g = c / (double)gcd(c, d) * d, abg = b / g - a / g;
cout << b - a + 1 - abc - abd + abg << endl;
return 0;
} | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
const double PI = acos(-1);
long gcd(long a, long b) {
if (b > a) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
while (b != 0) {
long t = b;
b = a % b;
a = t;
}
return a;
}
int main() {
long a, b, c, d;
cin >> a >> b >> c >> d;
long abc = b / c - (a - 1) / c, abd = b / d - (a - 1) / d;
long g = c / (double)gcd(c, d) * d, abg = b / g - (a - 1) / g;
cout << b - a + 1 - abc - abd + abg << endl;
return 0;
} | [] | 804,747 | 804,748 | u470123394 | cpp |
p02995 | //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int main();
using ll = long long;
using VB = vector<bool>;
using VVB = vector<vector<bool>>;
using VC = vector<char>;
using VVC = vector<vector<char>>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VD = vector<double>;
using VVD = vector<vector<double>>;
const double PI = 3.14159265358979323846;
const int INF =
1 << 29; // INF + N 程度の余裕を残すため、INT_MAXは使用しないこと。
const ll INFLL = 1LL << 61;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REP1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REPLL(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REP1LL(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define LEN(x) ((int)(x).length())
#define ZERO(a) memset(a, 0, sizeof(a))
#define RAD(d) (PI * (d) / 180)
#define DEG(r) (180.0 * (r) / PI)
#define popcnt(x) __builtin_popcount(x)
#define popcnt64(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define get0(x) get<0>(x)
#define get1(x) get<1>(x)
#define get2(x) get<2>(x)
#define get3(x) get<3>(x)
#define get4(x) get<4>(x)
// DP用
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// ダンプ
template <class T> void dump(const vector<T> &v) {
if (SZ(v) == 0)
return;
REP(i, SZ(v) - 1) { cout << v[i] << " "; }
cout << v[SZ(v) - 1] << endl;
}
// ダンプ（2次元）
template <class T> void dump(const vector<vector<T>> &v) {
REP(j, SZ(v)) { dump(v[j]); }
}
// ダンプ（２次元）
template <class T> void dump(int w, int h, const vector<T> &v) {
REP(j, h) {
REP(i, w - 1) { cout << v[j * w + i] << " "; }
cout << v[j * w + w - 1] << endl;
}
}
// 和
template <class T> T accumulate(const vector<T> &v) {
T sum = 0;
REP(i, SZ(v)) { sum += v[i]; }
return sum;
}
// 和（範囲指定）
template <class T> T accumulate(const vector<T> &v, int start, int length) {
T sum = 0;
REP(i, length) { sum += v[start + i]; }
return sum;
}
// 平均
template <class T> T average(const vector<T> &v) {
return accumulate(v) / SZ(v);
}
// 行列構造体
template <class T> struct Matrix {
T w, h;
vector<T> A;
Matrix(T w_, T h_) : w(w_), h(h_), A(w * h) {}
T get(T x, T y) const { return A[y * w + x]; }
};
// 行列への入力
template <class T> void input(Matrix<T> &m) {
REP(j, m.h) {
REP(i, m.w) { cin >> m.A[j * m.w + i]; }
}
}
// 行列の積算
template <class T> Matrix<T> prod(const Matrix<T> &a, const Matrix<T> &b) {
Matrix<T> m(b.w, a.h);
REP(j, m.h) {
REP(i, m.w) {
ll c = 0;
REP(k, a.w) { c += a.A[j * a.w + k] * b.A[k * b.w + i]; }
m.A[j * m.w + i] = c;
}
}
return m;
}
// 行列の出力(int)
void dump(const Matrix<int> &m) {
REP(j, m.h) {
REP(i, m.w - 1) { printf("%d ", m.A[j * m.w + i]); }
printf("%d\n", m.A[j * m.w + m.w - 1]);
}
}
// 行列の出力(long long)
void dump(const Matrix<ll> &m) {
REP(j, m.h) {
REP(i, m.w - 1) { printf("%lld ", m.A[j * m.w + i]); }
printf("%lld\n", m.A[j * m.w + m.w - 1]);
}
}
// 行列の出力(double)
void dump(const Matrix<double> &m) {
REP(j, m.h) {
REP(i, m.w - 1) { printf("%f ", m.A[j * m.w + i]); }
printf("%f\n", m.A[j * m.w + m.w - 1]);
}
}
// 文字列の大文字化
string &to_upper(string &s) {
REP(i, s.length()) {
if ('a' <= s[i] && s[i] <= 'z') {
s[i] -= 32;
}
}
return s;
}
// 文字列の小文字化
string &to_lower(string &s) {
REP(i, s.length()) {
if ('A' <= s[i] && s[i] <= 'Z') {
s[i] += 32;
}
}
return s;
}
// 素数取得
VB get_prime(int n) {
VB prime_flag(n, true);
prime_flag[0] = false;
prime_flag[1] = false;
for (int i = 2; i < n; i++) {
if (!prime_flag[i])
continue;
for (int j = i * 2; j < n; j += i)
prime_flag[j] = false;
}
return prime_flag;
}
// 素数判定（エラトステネスのふるい）
template <class T> bool is_prime(T value) {
for (ll i = 2; i * i <= value; i++) {
if (value % i == 0)
return false;
}
return true;
}
// 約数の列挙
template <class T> vector<T> get_divisors(T n) {
vector<T> ret;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ALL(ret));
return ret;
}
// 約数の列挙（1 ～ sqrt(N)まで）
template <class T> vector<T> get_divisors2(T n) {
vector<T> ret;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
}
}
return ret;
}
// 最大公約数(GCD; Greatest Common Divisor) ※ユークリッドの互除法
template <class T> T gcd(T a, T b) {
if (a < b)
return gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
// ３数の最大公約数
template <class T> T gcd(T a, T b, T c) { return gcd(gcd(a, b), c); }
// ３数以上の最大公約数
template <class T> T gcd(const vector<T> v) {
if (SZ(v) == 0)
return 0;
if (SZ(v) == 1)
return v[0];
if (SZ(v) == 2)
return gcd(v[0], v[1]);
T g = v[0];
for (int i = 1; i < SZ(v); i++) {
g = gcd(g, v[i]);
}
return g;
}
// 最小公倍数(LCM; Least Common Multiple)
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// MOD計算(べき乗) : a^n % MOD
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// MOD計算(逆元) : a^(-1) MOD (※拡張ユークリッド互除法)
ll modinv(ll a, ll mod) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
// MOD計算
//
// modint 構造体を使ってみませんか？ (C++) - noshi91のメモ
// https://noshi91.hatenablog.com/entry/2019/03/31/174006
//
// 使い方:
// const int MOD = 1000000007;
// using mint = modint<MOD>;
// mint a = 1234;
//
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
// DFS 幅優先探索 (A[0] ... A[N] タイプ)
#if 0
VI AA(N);
void dfs(int index, int size, int start, int end)
{
if (index == size) {
solve(A); // ここで必要な処理を行う
}
else{
for(int i = start; i <= end; ++i){
A[index] = i;
// start <= A[i] <= end (i=0~size-1) の場合
//dfs(index + 1, size, start, end);
// start <= A[0] <= A[1] <= ... <= A[size-1] <= end の場合
dfs(index + 1, size, i, end); // start = iを指定することで、次indexの値域を狭める
}
}
}
#endif
// DFS 幅優先探索 (グラフ問題)
//
// ■ 解ける問題
// 1.グラフ上の到達可否
// 2.連結成分の数
// 3.二部グラフ判定 → 引数に現在ノードの色を追加する。color[v]が到達済みで、かつ同じ色の場合、二部グラフではない。
// 4.各頂点の深さ → (行きがけ順)
// 5.各頂点の部分木サイズ → (帰りがけ順)
// 6.サイクル検出（★勉強中）
//
#if 0
VVI G(N); // グラフ
VB seen(N, false); // 到達フラグ
VI first_order(N); // 行きがけ順
VI last_order(N); // 帰りがけ順
VI color(N, 0); // 二部グラフ判定用(0:未到達, 1:白, -1:黒)
VI depth(N); // 各頂点の深さ
VI subtree_size(N); // 各頂点の部分木サイズ
void dfs(const VVI &G, int v, int &order, int parent, int d)
{
first_order[v] = order++;
depth[v] = d;
seen[v] = true;
for(auto nv : G[v]){
if(seen[nv]) continue;
dfs(G, nv, order, v, d);
}
// 部分木サイズ
subtree_size[v] = 1;
for(auto c : G[v]){
if(c == parent) continue;
subtree_size[v] += subtree_size[c];
}
last_order[v] = order++;
}
#endif
// DAG(有向無閉路グラフ)のトポロジカルソート
//
// ■ 応用問題
// 1.依存関係の解決処理
//
VI tsort(const VVI &G) {
int N = G.size();
VI indeg(N); // 各ノードへの入力辺数
stack<int> S; // indeg(x) == 0 のノード
for (auto &v : G) {
for (auto &e : v) {
indeg[e]++;
}
}
REP(i, N) {
if (indeg[i] == 0)
S.push(i);
}
VI ans;
while (!S.empty()) {
int v = S.top();
S.pop();
ans.pb(v);
for (auto &e : G[v]) {
indeg[e]--;
if (indeg[e] == 0)
S.push(e);
}
}
return ans;
}
// グラフの辺(Edge)
typedef pair<ll, int> Edge; // first : コスト, second : 接続先ノード
// ダイクストラ法(最短経路問題。コストが負の場合使用できない)
vector<ll> dijkstra(const vector<vector<Edge>> &G, int start) {
int N = G.size();
priority_queue<Edge, vector<Edge>, greater<Edge>> que;
vector<ll> dist(N, INFLL);
que.push(mp(0LL, start));
dist[start] = 0;
while (!que.empty()) {
Edge p = que.top();
que.pop();
if (dist[p.second] < p.first)
continue;
for (auto &e : G[p.second]) {
if (dist[e.second] > dist[p.second] + e.first) {
dist[e.second] = dist[p.second] + e.first;
que.push(mp(dist[e.second], e.second));
}
}
}
return dist;
}
// Union-Find木(素集合データ構造) -
// グループ分けを木構造で管理する。任意の２要素が同じグループに所属するか判定する
struct UnionFind {
// 親ノードのインデックス
VI parent;
UnionFind(int size) {
parent.resize(size);
REP(i, size) {
parent[i] = i;
} // 初期状態は自ノードが親ノード(＝すべてのノードが独立)
}
// 木の根(root)を取得する
int root(int x) {
// 要素xが根の場合
if (parent[x] == x)
return x;
// 経路圧縮
parent[x] = root(parent[x]);
return parent[x];
}
// 同じグループかどうか判定する
bool same(int x, int y) { return root(x) == root(y); }
// ２つのグループを併合する
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y)
parent[x] = y;
}
};
// 最小全域木(Minimum Spanning Tree) (クラスカル法)
typedef tuple<int, int, int> STEdge; // get0 : コスト, get1,2 : 頂点
struct SpanningTree {
vector<STEdge> edges;
// 辺を追加する(※直接edges変数に追加してもよい。)
void add(int cost, int a, int b) { edges.push_back(mt(cost, a, b)); }
// 最小全域木を生成し、コストの和を計算する
int kuraskal(int size) {
sort(ALL(edges));
UnionFind tree(size);
int min_cost = 0;
REP(i, SZ(edges)) {
auto &e = edges[i];
if (!tree.same(get1(e), get2(e))) {
min_cost += get0(e);
tree.unite(get1(e), get2(e));
}
}
return min_cost;
}
};
// よく忘れるSTLの使い方
//
// ■ 最小値、最大値
// it = min_element(first, last);
// it = min_element(first, last);
//
// ■ 値の交換 swap(a, b) ※文字列(string)も交換可能。
//
// ■ 乱数
// srand((unsigned)time(NULL));
// rand() - 0 ~ 2^31-1 の範囲の乱数(※VSの場合2^15-1。)
//
// ■ 時間計測
// int t0 = clock();
// double ts = 1.0 * (clock() - t0) / CLOCKS_PER_SEC;
//
// ■ sort ソート（降順）
// sort(first, last, greater<T>()); // 大きい順(降順)
//
// ■ カウント O(N)、探索 O(N)、二分探索 O(logN)
// n = count(first, last, value);
// it = find(first, last, value); ※見つからない場合、it == last
// i = lower_bound(first, last, value) - first
// ★[first, last) 間は小さい順に【 ソート済み 】であること。
//
// ■ vector<T>
// v{ a, b, c } // 初期値
// v.assign(first, last) ※sizeも変わる
// v.assign(N, value) ※sizeも変わる
// find(ALL(v)) != v.end()
//
// ■ stack<T>, queue<T>
// ■ priority_queue<T, vector<T>, greater<T>> // 大きい順(降順)の場合、less<T>
// (※sortとは逆) s.push(x) s.pop() x = s.top() or x = q.front()
// ※queueの場合はfront()。 s.size() s.empty()
//
// ■ set<T>, multiset<T>
// s.insert(x)
// s.erase(x) ※multisetではすべてのx
// s.erase(it)
// s.find(x) == s.end()
// s.lower_bound(x)
//
// ■ map<K, V>
// m[K] = V; // 追加
// m.find(K) == m.end() // 探索
//
// ■ tuple
// tuple<T0, T1, T2, ...> t;
// t = mt(v0, v1, v2, ...)
// v0 = get0(t)
// get0(t) = v0
//
// ■ 順列
// do{
// }while(next_permutation(first, last));
// ★[first, last) 間は小さい順に【 ソート済み 】であること。
//
// ■ ビットセット
// bitset<8> b("10000000");
// bs.size()
// b[i] (i = 0 ~ b.size()-1)
// b.set(i) or b.reset(i)
// b.count(), b.all(), b.any(), b.none() 1の数, すべて1か, いずれか1か,
// すべて0か
//
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll nC_A = (A - 1) / C;
ll nC_B = B / C;
ll nD_A = (A - 1) / D;
ll nD_B = B / D;
ll G = gcd(C, D);
ll nG_A = (A - 1) / G;
ll nG_B = B / G;
ll n = B - (A - 1) - (nC_B - nC_A) - (nD_B - nD_A) + (nG_B - nG_A);
cout << n << endl;
return 0;
}
| //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int main();
using ll = long long;
using VB = vector<bool>;
using VVB = vector<vector<bool>>;
using VC = vector<char>;
using VVC = vector<vector<char>>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VD = vector<double>;
using VVD = vector<vector<double>>;
const double PI = 3.14159265358979323846;
const int INF =
1 << 29; // INF + N 程度の余裕を残すため、INT_MAXは使用しないこと。
const ll INFLL = 1LL << 61;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REP1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REPLL(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REP1LL(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define LEN(x) ((int)(x).length())
#define ZERO(a) memset(a, 0, sizeof(a))
#define RAD(d) (PI * (d) / 180)
#define DEG(r) (180.0 * (r) / PI)
#define popcnt(x) __builtin_popcount(x)
#define popcnt64(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define get0(x) get<0>(x)
#define get1(x) get<1>(x)
#define get2(x) get<2>(x)
#define get3(x) get<3>(x)
#define get4(x) get<4>(x)
// DP用
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// ダンプ
template <class T> void dump(const vector<T> &v) {
if (SZ(v) == 0)
return;
REP(i, SZ(v) - 1) { cout << v[i] << " "; }
cout << v[SZ(v) - 1] << endl;
}
// ダンプ（2次元）
template <class T> void dump(const vector<vector<T>> &v) {
REP(j, SZ(v)) { dump(v[j]); }
}
// ダンプ（２次元）
template <class T> void dump(int w, int h, const vector<T> &v) {
REP(j, h) {
REP(i, w - 1) { cout << v[j * w + i] << " "; }
cout << v[j * w + w - 1] << endl;
}
}
// 和
template <class T> T accumulate(const vector<T> &v) {
T sum = 0;
REP(i, SZ(v)) { sum += v[i]; }
return sum;
}
// 和（範囲指定）
template <class T> T accumulate(const vector<T> &v, int start, int length) {
T sum = 0;
REP(i, length) { sum += v[start + i]; }
return sum;
}
// 平均
template <class T> T average(const vector<T> &v) {
return accumulate(v) / SZ(v);
}
// 行列構造体
template <class T> struct Matrix {
T w, h;
vector<T> A;
Matrix(T w_, T h_) : w(w_), h(h_), A(w * h) {}
T get(T x, T y) const { return A[y * w + x]; }
};
// 行列への入力
template <class T> void input(Matrix<T> &m) {
REP(j, m.h) {
REP(i, m.w) { cin >> m.A[j * m.w + i]; }
}
}
// 行列の積算
template <class T> Matrix<T> prod(const Matrix<T> &a, const Matrix<T> &b) {
Matrix<T> m(b.w, a.h);
REP(j, m.h) {
REP(i, m.w) {
ll c = 0;
REP(k, a.w) { c += a.A[j * a.w + k] * b.A[k * b.w + i]; }
m.A[j * m.w + i] = c;
}
}
return m;
}
// 行列の出力(int)
void dump(const Matrix<int> &m) {
REP(j, m.h) {
REP(i, m.w - 1) { printf("%d ", m.A[j * m.w + i]); }
printf("%d\n", m.A[j * m.w + m.w - 1]);
}
}
// 行列の出力(long long)
void dump(const Matrix<ll> &m) {
REP(j, m.h) {
REP(i, m.w - 1) { printf("%lld ", m.A[j * m.w + i]); }
printf("%lld\n", m.A[j * m.w + m.w - 1]);
}
}
// 行列の出力(double)
void dump(const Matrix<double> &m) {
REP(j, m.h) {
REP(i, m.w - 1) { printf("%f ", m.A[j * m.w + i]); }
printf("%f\n", m.A[j * m.w + m.w - 1]);
}
}
// 文字列の大文字化
string &to_upper(string &s) {
REP(i, s.length()) {
if ('a' <= s[i] && s[i] <= 'z') {
s[i] -= 32;
}
}
return s;
}
// 文字列の小文字化
string &to_lower(string &s) {
REP(i, s.length()) {
if ('A' <= s[i] && s[i] <= 'Z') {
s[i] += 32;
}
}
return s;
}
// 素数取得
VB get_prime(int n) {
VB prime_flag(n, true);
prime_flag[0] = false;
prime_flag[1] = false;
for (int i = 2; i < n; i++) {
if (!prime_flag[i])
continue;
for (int j = i * 2; j < n; j += i)
prime_flag[j] = false;
}
return prime_flag;
}
// 素数判定（エラトステネスのふるい）
template <class T> bool is_prime(T value) {
for (ll i = 2; i * i <= value; i++) {
if (value % i == 0)
return false;
}
return true;
}
// 約数の列挙
template <class T> vector<T> get_divisors(T n) {
vector<T> ret;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ALL(ret));
return ret;
}
// 約数の列挙（1 ～ sqrt(N)まで）
template <class T> vector<T> get_divisors2(T n) {
vector<T> ret;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
}
}
return ret;
}
// 最大公約数(GCD; Greatest Common Divisor) ※ユークリッドの互除法
template <class T> T gcd(T a, T b) {
if (a < b)
return gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
// ３数の最大公約数
template <class T> T gcd(T a, T b, T c) { return gcd(gcd(a, b), c); }
// ３数以上の最大公約数
template <class T> T gcd(const vector<T> v) {
if (SZ(v) == 0)
return 0;
if (SZ(v) == 1)
return v[0];
if (SZ(v) == 2)
return gcd(v[0], v[1]);
T g = v[0];
for (int i = 1; i < SZ(v); i++) {
g = gcd(g, v[i]);
}
return g;
}
// 最小公倍数(LCM; Least Common Multiple)
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// MOD計算(べき乗) : a^n % MOD
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// MOD計算(逆元) : a^(-1) MOD (※拡張ユークリッド互除法)
ll modinv(ll a, ll mod) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
// MOD計算
//
// modint 構造体を使ってみませんか？ (C++) - noshi91のメモ
// https://noshi91.hatenablog.com/entry/2019/03/31/174006
//
// 使い方:
// const int MOD = 1000000007;
// using mint = modint<MOD>;
// mint a = 1234;
//
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
// DFS 幅優先探索 (A[0] ... A[N] タイプ)
#if 0
VI AA(N);
void dfs(int index, int size, int start, int end)
{
if (index == size) {
solve(A); // ここで必要な処理を行う
}
else{
for(int i = start; i <= end; ++i){
A[index] = i;
// start <= A[i] <= end (i=0~size-1) の場合
//dfs(index + 1, size, start, end);
// start <= A[0] <= A[1] <= ... <= A[size-1] <= end の場合
dfs(index + 1, size, i, end); // start = iを指定することで、次indexの値域を狭める
}
}
}
#endif
// DFS 幅優先探索 (グラフ問題)
//
// ■ 解ける問題
// 1.グラフ上の到達可否
// 2.連結成分の数
// 3.二部グラフ判定 → 引数に現在ノードの色を追加する。color[v]が到達済みで、かつ同じ色の場合、二部グラフではない。
// 4.各頂点の深さ → (行きがけ順)
// 5.各頂点の部分木サイズ → (帰りがけ順)
// 6.サイクル検出（★勉強中）
//
#if 0
VVI G(N); // グラフ
VB seen(N, false); // 到達フラグ
VI first_order(N); // 行きがけ順
VI last_order(N); // 帰りがけ順
VI color(N, 0); // 二部グラフ判定用(0:未到達, 1:白, -1:黒)
VI depth(N); // 各頂点の深さ
VI subtree_size(N); // 各頂点の部分木サイズ
void dfs(const VVI &G, int v, int &order, int parent, int d)
{
first_order[v] = order++;
depth[v] = d;
seen[v] = true;
for(auto nv : G[v]){
if(seen[nv]) continue;
dfs(G, nv, order, v, d);
}
// 部分木サイズ
subtree_size[v] = 1;
for(auto c : G[v]){
if(c == parent) continue;
subtree_size[v] += subtree_size[c];
}
last_order[v] = order++;
}
#endif
// DAG(有向無閉路グラフ)のトポロジカルソート
//
// ■ 応用問題
// 1.依存関係の解決処理
//
VI tsort(const VVI &G) {
int N = G.size();
VI indeg(N); // 各ノードへの入力辺数
stack<int> S; // indeg(x) == 0 のノード
for (auto &v : G) {
for (auto &e : v) {
indeg[e]++;
}
}
REP(i, N) {
if (indeg[i] == 0)
S.push(i);
}
VI ans;
while (!S.empty()) {
int v = S.top();
S.pop();
ans.pb(v);
for (auto &e : G[v]) {
indeg[e]--;
if (indeg[e] == 0)
S.push(e);
}
}
return ans;
}
// グラフの辺(Edge)
typedef pair<ll, int> Edge; // first : コスト, second : 接続先ノード
// ダイクストラ法(最短経路問題。コストが負の場合使用できない)
vector<ll> dijkstra(const vector<vector<Edge>> &G, int start) {
int N = G.size();
priority_queue<Edge, vector<Edge>, greater<Edge>> que;
vector<ll> dist(N, INFLL);
que.push(mp(0LL, start));
dist[start] = 0;
while (!que.empty()) {
Edge p = que.top();
que.pop();
if (dist[p.second] < p.first)
continue;
for (auto &e : G[p.second]) {
if (dist[e.second] > dist[p.second] + e.first) {
dist[e.second] = dist[p.second] + e.first;
que.push(mp(dist[e.second], e.second));
}
}
}
return dist;
}
// Union-Find木(素集合データ構造) -
// グループ分けを木構造で管理する。任意の２要素が同じグループに所属するか判定する
struct UnionFind {
// 親ノードのインデックス
VI parent;
UnionFind(int size) {
parent.resize(size);
REP(i, size) {
parent[i] = i;
} // 初期状態は自ノードが親ノード(＝すべてのノードが独立)
}
// 木の根(root)を取得する
int root(int x) {
// 要素xが根の場合
if (parent[x] == x)
return x;
// 経路圧縮
parent[x] = root(parent[x]);
return parent[x];
}
// 同じグループかどうか判定する
bool same(int x, int y) { return root(x) == root(y); }
// ２つのグループを併合する
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y)
parent[x] = y;
}
};
// 最小全域木(Minimum Spanning Tree) (クラスカル法)
typedef tuple<int, int, int> STEdge; // get0 : コスト, get1,2 : 頂点
struct SpanningTree {
vector<STEdge> edges;
// 辺を追加する(※直接edges変数に追加してもよい。)
void add(int cost, int a, int b) { edges.push_back(mt(cost, a, b)); }
// 最小全域木を生成し、コストの和を計算する
int kuraskal(int size) {
sort(ALL(edges));
UnionFind tree(size);
int min_cost = 0;
REP(i, SZ(edges)) {
auto &e = edges[i];
if (!tree.same(get1(e), get2(e))) {
min_cost += get0(e);
tree.unite(get1(e), get2(e));
}
}
return min_cost;
}
};
// よく忘れるSTLの使い方
//
// ■ 最小値、最大値
// it = min_element(first, last);
// it = min_element(first, last);
//
// ■ 値の交換 swap(a, b) ※文字列(string)も交換可能。
//
// ■ 乱数
// srand((unsigned)time(NULL));
// rand() - 0 ~ 2^31-1 の範囲の乱数(※VSの場合2^15-1。)
//
// ■ 時間計測
// int t0 = clock();
// double ts = 1.0 * (clock() - t0) / CLOCKS_PER_SEC;
//
// ■ sort ソート（降順）
// sort(first, last, greater<T>()); // 大きい順(降順)
//
// ■ カウント O(N)、探索 O(N)、二分探索 O(logN)
// n = count(first, last, value);
// it = find(first, last, value); ※見つからない場合、it == last
// i = lower_bound(first, last, value) - first
// ★[first, last) 間は小さい順に【 ソート済み 】であること。
//
// ■ vector<T>
// v{ a, b, c } // 初期値
// v.assign(first, last) ※sizeも変わる
// v.assign(N, value) ※sizeも変わる
// find(ALL(v)) != v.end()
//
// ■ stack<T>, queue<T>
// ■ priority_queue<T, vector<T>, greater<T>> // 大きい順(降順)の場合、less<T>
// (※sortとは逆) s.push(x) s.pop() x = s.top() or x = q.front()
// ※queueの場合はfront()。 s.size() s.empty()
//
// ■ set<T>, multiset<T>
// s.insert(x)
// s.erase(x) ※multisetではすべてのx
// s.erase(it)
// s.find(x) == s.end()
// s.lower_bound(x)
//
// ■ map<K, V>
// m[K] = V; // 追加
// m.find(K) == m.end() // 探索
//
// ■ tuple
// tuple<T0, T1, T2, ...> t;
// t = mt(v0, v1, v2, ...)
// v0 = get0(t)
// get0(t) = v0
//
// ■ 順列
// do{
// }while(next_permutation(first, last));
// ★[first, last) 間は小さい順に【 ソート済み 】であること。
//
// ■ ビットセット
// bitset<8> b("10000000");
// bs.size()
// b[i] (i = 0 ~ b.size()-1)
// b.set(i) or b.reset(i)
// b.count(), b.all(), b.any(), b.none() 1の数, すべて1か, いずれか1か,
// すべて0か
//
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll nC_A = (A - 1) / C;
ll nC_B = B / C;
ll nD_A = (A - 1) / D;
ll nD_B = B / D;
ll G = lcm(C, D);
ll nG_A = (A - 1) / G;
ll nG_B = B / G;
ll n = B - (A - 1) - (nC_B - nC_A) - (nD_B - nD_A) + (nG_B - nG_A);
cout << n << endl;
return 0;
}
| [
"identifier.change",
"call.function.change"
] | 804,751 | 804,752 | u081029414 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long ans = b - b / c - b / d + b / (c * d / gcd(c, d));
ans -= a - a / c - c / d + a / (c * d / gcd(c, d));
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
a--;
long long ans = b - b / c - b / d + b / (c * d / gcd(c, d));
ans -= a - a / c - a / d + a / (c * d / gcd(c, d));
cout << ans << endl;
} | [
"expression.unary.arithmetic.add",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 804,757 | 804,758 | u336145516 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using p = pair<int, int>;
#define INF 1001001001
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repX(i, n, x) for (int i = x; i < (int)(n); i++)
#define repBack(i, n) for (int i = n; i >= 0; i--)
#define dup(x, y) (((x) + (y)-1) / (y))
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); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll no = 0;
no = B / C - A / C;
no += B / D - A / D;
int g = lcm(C, D);
no -= B / g - A / g;
ll ans = B - A - no;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using p = pair<int, int>;
#define INF 1001001001
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repX(i, n, x) for (int i = x; i < (int)(n); i++)
#define repBack(i, n) for (int i = n; i >= 0; i--)
#define dup(x, y) (((x) + (y)-1) / (y))
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); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
A -= 1;
ll no = 0;
no = B / C - A / C;
no += B / D - A / D;
ll g = lcm(C, D);
no -= B / g - A / g;
ll ans = B - A - no;
cout << ans << endl;
return 0;
} | [
"assignment.add",
"variable_declaration.type.change"
] | 804,779 | 804,780 | u911917041 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long A, B;
int C, D;
cin >> A >> B >> C >> D;
long long a, b, c, d, e, f, g, h;
a = (A - 1) / C;
b = (A - 1) / D;
c = (A - 1) / (C * D / __gcd(C, D));
d = (B) / C;
e = (B) / D;
f = (B) / (C * D / __gcd(C, D));
g = (A - 1) - a - b + c;
h = B - d - e + f;
cout << h - g << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long A, B;
long long C, D;
cin >> A >> B >> C >> D;
long long a, b, c, d, e, f, g, h;
a = (A - 1) / C;
b = (A - 1) / D;
c = (A - 1) / (C * D / __gcd(C, D));
d = (B) / C;
e = (B) / D;
f = (B) / (C * D / __gcd(C, D));
g = (A - 1) - a - b + c;
h = B - d - e + f;
cout << h - g << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,783 | 804,784 | u442097733 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll bai(ll A, ll B, ll w) { return 1 + (B / w) + ((A + w - 1) / w); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << (B - A + 1) - bai(A, B, C) - bai(A, B, D) +
(A, B, C / __gcd(C, D) * D)
<< endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll bai(ll A, ll B, ll w) { return 1 + (B / w) - ((A + w - 1) / w); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << (B - A + 1) - bai(A, B, C) - bai(A, B, D) +
bai(A, B, (C / __gcd(C, D)) * D)
<< endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"function.return_value.change",
"expression.operation.binary.change",
"call.add",
"call.arguments.change"
] | 804,792 | 804,793 | u083494782 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i = a; i < b; i++)
bool sort_by(pi c, pi d) { return c.S < d.S; }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
++B;
// ll ans = 0;
ll minc = A / C;
ll mind = A / D;
ll mint = A / (C * D / __gcd(C, D));
ll mac = B / C;
ll mad = B / D;
ll mat = B / (C * D / __gcd(C, D));
ll not_ok = (mac + mad - mat) - (minc + mind - mint);
cout << B - A - not_ok;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i = a; i < b; i++)
bool sort_by(pi c, pi d) { return c.S < d.S; }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
--A;
// ll ans = 0;
ll minc = A / C;
ll mind = A / D;
ll mint = A / (C * D / __gcd(C, D));
ll mac = B / C;
ll mad = B / D;
ll mat = B / (C * D / __gcd(C, D));
ll not_ok = (mac + mad - mat) - (minc + mind - mint);
cout << B - A - not_ok;
}
| [] | 804,814 | 804,815 | u712837698 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
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;
}
vector<bool> seen;
void dfs(const Graph &G, int v) {
seen[v] = true; // vを訪問済みにする
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_vが探索済みならスルー
dfs(G, next_v); // 再帰的に探索
}
}
int get_digit(ll n) {
int digit = 0;
if (n == 0) {
return 1;
}
while (n != 0) {
digit++;
n /= 10;
}
return digit;
}
bool is_junretu(ll n) {
int digit = get_digit(n);
string s;
s = to_string(n);
bool flg = true;
for (int i = 1; i <= digit; i++) {
if (s.find(i) == string::npos) {
flg = false;
break;
}
}
return flg;
}
ll gcd(ll x, ll y) { return y != 0 ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll cnt_c, cnt_d, cnt_cd;
cnt_c = (b / c) - ((a - 1) / c);
cnt_d = (b / d) - ((a - 1) / d);
cnt_cd = (b / lcm(c, d)) - (a / lcm(c, d));
ll cnt;
cnt = cnt_c + cnt_d - cnt_cd;
ll ans = (b - a + 1) - cnt;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
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;
}
vector<bool> seen;
void dfs(const Graph &G, int v) {
seen[v] = true; // vを訪問済みにする
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_vが探索済みならスルー
dfs(G, next_v); // 再帰的に探索
}
}
int get_digit(ll n) {
int digit = 0;
if (n == 0) {
return 1;
}
while (n != 0) {
digit++;
n /= 10;
}
return digit;
}
bool is_junretu(ll n) {
int digit = get_digit(n);
string s;
s = to_string(n);
bool flg = true;
for (int i = 1; i <= digit; i++) {
if (s.find(i) == string::npos) {
flg = false;
break;
}
}
return flg;
}
ll gcd(ll x, ll y) { return y != 0 ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll cnt_c, cnt_d, cnt_cd;
cnt_c = (b / c) - ((a - 1) / c);
cnt_d = (b / d) - ((a - 1) / d);
cnt_cd = (b / lcm(c, d)) - ((a - 1) / lcm(c, d));
ll cnt;
cnt = cnt_c + cnt_d - cnt_cd;
ll ans = (b - a + 1) - cnt;
cout << ans << endl;
return 0;
} | [] | 804,818 | 804,819 | u748757847 | cpp |
p02995 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
ll a, b, c, d;
ll num_of_mul(int n) { // a以上b以下でnで割り切れるものの数
return b / n - (a + n - 1) / n + 1;
}
int main() {
cin >> a >> b >> c >> d;
ll lcm = c * d / __gcd(c, d);
ll ng = num_of_mul(c) + num_of_mul(d) - num_of_mul(lcm);
cout << b - a + 1 - ng << endl;
return 0;
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
ll a, b, c, d;
ll num_of_mul(ll n) { // a以上b以下でnで割り切れるものの数
return b / n - (a + n - 1) / n + 1;
}
int main() {
cin >> a >> b >> c >> d;
ll lcm = c * d / __gcd(c, d);
ll ng = num_of_mul(c) + num_of_mul(d) - num_of_mul(lcm);
cout << b - a + 1 - ng << endl;
return 0;
} | [] | 804,830 | 804,831 | u168684371 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
long long A, B, C, D;
cin >> A >> B >> C >> D;
long long x = C * D * __gcd(C, D);
long long xa = (A - 1) / C + (A - 1) / D - (A - 1) / x;
long long xb = B / C + B / D - B / x;
cout << (B - xb) - (A - 1 - xa) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
long long A, B, C, D;
cin >> A >> B >> C >> D;
long long x = C * D / __gcd(C, D);
long long xa = (A - 1) / C + (A - 1) / D - (A - 1) / x;
long long xb = B / C + B / D - B / x;
cout << (B - xb) - (A - 1 - xa) << endl;
}
| [
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 804,843 | 804,844 | u093973314 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
int gcd(int64_t x, int64_t y) {
if (x == 0 || y == 0)
return max(x, y);
else if (x < y)
return gcd(x, y % x);
else if (y < x)
return gcd(y, x % y);
else
return x;
}
int lcm(int64_t x, int64_t y) { return ((x * y) / gcd(x, y)); }
int main() {
int64_t A, B, C, D;
cin >> A >> B >> C >> D;
int64_t b = B - B / C - B / D + B / lcm(C, D);
A--;
int64_t a = A - A / C - A / D + A / lcm(C, D);
int64_t ans = b - a;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int64_t gcd(int64_t x, int64_t y) {
if (x == 0 || y == 0)
return max(x, y);
else if (x < y)
return gcd(x, y % x);
else if (y < x)
return gcd(y, x % y);
else
return x;
}
int64_t lcm(int64_t x, int64_t y) { return ((x * y) / gcd(x, y)); }
int main() {
int64_t A, B, C, D;
cin >> A >> B >> C >> D;
int64_t b = B - B / C - B / D + B / lcm(C, D);
A--;
int64_t a = A - A / C - A / D + A / lcm(C, D);
int64_t ans = b - a;
cout << ans << endl;
return 0;
} | [
"function.return_type.change"
] | 804,853 | 804,854 | u101018317 | cpp |
p02995 | //----AUTHOR:kkdrummer----/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
// typedef unordered_set<ll> usll;
// typedef unordered_multiset<ll> umsll;
typedef multiset<ll> msll;
typedef set<ll> sll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef priority_queue<ll> pqll;
typedef vector<int> vi;
typedef set<int> si;
typedef multiset<int> msi;
// typedef unordered_multiset<int> umsi;
// typedef unordered_set<int> usi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef set<pi> spi;
typedef priority_queue<int> pqi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ind_set;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ind_setll;
#define in insert
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define be begin
#define en end
#define itr iterator
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mo 1000000007
#define inf 9223372036854775807
#define ninf -inf
#define ima 2147483647
#define imi -ima
#define oncnt __builtin_popcount
#define zerobegin __builtin_clz
#define zeroend __builtin_ctz
#define parity __builtin_parity
#define all(x) x.be(), x.en()
#define eps 1e-9
#define coutd cout << setprecision(10) << fixed
#define mems(dp, x) memset(dp, x, sizeof(dp))
const ld PI = 3.14159265359;
inline ll modpow(ll x, ll n) {
if (n == 0)
return 1;
if (n == 1)
return (x % mo);
ll u = (modpow(x, n / 2));
u = (u * u) % mo;
if (n % 2 != 0)
u = (u * x % mo) % mo;
return u;
}
inline ll modinv(ll x) { return modpow(x, mo - 2); }
inline ll mmul(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll madd(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a + b >= mo)
return (a + b) % mo;
return (a + b);
}
inline ll msub(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
return (((a - b) % mo + mo) % mo);
}
inline ll mdiv(ll a, ll bb) {
if (a >= mo)
a = a % mo;
ll b = modinv(bb);
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll gcd(ll a, ll b) { return __gcd(a, b); }
int main() {
io int testcases = 1; // cin>>testcases;
while (testcases--) {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ss = (b - a + 1);
ll s = ss;
b++;
a++;
ll k1 = (b) / c - a / c;
ll k2 = (b) / d - a / d;
ll h = (c * d) / gcd(c, d);
ll k3 = (b) / h - a / h;
cout << ss - k1 - k2 + k3;
}
return 0;
} | //----AUTHOR:kkdrummer----/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
// typedef unordered_set<ll> usll;
// typedef unordered_multiset<ll> umsll;
typedef multiset<ll> msll;
typedef set<ll> sll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef priority_queue<ll> pqll;
typedef vector<int> vi;
typedef set<int> si;
typedef multiset<int> msi;
// typedef unordered_multiset<int> umsi;
// typedef unordered_set<int> usi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef set<pi> spi;
typedef priority_queue<int> pqi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ind_set;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ind_setll;
#define in insert
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define be begin
#define en end
#define itr iterator
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mo 1000000007
#define inf 9223372036854775807
#define ninf -inf
#define ima 2147483647
#define imi -ima
#define oncnt __builtin_popcount
#define zerobegin __builtin_clz
#define zeroend __builtin_ctz
#define parity __builtin_parity
#define all(x) x.be(), x.en()
#define eps 1e-9
#define coutd cout << setprecision(10) << fixed
#define mems(dp, x) memset(dp, x, sizeof(dp))
const ld PI = 3.14159265359;
inline ll modpow(ll x, ll n) {
if (n == 0)
return 1;
if (n == 1)
return (x % mo);
ll u = (modpow(x, n / 2));
u = (u * u) % mo;
if (n % 2 != 0)
u = (u * x % mo) % mo;
return u;
}
inline ll modinv(ll x) { return modpow(x, mo - 2); }
inline ll mmul(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll madd(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
if (a + b >= mo)
return (a + b) % mo;
return (a + b);
}
inline ll msub(ll a, ll b) {
if (a >= mo)
a = a % mo;
if (b >= mo)
b = b % mo;
return (((a - b) % mo + mo) % mo);
}
inline ll mdiv(ll a, ll bb) {
if (a >= mo)
a = a % mo;
ll b = modinv(bb);
if (b >= mo)
b = b % mo;
if (a * b >= mo)
return (a * b) % mo;
return (a * b);
}
inline ll gcd(ll a, ll b) { return __gcd(a, b); }
int main() {
io int testcases = 1; // cin>>testcases;
while (testcases--) {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ss = (b - a + 1);
ll s = ss;
a--;
ll k1 = (b) / c - a / c;
ll k2 = (b) / d - a / d;
ll h = (c * d) / gcd(c, d);
ll k3 = (b) / h - a / h;
cout << ss - k1 - k2 + k3;
}
return 0;
} | [
"expression.unary.arithmetic.remove"
] | 804,861 | 804,862 | u452240501 | cpp |
p02995 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
typedef long long ll;
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll bnum = b - b / c - b / d + b / (lcm(c, d));
ll anum = a - 1 - (a - 1) / c - (a - 1) / d + (a - 1) / (lcm(c, d));
cout << bnum - anum << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll bnum = b - b / c - b / d + b / (lcm(c, d));
ll anum = a - 1 - (a - 1) / c - (a - 1) / d + (a - 1) / (lcm(c, d));
cout << bnum - anum << endl;
return 0;
} | [] | 804,871 | 804,872 | u374678351 | cpp |
p02995 | #include <bits/stdc++.h>
#include <regex>
#ifdef _DEBUG
#include "debug.h"
#endif
#define int ll
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define all(v) (v).begin(), (v).end()
#define mkpr make_pair
#define mktp make_tuple
#define tv(tp, i) get<(i)>(tp)
#define CLEAR(obj) obj = decltype(obj)()
#define var auto
#define OUT(type) type &
#define IN(type) const type &
#define self (*this)
#define in :
#define True true
#define False false
using namespace std;
using int32 = int32_t;
using str = string;
using cstr = const str;
using ll = long long;
using ull = unsigned long long;
using cint = const int;
using cll = const ll;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vc = vector<char>;
using vvc = vector<vc>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using psl = pair<string, ll>;
using tiii = tuple<int, int, int>;
using tlll = tuple<ll, ll, ll>;
static const int MGN = 10;
static const int ARYSZ_MAX = (int)1e7;
static const ll LINF = LLONG_MAX / 2;
#ifdef int
static const int INF = LINF;
#else
static const int INF = INT_MAX / 2;
#endif
static double EPS = 1e-9;
#define FASTCIN() \
cin.tie(0); \
ios::sync_with_stdio(false);
#ifdef IMPORT_SAMPLE
#define DEBUG_IMPORT(file) \
vs args(argv, argv + argc); \
str sample = make_sample(args, file); \
ifstream ifs(sample); \
cin.rdbuf(ifs.rdbuf());
#else
#define DEBUG_IMPORT(file)
#endif
static inline bool DBLEQ(double a, double b) { return abs(a - b) < EPS; }
static inline void EPR(str msg) { cerr << msg << endl; }
static inline void AST(bool exp, str msg) {
if (!exp) {
EPR(msg);
}
assert(exp);
}
static inline void TAST(bool exp, str msg) {
if (!exp) {
EPR(msg);
}
while (!exp) {
}
}
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; }
int multiple(int x, int d) { return x / d; }
int32 main(int32 argc, char *argv[]) {
FASTCIN();
DEBUG_IMPORT("sample-1");
int A, B, C, D;
cin >> A >> B >> C >> D;
// [A, B]
// x%C != 0 and x%D != 0
int cmult = multiple(B, C) - multiple(A - 1, C);
int dmult = multiple(B, D) - multiple(A - 1, D);
int lc = lcm(C, D);
int cdmult = multiple(B, lc) - multiple(A, lc);
int ans = B - A + 1 - cmult - dmult + cdmult;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <regex>
#ifdef _DEBUG
#include "debug.h"
#endif
#define int ll
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define all(v) (v).begin(), (v).end()
#define mkpr make_pair
#define mktp make_tuple
#define tv(tp, i) get<(i)>(tp)
#define CLEAR(obj) obj = decltype(obj)()
#define var auto
#define OUT(type) type &
#define IN(type) const type &
#define self (*this)
#define in :
#define True true
#define False false
using namespace std;
using int32 = int32_t;
using str = string;
using cstr = const str;
using ll = long long;
using ull = unsigned long long;
using cint = const int;
using cll = const ll;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vc = vector<char>;
using vvc = vector<vc>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using psl = pair<string, ll>;
using tiii = tuple<int, int, int>;
using tlll = tuple<ll, ll, ll>;
static const int MGN = 10;
static const int ARYSZ_MAX = (int)1e7;
static const ll LINF = LLONG_MAX / 2;
#ifdef int
static const int INF = LINF;
#else
static const int INF = INT_MAX / 2;
#endif
static double EPS = 1e-9;
#define FASTCIN() \
cin.tie(0); \
ios::sync_with_stdio(false);
#ifdef IMPORT_SAMPLE
#define DEBUG_IMPORT(file) \
vs args(argv, argv + argc); \
str sample = make_sample(args, file); \
ifstream ifs(sample); \
cin.rdbuf(ifs.rdbuf());
#else
#define DEBUG_IMPORT(file)
#endif
static inline bool DBLEQ(double a, double b) { return abs(a - b) < EPS; }
static inline void EPR(str msg) { cerr << msg << endl; }
static inline void AST(bool exp, str msg) {
if (!exp) {
EPR(msg);
}
assert(exp);
}
static inline void TAST(bool exp, str msg) {
if (!exp) {
EPR(msg);
}
while (!exp) {
}
}
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; }
int multiple(int x, int d) { return x / d; }
int32 main(int32 argc, char *argv[]) {
FASTCIN();
DEBUG_IMPORT("sample-1");
int A, B, C, D;
cin >> A >> B >> C >> D;
// [A, B]
// x%C != 0 and x%D != 0
int cmult = multiple(B, C) - multiple(A - 1, C);
int dmult = multiple(B, D) - multiple(A - 1, D);
int lc = lcm(C, D);
int cdmult = multiple(B, lc) - multiple(A - 1, lc);
int ans = B - A + 1 - cmult - dmult + cdmult;
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 804,887 | 804,888 | u404244809 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
int g = c * d / __gcd(c, d);
cout << fixed << setprecision(0)
<< b - b / c - b / d + b / g -
(a - 1 - (a - 1) / c - (a - 1) / d + (a - 1) / g)
<< endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long g = c * d / __gcd(c, d);
cout << fixed << setprecision(0)
<< b - b / c - b / d + b / g -
(a - 1 - (a - 1) / c - (a - 1) / d + (a - 1) / g)
<< endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,891 | 804,892 | u957377447 | cpp |
p02995 | #include <iostream>
using namespace std;
long long int GCD(long long int a, long long int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
long long int A, B, C, D;
cin >> A >> B >> C >> D;
long long int c, d, cd;
c = B / C - (A - 1) / C;
d = B / D - (A - 1) / D;
cd = C / GCD(C, D) * D;
cd = B / cd + (A - 1) / cd;
cout << (B - A + 1) - (c + d - cd) << endl;
return 0;
} | #include <iostream>
using namespace std;
long long int GCD(long long int a, long long int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
long long int A, B, C, D;
cin >> A >> B >> C >> D;
long long int c, d, cd;
c = B / C - (A - 1) / C;
d = B / D - (A - 1) / D;
cd = C / GCD(C, D) * D;
cd = B / cd - (A - 1) / cd;
cout << (B - A + 1) - (c + d - cd) << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 804,927 | 804,928 | u806657856 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
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;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
ll a, b, c, d;
cin >> a >> b >> c >> d;
--a;
ll y = b, x = a;
y -= b / c + b / d;
y += b / lcm(c, d);
x -= a / c + a / d;
x -= a / lcm(c, d);
cout << y - x << "\n";
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
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;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
ll a, b, c, d;
cin >> a >> b >> c >> d;
--a;
ll y = b, x = a;
y -= b / c + b / d;
y += b / lcm(c, d);
x -= a / c + a / d;
x += a / lcm(c, d);
cout << y - x << "\n";
}
| [
"expression.operator.change"
] | 804,934 | 804,935 | u863044225 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
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;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
ll a, b, c, d;
cin >> a >> b >> c >> d;
--a;
ll y = b, x = a;
y -= b / c + b / d;
y += b / lcm(c, d);
x -= a / c + a / d;
x -= a / lcm(c, d);
cout << y - x << "\n";
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
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;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
ll a, b, c, d;
cin >> a >> b >> c >> d;
--a;
ll y = b, x = a;
y -= b / c + b / d;
y += b / lcm(c, d);
x -= a / c + a / d;
x += a / lcm(c, d);
cout << y - x << "\n";
} | [
"expression.operator.change"
] | 804,934 | 804,936 | u863044225 | cpp |
p02995 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main(void) {
long long A, B, C, D;
cin >> A >> B >> C >> D;
A = A - 1;
long long a = B / C - A / C;
long long b = B / D - A / D;
long long x = C * D;
long long e, d, tmp, y;
if (C < D) {
tmp = e;
e = d;
d = tmp;
}
y = C % D;
while (y != 0) {
C = D;
D = y;
y = C % D;
}
int LCM = x / D;
long long c = B / LCM - A / LCM;
long long total = B - A;
long long ans = total - a - b + c;
// cout << a << endl;
cout << ans << endl;
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main(void) {
long long A, B, C, D;
cin >> A >> B >> C >> D;
A = A - 1;
long long a = B / C - A / C;
long long b = B / D - A / D;
long long x = C * D;
long long e, d, tmp, y;
if (C < D) {
tmp = e;
e = d;
d = tmp;
}
y = C % D;
while (y != 0) {
C = D;
D = y;
y = C % D;
}
long long LCM = x / D;
long long c = B / LCM - A / LCM;
long long total = B - A;
long long ans = total - a - b + c;
// cout << a << endl;
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 804,940 | 804,941 | u845000384 | cpp |
p02995 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
const int MOD = 1000000007;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
using Graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll ans = B - A + 1;
ans -= (B / C - (A - 1) / C);
ans -= (B / D - (A - 1) / D);
ans += (B / lcm(C, D) - A / lcm(C, D));
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
const int MOD = 1000000007;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
using Graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll ans = B - A + 1;
ans -= (B / C - (A - 1) / C);
ans -= (B / D - (A - 1) / D);
ans += (B / lcm(C, D) - (A - 1) / lcm(C, D));
cout << ans << endl;
}
| [] | 804,942 | 804,943 | u427344224 | cpp |
p02995 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mod 1000000007
using namespace std;
typedef long long ll;
ll a, b, c, d, ans;
ll gcm(ll a, ll b) {
if (b == 0)
return a;
return gcm(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcm(a, b) * b; }
main() {
cin >> a >> b >> c >> d;
b++;
a = a - a / c - a / d + a / lcm(c, d);
b = b - b / c - b / d + b / lcm(c, d);
cout << b - a << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mod 1000000007
using namespace std;
typedef long long ll;
ll a, b, c, d, ans;
ll gcm(ll a, ll b) {
if (b == 0)
return a;
return gcm(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcm(a, b) * b; }
main() {
cin >> a >> b >> c >> d;
a--;
b;
a = a - a / c - a / d + a / lcm(c, d);
b = b - b / c - b / d + b / lcm(c, d);
cout << b - a << endl;
}
| [] | 804,948 | 804,949 | u720321944 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 3000;
LL a, b, c, d;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> a >> b >> c >> d;
LL sum1 = b / c - (a - 1) / c;
LL sum2 = b / d - (a - 1) / d;
LL lcm = c * d / gcd(c, d);
LL sum3 = b / lcm - (a - 1) / lcm;
cout << (b - a + 1) - (sum1 - sum2 + sum3) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 3000;
LL a, b, c, d;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> a >> b >> c >> d;
LL sum1 = b / c - (a - 1) / c;
LL sum2 = b / d - (a - 1) / d;
LL lcm = c * d / gcd(c, d);
LL sum3 = b / lcm - (a - 1) / lcm;
cout << (b - a + 1) - sum1 - sum2 + sum3 << endl;
return 0;
}
| [] | 804,959 | 804,960 | u866538547 | cpp |
p02995 |
// C - Anti-Division
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const int MOD = 1e9 + 7;
ll get_gcd(ll x, ll y) {
if (x < y) {
swap(x, y);
}
ll m = x % y;
while (m != 0) {
x = y;
y = m;
m = x % y;
}
return y;
}
ll get_lcm(ll x, ll y) { return x * y / get_gcd(x, y); }
int main() {
int A, B, C, D;
cin >> A >> B >> C >> D;
ll lcm_CD = get_lcm(C, D);
ll div_C = B / C - (A - 1) / C;
ll div_D = B / D - (A - 1) / D;
ll div_CD = B / lcm_CD - (A - 1) / lcm_CD;
ll ans = B - A + 1 - (div_C + div_D - div_CD);
cout << ans << endl;
return 0;
} |
// C - Anti-Division
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const int MOD = 1e9 + 7;
ll get_gcd(ll x, ll y) {
if (x < y) {
swap(x, y);
}
ll m = x % y;
while (m != 0) {
x = y;
y = m;
m = x % y;
}
return y;
}
ll get_lcm(ll x, ll y) { return x * y / get_gcd(x, y); }
int main() {
ll A, B, C, D;
cin >> A >> B >> C >> D;
ll lcm_CD = get_lcm(C, D);
ll div_C = B / C - (A - 1) / C;
ll div_D = B / D - (A - 1) / D;
ll div_CD = B / lcm_CD - (A - 1) / lcm_CD;
ll ans = B - A + 1 - (div_C + div_D - div_CD);
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 804,971 | 804,972 | u790272146 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll c, d;
int calc(ll n) { return n - n / c - n / d + n / (c * d / __gcd(c, d)); }
int main() {
ll a, b;
cin >> a >> b >> c >> d;
cout << calc(b) - calc(a - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll c, d;
ll calc(ll n) { return n - n / c - n / d + n / (c * d / __gcd(c, d)); }
int main() {
ll a, b;
cin >> a >> b >> c >> d;
cout << calc(b) - calc(a - 1) << endl;
return 0;
} | [] | 804,981 | 804,982 | u804999113 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int c, d;
int calc(ll n) { return n - n / c - n / d + n / (c * d / __gcd(c, d)); }
int main() {
ll a, b;
cin >> a >> b >> c >> d;
cout << calc(b) - calc(a - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll c, d;
ll calc(ll n) { return n - n / c - n / d + n / (c * d / __gcd(c, d)); }
int main() {
ll a, b;
cin >> a >> b >> c >> d;
cout << calc(b) - calc(a - 1) << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 804,983 | 804,982 | u804999113 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int c, d;
int calc(int n) { return n - n / c - n / d + n / (c * d / __gcd(c, d)); }
int main() {
int a, b;
cin >> a >> b >> c >> d;
cout << calc(b) - calc(a - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll c, d;
ll calc(ll n) { return n - n / c - n / d + n / (c * d / __gcd(c, d)); }
int main() {
ll a, b;
cin >> a >> b >> c >> d;
cout << calc(b) - calc(a - 1) << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 804,984 | 804,982 | u804999113 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll get(ll l, ll r, ll x) { return (r / x) - ((l - 1) / x); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll lcm = a * b;
lcm /= __gcd(a, b);
ll num1 = get(a, b, c) + get(a, b, d) - get(a, b, lcm);
num1 = b - a + 1 - num1;
cout << num1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll get(ll l, ll r, ll x) { return (r / x) - ((l - 1) / x); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll lcm = c * d;
lcm /= __gcd(c, d);
ll num1 = get(a, b, c) + get(a, b, d) - get(a, b, lcm);
num1 = b - a + 1 - num1;
cout << num1 << endl;
} | [
"identifier.change",
"expression.operation.binary.change",
"assignment.value.change",
"call.arguments.change"
] | 805,000 | 805,001 | u109635851 | cpp |
p02995 | #include <iostream>
using namespace std;
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (c > d)
swap(c, d);
long long dd = d;
long long cc = c;
// gcd
while (dd % cc != 0) {
dd = dd % cc;
swap(dd, cc);
}
long long gcd = cc;
long long lcm = c * d / gcd;
long long n = b - a + 1;
long long ans =
n - b / d + (a - 1) / d - b / c + (a - 1) / c + b / lcm + (a - 1) / lcm;
cout << ans;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (c > d)
swap(c, d);
long long dd = d;
long long cc = c;
// gcd
while (dd % cc != 0) {
dd = dd % cc;
swap(dd, cc);
}
long long gcd = cc;
long long lcm = c * d / gcd;
long long n = b - a + 1;
long long ans =
n - b / d + (a - 1) / d - b / c + (a - 1) / c + b / lcm - (a - 1) / lcm;
cout << ans;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 805,006 | 805,007 | u564377816 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll a, b, c, d, ans = 0, r, l, lcm;
cin >> a >> b >> c >> d;
r = b / c;
l = (a - 1) / c;
ans = r - l;
r = b / d;
l = (a - 1) / d;
ans = ans + r - l;
lcm = (c * d) / __gcd(c, d);
r = b / lcm;
l = (a - 1) / lcm;
ans = ans - r - l;
ans = (b - a) + 1 - ans;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll a, b, c, d, ans = 0, r, l, lcm;
cin >> a >> b >> c >> d;
r = b / c;
l = (a - 1) / c;
ans = r - l;
r = b / d;
l = (a - 1) / d;
ans = ans + r - l;
lcm = (c * d) / __gcd(c, d);
r = b / lcm;
l = (a - 1) / lcm;
ans = ans - (r - l);
ans = (b - a) + 1 - ans;
cout << ans << endl;
return 0;
}
| [] | 805,008 | 805,009 | u858155043 | cpp |
p02995 | #include <bits/stdc++.h>
using namespace std;
int lcm(long long x, long long y) { return x / __gcd(x, y) * y; }
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long l = lcm(c, d);
long long all = b - a + 1, cs = (a + c - 1) / c, ce = b / c,
ds = (a + d - 1) / d, de = b / d, ls = (a + l - 1) / l, le = b / l;
cout << all - (ce - cs + 1) - (de - ds + 1) + (le - ls + 1);
} | #include <bits/stdc++.h>
using namespace std;
long long lcm(long long x, long long y) { return x / __gcd(x, y) * y; }
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long l = lcm(c, d);
long long all = b - a + 1, cs = (a + c - 1) / c, ce = b / c,
ds = (a + d - 1) / d, de = b / d, ls = (a + l - 1) / l, le = b / l;
cout << all - (ce - cs + 1) - (de - ds + 1) + (le - ls + 1);
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 805,016 | 805,017 | u441250130 | cpp |
p02995 | #include "bits/stdc++.h"
using namespace std;
using lint = long long;
#define low lower_bound
#define upp upper_bound
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, n) for (int i = int(n); i >= 0; --i)
#define all(vec) (vec).begin(), (vec).end()
#define cend printf("\n");
#define prique(T) priority_queue<T, vector<T>, greater<T>>
#define prique2(T) priority_queue<T>
struct edge {
lint to;
lint cost;
};
using P = pair<lint, lint>;
using D = pair<long double, long double>;
// const lint mod = 998244353LL;
const lint mod = 1000000007LL;
const lint inf = 3LL * mod * mod;
const double Pi = acos(-1.0);
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) { return chmax(b, a); }
lint modpow(lint x, lint n, lint m) {
lint ans = 1;
while (n > 0) {
if (n & 1) {
ans *= x;
if (m <= ans)
ans %= m;
}
x *= x;
if (m <= x)
x %= m;
n >>= 1;
}
return ans;
}
lint fact[1000000];
void f_init(lint n) {
if (1000000 <= n)
return;
fact[0] = fact[1] = 1;
for (lint i = 2; i <= n; ++i) {
fact[i] = i * fact[i - 1];
if (mod <= fact[i])
fact[i] %= mod;
}
return;
}
lint comb(lint n, lint r) {
if (n < r)
return 0;
if (n == r)
return 1;
lint ans = fact[n] * modpow(fact[n - r], mod - 2, mod) % mod *
modpow(fact[r], mod - 2, mod) % mod;
if (ans < 0)
return ans + mod;
return ans;
}
lint nck[1010][1010];
void comb(lint n) {
rep(i, n + 1) {
rep(j, i + 1) {
if (j == 0 || i == j)
nck[i][j] = 1;
else
nck[i][j] = nck[i - 1][j - 1] + nck[i - 1][j];
}
}
}
lint gcd(lint a, lint b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool pri(lint p) {
for (lint i = 2; i * i <= p; i == 2 ? ++i : i += 2)
if (p % i == 0)
return false;
return p > 1;
}
map<lint, lint> factring(lint n) {
map<lint, lint> ans;
for (lint i = 2; i * i <= n; ++i) {
while (n % i == 0) {
n /= i;
++ans[i];
}
}
if (n != 1)
++ans[n];
return ans;
}
lint xor128() {
static lint x = 123456789, y = 362436069, z = 521288629, w = 88675123;
lint t = (x xor (x << 11));
x = y;
y = z;
z = w;
return (w = (w xor (w >> 19)) xor (t xor (t >> 8)));
}
double dis(D a, D b) {
double x = a.first - b.first, y = a.second - b.second;
return sqrt(x * x + y * y);
}
//外心を求める
D circum(D x, D y, D z) {
long double a1, a2, b1, b2, c1, c2;
long double da, db, dc; //距離
long double a, b, c; // cos
long double o, ox, oy;
a1 = x.first, a2 = x.second, b1 = y.first, b2 = y.second, c1 = z.first,
c2 = z.second;
dc = dis(D(a1, a2), D(b1, b2));
da = dis(D(b1, b2), D(c1, c2));
db = dis(D(c1, c2), D(a1, a2));
a = (db * db + dc * dc - da * da) / (2 * db * dc);
b = (dc * dc + da * da - db * db) / (2 * dc * da);
c = (da * da + db * db - dc * dc) / (2 * da * db);
o = a * da + b * db + c * dc;
ox = (a1 * a * da + b1 * b * db + c1 * c * dc) / o;
oy = (a2 * a * da + b2 * b * db + c2 * c * dc) / o;
return D(ox, oy);
}
class unionfind {
private:
int par[2 * 100010], ranks[2 * 100010], sizeth[2 * 100010];
public:
void init(int n) {
for (int i = 0; i < n; ++i) {
par[i] = i;
ranks[i] = 0;
sizeth[i] = 1;
}
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (ranks[x] < ranks[y]) {
par[x] = y;
sizeth[y] += sizeth[x];
} else {
par[y] = x;
if (ranks[x] == ranks[y])
++ranks[x];
sizeth[x] += sizeth[y];
}
}
};
lint a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
a--;
cout << (b - (b / c + b / d - b / lcm(c, d))) -
(a - (a / c + a / d + a / lcm(c, d)))
<< endl;
} | #include "bits/stdc++.h"
using namespace std;
using lint = long long;
#define low lower_bound
#define upp upper_bound
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, n) for (int i = int(n); i >= 0; --i)
#define all(vec) (vec).begin(), (vec).end()
#define cend printf("\n");
#define prique(T) priority_queue<T, vector<T>, greater<T>>
#define prique2(T) priority_queue<T>
struct edge {
lint to;
lint cost;
};
using P = pair<lint, lint>;
using D = pair<long double, long double>;
// const lint mod = 998244353LL;
const lint mod = 1000000007LL;
const lint inf = 3LL * mod * mod;
const double Pi = acos(-1.0);
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) { return chmax(b, a); }
lint modpow(lint x, lint n, lint m) {
lint ans = 1;
while (n > 0) {
if (n & 1) {
ans *= x;
if (m <= ans)
ans %= m;
}
x *= x;
if (m <= x)
x %= m;
n >>= 1;
}
return ans;
}
lint fact[1000000];
void f_init(lint n) {
if (1000000 <= n)
return;
fact[0] = fact[1] = 1;
for (lint i = 2; i <= n; ++i) {
fact[i] = i * fact[i - 1];
if (mod <= fact[i])
fact[i] %= mod;
}
return;
}
lint comb(lint n, lint r) {
if (n < r)
return 0;
if (n == r)
return 1;
lint ans = fact[n] * modpow(fact[n - r], mod - 2, mod) % mod *
modpow(fact[r], mod - 2, mod) % mod;
if (ans < 0)
return ans + mod;
return ans;
}
lint nck[1010][1010];
void comb(lint n) {
rep(i, n + 1) {
rep(j, i + 1) {
if (j == 0 || i == j)
nck[i][j] = 1;
else
nck[i][j] = nck[i - 1][j - 1] + nck[i - 1][j];
}
}
}
lint gcd(lint a, lint b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool pri(lint p) {
for (lint i = 2; i * i <= p; i == 2 ? ++i : i += 2)
if (p % i == 0)
return false;
return p > 1;
}
map<lint, lint> factring(lint n) {
map<lint, lint> ans;
for (lint i = 2; i * i <= n; ++i) {
while (n % i == 0) {
n /= i;
++ans[i];
}
}
if (n != 1)
++ans[n];
return ans;
}
lint xor128() {
static lint x = 123456789, y = 362436069, z = 521288629, w = 88675123;
lint t = (x xor (x << 11));
x = y;
y = z;
z = w;
return (w = (w xor (w >> 19)) xor (t xor (t >> 8)));
}
double dis(D a, D b) {
double x = a.first - b.first, y = a.second - b.second;
return sqrt(x * x + y * y);
}
//外心を求める
D circum(D x, D y, D z) {
long double a1, a2, b1, b2, c1, c2;
long double da, db, dc; //距離
long double a, b, c; // cos
long double o, ox, oy;
a1 = x.first, a2 = x.second, b1 = y.first, b2 = y.second, c1 = z.first,
c2 = z.second;
dc = dis(D(a1, a2), D(b1, b2));
da = dis(D(b1, b2), D(c1, c2));
db = dis(D(c1, c2), D(a1, a2));
a = (db * db + dc * dc - da * da) / (2 * db * dc);
b = (dc * dc + da * da - db * db) / (2 * dc * da);
c = (da * da + db * db - dc * dc) / (2 * da * db);
o = a * da + b * db + c * dc;
ox = (a1 * a * da + b1 * b * db + c1 * c * dc) / o;
oy = (a2 * a * da + b2 * b * db + c2 * c * dc) / o;
return D(ox, oy);
}
class unionfind {
private:
int par[2 * 100010], ranks[2 * 100010], sizeth[2 * 100010];
public:
void init(int n) {
for (int i = 0; i < n; ++i) {
par[i] = i;
ranks[i] = 0;
sizeth[i] = 1;
}
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (ranks[x] < ranks[y]) {
par[x] = y;
sizeth[y] += sizeth[x];
} else {
par[y] = x;
if (ranks[x] == ranks[y])
++ranks[x];
sizeth[x] += sizeth[y];
}
}
};
lint a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
a--;
cout << (b - (b / c + b / d - b / lcm(c, d))) -
(a - (a / c + a / d - a / lcm(c, d)))
<< endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 805,018 | 805,019 | u054475353 | cpp |
p02995 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<int> enum_div(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll A, B, C, D;
cin >> A >> B >> C >> D;
auto solve = [](ll x, ll a, ll b) {
return (x - (x / a) - (x / b) + (x / LCM(a, b)));
};
cout << solve(B + 1, C, D) - solve(A, C, D) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<int> enum_div(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll A, B, C, D;
cin >> A >> B >> C >> D;
auto solve = [](ll x, ll a, ll b) {
return (x - (x / a) - (x / b) + (x / LCM(a, b)));
};
cout << solve(B, C, D) - solve(A - 1, C, D) << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 805,025 | 805,026 | u303039933 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.