problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
if (l < 1 - n) {
cout << (l - 1) * n + n * (n - 1) / 2 - (l + n - 1) << endl;
} else if (l > 0) {
cout << (l - 1) * n + n * (n - 1) / 2 - l << endl;
} else {
cout << (l - 1) * n + n * (n - 1) / 2 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
if (l < 1 - n) {
cout << (l - 1) * n + n * (n + 1) / 2 - (l + n - 1) << endl;
} else if (l > 0) {
cout << (l - 1) * n + n * (n + 1) / 2 - l << endl;
} else {
cout << (l - 1) * n + n * (n + 1) / 2 << endl;
}
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 802,780 | 802,781 | u882039496 | cpp |
p02994 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, l;
cin >> n >> l;
vector<int> a(n);
rep(i, n) a.at(i) = l + i;
if (l >= 0)
a.erase(a.begin());
if (l < 0) {
if (n < abs(l))
a.pop_back();
}
long long ans = accumulate(a.begin(), a.end(), 0);
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, l;
cin >> n >> l;
vector<int> a(n);
rep(i, n) a.at(i) = l + i;
if (l >= 0)
a.erase(a.begin());
if (l < 0) {
if (n <= abs(l))
a.pop_back();
}
long long ans = accumulate(a.begin(), a.end(), 0);
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,786 | 802,787 | u090866616 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = 0;
if (l <= 0 && l + n >= 0) {
for (int i = 0; i < n; i++) {
sum += l + i;
}
cout << sum;
} else if (l > 0) {
for (int i = 1; i < n; i++) {
sum += l + i;
}
cout << sum;
} else {
for (int i = 0; i < n - 1; i++) {
sum += l + i;
}
cout << sum;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = 0;
if (l <= 0 && l + n >= 1) {
for (int i = 0; i < n; i++) {
sum += l + i;
}
cout << sum;
} else if (l > 0) {
for (int i = 1; i < n; i++) {
sum += l + i;
}
cout << sum;
} else {
for (int i = 0; i < n - 1; i++) {
sum += l + i;
}
cout << sum;
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 802,791 | 802,792 | u094746828 | cpp |
p02994 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef signed long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) x.begin(), x.end()
#define DEBUG
int main() {
int n, l;
int ans = 0;
cin >> n >> l;
for (int i = 0; i < n; i++) {
ans += l;
l++;
}
if ((l - n) <= 0 && l >= 0) {
cout << ans << endl;
} else if (ans >= 0) {
ans -= (l - n);
cout << ans << endl;
} else {
ans -= l - 1;
cout << ans << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef signed long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) x.begin(), x.end()
#define DEBUG
int main() {
int n, l;
int ans = 0;
cin >> n >> l;
for (int i = 0; i < n; i++) {
ans += l;
l++;
}
if ((l - n) < 0 && l > 0) {
cout << ans << endl;
} else if (ans >= 0) {
ans -= (l - n);
cout << ans << endl;
} else {
ans -= l - 1;
cout << ans << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,795 | 802,796 | u959682820 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep2(i, x, n) for (int i = x; i < n; ++i)
int main() {
int n, l;
cin >> n >> l;
vector<int> t(n);
int sum = 0;
rep(i, n) {
t[i] = l - i;
sum += l - i;
}
int ans = 0;
int min_diff = 1e9;
rep(i, n) {
if (abs(t[i]) < min_diff) {
min_diff = abs(t[i]);
ans = sum - t[i];
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep2(i, x, n) for (int i = x; i < n; ++i)
int main() {
int n, l;
cin >> n >> l;
vector<int> t(n);
int sum = 0;
rep(i, n) {
t[i] = l + i;
sum += l + i;
}
int ans = 0;
int min_diff = 1e9;
rep(i, n) {
if (abs(t[i]) < min_diff) {
min_diff = abs(t[i]);
ans = sum - t[i];
}
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 802,799 | 802,800 | u445401544 | cpp |
p02994 | #include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
#define max(a, b) a > b ? a : b
#define min(a, b) a < b ? a : b
void strInit(char str[]); // str[]を0で初期化
void extIntStr(char str[],
int data[]); // str[]から数値(int)を抽出しdata[]に順次格納
void incsort(int data[], int len); // data[]を昇順ソート
void decsort(int data[], int len); // data[]を降順ソート
void printIntArray(int data[], int len); // data[]をprint
int *inputArray(
int n); //文字列を受け取り数値を抽出、n個の数値(int)を格納した配列のポインタをreturn
int *cpyArray(int data[], int len); //配列(int)を複製した配列のポインタをreturn
int judgePrime(int x); //素数かどうか判断するよ
int printPrime(int n); //ｎ番目の素数を出すよ
void soinsubunkai(int a, int *indexes, int **prim, int **e); //素因数を出すよ
// don't forget free(data);
int main() {
int N, L;
cin >> N >> L;
int sum = N * (L + N + L - 1) / 2;
int min = N;
if (L > 0) {
min = L;
} else {
for (int i = 0; i < N; i++) {
if (abs(L + i) < min) {
min = abs(L + i);
}
}
}
int prt;
if (sum > 0)
prt = sum - min;
else
prt = sum + min;
printf("%d", prt);
}
// temp##############################################
int judgePrime(int x) {
for (int i = 2; i < x - 1; i++) {
if (x % i == 0)
return 0;
}
return 1;
}
int printPrime(int n) {
int i = 1;
for (int j = 0; j < n + 1; j++) {
while (1) {
if (judgePrime(++i))
break;
}
}
return i;
}
void soinsubunkai(int a, int *indexes, int **prim, int **e) {
if (a == 1) {
int *t = (int *)malloc(sizeof(int));
int *b = (int *)malloc(sizeof(int));
*t = 1;
*b = 1;
*indexes = 1;
*prim = t;
*e = b;
return;
}
int n = a;
std::vector<int> pr, er;
int index, prm, j, rec;
index = rec = 0;
for (int i = 0; n != 1; i++) {
prm = printPrime(i);
if (n % prm == 0) {
pr.push_back(prm);
er.push_back(0);
while ((n % prm) == 0) {
n /= prm;
er[index]++;
j++;
}
index++;
}
}
int len = pr.size();
int *ret = (int *)malloc(sizeof(int) * len);
int *re = (int *)malloc(sizeof(int) * len);
for (int i = 0; i < len; i++) {
ret[i] = pr[i];
re[i] = er[i];
}
*indexes = len;
*prim = ret;
*e = re;
return;
}
void strInit(char str[]) {
int len = strlen(str);
for (int i = 0; i < len; i++) {
str[i] = 0;
}
}
void extIntStr(char str[], int data[]) {
int length = strlen(str);
str[length - 1] = ' ';
char buff[12];
int j, index;
index = j = 0;
for (int i = 0; i < length; i++) {
if (str[i] != ' ') {
buff[j++] = str[i];
} else {
data[index++] = atoi(buff);
strInit(buff);
j = 0;
}
}
}
void incsort(int data[], int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = i + 1; j < len; j++) {
if (data[i] > data[j]) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
}
void decsort(int data[], int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = i + 1; j < len; j++) {
if (data[i] < data[j]) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
}
void printIntArray(int data[], int len) {
for (int i = 0; i < len; i++) {
printf("%d\n", data[i]);
}
}
int *inputArray(int n) {
int *data;
data = (int *)malloc(sizeof(int) * n);
char *get;
get = (char *)malloc(sizeof(char) * 11 * n + 1);
fgets(get, 11 * n + 1, stdin);
extIntStr(get, data);
free(get);
return data;
}
int *cpyArray(int data[], int len) {
int *cp;
cp = (int *)malloc(sizeof(int) * len);
for (int i = 0; i < len; i++) {
cp[i] = data[i];
}
return cp;
}
// temp##############################################
| #include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
#define max(a, b) a > b ? a : b
#define min(a, b) a < b ? a : b
void strInit(char str[]); // str[]を0で初期化
void extIntStr(char str[],
int data[]); // str[]から数値(int)を抽出しdata[]に順次格納
void incsort(int data[], int len); // data[]を昇順ソート
void decsort(int data[], int len); // data[]を降順ソート
void printIntArray(int data[], int len); // data[]をprint
int *inputArray(
int n); //文字列を受け取り数値を抽出、n個の数値(int)を格納した配列のポインタをreturn
int *cpyArray(int data[], int len); //配列(int)を複製した配列のポインタをreturn
int judgePrime(int x); //素数かどうか判断するよ
int printPrime(int n); //ｎ番目の素数を出すよ
void soinsubunkai(int a, int *indexes, int **prim, int **e); //素因数を出すよ
// don't forget free(data);
int main() {
int N, L;
cin >> N >> L;
int sum = N * (L + N + L - 1) / 2;
int min = N + 1000;
if (L > 0) {
min = L;
} else {
for (int i = 0; i < N; i++) {
if (abs(L + i) < min) {
min = abs(L + i);
}
}
}
int prt;
if (sum > 0)
prt = sum - min;
else
prt = sum + min;
printf("%d", prt);
}
// temp##############################################
int judgePrime(int x) {
for (int i = 2; i < x - 1; i++) {
if (x % i == 0)
return 0;
}
return 1;
}
int printPrime(int n) {
int i = 1;
for (int j = 0; j < n + 1; j++) {
while (1) {
if (judgePrime(++i))
break;
}
}
return i;
}
void soinsubunkai(int a, int *indexes, int **prim, int **e) {
if (a == 1) {
int *t = (int *)malloc(sizeof(int));
int *b = (int *)malloc(sizeof(int));
*t = 1;
*b = 1;
*indexes = 1;
*prim = t;
*e = b;
return;
}
int n = a;
std::vector<int> pr, er;
int index, prm, j, rec;
index = rec = 0;
for (int i = 0; n != 1; i++) {
prm = printPrime(i);
if (n % prm == 0) {
pr.push_back(prm);
er.push_back(0);
while ((n % prm) == 0) {
n /= prm;
er[index]++;
j++;
}
index++;
}
}
int len = pr.size();
int *ret = (int *)malloc(sizeof(int) * len);
int *re = (int *)malloc(sizeof(int) * len);
for (int i = 0; i < len; i++) {
ret[i] = pr[i];
re[i] = er[i];
}
*indexes = len;
*prim = ret;
*e = re;
return;
}
void strInit(char str[]) {
int len = strlen(str);
for (int i = 0; i < len; i++) {
str[i] = 0;
}
}
void extIntStr(char str[], int data[]) {
int length = strlen(str);
str[length - 1] = ' ';
char buff[12];
int j, index;
index = j = 0;
for (int i = 0; i < length; i++) {
if (str[i] != ' ') {
buff[j++] = str[i];
} else {
data[index++] = atoi(buff);
strInit(buff);
j = 0;
}
}
}
void incsort(int data[], int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = i + 1; j < len; j++) {
if (data[i] > data[j]) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
}
void decsort(int data[], int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = i + 1; j < len; j++) {
if (data[i] < data[j]) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
}
void printIntArray(int data[], int len) {
for (int i = 0; i < len; i++) {
printf("%d\n", data[i]);
}
}
int *inputArray(int n) {
int *data;
data = (int *)malloc(sizeof(int) * n);
char *get;
get = (char *)malloc(sizeof(char) * 11 * n + 1);
fgets(get, 11 * n + 1, stdin);
extIntStr(get, data);
free(get);
return data;
}
int *cpyArray(int data[], int len) {
int *cp;
cp = (int *)malloc(sizeof(int) * len);
for (int i = 0; i < len; i++) {
cp[i] = data[i];
}
return cp;
}
// temp##############################################
| [
"assignment.change"
] | 802,801 | 802,802 | u493708099 | cpp |
p02994 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int l = L, A[N], sum = 0;
if (L >= 0) {
for (int i = 0; i < N - 1; i++) {
l++;
sum += l;
}
} else if (L < 0 && L + N < 0) {
for (int i = 0; i < N - 1; i++) {
sum += l;
l++;
}
} else {
for (int i = 0; i < N; i++) {
sum += l;
l++;
}
}
cout << sum << endl;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int l = L, A[N], sum = 0;
if (L >= 0) {
for (int i = 0; i < N - 1; i++) {
l++;
sum += l;
}
} else if (L < 0 && L + N <= 0) {
for (int i = 0; i < N - 1; i++) {
sum += l;
l++;
}
} else {
for (int i = 0; i < N; i++) {
sum += l;
l++;
}
}
cout << sum << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,808 | 802,809 | u433048345 | cpp |
p02994 | #include <stdio.h>
int main() {
int N, L;
scanf("%d %d", &N, &L);
int a[N], i, min, ans, count = 0;
for (i = 0; i < N; i++) {
a[i] = L + i;
}
min = a[0];
if (N == 1)
ans = L;
else {
if (min > 0) {
for (i = 0; i < N; i++) {
if (a[i] < min && a[i] > 0)
min = a[i];
}
} else {
for (i = 0; i < N; i++) {
if (i != N - 1) {
if (a[i] > min && a[i] >= 0 && a[i + 1] > a[i]) {
min = a[i];
break;
}
} else
min = a[i];
}
}
for (i = 0; i < N; i++) {
count = count + a[i];
}
ans = count - min;
}
printf("%d\n", ans);
return 0;
}
| #include <stdio.h>
int main() {
int N, L;
scanf("%d %d", &N, &L);
int a[N], i, min, ans, count = 0;
for (i = 0; i < N; i++) {
a[i] = L + i;
}
min = a[0];
if (N == 1)
ans = L;
else {
if (a[0] >= 0) {
for (i = 0; i < N; i++) {
if (a[i] < min && a[i] >= 0)
min = a[i];
}
} else {
for (i = 0; i < N; i++) {
if (i != N - 1) {
if (a[i] > min && a[i] >= 0 && a[i + 1] > a[i]) {
min = a[i];
break;
}
} else
min = a[i];
}
}
for (i = 0; i < N; i++) {
count = count + a[i];
}
ans = count - min;
}
printf("%d\n", ans);
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 802,816 | 802,817 | u560936174 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (1 - L > N) {
cout << N * (L - 1) + N * (N + 1) / 2 - (L + N - 1) << endl;
} else if (1 - L <= 0) {
cout << N * (L - 1) + N * (N + 1) / 2 - (L - 1) << endl;
} else {
cout << N * (L - 1) + N * (N + 1) / 2 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
if (1 - L > N) {
cout << N * (L - 1) + N * (N + 1) / 2 - (L + N - 1) << endl;
} else if (1 - L <= 0) {
cout << N * (L - 1) + N * (N + 1) / 2 - L << endl;
} else {
cout << N * (L - 1) + N * (N + 1) / 2 << endl;
}
} | [] | 802,831 | 802,832 | u028572059 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int all = (l + (l + n - 1)) * n / 2;
int min_abs = 1000;
int min_abs_taste = 0;
for (int i = l; i < l + n - 1; ++i) {
if (min_abs > abs(i)) {
min_abs = abs(i);
min_abs_taste = i;
}
}
cout << all - min_abs_taste << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int all = (l + (l + n - 1)) * n / 2;
int min_abs = 1000;
int min_abs_taste = 0;
for (int i = l; i <= l + n - 1; ++i) {
if (min_abs > abs(i)) {
min_abs = abs(i);
min_abs_taste = i;
}
}
cout << all - min_abs_taste << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 802,833 | 802,834 | u912025537 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int sa = 10000, num, sum = 0;
for (int i = 1; i <= N; i++) {
if (sa > abs(L + i - 1)) {
sa = abs(L + i - 1);
num = i;
}
}
for (int i = 1; i <= N; i++) {
if (i != num)
sum += L + i - 1;
}
cout << num;
} | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int sa = 10000, num, sum = 0;
for (int i = 1; i <= N; i++) {
if (sa > abs(L + i - 1)) {
sa = abs(L + i - 1);
num = i;
}
}
for (int i = 1; i <= N; i++) {
if (i != num)
sum += L + i - 1;
}
cout << sum;
}
| [
"identifier.change",
"io.output.change"
] | 802,835 | 802,836 | u544511937 | cpp |
p02994 | #include <cstdio>
int main() {
int N, L;
scanf("%d %d", &N, &L);
int aji = N * (2 * L + N - 1) / 2;
if (L >= 0)
aji -= 2;
else if (L + N <= 0)
aji -= L + N - 1;
printf("%d", aji);
} | #include <cstdio>
int main() {
int N, L;
scanf("%d %d", &N, &L);
int aji = N * (2 * L + N - 1) / 2;
if (L >= 0)
aji -= L;
else if (L + N <= 0)
aji -= L + N - 1;
printf("%d", aji);
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 802,837 | 802,838 | u568501780 | cpp |
p02994 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct edge {
int from;
int to;
int cost;
};
int main() {
int N, L;
cin >> N >> L;
int sum = 0;
if (L >= 0) {
for (int ni = 1; ni < N; ni++) {
sum += ni + L;
}
} else if (L < -N) {
for (int ni = 0; ni < N - 1; ni++) {
sum += ni + L;
}
} else {
for (int ni = 0; ni < N; ni++) {
sum += ni + L;
}
}
printf("%d", sum);
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct edge {
int from;
int to;
int cost;
};
int main() {
int N, L;
cin >> N >> L;
int sum = 0;
if (L >= 0) {
for (int ni = 1; ni < N; ni++) {
sum += ni + L;
}
} else if (L <= -N) {
for (int ni = 0; ni < N - 1; ni++) {
sum += ni + L;
}
} else {
for (int ni = 0; ni < N; ni++) {
sum += ni + L;
}
}
printf("%d", sum);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,843 | 802,844 | u388763757 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
using Int = long long int;
template <typename T> void swap(T *t1, T *t2) {
T *tmp = t1;
t1 = t2;
t2 = tmp;
}
Int tmpi = 0;
double tmpd = 0.0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Int n, l;
cin >> n >> l;
Int min = pow(10, 9);
Int sum = 0;
for (Int i = 1; i <= n; i++) {
sum += l + i - 1;
}
for (Int i = 1; i <= n; i++) {
if (abs(l + i - 1) < min) {
min = l + i - 1;
}
}
cout << sum - min << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Int = long long int;
template <typename T> void swap(T *t1, T *t2) {
T *tmp = t1;
t1 = t2;
t2 = tmp;
}
Int tmpi = 0;
double tmpd = 0.0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Int n, l;
cin >> n >> l;
Int min = pow(10, 9);
Int sum = 0;
for (Int i = 1; i <= n; i++) {
sum += l + i - 1;
}
for (Int i = 1; i <= n; i++) {
if (abs(l + i - 1) < abs(min)) {
min = l + i - 1;
}
}
cout << sum - min << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 802,847 | 802,848 | u026620445 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
using Int = long long int;
template <typename T> void swap(T *t1, T *t2) {
T *tmp = t1;
t1 = t2;
t2 = tmp;
}
Int tmpi = 0;
double tmpd = 0.0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Int n, l;
cin >> n >> l;
Int min = pow(10, 9);
Int sum = 0;
for (Int i = 1; i <= n; i++) {
sum += l + i - 1;
}
for (Int i = 1; i <= n; i++) {
if (abs(l + i - 1) < min) {
min = abs(l + i - 1);
}
}
cout << sum - min << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Int = long long int;
template <typename T> void swap(T *t1, T *t2) {
T *tmp = t1;
t1 = t2;
t2 = tmp;
}
Int tmpi = 0;
double tmpd = 0.0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Int n, l;
cin >> n >> l;
Int min = pow(10, 9);
Int sum = 0;
for (Int i = 1; i <= n; i++) {
sum += l + i - 1;
}
for (Int i = 1; i <= n; i++) {
if (abs(l + i - 1) < abs(min)) {
min = l + i - 1;
}
}
cout << sum - min << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add",
"call.remove",
"call.arguments.change"
] | 802,849 | 802,848 | u026620445 | cpp |
p02994 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, l;
cin >> n >> l;
if (l <= 0 && l + n > 0) {
cout << (l + (l + n - 1)) * (n - 1) / 2 << endl;
} else if (l > 0) {
cout << ((l + 1) + (l + n - 1)) * (n - 1) / 2 << endl;
} else {
cout << (l + (l + n - 2)) * (n - 1) / 2 << endl;
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, l;
cin >> n >> l;
if (l <= 0 && l + n > 0) {
cout << (l + (l + n - 1)) * (n) / 2 << endl;
} else if (l > 0) {
cout << ((l + 1) + (l + n - 1)) * (n - 1) / 2 << endl;
} else {
cout << (l + (l + n - 2)) * (n - 1) / 2 << endl;
}
}
| [
"expression.operation.binary.remove"
] | 802,854 | 802,855 | u806149832 | cpp |
p02994 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#define stoll(argument_string) atoll((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define CIN5(x, y, z, w, u) cin >> (x) >> (y) >> (z) >> (w) >> (u)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCAND5(x, y, z, w, u) scanf("%d%d%d%d%d", &(x), &(y), &(z), &(w), &(u))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define SCANLLD5(x, y, z, w, u) \
scanf("%lld%lld%lld%lld%lld", &(x), &(y), &(z), &(w), &(u))
#define I64DSCAN(x) scanf("%I64d", &(x))
#define I64DSCAN2(x, y) scanf("%I64d%I64d", &(x), &(y))
#define I64DSCAN3(x, y, z) scanf("%I64d%I64d%I64d", &(x), &(y), &(z))
#define I64DSCAN4(x, y, z, w) \
scanf("%I64d%I64d%I64d%I64d", &(x), &(y), &(z), &(w))
#define I64DSCAN5(x, y, z, w, u) \
scanf("%I64d%I64d%I64d%I64d%I64d", &(x), &(y), &(z), &(w), &(u))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
#define PRINTI64D(x) printf("%I64d\n", (x))
#define DEBUG(argument) cerr << (#argument) << " : " << (argument) << "\n"
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
long long gcd(long long a, long long b) // assuming a,b >= 1
{
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
long long lcm(long long a, long long b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
long long pow_fast(long long x, long long n_power, long long modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
struct CombinationTable {
vector<vector<long long>> val;
CombinationTable(int size)
: val(size + 1, vector<long long>(size + 1)) // constructor
{
for (int i = 0; i <= size; ++i) // note that 0 <= i <= size
{
for (int j = 0; j <= i; ++j) {
if (j == 0 or j == i) {
val[i][j] = 1LL;
} else {
val[i][j] = val[i - 1][j - 1] + val[i - 1][j];
}
}
}
}
};
void print_vector(vector<int> &h) {
int L = h.size();
for (int i = 0; i < L; ++i) {
printf("%d", h[i]);
if (i != L - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
void print_vector(vector<long long> &h) {
int L = h.size();
for (int i = 0; i < L; ++i) {
printf("%lld", h[i]);
if (i != L - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
void print_matrix2D(vector<vector<int>> &h) {
int Ly = h.size();
int Lx = h[0].size();
for (int i = 0; i < Ly; ++i) {
for (int j = 0; j < Lx; ++j) {
printf("%d", h[i][j]);
if (j != Lx - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
}
void print_matrix2D(vector<vector<long long>> &h) {
int Ly = h.size();
int Lx = h[0].size();
for (int i = 0; i < Ly; ++i) {
for (int j = 0; j < Lx; ++j) {
printf("%lld", h[i][j]);
if (j != Lx - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
}
void print_matrix2D(vector<string> &h) {
int Ly = h.size();
int Lx = h[0].size();
for (int i = 0; i < Ly; ++i) {
for (int j = 0; j < Lx; ++j) {
printf("%c", h[i][j]);
}
printf("\n");
}
}
struct UnionFind // size-based
{
vector<int> parent, treesize;
UnionFind(int size)
: parent(size), treesize(size, 1) // constructor
{
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (treesize[x] < treesize[y]) {
parent[x] = y;
treesize[y] += treesize[x];
} else {
parent[y] = x;
treesize[x] += treesize[y];
}
}
bool sametree(int x, int y) { return root(x) == root(y); }
int gettreesize(int x) { return treesize[root(x)]; }
};
template <typename Type_value>
struct SegmentTree // Range Minimum Query (RMQ)
{
private:
int n;
vector<Type_value> node;
Type_value identity_element_segmenttree;
public:
SegmentTree(vector<Type_value> v,
Type_value identity_element_st) // constructor
{
int sz = v.size();
identity_element_segmenttree = identity_element_st;
n = 1;
while (n < sz) {
n <<= 1;
}
node.resize(2 * n - 1, identity_element_segmenttree);
for (int i = 0; i < sz; ++i) {
node[i + n - 1] = v[i];
}
for (int i = n - 2; i >= 0; --i) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int x, Type_value val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
Type_value getmin(int a, int b, int k = 0, int l = 0,
int r = -1) // getting minimum value in [a,b)
{
// k : index of the referred node
// [l,r) : range covered by the k-th node
if (r < 0) {
r = n;
}
if (r <= a or b <= l) {
return identity_element_segmenttree;
}
if (a <= l and r <= b) {
return node[k];
}
Type_value vl = getmin(a, b, 2 * k + 1, l, (l + r) / 2);
Type_value vr = getmin(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
template <typename Type_value>
struct BinaryIndexedTree // Range Sum Query (RSQ), 0-indexed
{
private:
int size_;
vector<Type_value> data;
public:
BinaryIndexedTree(int sz, Type_value identity_element_binaryindexedtree =
0.0) // constructor
{
size_ = sz;
data.resize(sz + 1, identity_element_binaryindexedtree);
}
Type_value sum(int i) // sum within [0,i)
{
if (i <= 0) {
return (Type_value)0.0;
}
if (i > size_) {
i = size_;
}
Type_value sm = 0.0;
while (i > 0) {
sm += data[i];
i -= i & -i;
}
return sm;
}
void add(int i, Type_value x) {
if (i < 0 or i >= size_) {
return;
}
++i;
while (i <= size_) {
data[i] += x;
i += i & -i;
}
}
};
/*------------------ the end of the template -----------------------*/
signed main() {
IOS; /* making cin faster */
int N, L;
SCAND2(N, L);
int rem = L;
int sm = 0;
REP(i, N) {
if (abs(L + i) < rem) {
rem = L + i;
}
sm += L + i;
}
PRINTD(sm - rem);
}
| #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#define stoll(argument_string) atoll((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define CIN5(x, y, z, w, u) cin >> (x) >> (y) >> (z) >> (w) >> (u)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCAND5(x, y, z, w, u) scanf("%d%d%d%d%d", &(x), &(y), &(z), &(w), &(u))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define SCANLLD5(x, y, z, w, u) \
scanf("%lld%lld%lld%lld%lld", &(x), &(y), &(z), &(w), &(u))
#define I64DSCAN(x) scanf("%I64d", &(x))
#define I64DSCAN2(x, y) scanf("%I64d%I64d", &(x), &(y))
#define I64DSCAN3(x, y, z) scanf("%I64d%I64d%I64d", &(x), &(y), &(z))
#define I64DSCAN4(x, y, z, w) \
scanf("%I64d%I64d%I64d%I64d", &(x), &(y), &(z), &(w))
#define I64DSCAN5(x, y, z, w, u) \
scanf("%I64d%I64d%I64d%I64d%I64d", &(x), &(y), &(z), &(w), &(u))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
#define PRINTI64D(x) printf("%I64d\n", (x))
#define DEBUG(argument) cerr << (#argument) << " : " << (argument) << "\n"
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
long long gcd(long long a, long long b) // assuming a,b >= 1
{
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
long long lcm(long long a, long long b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
long long pow_fast(long long x, long long n_power, long long modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
struct CombinationTable {
vector<vector<long long>> val;
CombinationTable(int size)
: val(size + 1, vector<long long>(size + 1)) // constructor
{
for (int i = 0; i <= size; ++i) // note that 0 <= i <= size
{
for (int j = 0; j <= i; ++j) {
if (j == 0 or j == i) {
val[i][j] = 1LL;
} else {
val[i][j] = val[i - 1][j - 1] + val[i - 1][j];
}
}
}
}
};
void print_vector(vector<int> &h) {
int L = h.size();
for (int i = 0; i < L; ++i) {
printf("%d", h[i]);
if (i != L - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
void print_vector(vector<long long> &h) {
int L = h.size();
for (int i = 0; i < L; ++i) {
printf("%lld", h[i]);
if (i != L - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
void print_matrix2D(vector<vector<int>> &h) {
int Ly = h.size();
int Lx = h[0].size();
for (int i = 0; i < Ly; ++i) {
for (int j = 0; j < Lx; ++j) {
printf("%d", h[i][j]);
if (j != Lx - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
}
void print_matrix2D(vector<vector<long long>> &h) {
int Ly = h.size();
int Lx = h[0].size();
for (int i = 0; i < Ly; ++i) {
for (int j = 0; j < Lx; ++j) {
printf("%lld", h[i][j]);
if (j != Lx - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
}
void print_matrix2D(vector<string> &h) {
int Ly = h.size();
int Lx = h[0].size();
for (int i = 0; i < Ly; ++i) {
for (int j = 0; j < Lx; ++j) {
printf("%c", h[i][j]);
}
printf("\n");
}
}
struct UnionFind // size-based
{
vector<int> parent, treesize;
UnionFind(int size)
: parent(size), treesize(size, 1) // constructor
{
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (treesize[x] < treesize[y]) {
parent[x] = y;
treesize[y] += treesize[x];
} else {
parent[y] = x;
treesize[x] += treesize[y];
}
}
bool sametree(int x, int y) { return root(x) == root(y); }
int gettreesize(int x) { return treesize[root(x)]; }
};
template <typename Type_value>
struct SegmentTree // Range Minimum Query (RMQ)
{
private:
int n;
vector<Type_value> node;
Type_value identity_element_segmenttree;
public:
SegmentTree(vector<Type_value> v,
Type_value identity_element_st) // constructor
{
int sz = v.size();
identity_element_segmenttree = identity_element_st;
n = 1;
while (n < sz) {
n <<= 1;
}
node.resize(2 * n - 1, identity_element_segmenttree);
for (int i = 0; i < sz; ++i) {
node[i + n - 1] = v[i];
}
for (int i = n - 2; i >= 0; --i) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int x, Type_value val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
Type_value getmin(int a, int b, int k = 0, int l = 0,
int r = -1) // getting minimum value in [a,b)
{
// k : index of the referred node
// [l,r) : range covered by the k-th node
if (r < 0) {
r = n;
}
if (r <= a or b <= l) {
return identity_element_segmenttree;
}
if (a <= l and r <= b) {
return node[k];
}
Type_value vl = getmin(a, b, 2 * k + 1, l, (l + r) / 2);
Type_value vr = getmin(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
template <typename Type_value>
struct BinaryIndexedTree // Range Sum Query (RSQ), 0-indexed
{
private:
int size_;
vector<Type_value> data;
public:
BinaryIndexedTree(int sz, Type_value identity_element_binaryindexedtree =
0.0) // constructor
{
size_ = sz;
data.resize(sz + 1, identity_element_binaryindexedtree);
}
Type_value sum(int i) // sum within [0,i)
{
if (i <= 0) {
return (Type_value)0.0;
}
if (i > size_) {
i = size_;
}
Type_value sm = 0.0;
while (i > 0) {
sm += data[i];
i -= i & -i;
}
return sm;
}
void add(int i, Type_value x) {
if (i < 0 or i >= size_) {
return;
}
++i;
while (i <= size_) {
data[i] += x;
i += i & -i;
}
}
};
/*------------------ the end of the template -----------------------*/
signed main() {
IOS; /* making cin faster */
int N, L;
SCAND2(N, L);
int rem = L;
int sm = 0;
REP(i, N) {
if (abs(L + i) < abs(rem)) {
rem = L + i;
}
sm += L + i;
}
PRINTD(sm - rem);
}
| [
"control_flow.branch.if.condition.change",
"call.add"
] | 802,871 | 802,872 | u900727536 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l, ans = 0;
cin >> n >> l;
if (l >= 0) {
ans = (2 * l + n) * (n - 1) / 2;
} else if (l + n >= 0) {
ans = (2 * l + n - 1) * n / 2;
} else {
ans = (2 * l + n - 2) * (n - 1) / 2;
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, l, ans = 0;
cin >> n >> l;
if (l >= 0) {
ans = (2 * l + n) * (n - 1) / 2;
} else if (l + n - 1 >= 0) {
ans = (2 * l + n - 1) * n / 2;
} else {
ans = (2 * l + n - 2) * (n - 1) / 2;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 802,881 | 802,882 | u367199607 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int ans = ((l) + (l + n - 1)) * n / 2;
if (l < 0 && abs(l) < n) {
} else if (l > 0) {
ans -= l;
} else {
ans -= (l + n - 1);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int ans = ((l) + (l + n - 1)) * n / 2;
if (l <= 0 && abs(l) < n) {
} else if (l > 0) {
ans -= l;
} else {
ans -= (l + n - 1);
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,897 | 802,898 | u593459816 | cpp |
p02994 | #include <iostream>
int main() {
int N, L;
std::cin >> N >> L;
int m = 10000;
int ans = N;
for (int i = 0; i < N; i++) {
if (abs(L + i - 1) < m) {
m = abs(L + i - 1);
ans = i;
}
}
int sum = 0;
for (int i = 0; i < N; i++) {
if (i == ans)
continue;
sum += (L + i - 1);
}
std::cout << sum << std::endl;
return 0;
} | #include <iostream>
int main() {
int N, L;
std::cin >> N >> L;
int m = 10000;
int ans = N;
for (int i = 0; i < N; i++) {
if (abs(L + i) < m) {
m = abs(L + i);
ans = i;
}
}
int sum = 0;
for (int i = 0; i < N; i++) {
if (i == ans)
continue;
sum += (L + i);
}
std::cout << sum << std::endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 802,902 | 802,903 | u922974720 | cpp |
p02994 | #include <iostream>
using namespace std;
int main(void) {
int N, A;
cin >> N >> A;
int L = A;
int R = N + A - 1;
int ate;
if (L >= 0) {
ate = L;
} else if (R <= 0) {
ate = R;
} else {
ate = 0;
}
cout << (L + R) * N / 2 << endl;
} | #include <iostream>
using namespace std;
int main(void) {
int N, A;
cin >> N >> A;
int L = A;
int R = N + A - 1;
int ate;
if (L >= 0) {
ate = L;
} else if (R <= 0) {
ate = R;
} else {
ate = 0;
}
cout << (L + R) * N / 2 - ate << endl;
} | [
"expression.operation.binary.add"
] | 802,904 | 802,905 | u359856428 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, c = 0;
cin >> n >> l;
int aji = l;
if (aji < 0) {
aji = -aji;
}
for (int i = 1; i <= n; i++) {
int t = l + i - 1;
if (t < 0) {
t = -t;
}
if (aji > t) {
aji = t;
c = i;
}
}
int ans = (l - 1) * n + (n * (n + 1)) / 2 - (l + c - 1);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, c = 1;
cin >> n >> l;
int aji = l;
if (aji < 0) {
aji = -aji;
}
for (int i = 1; i <= n; i++) {
int t = l + i - 1;
if (t < 0) {
t = -t;
}
if (aji > t) {
aji = t;
c = i;
}
}
int ans = (l - 1) * n + (n * (n + 1)) / 2 - (l + c - 1);
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 802,906 | 802,907 | u768638812 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, c;
cin >> n >> l;
int aji = l;
if (aji < 0) {
aji = -aji;
}
for (int i = 1; i <= n; i++) {
int t = l + i - 1;
if (t < 0) {
t = -t;
}
if (aji > t) {
aji = t;
c = i;
}
}
int ans = (l - 1) * n + (n * (n + 1)) / 2 - (l + c - 1);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, c = 1;
cin >> n >> l;
int aji = l;
if (aji < 0) {
aji = -aji;
}
for (int i = 1; i <= n; i++) {
int t = l + i - 1;
if (t < 0) {
t = -t;
}
if (aji > t) {
aji = t;
c = i;
}
}
int ans = (l - 1) * n + (n * (n + 1)) / 2 - (l + c - 1);
cout << ans << endl;
}
| [
"variable_declaration.value.change"
] | 802,908 | 802,907 | u768638812 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int f = N + L - 1;
int eat;
if (L >= 0)
eat = L;
else if (f <= 0)
eat = f;
else
eat = 0;
int ans = (f * L) * (f - L + 1) / 2 - eat;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int f = N + L - 1;
int eat;
if (L >= 0)
eat = L;
else if (f <= 0)
eat = f;
else
eat = 0;
int ans = (f + L) * (f - L + 1) / 2 - eat;
cout << ans << endl;
} | [
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 802,914 | 802,915 | u914086391 | cpp |
p02994 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
static const unsigned long long int MOD = 1000000007LL;
int main() {
int n, l, res = 0, eat = 1000000;
cin >> n >> l;
for (int i = 1; i <= n; i++) {
int tmp = l + i - 1;
res += tmp;
if (abs(tmp) < eat) {
eat = tmp;
}
}
cout << res - eat;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
static const unsigned long long int MOD = 1000000007LL;
int main() {
int n, l, res = 0, eat = 1000000;
cin >> n >> l;
for (int i = 1; i <= n; i++) {
int tmp = l + i - 1;
res += tmp;
if (abs(tmp) < abs(eat)) {
eat = tmp;
}
}
cout << res - eat;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 802,928 | 802,929 | u814440174 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int ans = 0;
if (0 < (1 + l - 1)) {
for (int i = 2; i <= n; i++) {
ans += i + l - 1;
}
} else if (0 > (n + l - 1)) {
for (int i = 1; i < n; i++) {
ans += i + l - 1;
}
} else {
for (int i = 1; i < 1 - l; i++) {
ans += i + l - 1;
}
for (int i = 2 - l; i < n; i++) {
ans += i + l - 1;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int ans = 0;
if (0 < (1 + l - 1)) {
for (int i = 2; i <= n; i++) {
ans += i + l - 1;
}
} else if (0 > (n + l - 1)) {
for (int i = 1; i < n; i++) {
ans += i + l - 1;
}
} else {
for (int i = 1; i < 1 - l; i++) {
ans += i + l - 1;
}
for (int i = 2 - l; i <= n; i++) {
ans += i + l - 1;
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,932 | 802,933 | u103850114 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, sum = 0;
scanf("%d%d", &n, &l);
vector<int> vc;
for (int i = 1; i <= n; i++)
vc.push_back(l + i - 1);
sort(vc.begin(), vc.end());
if (vc[0] > 0) {
for (int i = 1; i < n; i++)
sum += vc[i];
} else if (vc[0] < 0 && vc[n - 1] > 0) {
for (int i = 0; i < n; i++)
sum += vc[i];
} else if (vc[n - 1] < 0) {
for (int i = 0; i < n - 1; i++)
sum += vc[i];
}
printf("%d\n", sum);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, sum = 0;
scanf("%d%d", &n, &l);
vector<int> vc;
for (int i = 1; i <= n; i++)
vc.push_back(l + i - 1);
sort(vc.begin(), vc.end());
if (vc[0] >= 0) {
for (int i = 1; i < n; i++)
sum += vc[i];
} else if (vc[0] <= 0 && vc[n - 1] > 0) {
for (int i = 0; i < n; i++)
sum += vc[i];
} else if (vc[n - 1] <= 0) {
for (int i = 0; i < n - 1; i++)
sum += vc[i];
}
printf("%d\n", sum);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,936 | 802,937 | u738354051 | cpp |
p02994 | // templates
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
#define SZ(x) ((int)(x).size())
typedef long long ll;
using namespace std;
// main
int main() {
int N, L;
int gap;
int a;
cin >> N >> L;
vector<int> ans(N);
int sum = (L - 1) * N + N * (N + 1) / 2;
rep(i, N) {
gap = abs(L + i);
if (gap >= 0)
a = -1;
else
a = 1;
ans[i] = abs(gap);
}
cout << sum - a * (*min_element(ALL(ans))) << endl;
} | // templates
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
#define SZ(x) ((int)(x).size())
typedef long long ll;
using namespace std;
// main
int main() {
int N, L;
int gap;
int a;
cin >> N >> L;
vector<int> ans(N);
int sum = (L - 1) * N + N * (N + 1) / 2;
rep(i, N) {
gap = L + i;
if (gap >= 0)
a = 1;
else
a = -1;
ans[i] = abs(gap);
}
cout << sum - a * (*min_element(ALL(ans))) << endl;
}
| [
"call.remove",
"call.arguments.change",
"expression.operation.unary.arithmetic.remove",
"expression.operation.unary.arithmetic.add"
] | 802,938 | 802,939 | u970738863 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> a(N);
for (int i = 0; i < N; i++) {
a.at(i) = L + i;
}
int ans = 0;
if (a.at(0) >= 0) {
for (int i = 1; i < N; i++) {
ans += a.at(i);
}
} else if (a.at(N) <= 0) {
for (int i = 0; i < N - 1; i++) {
ans += a.at(i);
}
} else {
for (int i = 0; i < N; i++) {
ans += a.at(i);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> a(N);
for (int i = 0; i < N; i++) {
a.at(i) = L + i;
}
int ans = 0;
if (a.at(0) >= 0) {
for (int i = 1; i < N; i++) {
ans += a.at(i);
}
} else if (a.at(N - 1) <= 0) {
for (int i = 0; i < N - 1; i++) {
ans += a.at(i);
}
} else {
for (int i = 0; i < N; i++) {
ans += a.at(i);
}
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 802,949 | 802,950 | u839110000 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> a(N);
for (int i = 0; i < N; i++) {
a.at(i) = L + i;
}
int ans = 0;
if (a.at(0) >= 0) {
for (int i = 1; i < N; i++) {
ans += a.at(i);
}
} else if (a.at(N <= 0)) {
for (int i = 0; i < N - 1; i++) {
ans += a.at(i);
}
} else {
for (int i = 0; i < N; i++) {
ans += a.at(i);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> a(N);
for (int i = 0; i < N; i++) {
a.at(i) = L + i;
}
int ans = 0;
if (a.at(0) >= 0) {
for (int i = 1; i < N; i++) {
ans += a.at(i);
}
} else if (a.at(N - 1) <= 0) {
for (int i = 0; i < N - 1; i++) {
ans += a.at(i);
}
} else {
for (int i = 0; i < N; i++) {
ans += a.at(i);
}
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"call.arguments.add"
] | 802,951 | 802,950 | u839110000 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
int main() {
int n, l;
cin >> n >> l;
int min = 1000;
int sum = 0;
rep(i, n) {
if (min > abs(l + i))
min = abs(l + i);
sum += l + i;
}
if (l + n >= 0)
cout << sum - min << endl;
else
cout << sum + min << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
int main() {
int n, l;
cin >> n >> l;
int min = 1000;
int sum = 0;
rep(i, n) {
if (min > abs(l + i))
min = abs(l + i);
sum += l + i;
}
if (l + n > 0)
cout << sum - min << endl;
else
cout << sum + min << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,952 | 802,953 | u207048881 | cpp |
p02994 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, L;
cin >> N >> L;
if (1 - N <= L && L <= 0) {
cout << N * (L - 1) + (N * (N + 1)) / 2 << endl;
} else if (L > 0) {
cout << N * (L - 1) + (N * (N + 1)) / 2 - 2 << endl;
} else if (L < (1 - N)) {
cout << N * (L - 1) + (N * (N + 1)) / 2 - (L + N - 1) << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, L;
cin >> N >> L;
if (1 - N <= L && L <= 0) {
cout << N * (L - 1) + (N * (N + 1)) / 2 << endl;
} else if (L > 0) {
cout << N * (L - 1) + (N * (N + 1)) / 2 - L << endl;
} else if (L < (1 - N)) {
cout << N * (L - 1) + (N * (N + 1)) / 2 - (L + N - 1) << endl;
}
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 802,956 | 802,957 | u904123392 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L, x;
cin >> N >> L;
if (L < 0 && N + L - 1 > 0) {
x = 0;
}
if (L < 0 && N + L - 1 < 0) {
x = N + L - 1;
}
if (L > 0) {
x = L;
}
cout << N * (N + 1) / 2 - x << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L, x;
cin >> N >> L;
if (L < 0 && N + L - 1 > 0) {
x = 0;
}
if (L < 0 && N + L - 1 < 0) {
x = N + L - 1;
}
if (L > 0) {
x = L;
}
cout << N * (2 * L + N - 1) / 2 - x << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change"
] | 802,959 | 802,960 | u438592861 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int n, l, arr[400], sum;
int main() {
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) {
arr[i - 1] = i + l - 1;
sum += arr[i - 1];
}
sort(arr, arr + n);
if (arr[0] < 0 && arr[n - 1] < 0)
printf("%d\n", sum - arr[n - 1]);
else if (arr[0] > 0 && arr[n - 1] > 0)
printf("%d\n", sum - arr[0]);
else
printf("0\n");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, l, arr[400], sum;
int main() {
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) {
arr[i - 1] = i + l - 1;
sum += arr[i - 1];
}
sort(arr, arr + n);
if (arr[0] < 0 && arr[n - 1] < 0)
printf("%d\n", sum - arr[n - 1]);
else if (arr[0] > 0 && arr[n - 1] > 0)
printf("%d\n", sum - arr[0]);
else
printf("%d\n", sum);
return 0;
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change",
"call.arguments.add"
] | 802,961 | 802,962 | u547105766 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l, sum;
cin >> n >> l;
if (l >= 0) {
sum = l * (n - 1) + (n - 1) * n / 2;
} else {
if (-l <= n) {
sum = l * n + (n - 1) * n / 2;
} else {
sum = l * n + (n - 1) * n / 2 - (l + n - 1);
}
}
cout << sum << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, l, sum;
cin >> n >> l;
if (l >= 0) {
sum = l * (n - 1) + (n - 1) * n / 2;
} else {
if (-l < n) {
sum = l * n + (n - 1) * n / 2;
} else {
sum = l * n + (n - 1) * n / 2 - (l + n - 1);
}
}
cout << sum << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,965 | 802,966 | u666641075 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = n * (2 * l + n - 1) / 2;
if (n * (l + n - 1) <= 0) {
cout << sum << endl;
}
else if (l > 0) {
cout << sum - l << endl;
}
else {
cout << sum - l - n + 1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = n * (2 * l + n - 1) / 2;
if (l * (l + n - 1) <= 0) {
cout << sum << endl;
}
else if (l > 0) {
cout << sum - l << endl;
}
else {
cout << sum - l - n + 1 << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 802,967 | 802,968 | u522993719 | cpp |
p02994 | #include <iostream>
#include <vector>
#define rep(i, N) for (int i = 0; i < N; i++)
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> a(N);
int s = 0;
rep(i, N) {
a[i] = L + i - 1;
s += a[i];
}
int ans = 1e9;
rep(i, N) {
int t = s - a[i];
if (abs(t - s) < abs(ans - s))
ans = t;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
#define rep(i, N) for (int i = 0; i < N; i++)
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> a(N);
int s = 0;
rep(i, N) {
a[i] = L + i;
s += a[i];
}
int ans = 1e9;
rep(i, N) {
int t = s - a[i];
if (abs(t - s) < abs(ans - s))
ans = t;
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 802,971 | 802,972 | u323327162 | cpp |
p02994 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll INFll = 1ll << 60;
int main() {
int n, l;
cin >> n >> l;
if (l >= 0) {
cout << (l + 2 - 1 + l + n - 1) * (n - 1) / 2 << endl;
} else {
cout << (l + 1 - 1 + l + n - 1) * n / 2 - l + min(n, 1 - l) - 1 << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll INFll = 1ll << 60;
int main() {
int n, l;
cin >> n >> l;
if (l >= 0) {
cout << (l + 2 - 1 + l + n - 1) * (n - 1) / 2 << endl;
} else {
cout << (l + 1 - 1 + l + n - 1) * n / 2 - (l + min(n, 1 - l) - 1) << endl;
}
return 0;
}
| [] | 802,973 | 802,974 | u735008991 | cpp |
p02994 | #include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
/* (๑╹◡╹) */
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll MOD = 1000000007;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* (๑╹◡╹)(๑╹◡╹)(๑╹◡╹)*/
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* (๑╹◡╹)(๑╹◡╹)(๑╹◡╹)(๑╹◡╹)(๑╹◡╹)(๑╹◡╹) */
///////////////////////////////////////////////
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
int main() {
int ans = 0;
int N, L;
cin >> N >> L;
for (int i = 0; i < N; i++) {
ans += L + i;
}
if (L > 0) {
ans -= L;
} else if (L + N < 0) {
ans -= (L + N - 1);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
/* (๑╹◡╹) */
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll MOD = 1000000007;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* (๑╹◡╹)(๑╹◡╹)(๑╹◡╹)*/
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* (๑╹◡╹)(๑╹◡╹)(๑╹◡╹)(๑╹◡╹)(๑╹◡╹)(๑╹◡╹) */
///////////////////////////////////////////////
const int MAX = 510000;
long long fac[MAX], finv[MAX], inv[MAX];
int main() {
int ans = 0;
int N, L;
cin >> N >> L;
for (int i = 0; i < N; i++) {
ans += L + i;
}
if (L > 0) {
ans -= L;
} else if (L + N - 1 < 0) {
ans -= (L + N - 1);
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 802,977 | 802,978 | u532894762 | cpp |
p02994 | #include <iostream>
using namespace std;
int main(void) {
int n, l;
cin >> n >> l;
int ans = 0;
if (l >= 0) {
for (int i = 2; i <= n; i++) {
ans += l + i - 1;
}
} else {
if (n - abs(l) >= 0) {
for (int i = 1; i <= n; i++) {
ans += l + i - 1;
}
} else {
for (int i = 1; i <= n; i++) {
ans += l + i - 1;
}
ans -= l + n - 1;
}
}
cout << ans;
}
| #include <iostream>
using namespace std;
int main(void) {
int n, l;
cin >> n >> l;
int ans = 0;
if (l >= 0) {
for (int i = 2; i <= n; i++) {
ans += l + i - 1;
}
} else {
if (n - abs(l) > 0) {
for (int i = 1; i <= n; i++) {
ans += l + i - 1;
}
} else {
for (int i = 1; i <= n; i++) {
ans += l + i - 1;
}
ans -= l + n - 1;
}
}
cout << ans;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 802,981 | 802,982 | u934529721 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
vector<int> vec(n);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += l + i;
vec.at(i) = l + i;
}
int eat = 0;
if (vec.at(0) > 0) {
eat = vec.at(0);
} else if (vec.at(n) < 0) {
eat = vec.at(n);
}
cout << sum - eat << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
vector<int> vec(n);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += l + i;
vec.at(i) = l + i;
}
int eat = 0;
if (vec.at(0) > 0) {
eat = vec.at(0);
} else if (vec.at(n - 1) < 0) {
eat = vec.at(n - 1);
}
cout << sum - eat << endl;
} | [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 803,008 | 803,009 | u249218227 | cpp |
p02994 | #include <iostream>
#include <numeric>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int arr[n];
// taking into array
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr[i] += i;
}
if (l > 0)
cout << accumulate(arr + 1, arr + n, 0) << '\n';
else if (l > -n)
cout << accumulate(arr, arr + n, 0) << '\n';
else
cout << accumulate(arr, arr + n - 1, 0) << '\n';
return 0;
} | #include <iostream>
#include <numeric>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int arr[n];
// taking into array
for (int i = 0; i < n; i++) {
arr[i] = l;
arr[i] += i;
}
if (l > 0)
cout << accumulate(arr + 1, arr + n, 0) << '\n';
else if (l > -n)
cout << accumulate(arr, arr + n, 0) << '\n';
else
cout << accumulate(arr, arr + n - 1, 0) << '\n';
return 0;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 803,010 | 803,011 | u551519692 | cpp |
p02994 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int N, L;
int i;
int absmin = 9999999;
int apple[300];
int sum = 0;
cin >> N >> L;
for (i = 0; i < N; ++i) {
apple[i] = L + i;
sum += apple[i];
}
for (i = 0; i < N; ++i) {
if (abs(apple[i]) < absmin) {
absmin = apple[i];
}
}
cout << sum - absmin << endl;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int N, L;
int i;
int absmin = 9999999;
int apple[300];
int sum = 0;
cin >> N >> L;
for (i = 0; i < N; ++i) {
apple[i] = L + i;
sum += apple[i];
}
for (i = 0; i < N; ++i) {
if (abs(apple[i]) < abs(absmin)) {
absmin = apple[i];
}
// cout << absmin << endl;
}
cout << sum - absmin << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 803,012 | 803,013 | u949097771 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define Rep(j, n) for (int j = 0; j < (int)(n); ++j)
#define Repo(j, o, n) for (int j = o; j < (int)(n); ++j)
#define Repone(j, n) for (int j = 1; j < (int)(n); ++j)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define int long long
#define pb(a) push_back(a)
#define eraser(v, i) (v).erase(v.begin() + (i))
#define pbpair(a, b) push_back(make_pair(a, b))
#define MOD 1000000007
#define INF 9223372036854775807
#define pairint pair<int, int>
signed main() {
int x = 0, y = 0, z = 0, w = 0, n = 0, m = 0, a = 0, b = 0;
std::cin >> x >> y;
if (0 <= y) {
rep(i, x) { z += i + y; }
std::cout << z - y << '\n';
} else {
if (x < abs(y)) {
rep(i, x - 1) { z += i + y; }
std::cout << z << '\n';
} else {
rep(i, x) { z += i + y; }
std::cout << z << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define Rep(j, n) for (int j = 0; j < (int)(n); ++j)
#define Repo(j, o, n) for (int j = o; j < (int)(n); ++j)
#define Repone(j, n) for (int j = 1; j < (int)(n); ++j)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define int long long
#define pb(a) push_back(a)
#define eraser(v, i) (v).erase(v.begin() + (i))
#define pbpair(a, b) push_back(make_pair(a, b))
#define MOD 1000000007
#define INF 9223372036854775807
#define pairint pair<int, int>
signed main() {
int x = 0, y = 0, z = 0, w = 0, n = 0, m = 0, a = 0, b = 0;
std::cin >> x >> y;
if (0 <= y) {
rep(i, x) { z += i + y; }
std::cout << z - y << '\n';
} else {
if (x <= abs(y)) {
rep(i, x - 1) { z += i + y; }
std::cout << z << '\n';
} else {
rep(i, x) { z += i + y; }
std::cout << z << '\n';
}
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,014 | 803,015 | u893330446 | cpp |
p02994 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using llint = long long;
using vint = vector<int>;
using vvint = vector<vector<int>>;
const llint INF = 1e9;
const llint llINF = 1e18;
int main() {
int n, l;
cin >> n >> l;
vint a(n);
for (int i = 0; i < n; i++) {
a[i] = l + i;
}
int s = 0;
for (int i = 0; i < n; i++) {
s += a[i];
}
int ans = INF;
for (int i = 0; i < n; i++) {
int t = s - a[i];
if (abs(t - s), abs(ans - s))
ans = t;
}
cout << ans << endl;
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using llint = long long;
using vint = vector<int>;
using vvint = vector<vector<int>>;
const llint INF = 1e9;
const llint llINF = 1e18;
int main() {
int n, l;
cin >> n >> l;
vint a(n);
for (int i = 0; i < n; i++) {
a[i] = l + i;
}
int s = 0;
for (int i = 0; i < n; i++) {
s += a[i];
}
int ans = INF;
for (int i = 0; i < n; i++) {
int t = s - a[i];
if (abs(t - s) < abs(ans - s))
ans = t;
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 803,016 | 803,017 | u932319885 | cpp |
p02994 | #include <iostream>
#include <vector>
int main() {
int n, l;
std::cin >> n >> l;
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += l + i;
}
int buf;
if (l < 0 && 0 < l + n - 1) {
buf = 0;
} else if (l + n - 1 < 0) {
buf = l + n - 1;
} else if (0 < l) {
buf = l;
}
std::cout << sum - buf << std::endl;
return 0;
}
| #include <iostream>
#include <vector>
int main() {
int n, l;
std::cin >> n >> l;
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += l + i;
}
int buf;
if (l <= 0 && 0 <= l + n - 1) {
buf = 0;
} else if (l + n - 1 < 0) {
buf = l + n - 1;
} else if (0 < l) {
buf = l;
}
std::cout << sum - buf << std::endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,018 | 803,019 | u913226400 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> v(N);
int count = 0;
int sum = 0;
for (int i = 0; i < N; i++) {
v.at(i) = L + i;
// cout << "i=" << v.at(i) << endl;
sum += v.at(i);
// cout << "sum=" << sum << endl;
if (v.at(i) == 0) {
count++;
// cout << "count=" << count << endl;
}
}
int h_min = 300;
int m_min;
if (count != 1) {
for (int i = 0; i < N; i++) {
m_min = min(abs(v.at(i)), h_min);
h_min = m_min;
if (i == N - 1) {
if (sum > 0) {
cout << sum - h_min << endl;
} else if (sum < 0) {
cout << sum + h_min << endl;
}
}
}
} else {
cout << 0 << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
vector<int> v(N);
int count = 0;
int sum = 0;
for (int i = 0; i < N; i++) {
v.at(i) = L + i;
// cout << "i=" << v.at(i) << endl;
sum += v.at(i);
// cout << "sum=" << sum << endl;
if (v.at(i) == 0) {
count++;
// cout << "count=" << count << endl;
}
}
int h_min = 300;
int m_min;
if (count != 1) {
for (int i = 0; i < N; i++) {
m_min = min(abs(v.at(i)), h_min);
h_min = m_min;
if (i == N - 1) {
if (sum > 0) {
cout << sum - h_min << endl;
} else if (sum < 0) {
cout << sum + h_min << endl;
}
}
}
} else {
cout << sum << endl;
}
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 803,020 | 803,021 | u062744808 | cpp |
p02994 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
const int INF = 100100100;
using namespace std;
int main() {
int N, L;
int res = 0;
cin >> N >> L;
for (int i = 1; i <= N; i++) {
res += L + i - 1;
}
if (L >= 0) {
res -= L;
} else if (-L > N) {
res -= L + N - 1;
} else {
// none
}
cout << res << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
const int INF = 100100100;
using namespace std;
int main() {
int N, L;
int res = 0;
cin >> N >> L;
for (int i = 1; i <= N; i++) {
res += L + i - 1;
}
if (L >= 0) { // all positive
res -= L;
} else if (L + N - 1 < 0) { // all negative
res -= L + N - 1;
} else {
// none
}
cout << res << endl;
} | [
"expression.operation.unary.arithmetic.remove",
"control_flow.branch.if.condition.change"
] | 803,022 | 803,023 | u411427373 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L >= 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L - 1 < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L > 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 803,030 | 803,031 | u399527001 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L > 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L - 1 < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L > 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 803,032 | 803,031 | u399527001 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L >= 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L - 1 < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L > 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 803,030 | 803,033 | u399527001 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L > 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int count = (2 * L + N - 1) * N / 2;
if (N + L - 1 < 0) {
cout << count - (L + N - 1) << endl;
} else {
if (L > 0)
cout << count - L << endl;
else
cout << count << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 803,032 | 803,033 | u399527001 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int t = L * N + N * (N + 1) / 2 - N;
if ((L - 1 <= 0 && L + N - 1 >= 0) || (L - 1 >= 0 && L + N - 1 <= 0)) {
cout << t;
} else if (L >= 0) {
cout << t - L;
} else {
cout << t - L - N + 1;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int t = L * N + N * (N + 1) / 2 - N;
if ((L <= 0 && L + N - 1 >= 0) || (L >= 0 && L + N - 1 <= 0)) {
cout << t;
} else if (L >= 0) {
cout << t - L;
} else {
cout << t - L - N + 1;
}
return 0;
} | [
"expression.operation.binary.remove"
] | 803,038 | 803,039 | u577354075 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int t = L * N + N * (N + 1) / 2 - N;
if ((L - 1 <= 0 && L + N - 1 >= 0) || (L - 1 >= 0 && L + N - 1 <= 0)) {
cout << t;
} else if (L > 0) {
cout << t - L;
} else {
cout << t - L - N + 1;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int t = L * N + N * (N + 1) / 2 - N;
if ((L <= 0 && L + N - 1 >= 0) || (L >= 0 && L + N - 1 <= 0)) {
cout << t;
} else if (L >= 0) {
cout << t - L;
} else {
cout << t - L - N + 1;
}
return 0;
} | [
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,040 | 803,039 | u577354075 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int sum = 0, m, mm = 100;
for (int i = 1; i <= N; i++) {
sum += L + i - 1;
if (abs(L + i - 1) < abs(mm)) {
m = i;
mm = L + i - 1;
}
}
cout << sum - (L + m - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int sum = 0, m, mm = 300;
for (int i = 1; i <= N; i++) {
sum += L + i - 1;
if (abs(L + i - 1) < abs(mm)) {
m = i;
mm = L + i - 1;
}
}
cout << sum - (L + m - 1) << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 803,045 | 803,046 | u298291365 | cpp |
p02994 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, l, x, sum, r;
cin >> n >> l;
int a = l;
x = l + n - 1;
if (a > 0) {
r = a;
} else if (a <= 0 && l >= 0) {
r = 0;
} else {
r = x;
}
sum = ((x - a + 1) * (a + x)) / 2;
sum -= r;
cout << sum << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, l, x, sum, r;
cin >> n >> l;
int a = l;
x = l + n - 1;
if (a > 0) {
r = a;
} else if (a <= 0 && x >= 0) {
r = 0;
} else {
r = x;
}
sum = ((x - a + 1) * (a + x)) / 2;
sum -= r;
cout << sum << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 803,049 | 803,050 | u553461888 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
// 入力
int N, L;
cin >> N >> L;
int answer = 0;
int eatApple = 0;
// 最小の絶対値を求める
int minAbs = abs(L);
for (int i = 0; i < N; i++) {
answer += L + i;
if (minAbs > abs(L + i)) {
minAbs = abs(L + i);
// 味の値
eatApple = L + i;
}
}
// 総和の味 - 食べたリンゴの最小の味
answer -= eatApple;
// 出力
cout << answer << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
// 入力
int N, L;
cin >> N >> L;
int answer = 0;
// 食べたリンゴの味
int eatApple = L;
// 最小の絶対値を求める
int minAbs = abs(L);
for (int i = 0; i < N; i++) {
answer += L + i;
if (minAbs > abs(L + i)) {
minAbs = abs(L + i);
// 味の値
eatApple = L + i;
}
}
// 総和の味 - 食べたリンゴの最小の味
answer -= eatApple;
// 出力
cout << answer << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 803,056 | 803,057 | u865500049 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, ans = 0;
cin >> n >> l;
for (int i = l; i < l + n; i++) {
ans += i;
}
if (l < 0 && n <= (-l)) {
ans += l + n - 1;
}
if (l > 0) {
ans -= l;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, ans = 0;
cin >> n >> l;
for (int i = l; i < l + n; i++) {
ans += i;
}
if (l < 0 && n <= (-l)) {
ans -= l + n - 1;
}
if (l > 0) {
ans -= l;
}
cout << ans << endl;
} | [
"expression.operator.change"
] | 803,073 | 803,074 | u442754977 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, ans = 0;
cin >> n >> l;
for (int i = l; i < l + n; i++) {
ans += i;
}
if (l < 0 && n <= (-l)) {
ans += l + n - 1;
}
if (l > 0) {
ans += l;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, ans = 0;
cin >> n >> l;
for (int i = l; i < l + n; i++) {
ans += i;
}
if (l < 0 && n <= (-l)) {
ans -= l + n - 1;
}
if (l > 0) {
ans -= l;
}
cout << ans << endl;
} | [
"expression.operator.change"
] | 803,075 | 803,074 | u442754977 | cpp |
p02994 | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
int main() {
ll ans = 0, n, l, absmin = 10000;
cin >> n >> l;
vector<ll> p(n);
rep(i, n) p.at(i) = l - 1 + i;
ans = accumulate(p.begin(), p.end(), 0);
rep(i, n) if (abs(absmin) > abs(p.at(i))) absmin = p.at(i);
ans -= absmin;
cout << ans << endl;
}
| #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
int main() {
ll ans = 0, n, l, absmin = 10000;
cin >> n >> l;
vector<ll> p(n);
rep(i, n) p.at(i) = l + i;
ans = accumulate(p.begin(), p.end(), 0);
rep(i, n) if (abs(absmin) > abs(p.at(i))) absmin = p.at(i);
ans -= absmin;
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 803,082 | 803,083 | u059207724 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long L) {
long long ans = 0;
if (L < 0) {
if (L + N >= 0) {
for (int i = 0; i < N; i++) {
ans += L;
L++;
}
} else {
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
} else {
L++;
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
cout << ans << endl;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long L;
scanf("%lld", &L);
solve(N, L);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long L) {
long long ans = 0;
if (L <= 0) {
if (L + N - 1 >= 0) {
for (int i = 0; i < N; i++) {
ans += L;
L++;
}
} else {
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
} else {
L++;
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
cout << ans << endl;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long L;
scanf("%lld", &L);
solve(N, L);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,084 | 803,085 | u329399746 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long L) {
long long ans = 0;
if (L <= 0) {
if (L + N >= 0) {
for (int i = 0; i < N; i++) {
ans += L;
L++;
}
} else {
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
} else {
L++;
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
cout << ans << endl;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long L;
scanf("%lld", &L);
solve(N, L);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long L) {
long long ans = 0;
if (L <= 0) {
if (L + N - 1 >= 0) {
for (int i = 0; i < N; i++) {
ans += L;
L++;
}
} else {
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
} else {
L++;
for (int i = 0; i < N - 1; i++) {
ans += L;
L++;
}
}
cout << ans << endl;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long L;
scanf("%lld", &L);
solve(N, L);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 803,086 | 803,085 | u329399746 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int L = l;
int R = l + n - 1;
int eat;
if (R <= 0)
eat = R;
else if (L >= 0)
eat = L;
else
eat = 0;
cout << (R + L) * (R - L + 1) / 2 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int L = l;
int R = l + n - 1;
int eat;
if (R <= 0)
eat = R;
else if (L >= 0)
eat = L;
else
eat = 0;
cout << (R + L) * (R - L + 1) / 2 - eat << endl;
} | [
"expression.operation.binary.add"
] | 803,087 | 803,088 | u538400413 | cpp |
p02994 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(x) (x).begin(), (x).end()
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;
}
typedef long long ll;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, l;
cin >> n >> l;
if (l * (n - l - 1) <= 0) {
cout << (n + 2 * l - 1) * n / 2 << endl;
} else if ((n - l - 1) <= 0) {
cout << (n + 2 * l - 1) * n / 2 - (n - l - 1) << endl;
} else {
cout << (n + 2 * l - 1) * n / 2 - l << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(x) (x).begin(), (x).end()
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;
}
typedef long long ll;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, l;
cin >> n >> l;
if (l * (n + l - 1) <= 0) {
cout << (n + 2 * l - 1) * n / 2 << endl;
} else if ((n + l - 1) <= 0) {
cout << (n + 2 * l - 1) * n / 2 - (n + l - 1) << endl;
} else {
cout << (n + 2 * l - 1) * n / 2 - l << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 803,090 | 803,091 | u834415466 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
int nijou;
int hozon = 10000;
int num = 0;
int wa = 0;
cin >> N >> L;
for (int i = 1; i <= N; i++) {
nijou = pow(L + i - 1, 2);
wa += L + i - 1;
if (hozon > nijou) {
hozon = nijou;
num = i;
}
}
cout << wa - (L + num - 1);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
int nijou;
int hozon = 10000000000000;
int num = 0;
int wa = 0;
cin >> N >> L;
for (int i = 1; i <= N; i++) {
nijou = pow(L + i - 1, 2);
wa += L + i - 1;
if (hozon > nijou) {
hozon = nijou;
num = i;
}
}
cout << wa - (L + num - 1);
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 803,092 | 803,093 | u459584010 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int ans = 0;
for (int i = 0; i < n; i++) {
ans += l + i;
}
if (l > 0) {
ans -= l;
} else if (l + n < 0) {
ans -= l + n - 1;
}
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int ans = 0;
for (int i = 0; i < n; i++) {
ans += l + i;
}
if (l > 0) {
ans -= l;
} else if (l + n <= 0) {
ans -= l + n - 1;
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,100 | 803,101 | u293511800 | cpp |
p02994 | #include <iostream>
#define ABS(X) ((X) < 0 ? -(X) : (X))
#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
using namespace std;
int main(void) {
int n, l;
int mn, sm = 0;
cin >> n >> l;
mn = ABS(l);
for (int i = 1; i <= n; i++) {
sm += (l + i - 1);
mn = MIN(mn, l + i - 1);
}
cout << (sm - mn) << endl;
return 0;
} | #include <iostream>
#define ABS(X) ((X) < 0 ? -(X) : (X))
#define MINABS(X, Y) (ABS(X) < ABS(Y) ? (X) : (Y))
using namespace std;
int main(void) {
int n, l;
int mn, sm = 0;
cin >> n >> l;
mn = ABS(l);
for (int i = 1; i <= n; i++) {
sm += (l + i - 1);
mn = MINABS(mn, l + i - 1);
}
cout << (sm - mn) << endl;
return 0;
} | [
"identifier.change",
"assignment.value.change",
"call.function.change"
] | 803,108 | 803,109 | u023463844 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int buff;
buff = L;
// cout<<buff<<endl;
for (int i = 1; i < N; i++) {
buff += (i + L);
// cout<<buff<<endl;
}
if (L + N < 0) {
buff -= L + N - 1;
} else if (L < 0) {
} else if (L >= 0) {
buff -= L;
}
cout << buff << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int buff;
buff = L;
// cout<<buff<<endl;
for (int i = 1; i < N; i++) {
buff += (i + L);
// cout<<buff<<endl;
}
if (L + N - 1 < 0) {
buff -= L + N - 1;
} else if (L < 0) {
} else if (L >= 0) {
buff -= L;
}
cout << buff << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 803,114 | 803,115 | u390712114 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
if (l >= 0)
cout << (l * 2 + n) * (n - 1) / 2 << endl;
else if (l + n < 0)
cout << (l * 2 + n - 2) * (n - 1) / 2 << endl;
else
cout << (l * 2 + n - 1) * n / 2 << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
if (l >= 0)
cout << (l * 2 + n) * (n - 1) / 2 << endl;
else if (l + n - 1 < 0)
cout << (l * 2 + n - 2) * (n - 1) / 2 << endl;
else
cout << (l * 2 + n - 1) * n / 2 << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 803,124 | 803,125 | u597243424 | cpp |
p02994 | #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define rep(i, a, n) for (int i = a; i < n; i++)
#define INF 1e9
#define LINF 1e17
#define MOD (int)(1e9 + 7)
#define pi 3.141592653589
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define ALL(a) (a).begin(), (a).end()
#define sort_v(a) sort(a.begin(), a.end())
#define fi first
#define se second
void print(bool a) {
if (a == true)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
ll gcdll(ll a, ll b) {
while (1) {
if (a < b)
swap(a, b);
if (b == 0)
break;
a %= b;
}
return a;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
int n, l;
cin >> n >> l;
int sum = (n * (2 * l + n - 1)) / 2;
// cout << sum << endl;
if (l >= 0) {
sum -= l;
} else {
if (l + n < 0)
sum -= l + n - 1;
}
cout << sum << endl;
}
| #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define rep(i, a, n) for (int i = a; i < n; i++)
#define INF 1e9
#define LINF 1e17
#define MOD (int)(1e9 + 7)
#define pi 3.141592653589
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define ALL(a) (a).begin(), (a).end()
#define sort_v(a) sort(a.begin(), a.end())
#define fi first
#define se second
void print(bool a) {
if (a == true)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
ll gcdll(ll a, ll b) {
while (1) {
if (a < b)
swap(a, b);
if (b == 0)
break;
a %= b;
}
return a;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
int n, l;
cin >> n >> l;
int sum = (n * (2 * l + n - 1)) / 2;
// cout << sum << endl;
if (l >= 0) {
sum -= l;
} else {
if (l + n - 1 < 0)
sum -= l + n - 1;
}
cout << sum << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 803,130 | 803,131 | u705296057 | cpp |
p02994 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, L;
vector<double> V;
int sum1 = 0; //食べる前の味
int sum2 = 0; //食べた後の味
int wk = 99999;
cin >> N >> L;
for (int i = 0; i < N; i++) {
sum1 = sum1 + (L + i);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
sum2 = sum1 - (L + i - 1);
}
if ((abs(sum2 - sum1)) < abs(wk - sum1)) {
wk = sum2;
}
}
cout << wk << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, L;
vector<double> V;
int sum1 = 0; //食べる前の味
int sum2 = 0; //食べた後の味
int wk = 99999;
cin >> N >> L;
for (int i = 0; i < N; i++) {
sum1 = sum1 + (L + i);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
sum2 = sum1 - (L + i);
}
if ((abs(sum2 - sum1)) < abs(wk - sum1)) {
wk = sum2;
}
}
cout << wk << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 803,139 | 803,140 | u372187342 | cpp |
p02994 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = 0, m = 99999;
for (int i = 0; i < n; i++) {
sum += l + i;
if (abs(l + i) < m)
m = l + i;
}
cout << sum - m << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = 0, m = 99999;
for (int i = 0; i < n; i++) {
sum += l + i;
if (abs(l + i) < abs(m))
m = l + i;
}
cout << sum - m << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 803,145 | 803,146 | u054798759 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, L;
cin >> N >> L;
int eat;
if (L >= 0)
eat = L;
if (L + N - 1 <= 0)
eat = L + N - 1;
else
eat = 0;
int kekka;
kekka = N * (2 * L + N - 1) / 2 - eat;
cout << kekka << '\n';
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, L;
cin >> N >> L;
int eat;
if (L >= 0)
eat = L;
else if (L + N - 1 <= 0)
eat = L + N - 1;
else
eat = 0;
int kekka;
kekka = N * (2 * L + N - 1) / 2 - eat;
cout << kekka << '\n';
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 803,147 | 803,148 | u853585082 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, L;
cin >> N >> L;
int eat;
if (L > 0)
eat = L;
if (L + N - 1 < 0)
eat = L + N - 1;
else
eat = 0;
int kekka;
kekka = N * (2 * L + N - 1) / 2 - eat;
cout << kekka << '\n';
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, L;
cin >> N >> L;
int eat;
if (L >= 0)
eat = L;
else if (L + N - 1 <= 0)
eat = L + N - 1;
else
eat = 0;
int kekka;
kekka = N * (2 * L + N - 1) / 2 - eat;
cout << kekka << '\n';
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 803,149 | 803,148 | u853585082 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, l;
cin >> n >> l;
ll sum = ((l + (l + n - 1)) * n) / 2;
ll ans;
if (l >= 0) {
ans = sum - l;
} else if (n + l >= 0) {
ans = sum;
} else {
ans = sum - (l + n - 1);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, l;
cin >> n >> l;
ll sum = ((l + (l + n - 1)) * n) / 2;
ll ans;
if (l >= 0) {
ans = sum - l;
} else if (n + l > 0) {
ans = sum;
} else {
ans = sum - (l + n - 1);
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,150 | 803,151 | u608499300 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, l;
cin >> n >> l;
ll sum = ((l + (l + n - 1)) * n) / 2;
ll ans;
if (l >= 0) {
ans = sum - n;
} else if (n + l >= 0) {
ans = sum;
} else {
ans = sum - (l + n - 1);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, l;
cin >> n >> l;
ll sum = ((l + (l + n - 1)) * n) / 2;
ll ans;
if (l >= 0) {
ans = sum - l;
} else if (n + l > 0) {
ans = sum;
} else {
ans = sum - (l + n - 1);
}
cout << ans << endl;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,152 | 803,151 | u608499300 | cpp |
p02994 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int N;
cin >> N;
int L;
cin >> L;
int ans;
if (L >= 0) {
ans = (2 * L + N) * (double(N - 1) / 2);
} else if (L + N > 0) {
ans = (2 * L + N - 1) * double(N / 2);
} else {
ans = (2 * L + N - 2) * (double(N - 1) / 2);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int N;
cin >> N;
int L;
cin >> L;
int ans;
if (L > 0) {
ans = (2 * L + N) * (double(N - 1) / 2);
} else if (L + N > 0) {
ans = (2 * L + N - 1) * (double(N) / 2);
} else {
ans = (2 * L + N - 2) * (double(N - 1) / 2);
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 803,155 | 803,156 | u311671153 | cpp |
p02994 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int N;
cin >> N;
int L;
cin >> L;
int ans;
if (L >= 0) {
ans = (2 * L + N) * (double(N - 1) / 2);
} else if (L + N >= 0) {
ans = (2 * L + N - 1) * double(N / 2);
} else {
ans = (2 * L + N - 2) * (double(N - 1) / 2);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
int main() {
int N;
cin >> N;
int L;
cin >> L;
int ans;
if (L > 0) {
ans = (2 * L + N) * (double(N - 1) / 2);
} else if (L + N > 0) {
ans = (2 * L + N - 1) * (double(N) / 2);
} else {
ans = (2 * L + N - 2) * (double(N - 1) / 2);
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 803,157 | 803,156 | u311671153 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int i = (int)s; i < (int)n; i++)
#define ll long long
int main() {
int N, L;
cin >> N >> L;
vector<int> ord(N);
iota(ord.begin(), ord.end(), 0);
vector<int> apple(N);
vector<int> absapple(N);
rep(i, 0, N) {
apple[i] = L + i;
absapple[i] = abs(L + i);
}
sort(ord.begin(), ord.end(),
[&](int a, int b) { return absapple[a] < absapple[b]; });
int ans = 0;
rep(i, 1, N) { ans += apple[i]; }
cout << ans << endl;
};
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int i = (int)s; i < (int)n; i++)
#define ll long long
int main() {
int N, L;
cin >> N >> L;
vector<int> ord(N);
iota(ord.begin(), ord.end(), 0);
vector<int> apple(N);
vector<int> absapple(N);
rep(i, 0, N) {
apple[i] = L + i;
absapple[i] = abs(L + i);
}
sort(ord.begin(), ord.end(),
[&](int a, int b) { return absapple[a] < absapple[b]; });
int ans = 0;
rep(i, 1, N) { ans += apple[ord[i]]; }
cout << ans << endl;
};
| [] | 803,160 | 803,161 | u987594251 | cpp |
p02994 | #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int N, L, minus;
long ans;
cin >> N >> L;
if (L * (L + N - 1) < 0)
minus = 0;
else if (L > 0)
minus = L;
else
minus = L + N - 1;
ans = (L - 1) * N + (N + 1) * N / 2 - minus;
cout << ans;
} | #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int N, L, minus;
long ans;
cin >> N >> L;
if (L * (L + N - 1) <= 0)
minus = 0;
else if (L > 0)
minus = L;
else
minus = L + N - 1;
ans = (L - 1) * N + (N + 1) * N / 2 - minus;
cout << ans;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,162 | 803,163 | u137051876 | cpp |
p02994 | #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int N, L, ans, minus;
cin >> N >> L;
if (L * (L + N - 1) < 0)
minus = 0;
else if (L > 0)
minus = L;
else
minus = L + N - 1;
ans = (L - 1) * N + (N + 1) * N / 2 - minus;
cout << ans;
} | #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int N, L, minus;
long ans;
cin >> N >> L;
if (L * (L + N - 1) <= 0)
minus = 0;
else if (L > 0)
minus = L;
else
minus = L + N - 1;
ans = (L - 1) * N + (N + 1) * N / 2 - minus;
cout << ans;
}
| [
"variable_declaration.remove",
"variable_declaration.add",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,164 | 803,163 | u137051876 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int n, l;
int main() {
cin >> n;
cin >> l;
if (l >= 0)
cout << ((2 * l + n) * (n - 1)) / 2 << endl;
else if (l + n <= 1) {
cout << (l + l + n - 2) * (n - 1) / 2 << endl;
} else
cout << (l + l + n - 1) * (n - 1) / 2 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int n, l;
int main() {
cin >> n;
cin >> l;
if (l >= 0)
cout << ((2 * l + n) * (n - 1)) / 2 << endl;
else if (l + n <= 1) {
cout << (l + l + n - 2) * (n - 1) / 2 << endl;
} else
cout << (l + l + n - 1) * n / 2 << endl;
} | [] | 803,165 | 803,166 | u110681742 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
typedef pair<string, int> psi;
int a[1000], x, sum;
int main() {
int n, l;
cin >> n >> l;
for (int i = 1; i <= n; i++) {
a[i] = i + l - 1;
sum += a[i];
}
if (l < 0 && (l + n - 1) >= 0)
x = 0;
else if (l > 0)
x = l;
else
x = l + n - 1;
cout << sum - x;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<string, int> psi;
int a[1000], x, sum;
int main() {
int n, l;
cin >> n >> l;
for (int i = 1; i <= n; i++) {
a[i] = i + l - 1;
sum += a[i];
}
if (l < 0 && (l + n - 1) >= 0)
x = 0;
else if (l >= 0)
x = l;
else
x = l + n - 1;
cout << sum - x;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,169 | 803,170 | u179420613 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = 0;
int zero = 100000000;
int a;
for (int i = 0; i < n; i++) {
sum += l + i - 1;
if (abs(l + i - 1) < zero) {
a = i;
zero = abs(l + i - 1);
}
}
sum -= l + a - 1;
cout << sum << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int sum = 0;
int zero = 100000000;
int a;
for (int i = 1; i <= n; i++) {
sum += l + i - 1;
if (abs(l + i - 1) < zero) {
a = i;
zero = abs(l + i - 1);
}
}
sum -= l + a - 1;
cout << sum << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 803,173 | 803,174 | u827974318 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
inline void solve() {
int n, l;
cin >> n >> l;
auto ans = l * n + n * (n - 1) / 2;
if (l < -n) {
ans -= l + n - 1;
} else if (l > 0) {
ans -= l;
}
cout << ans << endl;
}
auto main() -> int {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << boolalpha;
cerr << fixed << boolalpha;
solve();
}
| #include <bits/stdc++.h>
using namespace std;
inline void solve() {
int n, l;
cin >> n >> l;
auto ans = l * n + n * (n - 1) / 2;
if (l <= -n) {
ans -= l + n - 1;
} else if (l > 0) {
ans -= l;
}
cout << ans << endl;
}
auto main() -> int {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << boolalpha;
cerr << fixed << boolalpha;
solve();
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,176 | 803,177 | u431001086 | cpp |
p02994 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define PRINT(str) printf(#str "\n")
#define yOUT PRINT(Yes)
#define nOUT PRINT(No)
#define YOUT PRINT(YES)
#define NOUT PRINT(NO)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
if (x > 0)
ans -= x;
else if (n >= x)
ans -= x + n - 1;
REP(i, n) ans += x + i;
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define PRINT(str) printf(#str "\n")
#define yOUT PRINT(Yes)
#define nOUT PRINT(No)
#define YOUT PRINT(YES)
#define NOUT PRINT(NO)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
if (x > 0)
ans -= x;
else if (-x >= n)
ans -= x + n - 1;
REP(i, n) ans += x + i;
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 803,180 | 803,181 | u833064541 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int aji[n];
int i, osum;
;
for (i = 0; i < n; i++) {
aji[i] = l + i + 1;
osum += aji[i];
}
int j, sum = 0, min = 1000000000, dif, res;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < n; j++) {
if (j != i)
sum += aji[j];
}
dif = abs(osum - sum);
if (dif < min) {
min = dif;
res = sum;
}
}
cout << res << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int aji[n];
int i, osum = 0;
for (i = 0; i < n; i++) {
aji[i] = l + i;
osum += aji[i];
}
int j, sum = 0, min = 1000000000, dif, res;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < n; j++) {
if (j != i)
sum += aji[j];
}
dif = abs(osum - sum);
if (dif < min) {
min = dif;
res = sum;
}
}
cout << res << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 803,182 | 803,183 | u976940619 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int aji[n];
int i, osum;
;
for (i = 0; i < n; i++) {
aji[i] = l + i;
osum += aji[i];
}
int j, sum = 0, min = 1000000000, dif, res;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < n; j++) {
if (j != i)
sum += aji[j];
}
dif = abs(osum - sum);
if (dif < min) {
min = dif;
res = sum;
}
}
cout << res << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int aji[n];
int i, osum = 0;
for (i = 0; i < n; i++) {
aji[i] = l + i;
osum += aji[i];
}
int j, sum = 0, min = 1000000000, dif, res;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < n; j++) {
if (j != i)
sum += aji[j];
}
dif = abs(osum - sum);
if (dif < min) {
min = dif;
res = sum;
}
}
cout << res << endl;
return 0;
} | [] | 803,184 | 803,183 | u976940619 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
if (l >= 0) {
cout << ((l + n - 1) + l + 1) * (n - 1) / 2 << endl;
}
if (l + n - 1 <= 0) {
cout << ((l + n - 2) + l) * (n - 1) / 2 << endl;
} else {
cout << ((l + n - 1) + l) * n / 2 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
if (l >= 0) {
cout << ((l + n - 1) + l + 1) * (n - 1) / 2 << endl;
} else if (l + n - 1 <= 0) {
cout << ((l + n - 2) + l) * (n - 1) / 2 << endl;
} else {
cout << ((l + n - 1) + l) * n / 2 << endl;
}
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 803,194 | 803,195 | u544165468 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
#define IO() \
assert(freopen("in.in", "rt", stdin)), \
assert(freopen("out.out", "wt", stdout))
#define FastIO() ios::sync_with_stdio(false);
#define debug(x) cout << __LINE__ << ": " << #x << " = " << (x) << endl
inline int readChar();
template <class T = int> inline T readInt();
template <class T> inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
/** Read */
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len)
pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len)
return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32)
c = getChar();
return c;
}
template <class T> inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-')
s = -1, c = getChar();
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
/** Write */
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T> inline void writeInt(T x, char end) {
if (x < 0)
writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n)
s[n++] = '0' + x % 10, x /= 10;
while (n--)
writeChar(s[n]);
if (end)
writeChar(end);
}
inline void writeWord(const char *s) {
while (*s)
writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos)
fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int N = 1e7 + 9, M = 1e5 + 9, OO = 0x3f3f3f3f;
const double EPS = 1e-10;
int main() {
#ifndef ONLINE_JUDGE
IO();
#endif
int n = readInt(), l = readInt();
int mn = OO;
ll sum = 0;
for (int i = 0; i < n; ++i) {
int x = l + i;
sum += x;
mn = (abs(mn) > abs(x)) ? x : mn;
}
writeInt(sum - mn);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IO() \
assert(freopen("in.in", "rt", stdin)), \
assert(freopen("out.out", "wt", stdout))
#define FastIO() ios::sync_with_stdio(false);
#define debug(x) cout << __LINE__ << ": " << #x << " = " << (x) << endl
inline int readChar();
template <class T = int> inline T readInt();
template <class T> inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
/** Read */
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len)
pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len)
return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32)
c = getChar();
return c;
}
template <class T> inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-')
s = -1, c = getChar();
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
/** Write */
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T> inline void writeInt(T x, char end) {
if (x < 0)
writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n)
s[n++] = '0' + x % 10, x /= 10;
while (n--)
writeChar(s[n]);
if (end)
writeChar(end);
}
inline void writeWord(const char *s) {
while (*s)
writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos)
fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int N = 1e7 + 9, M = 1e5 + 9, OO = 0x3f3f3f3f;
const double EPS = 1e-10;
int main() {
#ifdef _LOCAL_DEFINE
IO();
#endif
int n = readInt(), l = readInt();
int mn = OO;
ll sum = 0;
for (int i = 0; i < n; ++i) {
int x = l + i;
sum += x;
mn = (abs(mn) > abs(x)) ? x : mn;
}
writeInt(sum - mn);
return 0;
} | [] | 803,196 | 803,197 | u970872504 | cpp |
p02994 | #include <algorithm>
#include <cstdlib>
#include <iomanip> //小数点以下を表示させる(setprecision())
#include <iostream> //入出力
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
// DP法
template <class T>
inline bool chmin(T &a, T b) // change minimum
{
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) // change max
{
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long ll; // 64bit型
using namespace std;
// const long long INF = 1LL << 60; //無限大の値
int INF = 1000000;
int main() {
int N, L;
cin >> N >> L;
int s = 0, t = 0;
REP(i, N) { s += L + i; }
int ans = 1e9;
REP(i, N) {
int t = s - (L - i);
if (abs(t - s) < abs(ans - s))
ans = t;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstdlib>
#include <iomanip> //小数点以下を表示させる(setprecision())
#include <iostream> //入出力
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
// DP法
template <class T>
inline bool chmin(T &a, T b) // change minimum
{
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) // change max
{
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long ll; // 64bit型
using namespace std;
// const long long INF = 1LL << 60; //無限大の値
int INF = 1000000;
int main() {
int N, L;
cin >> N >> L;
int s = 0, t = 0;
REP(i, N) { s += L + i; }
int ans = 1e9;
REP(i, N) {
int t = s - (L + i);
if (abs(t - s) < abs(ans - s))
ans = t;
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 803,207 | 803,208 | u966508131 | cpp |
p02994 | #include <iostream>
using namespace std;
int main() {
int n, l, sum = 0, m = 10000;
cin >> n >> l;
for (int i = 0; i < n; i++) {
sum += l + i;
if (m > abs(l + i))
m = l + i;
}
cout << sum - m << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, l, sum = 0, m = 10000;
cin >> n >> l;
for (int i = 0; i < n; i++) {
sum += l + i;
if (abs(m) > abs(l + i))
m = l + i;
}
cout << sum - m << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 803,213 | 803,214 | u169639579 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, L;
cin >> N >> L;
int eat = N;
int eat_idx;
vector<int> vec(N);
for (int i = 0; i < N; ++i) {
vec[i] = L + i;
if (eat > abs(vec[i])) {
eat = abs(vec[i]);
eat_idx = i;
}
}
vec.erase(vec.begin() + eat_idx);
int ans = accumulate(vec.begin(), vec.end(), 0);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, L;
cin >> N >> L;
int eat = N * 100;
int eat_idx;
vector<int> vec(N);
for (int i = 0; i < N; ++i) {
vec[i] = L + i;
if (eat > abs(vec[i])) {
eat = abs(vec[i]);
eat_idx = i;
}
}
vec.erase(vec.begin() + eat_idx);
int ans = accumulate(vec.begin(), vec.end(), 0);
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 803,215 | 803,216 | u489326854 | cpp |
p02994 | #include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, n) for (int i = 1; i < n; i++)
using namespace std;
int main() {
int n, l;
cin >> n >> l;
vector<int> a(n);
rep(i, n) { a[i] = l + i + 1 - 1; }
int sum = 0;
int min = abs(a[0]);
bool flag;
if (a[0] >= 0) {
flag = true;
} else {
flag = false;
}
rep(i, n) {
sum += a[i];
if (min < abs(a[i])) {
min = abs(a[i]);
if (a[i] >= 0) {
flag = true;
} else {
flag = false;
}
}
}
int ans;
if (flag) {
ans = sum - min;
} else {
ans = sum + min;
}
cout << ans;
return 0;
} | #include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, n) for (int i = 1; i < n; i++)
using namespace std;
int main() {
int n, l;
cin >> n >> l;
vector<int> a(n);
rep(i, n) { a[i] = l + i + 1 - 1; }
int sum = 0;
int min = abs(a[0]);
bool flag;
if (a[0] >= 0) {
flag = true;
} else {
flag = false;
}
rep(i, n) {
sum += a[i];
if (min > abs(a[i])) {
min = abs(a[i]);
if (a[i] >= 0) {
flag = true;
} else {
flag = false;
}
}
}
int ans;
if (flag) {
ans = sum - min;
} else {
ans = sum + min;
}
cout << ans;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,222 | 803,223 | u096186754 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
// string ans= "";
// string str;
int n;
int l;
int sum1 = 0;
int sum2 = 0;
cin >> n;
cin >> l;
for (int i = 0; i < n; i++) {
sum1 += l + i;
}
if (l >= 0) {
cout << sum1 - l << endl;
} else if (l >= -n && -1 >= l) {
cout << sum1 << endl;
} else if (-n >= l) {
cout << sum1 - (l + n - 1) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
// string ans= "";
// string str;
int n;
int l;
int sum1 = 0;
int sum2 = 0;
cin >> n;
cin >> l;
for (int i = 0; i < n; i++) {
sum1 += l + i;
}
if (l >= 0) {
cout << sum1 - l << endl;
} else if (l > -n && 0 >= l) {
cout << sum1 << endl;
} else if (-n >= l) {
cout << sum1 - (l + n - 1) << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 803,231 | 803,232 | u841875314 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, min;
cin >> n >> l;
int sum = (n * (2 * l - 1 + n)) / 2;
min = l;
for (int i = 0; i < n; i++) {
if (abs(l + i) < abs(min))
min = l + i;
}
if (min >= 0)
cout << sum - min << endl;
else
cout << sum + min << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, min;
cin >> n >> l;
int sum = (n * (2 * l - 1 + n)) / 2;
min = l;
for (int i = 0; i < n; i++) {
if (abs(l + i) < abs(min))
min = l + i;
}
if (min >= 0)
cout << sum - abs(min) << endl;
else
cout << sum + abs(min) << endl;
} | [
"call.add",
"call.arguments.change"
] | 803,250 | 803,251 | u703214333 | cpp |
p02994 | #include <bits/stdc++.h>
using namespace std;
int N, L;
int sum(int s, int e) {
int t = 0;
for (int i = s; i <= e; i++)
t += i;
return t;
}
int main() {
scanf("%d%d", &N, &L);
if (L > 0)
printf("%d\n", sum(L + 1, L + N - 1));
else if (L < 0 && L + N - 1 >= 0)
printf("%d\n", sum(L, L + N - 1));
else
printf("%d\n", sum(L, L + N - 2));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int N, L;
int sum(int s, int e) {
int t = 0;
for (int i = s; i <= e; i++)
t += i;
return t;
}
int main() {
scanf("%d%d", &N, &L);
if (L > 0)
printf("%d\n", sum(L + 1, L + N - 1));
else if (L <= 0 && L + N - 1 >= 0)
printf("%d\n", sum(L, L + N - 1));
else
printf("%d\n", sum(L, L + N - 2));
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 803,252 | 803,253 | u027479217 | cpp |
p02994 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
int main(void) {
int n, l;
int ii;
int sum = 0;
cin >> n >> l;
rep(ii, n) { sum += (l + ii); }
if (l >= 1) {
sum -= l;
} else if ((l + n) < 0) {
sum -= (l + n - 1);
}
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
int main(void) {
int n, l;
int ii;
int sum = 0;
cin >> n >> l;
rep(ii, n) { sum += (l + ii); }
if (l >= 1) {
sum -= l;
} else if ((l + n - 1) < 0) {
sum -= (l + n - 1);
}
cout << sum << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 803,254 | 803,255 | u750004862 | cpp |
p02994 | #include <iostream>
using namespace std;
int main(void) {
int n, l;
cin >> n >> l;
int l2 = l;
int ans = 0;
for (int i = 0; i < n; i++) {
ans += l2;
l2++;
}
if (l >= 0)
ans -= l;
else if (l2 >= 0)
ans;
else if (l2 < 0)
ans -= l2;
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
int n, l;
cin >> n >> l;
int l2 = l;
int ans = 0;
for (int i = 0; i < n; i++) {
ans += l2;
l2++;
}
l2--;
if (l >= 0)
ans -= l;
else if (l2 >= 0)
ans;
else if (l2 < 0)
ans -= l2;
cout << ans << endl;
return 0;
}
| [
"expression.unary.arithmetic.add"
] | 803,259 | 803,260 | u653206280 | cpp |
p02994 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int f = (L - 1) * N + (N * (N + 1)) / 2;
if ((1 - L) <= N && (1 - L) > 0)
cout << f << "\n";
else if (L > 0)
cout << f - (L) << "\n";
else
cout << f + (L + N - 1) << "\n";
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int f = (L - 1) * N + (N * (N + 1)) / 2;
if ((1 - L) <= N && (1 - L) > 0)
cout << f << "\n";
else if (L > 0)
cout << f - (L) << "\n";
else
cout << f - (L + N - 1) << "\n";
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 803,261 | 803,262 | u100659799 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.