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 |
|---|---|---|---|---|---|---|---|
p03037 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) \
; \
for (ll i = 0; i < (ll)n; i++)
int main() {
int n, m;
cin >> n >> m;
int l, u;
l = 0;
u = (int)1e6;
rep(i, m) {
int p, q;
cin >> p >> q;
if (l < p)
l = p;
if (q < u)
u = q;
}
cout << u - l + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) \
; \
for (ll i = 0; i < (ll)n; i++)
int main() {
int n, m;
cin >> n >> m;
int l, u;
l = 0;
u = (int)1e6;
rep(i, m) {
int p, q;
cin >> p >> q;
if (l < p)
l = p;
if (q < u)
u = q;
}
cout << max(u - l + 1, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 850,185 | 850,186 | u678961336 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int L = 0, R = n;
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
L = max(L, l);
R = min(R, r);
}
cout << R - L + 1 << "\n"s;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int L = 0, R = n;
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
L = max(L, l);
R = min(R, r);
}
cout << max(0, R - L + 1) << "\n"s;
}
| [
"call.add",
"call.arguments.change"
] | 850,193 | 850,194 | u104613587 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int L = 0, R = 1e9;
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
L = max(L, l), R = min(R, r);
}
cout << (R - L > 0 ? R - L + 1 : 0) << "\n"s;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int L = 0, R = 1e9;
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
L = max(L, l), R = min(R, r);
}
cout << (R - L >= 0 ? R - L + 1 : 0) << "\n"s;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 850,195 | 850,196 | u104613587 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
int l = 0, r = 9999999;
for (int i = 0; i < m; i++) {
l = max(l, L.at(i));
r = min(r, R.at(i));
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i >= l && i <= r) {
ans++;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
int l = 0, r = 999999;
for (int i = 0; i < m; i++) {
l = max(l, L.at(i));
r = min(r, R.at(i));
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (i >= l && i <= r) {
ans++;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 850,207 | 850,208 | u856957535 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
int l = 0, r = 999999;
for (int i = 0; i < m; i++) {
l = max(l, L.at(i));
r = min(r, R.at(i));
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i >= l && i <= r) {
ans++;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
int l = 0, r = 999999;
for (int i = 0; i < m; i++) {
l = max(l, L.at(i));
r = min(r, R.at(i));
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (i >= l && i <= r) {
ans++;
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 850,209 | 850,208 | u856957535 | cpp |
p03037 | #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
void scan() {
#ifdef NURS
freopen("main.in", "r", stdin);
freopen("main.out", "w", stdout);
#endif
}
const int N = 1e6 + 500;
const int mod = 1e9 + 7;
int pref[N];
int main() {
scan();
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
pref[l]++;
pref[r + 1]--;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
pref[i] += pref[i - 1];
if (pref[i] == n) {
ans++;
}
}
cout << ans;
}
// JUDGE_ID: 295965SY
// Tis I | #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
void scan() {
#ifdef NURS
freopen("main.in", "r", stdin);
freopen("main.out", "w", stdout);
#endif
}
const int N = 1e6 + 500;
const int mod = 1e9 + 7;
int pref[N];
int main() {
scan();
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
pref[l]++;
pref[r + 1]--;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
pref[i] += pref[i - 1];
if (pref[i] == m) {
ans++;
}
}
cout << ans;
}
// JUDGE_ID: 295965SY
// Tis I | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 850,210 | 850,211 | u165212329 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++)
cin >> l[i] >> r[i];
sort(l, l + m, greater<int>());
sort(r, r + m);
if (r[0] - l[0] > 0)
cout << r[0] - l[0] + 1 << endl;
else
cout << 0 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m], r[m];
for (int i = 0; i < m; i++)
cin >> l[i] >> r[i];
sort(l, l + m, greater<int>());
sort(r, r + m);
if (r[0] - l[0] >= 0)
cout << r[0] - l[0] + 1 << endl;
else
cout << 0 << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,218 | 850,219 | u351148423 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define EACH(i, a, b) for (int i = (a); i <= (b); i++)
#define REACH(i, a, b) for (int i = (b); i >= (a); i--)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define in(a, x, b) ((a) <= (x) && (x) < (b))
const int MOD = 1e9 + 7;
const int INF = 1 << 29;
const double EPS = 1e-10;
using ll = long long;
using P = pair<int, int>;
template <class T = int> using V = vector<T>;
template <class T> bool inline chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool inline chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T = int> T inline input() {
T x;
cin >> x;
return (x);
}
template <class T> void inline print(T &x) { cout << x << '\n'; }
#define debug(x) cerr << #x << ": " << x << endl;
const int dxs[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dys[] = {0, -1, 0, 1, 1, -1, -1, 1};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int L[M], R[M];
REP(i, M) cin >> L[i] >> R[i];
int left_max = *max_element(L, L + M);
int right_min = *min_element(R, R + M);
cout << right_min - left_max + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define EACH(i, a, b) for (int i = (a); i <= (b); i++)
#define REACH(i, a, b) for (int i = (b); i >= (a); i--)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define in(a, x, b) ((a) <= (x) && (x) < (b))
const int MOD = 1e9 + 7;
const int INF = 1 << 29;
const double EPS = 1e-10;
using ll = long long;
using P = pair<int, int>;
template <class T = int> using V = vector<T>;
template <class T> bool inline chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool inline chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T = int> T inline input() {
T x;
cin >> x;
return (x);
}
template <class T> void inline print(T &x) { cout << x << '\n'; }
#define debug(x) cerr << #x << ": " << x << endl;
const int dxs[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dys[] = {0, -1, 0, 1, 1, -1, -1, 1};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int L[M], R[M];
REP(i, M) cin >> L[i] >> R[i];
int left_max = *max_element(L, L + M);
int right_min = *min_element(R, R + M);
cout << max(right_min - left_max + 1, 0) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 850,226 | 850,227 | u616360029 | cpp |
p03037 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define pi 3.14159265359
#define all(i) i.begin(), i.end()
using namespace std;
const long long INF = 1e9 + 7;
const string alp = "abcdefghijklmnopqrstuvwxyz"; // 26
const string ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
// const ll MOD=998244353LL;
// const ll MOD=1777777777LL;
int main() {
ll N, M;
cin >> N >> M;
ll L[M], R[M];
rep(i, M) cin >> L[i] >> R[i];
ll mi = 1;
ll ma = M;
for (int i = 0; i < M; i++) {
mi = max(mi, L[i]);
ma = min(ma, R[i]);
}
ll ans = 0;
if (mi <= ma)
ans = ma - mi + 1;
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define pi 3.14159265359
#define all(i) i.begin(), i.end()
using namespace std;
const long long INF = 1e9 + 7;
const string alp = "abcdefghijklmnopqrstuvwxyz"; // 26
const string ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
// const ll MOD=998244353LL;
// const ll MOD=1777777777LL;
int main() {
ll N, M;
cin >> N >> M;
ll L[M], R[M];
rep(i, M) cin >> L[i] >> R[i];
ll mi = 1;
ll ma = N;
for (int i = 0; i < M; i++) {
mi = max(mi, L[i]);
ma = min(ma, R[i]);
}
ll ans = 0;
if (mi <= ma)
ans = ma - mi + 1;
cout << ans << endl;
}
| [
"variable_declaration.value.change",
"identifier.change"
] | 850,239 | 850,240 | u251242696 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mxn = 5e5 + 5;
#define mod 1000000007
#define endl '\n'
void rishabh() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
rishabh();
int n, m;
cin >> n >> m;
int x, y;
x = -1e6, y = 1e6;
for (int i = 0; i < m; i++) {
int p, q;
cin >> p >> q;
x = max(p, x);
y = min(y, q);
}
if (y - x + 1)
cout << y - x + 1;
else
cout << 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mxn = 5e5 + 5;
#define mod 1000000007
#define endl '\n'
void rishabh() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
rishabh();
int n, m;
cin >> n >> m;
int x, y;
x = -1e6, y = 1e6;
for (int i = 0; i < m; i++) {
int p, q;
cin >> p >> q;
x = max(p, x);
y = min(y, q);
}
if (y - x + 1 >= 0)
cout << y - x + 1;
else
cout << 0;
}
| [
"control_flow.branch.if.condition.change"
] | 850,246 | 850,247 | u577654787 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
vector<int> L(100010), R(100010);
cin >> N >> M;
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
int left = 1;
int right = N;
for (int i = 0; i < M; i++) {
left = max(left, L[i]);
right = min(right, R[i]);
}
cout << right - left + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
vector<int> L(100010), R(100010);
cin >> N >> M;
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
int left = 1;
int right = N;
for (int i = 0; i < M; i++) {
left = max(left, L[i]);
right = min(right, R[i]);
}
cout << max(0, right - left + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,258 | 850,259 | u285358283 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M, l, r, ans;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
cin >> L[0] >> R[0];
l = L[0];
r = R[0];
for (int i = 1; i < M; i++) {
cin >> L[i] >> R[i];
l = max(l, L[i]);
r = min(r, R[i]);
}
ans = r - l + 1;
if (ans > N) {
ans = N;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M, l, r, ans;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
cin >> L[0] >> R[0];
l = L[0];
r = R[0];
for (int i = 1; i < M; i++) {
cin >> L[i] >> R[i];
l = max(l, L[i]);
r = min(r, R[i]);
}
ans = r - l + 1;
if (0 > ans) {
ans = 0;
}
cout << ans << endl;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change",
"identifier.change",
"assignment.value.change"
] | 850,276 | 850,277 | u066538689 | cpp |
p03037 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int MAX = 510000;
ll dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << endl;
}
const int mod = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
ll mn = inf, mx = 0;
rep(i, m) {
ll l, r;
cin >> l >> r;
chmax(mx, l);
chmin(mn, r);
}
cout << mn - mx + 1 << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int MAX = 510000;
ll dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << endl;
}
const int mod = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
ll mn = inf, mx = 0;
rep(i, m) {
ll l, r;
cin >> l >> r;
chmax(mx, l);
chmin(mn, r);
}
cout << max(0LL, mn - mx + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,278 | 850,279 | u242679311 | cpp |
p03037 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <set>
#include <string>
#include <vector>
typedef long long ll;
#define LL_MAX (1 << 30)
using namespace std;
int main() {
ll n, m;
vector<ll> r;
vector<ll> l;
cin >> n >> m;
ll tmp;
for (ll i = 0; i < m; i++) {
cin >> tmp, l.push_back(--tmp);
cin >> tmp, r.push_back(--tmp);
}
vector<ll> gate(n, 0);
ll _min(-LL_MAX), _max(LL_MAX);
for (ll i = 0; i < m; i++)
_min = max(_min, l[i]), _max = min(_max, r[i]);
ll ans(0);
if (_max > _min)
ans = _max - _min + 1;
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <set>
#include <string>
#include <vector>
typedef long long ll;
#define LL_MAX (1 << 30)
using namespace std;
int main() {
ll n, m;
vector<ll> r;
vector<ll> l;
cin >> n >> m;
ll tmp;
for (ll i = 0; i < m; i++) {
cin >> tmp, l.push_back(--tmp);
cin >> tmp, r.push_back(--tmp);
}
vector<ll> gate(n, 0);
ll _min(-LL_MAX), _max(LL_MAX);
for (ll i = 0; i < m; i++)
_min = max(_min, l[i]), _max = min(_max, r[i]);
ll ans(0);
if (_max >= _min)
ans = _max - _min + 1;
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,280 | 850,281 | u778668639 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
//#define int long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
signed main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
rep(i, M) cin >> L[i] >> R[i];
int left = L[0];
int right = R[0];
rep(i, M - 1) {
left = max(L[i + 1], left);
right = min(R[i + 1], right);
}
cout << right - left + 1;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
//#define int long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
signed main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
rep(i, M) cin >> L[i] >> R[i];
int left = L[0];
int right = R[0];
rep(i, M - 1) {
left = max(L[i + 1], left);
right = min(R[i + 1], right);
}
cout << max(right - left + 1, 0);
} | [
"call.add",
"call.arguments.add"
] | 850,296 | 850,297 | u697090185 | cpp |
p03037 | #define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, n) for (ll i##_len = (n), i = i##_len - 1; i >= 0; --i)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define printd(val) std::cout << #val " = " << val << "\n";
#define lim 1000000007ll
#include <bits/stdc++.h>
using ll = long long;
using pii = std::pair<ll, ll>;
using namespace std;
template <class T> T chmin(T &a, T b) {
if (a > b) {
a ^= b;
b ^= a;
a ^= b;
return 1;
}
return 0;
}
template <class T> T chmax(T &b, T a) {
if (a > b) {
a ^= b;
b ^= a;
a ^= b;
return 1;
}
return 0;
}
template <class T> T gcd(T a, T b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
template <class T> T lcm(T a, T b) { return a * b / gcd(a, b); }
template <class T> vector<pair<T, T>> duplicator(const vector<T> &input) {
vector<pair<T, T>> out(input.size() - 1);
rep(i, input.size() - 1) {
out[i].first = input[i];
out[i].second = input[i + 1];
}
return (out);
}
vector<char> String_to_vector_char(const string &input) {
vector<char> out(input.size());
rep(i, input.size()) { out[i] = input[i]; }
return out;
}
inline bool operator<(const pii &lhs, const pii &rhs) {
return (lhs.first < rhs.first);
}
int n, m;
vector<int> L, R;
void input() {
cin >> n >> m;
int l, r;
rep(i, m) {
cin >> l >> r;
L.push_back(l);
R.push_back(r);
}
}
void src() {
int count = 0;
cout << *min_element(R.begin(), R.end()) - *max_element(L.begin(), L.end()) +
1;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
// ifstream in( argv[1] ); cin.rdbuf(in.rdbuf());
input();
src();
return 0;
} | #define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, n) for (ll i##_len = (n), i = i##_len - 1; i >= 0; --i)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define printd(val) std::cout << #val " = " << val << "\n";
#define lim 1000000007ll
#include <bits/stdc++.h>
using ll = long long;
using pii = std::pair<ll, ll>;
using namespace std;
template <class T> T chmin(T &a, T b) {
if (a > b) {
a ^= b;
b ^= a;
a ^= b;
return 1;
}
return 0;
}
template <class T> T chmax(T &b, T a) {
if (a > b) {
a ^= b;
b ^= a;
a ^= b;
return 1;
}
return 0;
}
template <class T> T gcd(T a, T b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
template <class T> T lcm(T a, T b) { return a * b / gcd(a, b); }
template <class T> vector<pair<T, T>> duplicator(const vector<T> &input) {
vector<pair<T, T>> out(input.size() - 1);
rep(i, input.size() - 1) {
out[i].first = input[i];
out[i].second = input[i + 1];
}
return (out);
}
vector<char> String_to_vector_char(const string &input) {
vector<char> out(input.size());
rep(i, input.size()) { out[i] = input[i]; }
return out;
}
inline bool operator<(const pii &lhs, const pii &rhs) {
return (lhs.first < rhs.first);
}
int n, m;
vector<int> L, R;
void input() {
cin >> n >> m;
int l, r;
rep(i, m) {
cin >> l >> r;
L.push_back(l);
R.push_back(r);
}
}
void src() {
int count = 0;
cout << max(*min_element(R.begin(), R.end()) -
*max_element(L.begin(), L.end()) + 1,
0);
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
// ifstream in( argv[1] ); cin.rdbuf(in.rdbuf());
input();
src();
return 0;
} | [
"call.add",
"call.arguments.change",
"call.arguments.add"
] | 850,298 | 850,299 | u954176652 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, L, R, MIN = 1e9, MAX = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> L >> R;
MAX = max(MAX, L);
MIN = min(MIN, R);
}
cout << MIN - MAX + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, L, R, MIN = 1e9, MAX = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> L >> R;
MAX = max(MAX, L);
MIN = min(MIN, R);
}
cout << max(0, MIN - MAX + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 850,300 | 850,301 | u675509234 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> left(M);
vector<int> right(M);
for (int i = 0; i < M; i++) {
cin >> left[i];
cin >> right[i];
}
sort(left.begin(), left.end());
reverse(left.begin(), left.end());
sort(right.begin(), right.end());
if (right[0] + 1 > left[0]) {
cout << right[0] + 1 - left[0] << endl;
} else {
cout << 9 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> left(M);
vector<int> right(M);
for (int i = 0; i < M; i++) {
cin >> left[i];
cin >> right[i];
}
sort(left.begin(), left.end());
reverse(left.begin(), left.end());
sort(right.begin(), right.end());
if (right[0] + 1 > left[0]) {
cout << right[0] + 1 - left[0] << endl;
} else {
cout << 0 << endl;
}
}
| [
"literal.number.change",
"io.output.change"
] | 850,313 | 850,314 | u762502257 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
static int n, m;
static int l[100010], r[100010];
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
}
int MIN = 1, MAX = n;
for (int i = 1; i <= m; i++) {
MIN = max(MIN, l[i]);
MAX = min(MAX, r[i]);
}
cout << MAX - MIN + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
static int n, m;
static int l[100010], r[100010];
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
}
int MIN = 1, MAX = n;
for (int i = 1; i <= m; i++) {
MIN = max(MIN, l[i]);
MAX = min(MAX, r[i]);
}
cout << max(0, MAX - MIN + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,319 | 850,320 | u957457849 | cpp |
p03037 | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int l, r, n, m;
int main() {
scanf("%d%d", &n, &m);
scanf("%d%d", &l, &r);
for (int i = 1; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
l = max(x, l);
r = max(y, r);
}
printf("%d\n", r >= l ? r - l + 1 : 0);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int l, r, n, m;
int main() {
scanf("%d%d", &n, &m);
scanf("%d%d", &l, &r);
for (int i = 1; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
l = max(x, l);
r = min(y, r);
}
printf("%d\n", r >= l ? r - l + 1 : 0);
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 850,325 | 850,326 | u427571081 | cpp |
p03037 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX(x, y) (x > y ? x : y)
#define MIN(x, y) (x < y ? x : y)
#define ABS(x) (x > 0 ? x : -(x))
int main() {
int N, M;
int L[100000];
int R[100000];
int max, min;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++)
scanf("%d%d", &L[i], &R[i]);
min = 1, max = N;
for (int i = 0; i < M; i++) {
if (L[i] > i)
min = L[i];
if (R[i] < max)
max = R[i];
}
if (max - min + 1 > 0)
printf("%d", max - min + 1);
else
printf("0\n");
} | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX(x, y) (x > y ? x : y)
#define MIN(x, y) (x < y ? x : y)
#define ABS(x) (x > 0 ? x : -(x))
int main() {
int N, M;
int L[100000];
int R[100000];
int max, min;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++)
scanf("%d%d", &L[i], &R[i]);
min = 1, max = N;
for (int i = 0; i < M; i++) {
if (L[i] > min)
min = L[i];
if (R[i] < max)
max = R[i];
}
if (max - min + 1 > 0)
printf("%d", max - min + 1);
else
printf("0\n");
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 850,333 | 850,334 | u314920173 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
cout << r[0] - l[m - 1] + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
cout << max(0, r[0] - l[m - 1] + 1) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 850,343 | 850,344 | u180716041 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a, b;
cin >> a >> b;
for (int i = 0; i < m - 1; i++) {
int c;
cin >> c;
a = max(a, c);
int d;
cin >> d;
b = min(b, d);
}
cout << max(0, b - a) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a, b;
cin >> a >> b;
for (int i = 0; i < m - 1; i++) {
int c;
cin >> c;
a = max(a, c);
int d;
cin >> d;
b = min(b, d);
}
cout << max(0, b - a + 1) << endl;
} | [
"expression.operation.binary.add"
] | 850,345 | 850,346 | u356701928 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int ans1 = 0;
int ans2 = 10000;
for (int i = 0; i < m; i++) {
cin >> l.at(i) >> r.at(i);
ans1 = max(ans1, l.at(i));
ans2 = min(ans2, r.at(i));
}
if (ans2 - ans1 < 0) {
cout << 0 << endl;
} else {
cout << ans2 - ans1 + 1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int ans1 = 0;
int ans2 = 1000000;
for (int i = 0; i < m; i++) {
cin >> l.at(i) >> r.at(i);
ans1 = max(ans1, l.at(i));
ans2 = min(ans2, r.at(i));
}
if (ans2 - ans1 < 0) {
cout << 0 << endl;
} else {
cout << ans2 - ans1 + 1 << endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 850,363 | 850,364 | u955282280 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int ans1 = 0;
int ans2 = 10000;
for (int i = 0; i < m; i++) {
cin >> l.at(i) >> r.at(i);
ans1 = max(ans1, l.at(i));
ans2 = min(ans2, r.at(i));
}
if (ans2 - ans1 < 0) {
cout << 0 << endl;
} else {
cout << ans2 - ans1 + 1 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int ans1 = 0;
int ans2 = 1000000;
for (int i = 0; i < m; i++) {
cin >> l.at(i) >> r.at(i);
ans1 = max(ans1, l.at(i));
ans2 = min(ans2, r.at(i));
}
if (ans2 - ans1 < 0) {
cout << 0 << endl;
} else {
cout << ans2 - ans1 + 1 << endl;
}
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 850,365 | 850,364 | u955282280 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
vector<int> A(N);
for (int i = 0; i < N; ++i) {
A[i] = i + 1;
}
int num = 1e7;
int num2 = -1;
int num3 = 0;
for (int i = 0; i < M; ++i) {
cin >> L[i];
cin >> R[i];
}
for (int i = 0; i < M; ++i) {
num = min(num, R[i]);
}
for (int j = 0; j < M; ++j) {
num2 = max(num2, L[j]);
}
for (int i = 0; i < N; ++i) {
if (A[i] >= num && A[i] <= num2) {
num3++;
}
}
cout << num3 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
vector<int> A(N);
for (int i = 0; i < N; ++i) {
A[i] = i + 1;
}
int num = 1e7;
int num2 = -1;
int num3 = 0;
for (int i = 0; i < M; ++i) {
cin >> L[i];
cin >> R[i];
}
for (int i = 0; i < M; ++i) {
num = min(num, R[i]);
}
for (int j = 0; j < M; ++j) {
num2 = max(num2, L[j]);
}
for (int i = 0; i < N; ++i) {
if (A[i] >= num2 && A[i] <= num) {
num3++;
}
}
cout << num3 << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 850,369 | 850,370 | u091026689 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
vector<int> A(N);
for (int i = 0; i < N; ++i) {
A[i] = i + 1;
}
int num = 1e7;
int num2 = -1;
int num3 = 0;
for (int i = 0; i < M; ++i) {
cin >> L[i];
cin >> R[i];
}
for (int i = 0; i < M; ++i) {
num = min(num, A[i]);
}
for (int j = 0; j < M; ++j) {
num2 = max(num2, A[j]);
}
for (int i = 0; i < N; ++i) {
if (A[i] >= num && A[i] <= num2) {
num3++;
}
}
cout << num3 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
vector<int> A(N);
for (int i = 0; i < N; ++i) {
A[i] = i + 1;
}
int num = 1e7;
int num2 = -1;
int num3 = 0;
for (int i = 0; i < M; ++i) {
cin >> L[i];
cin >> R[i];
}
for (int i = 0; i < M; ++i) {
num = min(num, R[i]);
}
for (int j = 0; j < M; ++j) {
num2 = max(num2, L[j]);
}
for (int i = 0; i < N; ++i) {
if (A[i] >= num2 && A[i] <= num) {
num3++;
}
}
cout << num3 << endl;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 850,371 | 850,370 | u091026689 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define what_is(x) cerr << #x << " is " << x << endl;
#define what_is_v(x) \
cerr << #x << " is "; \
for (auto &e : (x)) \
cerr << e << ' '; \
cerr << '\n'; // vector, set
#define what_is_a(x, n) \
cerr << #x << " is "; \
for (int i = 0; i < n; i++) \
cerr << x[i] << ' '; \
cerr << '\n'; // n first element of array
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define st first
#define nd second
#define cerr_pair(x) '{' << x.st << ", " << x.nd << '}'
#define pwhat_is(x) cerr << #x << " is " << cerr_pair(x) << endl;
#define pwhat_is_v(x) \
cerr << #x << " is "; \
for (auto &e : (x)) \
cerr << cerr_pair(e) << ' '; \
cerr << '\n'; // vector, set
#define pwhat_is_a(x, n) \
cerr << #x << " is "; \
for (int i = 0; i < n; i++) \
cerr << cerr_pair(x[i]) << ' '; \
cerr << '\n'; // n first element of array
#define endl '\n'
// #define int long long
typedef pair<int, int> pii;
const int N = 1e5 + 5;
const int M = 1e5 + 5;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n, m;
int l[M], r[M];
int32_t main() {
IOS
// freopen("input.txt", "r", stdin);
cin >>
n >> m;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int L = l[0], R = r[0];
for (int i = 1; i < m; i++) {
L = max(L, l[i]);
R = min(R, r[i]);
}
int ans = R - L + 1;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define what_is(x) cerr << #x << " is " << x << endl;
#define what_is_v(x) \
cerr << #x << " is "; \
for (auto &e : (x)) \
cerr << e << ' '; \
cerr << '\n'; // vector, set
#define what_is_a(x, n) \
cerr << #x << " is "; \
for (int i = 0; i < n; i++) \
cerr << x[i] << ' '; \
cerr << '\n'; // n first element of array
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define st first
#define nd second
#define cerr_pair(x) '{' << x.st << ", " << x.nd << '}'
#define pwhat_is(x) cerr << #x << " is " << cerr_pair(x) << endl;
#define pwhat_is_v(x) \
cerr << #x << " is "; \
for (auto &e : (x)) \
cerr << cerr_pair(e) << ' '; \
cerr << '\n'; // vector, set
#define pwhat_is_a(x, n) \
cerr << #x << " is "; \
for (int i = 0; i < n; i++) \
cerr << cerr_pair(x[i]) << ' '; \
cerr << '\n'; // n first element of array
#define endl '\n'
// #define int long long
typedef pair<int, int> pii;
const int N = 1e5 + 5;
const int M = 1e5 + 5;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n, m;
int l[M], r[M];
int32_t main() {
IOS
// freopen("input.txt", "r", stdin);
cin >>
n >> m;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
int L = l[0], R = r[0];
for (int i = 1; i < m; i++) {
L = max(L, l[i]);
R = min(R, r[i]);
}
int ans = max(0, R - L + 1);
cout << ans << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 850,374 | 850,375 | u411771230 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; ++i) {
cin >> L.at(i) >> R.at(i);
}
sort(L.begin(), L.end(), greater<int>());
sort(R.begin(), R.end());
cout << min(N, R.at(0)) - L.at(0) + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; ++i) {
cin >> L.at(i) >> R.at(i);
}
sort(L.begin(), L.end(), greater<int>());
sort(R.begin(), R.end());
cout << max(0, min(N, R.at(0)) - L.at(0) + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 850,376 | 850,377 | u304862095 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct node {
int l, r;
};
int m, n;
node a[maxn];
int kq;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++)
cin >> a[i].l >> a[i].r;
int L = 0;
for (int i = 1; i <= m; i++)
L = max(L, a[i].l);
int R = n + 1;
for (int i = 1; i <= m; i++)
R = min(R, a[i].r);
kq = R - L + 1;
cout << kq;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct node {
int l, r;
};
int m, n;
node a[maxn];
int kq;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++)
cin >> a[i].l >> a[i].r;
int L = 0;
for (int i = 1; i <= m; i++)
L = max(L, a[i].l);
int R = n + 1;
for (int i = 1; i <= m; i++)
R = min(R, a[i].r);
kq = max(0, R - L + 1);
cout << kq;
}
| [
"call.add",
"call.arguments.change"
] | 850,378 | 850,379 | u013476277 | cpp |
p03037 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x) * (x))
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vi>
typedef long long ll;
int main() {
int N, M, max_L = 0, min_R = 1000000;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
max_L = max(max_L, L);
min_R = min(min_R, R);
}
cout << min_R - max_L + 1 << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define sqr(x) ((x) * (x))
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vi>
typedef long long ll;
int main() {
int N, M, max_L = 0, min_R = 1000000;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
max_L = max(max_L, L);
min_R = min(min_R, R);
}
cout << max(min_R - max_L + 1, 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,380 | 850,381 | u346180161 | cpp |
p03037 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define print(x) cout << (x) << endl
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define INF10 1001001001
#define INF5 100000
#define EPS 1e-10
int main() {
int N, M;
cin >> N >> M;
vector<bool> card(N);
REP(i, N) { card[i] = true; }
int left = 0, right = N - 1;
REP(i, M) {
int l, r;
cin >> l >> r;
l--;
r--;
if (left < l)
left = l;
if (right > r)
right = r;
}
print(right - left + 1);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define print(x) cout << (x) << endl
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define INF10 1001001001
#define INF5 100000
#define EPS 1e-10
int main() {
int N, M;
cin >> N >> M;
vector<bool> card(N);
REP(i, N) { card[i] = true; }
int left = 0, right = N - 1;
REP(i, M) {
int l, r;
cin >> l >> r;
l--;
r--;
if (left < l)
left = l;
if (right > r)
right = r;
}
print(max(0, right - left + 1));
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 850,382 | 850,383 | u301893320 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(n);
vector<int> r(n);
int mal = 0;
int mar = 0;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
mal = max(mal, l[i]);
mar = max(mar, r[i]);
}
if (mal <= mar) {
cout << mar - mal + 1 << endl;
} else {
cout << 0 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int mal = 0;
int mar = 10000000;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
mal = max(mal, l[i]);
mar = min(mar, r[i]);
}
if (mal <= mar) {
cout << mar - mal + 1 << endl;
} else {
cout << 0 << endl;
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 850,388 | 850,387 | u103850114 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int i, j, cnt;
int n, m;
cin >> n >> m;
int L[m], R[m];
for (i = 0; i < m; i++)
cin >> L[i] >> R[i];
int maL = 0, miR = 1000000;
for (i = 0; i < m; i++) {
maL = max(maL, L[i]);
miR = min(miR, R[i]);
}
cout << miR - maL + 1;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int i, j, cnt;
int n, m;
cin >> n >> m;
int L[m], R[m];
for (i = 0; i < m; i++)
cin >> L[i] >> R[i];
int maL = 0, miR = 1000000;
for (i = 0; i < m; i++) {
maL = max(maL, L[i]);
miR = min(miR, R[i]);
}
cout << max(0, miR - maL + 1);
} | [
"call.add",
"call.arguments.change"
] | 850,389 | 850,390 | u952130512 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int i, j, cnt;
int n, m;
cin >> n >> m;
int L[m], R[m];
for (i = 0; i < m; i++)
cin >> L[i] >> R[i];
int maL = 0, miR = 1000000;
for (i = 0; i < m; i++) {
maL = max(maL, L[i]);
miR = min(miR, R[i]);
}
cout << min(miR - maL + 1, n);
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int i, j, cnt;
int n, m;
cin >> n >> m;
int L[m], R[m];
for (i = 0; i < m; i++)
cin >> L[i] >> R[i];
int maL = 0, miR = 1000000;
for (i = 0; i < m; i++) {
maL = max(maL, L[i]);
miR = min(miR, R[i]);
}
cout << max(0, miR - maL + 1);
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"call.arguments.add",
"call.arguments.change"
] | 850,391 | 850,390 | u952130512 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int ans = min(*min_element(R.begin(), R.end()) -
*max_element(L.begin(), L.end()) + 1,
0);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int ans = max(*min_element(R.begin(), R.end()) -
*max_element(L.begin(), L.end()) + 1,
0);
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change"
] | 850,394 | 850,395 | u976833038 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int ans =
*min_element(R.begin(), R.end()) - *max_element(L.begin(), L.end()) + 1;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int ans = max(*min_element(R.begin(), R.end()) -
*max_element(L.begin(), L.end()) + 1,
0);
cout << ans << endl;
return 0;
} | [
"call.add",
"call.arguments.change",
"call.arguments.add"
] | 850,396 | 850,395 | u976833038 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int a, b, c, d;
a = 1;
b = N;
for (int i = 0; i < M; i++) {
cin >> c >> d;
if (a < c)
a = c;
if (d < b)
b = d;
}
cout << b - a + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int a, b, c, d;
a = 1;
b = N;
for (int i = 0; i < M; i++) {
cin >> c >> d;
if (a < c)
a = c;
if (d < b)
b = d;
}
cout << max(0, b - a + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,397 | 850,398 | u136342563 | cpp |
p03037 | #include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int mins = 1;
int maxs = N;
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
mins = max(mins, L);
maxs = min(maxs, R);
}
cout << maxs - mins + 1 << endl;
return 0;
}
| #include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int mins = 1;
int maxs = N;
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
mins = max(mins, L);
maxs = min(maxs, R);
}
cout << max(0, maxs - mins + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 850,409 | 850,410 | u064359585 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
}
int s = 0;
int t = 0;
for (int i = 0; i < m; i++) {
s = max(s, p[i].first);
t = min(t, p[i].second);
}
int ans = max(t - s + 1, 0);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
}
int s = 0;
int t = n;
for (int i = 0; i < m; i++) {
s = max(s, p[i].first);
t = min(t, p[i].second);
}
int ans = max(t - s + 1, 0);
cout << ans << endl;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 850,422 | 850,423 | u882039496 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
}
int s = 0;
int t = 0;
for (int i = 0; i < m; i++) {
s = max(s, p[i].first);
t = min(t, p[i].second);
}
int ans = max(t - s, 0);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
}
int s = 0;
int t = n;
for (int i = 0; i < m; i++) {
s = max(s, p[i].first);
t = min(t, p[i].second);
}
int ans = max(t - s + 1, 0);
cout << ans << endl;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 850,424 | 850,423 | u882039496 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
typedef long long ll;
const ll INF = 1e17;
const ll BIG = 1000000007;
int main() {
int N, M;
cin >> N >> M;
int x = 1;
int y = N;
for (int i = 1; i <= M; i++) {
int l, r;
cin >> l >> r;
if (l > x) {
x = l;
}
if (r < y) {
y = r;
}
}
cout << y - x + 1;
system("PAUSE");
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
typedef long long ll;
const ll INF = 1e17;
const ll BIG = 1000000007;
int main() {
int N, M;
cin >> N >> M;
int x = 1;
int y = N;
for (int i = 1; i <= M; i++) {
int l, r;
cin >> l >> r;
if (l > x) {
x = l;
}
if (r < y) {
y = r;
}
}
cout << max(0, y - x + 1);
system("PAUSE");
} | [
"call.add",
"call.arguments.change"
] | 850,425 | 850,426 | u004411048 | cpp |
p03037 | #include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#define rep(i, initial_value, max_value) \
for (uint64_t i{initial_value}; i < max_value; ++i)
#define fore(i, a) for (auto &i : a)
#define each(i, c) \
for (__typeof((c).begin()) i{(c).begin()}, \
__typeof((c).end()) end{(c).end()}; \
i != end; ++i)
#define dbg(x) cerr << __LINE__ << ": " << #x << " = " << (x) << endl
#define all(x) (x).begin(), (x).end()
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
using i64 = int64_t;
using i32 = int32_t;
using u64 = unsigned long long;
using u32 = unsigned long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// ===
void _main() {
int n;
int m;
cin >> n >> m;
int L[m];
int R[m];
rep(i, 0, m) cin >> L[i] >> R[i];
// sort(L, L + m, greater<int>());
// sort(R, R + m);
int maxL{1};
int minR{n};
rep(i, 0, m) {
max(maxL, L[i]);
min(minR, R[i]);
}
// int r = R[0];
// chmin(r, n);
//
// int ans = r - L[0] + 1;
// chmax(ans, (int)0);
int ans = minR - maxL + 1;
ans = max(ans, 0);
cout << ans << endl;
} | #include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#define rep(i, initial_value, max_value) \
for (uint64_t i{initial_value}; i < max_value; ++i)
#define fore(i, a) for (auto &i : a)
#define each(i, c) \
for (__typeof((c).begin()) i{(c).begin()}, \
__typeof((c).end()) end{(c).end()}; \
i != end; ++i)
#define dbg(x) cerr << __LINE__ << ": " << #x << " = " << (x) << endl
#define all(x) (x).begin(), (x).end()
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
using i64 = int64_t;
using i32 = int32_t;
using u64 = unsigned long long;
using u32 = unsigned long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// ===
void _main() {
int n;
int m;
cin >> n >> m;
int L[m];
int R[m];
rep(i, 0, m) cin >> L[i] >> R[i];
// sort(L, L + m, greater<int>());
// sort(R, R + m);
int maxL{1};
int minR{n};
rep(i, 0, m) {
maxL = max(maxL, L[i]);
minR = min(minR, R[i]);
}
// int r = R[0];
// chmin(r, n);
//
// int ans = r - L[0] + 1;
// chmax(ans, (int)0);
int ans = minR - maxL + 1;
ans = max(ans, 0);
cout << ans << endl;
} | [
"assignment.change"
] | 850,427 | 850,428 | u955529484 | cpp |
p03037 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
int MX = 0, MN = INF;
rep(i, m) {
int a, b;
cin >> a >> b;
MN = min(b, MN);
MX = max(a, MX);
}
int ans = MN - MX + 1;
cout << ans << endl;
}
| #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
int MX = 0, MN = INF;
rep(i, m) {
int a, b;
cin >> a >> b;
MN = min(b, MN);
MX = max(a, MX);
}
int ans = max(MN - MX + 1, 0);
cout << ans << endl;
}
| [
"call.add",
"call.arguments.add"
] | 850,434 | 850,435 | u516525290 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 99999999
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
template <typename T> std::string to_string(const T &n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> lr(M);
rep(i, M) cin >> lr[i].first >> lr[i].second;
ll left = 0;
ll right = INF;
rep(i, M) {
if (left < lr[i].first)
left = lr[i].first;
if (right > lr[i].second)
right = lr[i].second;
}
// cout << left << " " << right << endl;
if (N < left && left > right) {
cout << 0 << endl;
} else
cout << right - left + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 99999999
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
template <typename T> std::string to_string(const T &n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> lr(M);
rep(i, M) cin >> lr[i].first >> lr[i].second;
ll left = 0;
ll right = INF;
rep(i, M) {
if (left < lr[i].first)
left = lr[i].first;
if (right > lr[i].second)
right = lr[i].second;
}
// cout << left << " " << right << endl;
if (N < left || left > right) {
cout << 0 << endl;
} else
cout << right - left + 1 << endl;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 850,445 | 850,446 | u730271001 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 99999999
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
template <typename T> std::string to_string(const T &n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> lr(M);
rep(i, M) cin >> lr[i].first >> lr[i].second;
ll left = 0;
ll right = INF;
rep(i, M) {
if (left < lr[i].first)
left = lr[i].first;
if (right > lr[i].second)
right = lr[i].second;
}
// cout << left << " " << right << endl;
if (N < left) {
cout << 0 << endl;
} else
cout << right - left + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 99999999
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
template <typename T> std::string to_string(const T &n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> lr(M);
rep(i, M) cin >> lr[i].first >> lr[i].second;
ll left = 0;
ll right = INF;
rep(i, M) {
if (left < lr[i].first)
left = lr[i].first;
if (right > lr[i].second)
right = lr[i].second;
}
// cout << left << " " << right << endl;
if (N < left || left > right) {
cout << 0 << endl;
} else
cout << right - left + 1 << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 850,447 | 850,446 | u730271001 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
#define all(n) begin(n), end(n)
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<char> vchar;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
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;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
int main() {
int N, M;
cin >> N >> M;
int lmax = 0, rmin = INT_MAX;
rep(i, M) {
int l, r;
cin >> l >> r;
chmax(lmax, l);
chmin(rmin, r);
}
cout << rmin - lmax + 1;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
#define all(n) begin(n), end(n)
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<char> vchar;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
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;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
int main() {
int N, M;
cin >> N >> M;
int lmax = 0, rmin = INT_MAX;
rep(i, M) {
int l, r;
cin >> l >> r;
chmax(lmax, l);
chmin(rmin, r);
}
cout << max(rmin - lmax + 1, 0);
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,450 | 850,451 | u987913144 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
#define all(n) begin(n), end(n)
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<char> vchar;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
int main() {
int N, M;
cin >> N >> M;
vint L(M), R(M);
rep(i, M) { cin >> L[i] >> R[i]; }
int lmax = *max_element(all(L));
int rmin = *min_element(all(R));
cout << rmin - lmax + 1;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
#define all(n) begin(n), end(n)
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<char> vchar;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
int main() {
int N, M;
cin >> N >> M;
vint L(M), R(M);
rep(i, M) { cin >> L[i] >> R[i]; }
int lmax = *max_element(all(L));
int rmin = *min_element(all(R));
cout << max(rmin - lmax + 1, 0);
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,452 | 850,453 | u987913144 | cpp |
p03037 | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L = 0, R = N + 1;
for (int i = 0; i < M; i++) {
int l, r;
cin >> l >> r;
L = max(L, l);
R = min(R, r);
}
cout << R - L + 1 << endl;
}
| #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L = 0, R = N + 1;
for (int i = 0; i < M; i++) {
int l, r;
cin >> l >> r;
L = max(L, l);
R = min(R, r);
}
cout << max(0, R - L + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 850,456 | 850,457 | u119098168 | cpp |
p03037 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vv = vector<vector<int>>;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<int> ans(n, 1);
int mn, mx;
rep(i, m) {
int l, r;
cin >> l >> r;
if (i == 0) {
mn = l;
mx = r;
} else {
mn = max(mn, l);
mx = min(mx, r);
}
}
if (mx - mx < 0) {
cout << 0 << endl;
} else {
cout << mx - mn + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vv = vector<vector<int>>;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<int> ans(n, 1);
int mn, mx;
rep(i, m) {
int l, r;
cin >> l >> r;
if (i == 0) {
mn = l;
mx = r;
} else {
mn = max(mn, l);
mx = min(mx, r);
}
}
if (mx - mn < 0) {
cout << 0 << endl;
} else {
cout << mx - mn + 1 << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 850,462 | 850,463 | u548778623 | cpp |
p03037 | #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int l = L.at(0), r = R.at(0);
for (int i = 0; i < M; i++) {
l = max(l, L.at(i));
r = min(r, R.at(i));
}
if (r <= l)
cout << r - l + 1 << endl;
else
cout << 0 << endl;
}
| #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int l = L.at(0), r = R.at(0);
for (int i = 0; i < M; i++) {
l = max(l, L.at(i));
r = min(r, R.at(i));
}
if (l <= r)
cout << r - l + 1 << endl;
else
cout << 0 << endl;
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 850,464 | 850,465 | u455266724 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
rep(i, m) cin >> l[i] >> r[i];
int L = *max_element(l.begin(), l.end());
int R = *min_element(r.begin(), r.end());
int ans = L - R + 1;
if (ans >= 0)
cout << ans;
else
cout << "0";
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
rep(i, m) cin >> l[i] >> r[i];
int L = *max_element(l.begin(), l.end());
int R = *min_element(r.begin(), r.end());
int ans = R - L + 1;
if (ans >= 0)
cout << ans;
else
cout << "0";
} | [
"expression.operation.binary.remove"
] | 850,477 | 850,478 | u928712536 | cpp |
p03037 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define ALL(v) v.begin(), v.end()
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
template <class T> inline T GCD(T a, T b) { return b ? GCD(b, a % b) : a; }
template <class T> inline T LCM(T a, T b) { return a * b / GCD(a, b); }
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
cout << *min_element(ALL(r)) - *max_element(ALL(l)) + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define ALL(v) v.begin(), v.end()
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
template <class T> inline T GCD(T a, T b) { return b ? GCD(b, a % b) : a; }
template <class T> inline T LCM(T a, T b) { return a * b / GCD(a, b); }
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
cout << max(0, *min_element(ALL(r)) - *max_element(ALL(l)) + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 850,479 | 850,480 | u445457059 | cpp |
p03037 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
const double pi = acos(-1.0);
const ll mod = pow(10, 9) + 7;
const ll INF = pow(2, 31) - 1;
using str = string;
typedef pair<int, int> P;
typedef vector<int> vi;
ll gcd(ll a, ll b) {
ll v0 = a, v1 = b, v2 = a % b;
while (v2 != 0) {
v0 = v1;
v1 = v2;
v2 = v0 % v1;
}
return v1;
}
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
int main() {
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
ll l[m], r[m];
rep(i, m) cin >> l[i] >> r[i];
ll ml = l[0], mr = r[0];
rep(i, m) {
ml = max(ml, l[i]);
mr = min(mr, r[i]);
}
if (ml < mr)
cout << 0 << endl;
else
cout << mr - ml + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
const double pi = acos(-1.0);
const ll mod = pow(10, 9) + 7;
const ll INF = pow(2, 31) - 1;
using str = string;
typedef pair<int, int> P;
typedef vector<int> vi;
ll gcd(ll a, ll b) {
ll v0 = a, v1 = b, v2 = a % b;
while (v2 != 0) {
v0 = v1;
v1 = v2;
v2 = v0 % v1;
}
return v1;
}
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
int main() {
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
ll l[m], r[m];
rep(i, m) cin >> l[i] >> r[i];
ll ml = l[0], mr = r[0];
rep(i, m) {
ml = max(ml, l[i]);
mr = min(mr, r[i]);
}
if (mr < ml)
cout << 0 << endl;
else
cout << mr - ml + 1 << endl;
return 0;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 850,481 | 850,482 | u420130252 | cpp |
p03037 | #include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int right = n;
int left = 1;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
left = max(left, l);
right = min(right, r);
}
cout << (right + 1 - left) << endl;
}
| #include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int right = n;
int left = 1;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
left = max(left, l);
right = min(right, r);
}
cout << max(0, (right + 1 - left)) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 850,487 | 850,488 | u537234062 | cpp |
p03037 | #include <bits/stdc++.h>
#define ford(i, a, b) for (int i = (a); i >= b; i--)
#define rep(i, a, b) for (int i = (a); (i) <= (b); (i)++)
#define ll long long
#define re return
#define mp map<int, int>
#define N 200005
using namespace std;
int l[N], r[N];
int main() {
int n, m;
cin >> n >> m;
rep(i, 1, m) cin >> l[i] >> r[i];
sort(l + 1, l + 1 + m);
sort(r + 1, r + 1 + m);
if (r[n + 1] - l[1] + 1 < 0)
cout << 0;
else
cout << r[1] - l[m] + 1;
re 0;
}
| #include <bits/stdc++.h>
#define ford(i, a, b) for (int i = (a); i >= b; i--)
#define rep(i, a, b) for (int i = (a); (i) <= (b); (i)++)
#define ll long long
#define re return
#define mp map<int, int>
#define N 200005
using namespace std;
int l[N], r[N];
int main() {
int n, m;
cin >> n >> m;
rep(i, 1, m) cin >> l[i] >> r[i];
sort(l + 1, l + 1 + m);
sort(r + 1, r + 1 + m);
if (r[1] - l[m] + 1 < 0)
cout << 0;
else
cout << r[1] - l[m] + 1;
re 0;
}
| [
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 850,499 | 850,500 | u796123030 | cpp |
p03037 | #include <algorithm> //辞書順=next_permutation
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <locale>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string> //char 小文字のほうが32大きい
#include <time.h>
#include <utility> //swap=数値交換
#include <vector> //s1.erase(n)=文字列s1の、n文字目以降削除
#define rt "\n"
#define rep(i, n) for (int i = 0; i < n; i++)
#define rop(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define drop(i, n) for (int i = n; 0 < i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << rt; \
else \
cout << "no" << rt;
#define Yes(ans) \
if (ans) \
cout << "Yes" << rt; \
else \
cout << "No" << rt;
#define YES(ans) \
if (ans) \
cout << "YES" << rt; \
else \
cout << "NO" << rt;
#define sec(a, b, ans) \
if (ans) \
cout << a << rt; \
else \
cout << b << rt;
#define vcin(s, n) rep(i, n) cin >> s[i]; // vcin(配列名),(繰り返し回数)
#define sort(s) sort(s.begin(), s.end()) //標準=昇順
#define reve(s) reverse(s.begin(), s.end())
#define asas int ans = 0
#define llcncn llint cnt = 0
#define llasas llint ans = 0
#define str string
#define please return
#define AC 0
#define Rapid \
cin.tie(0); \
ios::sync_with_stdio(false)
#define Pi 3.1415926535897932384626
#define nine 1000000000
using namespace std;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
typedef vector<double> vdou;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<char>> vvchar;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<string>> vvstr;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
unsigned GetDigit(unsigned num) { return std::to_string(num).length(); }
int tow(int n) { // 2のn乗
if (n == 0)
return 1;
int x = tow(n / 2);
x *= x;
if (n % 2 == 1)
x *= 2;
return x; //@domino
}
/*
(char)toupper(a[n])=文字列のn文字目を大文字で出力
pow(a,b)=aのb乗
*/
int a = 0, b = 0, c = 0;
int main(void) {
Rapid; //固定高速
int n, m;
cin >> n >> m;
int big = nine, small = 0;
rep(i, m) {
int l, r;
cin >> l >> r;
big = min(r, big);
small = max(l, small);
}
if (big - small + 1 < 0)
cout << 0 << rt;
cout << big - small + 1 << rt;
please AC;
} | #include <algorithm> //辞書順=next_permutation
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <locale>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string> //char 小文字のほうが32大きい
#include <time.h>
#include <utility> //swap=数値交換
#include <vector> //s1.erase(n)=文字列s1の、n文字目以降削除
#define rt "\n"
#define rep(i, n) for (int i = 0; i < n; i++)
#define rop(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define drop(i, n) for (int i = n; 0 < i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << rt; \
else \
cout << "no" << rt;
#define Yes(ans) \
if (ans) \
cout << "Yes" << rt; \
else \
cout << "No" << rt;
#define YES(ans) \
if (ans) \
cout << "YES" << rt; \
else \
cout << "NO" << rt;
#define sec(a, b, ans) \
if (ans) \
cout << a << rt; \
else \
cout << b << rt;
#define vcin(s, n) rep(i, n) cin >> s[i]; // vcin(配列名),(繰り返し回数)
#define sort(s) sort(s.begin(), s.end()) //標準=昇順
#define reve(s) reverse(s.begin(), s.end())
#define asas int ans = 0
#define llcncn llint cnt = 0
#define llasas llint ans = 0
#define str string
#define please return
#define AC 0
#define Rapid \
cin.tie(0); \
ios::sync_with_stdio(false)
#define Pi 3.1415926535897932384626
#define nine 1000000000
using namespace std;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
typedef vector<double> vdou;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<char>> vvchar;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<string>> vvstr;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
unsigned GetDigit(unsigned num) { return std::to_string(num).length(); }
int tow(int n) { // 2のn乗
if (n == 0)
return 1;
int x = tow(n / 2);
x *= x;
if (n % 2 == 1)
x *= 2;
return x; //@domino
}
/*
(char)toupper(a[n])=文字列のn文字目を大文字で出力
pow(a,b)=aのb乗
*/
int a = 0, b = 0, c = 0;
int main(void) {
Rapid; //固定高速
int n, m;
cin >> n >> m;
int big = nine, small = 0;
rep(i, m) {
int l, r;
cin >> l >> r;
big = min(r, big);
small = max(l, small);
}
if (big - small + 1 < 0)
cout << 0 << rt;
else
cout << big - small + 1 << rt;
please AC;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 850,508 | 850,509 | u742306624 | cpp |
p03037 | #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() {
int n, m;
cin >> n >> m;
int most_left = -1;
int most_right = n + 1;
rep(i, m) {
int lef, rig;
cin >> lef >> rig;
most_left = max(lef, most_left);
most_right = min(rig, most_right);
}
int ans = most_right - most_left + 1;
cout << ans << endl;
} | #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() {
int n, m;
cin >> n >> m;
int most_left = -1;
int most_right = n + 1;
rep(i, m) {
int lef, rig;
cin >> lef >> rig;
most_left = max(lef, most_left);
most_right = min(rig, most_right);
}
int ans = max(most_right - most_left + 1, 0);
cout << ans << endl;
} | [
"call.add",
"call.arguments.add"
] | 850,515 | 850,516 | u868237899 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int maxID = n;
int minID = 1;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
maxID = min(maxID, r);
minID = max(minID, l);
}
cout << maxID - minID + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int maxID = n;
int minID = 1;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
maxID = min(maxID, r);
minID = max(minID, l);
}
cout << max(maxID - minID + 1, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 850,526 | 850,527 | u503841284 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int n, m, l, r, ls, rs;
cin >> n >> m;
ls = 0, rs = n;
rep(i, m) {
cin >> l >> r;
ls = max(ls, l);
rs = min(rs, r);
}
cout << rs - ls + 1;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int n, m, l, r, ls, rs;
cin >> n >> m;
ls = 0, rs = n;
rep(i, m) {
cin >> l >> r;
ls = max(ls, l);
rs = min(rs, r);
}
cout << max(0, rs - ls + 1);
} | [
"call.add",
"call.arguments.change"
] | 850,528 | 850,529 | u983711104 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define ll long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int L[100000];
int R[100000];
int mM = 1;
int Mm = n;
rep(i, m) {
cin >> L[i] >> R[i];
mM = max(mM, L[i]);
Mm = min(Mm, R[i]);
}
if (Mm <= mM) {
cout << "0" << endl;
} else {
cout << Mm - mM + 1 << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define ll long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int L[100000];
int R[100000];
int mM = 1;
int Mm = n;
rep(i, m) {
cin >> L[i] >> R[i];
mM = max(mM, L[i]);
Mm = min(Mm, R[i]);
}
if (Mm < mM) {
cout << "0" << endl;
} else {
cout << Mm - mM + 1 << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,530 | 850,531 | u745267317 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int min = L.at(0);
int max = R.at(0);
for (int i = 0; i < M; i++) {
min = (min >= L.at(i)) ? min : L.at(i);
max = (max >= R.at(i)) ? R.at(i) : max;
}
if (max > min) {
cout << (max - min + 1) << endl;
} else {
cout << 0 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
for (int i = 0; i < M; i++) {
cin >> L.at(i) >> R.at(i);
}
int min = L.at(0);
int max = R.at(0);
for (int i = 0; i < M; i++) {
min = (min >= L.at(i)) ? min : L.at(i);
max = (max >= R.at(i)) ? R.at(i) : max;
}
if (max >= min) {
cout << (max - min + 1) << endl;
} else {
cout << 0 << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,543 | 850,544 | u568010843 | cpp |
p03037 | #include <algorithm>
#include <cstdint>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll ans, mx, mn = 1e8, sum;
int main() {
ll n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
ll a, b;
cin >> a >> b;
mx = max(mx, a);
mn = min(mn, b);
}
cout << (mn - mx) + 1;
}
| #include <algorithm>
#include <cstdint>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll ans, mx, mn = 1e8, sum;
int main() {
ll n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
ll a, b;
cin >> a >> b;
mx = max(mx, a);
mn = min(mn, b);
}
cout << max(0ll, (mn - mx) + 1);
}
| [
"call.add",
"call.arguments.change"
] | 850,545 | 850,546 | u620390714 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[N], R[N];
int LT, RT;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
LT = 1;
RT = N;
for (int i = 0; i < M; i++) {
if (LT <= L[i]) {
LT = L[i];
}
if (RT >= R[i]) {
RT = R[i];
}
// cout << "LT RT " << LT << " " << RT << endl;
}
cout << min(RT - LT + 1, 0) << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[N], R[N];
int LT, RT;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
LT = 1;
RT = N;
for (int i = 0; i < M; i++) {
if (LT <= L[i]) {
LT = L[i];
}
if (RT >= R[i]) {
RT = R[i];
}
// cout << "LT RT " << LT << " " << RT << endl;
}
cout << max(RT - LT + 1, 0) << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 850,553 | 850,554 | u961135803 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[N], R[N];
int LT, RT;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
LT = 1;
RT = N;
for (int i = 0; i < M; i++) {
if (LT <= L[i]) {
LT = L[i];
}
if (RT >= R[i]) {
RT = R[i];
}
// cout << "LT RT " << LT << " " << RT << endl;
}
cout << RT - LT + 1 << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[N], R[N];
int LT, RT;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
LT = 1;
RT = N;
for (int i = 0; i < M; i++) {
if (LT <= L[i]) {
LT = L[i];
}
if (RT >= R[i]) {
RT = R[i];
}
// cout << "LT RT " << LT << " " << RT << endl;
}
cout << max(RT - LT + 1, 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,555 | 850,554 | u961135803 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Vec = vector<ll>;
using VecP = vector<P>;
#define FOR(i, m, n) for (ll(i) = (m); (i) < (n); ++(i))
#define FORN(i, m, n) for (ll(i) = (m); (i) <= (n); ++(i))
#define FORR(i, m, n) for (ll(i) = (m); (i) >= (n); --(i))
#define rep(i, n) FOR(i, 0, n)
#define repn(i, n) FORN(i, 1, n)
#define repr(i, n) FORR(i, n, 0)
#define repnr(i, n) FORR(i, n, 1)
#define co(n) cout << (n) << endl
#define cosp(n) cout << (n) << ' '
#define setp(n) cout << fixed << setprecision(n);
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fs first
#define sc second
const ll INF = 1e9 + 1;
const ll LINF = 1e18 + 1;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const double PI = acos(-1);
const double EPS = 1e-9;
int main(void) {
ll n, m;
cin >> n >> m;
ll maxL = 0, minR = LINF;
rep(i, m) {
ll l, r;
cin >> l >> r;
maxL = (maxL, l);
minR = min(minR, r);
}
co(max(0LL, minR - maxL + 1));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Vec = vector<ll>;
using VecP = vector<P>;
#define FOR(i, m, n) for (ll(i) = (m); (i) < (n); ++(i))
#define FORN(i, m, n) for (ll(i) = (m); (i) <= (n); ++(i))
#define FORR(i, m, n) for (ll(i) = (m); (i) >= (n); --(i))
#define rep(i, n) FOR(i, 0, n)
#define repn(i, n) FORN(i, 1, n)
#define repr(i, n) FORR(i, n, 0)
#define repnr(i, n) FORR(i, n, 1)
#define co(n) cout << (n) << endl
#define cosp(n) cout << (n) << ' '
#define setp(n) cout << fixed << setprecision(n);
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fs first
#define sc second
const ll INF = 1e9 + 1;
const ll LINF = 1e18 + 1;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const double PI = acos(-1);
const double EPS = 1e-9;
int main(void) {
ll n, m;
cin >> n >> m;
ll maxL = 0, minR = LINF;
rep(i, m) {
ll l, r;
cin >> l >> r;
maxL = max(maxL, l);
minR = min(minR, r);
}
co(max(0LL, minR - maxL + 1));
return 0;
}
| [
"call.add"
] | 850,562 | 850,563 | u997368585 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef pair<int, int> P;
int n, m;
int main() {
cin >> n >> m;
int left = 0, right = n;
rep(i, m) {
int l, r;
cin >> l >> r;
l--;
left = max(l, left);
right = min(r, right);
}
cout << right - left << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef pair<int, int> P;
int n, m;
int main() {
cin >> n >> m;
int left = 0, right = n;
rep(i, m) {
int l, r;
cin >> l >> r;
l--;
left = max(l, left);
right = min(r, right);
}
cout << max(right - left, 0) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 850,568 | 850,569 | u389007679 | cpp |
p03037 |
// C - Prison
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const int MOD = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
int max_L = 1;
int min_R = N;
int L, R;
for (int i = 0; i < M; i++) {
cin >> L >> R;
max_L = max(max_L, L);
min_R = min(min_R, R);
}
cout << min_R - max_L + 1 << endl;
return 0;
} |
// C - Prison
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const int MOD = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
int max_L = 1;
int min_R = N;
int L, R;
for (int i = 0; i < M; i++) {
cin >> L >> R;
max_L = max(max_L, L);
min_R = min(min_R, R);
}
cout << max(min_R - max_L + 1, 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,588 | 850,589 | u790272146 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m] = {};
int r[m] = {};
int lmax = 0, rmin = 1000000;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
lmax = max(l[i], lmax);
rmin = min(r[i], rmin);
}
cout << rmin - lmax + 1;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[m] = {};
int r[m] = {};
int lmax = 0, rmin = 1000000;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
lmax = max(l[i], lmax);
rmin = min(r[i], rmin);
}
cout << max(0, rmin - lmax + 1);
}
| [
"call.add",
"call.arguments.change"
] | 850,601 | 850,602 | u924373338 | cpp |
p03037 | #include <bits/stdc++.h>
#define sz(arr) (int)(arr).size()
#define rng(arr) arr.begin(), arr.end()
#define show(x) cout << #x << " = " << x << endl;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
void _cin() {}
template <class Head, class... Tail> void _cin(Head &&head, Tail &&...tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
for (int i = 0; i < n; ++i) \
cin >> xs[i]
void Main();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
Main();
return 0;
}
void Main() {
Cin(int, n, m);
int min = 0, max = 1001001001;
rep(i, m) {
Cin(int, l, r);
min = ::max(min, l);
max = ::min(max, r);
}
int ans = ::max(0, max - min + 1);
cout << ::min(n, 0) << endl;
} | #include <bits/stdc++.h>
#define sz(arr) (int)(arr).size()
#define rng(arr) arr.begin(), arr.end()
#define show(x) cout << #x << " = " << x << endl;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
void _cin() {}
template <class Head, class... Tail> void _cin(Head &&head, Tail &&...tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
for (int i = 0; i < n; ++i) \
cin >> xs[i]
void Main();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
Main();
return 0;
}
void Main() {
Cin(int, n, m);
int min = 0, max = 1001001001;
rep(i, m) {
Cin(int, l, r);
min = std::max(min, l);
max = std::min(max, r);
}
int ans = std::max(0, max - min + 1);
cout << std::min(n, ans) << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 850,611 | 850,612 | u994307795 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using ll = long long;
using VI = vector<int>;
using VVI = vector<vector<int>>;
int main() {
int n, m;
cin >> n >> m;
VI l(m), r(m);
rep(i, m) { cin >> l[i] >> r[i]; }
int left = 0, right = n + 1;
rep(i, m) {
left = max(left, l[i]);
right = min(right, r[i]);
}
cout << (right - left + 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using ll = long long;
using VI = vector<int>;
using VVI = vector<vector<int>>;
int main() {
int n, m;
cin >> n >> m;
VI l(m), r(m);
rep(i, m) { cin >> l[i] >> r[i]; }
int left = 0, right = n + 1;
rep(i, m) {
left = max(left, l[i]);
right = min(right, r[i]);
}
cout << max(0, (right - left + 1)) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 850,622 | 850,623 | u491314298 | cpp |
p03037 | /*
27 January 2020
islingr
*/
#pragma region Boilerplate
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define rep(i, a, b) for (auto i = (a); i < (b); ++i) // [a, b)
#define per(i, a, b) for (auto i = (b)-1; i >= (a); --i) // (b, a]
#define trav(e, x) for (auto &e : x)
template <class T> bool ckmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template <class T> bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ook order_of_key
#define fbo find_by_order
namespace helper {
template <class T, class = decltype(begin(declval<T>()))>
inline constexpr auto is_iterable(int) {
return true_type{};
}
template <class> inline constexpr auto is_iterable(unsigned) {
return false_type{};
}
} // namespace helper
namespace input {
void re(string &s) { cin >> s; }
template <class T> void re(T &x);
template <class P, class Q> void re(pair<P, Q> &);
template <class T, class... Ts> void re(T &t, Ts &...ts);
template <class T> void re(T &x, false_type) { cin >> x; }
template <class T> void re(T &x, true_type) {
for (auto &v : x)
re(v);
}
template <class T> void re(T &x) { re(x, helper::is_iterable<T>(0)); }
template <class P, class Q> void re(pair<P, Q> &p) { re(p.first, p.second); }
template <class T, class... Ts> void re(T &t, Ts &...ts) {
re(t);
re(ts...);
}
} // namespace input
namespace output {
template <typename T> void pr(const T &);
template <class T, class... Ts> void pr(const T &, const Ts &...);
template <class S, class T> void pr(const pair<S, T> &p) {
pr("(", p.first, ",", p.second, ")");
}
template <class T> void pr(queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.front()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(priority_queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.top()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(stack<T> s) {
pr("{");
bool c = false;
while (!s.empty())
pr(c ? ", " : "", s.top()), s.pop(), c = true;
pr("}");
}
void pr(const string &s) { cout << s; }
template <typename T> void pr(const T &x, false_type) { cout << x; }
template <typename T> void pr(const T &x, true_type) {
pr("{");
bool f = false;
for (const auto &v : x)
pr(f ? ", " : "", v), f = true;
pr("}");
}
template <typename T> void pr(const T &x) { pr(x, helper::is_iterable<T>(0)); }
template <class T, class... Ts> void pr(const T &t, const Ts &...ts) {
pr(t);
pr(ts...);
}
void pc() { pr("]\n"); } // debug w/ commas
template <class T, class... Ts> void pc(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(", ");
pc(ts...);
}
#define dbg(x...) pr("[", #x, "] = ["), pc(x);
} // namespace output
struct IO {
IO(bool b) {
if (b)
fastio();
cout << fixed << setprecision(numeric_limits<ld>::digits10);
}
IO(bool b, string s) : IO(b) {
setIn(s + ".in");
setOut(s + ".out");
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
};
#pragma endregion
using namespace input;
using namespace output;
IO io = IO(true);
signed main() {
int n, m;
re(n, m);
int l = 1, r = n;
while (m--) {
int a, b;
re(a, b);
ckmax(l, a);
ckmin(r, b);
}
pr(r - l + 1);
} | /*
27 January 2020
islingr
*/
#pragma region Boilerplate
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define rep(i, a, b) for (auto i = (a); i < (b); ++i) // [a, b)
#define per(i, a, b) for (auto i = (b)-1; i >= (a); --i) // (b, a]
#define trav(e, x) for (auto &e : x)
template <class T> bool ckmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template <class T> bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ook order_of_key
#define fbo find_by_order
namespace helper {
template <class T, class = decltype(begin(declval<T>()))>
inline constexpr auto is_iterable(int) {
return true_type{};
}
template <class> inline constexpr auto is_iterable(unsigned) {
return false_type{};
}
} // namespace helper
namespace input {
void re(string &s) { cin >> s; }
template <class T> void re(T &x);
template <class P, class Q> void re(pair<P, Q> &);
template <class T, class... Ts> void re(T &t, Ts &...ts);
template <class T> void re(T &x, false_type) { cin >> x; }
template <class T> void re(T &x, true_type) {
for (auto &v : x)
re(v);
}
template <class T> void re(T &x) { re(x, helper::is_iterable<T>(0)); }
template <class P, class Q> void re(pair<P, Q> &p) { re(p.first, p.second); }
template <class T, class... Ts> void re(T &t, Ts &...ts) {
re(t);
re(ts...);
}
} // namespace input
namespace output {
template <typename T> void pr(const T &);
template <class T, class... Ts> void pr(const T &, const Ts &...);
template <class S, class T> void pr(const pair<S, T> &p) {
pr("(", p.first, ",", p.second, ")");
}
template <class T> void pr(queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.front()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(priority_queue<T> q) {
pr("{");
bool c = false;
while (!q.empty())
pr(c ? ", " : "", q.top()), q.pop(), c = true;
pr("}");
}
template <class T> void pr(stack<T> s) {
pr("{");
bool c = false;
while (!s.empty())
pr(c ? ", " : "", s.top()), s.pop(), c = true;
pr("}");
}
void pr(const string &s) { cout << s; }
template <typename T> void pr(const T &x, false_type) { cout << x; }
template <typename T> void pr(const T &x, true_type) {
pr("{");
bool f = false;
for (const auto &v : x)
pr(f ? ", " : "", v), f = true;
pr("}");
}
template <typename T> void pr(const T &x) { pr(x, helper::is_iterable<T>(0)); }
template <class T, class... Ts> void pr(const T &t, const Ts &...ts) {
pr(t);
pr(ts...);
}
void pc() { pr("]\n"); } // debug w/ commas
template <class T, class... Ts> void pc(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(", ");
pc(ts...);
}
#define dbg(x...) pr("[", #x, "] = ["), pc(x);
} // namespace output
struct IO {
IO(bool b) {
if (b)
fastio();
cout << fixed << setprecision(numeric_limits<ld>::digits10);
}
IO(bool b, string s) : IO(b) {
setIn(s + ".in");
setOut(s + ".out");
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
};
#pragma endregion
using namespace input;
using namespace output;
IO io = IO(true);
signed main() {
int n, m;
re(n, m);
int l = 1, r = n;
while (m--) {
int a, b;
re(a, b);
ckmax(l, a);
ckmin(r, b);
}
pr(max(0, r - l + 1));
} | [
"call.add",
"call.arguments.change"
] | 850,636 | 850,637 | u883745615 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, ma = 1, mi;
cin >> n >> m;
mi = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ma = max(ma, l);
mi = min(mi, r);
}
if (mi <= ma) {
cout << mi - ma + 1 << endl;
} else {
cout << 0 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, ma = 1, mi;
cin >> n >> m;
mi = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ma = max(ma, l);
mi = min(mi, r);
}
if (mi >= ma) {
cout << mi - ma + 1 << endl;
} else {
cout << 0 << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,643 | 850,644 | u442754977 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, ma = 1, mi;
cin >> n >> m;
mi = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ma = max(ma, l);
mi = min(mi, r);
}
if (mi < ma) {
cout << mi - ma + 1 << endl;
} else {
cout << 0 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, ma = 1, mi;
cin >> n >> m;
mi = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ma = max(ma, l);
mi = min(mi, r);
}
if (mi >= ma) {
cout << mi - ma + 1 << endl;
} else {
cout << 0 << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,645 | 850,644 | u442754977 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, ma = 1, mi;
cin >> n >> m;
mi = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ma = max(ma, l);
mi = min(mi, r);
}
if (mi - ma + 1 < 0) {
cout << mi - ma + 1 << endl;
} else {
cout << 0 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r, ma = 1, mi;
cin >> n >> m;
mi = n;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ma = max(ma, l);
mi = min(mi, r);
}
if (mi >= ma) {
cout << mi - ma + 1 << endl;
} else {
cout << 0 << endl;
}
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 850,646 | 850,644 | u442754977 | cpp |
p03037 | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) \
sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SIZE(a) int((a).size())
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_LARGE = 1000000100;
// debug func
template <typename T> void vecprint(vector<T> v) {
for (auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template <typename T> void vecvecprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) { cerr << vv[i][j] << " "; }
cerr << endl;
}
}
template <typename T> void pqprint(priority_queue<T> q) {
while (!q.empty()) {
cerr << q.top() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void qprint(queue<T> q) {
while (!q.empty()) {
cerr << q.front() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void vecqprint(vector<queue<T>> v) {
for (int i = 0; i < v.size(); i++) {
qprint(v[i]);
}
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
/* Credits: Thomas Draper */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
rotate(k, itr2, last);
return true;
}
}
rotate(first, k, last);
return false;
}
inline double get_time_sec(void) {
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count()) /
1000000000;
}
template <typename T> T gcd(T a, T b) {
if (a > b)
swap(a, b);
if (a == 0)
return b;
if (a == 1)
return 1;
else
return gcd(b - a, a);
}
template <typename T> map<T, T> prime_list(T n) {
map<T, T> ret;
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret[i] = 0;
while (n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if (n != 1)
ret[n]++;
return ret;
}
int main(void) {
int n, m;
cin >> n >> m;
int lmax = 0, rmin = INT_MAX;
REP(i, m) {
int l, r;
cin >> l >> r;
if (l > lmax)
lmax = l;
if (rmin > r)
rmin = r;
}
if (rmin > lmax)
cout << 0 << endl;
else
cout << rmin - lmax + 1 << endl;
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) \
sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SIZE(a) int((a).size())
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_LARGE = 1000000100;
// debug func
template <typename T> void vecprint(vector<T> v) {
for (auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template <typename T> void vecvecprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) { cerr << vv[i][j] << " "; }
cerr << endl;
}
}
template <typename T> void pqprint(priority_queue<T> q) {
while (!q.empty()) {
cerr << q.top() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void qprint(queue<T> q) {
while (!q.empty()) {
cerr << q.front() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void vecqprint(vector<queue<T>> v) {
for (int i = 0; i < v.size(); i++) {
qprint(v[i]);
}
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
/* Credits: Thomas Draper */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
rotate(k, itr2, last);
return true;
}
}
rotate(first, k, last);
return false;
}
inline double get_time_sec(void) {
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count()) /
1000000000;
}
template <typename T> T gcd(T a, T b) {
if (a > b)
swap(a, b);
if (a == 0)
return b;
if (a == 1)
return 1;
else
return gcd(b - a, a);
}
template <typename T> map<T, T> prime_list(T n) {
map<T, T> ret;
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret[i] = 0;
while (n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if (n != 1)
ret[n]++;
return ret;
}
int main(void) {
int n, m;
cin >> n >> m;
int lmax = 0, rmin = INT_MAX;
REP(i, m) {
int l, r;
cin >> l >> r;
if (l > lmax)
lmax = l;
if (rmin > r)
rmin = r;
}
if (rmin < lmax)
cout << 0 << endl;
else
cout << rmin - lmax + 1 << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,660 | 850,661 | u637983859 | cpp |
p03037 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <ciso646>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define inf 0x3f3f3f3f3f3f3f3f
#define ALL(a) (a).begin(), (a).end()
#define DEBUG(x) // cerr<<#x<<": "<<x<<endl
#define ll long long
#define ull unsigned long long
using pii = pair<ll, ll>;
#define eps 1e-14
#define SETUP \
cin.tie(0), ios::sync_with_stdio(false), \
cout << setprecision(15) << std::fixed;
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
template <class T> using vec2 = std::vector<vector<T>>;
//// bit ////
#ifdef _MSC_VER
#ifdef _WIN32
inline unsigned int __builtin_ctz(unsigned int x) {
unsigned long r;
_BitScanForward(&r, x);
return r;
}
inline unsigned int __builtin_clz(unsigned int x) {
unsigned long r;
_BitScanReverse(&r, x);
return 31 - r;
}
inline unsigned int __builtin_ffs(unsigned int x) {
unsigned long r;
return _BitScanForward(&r, x) ? r + 1 : 0;
}
// inline unsigned int __builtin_popcount(unsigned int x){ return __popcnt(x); }
#ifdef _WIN64
inline unsigned long long __builtin_ctzll(unsigned long long x) {
unsigned long r;
_BitScanForward64(&r, x);
return r;
}
inline unsigned long long __builtin_clzll(unsigned long long x) {
unsigned long r;
_BitScanReverse64(&r, x);
return 63 - r;
}
inline unsigned long long __builtin_ffsll(unsigned long long x) {
unsigned long r;
return _BitScanForward64(&r, x) ? r + 1 : 0;
}
inline unsigned long long __builtin_popcountll(unsigned long long x) {
return __popcnt64(x);
}
#else
inline unsigned int hidword(unsigned long long x) {
return static_cast<unsigned int>(x >> 32);
}
inline unsigned int lodword(unsigned long long x) {
return static_cast<unsigned int>(x & 0xFFFFFFFF);
}
inline unsigned long long __builtin_ctzll(unsigned long long x) {
return lodword(x) ? __builtin_ctz(lodword(x))
: __builtin_ctz(hidword(x)) + 32;
}
inline unsigned long long __builtin_clzll(unsigned long long x) {
return hidword(x) ? __builtin_clz(hidword(x))
: __builtin_clz(lodword(x)) + 32;
}
inline unsigned long long __builtin_ffsll(unsigned long long x) {
return lodword(x) ? __builtin_ffs(lodword(x))
: hidword(x) ? __builtin_ffs(hidword(x)) + 32
: 0;
}
// inline unsigned long long __builtin_popcountll(unsigned long long x) { return
// __builtin_popcount(lodword(x)) + __builtin_popcount(hidword(x)); }
#endif // _WIN64
#endif // _WIN32
#endif // _MSC_VER
namespace {
struct input_returnner {
ll N;
input_returnner(ll N_ = 0) : N(N_) {}
template <typename T> operator vector<T>() const {
vector<T> res(N);
for (auto &a : res)
cin >> a;
return std::move(res);
}
template <typename T> operator T() const {
T res;
cin >> res;
return res;
}
template <typename T> T operator-(T right) {
return T(input_returnner()) - right;
}
template <typename T> T operator+(T right) {
return T(input_returnner()) + right;
}
template <typename T> T operator*(T right) {
return T(input_returnner()) * right;
}
template <typename T> T operator/(T right) {
return T(input_returnner()) / right;
}
template <typename T> T operator<<(T right) {
return T(input_returnner()) << right;
}
template <typename T> T operator>>(T right) {
return T(input_returnner()) >> right;
}
};
template <typename T> input_returnner in() { return in<T>(); }
input_returnner in() { return input_returnner(); }
input_returnner in(ll N) { return std::move(input_returnner(N)); }
} // namespace
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> struct is_vector : std::false_type {};
template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
template <typename T> constexpr bool is_vector_v = is_vector<T>::value;
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
if (!v.empty()) {
for (int i = 0; i < v.size(); ++i) {
out << v[i] << (i == v.size() - 1 ? "\n" : (is_vector_v<T> ? "" : ", "));
}
}
return out;
}
namespace std {
// ref:
// https://stackoverflow.com/questions/7110301/generic-hash-for-tuples-in-unordered-map-unordered-set
template <class T> inline void hash_combine(std::size_t &seed, T const &v) {
seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
template <class T, class U> class hash<std::pair<T, U>> {
public:
size_t operator()(const std::pair<T, U> &x) const {
return hash<std::tuple<T, U>>()(std::tie(x.first, x.second));
}
};
} // namespace std
// ref: https://stackoverflow.com/questions/6245735/pretty-print-stdtuple
namespace aux {
template <std::size_t...> struct seq {};
template <std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <std::size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using swallow = int[];
(void)swallow{0,
(void(os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), 0)...};
}
} // namespace aux
template <class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr> &os, std::tuple<Args...> const &t)
-> std::basic_ostream<Ch, Tr> & {
os << "(";
aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
return os << ")";
}
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
// ref:
// https://stackoverflow.com/questions/8542591/c11-reverse-range-based-for-loo�Fp
template <typename T> struct reversion_wrapper { T &iterable; };
template <typename T> auto begin(reversion_wrapper<T> w) {
return std::rbegin(w.iterable);
}
template <typename T> auto end(reversion_wrapper<T> w) {
return std::rend(w.iterable);
}
template <typename T> reversion_wrapper<T> REV(T &&iterable) {
return {iterable};
}
template <class T> bool inside(T left, T val, T right) {
return left <= val and val < right;
}
template <class T> T bitCount(T num) {
T res = 0;
while (num > 0) {
if (num & 1)
++res;
num >>= 1;
}
return res;
}
ll MOD = 1e9 + 7;
// ll MOD = 998244353;
void solve();
signed main() {
SETUP;
#ifdef _DEBUG
while (true) {
#endif
solve();
#ifdef _DEBUG
cout << "-------" << endl;
}
#endif
#ifdef _DEBUG
system("pause");
#endif
return 0;
}
#define int ll
struct mint {
int64_t value;
mint() : value(0) {}
mint(int64_t value_) : value(value_ % MOD) {}
inline mint &operator+=(const mint &rhs) {
value += rhs.value;
if (value >= MOD) {
value -= MOD;
}
return *this;
}
inline mint &operator-=(const mint &rhs) {
value -= rhs.value;
if (value < 0) {
value += MOD;
}
return *this;
}
inline mint &operator*=(const mint &rhs) {
value *= rhs.value;
value %= MOD;
return *this;
}
inline mint &operator%=(const mint &rhs) { return *this; }
};
inline mint operator+(const mint &lhs, const mint &rhs) {
mint res = lhs;
res += rhs;
return res;
}
inline mint operator-(const mint &lhs, const mint &rhs) {
mint res = lhs;
res -= rhs;
return res;
}
inline mint operator*(const mint &lhs, const mint &rhs) {
mint res = lhs;
res *= rhs;
return res;
}
inline mint operator%(const mint &lhs, const uint64_t &rhs) { return lhs; }
ostream &operator<<(ostream &out, mint n) { return out << n.value; }
// L, length
int f(const vector<pair<int, int>> &L, int length, int level) {
if (level == 0) {
assert(1 <= length);
return 1;
}
int res = 0;
if (length == 1) {
return 0;
}
--length;
if (length <= L[level - 1].first) {
return f(L, length, level - 1);
}
length -= L[level - 1].first;
res += L[level - 1].second;
if (length == 1) {
return res + 1;
}
--length;
++res;
if (length <= L[level - 1].first) {
return res + f(L, length, level - 1);
}
length -= L[level - 1].first;
res += L[level - 1].second;
assert(length <= 1);
return res;
}
void solve() {
int N, M;
cin >> N >> M;
vector<pii> LR(M);
for (auto &a : LR) {
cin >> a.first >> a.second;
}
pii res = {1, N};
for (auto &a : LR) {
res.first = max(a.first, res.first);
res.second = min(a.second, res.second);
}
cout << res.second - res.first + 1 << endl;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <ciso646>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define inf 0x3f3f3f3f3f3f3f3f
#define ALL(a) (a).begin(), (a).end()
#define DEBUG(x) // cerr<<#x<<": "<<x<<endl
#define ll long long
#define ull unsigned long long
using pii = pair<ll, ll>;
#define eps 1e-14
#define SETUP \
cin.tie(0), ios::sync_with_stdio(false), \
cout << setprecision(15) << std::fixed;
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
template <class T> using vec2 = std::vector<vector<T>>;
//// bit ////
#ifdef _MSC_VER
#ifdef _WIN32
inline unsigned int __builtin_ctz(unsigned int x) {
unsigned long r;
_BitScanForward(&r, x);
return r;
}
inline unsigned int __builtin_clz(unsigned int x) {
unsigned long r;
_BitScanReverse(&r, x);
return 31 - r;
}
inline unsigned int __builtin_ffs(unsigned int x) {
unsigned long r;
return _BitScanForward(&r, x) ? r + 1 : 0;
}
// inline unsigned int __builtin_popcount(unsigned int x){ return __popcnt(x); }
#ifdef _WIN64
inline unsigned long long __builtin_ctzll(unsigned long long x) {
unsigned long r;
_BitScanForward64(&r, x);
return r;
}
inline unsigned long long __builtin_clzll(unsigned long long x) {
unsigned long r;
_BitScanReverse64(&r, x);
return 63 - r;
}
inline unsigned long long __builtin_ffsll(unsigned long long x) {
unsigned long r;
return _BitScanForward64(&r, x) ? r + 1 : 0;
}
inline unsigned long long __builtin_popcountll(unsigned long long x) {
return __popcnt64(x);
}
#else
inline unsigned int hidword(unsigned long long x) {
return static_cast<unsigned int>(x >> 32);
}
inline unsigned int lodword(unsigned long long x) {
return static_cast<unsigned int>(x & 0xFFFFFFFF);
}
inline unsigned long long __builtin_ctzll(unsigned long long x) {
return lodword(x) ? __builtin_ctz(lodword(x))
: __builtin_ctz(hidword(x)) + 32;
}
inline unsigned long long __builtin_clzll(unsigned long long x) {
return hidword(x) ? __builtin_clz(hidword(x))
: __builtin_clz(lodword(x)) + 32;
}
inline unsigned long long __builtin_ffsll(unsigned long long x) {
return lodword(x) ? __builtin_ffs(lodword(x))
: hidword(x) ? __builtin_ffs(hidword(x)) + 32
: 0;
}
// inline unsigned long long __builtin_popcountll(unsigned long long x) { return
// __builtin_popcount(lodword(x)) + __builtin_popcount(hidword(x)); }
#endif // _WIN64
#endif // _WIN32
#endif // _MSC_VER
namespace {
struct input_returnner {
ll N;
input_returnner(ll N_ = 0) : N(N_) {}
template <typename T> operator vector<T>() const {
vector<T> res(N);
for (auto &a : res)
cin >> a;
return std::move(res);
}
template <typename T> operator T() const {
T res;
cin >> res;
return res;
}
template <typename T> T operator-(T right) {
return T(input_returnner()) - right;
}
template <typename T> T operator+(T right) {
return T(input_returnner()) + right;
}
template <typename T> T operator*(T right) {
return T(input_returnner()) * right;
}
template <typename T> T operator/(T right) {
return T(input_returnner()) / right;
}
template <typename T> T operator<<(T right) {
return T(input_returnner()) << right;
}
template <typename T> T operator>>(T right) {
return T(input_returnner()) >> right;
}
};
template <typename T> input_returnner in() { return in<T>(); }
input_returnner in() { return input_returnner(); }
input_returnner in(ll N) { return std::move(input_returnner(N)); }
} // namespace
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> struct is_vector : std::false_type {};
template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
template <typename T> constexpr bool is_vector_v = is_vector<T>::value;
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
if (!v.empty()) {
for (int i = 0; i < v.size(); ++i) {
out << v[i] << (i == v.size() - 1 ? "\n" : (is_vector_v<T> ? "" : ", "));
}
}
return out;
}
namespace std {
// ref:
// https://stackoverflow.com/questions/7110301/generic-hash-for-tuples-in-unordered-map-unordered-set
template <class T> inline void hash_combine(std::size_t &seed, T const &v) {
seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
template <class T, class U> class hash<std::pair<T, U>> {
public:
size_t operator()(const std::pair<T, U> &x) const {
return hash<std::tuple<T, U>>()(std::tie(x.first, x.second));
}
};
} // namespace std
// ref: https://stackoverflow.com/questions/6245735/pretty-print-stdtuple
namespace aux {
template <std::size_t...> struct seq {};
template <std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <std::size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using swallow = int[];
(void)swallow{0,
(void(os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), 0)...};
}
} // namespace aux
template <class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr> &os, std::tuple<Args...> const &t)
-> std::basic_ostream<Ch, Tr> & {
os << "(";
aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
return os << ")";
}
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
// ref:
// https://stackoverflow.com/questions/8542591/c11-reverse-range-based-for-loo�Fp
template <typename T> struct reversion_wrapper { T &iterable; };
template <typename T> auto begin(reversion_wrapper<T> w) {
return std::rbegin(w.iterable);
}
template <typename T> auto end(reversion_wrapper<T> w) {
return std::rend(w.iterable);
}
template <typename T> reversion_wrapper<T> REV(T &&iterable) {
return {iterable};
}
template <class T> bool inside(T left, T val, T right) {
return left <= val and val < right;
}
template <class T> T bitCount(T num) {
T res = 0;
while (num > 0) {
if (num & 1)
++res;
num >>= 1;
}
return res;
}
ll MOD = 1e9 + 7;
// ll MOD = 998244353;
void solve();
signed main() {
SETUP;
#ifdef _DEBUG
while (true) {
#endif
solve();
#ifdef _DEBUG
cout << "-------" << endl;
}
#endif
#ifdef _DEBUG
system("pause");
#endif
return 0;
}
#define int ll
struct mint {
int64_t value;
mint() : value(0) {}
mint(int64_t value_) : value(value_ % MOD) {}
inline mint &operator+=(const mint &rhs) {
value += rhs.value;
if (value >= MOD) {
value -= MOD;
}
return *this;
}
inline mint &operator-=(const mint &rhs) {
value -= rhs.value;
if (value < 0) {
value += MOD;
}
return *this;
}
inline mint &operator*=(const mint &rhs) {
value *= rhs.value;
value %= MOD;
return *this;
}
inline mint &operator%=(const mint &rhs) { return *this; }
};
inline mint operator+(const mint &lhs, const mint &rhs) {
mint res = lhs;
res += rhs;
return res;
}
inline mint operator-(const mint &lhs, const mint &rhs) {
mint res = lhs;
res -= rhs;
return res;
}
inline mint operator*(const mint &lhs, const mint &rhs) {
mint res = lhs;
res *= rhs;
return res;
}
inline mint operator%(const mint &lhs, const uint64_t &rhs) { return lhs; }
ostream &operator<<(ostream &out, mint n) { return out << n.value; }
// L, length
int f(const vector<pair<int, int>> &L, int length, int level) {
if (level == 0) {
assert(1 <= length);
return 1;
}
int res = 0;
if (length == 1) {
return 0;
}
--length;
if (length <= L[level - 1].first) {
return f(L, length, level - 1);
}
length -= L[level - 1].first;
res += L[level - 1].second;
if (length == 1) {
return res + 1;
}
--length;
++res;
if (length <= L[level - 1].first) {
return res + f(L, length, level - 1);
}
length -= L[level - 1].first;
res += L[level - 1].second;
assert(length <= 1);
return res;
}
void solve() {
int N, M;
cin >> N >> M;
vector<pii> LR(M);
for (auto &a : LR) {
cin >> a.first >> a.second;
}
pii res = {1, N};
for (auto &a : LR) {
res.first = max(a.first, res.first);
res.second = min(a.second, res.second);
}
cout << max(res.second - res.first + 1, 0LL) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 850,662 | 850,663 | u579875569 | cpp |
p03037 | #include <stdio.h>
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); ++(i))
#define REP(i, n) FOR(i, 0, n)
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
int l = 1, r = n;
REP(i, m) {
int a, b;
scanf("%d%d", &a, &b);
if (l < a)
l = a;
if (r > b)
r = b;
}
if (r < l)
puts("0");
printf("%d\n", r - l + 1);
return 0;
} | #include <stdio.h>
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); ++(i))
#define REP(i, n) FOR(i, 0, n)
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
int l = 1, r = n;
REP(i, m) {
int a, b;
scanf("%d%d", &a, &b);
if (l < a)
l = a;
if (r > b)
r = b;
}
if (r < l)
puts("0");
else
printf("%d\n", r - l + 1);
return 0;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 850,668 | 850,669 | u394853232 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; ++i) {
cin >> L.at(i) >> R.at(i);
}
int L_max = 0, R_min = N;
for (int i = 0; i < M; ++i) {
L_max = max(L_max, L.at(i));
R_min = min(R_min, R.at(i));
}
cout << R_min - L_max + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; ++i) {
cin >> L.at(i) >> R.at(i);
}
int L_max = 0, R_min = N;
for (int i = 0; i < M; ++i) {
L_max = max(L_max, L.at(i));
R_min = min(R_min, R.at(i));
}
cout << max(R_min - L_max + 1, 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,672 | 850,673 | u564185267 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define REPL(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define repl(i, n) REP(i, 0, n)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N;
cin >> M;
int mi = 0;
int ma = 1000000;
int L, R;
REP(i, 0, M) {
cin >> L;
cin >> R;
mi = max(mi, L);
ma = min(ma, R);
}
cout << ma - mi + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define REPL(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define repl(i, n) REP(i, 0, n)
#define all(v) v.begin(), v.end()
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N;
cin >> M;
int mi = 0;
int ma = 1000000;
int L, R;
REP(i, 0, M) {
cin >> L;
cin >> R;
mi = max(mi, L);
ma = min(ma, R);
}
cout << max(ma - mi + 1, 0) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 850,674 | 850,675 | u764013649 | cpp |
p03037 | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
//
// using boost::multiprecision::cpp_int;
using namespace std;
#if __has_include("print.hpp")
#include "print.hpp"
#endif
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
vector<p> v(m);
ll l = -1, r = INT_MAX;
rep(i, m) {
cin >> v[i].first >> v[i].second;
l = max(l, v[i].first);
r = min(r, v[i].second);
}
cout << min(r, n) - l + 1 << endl;
}
| #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
//
// using boost::multiprecision::cpp_int;
using namespace std;
#if __has_include("print.hpp")
#include "print.hpp"
#endif
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
vector<p> v(m);
ll l = -1, r = INT_MAX;
rep(i, m) {
cin >> v[i].first >> v[i].second;
l = max(l, v[i].first);
r = min(r, v[i].second);
}
cout << max(0ll, min(r, n) - l + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 850,680 | 850,681 | u916743460 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
#if __has_include("print.hpp")
#include "print.hpp"
#endif
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int minv = -1;
int maxv = INT_MAX;
vector<p> v(m);
for (int i = 0; i < m; i++) {
cin >> v[i].first >> v[i].second;
minv = max(minv, v[i].first);
maxv = min(maxv, v[i].second);
}
int res = maxv - minv + 1;
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#if __has_include("print.hpp")
#include "print.hpp"
#endif
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int minv = -1;
int maxv = INT_MAX;
vector<p> v(m);
for (int i = 0; i < m; i++) {
cin >> v[i].first >> v[i].second;
minv = max(minv, v[i].first);
maxv = min(maxv, v[i].second);
}
int res = max(maxv - minv + 1, 0);
cout << res << endl;
}
| [
"call.add",
"call.arguments.add"
] | 850,682 | 850,683 | u916743460 | cpp |
p03037 |
#include <algorithm>
#include <functional>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <utility>
using namespace std;
typedef long long LL;
#define dump(c) \
{ \
for (auto it = c.begin(); it != c.end(); ++it) \
if (it == c.begin()) \
cout << *it; \
else \
cout << ' ' << *it; \
cout << endl; \
}
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
int l = 1;
int r = N;
rep(i, M) {
int L, R;
cin >> L >> R;
l = max(l, L);
r = min(r, R);
}
cout << max(0, r - l - 1) << endl;
return 0;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <utility>
using namespace std;
typedef long long LL;
#define dump(c) \
{ \
for (auto it = c.begin(); it != c.end(); ++it) \
if (it == c.begin()) \
cout << *it; \
else \
cout << ' ' << *it; \
cout << endl; \
}
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
int l = 1;
int r = N;
rep(i, M) {
int L, R;
cin >> L >> R;
l = max(l, L);
r = min(r, R);
}
cout << max(0, r - l + 1) << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 850,684 | 850,685 | u851470173 | cpp |
p03037 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[M], R[M];
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
int st = L[0];
int en = R[0];
for (int i = 0; i < M; i++) {
st = max(st, L[i]);
en = min(en, R[i]);
}
if (en - st >= 0)
cout << en - st + 1 << endl;
else
cout << st - en + 1 << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[M], R[M];
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
int st = L[0];
int en = R[0];
for (int i = 0; i < M; i++) {
st = max(st, L[i]);
en = min(en, R[i]);
}
if (en - st >= 0)
cout << en - st + 1 << endl;
else
cout << "0" << endl;
}
| [
"expression.operation.binary.remove"
] | 850,696 | 850,697 | u937275419 | cpp |
p03037 | #include <bits/stdc++.h>
#include <math.h>
#include <stdlib.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
inline constexpr ll gcd(ll a, ll b) {
if (!a || !b)
return 0;
while (b) {
ll c = b;
b = a % b;
a = c;
}
return a;
}
inline constexpr ll lcm(ll a, ll b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
int main() {
int a, b;
cin >> a >> b;
vector<int> rvec(b);
vector<int> lvec(b);
rep(i, b) { cin >> rvec.at(i) >> lvec.at(i); }
int max = *std::max_element(rvec.begin(), rvec.end());
int min = *std::min_element(lvec.begin(), lvec.end());
if (min > max) {
cout << min - max + 1 << endl;
} else {
cout << 0 << endl;
}
}
| #include <bits/stdc++.h>
#include <math.h>
#include <stdlib.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
inline constexpr ll gcd(ll a, ll b) {
if (!a || !b)
return 0;
while (b) {
ll c = b;
b = a % b;
a = c;
}
return a;
}
inline constexpr ll lcm(ll a, ll b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
int main() {
int a, b;
cin >> a >> b;
vector<int> rvec(b);
vector<int> lvec(b);
rep(i, b) { cin >> rvec.at(i) >> lvec.at(i); }
int max = *std::max_element(rvec.begin(), rvec.end());
int min = *std::min_element(lvec.begin(), lvec.end());
if (min >= max) {
cout << min - max + 1 << endl;
} else {
cout << 0 << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,700 | 850,701 | u540741303 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef tuple<ll, ll, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define REPR(i, n) for (ll i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define FORR(i, m, n) for (ll i = n - 1; i >= m; --i)
#define FORE(x, xs) for (const auto &x : xs)
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
int N, M;
int solve() {
int mn = 0, mx = N;
REP(m, M) {
int l, r;
cin >> l >> r;
mn = max(mn, l - 1);
mx = min(mx, r);
}
return mx - mn;
}
int main() {
cin >> N >> M;
cout << solve() << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef tuple<ll, ll, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define REPR(i, n) for (ll i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define FORR(i, m, n) for (ll i = n - 1; i >= m; --i)
#define FORE(x, xs) for (const auto &x : xs)
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
int N, M;
int solve() {
int mn = 0, mx = N;
REP(m, M) {
int l, r;
cin >> l >> r;
mn = max(mn, l - 1);
mx = min(mx, r);
}
return max(0, mx - mn);
}
int main() {
cin >> N >> M;
cout << solve() << endl;
} | [
"call.add",
"call.arguments.change",
"function.return_value.change"
] | 850,723 | 850,724 | u957084285 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M, L, R;
cin >> N >> M;
int L_max = 0;
int R_min = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
L_max = max(L_max, L);
R_min = min(R_min, R);
}
cout << R_min - L_max + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M, L, R;
cin >> N >> M;
int L_max = 0;
int R_min = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
L_max = max(L_max, L);
R_min = min(R_min, R);
}
cout << max(0, R_min - L_max + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,734 | 850,735 | u351586819 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
vector<int> vec(b);
vector<int> vecb(b);
for (int i = 0; i < b; i++) {
cin >> vec.at(i);
cin >> vecb.at(i);
}
sort(vec.begin(), vec.end());
sort(vecb.begin(), vecb.end());
int l = vecb.at(0) - vec.at(b - 1) + 1;
cout << min(l, a) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
vector<int> vec(b);
vector<int> vecb(b);
for (int i = 0; i < b; i++) {
cin >> vec.at(i);
cin >> vecb.at(i);
}
sort(vec.begin(), vec.end());
sort(vecb.begin(), vecb.end());
int l = vecb.at(0) - vec.at(b - 1) + 1;
cout << max(l, 0) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"identifier.replace.remove",
"literal.replace.add"
] | 850,736 | 850,737 | u363369454 | cpp |
p03037 | // abc127_c
#include <bits/stdc++.h>
#ifdef LOCAL
#include "../cxx-prettyprint/prettyprint.hpp"
#endif
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define ALL(x) x.begin(), x.end()
#define INF ((1 << 29) - 1)
#define MOD (1000000007)
#define print2D(h, w, arr) \
REP(i, h) { \
REP(j, w) cout << arr[i][j] << " "; \
cout << endl; \
}
template <class T> void print(const T &x) { cout << x << endl; }
template <class T, class... A> void print(const T &first, const A &...rest) {
cout << first << " ";
print(rest...);
}
struct PreMain {
PreMain() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} premain;
int main() {
#ifdef LOCAL
ifstream in("../arg.txt");
cin.rdbuf(in.rdbuf());
#endif
int N, M;
cin >> N >> M;
int max_l = 0;
int min_r = N - 1;
REP(i, M) {
int l, r;
cin >> l >> r;
l--;
r--;
max_l = max(max_l, l);
min_r = min(min_r, r);
}
print(min_r - max_l + 1);
return 0;
}
| // abc127_c
#include <bits/stdc++.h>
#ifdef LOCAL
#include "../cxx-prettyprint/prettyprint.hpp"
#endif
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define ALL(x) x.begin(), x.end()
#define INF ((1 << 29) - 1)
#define MOD (1000000007)
#define print2D(h, w, arr) \
REP(i, h) { \
REP(j, w) cout << arr[i][j] << " "; \
cout << endl; \
}
template <class T> void print(const T &x) { cout << x << endl; }
template <class T, class... A> void print(const T &first, const A &...rest) {
cout << first << " ";
print(rest...);
}
struct PreMain {
PreMain() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} premain;
int main() {
#ifdef LOCAL
ifstream in("../arg.txt");
cin.rdbuf(in.rdbuf());
#endif
int N, M;
cin >> N >> M;
int max_l = 0;
int min_r = N - 1;
REP(i, M) {
int l, r;
cin >> l >> r;
l--;
r--;
max_l = max(max_l, l);
min_r = min(min_r, r);
}
print(max(min_r - max_l + 1, 0));
return 0;
}
| [
"call.arguments.add"
] | 850,738 | 850,739 | u614550445 | cpp |
p03037 | #include <algorithm>
#include <climits>
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int max_l = INT_MIN, min_r = INT_MAX;
int l, r;
for (int i = 0; i < m; ++i) {
cin >> l >> r;
max_l = max(max_l, l);
min_r = min(min_r, r);
}
cout << min_r - max_l + 1 << '\n';
}
| #include <algorithm>
#include <climits>
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int max_l = INT_MIN, min_r = INT_MAX;
int l, r;
for (int i = 0; i < m; ++i) {
cin >> l >> r;
max_l = max(max_l, l);
min_r = min(min_r, r);
}
cout << max(min_r - max_l + 1, 0) << '\n';
}
| [
"call.add",
"call.arguments.add"
] | 850,740 | 850,741 | u964185015 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
int main(void) {
int N, M, ans = 0;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int p[N];
REP(i, N) p[i] = 0;
REP(i, M) { cin >> L[i] >> R[i]; }
int Lmax = *std::max_element(L.begin(), L.end());
int Rmin = *std::min_element(R.begin(), R.end());
if (Lmax < Rmin)
ans = Rmin - Lmax + 1;
else
ans = 0;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
int main(void) {
int N, M, ans = 0;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int p[N];
REP(i, N) p[i] = 0;
REP(i, M) { cin >> L[i] >> R[i]; }
int Lmax = *std::max_element(L.begin(), L.end());
int Rmin = *std::min_element(R.begin(), R.end());
if (Lmax <= Rmin)
ans = Rmin - Lmax + 1;
else
ans = 0;
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,742 | 850,743 | u075689098 | cpp |
p03037 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a = 1, b = n;
rep(i, m) {
int l, r;
cin >> l >> r;
a = max(a, l);
b = min(b, r);
}
cout << max(b - a, 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a = 1, b = n;
rep(i, m) {
int l, r;
cin >> l >> r;
a = max(a, l);
b = min(b, r);
}
cout << max(b - a + 1, 0) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 850,746 | 850,747 | u781095600 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int mini = 0;
int maxi = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
mini = max(mini, L);
maxi = min(maxi, R);
}
cout << maxi - mini + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L, R;
int mini = 0;
int maxi = N;
for (int i = 0; i < M; i++) {
cin >> L >> R;
mini = max(mini, L);
maxi = min(maxi, R);
}
cout << max(0, maxi - mini + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,748 | 850,749 | u476833465 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int left = 1, right = n, t_left, t_right;
for (int i = 0; i < m; i++) {
cin >> t_left >> t_right;
left = max(left, t_left);
right = min(right, t_right);
}
cout << right - left + 1 << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int left = 1, right = n, t_left, t_right;
for (int i = 0; i < m; i++) {
cin >> t_left >> t_right;
left = max(left, t_left);
right = min(right, t_right);
}
cout << max(right - left + 1, 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 850,752 | 850,753 | u448407332 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int l = 1, r = N;
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
l = max(l, L);
r = min(r, R);
}
cout << r - l + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int l = 1, r = N;
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
l = max(l, L);
r = min(r, R);
}
cout << max(0, r - l + 1) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 850,766 | 850,767 | u223172354 | cpp |
p03037 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<string> vs;
typedef pair<int, int> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<p> g(m);
REP(i, m) { cin >> g[i].first >> g[i].second; }
int minv = 0, maxv = 10000000;
REP(i, m) {
minv = max(minv, g[i].first);
maxv = min(maxv, g[i].second);
}
cout << maxv - minv + 1 << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<string> vs;
typedef pair<int, int> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<p> g(m);
REP(i, m) { cin >> g[i].first >> g[i].second; }
int minv = 0, maxv = 10000000;
REP(i, m) {
minv = max(minv, g[i].first);
maxv = min(maxv, g[i].second);
}
cout << max(0, maxv - minv + 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 850,770 | 850,771 | u983505021 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define log(i, n) log(n) / log(i);
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
cout << min(n, *min_element(r.begin(), r.end()) -
*max_element(l.begin(), l.end()) + 1)
<< endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define log(i, n) log(n) / log(i);
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
cout << min(n, max(0LL, *min_element(r.begin(), r.end()) -
*max_element(l.begin(), l.end()) + 1))
<< endl;
}
| [
"call.arguments.add",
"call.arguments.change"
] | 850,775 | 850,776 | u317177661 | cpp |
p03037 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m, ans = 0, min = 0, max;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
max = r[0];
for (int j = 0; j < m; j++) {
if (min < l[j])
min = l[j];
if (max > r[j])
max = r[j];
}
if (max > min)
ans = 1 + max - min;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m, ans = 0, min = 0, max;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
}
max = r[0];
for (int j = 0; j < m; j++) {
if (min < l[j])
min = l[j];
if (max > r[j])
max = r[j];
}
if (max >= min)
ans = 1 + max - min;
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 850,779 | 850,780 | u117606227 | cpp |
p03037 | #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
sort(l.begin(), l.end());
sort(r.begin(), r.end());
cout << min(n, r[0] - l[m - 1] + 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
sort(l.begin(), l.end());
sort(r.begin(), r.end());
cout << max(0, r[0] - l[m - 1] + 1) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"identifier.replace.remove",
"literal.replace.add"
] | 850,791 | 850,792 | u374190629 | cpp |
p03037 | #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
sort(l.begin(), l.end());
sort(r.begin(), r.end());
cout << r[0] - l[m - 1] + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
rep(i, m) cin >> l[i] >> r[i];
sort(l.begin(), l.end());
sort(r.begin(), r.end());
cout << max(0, r[0] - l[m - 1] + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 850,793 | 850,792 | u374190629 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.