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 8
values |
|---|---|---|---|---|---|---|---|
p02924
|
//#include "SaveFuncs.cpp"
/*****/
#include <algorithm>
#include <array>
#include <cmath>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b);
//#define int long long
constexpr int INF = 2000000100;
constexpr ll DIV = 1000000007; // 10e9+7
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T divUp(T a, T b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
std::string strMulti(std::string t, int n) {
std::string out = "";
for (int i = 0; i < n; i++) {
out += t;
}
return out;
}
template <class T> T math_P(T m, T n) {
T ret = 1;
for (T i = m; i > m - n; i--) {
ret *= i;
}
return ret;
}
template <class T> T math_C(T m, T n) {
T ret = mathP(m, n);
for (T i = 2; i <= n; i++) {
ret /= i;
}
return ret;
}
template <class T> bool compare_by_b(pair<T, T> a, pair<T, T> b) {
if (a.second != b.second) {
return a.second < b.second;
}
return a.first < b.first;
}
template <class T> T math_gcd(T a, T b) {
a = abs(a);
b = abs(b);
if (a < b) {
std::swap(a, b);
}
T tmp;
while (b != 0) {
tmp = b;
b = a % b;
a = tmp;
}
return a;
}
template <class T> T math_lcm(T a, T b) {
a = abs(a);
b = abs(b);
if (a > b) {
std::swap(a, b);
}
if (a == 1) {
return b;
}
T i = a;
while (i % b != 0) {
i += a;
}
return i;
}
/*****/
int Main() {
int N;
cin >> N;
int ret = 0;
ret = N * (N - 1) / 2;
cout << ret;
return 0;
}
/*****/
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
// std::cout << std::fixed << std::setprecision(10);
Main();
return 0;
}
|
//#include "SaveFuncs.cpp"
/*****/
#include <algorithm>
#include <array>
#include <cmath>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b);
//#define int long long
constexpr int INF = 2000000100;
constexpr ll DIV = 1000000007; // 10e9+7
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T divUp(T a, T b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
std::string strMulti(std::string t, int n) {
std::string out = "";
for (int i = 0; i < n; i++) {
out += t;
}
return out;
}
template <class T> T math_P(T m, T n) {
T ret = 1;
for (T i = m; i > m - n; i--) {
ret *= i;
}
return ret;
}
template <class T> T math_C(T m, T n) {
T ret = mathP(m, n);
for (T i = 2; i <= n; i++) {
ret /= i;
}
return ret;
}
template <class T> bool compare_by_b(pair<T, T> a, pair<T, T> b) {
if (a.second != b.second) {
return a.second < b.second;
}
return a.first < b.first;
}
template <class T> T math_gcd(T a, T b) {
a = abs(a);
b = abs(b);
if (a < b) {
std::swap(a, b);
}
T tmp;
while (b != 0) {
tmp = b;
b = a % b;
a = tmp;
}
return a;
}
template <class T> T math_lcm(T a, T b) {
a = abs(a);
b = abs(b);
if (a > b) {
std::swap(a, b);
}
if (a == 1) {
return b;
}
T i = a;
while (i % b != 0) {
i += a;
}
return i;
}
/*****/
int Main() {
ll N;
cin >> N;
ll ret = 0;
ret = N * (N - 1) / 2;
cout << ret;
return 0;
}
/*****/
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
// std::cout << std::fixed << std::setprecision(10);
Main();
return 0;
}
|
[
"variable_declaration.type.change"
] | 726,619
| 726,620
|
u588369531
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll inf = 1LL << 60;
const double eps = 1e-9;
int main() {
ll n;
cin >> n;
cout << n / (n - 1) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll inf = 1LL << 60;
const double eps = 1e-9;
int main() {
ll n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
[
"expression.operator.arithmetic.change",
"io.output.change"
] | 726,621
| 726,622
|
u831873811
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
using ll = long long;
int main() {
ll n;
cout << n * (n - 1) / 2 << endl;
}
|
#include <iostream>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
[] | 726,623
| 726,624
|
u949798495
|
cpp
|
p02924
|
#include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define ll long long
#define ull unsigned long long
#define vint vector<int>
#define vll vector<ll>
//#include <stack>
//#include <queue>
/*
#include <math.h>
int standerd = int(pow(10.0,9.0)) + 7;
*/
string ans_Yes = "Yes";
string ans_No = "No";
string ans_yes = "yes";
string ans_no = "no";
int N;
ll NN;
int main() {
cin >> N;
NN = N * (N - 1) / 2;
cout << NN << endl;
}
|
#include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define ll long long
#define ull unsigned long long
#define vint vector<int>
#define vll vector<ll>
//#include <stack>
//#include <queue>
/*
#include <math.h>
int standerd = int(pow(10.0,9.0)) + 7;
*/
string ans_Yes = "Yes";
string ans_No = "No";
string ans_yes = "yes";
string ans_no = "no";
ll N;
ll NN;
int main() {
cin >> N;
NN = N * (N - 1) / 2;
cout << NN << endl;
}
|
[
"variable_declaration.type.change"
] | 726,631
| 726,632
|
u756614568
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
#define what_is(x) cerr << #x << " is " << x << endl;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
typedef long long ll;
const int N = 1e5 + 5;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
IOS
// freopen("input.txt", "r", stdin);
int n;
cin >> n;
ll ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define what_is(x) cerr << #x << " is " << x << endl;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
typedef long long ll;
const int N = 1e5 + 5;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
IOS
// freopen("input.txt", "r", stdin);
int n;
cin >> n;
ll ans = 1LL * n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"assignment.change"
] | 726,636
| 726,637
|
u411771230
|
cpp
|
p02924
|
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define watch(x) cout << (#x) << " is: " << (x) << endl
#define vw(v) \
cout << (#v) << " is: " << endl; \
for (long long B : (v)) { \
cout << B << " "; \
} \
cout << endl
#define check(x) cout << "here " << (x) << "?" << endl
#define rep(i, a, b) for (long long i = (a); i < (b); i++)
#define per(i, a) for (long long i = (a); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define rv(x) (x).rbegin(), (x).rend()
#define pb push_back
long long const MAX = 2147483647, REALMAX = 9223372036854775806;
int main() {
int a;
cin >> a;
cout << (a * (a - 1)) / 2;
}
|
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define watch(x) cout << (#x) << " is: " << (x) << endl
#define vw(v) \
cout << (#v) << " is: " << endl; \
for (long long B : (v)) { \
cout << B << " "; \
} \
cout << endl
#define check(x) cout << "here " << (x) << "?" << endl
#define rep(i, a, b) for (long long i = (a); i < (b); i++)
#define per(i, a) for (long long i = (a); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define rv(x) (x).rbegin(), (x).rend()
#define pb push_back
long long const MAX = 2147483647, REALMAX = 9223372036854775806;
int main() {
long long a;
cin >> a;
cout << a * (a - 1) / 2;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,638
| 726,639
|
u771565679
|
cpp
|
p02924
|
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define watch(x) cout << (#x) << " is: " << (x) << endl
#define vw(v) \
cout << (#v) << " is: " << endl; \
for (long long B : (v)) { \
cout << B << " "; \
} \
cout << endl
#define check(x) cout << "here " << (x) << "?" << endl
#define rep(i, a, b) for (long long i = (a); i < (b); i++)
#define per(i, a) for (long long i = (a); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define rv(x) (x).rbegin(), (x).rend()
#define pb push_back
long long const MAX = 2147483647, REALMAX = 9223372036854775806;
int main() {
int a;
cin >> a;
cout << a * (a - 1) / 2;
}
|
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define watch(x) cout << (#x) << " is: " << (x) << endl
#define vw(v) \
cout << (#v) << " is: " << endl; \
for (long long B : (v)) { \
cout << B << " "; \
} \
cout << endl
#define check(x) cout << "here " << (x) << "?" << endl
#define rep(i, a, b) for (long long i = (a); i < (b); i++)
#define per(i, a) for (long long i = (a); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define rv(x) (x).rbegin(), (x).rend()
#define pb push_back
long long const MAX = 2147483647, REALMAX = 9223372036854775806;
int main() {
long long a;
cin >> a;
cout << a * (a - 1) / 2;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,640
| 726,639
|
u771565679
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
const ll MOD = 1000000007;
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
const ll MOD = 1000000007;
int main() {
ll n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
[
"variable_declaration.type.change"
] | 726,641
| 726,642
|
u915689660
|
cpp
|
p02924
|
#include "bits/stdc++.h"
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define repf(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define repfr(i, x, n) for (int i = (int)(x)-1; i >= (int)(n); i--)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define INF 1e9
using ll = int64_t;
#define waru 1000000007
std::int64_t gcd(std::int64_t a, std::int64_t b) {
// a >= b && b != 0
std::int64_t c;
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
std::int64_t gcd_s(std::int64_t aa, std::int64_t bb) {
std::int64_t a = max(aa, bb);
std::int64_t b = min(aa, bb);
std::int64_t c;
if (b == 0) {
return -1;
}
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
void rle(std::vector<std::pair<char, std::int64_t>> &data, std::string str) {
char now = str[0];
std::int64_t count = 0;
for (std::int64_t i = 0; i < str.size() + 1; i++) {
if (i == str.size()) {
data.push_back(make_pair(str[i - 1], count));
break;
} else if (now != str[i]) {
data.push_back(make_pair(now, count));
now = str[i];
count = 0;
}
count++;
}
return;
}
#define MAX_NUM 1000000
int n;
void Main() {
//自動整形防止用コメント
std::cin >> n;
std::cout << ((n - 1) * n) / 2 << '\n';
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define repf(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define repfr(i, x, n) for (int i = (int)(x)-1; i >= (int)(n); i--)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define INF 1e9
using ll = int64_t;
#define waru 1000000007
std::int64_t gcd(std::int64_t a, std::int64_t b) {
// a >= b && b != 0
std::int64_t c;
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
std::int64_t gcd_s(std::int64_t aa, std::int64_t bb) {
std::int64_t a = max(aa, bb);
std::int64_t b = min(aa, bb);
std::int64_t c;
if (b == 0) {
return -1;
}
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
void rle(std::vector<std::pair<char, std::int64_t>> &data, std::string str) {
char now = str[0];
std::int64_t count = 0;
for (std::int64_t i = 0; i < str.size() + 1; i++) {
if (i == str.size()) {
data.push_back(make_pair(str[i - 1], count));
break;
} else if (now != str[i]) {
data.push_back(make_pair(now, count));
now = str[i];
count = 0;
}
count++;
}
return;
}
#define MAX_NUM 1000000
ll n;
void Main() {
//自動整形防止用コメント
std::cin >> n;
std::cout << (n * (n - 1)) / 2 << '\n';
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
[
"variable_declaration.type.change",
"expression.operation.binary.remove"
] | 726,643
| 726,644
|
u395846213
|
cpp
|
p02924
|
#include "bits/stdc++.h"
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define repf(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define repfr(i, x, n) for (int i = (int)(x)-1; i >= (int)(n); i--)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define INF 1e9
using ll = int64_t;
#define waru 1000000007
std::int64_t gcd(std::int64_t a, std::int64_t b) {
// a >= b && b != 0
std::int64_t c;
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
std::int64_t gcd_s(std::int64_t aa, std::int64_t bb) {
std::int64_t a = max(aa, bb);
std::int64_t b = min(aa, bb);
std::int64_t c;
if (b == 0) {
return -1;
}
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
void rle(std::vector<std::pair<char, std::int64_t>> &data, std::string str) {
char now = str[0];
std::int64_t count = 0;
for (std::int64_t i = 0; i < str.size() + 1; i++) {
if (i == str.size()) {
data.push_back(make_pair(str[i - 1], count));
break;
} else if (now != str[i]) {
data.push_back(make_pair(now, count));
now = str[i];
count = 0;
}
count++;
}
return;
}
#define MAX_NUM 1000000
int n;
void Main() {
//自動整形防止用コメント
std::cin >> n;
std::cout << ((n - 1) * n) / 2 << '\n';
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define repf(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define repfr(i, x, n) for (int i = (int)(x)-1; i >= (int)(n); i--)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define INF 1e9
using ll = int64_t;
#define waru 1000000007
std::int64_t gcd(std::int64_t a, std::int64_t b) {
// a >= b && b != 0
std::int64_t c;
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
std::int64_t gcd_s(std::int64_t aa, std::int64_t bb) {
std::int64_t a = max(aa, bb);
std::int64_t b = min(aa, bb);
std::int64_t c;
if (b == 0) {
return -1;
}
do {
c = a % b;
a = b;
b = c;
} while (c);
return a;
}
void rle(std::vector<std::pair<char, std::int64_t>> &data, std::string str) {
char now = str[0];
std::int64_t count = 0;
for (std::int64_t i = 0; i < str.size() + 1; i++) {
if (i == str.size()) {
data.push_back(make_pair(str[i - 1], count));
break;
} else if (now != str[i]) {
data.push_back(make_pair(now, count));
now = str[i];
count = 0;
}
count++;
}
return;
}
#define MAX_NUM 1000000
ll n;
void Main() {
//自動整形防止用コメント
std::cin >> n;
std::cout << n * (n - 1) / 2 << '\n';
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
[
"variable_declaration.type.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 726,643
| 726,645
|
u395846213
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
using namespace std;
int main() {
int N;
cin >> N;
ll ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
using namespace std;
int main() {
ll N;
cin >> N;
ll ans = (N * (N - 1)) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 726,646
| 726,647
|
u689844566
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int answer;
answer = N * (N - 1) / 2;
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N;
cin >> N;
int64_t answer;
answer = N * (N - 1) / 2;
cout << answer << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 726,652
| 726,653
|
u119425165
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define all(t) (t).begin(), (t).end()
#define MOD 1000000007
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
} else {
return 0;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
} else {
return 0;
}
}
template <class T> inline T GCD(T a, T b) {
T c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
template <class T> inline T LCM(T a, T b) { return a * b / GCD(a, b); }
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define all(t) (t).begin(), (t).end()
#define MOD 1000000007
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
} else {
return 0;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
} else {
return 0;
}
}
template <class T> inline T GCD(T a, T b) {
T c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
template <class T> inline T LCM(T a, T b) { return a * b / GCD(a, b); }
int main() {
ll n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
[
"variable_declaration.type.change"
] | 726,657
| 726,658
|
u962104148
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 1) * n / 2 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << (n - 1) * n / 2 << "\n";
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,691
| 726,692
|
u582460965
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#include <cstdlib>
#include <ctime>
#define rep(i, N) for (int i = 0; i < (N); i++)
#define swap(a, b) (a += b, b = a - b, a -= b)
using namespace std;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
#include <cstdlib>
#include <ctime>
#define rep(i, N) for (int i = 0; i < (N); i++)
#define swap(a, b) (a += b, b = a - b, a -= b)
using namespace std;
int main() {
long long N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,693
| 726,694
|
u466393447
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
cout << (a * (a - 1) / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long a;
cin >> a;
cout << (a * (a - 1) / 2);
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 726,700
| 726,701
|
u657236078
|
cpp
|
p02924
|
#include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-9)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for (int i = 0; i < n; i++)
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll beki(ll a, ll b) {
ll tmp = 1;
REP(i, b) tmp *= a;
return tmp;
}
int N;
int main() {
cin >> N;
cout << (N - 1) * N / 2 << endl;
}
|
#include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-9)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for (int i = 0; i < n; i++)
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll beki(ll a, ll b) {
ll tmp = 1;
REP(i, b) tmp *= a;
return tmp;
}
ll N;
// int ans;
int main() {
cin >> N;
cout << (N - 1) * N / 2 << endl;
}
|
[
"variable_declaration.type.change"
] | 726,719
| 726,720
|
u815863697
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
ans = n * (n - 1) / 2;
// for(int i = 1; i < n; i++) ans += i;
cout << ans;
}
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
ans = n * (n - 1) / 2;
// for(int i = 1; i < n; i++) ans += i;
cout << ans;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,732
| 726,733
|
u521973174
|
cpp
|
p02924
|
#include <iostream>
int main() {
int N;
long int ans = 0;
std::cin >> N;
ans = N * (N - 1) / 2;
std::cout << ans << std::endl;
return 0;
}
|
#include <iostream>
int main() {
long int N, ans = 0;
std::cin >> N;
ans = N * (N - 1) / 2;
std::cout << ans << std::endl;
return 0;
}
|
[
"variable_declaration.remove",
"variable_declaration.add"
] | 726,744
| 726,745
|
u721269623
|
cpp
|
p02924
|
#include <iostream>
int main() {
int N, ans = 0;
std::cin >> N;
ans = N * (N - 1) / 2;
std::cout << ans << std::endl;
return 0;
}
|
#include <iostream>
int main() {
long int N, ans = 0;
std::cin >> N;
ans = N * (N - 1) / 2;
std::cout << ans << std::endl;
return 0;
}
|
[
"variable_declaration.type.widen.change"
] | 726,746
| 726,745
|
u721269623
|
cpp
|
p02924
|
#include <iostream>
int main() {
int N, ans = 0;
std::cin >> N;
ans = N * (N - 1) / 2;
std::cout << ans << std::endl;
return 0;
}
|
#include <iostream>
int main() {
long int N, ans = 0;
std::cin >> N;
ans = (N * (N - 1)) / 2;
std::cout << ans << std::endl;
return 0;
}
|
[
"variable_declaration.type.widen.change"
] | 726,746
| 726,748
|
u721269623
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
/* alias */
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
/* repetition */
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define repr(i, n) for (int i = (n - 1); i >= 0; --i)
#define repre(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORR(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define FORRE(i, a, b) for (int i = (b); i >= (a); --i)
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
/* alias */
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
/* repetition */
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define repr(i, n) for (int i = (n - 1); i >= 0; --i)
#define repre(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORR(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define FORRE(i, a, b) for (int i = (b); i >= (a); --i)
int main() {
ll N;
cin >> N;
cout << N * (N - 1) / 2ll << endl;
}
|
[
"variable_declaration.type.change"
] | 726,764
| 726,765
|
u792521295
|
cpp
|
p02924
|
#include <iostream>
int main(void) {
int n;
std::cin >> n;
std::cout << n * (n - 1) / 2 << std::endl;
return 0;
}
|
#include <iostream>
int main(void) {
long long n;
std::cin >> n;
std::cout << n * (n - 1) / 2 << std::endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,772
| 726,773
|
u654558363
|
cpp
|
p02924
|
/*input
13
*/
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 1) * n / 2 << endl;
}
|
/*input
13
*/
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
cout << (n - 1) * n / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 726,780
| 726,781
|
u965602776
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
ans = (n * n - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
ans = (n * (n - 1)) / 2;
cout << ans << endl;
}
|
[] | 726,782
| 726,783
|
u880212367
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define FORD(i, a, b) for (int i = a; i >= b; i--)
#define FORL(i, x) for (int i = head[x]; i; i = nxt[i])
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define PB push_back
#define MP make_pair
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int a;
cin >> a;
int ans = a * (a - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define FORD(i, a, b) for (int i = a; i >= b; i--)
#define FORL(i, x) for (int i = head[x]; i; i = nxt[i])
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define PB push_back
#define MP make_pair
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll a;
cin >> a;
ll ans = a * (a - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 726,784
| 726,785
|
u054501336
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main(void) {
int N;
cin >> N;
int M;
M = N * (N - 1) / 2;
cout << M << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main(void) {
long N;
cin >> N;
long M;
M = N * (N - 1) / 2;
cout << M << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 726,792
| 726,793
|
u215743476
|
cpp
|
p02924
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
typedef long long ll;
const ll longinf = 1LL << 60;
using namespace std;
int n;
ll ans;
int main() {
cin >> n;
ans = (1 + n) * n / 2;
ans -= n;
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
typedef long long ll;
const ll longinf = 1LL << 60;
using namespace std;
ll n;
ll ans;
int main() {
cin >> n;
ans = (1 + n) * n / 2;
ans -= n;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 726,798
| 726,799
|
u806661586
|
cpp
|
p02924
|
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <unordered_map> //hash map
#include <utility>
#include <vector>
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define rrep(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
using namespace std;
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;
}
double euclid_distance(double a, double b) { return sqrt(a * a + b * b); }
ll gcd(ll a, ll b) {
ll r;
if (a < b) {
ll tmp;
tmp = a;
a = b;
b = tmp;
}
while (r = a % b) {
a = b;
b = r;
}
return b;
}
void Integer_factorization(long long int b, long long int n) {
long long int a = 2;
long long int count = 0;
long long int ans = 1;
long long int ndash = n;
if (b == 1)
cout << n << endl;
else {
while (ndash >= a * a) {
if (n % a == 0) {
count++;
n /= a;
if (count % b == 0) {
ans *= a;
}
} else {
a++;
count = 0;
}
}
cout << ans << endl;
}
}
ll r_fuct[2000];
ll fuct[2000];
// MOD逆元
void conb(ll n, ll k) {
fuct[0] = 1;
for (int i = 1; i < k + 1; i++) {
fuct[i] *= fuct[i - 1] % MOD;
ll b = MOD, u = 1, v = 0;
ll value = fuct[i];
while (b) {
ll t = value / b;
value -= t * b;
swap(value, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
r_fuct[i] = u;
}
}
ll factrial(ll n) {
if (n == 0)
return 1;
ll p = factrial(n - 1) * n % MOD;
return p;
}
// MOD逆元
ll farmat(ll n, ll p) {
if (p == 0)
return 1;
else if (p == 1)
return n % MOD;
ll d = farmat(n, p / 2);
if (p % 2 == 0) {
return (d * d) % MOD;
} else {
return ((n * d) % MOD * d) % MOD;
}
}
ll conbination(ll n, ll k) {
ll a = factrial(n);
ll b = factrial(k);
ll c = factrial(n - k);
return (a * farmat(b, MOD - 2) % MOD * farmat(c, MOD - 2)) % MOD;
}
int n;
int memo[10000000];
int fib(int i) {
if (i <= 1)
return i;
if (memo[i] != 0)
return memo[i];
return memo[i] = fib(i - 1) + fib(i - 2);
}
void solve() {
int n;
cin >> n;
cout << (n - 1) * n / 2 << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <unordered_map> //hash map
#include <utility>
#include <vector>
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define rrep(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
using namespace std;
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;
}
double euclid_distance(double a, double b) { return sqrt(a * a + b * b); }
ll gcd(ll a, ll b) {
ll r;
if (a < b) {
ll tmp;
tmp = a;
a = b;
b = tmp;
}
while (r = a % b) {
a = b;
b = r;
}
return b;
}
void Integer_factorization(long long int b, long long int n) {
long long int a = 2;
long long int count = 0;
long long int ans = 1;
long long int ndash = n;
if (b == 1)
cout << n << endl;
else {
while (ndash >= a * a) {
if (n % a == 0) {
count++;
n /= a;
if (count % b == 0) {
ans *= a;
}
} else {
a++;
count = 0;
}
}
cout << ans << endl;
}
}
ll r_fuct[2000];
ll fuct[2000];
// MOD逆元
void conb(ll n, ll k) {
fuct[0] = 1;
for (int i = 1; i < k + 1; i++) {
fuct[i] *= fuct[i - 1] % MOD;
ll b = MOD, u = 1, v = 0;
ll value = fuct[i];
while (b) {
ll t = value / b;
value -= t * b;
swap(value, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
r_fuct[i] = u;
}
}
ll factrial(ll n) {
if (n == 0)
return 1;
ll p = factrial(n - 1) * n % MOD;
return p;
}
// MOD逆元
ll farmat(ll n, ll p) {
if (p == 0)
return 1;
else if (p == 1)
return n % MOD;
ll d = farmat(n, p / 2);
if (p % 2 == 0) {
return (d * d) % MOD;
} else {
return ((n * d) % MOD * d) % MOD;
}
}
ll conbination(ll n, ll k) {
ll a = factrial(n);
ll b = factrial(k);
ll c = factrial(n - k);
return (a * farmat(b, MOD - 2) % MOD * farmat(c, MOD - 2)) % MOD;
}
int n;
int memo[10000000];
int fib(int i) {
if (i <= 1)
return i;
if (memo[i] != 0)
return memo[i];
return memo[i] = fib(i - 1) + fib(i - 2);
}
void solve() {
ll n;
cin >> n;
cout << (n - 1) * n / 2 << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
[
"variable_declaration.type.change"
] | 726,811
| 726,812
|
u677400065
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#include <iomanip>
#include <unordered_map>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n;
cin >> n;
ll ans;
ans = n * (n - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#include <iomanip>
#include <unordered_map>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll n;
cin >> n;
ll ans;
ans = n * (n - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 726,820
| 726,821
|
u295618957
|
cpp
|
p02924
|
#include <array>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
int main() {
int N;
std::cin >> N;
std::cout << N * (N - 1) / 2 << std::endl;
}
|
#include <array>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
int main() {
long N;
std::cin >> N;
std::cout << N * (N - 1) / 2 << std::endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 726,833
| 726,834
|
u474016796
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int n, a, b;
cin >> n;
a = n * (n - 1);
b = a / 2;
cout << b;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long int n, a, b;
cin >> n;
a = n * (n - 1);
b = a / 2;
cout << b;
return 0;
}
|
[
"variable_declaration.type.widen.change"
] | 726,837
| 726,838
|
u157835683
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
template <class e, class t, int N>
std::basic_istream<e, t> &operator>>(std::basic_istream<e, t> &in,
const e (&literal)[N]) {
std::array<e, N - 1> buffer; // get buffer
in >> buffer[0]; // skips whitespace
if (N > 2)
in.read(&buffer[1], N - 2); // read the rest
if (strncmp(&buffer[0], literal, N - 1)) // if it failed
in.setstate(in.rdstate() | std::ios::badbit); // set the state
return in;
}
template <class e, class t>
std::basic_istream<e, t> &operator>>(std::basic_istream<e, t> &in,
const e &literal) {
e buffer; // get buffer
in >> buffer; // read data
if (buffer != literal) // if it failed
in.setstate(in.rdstate() | std::ios::badbit); // set the state
return in;
}
// redirect mutable char arrays to their normal function
template <class e, class t, int N>
std::basic_istream<e, t> &operator>>(std::basic_istream<e, t> &in,
e (&carray)[N]) {
return std::operator>>(in, carray);
}
template <class t> istream &operator>>(istream &in, vector<t> &v) {
for (int i = 0; i < v.size(); i++)
in >> v[i];
return in;
}
template <class t1, class t2>
istream &operator>>(istream &in, pair<t1, t2> &v) {
cin >> v.first >> v.second;
return in;
}
template <class t> ostream &operator<<(ostream &out, vector<t> &a) {
for (auto x : a) {
out << x << " ";
}
return out;
}
template <class t> ostream &operator<<(ostream &out, set<t> &a) {
for (auto x : a) {
out << x << " ";
}
return out;
}
template <class t1, class t2>
ostream &operator<<(ostream &out, map<t1, t2> &a) {
for (auto x : a) {
out << x.first << " = " << x.second << endl;
}
return out;
}
template <class t1, class t2>
ostream &operator<<(ostream &out, const pair<t1, t2> &a) {
out << a.first << " " << a.second;
return out;
}
template <class t1, class t2>
pair<t1, t2> operator+(const pair<t2, t1> &a, const pair<t1, t2> &b) {
return {a.first + b.first, a.second + b.second};
}
template <class t1, class t2>
pair<t1, t2> operator-(const pair<t2, t1> &a, const pair<t1, t2> &b) {
return {a.first - b.first, a.second - b.second};
}
//#define PRAGMA 448
#ifdef PRAGMA
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif
#ifdef LUCARIO
#define deb(...) fprintf(stderr, __VA_ARGS__)
#define deb1(x) cerr << #x << " = " << x << endl;
#define FIN 0
#else
#define deb(...) 0
#define deb1(x) 0
#define FIN \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#endif
typedef pair<long long, long long> pll;
typedef pair<int, int> pii;
typedef pair<string, int> psi;
#define ll long long
#define ld long double
//#define int long long
#define pb push_back
#define bs binary_search
#define up upper_bound // >
#define lb lower_bound // >=
#define f first
#define s second
#define fst first
#define snd second
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define mp make_pair
#define endl "\n"
#define fore(i, a, b) for (ll i = a; i < (ll)b; i++)
#define rfore(i, a, b) for (ll i = b - 1; i >= (ll)a; i--)
#define bin(aaa, bbb) \
fore(_, 0, bbb) cout << ((aaa & (1 << _)) != 0); \
cout << endl;
#define mm(a, b) memset(a, b, sizeof a)
#define trans(a, b) \
transform(a.begin(), a.end(), a.begin(), b) //::tolower ::toupper
#define bpop(n) __builtin_popcount(n)
#define np(a) next_permutation(a.begin(), a.end())
#define ALL(a) a.begin(), a.end()
#define SZ(n) ((ll)(n).size())
#define sfind(s, t) (s.find(t) != string::npos)
#define infll (ll)(1e16 + 3)
#define infi (ll)(1e9 + 4)
#define pi acos(-1)
#define mod (ll)(1e9 + 7)
#define eps 1e-7
#define YES "YES"
#define NO "NO"
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a * (b / gcd(a, b)); }
ll fpow(ll b, ll e, ll m = mod) {
int r = 1;
while (e) {
if (e & 1)
r = (r * b) % m;
e /= 2;
b = (b * b) % m;
}
return r;
}
int32_t main(int32_t argc, char const *argv[]) {
FIN;
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
/*
Para las DP:
sLos arreglos donde estén los valores en lo posible se declaran como INT
siempre hacer int &r = dp...
int res y trabapiijas todo con res
luego haces return r = res
cuando se trabaja se hace solve(...)+a[x];
break;
Fórmulas:
priority_queue < int,vector<int>,greater<int> > q; calse contenedor y
comparacion continue break cero = r/k - (l/k + (l%k!=0)) +1; cantidad de
números divisibles por k en el intervalo [l, r] en un arreglo sircularde largo n
si das saltos de largo m para volver al inicion nesesitas n/gcd(n,m) cantidad de
inmeros en un rango lower_bound(r) -lowerbound(l-1) upper_bound primer elemento
mayor estricto lower_bound primer elemento mayor o igual Al hacer BFS con
distancia recordar simpre antes de visitar preguntar si ya llegue antes con un
peso menor setprecision(15) freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
getline(cin,s); donde s es un string
si luego se van a haces unuevos cins hacer cin.ignore
__builtin_popcount(3) cantidad de unos en la reprewsentacion binaria
__builtin_clz() cantidad de 0 a la izquierda del primer numero
__builtin_ffs evuelve 1+ el indise del uno menos significativo
TCL
tuple
tuple<tipo> nombre
get<pos>(nombre) //forma de acceder
vector
vector<tipo> nombre(cantidad,contenido)
vector<int> nombre = {...}
nombre.resize(tam,contenido si se agregan) //cambia el tamaño a tam
nombre.pop_back() elimina el ultimo elemento
nombre.back() // ultimo elemnto
set
erase(it/elem)
insert(elem)
rectas en un set
recta = az+by+c = 0
recta entre 2 puntos
a = y1-y0 y b = x0-x1 => c = x1*y0-y1*x0
if(a<0 || (a==0 && b<0)) {
a=-a;
b=-b;
c=-c;
}
d = gcd(a,b)
a,b /= gcd(a,b);
c,d /= gcd(d,c)
luego
*/
|
#include <bits/stdc++.h>
using namespace std;
template <class e, class t, int N>
std::basic_istream<e, t> &operator>>(std::basic_istream<e, t> &in,
const e (&literal)[N]) {
std::array<e, N - 1> buffer; // get buffer
in >> buffer[0]; // skips whitespace
if (N > 2)
in.read(&buffer[1], N - 2); // read the rest
if (strncmp(&buffer[0], literal, N - 1)) // if it failed
in.setstate(in.rdstate() | std::ios::badbit); // set the state
return in;
}
template <class e, class t>
std::basic_istream<e, t> &operator>>(std::basic_istream<e, t> &in,
const e &literal) {
e buffer; // get buffer
in >> buffer; // read data
if (buffer != literal) // if it failed
in.setstate(in.rdstate() | std::ios::badbit); // set the state
return in;
}
// redirect mutable char arrays to their normal function
template <class e, class t, int N>
std::basic_istream<e, t> &operator>>(std::basic_istream<e, t> &in,
e (&carray)[N]) {
return std::operator>>(in, carray);
}
template <class t> istream &operator>>(istream &in, vector<t> &v) {
for (int i = 0; i < v.size(); i++)
in >> v[i];
return in;
}
template <class t1, class t2>
istream &operator>>(istream &in, pair<t1, t2> &v) {
cin >> v.first >> v.second;
return in;
}
template <class t> ostream &operator<<(ostream &out, vector<t> &a) {
for (auto x : a) {
out << x << " ";
}
return out;
}
template <class t> ostream &operator<<(ostream &out, set<t> &a) {
for (auto x : a) {
out << x << " ";
}
return out;
}
template <class t1, class t2>
ostream &operator<<(ostream &out, map<t1, t2> &a) {
for (auto x : a) {
out << x.first << " = " << x.second << endl;
}
return out;
}
template <class t1, class t2>
ostream &operator<<(ostream &out, const pair<t1, t2> &a) {
out << a.first << " " << a.second;
return out;
}
template <class t1, class t2>
pair<t1, t2> operator+(const pair<t2, t1> &a, const pair<t1, t2> &b) {
return {a.first + b.first, a.second + b.second};
}
template <class t1, class t2>
pair<t1, t2> operator-(const pair<t2, t1> &a, const pair<t1, t2> &b) {
return {a.first - b.first, a.second - b.second};
}
//#define PRAGMA 448
#ifdef PRAGMA
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif
#ifdef LUCARIO
#define deb(...) fprintf(stderr, __VA_ARGS__)
#define deb1(x) cerr << #x << " = " << x << endl;
#define FIN 0
#else
#define deb(...) 0
#define deb1(x) 0
#define FIN \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#endif
typedef pair<long long, long long> pll;
typedef pair<int, int> pii;
typedef pair<string, int> psi;
#define ll long long
#define ld long double
#define int long long
#define pb push_back
#define bs binary_search
#define up upper_bound // >
#define lb lower_bound // >=
#define f first
#define s second
#define fst first
#define snd second
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define mp make_pair
#define endl "\n"
#define fore(i, a, b) for (ll i = a; i < (ll)b; i++)
#define rfore(i, a, b) for (ll i = b - 1; i >= (ll)a; i--)
#define bin(aaa, bbb) \
fore(_, 0, bbb) cout << ((aaa & (1 << _)) != 0); \
cout << endl;
#define mm(a, b) memset(a, b, sizeof a)
#define trans(a, b) \
transform(a.begin(), a.end(), a.begin(), b) //::tolower ::toupper
#define bpop(n) __builtin_popcount(n)
#define np(a) next_permutation(a.begin(), a.end())
#define ALL(a) a.begin(), a.end()
#define SZ(n) ((ll)(n).size())
#define sfind(s, t) (s.find(t) != string::npos)
#define infll (ll)(1e16 + 3)
#define infi (ll)(1e9 + 4)
#define pi acos(-1)
#define mod (ll)(1e9 + 7)
#define eps 1e-7
#define YES "YES"
#define NO "NO"
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a * (b / gcd(a, b)); }
ll fpow(ll b, ll e, ll m = mod) {
int r = 1;
while (e) {
if (e & 1)
r = (r * b) % m;
e /= 2;
b = (b * b) % m;
}
return r;
}
int32_t main(int32_t argc, char const *argv[]) {
FIN;
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
/*
Para las DP:
sLos arreglos donde estén los valores en lo posible se declaran como INT
siempre hacer int &r = dp...
int res y trabapiijas todo con res
luego haces return r = res
cuando se trabaja se hace solve(...)+a[x];
break;
Fórmulas:
priority_queue < int,vector<int>,greater<int> > q; calse contenedor y
comparacion continue break cero = r/k - (l/k + (l%k!=0)) +1; cantidad de
números divisibles por k en el intervalo [l, r] en un arreglo sircularde largo n
si das saltos de largo m para volver al inicion nesesitas n/gcd(n,m) cantidad de
inmeros en un rango lower_bound(r) -lowerbound(l-1) upper_bound primer elemento
mayor estricto lower_bound primer elemento mayor o igual Al hacer BFS con
distancia recordar simpre antes de visitar preguntar si ya llegue antes con un
peso menor setprecision(15) freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
getline(cin,s); donde s es un string
si luego se van a haces unuevos cins hacer cin.ignore
__builtin_popcount(3) cantidad de unos en la reprewsentacion binaria
__builtin_clz() cantidad de 0 a la izquierda del primer numero
__builtin_ffs evuelve 1+ el indise del uno menos significativo
TCL
tuple
tuple<tipo> nombre
get<pos>(nombre) //forma de acceder
vector
vector<tipo> nombre(cantidad,contenido)
vector<int> nombre = {...}
nombre.resize(tam,contenido si se agregan) //cambia el tamaño a tam
nombre.pop_back() elimina el ultimo elemento
nombre.back() // ultimo elemnto
set
erase(it/elem)
insert(elem)
rectas en un set
recta = az+by+c = 0
recta entre 2 puntos
a = y1-y0 y b = x0-x1 => c = x1*y0-y1*x0
if(a<0 || (a==0 && b<0)) {
a=-a;
b=-b;
c=-c;
}
d = gcd(a,b)
a,b /= gcd(a,b);
c,d /= gcd(d,c)
luego
*/
|
[] | 726,841
| 726,842
|
u037242228
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
#define bug cout << "-----------" << endl
const long long INF = (long long)1e18;
#define ll long long int
#define MAX 2268312229760322080
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
cout << n * (n - 1) / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define bug cout << "-----------" << endl
const long long INF = (long long)1e18;
#define ll long long int
#define MAX 2268312229760322080
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
cout << n * (n - 1) / 2;
return 0;
}
|
[
"variable_declaration.type.change"
] | 726,847
| 726,848
|
u918077858
|
cpp
|
p02924
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
int main() {
int N;
cin >> N;
int ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
int main() {
ll N;
cin >> N;
ll ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 726,854
| 726,855
|
u607865971
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
#include <iostream>
using namespace std;
int main() {
unsigned long n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,856
| 726,857
|
u827974318
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
// Function Macros:
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define setpre(n) cout << fixed << setprecision(n)
// Type Definitions:
typedef long long ll;
typedef unsigned long long ull;
// Constants:
const int INF = 2e9;
const int MOD = 1e9 + 7;
// Global Variables:
// Prototype Declarations:
int gcd(int, int);
//================ Main Loop ================
int main() {
int N;
cin >> N;
cout << (ull)(N * (N - 1) / 2) << endl;
return 0;
}
//===========================================
// Functions:
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
|
#include <bits/stdc++.h>
using namespace std;
// Function Macros:
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define setpre(n) cout << fixed << setprecision(n)
// Type Definitions:
typedef long long ll;
typedef unsigned long long ull;
// Constants:
const int INF = 2e9;
const int MOD = 1e9 + 7;
// Global Variables:
// Prototype Declarations:
int gcd(int, int);
//================ Main Loop ================
int main() {
ull N;
cin >> N;
cout << (ull)(N * (N - 1) / 2) << endl;
return 0;
}
//===========================================
// Functions:
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
|
[
"variable_declaration.type.change"
] | 726,859
| 726,860
|
u449175559
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
// Function Macros:
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define setpre(n) cout << fixed << setprecision(n)
// Type Definitions:
typedef long long ll;
typedef unsigned long long ull;
// Constants:
const int INF = 2e9;
const int MOD = 1e9 + 7;
// Global Variables:
// Prototype Declarations:
int gcd(int, int);
//================ Main Loop ================
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
return 0;
}
//===========================================
// Functions:
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
|
#include <bits/stdc++.h>
using namespace std;
// Function Macros:
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define setpre(n) cout << fixed << setprecision(n)
// Type Definitions:
typedef long long ll;
typedef unsigned long long ull;
// Constants:
const int INF = 2e9;
const int MOD = 1e9 + 7;
// Global Variables:
// Prototype Declarations:
int gcd(int, int);
//================ Main Loop ================
int main() {
ull N;
cin >> N;
cout << (ull)(N * (N - 1) / 2) << endl;
return 0;
}
//===========================================
// Functions:
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
|
[
"variable_declaration.type.change",
"call.add",
"call.arguments.change"
] | 726,861
| 726,860
|
u449175559
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << (N - 1) * N / 2 << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long N;
cin >> N;
cout << (N - 1) * N / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,862
| 726,863
|
u577926181
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
long long int n, x;
x = (n * (n - 1)) / 2;
cout << x << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long int n, x;
cin >> n;
x = (n * (n - 1)) / 2;
cout << x << endl;
return 0;
}
|
[] | 726,864
| 726,865
|
u072203760
|
cpp
|
p02924
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
ll ans;
ans = (n * n - n) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
ll n;
cin >> n;
ll ans;
ans = (n * n - n) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 726,868
| 726,869
|
u639426108
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
cout << N * (N - 1) / 2;
}
|
[
"variable_declaration.type.widen.change"
] | 726,881
| 726,882
|
u926416331
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
int h[100001];
int a[100001];
int main() {
cin.tie(0); // cout と cin の同期を切る
ios::sync_with_stdio(false); /* cの stdioストリーム (printfとか)と*/
int N;
cin >> N;
cout << ((N - 1) * (N)) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
int h[100001];
int a[100001];
int main() {
cin.tie(0); // cout と cin の同期を切る
ios::sync_with_stdio(false); /* cの stdioストリーム (printfとか)と*/
long long N;
cin >> N;
cout << ((N - 1) * (N)) / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,887
| 726,888
|
u858520692
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int n;
long long res = 0;
cin >> n;
cout << ((n - 1) * n) / 2;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long n;
long long res = 0;
cin >> n;
cout << ((n - 1) * n) / 2;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,895
| 726,896
|
u021107862
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
unsigned int N;
cin >> N;
unsigned int ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
unsigned long N;
cin >> N;
unsigned long ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 726,897
| 726,898
|
u204252859
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
unsigned long N;
cin >> N;
unsigned long ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,899
| 726,898
|
u204252859
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int ans = (N * N - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
unsigned long N;
cin >> N;
unsigned long ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,900
| 726,898
|
u204252859
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
#include <iostream>
using namespace std;
int main() {
long long N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,901
| 726,902
|
u864044904
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2;
}
|
#include <iostream>
using namespace std;
int main() {
long long N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"io.output.newline.add"
] | 726,903
| 726,902
|
u864044904
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
int sum = (n * (n - 1)) / 2;
cout << sum << endl;
}
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = (n * (n - 1)) / 2;
cout << sum << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,904
| 726,905
|
u526278960
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int sum = (n * (n - 1)) / 2;
cout << sum << endl;
}
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = (n * (n - 1)) / 2;
cout << sum << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,906
| 726,905
|
u526278960
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
long long s = (n * (n + 1)) / 2;
cout << s << endl;
}
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
n--;
long long s = (n * (n + 1)) / 2;
cout << s << endl;
}
|
[
"expression.unary.arithmetic.add"
] | 726,909
| 726,910
|
u146209432
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * (n + 1) / 2 - n << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
long long n;
cin >> n;
cout << n * (n + 1) / 2 - n << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,915
| 726,916
|
u710397511
|
cpp
|
p02924
|
#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;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
cout << (ll)n * (n - 1) / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 726,921
| 726,922
|
u775556337
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = N * (N - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,923
| 726,924
|
u942915776
|
cpp
|
p02924
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define INF 1e18
#define int long long
signed main() {
int n;
cin >> n;
int ans = n * (n - 1) / 2.0;
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define INF 1e18
#define int long long
signed main() {
int n;
cin >> n;
int ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"literal.number.change",
"expression.operation.binary.change"
] | 726,948
| 726,949
|
u032189172
|
cpp
|
p02924
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
long long ans = (1 + N) * N / 2 - N;
cout << ans;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = (1 + N) * N / 2 - N;
cout << ans;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,950
| 726,951
|
u582357587
|
cpp
|
p02924
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
long long ans = (1 + N) * N / 2 - N;
cout << ans;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = (1 + N) * N / 2 - N;
cout << ans;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,950
| 726,952
|
u582357587
|
cpp
|
p02924
|
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = n * (n - 1) / 2;
cout << ans << endl;
}
|
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#include <bits/stdc++.h>
using namespace std;
int main() {
ll n;
cin >> n;
ll ans = n * (n - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 726,955
| 726,956
|
u438592861
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 1) {
cout << n * (n - 1) / 2 << endl;
} else {
cout << (n + 1) * n / 2 - n << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 2 == 1) {
cout << n * (n - 1) / 2 << endl;
} else {
cout << (n + 1) * n / 2 - n << endl;
}
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,962
| 726,963
|
u564060397
|
cpp
|
p02924
|
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
#include <iostream>
using namespace std;
int main() {
long int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
[
"variable_declaration.type.widen.change"
] | 726,966
| 726,967
|
u984200859
|
cpp
|
p02924
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = n * (n - 1LL) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.type.widen.change"
] | 726,976
| 726,977
|
u917944707
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define MOD 1000000007
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define rep(i, a, b) for (long long int i = a; i < b; i++)
#define nrep(i, a, b) for (long long int i = a; i >= b; i--)
using namespace std;
int main() {
fast;
ll n1;
cout << (n1 * (n1 - 1)) / 2;
}
|
#include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define MOD 1000000007
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define rep(i, a, b) for (long long int i = a; i < b; i++)
#define nrep(i, a, b) for (long long int i = a; i >= b; i--)
using namespace std;
int main() {
fast;
ll n1;
cin >> n1;
cout << (n1 * (n1 - 1)) / 2;
}
|
[] | 726,980
| 726,981
|
u336130820
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#include <vector>
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
//ループマクロ
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; 0 <= i; i--)
//入出力
#define SCOUT(x) cout << (x) << " "
#define VECCIN(x) \
for (auto &ele : (x)) \
cin >> ele
#define CEVCOUT(x) \
for (auto &ele : (x)) \
cout << ele << " "; \
cout << endl;
//その他
#define ALL(obj) (obj).begin(), (obj).end()
#define P pair<int, int>
#define V vector<int>
#define M map<int>
#define S set<int>
#define PQ priority_queue<int>
#define PQG priority_queue<int, V, greater<int>>
int main(void) {
ios::sync_with_stdio(false);
int N;
cin >> N;
printf("%lld\n", ((N - 1) * N) / 2);
return 0;
}
|
#include <bits/stdc++.h>
#include <vector>
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
//ループマクロ
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; 0 <= i; i--)
//入出力
#define SCOUT(x) cout << (x) << " "
#define VECCIN(x) \
for (auto &ele : (x)) \
cin >> ele
#define CEVCOUT(x) \
for (auto &ele : (x)) \
cout << ele << " "; \
cout << endl;
//その他
#define ALL(obj) (obj).begin(), (obj).end()
#define P pair<int, int>
#define V vector<int>
#define M map<int>
#define S set<int>
#define PQ priority_queue<int>
#define PQG priority_queue<int, V, greater<int>>
int main(void) {
ios::sync_with_stdio(false);
long long N;
cin >> N;
printf("%lld\n", ((N - 1) * N) / 2);
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 726,988
| 726,989
|
u281840563
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
int main() {
int n, ans;
cin >> n;
ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
int main() {
ll n, ans;
cin >> n;
ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 727,000
| 727,001
|
u199343957
|
cpp
|
p02924
|
/*
Chase
Your
Legend
英雄志逐传奇
*/
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
cout << (n * (n - 1)) / 2 << endl;
}
|
/*
Chase
Your
Legend
英雄志逐传奇
*/
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
int main() {
ll n;
cin >> n;
cout << (n * (n - 1)) / 2 << endl;
}
|
[
"variable_declaration.type.change"
] | 727,014
| 727,015
|
u955534952
|
cpp
|
p02924
|
/*
Chase
Your
Legend
英雄志逐传奇
*/
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
/*
Chase
Your
Legend
英雄志逐传奇
*/
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
using namespace std;
int main() {
ll n;
cin >> n;
cout << (n * (n - 1)) / 2 << endl;
}
|
[
"variable_declaration.type.change"
] | 727,016
| 727,015
|
u955534952
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a) for (int i = 0; i < (a); i++)
const ll MOD = 1000000007;
// const ll MOD=998244353;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a) for (int i = 0; i < (a); i++)
const ll MOD = 1000000007;
// const ll MOD=998244353;
int main() {
int N;
cin >> N;
cout << 1LL * N * (N - 1) / 2 << endl;
return 0;
}
|
[
"expression.operation.binary.add"
] | 727,017
| 727,018
|
u046768272
|
cpp
|
p02924
|
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d\n", n * (n - 1) / 2);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
printf("%lld\n", n * (n - 1) / 2);
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 727,029
| 727,030
|
u919923389
|
cpp
|
p02924
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef vector<double> VD;
typedef vector<LL> VLL;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef vector<vector<bool>> VVB;
typedef vector<vector<double>> VVD;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(a) (a).begin(), (a).end()
const int MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void debug(VVI &board) {
int h = board.size();
int w = board.at(0).size();
rep(i, h) {
rep(j, w) { cout << board.at(i).at(j) << " "; }
cout << endl;
}
}
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef vector<double> VD;
typedef vector<LL> VLL;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef vector<vector<bool>> VVB;
typedef vector<vector<double>> VVD;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(a) (a).begin(), (a).end()
const int MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void debug(VVI &board) {
int h = board.size();
int w = board.at(0).size();
rep(i, h) {
rep(j, w) { cout << board.at(i).at(j) << " "; }
cout << endl;
}
}
int main() {
LL n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 727,031
| 727,032
|
u662614053
|
cpp
|
p02924
|
#include <algorithm>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility> // pair make_pair
#include <vector>
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define ll long long
//#define int ll
#define INF INT_MAX / 10
using namespace std;
using Pi = pair<int, int>;
using Graph = vector<vector<int>>;
using WeightGraph = vector<vector<Pi>>;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
#include <algorithm>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility> // pair make_pair
#include <vector>
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define ll long long
#define int ll
#define INF INT_MAX / 10
using namespace std;
using Pi = pair<int, int>;
using Graph = vector<vector<int>>;
using WeightGraph = vector<vector<Pi>>;
signed main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 727,035
| 727,036
|
u703205079
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
cout << n * (n + 1) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 727,045
| 727,046
|
u017167684
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
#define psi pair<string, int>
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n;
cin >> n;
long long sum = n * (n - 1) / 2;
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define psi pair<string, int>
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
long long n;
cin >> n;
long long sum = n * (n - 1) / 2;
cout << sum << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,047
| 727,048
|
u224843402
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << ((N - 1) * N) / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
cout << ((N - 1) * N) / 2;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,057
| 727,058
|
u038569501
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
typedef long long ll;
int main() {
int n;
cin >> n;
cout << (n * (n - 1) / 2) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
typedef long long ll;
int main() {
ll n;
cin >> n;
cout << (n * (n - 1) / 2) << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 727,069
| 727,070
|
u168525123
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int num = (N - 1) * (N);
cout << num / 2 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
long long num = (N - 1) * (N);
cout << num / 2 << "\n";
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,071
| 727,072
|
u605757515
|
cpp
|
p02924
|
#include <stdio.h>
int main(int argc, char const *argv[]) {
int N;
scanf("%d", &N);
int mod_sum;
mod_sum = N * (N - 1) / 2;
printf("%d\n", mod_sum);
return 0;
}
|
#include <stdio.h>
int main(int argc, char const *argv[]) {
long int N;
scanf("%ld", &N);
long int mod_sum;
mod_sum = N * (N - 1) / 2;
printf("%ld\n", mod_sum);
return 0;
}
|
[
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 727,073
| 727,074
|
u723444827
|
cpp
|
p02924
|
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int n;
cin >> n;
cout << (n - 1) * n / 2 << endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
long long n;
cin >> n;
cout << (n - 1) * n / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,092
| 727,093
|
u359856428
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 1 + (n + 1) * (n - 2) / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << 1 + (n + 1) * (n - 2) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,094
| 727,095
|
u548026329
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,096
| 727,097
|
u548026329
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,098
| 727,099
|
u331948661
|
cpp
|
p02924
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
if (N != 1)
ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int64_t N;
cin >> N;
int64_t ans = 0;
if (N != 1)
ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 727,114
| 727,115
|
u661738979
|
cpp
|
p02924
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#define INF INT_MAX >> 1
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, from, to) for (int i = (from); i < (int)(to); i++)
#define repr(i, n) for (int i = (n - 1); 0 <= i; i--)
#define repr2(i, from, to) for (int i = (from - 1); (int)(to) <= i; i--)
#define ALL(obj) (obj).begin(), (obj).end()
typedef long long ll;
using namespace std;
struct Point {
int x, y;
};
struct Edge {
int to, cost;
};
struct gNode {
int from, to, cost;
};
struct tNode {
int value;
int parent;
vector<int> child;
};
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int extgcd(int a, int b, int &x, int &y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
ll mod_pow(ll x, ll n) {
if (n == 0)
return 1;
ll res = mod_pow(x * x % MOD, n / 2);
if (n & 1)
res = res * x % MOD;
return res;
}
int main(void) {
int n;
cin >> n;
cout << (n * (n - 1)) / 2 << endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#define INF INT_MAX >> 1
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, from, to) for (int i = (from); i < (int)(to); i++)
#define repr(i, n) for (int i = (n - 1); 0 <= i; i--)
#define repr2(i, from, to) for (int i = (from - 1); (int)(to) <= i; i--)
#define ALL(obj) (obj).begin(), (obj).end()
typedef long long ll;
using namespace std;
struct Point {
int x, y;
};
struct Edge {
int to, cost;
};
struct gNode {
int from, to, cost;
};
struct tNode {
int value;
int parent;
vector<int> child;
};
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int extgcd(int a, int b, int &x, int &y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
ll mod_pow(ll x, ll n) {
if (n == 0)
return 1;
ll res = mod_pow(x * x % MOD, n / 2);
if (n & 1)
res = res * x % MOD;
return res;
}
int main(void) {
ll n;
cin >> n;
cout << (n * (n - 1)) / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 727,116
| 727,117
|
u117734686
|
cpp
|
p02924
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
int n;
unsigned long long ans = 0, temp = 0;
cin >> n;
ans = (ll)(n * (n - 1)) / 2;
cout << ans << endl;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
int n;
unsigned long long ans = 0, temp = 0;
cin >> n;
ans = ((ll)(n) * (ll)(n - 1)) / 2;
cout << ans << endl;
}
|
[
"call.arguments.change"
] | 727,122
| 727,123
|
u227764848
|
cpp
|
p02924
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
int n;
ll ans = 0, temp = 0;
cin >> n;
ans = (n * (n - 1)) / 2;
cout << ans << endl;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
unsigned long long n;
unsigned long long ans = 0, temp = 0;
cin >> n;
ans = (n * (n - 1)) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 727,124
| 727,125
|
u227764848
|
cpp
|
p02924
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
int n;
int ans = 0, temp = 0;
cin >> n;
ans = (n * (n - 1)) / 2;
cout << ans << endl;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
unsigned long long n;
unsigned long long ans = 0, temp = 0;
cin >> n;
ans = (n * (n - 1)) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 727,126
| 727,125
|
u227764848
|
cpp
|
p02924
|
#include <stdio.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d", (n * (n - 1)) / 2);
}
|
#include <stdio.h>
using namespace std;
int main() {
long long int n;
scanf("%lld", &n);
printf("%lld", (n * (n - 1)) / 2);
}
|
[
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 727,127
| 727,128
|
u271454647
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N = 0;
cin >> N;
auto ans = static_cast<long long>(N * (N - 1) / 2);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N = 0;
cin >> N;
auto ans = static_cast<long long>(N) * (N - 1) / 2;
cout << ans << endl;
}
|
[
"call.arguments.change"
] | 727,135
| 727,136
|
u879434320
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
auto N = 0;
cin >> N;
auto ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N = 0;
cin >> N;
auto ans = (long long)N * (N - 1) / 2;
cout << ans << endl;
}
|
[
"type_conversion.add"
] | 727,137
| 727,138
|
u879434320
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
auto N = 0;
cin >> N;
auto ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
auto ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.widen.change"
] | 727,137
| 727,139
|
u879434320
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
long long ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
auto ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"variable_declaration.type.narrow.change"
] | 727,140
| 727,139
|
u879434320
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
long long ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
long long ans = N * (N - 1) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,140
| 727,141
|
u879434320
|
cpp
|
p02924
|
#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;
cin >> n;
cout << ((2 + n - 1) * (n - 2)) / 2 + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
cout << ((2 + n - 1) * (n - 2)) / 2 + 1 << endl;
// cout << (1 + n - 1) * (n - 1) / 2 << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 727,144
| 727,145
|
u735909278
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
n = n - 1;
ll ans = (n + 1) * n / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
typedef long long ll;
using namespace std;
int main() {
ll n;
cin >> n;
n = n - 1;
ll ans = (n + 1) * n / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 727,150
| 727,151
|
u142253890
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
n = n - 1;
int ans = (n + 1) * n / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
typedef long long ll;
using namespace std;
int main() {
ll n;
cin >> n;
n = n - 1;
ll ans = (n + 1) * n / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.change"
] | 727,152
| 727,151
|
u142253890
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
long long int N;
cin >> N;
cout << N * (N - 1) / 2 << endl;
}
|
[
"variable_declaration.type.widen.change"
] | 727,159
| 727,160
|
u258342334
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
// inline int in() { int x; scanf("%d",&x); return x;}
inline ll in() {
ll x;
cin >> x;
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MX = 200005;
vector<int> to[2505];
vector<int> rto[2505];
bool reachablefrom1[2505];
bool reachableToN[2505];
bool ok[2505];
void dfs(int v) {
if (reachablefrom1[v])
return;
reachablefrom1[v] = true;
for (int u : to[v]) {
dfs(u);
}
}
void rdfs(int v) {
if (reachableToN[v])
return;
reachableToN[v] = true;
for (int u : rto[v]) {
rdfs(u);
}
}
int main() {
int n = in();
ll ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
// inline int in() { int x; scanf("%d",&x); return x;}
inline ll in() {
ll x;
cin >> x;
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MX = 200005;
vector<int> to[2505];
vector<int> rto[2505];
bool reachablefrom1[2505];
bool reachableToN[2505];
bool ok[2505];
void dfs(int v) {
if (reachablefrom1[v])
return;
reachablefrom1[v] = true;
for (int u : to[v]) {
dfs(u);
}
}
void rdfs(int v) {
if (reachableToN[v])
return;
reachableToN[v] = true;
for (int u : rto[v]) {
rdfs(u);
}
}
int main() {
ll n = in();
ll ans = n * (n - 1) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 727,185
| 727,186
|
u526630579
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最大公約数
int lcm(int a, int b) { return a * b / gcd(a, b); } //最小公倍数
int main() {
int n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, x, n) for (int i = x; i < (n); i++)
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最大公約数
int lcm(int a, int b) { return a * b / gcd(a, b); } //最小公倍数
int main() {
long long n;
cin >> n;
cout << n * (n - 1) / 2 << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 727,189
| 727,190
|
u110681742
|
cpp
|
p02924
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
uint64_t m = 2;
uint64_t t = (n + 1) * n;
uint64_t ret = t / m - n;
cout << ret << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
uint64_t n;
cin >> n;
uint64_t m = 2;
uint64_t t = (n + 1) * n;
uint64_t ret = t / m - n;
cout << ret << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 727,191
| 727,192
|
u155403964
|
cpp
|
p02924
|
#include <bits/stdc++.h>
#define ll long long int
#define vi vector<int>
#define vc vector<char>
#define vl vector<ll>
#define vii vector<pair<int, int>>
#define vll vector<pair<ll, ll>>
#define pb push_back
#define el '\n'
#define N 1000000007
#define re return
#define PI 3.14159265
#define take(a, n) \
for (int i = 0; i < (n); i++) \
cin >> (a)[i]
#define out(a, n) \
for (int i = 0; i < n; i++) \
cout << a[i] << " ";
#define all(a) (a).begin(), (a).end()
#define forup(i, n) for (int(i) = 0; i < (n); (i)++)
#define ford(i, n) for (int(i) = (n)-1; i >= 0; (i)--)
using namespace std;
ll poww(ll a, ll b) {
ll ans = 1;
for (int i = 1; i <= b; i++) {
ans *= a;
}
return ans;
}
int max(int a, int b, int c) {
if (a >= b && a >= c)
return a;
if (b >= a && b >= c)
return b;
return c;
}
ll ncr(int n, int r) {
ll ans = 1;
forup(i, r) { ans = (ans * (n - i) / (i + 1)) % N; }
re ans;
}
int main() {
int n, b;
cin >> n;
ll ans = 0;
ans = (n * (n - 1)) / 2;
cout << ans;
}
|
#include <bits/stdc++.h>
#define ll long long int
#define vi vector<int>
#define vc vector<char>
#define vl vector<ll>
#define vii vector<pair<int, int>>
#define vll vector<pair<ll, ll>>
#define pb push_back
#define el '\n'
#define N 1000000007
#define re return
#define PI 3.14159265
#define take(a, n) \
for (int i = 0; i < (n); i++) \
cin >> (a)[i]
#define out(a, n) \
for (int i = 0; i < n; i++) \
cout << a[i] << " ";
#define all(a) (a).begin(), (a).end()
#define forup(i, n) for (int(i) = 0; i < (n); (i)++)
#define ford(i, n) for (int(i) = (n)-1; i >= 0; (i)--)
using namespace std;
ll poww(ll a, ll b) {
ll ans = 1;
for (int i = 1; i <= b; i++) {
ans *= a;
}
return ans;
}
int max(int a, int b, int c) {
if (a >= b && a >= c)
return a;
if (b >= a && b >= c)
return b;
return c;
}
ll ncr(int n, int r) {
ll ans = 1;
forup(i, r) { ans = (ans * (n - i) / (i + 1)) % N; }
re ans;
}
int main() {
ll n, b;
cin >> n;
ll ans = 0;
ans = (n * (n - 1)) / 2;
cout << ans;
}
|
[
"variable_declaration.type.change"
] | 727,193
| 727,194
|
u093730269
|
cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.