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 |
|---|---|---|---|---|---|---|---|
p02934
|
#include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
unsigned euclidean_lcm(unsigned a, unsigned b) {
unsigned g;
g = euclidean_gcd(a, b);
return a * b / g;
}
int main() {
long long n = 0;
double mother, child = 0;
cin >> n;
vector<double> a(n);
vector<double> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
for (int j = 1; j < n; j++) {
a[j] = euclidean_lcm(a[j], a[j - 1]);
mother = a[j]; //最小公倍数
}
for (int k = 0; k < n; k++) {
child += mother / b[k]; //最小公倍数÷配列[i]
}
cout << setprecision(12) << mother / child << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
unsigned euclidean_lcm(unsigned a, unsigned b) {
unsigned g;
g = euclidean_gcd(a, b);
return a * b / g;
}
int main() {
long long n = 0;
double mother, child = 0;
cin >> n;
vector<double> a(n);
vector<double> b(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
for (long long j = 1; j < n; j++) {
a[j] = euclidean_lcm(a[j], a[j - 1]);
mother = a[j]; //最小公倍数
}
for (long long k = 0; k < n; k++) {
child += mother / b[k]; //最小公倍数÷配列[i]
}
cout << setprecision(12) << mother / child << endl;
return 0;
}
|
[
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 736,648
| 736,649
|
u464527162
|
cpp
|
p02934
|
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
std::vector<double> a(n);
for (int i = 0; i < n; ++i)
std::cin >> a[i];
double ans = 0;
for (int i = 0; i < n; ++i)
ans += a[i];
ans = 1 / ans;
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
std::vector<double> a(n);
for (int i = 0; i < n; ++i)
std::cin >> a[i];
double ans = 0;
for (int i = 0; i < n; ++i)
ans += 1 / a[i];
ans = 1 / ans;
std::cout << ans << std::endl;
return 0;
}
|
[
"assignment.change"
] | 736,652
| 736,653
|
u313111801
|
cpp
|
p02934
|
///////////////////////////////////////////////////////////
#include <algorithm>
#include <array>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
///////////////////////////////////////////////////////////
#define ll long long
#define ull insigned lon long
///////////////////////////////////////////////////////////
int absolute(int n);
void input(vector<int> &vec);
void print(vector<int> vec);
void print(vector<double> vec);
int sum(vector<int> vec);
double sum(vector<double> vec);
void upsort(vector<int> &vec);
void downsort(vector<int> &vec);
int maxvec(vector<int> vec);
int minvec(vector<int> vec);
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
int main() {
int n;
cin >> n;
vector<int> a(n);
input(a);
vector<double> b(n);
for (int i = 0; i < n; ++i) {
b.at(i) = 1.0 / a.at(i);
}
print(b);
cout << 1.0 / sum(b) << endl;
return 0;
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
int absolute(int n) {
if (n < 0) {
return (-n);
}
return n;
}
void input(vector<int> &vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cin >> vec.at(i);
}
}
void print(vector<int> vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cout << vec.at(i) << " ";
}
cout << endl;
}
void print(vector<double> vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cout << vec.at(i) << " ";
}
cout << endl;
}
int sum(vector<int> vec) {
int s = accumulate(vec.begin(), vec.end(), 0);
return s;
}
double sum(vector<double> vec) {
double s = accumulate(vec.begin(), vec.end(), 0.0);
return s;
}
void upsort(vector<int> &vec) { sort(vec.begin(), vec.end()); }
void downsort(vector<int> &vec) {
sort(vec.begin(), vec.end(), greater<int>());
}
int maxvec(vector<int> vec) {
int m = vec.at(0);
for (size_t i = 0; i < vec.size(); ++i) {
m = max(m, vec.at(i));
}
return m;
}
int minvec(vector<int> vec) {
int m = vec.at(0);
for (size_t i = 0; i < vec.size(); ++i) {
m = min(m, vec.at(i));
}
return m;
}
///////////////////////////////////////////////////////////
|
///////////////////////////////////////////////////////////
#include <algorithm>
#include <array>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
///////////////////////////////////////////////////////////
#define ll long long
#define ull insigned lon long
///////////////////////////////////////////////////////////
int absolute(int n);
void input(vector<int> &vec);
void print(vector<int> vec);
void print(vector<double> vec);
int sum(vector<int> vec);
double sum(vector<double> vec);
void upsort(vector<int> &vec);
void downsort(vector<int> &vec);
int maxvec(vector<int> vec);
int minvec(vector<int> vec);
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
int main() {
int n;
cin >> n;
vector<int> a(n);
input(a);
vector<double> b(n);
for (int i = 0; i < n; ++i) {
b.at(i) = 1.0 / a.at(i);
}
cout << 1.0 / sum(b) << endl;
return 0;
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
int absolute(int n) {
if (n < 0) {
return (-n);
}
return n;
}
void input(vector<int> &vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cin >> vec.at(i);
}
}
void print(vector<int> vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cout << vec.at(i) << " ";
}
cout << endl;
}
void print(vector<double> vec) {
for (size_t i = 0; i < vec.size(); ++i) {
cout << vec.at(i) << " ";
}
cout << endl;
}
int sum(vector<int> vec) {
int s = accumulate(vec.begin(), vec.end(), 0);
return s;
}
double sum(vector<double> vec) {
double s = accumulate(vec.begin(), vec.end(), 0.0);
return s;
}
void upsort(vector<int> &vec) { sort(vec.begin(), vec.end()); }
void downsort(vector<int> &vec) {
sort(vec.begin(), vec.end(), greater<int>());
}
int maxvec(vector<int> vec) {
int m = vec.at(0);
for (size_t i = 0; i < vec.size(); ++i) {
m = max(m, vec.at(i));
}
return m;
}
int minvec(vector<int> vec) {
int m = vec.at(0);
for (size_t i = 0; i < vec.size(); ++i) {
m = min(m, vec.at(i));
}
return m;
}
///////////////////////////////////////////////////////////
|
[
"call.remove"
] | 736,656
| 736,657
|
u335921722
|
cpp
|
p02934
|
#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;
double sum = 0;
rep(i, n) {
int a;
cin >> a;
sum += 1.0 / a;
}
double ans = 1 / sum;
printf("%.10f\n", ans);
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() {
int n;
cin >> n;
double sum = 0;
rep(i, n) {
int a;
cin >> a;
sum += 1.0 / a;
}
double ans = 1 / sum;
printf("%.10f\n", ans);
return 0;
}
|
[] | 736,660
| 736,661
|
u457283867
|
cpp
|
p02934
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n = 1;
cin >> n;
vector<double> a(n);
double s1 = 0, s2 = 1;
for (int i = 0; i < n; i++) {
cin >> a[n];
s1 += 1 / a[n];
}
cout << 1 / s1 << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n = 1;
cin >> n;
// vector<double>a(n);
double a[105];
double s1 = 0, s2 = 1;
for (int i = 0; i < n; i++) {
cin >> a[n];
s1 += 1 / a[n];
}
cout << 1 / s1 << endl;
return 0;
}
|
[] | 736,662
| 736,663
|
u199184624
|
cpp
|
p02934
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define double long double
#define low lower_bound
#define upp upper_bound
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n) for (int i = (int)(n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
#define rever(vec) reverse(all(vec));
#define cend cout << endl;
#define prique(T) priority_queue<T, vector<T>, greater<T>>
#define prique2(T) priority_queue<T>
struct edge {
int to, cost;
};
using P = pair<int, int>;
using PP = pair<P, int>;
const int mod2 = 998244353;
const int mod = 1e9 + 7, inf = 1e16;
int modpow(int x, int n) {
int ans = 1;
while (n > 0) {
if (n & 1) {
ans *= x;
if (mod <= ans)
ans %= mod;
}
x *= x;
if (mod <= x)
x %= mod;
n >>= 1;
}
return ans;
}
int fact_memo[114514];
int fact(int n) {
int ans = 1;
if (fact_memo[n])
return fact_memo[n];
rep(i, n) {
ans *= (i + 1);
if (mod <= ans)
ans %= mod;
fact_memo[i + 1] = ans;
}
return (ans + mod) % mod;
}
int comb(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod *
modpow(fact(r), mod - 2) +
mod) %
mod;
}
int perm(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod + mod) % mod;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool pri(int p) {
for (int i = 2; i * i <= p; i++)
if (p % i == 0)
return false;
return p > 1;
}
map<int, int> factring(int n) {
map<int, int> ans;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
ans[i]++;
}
}
if (n != 1)
ans[n]++;
return ans;
}
P operator+(const P &a, const P &b) {
return P(a.first + b.first, a.second + b.second);
}
P operator-(const P &a, const P &b) {
return P(a.first - b.first, a.second - b.second);
}
int n;
double ans;
signed main() {
cin >> n;
rep(i, n) {
double a;
cin >> a;
ans += (1.0 / a);
}
printf("%.10lf\n", 1.0 / ans);
}
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
//#define double long double
#define low lower_bound
#define upp upper_bound
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n) for (int i = (int)(n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
#define rever(vec) reverse(all(vec));
#define cend cout << endl;
#define prique(T) priority_queue<T, vector<T>, greater<T>>
#define prique2(T) priority_queue<T>
struct edge {
int to, cost;
};
using P = pair<int, int>;
using PP = pair<P, int>;
const int mod2 = 998244353;
const int mod = 1e9 + 7, inf = 1e16;
int modpow(int x, int n) {
int ans = 1;
while (n > 0) {
if (n & 1) {
ans *= x;
if (mod <= ans)
ans %= mod;
}
x *= x;
if (mod <= x)
x %= mod;
n >>= 1;
}
return ans;
}
int fact_memo[114514];
int fact(int n) {
int ans = 1;
if (fact_memo[n])
return fact_memo[n];
rep(i, n) {
ans *= (i + 1);
if (mod <= ans)
ans %= mod;
fact_memo[i + 1] = ans;
}
return (ans + mod) % mod;
}
int comb(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod *
modpow(fact(r), mod - 2) +
mod) %
mod;
}
int perm(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod + mod) % mod;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool pri(int p) {
for (int i = 2; i * i <= p; i++)
if (p % i == 0)
return false;
return p > 1;
}
map<int, int> factring(int n) {
map<int, int> ans;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
ans[i]++;
}
}
if (n != 1)
ans[n]++;
return ans;
}
P operator+(const P &a, const P &b) {
return P(a.first + b.first, a.second + b.second);
}
P operator-(const P &a, const P &b) {
return P(a.first - b.first, a.second - b.second);
}
int n;
double ans;
signed main() {
cin >> n;
rep(i, n) {
double a;
cin >> a;
ans += (1.0 / a);
}
printf("%.10lf\n", 1.0 / ans);
}
|
[] | 736,664
| 736,665
|
u054475353
|
cpp
|
p02934
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define double long double
#define low lower_bound
#define upp upper_bound
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n) for (int i = (int)(n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
#define rever(vec) reverse(all(vec));
#define cend cout << endl;
#define prique(T) priority_queue<T, vector<T>, greater<T>>
#define prique2(T) priority_queue<T>
struct edge {
int to, cost;
};
using P = pair<int, int>;
using PP = pair<P, int>;
const int mod2 = 998244353;
const int mod = 1e9 + 7, inf = 1e16;
int modpow(int x, int n) {
int ans = 1;
while (n > 0) {
if (n & 1) {
ans *= x;
if (mod <= ans)
ans %= mod;
}
x *= x;
if (mod <= x)
x %= mod;
n >>= 1;
}
return ans;
}
int fact_memo[114514];
int fact(int n) {
int ans = 1;
if (fact_memo[n])
return fact_memo[n];
rep(i, n) {
ans *= (i + 1);
if (mod <= ans)
ans %= mod;
fact_memo[i + 1] = ans;
}
return (ans + mod) % mod;
}
int comb(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod *
modpow(fact(r), mod - 2) +
mod) %
mod;
}
int perm(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod + mod) % mod;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool pri(int p) {
for (int i = 2; i * i <= p; i++)
if (p % i == 0)
return false;
return p > 1;
}
map<int, int> factring(int n) {
map<int, int> ans;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
ans[i]++;
}
}
if (n != 1)
ans[n]++;
return ans;
}
P operator+(const P &a, const P &b) {
return P(a.first + b.first, a.second + b.second);
}
P operator-(const P &a, const P &b) {
return P(a.first - b.first, a.second - b.second);
}
int n;
double ans;
signed main() {
cin >> n;
rep(i, n) {
double a;
cin >> a;
ans += (1.0 / a);
}
printf("%.10lf\n", 1.0 / ans);
}
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define double long double
#define low lower_bound
#define upp upper_bound
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n) for (int i = (int)(n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
#define rever(vec) reverse(all(vec));
#define cend cout << endl;
#define prique(T) priority_queue<T, vector<T>, greater<T>>
#define prique2(T) priority_queue<T>
struct edge {
int to, cost;
};
using P = pair<int, int>;
using PP = pair<P, int>;
const int mod2 = 998244353;
const int mod = 1e9 + 7, inf = 1e16;
int modpow(int x, int n) {
int ans = 1;
while (n > 0) {
if (n & 1) {
ans *= x;
if (mod <= ans)
ans %= mod;
}
x *= x;
if (mod <= x)
x %= mod;
n >>= 1;
}
return ans;
}
int fact_memo[114514];
int fact(int n) {
int ans = 1;
if (fact_memo[n])
return fact_memo[n];
rep(i, n) {
ans *= (i + 1);
if (mod <= ans)
ans %= mod;
fact_memo[i + 1] = ans;
}
return (ans + mod) % mod;
}
int comb(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod *
modpow(fact(r), mod - 2) +
mod) %
mod;
}
int perm(int n, int r) {
if (n < r)
return 0;
if (n - r < r)
r = n - r;
return (fact(n) * modpow(fact(n - r), mod - 2) % mod + mod) % mod;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool pri(int p) {
for (int i = 2; i * i <= p; i++)
if (p % i == 0)
return false;
return p > 1;
}
map<int, int> factring(int n) {
map<int, int> ans;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
ans[i]++;
}
}
if (n != 1)
ans[n]++;
return ans;
}
P operator+(const P &a, const P &b) {
return P(a.first + b.first, a.second + b.second);
}
P operator-(const P &a, const P &b) {
return P(a.first - b.first, a.second - b.second);
}
int n;
double ans;
signed main() {
cin >> n;
rep(i, n) {
double a;
cin >> a;
ans += (1.0 / a);
}
printf("%.10Lf\n", 1.0 / ans);
}
|
[
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 736,664
| 736,666
|
u054475353
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a, i;
double b, ans;
cin >> a;
for (i = 0; i < a; i++) {
cin >> b;
ans = ans + 1 / b;
cout << ans;
}
ans = 1 / ans;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a, i;
double b, ans;
cin >> a;
for (i = 0; i < a; i++) {
cin >> b;
ans = ans + 1 / b;
}
ans = 1 / ans;
cout << ans;
return 0;
}
|
[] | 736,667
| 736,668
|
u293317519
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a, i;
double b, ans;
cin >> a;
for (i = 0; i <= a; i++) {
cin >> b;
ans = ans + 1 / b;
}
ans = 1 / ans;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a, i;
double b, ans;
cin >> a;
for (i = 0; i < a; i++) {
cin >> b;
ans = ans + 1 / b;
}
ans = 1 / ans;
cout << ans;
return 0;
}
|
[
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 736,669
| 736,668
|
u293317519
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
float sum = 0, kei;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
for (int i = 0; i < N; i++) {
float a;
a = (1 / vec.at(i));
sum += a;
}
kei = 1 / sum;
cout << kei << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
float sum = 0, kei;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
for (int i = 0; i < N; i++) {
float a;
a = (1.0 / vec.at(i));
sum += a;
}
kei = 1.0 / sum;
cout << kei << endl;
}
|
[
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 736,679
| 736,680
|
u361557064
|
cpp
|
p02934
|
/*
* AtCode Beginner Contest 138 : B.Resistor in Parallel
* Author : anaksoleh
* 18 August 2019
*
*/
#include <bits/stdc++.h>
using namespace std;
int N;
float x = (1 / 10e4);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
float A, B;
cin >> N;
if (N >= 2) {
cin >> A >> B;
float pembilang = A + B, pembagi = A * B;
N -= 2;
while (N--) {
cin >> A;
pembilang = (A * pembilang) + pembagi;
pembagi = A * pembagi;
}
cout << (pembagi / pembilang) + x << '\n';
} else {
cin >> A;
cout << A << '\n';
}
return 0;
}
|
/*
* AtCode Beginner Contest 138 : B.Resistor in Parallel
* Author : anaksoleh
* 18 August 2019
*
*/
#include <bits/stdc++.h>
using namespace std;
int N;
float x = (1 / 10e4);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
double A, B;
cin >> N;
if (N >= 2) {
cin >> A >> B;
double pembilang = A + B, pembagi = A * B;
N -= 2;
while (N--) {
cin >> A;
pembilang = (A * pembilang) + pembagi;
pembagi = A * pembagi;
}
cout << pembagi / pembilang << '\n';
} else {
cin >> A;
cout << A << '\n';
}
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"expression.operation.binary.remove"
] | 736,693
| 736,694
|
u387120391
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[101];
for (int i = 0; i < n; i++)
cin >> a[i];
double p = 0;
for (int i = 0; i < n; i++) {
p += (double)(1 / a[i]);
}
cout << (double)(1 / p) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[101];
for (int i = 0; i < n; i++)
cin >> a[i];
double p = 0;
for (int i = 0; i < n; i++) {
p += (double)1 / a[i];
}
cout << (double)1 / p << endl;
return 0;
}
|
[] | 736,697
| 736,698
|
u179077505
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double sum = 0.0;
while (n--) {
double x;
cin >> x;
sum += 1.0 / x;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double sum = 0.0;
while (n--) {
double x;
cin >> x;
sum += 1.0 / x;
}
cout << 1.0 / sum << endl;
return 0;
}
|
[
"expression.operation.binary.add"
] | 736,699
| 736,700
|
u144695182
|
cpp
|
p02934
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int numArr[n];
int index = 0;
while (n != index) {
int input;
cin >> input;
numArr[index] = input;
index += 1;
}
float sum = 0;
for (int i = 0; i < n; ++i) {
sum += 1 / numArr[i];
}
cout << 1 / sum;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
double numArr[n];
int index = 0;
while (n != index) {
int input;
cin >> input;
numArr[index] = input;
index += 1;
}
double sum = 0;
for (int i = 0; i < n; ++i) {
sum += 1.0 / numArr[i];
}
cout << 1.0 / sum;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change",
"io.output.change"
] | 736,716
| 736,717
|
u780842141
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
float S = 0;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
S += 1 / vec.at(i);
}
cout << 1 / S << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
float S = 0;
vector<float> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
S += 1 / vec.at(i);
}
cout << 1 / S << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,721
| 736,722
|
u890758760
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
float ans = 0;
for (int i = 0; i < n; i++)
ans += 1 / a[i];
cout << 1 / ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
float a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
float ans = 0;
for (int i = 0; i < n; i++)
ans += 1 / a[i];
cout << 1 / ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,733
| 736,734
|
u243126309
|
cpp
|
p02934
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
float ans;
for (int i = 0; i < n; i++)
ans += 1 / a[i];
cout << 1 / ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
float a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
float ans = 0;
for (int i = 0; i < n; i++)
ans += 1 / a[i];
cout << 1 / ans << endl;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.value.change"
] | 736,735
| 736,734
|
u243126309
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
#define rep0(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep1(i, n) for (long long i = 1; i <= (long long)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<ll> v(N);
rep0(i, N) { cin >> v[i]; }
sort(all(v));
reverse(all(v));
for (ll i = N - 1; i >= 1; i--) {
v[i - 1] = (v[i] + v[i - 1]) / 2;
}
cout << v[0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep0(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep1(i, n) for (long long i = 1; i <= (long long)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<double> v(N);
rep0(i, N) { cin >> v[i]; }
sort(all(v));
reverse(all(v));
for (ll i = N - 1; i >= 1; i--) {
v[i - 1] = (double)(v[i] + v[i - 1]) / 2;
}
cout << v[0] << endl;
}
|
[
"type_conversion.add"
] | 736,736
| 736,737
|
u053064675
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(1000) << fixed;
int n;
cin >> n;
int *v = new int[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort_heap(v, v + n);
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
delete[] v;
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(10) << fixed;
int n;
cin >> n;
int *v = new int[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v, v + n);
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
delete[] v;
return 0;
}
|
[
"literal.number.change",
"io.output.change",
"identifier.change",
"call.function.change"
] | 736,740
| 736,741
|
u242082438
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> V(N);
for (int i = 0; i < N; i++)
cin >> V.at(i);
sort(V.begin(), V.end());
int sum = V.at(0) / pow(2, N);
for (int i = 0; i < N; i++)
sum += V.at(i) / pow(2, N - i);
cout << setprecision(8) << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> V(N);
for (int i = 0; i < N; i++)
cin >> V.at(i);
sort(V.begin(), V.end());
double sum = V.at(0) / pow(2, N);
for (int i = 0; i < N; i++)
sum += V.at(i) / pow(2, N - i);
cout << setprecision(8) << sum << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,744
| 736,745
|
u101018317
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
typedef long long ll;
#define _GLIBCXX_DEBUG
typedef vector<int> vec;
typedef vector<ll> lvec;
typedef vector<char> cvec;
typedef pair<ll, ll> LP;
typedef tuple<ll, ll, ll> LT;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(all(v));
int ans = v[0];
for (int i = 1; i < n; i++)
ans = (ans + v[i]) / 2;
cout << fixed << setprecision(10) << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
typedef long long ll;
#define _GLIBCXX_DEBUG
typedef vector<int> vec;
typedef vector<ll> lvec;
typedef vector<char> cvec;
typedef pair<ll, ll> LP;
typedef tuple<ll, ll, ll> LT;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(all(v));
double ans = v[0];
for (int i = 1; i < n; i++)
ans = (ans + v[i]) / 2;
cout << fixed << setprecision(10) << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,746
| 736,747
|
u981759938
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define sort(s) sort(s.begin(), s.end())
#define reverse(s) reverse(s.begin(), s.end())
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
const ll mod = 1e9 + 7;
//最大公約数
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
//最小公倍数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
//素数判定
bool isPrime(ll x) {
ll i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
//桁和
int digsum(ll n) {
int res = 0;
while (n > 0) {
res += n % 10;
n /= 10;
}
return res;
}
//桁数
int dignum(ll n) {
int res = 0;
while (n > 0) {
res++;
n /= 10;
}
return res;
}
//文字列中の特定の文字カウント
ll stringcount(string s, char c) { return count(s.cbegin(), s.cend(), c); }
//階乗
ll ka(ll i) {
ll res = 1;
while (i > 0) {
res = res * i;
i--;
}
return res;
}
// ncr
ll ncr(ll x, ll y) {
ll a = x;
ll b = 1;
if (y > (x / 2)) {
y = x - y;
}
for (ll i = 1; i < y; i++) {
a *= x - i;
b *= i + 1;
}
return a / b;
}
//フィボナッチ数列 -92
ll f(ll x) {
ll dp[x + 1];
dp[1] = 1;
dp[2] = 1;
for (ll i = 3; i <= x; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[x];
}
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(v);
int ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define sort(s) sort(s.begin(), s.end())
#define reverse(s) reverse(s.begin(), s.end())
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
const ll mod = 1e9 + 7;
//最大公約数
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
//最小公倍数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
//素数判定
bool isPrime(ll x) {
ll i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
//桁和
int digsum(ll n) {
int res = 0;
while (n > 0) {
res += n % 10;
n /= 10;
}
return res;
}
//桁数
int dignum(ll n) {
int res = 0;
while (n > 0) {
res++;
n /= 10;
}
return res;
}
//文字列中の特定の文字カウント
ll stringcount(string s, char c) { return count(s.cbegin(), s.cend(), c); }
//階乗
ll ka(ll i) {
ll res = 1;
while (i > 0) {
res = res * i;
i--;
}
return res;
}
// ncr
ll ncr(ll x, ll y) {
ll a = x;
ll b = 1;
if (y > (x / 2)) {
y = x - y;
}
for (ll i = 1; i < y; i++) {
a *= x - i;
b *= i + 1;
}
return a / b;
}
//フィボナッチ数列 -92
ll f(ll x) {
ll dp[x + 1];
dp[1] = 1;
dp[2] = 1;
for (ll i = 3; i <= x; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[x];
}
int main() {
int n;
cin >> n;
vector<double> v(n);
rep(i, n) cin >> v[i];
sort(v);
double ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,759
| 736,760
|
u584787460
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n;
int a[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
double ans = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) {
ans = 1.0 * (a[i] + a[i + 1]) / 2;
a[i + 1] = ans;
}
cout << setprecision(9) << fixed << a[n] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n;
double a[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
double ans = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) {
ans = 1.0 * (a[i] + a[i + 1]) / 2;
a[i + 1] = ans;
}
cout << setprecision(9) << fixed << ans << '\n';
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"io.output.change"
] | 736,769
| 736,770
|
u670128805
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n;
int a[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
double ans = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) {
ans = 1.0 * (a[i] + a[i + 1]) / 2;
a[i + 1] = ans;
}
cout << setprecision(9) << fixed << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n;
double a[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
double ans = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) {
ans = 1.0 * (a[i] + a[i + 1]) / 2;
a[i + 1] = ans;
}
cout << setprecision(9) << fixed << ans << '\n';
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,771
| 736,770
|
u670128805
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define ll long long
#define int long long
#define float double
#define double long double
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define pb push_back
int32_t main() {
IOS int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double res = (v[0] + v[1]) / 2.0;
for (int i = 1; i < n; i++)
res += (res + v[i]) / 2.0;
cout << res;
// printf("%.12lf",res);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define ll long long
#define int long long
#define float double
#define double long double
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define pb push_back
int32_t main() {
IOS int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double res = (v[0] + v[1]) / 2.0;
for (int i = 2; i < n; i++)
res = (res + v[i]) / 2.0;
cout << res;
// printf("%.12lf",res);
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"assignment.value.change"
] | 736,774
| 736,775
|
u499347398
|
cpp
|
p02935
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vs;
int v;
for (int i = 0; i < N; ++i) {
cin >> v;
vs.push_back(v);
}
sort(vs.begin(), vs.end());
for (int i = 0; i < N - 1; ++i) {
vs[i + 1] = (double)vs[i] + (double)(vs[i + 1] - vs[i]) / (double)2;
}
cout << vs[N - 1] << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> vs;
double v;
for (int i = 0; i < N; ++i) {
cin >> v;
vs.push_back(v);
}
sort(vs.begin(), vs.end());
for (int i = 0; i < N - 1; ++i) {
vs[i + 1] = (double)vs[i] + (double)(vs[i + 1] - vs[i]) / (double)2;
}
cout << vs[N - 1] << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,780
| 736,781
|
u319569229
|
cpp
|
p02935
|
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n;
cin >> n;
priority_queue<double, vector<double>, greater<double>> q;
for (int i = 0; i < n; i++) {
double n;
cin >> n;
q.push(n);
}
while (q.size() > 1) {
int fst = q.top();
q.pop();
int snd = q.top();
q.pop();
q.push((fst + snd) / 2);
}
cout << q.top() << "\n";
return 0;
}
|
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n;
cin >> n;
priority_queue<double, vector<double>, greater<double>> q;
for (int i = 0; i < n; i++) {
double n;
cin >> n;
q.push(n);
}
while (q.size() > 1) {
double fst = q.top();
q.pop();
double snd = q.top();
q.pop();
q.push((fst + snd) / 2);
}
cout << q.top() << "\n";
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,782
| 736,783
|
u289545075
|
cpp
|
p02935
|
#include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
const double EPS = 1e-9;
#define INF (1LL << 60)
#define D double
#define fs first
#define sc second
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define RFOR(i, a, b) for (int i = (int)(b - 1); i >= (int)(a); --i)
#define REP(i, n) FOR(i, 0, (n))
#define RREP(i, n) RFOR(i, 0, (n))
#define ITR(itr, mp) for (auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr, mp) for (auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i, a, b) ((a) <= (i) && (i) < (b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define SP << " " <<
typedef pair<int, int> P;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
signed main() {
ios::sync_with_stdio(false);
cout.tie(0);
cout.precision(20);
int n;
cin >> n;
vector<int> vs(n);
REP(i, n) cin >> vs[i];
sort(vs.begin(), vs.end(), greater<int>());
stack<D> s;
REP(i, n) s.push(vs[i]);
while (s.size() != 1) {
int a = s.top();
s.pop();
int b = s.top();
s.pop();
s.push((a + b) / 2.0);
}
cout << s.top() << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
const double EPS = 1e-9;
#define INF (1LL << 60)
#define D double
#define fs first
#define sc second
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define RFOR(i, a, b) for (int i = (int)(b - 1); i >= (int)(a); --i)
#define REP(i, n) FOR(i, 0, (n))
#define RREP(i, n) RFOR(i, 0, (n))
#define ITR(itr, mp) for (auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr, mp) for (auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i, a, b) ((a) <= (i) && (i) < (b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define SP << " " <<
typedef pair<int, int> P;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
signed main() {
ios::sync_with_stdio(false);
cout.tie(0);
cout.precision(20);
int n;
cin >> n;
vector<int> vs(n);
REP(i, n) cin >> vs[i];
sort(vs.begin(), vs.end(), greater<int>());
stack<D> s;
REP(i, n) s.push(vs[i]);
while (s.size() != 1) {
double a = s.top();
s.pop();
double b = s.top();
s.pop();
s.push((a + b) / 2.0);
}
cout << s.top() << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,786
| 736,787
|
u237054088
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> p(N);
for (int i = 0; i < N; i++) {
cin >> p.at(i);
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
int64_t a = 2;
double Z = 0;
for (int i = 1; i < N; i++) {
Z += p.at(i) / a;
a *= 2;
if (i == N - 2) {
a /= 2;
}
}
cout << fixed << setprecision(10);
cout << Z << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> p(N);
for (int i = 0; i < N; i++) {
cin >> p.at(i);
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
int64_t a = 2;
double Z = 0;
for (int i = 0; i < N; i++) {
Z += p.at(i) / a;
a *= 2;
if (i == N - 2) {
a /= 2;
}
}
cout << fixed << setprecision(10);
cout << Z << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 736,800
| 736,801
|
u158290747
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n, 0);
rep(i, n) { cin >> v[i]; }
sort(v.begin(), v.end());
rep(i, n - 1) { v[i + 1] = (v[i] + v[i + 1]) / 2; }
cout << v[n - 1] << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<float> v(n, 0);
rep(i, n) { cin >> v[i]; }
sort(v.begin(), v.end());
rep(i, n - 1) { v[i + 1] = (v[i] + v[i + 1]) / 2; }
cout << v[n - 1] << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,804
| 736,805
|
u443151804
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
double x = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++)
x = (x + v[i]) / 2;
cout << fixed << setprecision(10) << x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
double x = v[0] + v[1];
x /= 2;
for (int i = 2; i < n; i++)
x = (x + v[i]) / 2;
cout << fixed << setprecision(10) << x << endl;
}
|
[] | 736,814
| 736,815
|
u261947526
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
double x = v[0] + v[1] / 2;
for (int i = 2; i < n; i++)
x = (x + v[i]) / 2;
cout << fixed << setprecision(10) << x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
double x = v[0] + v[1];
x /= 2;
for (int i = 2; i < n; i++)
x = (x + v[i]) / 2;
cout << fixed << setprecision(10) << x << endl;
}
|
[
"expression.operation.binary.change",
"assignment.change"
] | 736,816
| 736,815
|
u261947526
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
double x = (v[0] + v[1]) / 2;
for (int i = 2; i < n; ++i) {
x = double(x + v[i]) / 2;
}
cout << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
double x = double(v[0] + v[1]) / 2;
for (int i = 2; i < n; ++i) {
x = double(x + v[i]) / 2;
}
cout << x << endl;
return 0;
}
|
[
"call.add"
] | 736,821
| 736,822
|
u754114382
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<int> v(n);
for (int i = 0; i < n; i++) {
std::cin >> v[i];
}
float accum = 0;
bool flag = true;
std::sort(v.begin(), v.end());
while (flag) {
int first = v.front();
int second = v.at(1);
accum = (first + second) / 2.0f;
v.erase(v.begin());
v.erase(v.begin());
v.push_back(int(accum));
std::sort(v.begin(), v.end());
if (v.size() <= 1) {
flag = false;
}
}
std::cout << accum << std::endl;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<float> v(n);
for (int i = 0; i < n; i++) {
std::cin >> v[i];
}
float accum = 0;
bool flag = true;
std::sort(v.begin(), v.end());
while (flag) {
float first = v.front();
float second = v.at(1);
accum = (first + second) / 2.0f;
v.erase(v.begin());
v.erase(v.begin());
v.push_back(accum);
std::sort(v.begin(), v.end());
if (v.size() <= 1) {
flag = false;
}
}
std::cout << accum << std::endl;
}
|
[
"variable_declaration.type.primitive.change",
"call.remove",
"call.arguments.change"
] | 736,825
| 736,824
|
u083254278
|
cpp
|
p02935
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define int long long
#define rng(i, l, r) for (size_t i = (l); i < (r); ++i)
#define rep(i, n) rng(i, 0, n)
#define gnr(i, l, r) for (size_t i = (r)-1; i >= (l); i--)
#define per(i, b) gnr(i, 0, b)
#define ALL(obj) (obj).begin(), (obj).end() // 1,2,3,...
#define rALL(obj) (obj).rbegin(), (obj).rend() //...,3,2,1
using namespace std;
// using ll = long long;
const int MOD = 1000000007;
const int INF = 1e18;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const double pi = acos(-1);
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<int>>;
void solve() {
// remove the bottom 3 lines when you submit this code.
std::ifstream in("sample.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(ALL(v));
double ans = 0;
for (int i = 0; i < n - 1; i++) {
if (i == 0) {
ans = (v[i] + v[i + 1]) / 2;
} else {
ans = (ans + v[i + 1]) / 2;
}
}
cout << setprecision(10) << ans << endl;
}
signed main() {
solve();
return 0;
}
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define int long long
#define rng(i, l, r) for (size_t i = (l); i < (r); ++i)
#define rep(i, n) rng(i, 0, n)
#define gnr(i, l, r) for (size_t i = (r)-1; i >= (l); i--)
#define per(i, b) gnr(i, 0, b)
#define ALL(obj) (obj).begin(), (obj).end() // 1,2,3,...
#define rALL(obj) (obj).rbegin(), (obj).rend() //...,3,2,1
using namespace std;
// using ll = long long;
const int MOD = 1000000007;
const int INF = 1e18;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const double pi = acos(-1);
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<int>>;
void solve() {
// remove the bottom 3 lines when you submit this code.
std::ifstream in("sample.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<double> v(n);
rep(i, n) cin >> v[i];
sort(ALL(v));
double ans = 0;
for (int i = 0; i < n - 1; i++) {
if (i == 0) {
ans = (v[i] + v[i + 1]) / 2;
} else {
ans = (ans + v[i + 1]) / 2;
}
}
cout << setprecision(10) << ans << endl;
}
signed main() {
solve();
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,831
| 736,832
|
u914047482
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define EB emplace_back
#define int long long
#define F first
#define S second
#define N 100005
#define ALL(x) x.begin(), x.end()
#define endl '\n'
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
using namespace std;
int32_t main() {
IOS;
int tt = 1;
cin >> tt;
while (tt--) {
int n;
cin >> n;
cout << fixed;
cout << setprecision(13);
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
double ans = 0.0;
int cnt = 1;
ans += arr[0];
for (int i = 1; i < n; i++) {
ans += cnt * arr[i];
cnt *= 2;
}
cout << ans / cnt;
}
return 0;
}
|
#include <bits/stdc++.h>
#define EB emplace_back
#define int long long
#define F first
#define S second
#define N 100005
#define ALL(x) x.begin(), x.end()
#define endl '\n'
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
using namespace std;
int32_t main() {
IOS;
int tt = 1;
// cin>>tt;
while (tt--) {
int n;
cin >> n;
cout << fixed;
cout << setprecision(13);
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n); //,greater<int>());
double ans = 0.0;
int cnt = 1;
ans += arr[0];
for (int i = 1; i < n; i++) {
ans += cnt * arr[i];
cnt *= 2;
}
cout << ans / cnt;
}
return 0;
}
|
[] | 736,841
| 736,842
|
u915287802
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<double> x(n);
for (int i = 0; i < n; i++)
cin >> x[i];
sort(x.begin(), x.end());
for (int i = 1; i < n; i++) {
for (int j = 0; j < i + 1; j++)
cout << x[j] << endl;
}
double sum = 0;
for (int i = 0; i < n; i++)
sum += x[i];
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<double> x(n);
for (int i = 0; i < n; i++)
cin >> x[i];
sort(x.begin(), x.end());
for (int i = 1; i < n; i++) {
for (int j = 0; j < i + 1; j++)
x[j] /= 2;
}
double sum = 0;
for (int i = 0; i < n; i++)
sum += x[i];
cout << sum << endl;
return 0;
}
|
[
"expression.operation.binary.remove"
] | 736,843
| 736,844
|
u028906014
|
cpp
|
p02935
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (auto &t : a) {
cin >> t;
}
sort(a.begin(), a.end());
double cur = (a[0] + a[1]) / 2;
for (int i = 2; i < n; i++) {
cur = (cur + a[i]) / 2;
}
cout << fixed << setprecision(15);
cout << cur << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (auto &t : a) {
cin >> t;
}
sort(a.begin(), a.end());
double cur = ((double)a[0] + a[1]) / 2;
for (int i = 2; i < n; i++) {
cur = (cur + a[i]) / 2;
}
cout << fixed << setprecision(15);
cout << cur << endl;
}
|
[
"type_conversion.add"
] | 736,845
| 736,846
|
u293523151
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, max;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
max = v[0];
for (int i = 1; i < n; ++i)
max = (max + v[i]) / 2;
cout << max << '\n';
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
double max;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
max = v[0];
for (int i = 1; i < n; ++i)
max = (max + v[i]) / 2;
cout << max << '\n';
}
|
[
"variable_declaration.type.change"
] | 736,861
| 736,862
|
u722351299
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<double> v(n);
rep(i, n) cin >> v.at(i);
sort(v.begin(), v.end());
int ans = v.at(0);
rep(i, n - 1) ans = (ans + v.at(i + 1)) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<double> v(n);
rep(i, n) cin >> v.at(i);
sort(v.begin(), v.end());
double ans = v.at(0);
rep(i, n - 1) ans = (ans + v.at(i + 1)) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,870
| 736,871
|
u297398560
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
vector<double> v(n);
rep(i, n) cin >> v.at(i);
sort(v.begin(), v.end());
int ans = v.at(0);
rep(i, n - 1) ans = (ans + v.at(i + 1)) / 2;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<double> v(n);
rep(i, n) cin >> v.at(i);
sort(v.begin(), v.end());
double ans = v.at(0);
rep(i, n - 1) ans = (ans + v.at(i + 1)) / 2;
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,872
| 736,871
|
u297398560
|
cpp
|
p02935
|
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
void solve() {
int n;
cin >> n;
vector<double> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
while (v.size() > 1) {
sort(v.begin(), v.end());
int a = v[0], b = v[1];
v.erase(v.begin(), v.begin() + 2);
v.push_back((a + b) / 2.0);
}
cout << fixed << setprecision(6) << v[0] << endl;
return;
}
int main() {
solve();
return 0;
}
|
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
void solve() {
int n;
cin >> n;
vector<double> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
while (v.size() > 1) {
sort(v.begin(), v.end());
double a = v[0], b = v[1];
v.erase(v.begin(), v.begin() + 2);
v.push_back((a + b) / 2.0);
}
cout << fixed << setprecision(6) << v[0] << endl;
return;
}
int main() {
solve();
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,876
| 736,877
|
u489302942
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++)
for (int j = 1; j < n; j++) {
if (a[i] > a[j]) {
float t;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
int k = 0;
int l = 1;
while (k < n - 1) {
a[l] = (a[k] + a[l]) / 2.0;
k++;
l++;
}
cout << a[n - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
float a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++)
for (int j = i; j < n; j++) {
if (a[i] > a[j]) {
float t;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
int k = 0;
int l = 1;
while (k < n - 1) {
a[l] = (a[k] + a[l]) / 2.0;
k++;
l++;
}
cout << a[n - 1];
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 736,882
| 736,883
|
u294547216
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++)
for (int j = 1; j < n; j++) {
if (a[i] > a[j]) {
float t;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
int k = 0;
int l = 1;
while (k < n - 1) {
a[l] = (a[k] + a[l]) / 2.0;
k++;
l++;
}
cout << a[n - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++)
for (int j = i; j < n; j++) {
if (a[i] > a[j]) {
double t;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
int k = 0;
int l = 1;
while (k < n - 1) {
a[l] = (a[k] + a[l]) / 2.0;
k++;
l++;
}
cout << a[n - 1];
}
|
[
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change"
] | 736,882
| 736,884
|
u294547216
|
cpp
|
p02935
|
#pragma once
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
#define all(x) (x).begin(), (x).end() // sortなどの引数を省略
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#ifdef _MSC_FULL_VER //デバッグ出力
#define dout cout
#define debug() if (true)
#define check(x) std::cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) std::cout << "☆" << x << endl
#else
#define dout \
if (false) \
cout
#define debug() if (false)
#define check(x) \
if (false) \
cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) \
if (false) \
cout << "☆" << x << endl
#endif
using namespace std;
int main() {
int N;
cin >> N;
vector<double> list(N + 1, 9999);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
sort(all(list));
dout << "====listの内容====\n";
for (int i = 0; i < N; i++)
dout << list[i] << endl;
dout << "====ここまで====\n";
rep(i, N - 1) {
cout << i << "/" << list[i] << "/" << list[i + 1] << endl;
list[i + 1] = (list[i] + list[i + 1]) / 2;
}
cout << list[N - 1];
return 0;
}
/*
//よく使うやつ
int N;
cin >> N;
vector<int> list(N);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
// for文
for (int i = 0; i < N; i++) {
}
//配列
vector<int> vec;
vec.at(i)
vector<vector<int>> vec(10, vector<int>(10));
sort(all(vec));
sort(all(vec), greater<int>());
//配列の内容表示
dout << "====vecの内容====\n";
for (int i = 0; i < N; i++) dout << vec[i] << endl;
dout << "====ここまで====\n";
*/
|
#pragma once
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
#define all(x) (x).begin(), (x).end() // sortなどの引数を省略
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#ifdef _MSC_FULL_VER //デバッグ出力
#define dout cout
#define debug() if (true)
#define check(x) std::cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) std::cout << "☆" << x << endl
#else
#define dout \
if (false) \
cout
#define debug() if (false)
#define check(x) \
if (false) \
cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) \
if (false) \
cout << "☆" << x << endl
#endif
using namespace std;
int main() {
int N;
cin >> N;
vector<double> list(N + 1, 9999);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
sort(all(list));
dout << "====listの内容====\n";
for (int i = 0; i < N; i++)
dout << list[i] << endl;
dout << "====ここまで====\n";
rep(i, N - 1) {
dout << i << "/" << list[i] << "/" << list[i + 1] << endl;
list[i + 1] = (list[i] + list[i + 1]) / 2;
}
cout << list[N - 1];
return 0;
}
/*
//よく使うやつ
int N;
cin >> N;
vector<int> list(N);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
// for文
for (int i = 0; i < N; i++) {
}
//配列
vector<int> vec;
vec.at(i)
vector<vector<int>> vec(10, vector<int>(10));
sort(all(vec));
sort(all(vec), greater<int>());
//配列の内容表示
dout << "====vecの内容====\n";
for (int i = 0; i < N; i++) dout << vec[i] << endl;
dout << "====ここまで====\n";
*/
|
[
"identifier.change",
"expression.operation.binary.change"
] | 736,885
| 736,886
|
u043964516
|
cpp
|
p02935
|
#pragma once
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
#define all(x) (x).begin(), (x).end() // sortなどの引数を省略
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#ifdef _MSC_FULL_VER //デバッグ出力
#define dout cout
#define debug() if (true)
#define check(x) std::cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) std::cout << "☆" << x << endl
#else
#define dout \
if (false) \
cout
#define debug() if (false)
#define check(x) \
if (false) \
cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) \
if (false) \
cout << "☆" << x << endl
#endif
using namespace std;
int main() {
int N;
cin >> N;
vector<int> list(N + 1, 9999);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
sort(all(list));
dout << "====listの内容====\n";
for (int i = 0; i < N; i++)
dout << list[i] << endl;
dout << "====ここまで====\n";
rep(i, N - 1) {
cout << i << "/" << list[i] << "/" << list[i + 1] << endl;
list[i + 1] = (list[i] + list[i + 1]) / 2;
}
cout << list[N - 1];
return 0;
}
/*
//よく使うやつ
int N;
cin >> N;
vector<int> list(N);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
// for文
for (int i = 0; i < N; i++) {
}
//配列
vector<int> vec;
vec.at(i)
vector<vector<int>> vec(10, vector<int>(10));
sort(all(vec));
sort(all(vec), greater<int>());
//配列の内容表示
dout << "====vecの内容====\n";
for (int i = 0; i < N; i++) dout << vec[i] << endl;
dout << "====ここまで====\n";
*/
|
#pragma once
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
#define all(x) (x).begin(), (x).end() // sortなどの引数を省略
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#ifdef _MSC_FULL_VER //デバッグ出力
#define dout cout
#define debug() if (true)
#define check(x) std::cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) std::cout << "☆" << x << endl
#else
#define dout \
if (false) \
cout
#define debug() if (false)
#define check(x) \
if (false) \
cout << "★" << #x << "の値:" << (x) << endl
#define pass(x) \
if (false) \
cout << "☆" << x << endl
#endif
using namespace std;
int main() {
int N;
cin >> N;
vector<double> list(N + 1, 9999);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
sort(all(list));
dout << "====listの内容====\n";
for (int i = 0; i < N; i++)
dout << list[i] << endl;
dout << "====ここまで====\n";
rep(i, N - 1) {
dout << i << "/" << list[i] << "/" << list[i + 1] << endl;
list[i + 1] = (list[i] + list[i + 1]) / 2;
}
cout << list[N - 1];
return 0;
}
/*
//よく使うやつ
int N;
cin >> N;
vector<int> list(N);
for (int i = 0; i < N; i++) {
cin >> list[i];
}
// for文
for (int i = 0; i < N; i++) {
}
//配列
vector<int> vec;
vec.at(i)
vector<vector<int>> vec(10, vector<int>(10));
sort(all(vec));
sort(all(vec), greater<int>());
//配列の内容表示
dout << "====vecの内容====\n";
for (int i = 0; i < N; i++) dout << vec[i] << endl;
dout << "====ここまで====\n";
*/
|
[
"variable_declaration.type.primitive.change",
"identifier.change",
"expression.operation.binary.change"
] | 736,887
| 736,886
|
u043964516
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
const double pi = acos(-1.0);
const ll mod = pow(10, 9) + 7;
const ll INF = pow(2, 31) - 1;
using str = string;
typedef pair<int, int> P;
typedef vector<int> vi;
ll gcd(ll a, ll b) {
ll v0 = a, v1 = b, v2 = a % b;
while (v2 != 0) {
v0 = v1;
v1 = v2;
v2 = v0 % v1;
}
return v1;
}
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) { cin >> v[i]; }
sort(v.begin(), v.end());
float ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (v[i] + ans) / 2;
}
printf("%.10f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
const double pi = acos(-1.0);
const ll mod = pow(10, 9) + 7;
const ll INF = pow(2, 31) - 1;
using str = string;
typedef pair<int, int> P;
typedef vector<int> vi;
ll gcd(ll a, ll b) {
ll v0 = a, v1 = b, v2 = a % b;
while (v2 != 0) {
v0 = v1;
v1 = v2;
v2 = v0 % v1;
}
return v1;
}
ll lcm(ll a, ll b) { return (a * b / gcd(a, b)); }
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) { cin >> v[i]; }
sort(v.begin(), v.end());
float ans = (v[0] + v[1]) / 2.0;
for (int i = 2; i < n; i++) {
ans = (v[i] + ans) / 2.0;
}
printf("%.10f\n", ans);
return 0;
}
|
[
"literal.number.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 736,888
| 736,889
|
u420130252
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
sort(v.begin(), v.end());
double ans = 0;
ans = v.at(0) * pow(2, n - 1);
for (int i = 1; i < n; i++) {
ans += v[i] / pow(2, n - i);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
sort(v.begin(), v.end());
double ans = 0;
ans = v.at(0) / pow(2, n - 1);
for (int i = 1; i < n; i++) {
ans += v[i] / pow(2, n - i);
}
cout << ans << endl;
}
|
[
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 736,890
| 736,891
|
u553183019
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
sort(v.begin(), v.end());
double ans = 0;
ans = v.at(0) * pow(2, n - 1);
for (int i = 1; i < n; i++) {
ans += v[i] / pow(2, n - i);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
sort(v.begin(), v.end());
double ans = 0;
ans = v.at(0) / pow(2, n - 1);
for (int i = 1; i < n; i++) {
ans += v[i] / pow(2, n - i);
}
cout << ans << endl;
}
|
[
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 736,892
| 736,891
|
u553183019
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int ans = 0;
ans += v[0] / pow(2, n - 1);
for (int i = 1; i < n; i++) {
ans += v[i] / pow(2, n - i);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = 0;
ans += v[0] / pow(2, n - 1);
for (int i = 1; i < n; i++) {
ans += v[i] / pow(2, n - i);
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,896
| 736,897
|
u265359795
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
sort(v.begin(), v.end());
double ans = 0;
for (int i = 0; i < N - 1; i++) {
v[i + 1] = (v[i] + v[i + 1]) / 2.0;
}
cout << v[N - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
sort(v.begin(), v.end());
double ans = 0;
for (int i = 0; i < N - 1; i++) {
v[i + 1] = (v[i] + v[i + 1]) / 2.0;
}
cout << v[N - 1];
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,906
| 736,907
|
u109191542
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
int ans = a[0];
for (int i = 1; i < n; i++) {
ans = (ans + a[i]) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
float a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
float ans = a[0];
for (int i = 1; i < n; i++) {
ans = (ans + a[i]) * 1.0 / 2;
}
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"assignment.change"
] | 736,916
| 736,917
|
u127438619
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
int ans = a[0];
for (int i = 1; i < n; i++) {
ans = (ans + a[i]) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
float a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
float ans = a[0];
for (int i = 1; i < n; i++) {
ans = (ans + a[i]) * 1.0 / 2;
}
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"assignment.change"
] | 736,916
| 736,918
|
u127438619
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define debug(x) cerr << #x << " " << x << '\n'
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
const ll LINF = 1e18 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
priority_queue<double, vector<double>, greater<double>> q;
for (int i = 1; i <= n; i++) {
double v;
cin >> v;
q.push(v);
}
while (sz(q) >= 2) {
auto u = q.top();
q.pop();
auto v = q.top();
q.pop();
q.push((u + v) / 2);
}
auto ans = q.top();
cout << fixed << setprecision(12) << ans;
return 0;
}
|
#include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define debug(x) cerr << #x << " " << x << '\n'
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
const ll LINF = 1e18 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
priority_queue<double, vector<double>, greater<double>> q;
for (int i = 1; i <= n; i++) {
double v;
cin >> v;
q.push(v);
}
while (sz(q) >= 2) {
auto u = q.top();
q.pop();
auto v = q.top();
q.pop();
q.push((u + v) / 2);
}
auto ans = q.top();
cout << fixed << setprecision(12) << ans;
return 0;
}
|
[] | 736,928
| 736,929
|
u047655753
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, res;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
sort(v.begin(), v.end());
res = v.at(0);
for (int i = 1; i < n; i++) {
res = (res + v.at(i)) / 2;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
double res;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
sort(v.begin(), v.end());
res = v.at(0);
for (int i = 1; i < n; i++) {
res = (res + v.at(i)) / 2.;
}
cout << res << endl;
}
|
[
"variable_declaration.type.change"
] | 736,940
| 736,941
|
u353748264
|
cpp
|
p02935
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
int main() {
ll n, k, m;
ll ans = 0;
string s;
vector<ll> v;
cin >> n;
splitIn(n, v);
sort(all(v));
ans = v[0];
for (auto &a : v) {
ans = (ans + a) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, ll> prll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array) {
T temp;
int i = 0;
if (N == 0) {
return;
}
array.resize(N);
while (cin >> temp) {
array[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
int main() {
ll n, k, m;
double ans = 0;
string s;
vector<double> v;
cin >> n;
splitIn(n, v);
sort(all(v));
ans = v[0];
for (auto &a : v) {
ans = (ans + a) / 2;
}
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.change"
] | 736,950
| 736,951
|
u143100985
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v, v + n);
double ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v, v + n);
double ans = (v[0] + v[1]) / 2.0;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2.0;
}
cout << ans << endl;
}
|
[
"literal.number.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 736,955
| 736,956
|
u787005274
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v, v + n);
int ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v, v + n);
double ans = (v[0] + v[1]) / 2.0;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2.0;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change",
"literal.number.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 736,957
| 736,956
|
u787005274
|
cpp
|
p02935
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
template <typename T> using V = std::vector<T>;
using Vi = V<int>;
using VVi = V<V<int>>;
using Vll = V<ll>;
using VVll = V<V<ll>>;
using Vs = V<string>;
template <typename T1, typename T2> using P = std::pair<T1, T2>;
using Pii = P<int, int>;
using Pdd = P<double, double>;
template <typename T1, typename T2> using M = std::map<T1, T2>;
using Msi = M<string, int>;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP2(i, s, e) for (int i = (int)(s); i < (int)(e); ++i)
#define RREP(i, s, e) for (int i = (int)(s); i >= (int)(e); --i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(), ie = (c).end(); i != ie; ++i)
#define ALL(c) (c).begin(), (c).end()
int main() {
int n;
cin >> n;
Vi v(n);
REP(i, n) { cin >> v[i]; }
sort(ALL(v), greater<int>());
double cnt = 0;
REP(i, n) {
if (i != n - 1) {
cnt += v[i] * pow(0.5, i + 1);
} else {
cnt += v[i] * pow(0.5, i);
}
}
printf("%.6fl\n", cnt);
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
template <typename T> using V = std::vector<T>;
using Vi = V<int>;
using VVi = V<V<int>>;
using Vll = V<ll>;
using VVll = V<V<ll>>;
using Vs = V<string>;
template <typename T1, typename T2> using P = std::pair<T1, T2>;
using Pii = P<int, int>;
using Pdd = P<double, double>;
template <typename T1, typename T2> using M = std::map<T1, T2>;
using Msi = M<string, int>;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP2(i, s, e) for (int i = (int)(s); i < (int)(e); ++i)
#define RREP(i, s, e) for (int i = (int)(s); i >= (int)(e); --i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(), ie = (c).end(); i != ie; ++i)
#define ALL(c) (c).begin(), (c).end()
int main() {
int n;
cin >> n;
Vi v(n);
REP(i, n) { cin >> v[i]; }
sort(ALL(v), greater<int>());
double cnt = 0;
REP(i, n) {
if (i != n - 1) {
cnt += v[i] * pow(0.5, i + 1);
} else {
cnt += v[i] * pow(0.5, i);
}
}
printf("%.6f\n", cnt);
return 0;
}
|
[
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 736,958
| 736,959
|
u868099754
|
cpp
|
p02935
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
template <typename T> using V = std::vector<T>;
using Vi = V<int>;
using VVi = V<V<int>>;
using Vll = V<ll>;
using VVll = V<V<ll>>;
using Vs = V<string>;
template <typename T1, typename T2> using P = std::pair<T1, T2>;
using Pii = P<int, int>;
using Pdd = P<double, double>;
template <typename T1, typename T2> using M = std::map<T1, T2>;
using Msi = M<string, int>;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP2(i, s, e) for (int i = (int)(s); i < (int)(e); ++i)
#define RREP(i, s, e) for (int i = (int)(s); i >= (int)(e); --i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(), ie = (c).end(); i != ie; ++i)
#define ALL(c) (c).begin(), (c).end()
int main() {
int n;
cin >> n;
Vi v(n);
REP(i, n) { cin >> v[i]; }
sort(ALL(v), greater<int>());
double cnt = 0;
REP(i, n) {
if (i != n - 1) {
cnt += v[i] * pow(0.5, i + 1);
} else {
cnt += v[i] * pow(0.5, i);
}
}
printf("%.5fl\n", cnt);
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
template <typename T> using V = std::vector<T>;
using Vi = V<int>;
using VVi = V<V<int>>;
using Vll = V<ll>;
using VVll = V<V<ll>>;
using Vs = V<string>;
template <typename T1, typename T2> using P = std::pair<T1, T2>;
using Pii = P<int, int>;
using Pdd = P<double, double>;
template <typename T1, typename T2> using M = std::map<T1, T2>;
using Msi = M<string, int>;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP2(i, s, e) for (int i = (int)(s); i < (int)(e); ++i)
#define RREP(i, s, e) for (int i = (int)(s); i >= (int)(e); --i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(), ie = (c).end(); i != ie; ++i)
#define ALL(c) (c).begin(), (c).end()
int main() {
int n;
cin >> n;
Vi v(n);
REP(i, n) { cin >> v[i]; }
sort(ALL(v), greater<int>());
double cnt = 0;
REP(i, n) {
if (i != n - 1) {
cnt += v[i] * pow(0.5, i + 1);
} else {
cnt += v[i] * pow(0.5, i);
}
}
printf("%.6f\n", cnt);
return 0;
}
|
[
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 736,960
| 736,959
|
u868099754
|
cpp
|
p02935
|
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ALL(a) begin(a), end(a)
#define mii map<int, int>
#define msi map<string, int>
#define vi vector<int>
#define vl vector<ll>
#define MOD 1000000007
#define INF 1e9
#define showVector(v) \
rep(i, 0, v.size()) { \
p(v[i]); \
p(" ") \
} \
pl("")
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
using namespace std;
// 素数判定 O(√n)
bool is_prime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
string s;
int N;
cin >> N;
// vector<vector<int>> data(3, vector<int>(4));
//初期値0
// vector<int> data(i, 0);
vector<double> a(N);
rep(i, 0, N) { cin >> a[i]; }
sort(a.begin(), a.end());
double res = 0;
res = (a[0] + a[1]) / 2.0;
for (int i = 2; i < N; i += 2) {
res = (res + a[i]) / 2.0;
}
cout << res << endl;
return 0;
}
|
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ALL(a) begin(a), end(a)
#define mii map<int, int>
#define msi map<string, int>
#define vi vector<int>
#define vl vector<ll>
#define MOD 1000000007
#define INF 1e9
#define showVector(v) \
rep(i, 0, v.size()) { \
p(v[i]); \
p(" ") \
} \
pl("")
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
using namespace std;
// 素数判定 O(√n)
bool is_prime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
string s;
int N;
cin >> N;
// vector<vector<int>> data(3, vector<int>(4));
//初期値0
// vector<int> data(i, 0);
vector<double> a(N);
rep(i, 0, N) { cin >> a[i]; }
sort(a.begin(), a.end());
double res = 0;
res = (a[0] + a[1]) / 2.0;
for (int i = 2; i < N; i++) {
res = (res + a[i]) / 2.0;
}
cout << res << endl;
return 0;
}
|
[] | 736,969
| 736,970
|
u452512115
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(all(v));
int ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(all(v));
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = double(ans + v[i]) / 2;
}
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"call.add"
] | 736,971
| 736,972
|
u115838990
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> u(N);
for (int i = 0; i < N; i++)
cin >> u.at(i);
sort(u.begin(), u.end());
int sum = u.at(0);
for (int i = 1; i < N; i++)
sum = (sum + u.at(i)) / 2;
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> u(N);
for (int i = 0; i < N; i++)
cin >> u.at(i);
sort(u.begin(), u.end());
double sum = u.at(0);
for (int i = 1; i < N; i++)
sum = (sum + u.at(i)) / 2;
cout << sum << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,973
| 736,974
|
u620626180
|
cpp
|
p02935
|
#include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cstring>
#include <float.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
using Graph = vector<vector<int>>;
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
int n;
cin >> n;
VEC(double, v, n);
sort(v.begin(), v.end());
double sum = (v[0] + v[1]) / 2;
REP(i, 2, n) { sum = (sum + v[i]) / 2; }
cout << sum;
}
|
#include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cstring>
#include <float.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
using Graph = vector<vector<int>>;
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
int n;
cin >> n;
VEC(double, v, n);
sort(v.begin(), v.end());
double sum = (v[0] + v[1]) / 2;
REP(i, 2, n - 1) { sum = (sum + v[i]) / 2; }
cout << sum;
}
|
[
"expression.operation.binary.add"
] | 736,975
| 736,976
|
u516525290
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<double> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = (v[0] + v[1]) / 2;
// double ans = 0;
if (n == 2) {
cout << ans;
} else {
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<double> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = (v[0] + v[1]) / 2;
// double ans = 0;
if (n == 2) {
cout << ans;
} else {
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans;
}
}
|
[] | 736,977
| 736,978
|
u934529721
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<float> v(n);
for (float &i : v)
cin >> i;
sort(v.begin(), v.end());
n--;
while (n--) {
float k = v[v.size() - 1] + v[v.size() - 2];
k /= 2.0;
v.pop_back();
v.pop_back();
v.push_back(k);
sort(v.begin(), v.end());
}
cout << v.back() << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<float> v(n);
for (float &i : v)
cin >> i;
sort(v.rbegin(), v.rend());
n--;
while (n--) {
float k = v[v.size() - 1] + v[v.size() - 2];
k /= 2.0;
v.pop_back();
v.pop_back();
v.push_back(k);
sort(v.rbegin(), v.rend());
}
cout << v.back() << "\n";
return 0;
}
|
[
"call.function.change",
"call.arguments.change"
] | 736,981
| 736,982
|
u767871438
|
cpp
|
p02935
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (size_t i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ave = 0;
ave = (v[0] + v[1]) / 2;
for (size_t i = 2; i < n; i++) {
ave = (ave + v[i]) / 2;
}
cout << setprecision(15) << ave;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<double> v(n);
for (size_t i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ave = 0;
ave = (v[0] + v[1]) / 2;
for (size_t i = 2; i < n; i++) {
ave = (ave + v[i]) / 2;
}
cout << setprecision(15) << ave;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,983
| 736,984
|
u696988954
|
cpp
|
p02935
|
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, n) for (int i##_len = (n), i = i##_len - 1; i >= 0; --i)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define printd(val) std::cout << #val " = " << val << "\n";
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
using pii = pair<int, int>;
int n;
double v;
priority_queue<double, vector<double>, greater<double>> q;
void input() {
cin >> n;
rep(i, n) {
cin >> v;
q.push(v);
}
}
void src() {
rep(c, n - 1) {
int v1 = q.top();
q.pop();
int v2 = q.top();
q.pop();
q.push((v1 + v2) / 2.0);
}
cout << setprecision(6) << fixed << q.top();
return;
}
int main(int argc, char *argv[]) {
// ifstream in( argv[1] ); cin.rdbuf(in.rdbuf());
input();
src();
return 0;
}
|
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, n) for (int i##_len = (n), i = i##_len - 1; i >= 0; --i)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define printd(val) std::cout << #val " = " << val << "\n";
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
using pii = pair<int, int>;
int n;
int v;
priority_queue<double, vector<double>, greater<double>> q;
void input() {
cin >> n;
rep(i, n) {
cin >> v;
q.push((double)v);
}
}
void src() {
rep(c, n - 1) {
double v1 = q.top();
q.pop();
double v2 = q.top();
q.pop();
q.push((v1 + v2) / 2.0);
}
cout << setprecision(6) << fixed << q.top();
return;
}
int main(int argc, char *argv[]) {
// ifstream in( argv[1] ); cin.rdbuf(in.rdbuf());
input();
src();
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,985
| 736,986
|
u954176652
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> V(N);
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.at(i) = v;
}
sort(V.begin(), V.end());
int ans = V.at(0);
for (int i = 1; i < N; i++) {
ans = (ans + V.at(i)) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> V(N);
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.at(i) = v;
}
sort(V.begin(), V.end());
double ans = V.at(0);
for (int i = 1; i < N; i++) {
ans = (ans + V.at(i)) / 2;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 736,987
| 736,988
|
u536916602
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, tmp;
priority_queue<int, vector<int>, greater<int>> queue;
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> tmp;
queue.push(tmp * 100000);
}
do {
int now = 0;
now += queue.top();
queue.pop();
now += queue.top();
queue.pop();
queue.push(now / 2);
} while (queue.empty() != 1);
printf("%5f\n", (double)queue.top() / 100000);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, tmp;
priority_queue<int, vector<int>, greater<int>> queue;
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> tmp;
queue.push(tmp * 100000);
}
do {
int now = 0;
now += queue.top();
queue.pop();
now += queue.top();
queue.pop();
queue.push(now / 2);
} while (queue.size() != 1);
printf("%5f\n", (double)queue.top() / 100000);
return 0;
}
|
[
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 736,996
| 736,997
|
u280097533
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long int ll;
int main() {
// your code goes here
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, i, j;
ll a, b;
double c;
cin >> n;
priority_queue<double, vector<double>, greater<double>> q;
for (i = 0; i < n; i++) {
cin >> j;
q.push(j);
}
while (q.size() > 1) {
a = q.top();
q.pop();
b = q.top();
q.pop();
c = (a + b) / 2.0;
q.push(c);
}
cout << q.top();
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long int ll;
int main() {
// your code goes here
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, i, j;
double a, b;
double c;
cin >> n;
priority_queue<double, vector<double>, greater<double>> q;
for (i = 0; i < n; i++) {
cin >> j;
q.push(j);
}
while (q.size() > 1) {
a = q.top();
q.pop();
b = q.top();
q.pop();
c = (a + b) / 2.0;
q.push(c);
}
cout << q.top();
return 0;
}
|
[
"variable_declaration.type.change"
] | 737,000
| 737,001
|
u716242664
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
std::vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
v[i] = (v[i - 1] + v[i]) / 2;
}
cout << v[n - 1] << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
std::vector<float> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
v[i] = (v[i - 1] + v[i]) / 2;
}
cout << v[n - 1] << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,004
| 737,005
|
u420421811
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
sort(ar, ar + n);
int ans = (ar[0] + ar[1]) / 2;
for (int i = 2; i < n; i++)
ans = (ans + ar[i]) / 2;
cout << ans << "\n";
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
sort(ar, ar + n);
float ans = (ar[0] + ar[1]) / 2.0;
for (int i = 2; i < n; i++)
ans = (ans + ar[i]) / 2.0;
cout << ans << "\n";
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"literal.number.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 737,006
| 737,007
|
u773406543
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v.at(0);
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n");
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v.at(0);
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n", ans);
return 0;
}
|
[
"call.arguments.add"
] | 737,017
| 737,018
|
u648009244
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v.at(1);
for (int i = 1; i < n; i++) {
ans = (ans + double(v[i])) / 2;
}
printf("%.10f\n");
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v.at(0);
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n", ans);
return 0;
}
|
[
"literal.number.change",
"call.arguments.change",
"call.remove",
"call.arguments.add"
] | 737,019
| 737,018
|
u648009244
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v.at(1);
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n");
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v.at(0);
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n", ans);
return 0;
}
|
[
"literal.number.change",
"call.arguments.change",
"call.arguments.add"
] | 737,020
| 737,018
|
u648009244
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
ll ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n", ans);
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%.10f\n", ans);
}
|
[
"variable_declaration.type.change"
] | 737,027
| 737,028
|
u147556624
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
int main() {
int n;
cin >> n;
vector<int> v(n, 0);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
double result = 0;
for (int i = n - 1; i > 0; i--) {
sort(v.rbegin(), v.rend());
result = v.at(i) + v.at(i - 1);
result /= 2.0;
v.pop_back();
v.pop_back();
v.push_back(result);
}
cout << setprecision(6) << result << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
int main() {
int n;
cin >> n;
vector<double> v(n, 0);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
double result = 0;
for (int i = n - 1; i > 0; i--) {
sort(v.rbegin(), v.rend());
result = v.at(i) + v.at(i - 1);
result /= 2.0;
v.pop_back();
v.pop_back();
v.push_back(result);
}
cout << setprecision(6) << result << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,029
| 737,030
|
u820925909
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int ans = v[0];
for (int i = 1; i < N; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < N; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,037
| 737,038
|
u584139221
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = 0; i < n; i++)
scanf("%d", &v[i]);
sort(v.begin(), v.end());
int ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = 0; i < n; i++)
scanf("%d", &v[i]);
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2.0;
}
printf("%lf\n", ans);
}
|
[
"variable_declaration.type.primitive.change",
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 737,039
| 737,040
|
u224590796
|
cpp
|
p02935
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> _v(N);
auto *const v = &_v[0];
for (int i = 0; i < N; ++i)
cin >> v[i];
sort(v, v + N);
double den = 2.;
double sum = 0.;
for (int i = N - 1; 1 <= i; --i) {
v[i] /= den;
sum += v[i];
den *= 2.;
}
v[0] /= (den / 2.);
sum += v[0];
cout << sum;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> _v(N);
auto *const v = &_v[0];
for (int i = 0; i < N; ++i)
cin >> v[i];
sort(v, v + N);
double den = 2.;
double sum = 0.;
for (int i = N - 1; 1 <= i; --i) {
v[i] /= den;
sum += v[i];
den *= 2.;
}
v[0] /= (den / 2.);
sum += v[0];
cout << sum;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,041
| 737,042
|
u673513296
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
int ans = v[0];
for (int i = 1; i < n; ++i)
ans = (ans + v[i]) / 2;
printf("%.8f", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; ++i)
ans = (ans + v[i]) / 2;
printf("%.8f", ans);
}
|
[
"variable_declaration.type.primitive.change"
] | 737,082
| 737,083
|
u458187055
|
cpp
|
p02935
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
double ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; ++i)
ans = (ans + v[i]) / 2;
cout << ans << endl;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
double ans = (double)(v[0] + v[1]) / 2;
for (int i = 2; i < n; ++i)
ans = (ans + v[i]) / 2;
cout << ans << endl;
}
|
[
"type_conversion.add"
] | 737,093
| 737,094
|
u386131832
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int v[n];
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v, v + n);
double temp = 0;
for (int i = 0; i < n - 1; i++) {
temp = (double)(v[i] + v[i + 1]) / 2;
v[i + 1] = temp;
}
cout << temp;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double v[n];
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v, v + n);
double temp = 0;
for (int i = 0; i < n - 1; i++) {
temp = (v[i] + v[i + 1]) / 2;
v[i + 1] = temp;
}
cout << temp;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,108
| 737,109
|
u523261038
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
[] | 737,112
| 737,113
|
u882039496
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans = v[0];
for (int i = 1; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,116
| 737,113
|
u882039496
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
double ans = 0;
ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<double> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
sort(v.begin(), v.end());
double ans = 0;
ans = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + v[i]) / 2.0;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change",
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 737,129
| 737,130
|
u544165468
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> vec(n);
for (int t = 0; t < n; t++) {
cin >> vec.at(t);
}
sort(vec.begin(), vec.end());
int ans = vec.at(0);
for (int i = 0; i < n - 1; i++) {
ans = ans + vec.at(i + 1);
ans /= 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> vec(n);
for (int t = 0; t < n; t++) {
cin >> vec.at(t);
}
sort(vec.begin(), vec.end());
double ans = vec.at(0);
for (int i = 0; i < n - 1; i++) {
ans += vec.at(i + 1);
ans /= 2;
}
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change",
"assignment.value.change",
"expression.operation.binary.remove"
] | 737,131
| 737,132
|
u371051907
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int ans;
ans = v[0];
for (int i = 1; i < N; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
double ans;
ans = v[0];
for (int i = 1; i < N; i++) {
ans = (ans + v[i]) / 2;
}
cout << ans;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,133
| 737,134
|
u231455327
|
cpp
|
p02935
|
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author Gosu_Hiroo
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define TR(container, it) \
for (auto it = container.begin(); it != container.end(); it++)
#define IN(c, x) ((c).find(x) != (c).end()) // O(log n)
#define IN_L(c, x) (find((c).begin(), (c).end(), x) != (c).end()) // O(n)
#define PLL pair<ll, ll>
#define PII pair<int, int>
#define VI vector<int>
#define VVI vector<vector<int>>
#define FOR(i, _begin, _end) \
for (__typeof(_end) end = _end, begin = _begin, \
i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define REP(i, end) for (__typeof(end) i = 0, _len = (end); i < (_len); i += 1)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define MOD(x, m) ((((x) % (m)) + (m)) % (m))
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define READ \
({ \
int t; \
cin >> t; \
t; \
})
#define EB emplace_back
#define fcout cout << fixed << setprecision(12)
#define fcerr cerr << fixed << setprecision(12)
#define print(x) cout << (x) << endl
#ifdef DEBUG
#define ERR(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
_err(cerr, _it, args); \
}
#define DBG(x) cerr << #x << " is " << x << endl;
#else
#define DBG(x) {};
#define ERR(args...) {};
#endif
void _err(std::ostream &cerr, istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void _err(std::ostream &cerr, istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
_err(cerr, ++it, args...);
}
const double pi = 2 * acos(.0);
const int inf = 0x3f3f3f3f;
const ll mod = (ll)(1e9) + 7;
// const ll mod = (ll) 998244353 ;
const double eps = 1e-10;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> V) {
for (auto v : V)
os << v << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> V) {
for (auto v : V)
os << v << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> V) {
for (auto v : V)
os << v << " ";
return os;
}
template <class T> bool Chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool Chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//#define int ll
class CAlchemist {
public:
void solve(std::istream &cin, std::ostream &cout, std::ostream &cerr) {
int N;
cin >> N;
double a[55];
REP(i, N) cin >> a[i];
sort(a, a + N);
double ans = a[0];
REP(i, N - 1) ans += a[i + 1], ans /= 2;
fcerr << ans << endl;
}
};
#undef int
int main() {
CAlchemist solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
std::ostringstream err;
in.tie(0);
ios::sync_with_stdio(0);
// solver.solve(in, out);
solver.solve(in, out, err);
return 0;
}
|
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author Gosu_Hiroo
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define TR(container, it) \
for (auto it = container.begin(); it != container.end(); it++)
#define IN(c, x) ((c).find(x) != (c).end()) // O(log n)
#define IN_L(c, x) (find((c).begin(), (c).end(), x) != (c).end()) // O(n)
#define PLL pair<ll, ll>
#define PII pair<int, int>
#define VI vector<int>
#define VVI vector<vector<int>>
#define FOR(i, _begin, _end) \
for (__typeof(_end) end = _end, begin = _begin, \
i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define REP(i, end) for (__typeof(end) i = 0, _len = (end); i < (_len); i += 1)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define MOD(x, m) ((((x) % (m)) + (m)) % (m))
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define READ \
({ \
int t; \
cin >> t; \
t; \
})
#define EB emplace_back
#define fcout cout << fixed << setprecision(12)
#define fcerr cerr << fixed << setprecision(12)
#define print(x) cout << (x) << endl
#ifdef DEBUG
#define ERR(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
_err(cerr, _it, args); \
}
#define DBG(x) cerr << #x << " is " << x << endl;
#else
#define DBG(x) {};
#define ERR(args...) {};
#endif
void _err(std::ostream &cerr, istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void _err(std::ostream &cerr, istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
_err(cerr, ++it, args...);
}
const double pi = 2 * acos(.0);
const int inf = 0x3f3f3f3f;
const ll mod = (ll)(1e9) + 7;
// const ll mod = (ll) 998244353 ;
const double eps = 1e-10;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> V) {
for (auto v : V)
os << v << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> V) {
for (auto v : V)
os << v << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> V) {
for (auto v : V)
os << v << " ";
return os;
}
template <class T> bool Chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool Chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//#define int ll
class CAlchemist {
public:
void solve(std::istream &cin, std::ostream &cout, std::ostream &cerr) {
int N;
cin >> N;
double a[55];
REP(i, N) cin >> a[i];
sort(a, a + N);
double ans = a[0];
REP(i, N - 1) ans += a[i + 1], ans /= 2;
fcout << ans << endl;
}
};
#undef int
int main() {
CAlchemist solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
std::ostringstream err;
in.tie(0);
ios::sync_with_stdio(0);
// solver.solve(in, out);
solver.solve(in, out, err);
return 0;
}
|
[
"identifier.change",
"expression.operation.binary.change"
] | 737,146
| 737,147
|
u093219895
|
cpp
|
p02935
|
#include <algorithm>
#include <bits/stdc++.h>
// #include <cstdio>
// #include <iomanip>
// #include <iostream>
// #include <queue>
#include <cstdio>
#include <queue>
// 3
// 500 300 200
using namespace std;
int main() {
int n;
scanf("%d", &n);
std::priority_queue<float, std::vector<float>, std::greater<float>> q;
for (int i = 0; i < n; i++) {
float v;
scanf("%f", &v);
q.push(v);
}
while (true) {
int v1 = q.top();
q.pop();
int v2 = q.top();
q.pop();
int v3 = (v1 + v2) / 2.0;
if (q.empty()) {
cout << v3 << endl;
break;
}
q.push(v3);
}
}
|
#include <algorithm>
#include <bits/stdc++.h>
// #include <cstdio>
// #include <iomanip>
// #include <iostream>
// #include <queue>
#include <cstdio>
#include <queue>
// 3
// 500 300 200
using namespace std;
int main() {
int n;
scanf("%d", &n);
std::priority_queue<float, std::vector<float>, std::greater<float>> q;
for (int i = 0; i < n; i++) {
float v;
scanf("%f", &v);
q.push(v);
}
while (true) {
float v1 = q.top();
q.pop();
float v2 = q.top();
q.pop();
float v3 = (v1 + v2) / 2.0;
if (q.empty()) {
cout << v3 << endl;
break;
}
q.push(v3);
}
}
|
[
"variable_declaration.type.primitive.change"
] | 737,154
| 737,155
|
u006576567
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define ppb pop_back
#define INF 1e18
typedef long long ll;
using namespace std;
int main(int argc, char *argv[]) {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(all(v));
int sum = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
sum = (sum + v[i]) / 2;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define ppb pop_back
#define INF 1e18
typedef long long ll;
using namespace std;
int main(int argc, char *argv[]) {
int n;
cin >> n;
vector<double> v(n);
rep(i, n) cin >> v[i];
sort(all(v));
double sum = (v[0] + v[1]) / 2;
for (int i = 2; i < n; i++) {
sum = (sum + v[i]) / 2;
}
cout << sum << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,156
| 737,157
|
u732817215
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
priority_queue<double, vector<double>, greater<double>> q;
int v;
for (int i = 0; i < N; i++) {
cin >> v;
q.push(v);
}
int top1, top2;
for (int i = 0; i < N - 1; i++) {
top1 = q.top();
q.pop();
top2 = q.top();
q.pop();
q.push((top1 + top2) / 2.0);
}
cout << q.top() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
priority_queue<double, vector<double>, greater<double>> q;
int v;
for (int i = 0; i < N; i++) {
cin >> v;
q.push(v);
}
double top1, top2;
for (int i = 0; i < N - 1; i++) {
top1 = q.top();
q.pop();
top2 = q.top();
q.pop();
q.push((top1 + top2) / 2.0);
}
cout << q.top() << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,162
| 737,163
|
u182310429
|
cpp
|
p02935
|
// in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n";
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
int arr[maxn];
int main() {
migmig;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 1; i < n; i++) {
arr[i] = arr[i - 1] + arr[i];
arr[i] /= 2;
}
cout << arr[n - 1];
return 0;
}
|
// in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n";
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
long double arr[maxn];
int main() {
migmig;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 1; i < n; i++) {
arr[i] = arr[i - 1] + arr[i];
arr[i] /= 2;
}
cout << arr[n - 1];
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 737,172
| 737,173
|
u433132072
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
double make;
vector<int> rare(N);
for (int i = 0; i < N; i++) {
cin >> rare.at(i);
}
for (int i = 0; i < N - 1; i++) {
sort(rare.begin(), rare.end());
make = (rare.at(0) + rare.at(1)) / 2;
rare.push_back(make);
reverse(rare.begin(), rare.end());
rare.pop_back();
rare.pop_back();
}
cout << rare.at(0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
double make;
vector<double> rare(N);
for (int i = 0; i < N; i++) {
cin >> rare.at(i);
}
for (int i = 0; i < N - 1; i++) {
sort(rare.begin(), rare.end());
make = (double)(rare.at(0) + rare.at(1)) / 2;
rare.push_back(make);
reverse(rare.begin(), rare.end());
rare.pop_back();
rare.pop_back();
}
cout << rare.at(0) << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,176
| 737,177
|
u525502670
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
const int N = 55;
int n, a[N];
double ans;
int main() {
cin >> n;
rep(i, 1, n) cin >> a[i];
sort(a + 1, a + n + 1);
ans = (a[1] + a[2]) / 2;
rep(i, 3, n) ans = (ans + a[i]) / 2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
const int N = 55;
double n, a[N];
double ans;
int main() {
cin >> n;
rep(i, 1, n) cin >> a[i];
sort(a + 1, a + (int)n + 1);
ans = (a[1] + a[2]) / 2;
rep(i, 3, n) ans = (ans + a[i]) / 2;
cout << ans << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,186
| 737,187
|
u299994354
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A.begin(), A.end());
for (int k = 0; k < N - 1; k++) {
A[k + 1] = (A[k] + A[k + 1]) / 2;
}
cout << A[N - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A.begin(), A.end());
for (int k = 0; k < N - 1; k++) {
A[k + 1] = (A[k] + A[k + 1]) / 2;
}
cout << A[N - 1] << endl;
}
|
[
"variable_declaration.remove",
"variable_declaration.type.primitive.change"
] | 737,190
| 737,191
|
u001858868
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A.begin(), A.end());
for (int k = 0; k < N; k++) {
A[k + 1] = (A[k] + A[k + 1]) / 2;
}
cout << A[N - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A.begin(), A.end());
for (int k = 0; k < N - 1; k++) {
A[k + 1] = (A[k] + A[k + 1]) / 2;
}
cout << A[N - 1] << endl;
}
|
[
"variable_declaration.type.primitive.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 737,192
| 737,191
|
u001858868
|
cpp
|
p02935
|
#include <bits/stdc++.h>
#include <numeric>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
std::priority_queue<float, std::vector<float>, std::greater<float>> que;
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
que.push(v);
}
for (int i = 0; i < N - 1; i++) {
int v1, v2;
v1 = que.top();
que.pop();
v2 = que.top();
que.pop();
que.push((float)(v1 + v2) / 2);
}
cout << que.top() << endl;
}
|
#include <bits/stdc++.h>
#include <numeric>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
std::priority_queue<double, std::vector<double>, std::greater<double>> que;
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
que.push(v);
}
for (int i = 0; i < N - 1; i++) {
double v1, v2;
v1 = que.top();
que.pop();
v2 = que.top();
que.pop();
que.push((double)(v1 + v2) / 2);
}
cout << que.top() << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,193
| 737,194
|
u909162870
|
cpp
|
p02935
|
#include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) {
long long M = max(a, b), m = min(a, b);
while (m != 0) {
long long r = M % m;
M = m;
m = r;
}
return M;
}
int digit_sum(long long n) {
long long ans;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ans;
}
int main() {
int n;
cin >> n;
vector<double> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
int ans = (a.at(0) + a.at(1)) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + a.at(i)) / 2;
}
cout << fixed << setprecision(10);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) {
long long M = max(a, b), m = min(a, b);
while (m != 0) {
long long r = M % m;
M = m;
m = r;
}
return M;
}
int digit_sum(long long n) {
long long ans;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ans;
}
int main() {
int n;
cin >> n;
vector<double> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
double ans = (a.at(0) + a.at(1)) / 2;
for (int i = 2; i < n; i++) {
ans = (ans + a.at(i)) / 2;
}
cout << fixed << setprecision(10);
cout << ans << endl;
}
|
[
"variable_declaration.type.primitive.change"
] | 737,195
| 737,196
|
u522993719
|
cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.