text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 1e5 + 10;
long double a[20];
string s[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double x, y, z;
while (cin >> x >> y >> z) {
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = z * log(pow(x, y));
a[3] = y * log(pow(x, z));
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = z * log(pow(y, x));
a[7] = x * log(pow(y, z));
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = y * log(pow(z, x));
a[11] = x * log(pow(z, y));
int index = 0;
for (int i = 1; i < 12; ++i) {
if (a[i] > a[index] + eps) {
index = i;
}
}
cout << s[index] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double x, y, z;
cin >> x >> y >> z;
long double a[12];
a[0] = log(x) * pow(y, z);
a[1] = log(x) * pow(z, y);
a[2] = log(x) * (y * z);
a[3] = log(x) * (y * z);
a[4] = log(y) * pow(x, z);
a[5] = log(y) * pow(z, x);
a[6] = log(y) * (x * z);
a[7] = log(y) * (x * z);
a[8] = log(z) * pow(x, y);
a[9] = log(z) * pow(y, x);
a[10] = log(z) * (y * x);
a[11] = log(z) * (y * x);
int index = 0;
for (int i = 1; i < 12; ++i) {
if (a[index] < a[i]) {
index = i;
}
}
cout << s[index] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string out[20] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
const int Maxn = 1e5 + 1000;
long double a, b, c, mx = -5e100l;
int res;
void put_in() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b >> c;
}
void output() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << out[res] << '\n';
}
void cmp1(long double x, long double y, long double z, int i) {
long double tmp = logl(x);
if (tmp * powl(y, z) > mx) {
mx = tmp * powl(y, z);
res = i;
}
}
void cmp2(long double x, long double y, long double z, int i) {
long double tmp = logl(x);
cerr << out[i] << ": " << setprecision(200) << fixed << tmp * y * z << '\n';
if (tmp * y * z > mx) {
mx = tmp * y * z;
res = i;
}
}
void problem_fucker() {
cmp1(a, b, c, 0);
cmp1(a, c, b, 1);
cmp2(a, b, c, 2);
cmp1(b, a, c, 4);
cmp1(b, c, a, 5);
cmp2(b, a, c, 6);
cmp1(c, a, b, 8);
cmp1(c, b, a, 9);
cmp2(c, a, b, 10);
}
int main() {
put_in();
problem_fucker();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const float EPS = 1e-15;
float x, y, z, arr[12];
int main() {
ios::sync_with_stdio(0);
cin >> x >> y >> z;
int cnt = (x < 1) + (y < 1) + (z < 1);
if (cnt != 3) {
if (x > 1) {
arr[1] = log(y) * z + log(log(x));
arr[2] = log(z) * y + log(log(x));
arr[3] = log(y) + log(z) + log(log(x));
} else if (x < 1)
arr[1] = arr[2] = arr[3] = -1e18;
else
arr[1] = arr[2] = arr[3] = -1e17;
if (y > 1) {
arr[4] = log(x) * z + log(log(y));
arr[5] = log(z) * x + log(log(y));
arr[6] = log(x) + log(z) + log(log(y));
} else if (y < 1)
arr[4] = arr[5] = arr[6] = -1e18;
else
arr[4] = arr[5] = arr[6] = -1e17;
if (z > 1) {
arr[7] = log(x) * y + log(log(z));
arr[8] = log(y) * x + log(log(z));
arr[9] = log(x) + log(y) + log(log(z));
} else if (z < 1)
arr[7] = arr[8] = arr[9] = -1e18;
else
arr[7] = arr[8] = arr[9] = -1e17;
} else {
arr[1] = -(log(y) * z + log(log(1 / x)));
arr[2] = -(log(z) * y + log(log(1 / x)));
arr[3] = -(log(y) + log(z) + log(log(1 / x)));
arr[4] = -(log(x) * z + log(log(1 / y)));
arr[5] = -(log(z) * x + log(log(1 / y)));
arr[6] = -(log(x) + log(z) + log(log(1 / y)));
arr[7] = -(log(x) * y + log(log(1 / z)));
arr[8] = -(log(y) * x + log(log(1 / z)));
arr[9] = -(log(x) + log(y) + log(log(1 / z)));
}
int mx = 1;
for (int i = 2; i < 10; ++i)
if (arr[i] > arr[mx]) mx = i;
if (mx == 1) cout << "x^y^z";
if (mx == 2) cout << "x^z^y";
if (mx == 3) cout << "(x^y)^z";
if (mx == 4) cout << "y^x^z";
if (mx == 5) cout << "y^z^x";
if (mx == 6) cout << "(y^x)^z";
if (mx == 7) cout << "z^x^y";
if (mx == 8) cout << "z^y^x";
if (mx == 9) cout << "(z^x)^y";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char s[9][10] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
long double x, y, z, a[20];
int ans = -1;
int main() {
double _x, _y, _z;
scanf("%lf%lf%lf", &_x, &_y, &_z);
x = _x;
y = _y;
z = _z;
a[0] = log(x) * pow(y, z);
a[1] = log(x) * pow(z, y);
a[3] = log(y) * pow(x, z);
a[4] = log(y) * pow(z, x);
a[6] = log(z) * pow(x, y);
a[7] = log(z) * pow(y, x);
a[2] = y * z * log(x);
a[5] = x * z * log(y);
a[8] = y * x * log(z);
for (int i = 0; i < 9; i++)
if (ans == -1 || a[i] - a[ans] > 0) ans = i;
puts(s[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long double x, y, z, maxx, EPS = 1E-7;
int n, i, j, k, ans;
cin >> x >> y >> z;
vector<long double> a(13);
a[1] = log(x) * pow(y, z);
a[2] = log(x) * pow(z, y);
a[3] = log(pow(x, y)) * z;
a[4] = log(pow(x, z)) * y;
a[5] = log(y) * pow(x, z);
a[6] = log(y) * pow(z, x);
a[7] = log(pow(y, x)) * z;
a[8] = log(pow(y, z)) * x;
a[9] = log(z) * pow(x, y);
a[10] = log(z) * pow(y, x);
a[11] = log(pow(z, x)) * y;
a[12] = log(pow(z, y)) * x;
maxx = -1;
ans = -1;
for (i = 1; i <= 12; i++) {
if (a[i] > maxx + EPS) {
maxx = a[i];
ans = i;
}
}
vector<string> ss = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
cout << ss[ans] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long MOD) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
char out[12][15] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double a[15];
int main() {
double x, y, z;
scanf("%lf%lf%lf", &x, &y, &z);
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
long double a[11];
a[0] = logx * powl(y, z);
a[1] = logx * powl(z, y);
a[2] = logx * y * z;
a[3] = -1;
a[4] = logy * powl(x, z);
a[5] = logy * powl(z, x);
a[6] = logy * x * z;
a[7] = -1;
a[8] = logz * powl(x, y);
a[9] = logz * powl(y, x);
a[10] = logz * x * y;
a[11] = -1;
long double ans = a[0];
int ind = 0;
for (int i = 1; i < 12; i++) {
if (!fabs(ans - a[i]) < 1e-8 && a[i] > ans) {
ans = a[i];
ind = i;
}
}
printf("%s\n", out[ind]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
long double a[20];
bool flag = 0, vis[15];
char s[20][20] = {" ", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double x, y, z;
while (cin >> x >> y >> z) {
long double xx, yy, zz, a[15];
int i;
for (i = 0; i < 14; i++) vis[i] = 1;
if (x < 1 && y < 1 && z < 1) {
flag = 1;
xx = 1.0 / x;
yy = 1.0 / y;
zz = 1.0 / z;
a[1] = z * log(y) + log(log(xx));
a[2] = y * log(z) + log(log(xx));
a[3] = log(z) + log(y) + log(log(xx));
a[4] = log(y) + log(z) + log(log(xx));
a[5] = z * log(x) + log(log(yy));
a[6] = x * log(z) + log(log(yy));
a[7] = log(log(yy)) + log(x) + log(z);
a[8] = log(log(yy)) + log(x) + log(z);
a[9] = y * log(x) + log(log(zz));
a[10] = x * log(y) + log(log(zz));
;
a[11] = log(x) + log(y) + log(log(zz));
a[12] = log(y) + log(x) + log(log(zz));
} else {
if (x < 1) {
vis[1] = vis[2] = vis[3] = vis[4] = 0;
} else {
a[1] = z * log(y) + log(log(x));
a[2] = y * log(z) + log(log(x));
a[3] = log(z) + log(y) + log(log(x));
a[4] = log(y) + log(z) + log(log(x));
}
if (y < 1) {
vis[5] = vis[6] = vis[7] = vis[8] = 0;
} else {
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(log(y)) + log(x) + log(z);
a[8] = log(log(y)) + log(x) + log(z);
}
if (z < 1) {
vis[9] = vis[10] = vis[11] = vis[12] = 0;
} else {
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
;
a[11] = log(x) + log(y) + log(log(z));
a[12] = log(y) + log(x) + log(log(z));
}
}
int c = 1;
if (flag) {
for (i = 2; i <= 12; i++)
if (a[c] > a[i]) c = i;
} else {
for (i = 1; i <= 12; i++)
if (vis[i]) {
c = i;
break;
}
for (i++; i <= 12; i++)
if (vis[i] && a[c] < a[i]) c = i;
}
printf("%s\n", s[c]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long double EPS = 1e-6;
bool cmp(const pair<pair<long double, string>, int> &a,
const pair<pair<long double, string>, int> &b) {
if (a.first.first >= 0) {
if (b.first.first < 0) {
return false;
}
if (abs(a.first.first - b.first.first) > EPS) {
return a.first.first < b.first.first;
}
return a.second > b.second;
}
if (abs(a.first.first - b.first.first) > EPS) {
return a.first.first < b.first.first;
}
return a.second > b.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long double x, y, z;
cin >> x >> y >> z;
vector<pair<pair<long double, string>, int> > all;
all.push_back(make_pair(make_pair(powl(y, z) * log(x), "x^y^z"), 0));
all.push_back(make_pair(make_pair(powl(z, y) * log(x), "x^z^y"), 1));
all.push_back(make_pair(make_pair(y * z * log(x), "(x^y)^z"), 2));
all.push_back(make_pair(make_pair(powl(x, z) * log(y), "y^x^z"), 3));
all.push_back(make_pair(make_pair(powl(z, x) * log(y), "y^z^x"), 4));
all.push_back(make_pair(make_pair(z * x * log(y), "(y^x)^z"), 5));
all.push_back(make_pair(make_pair(powl(x, y) * log(z), "z^x^y"), 6));
all.push_back(make_pair(make_pair(powl(y, x) * log(z), "z^y^x"), 7));
all.push_back(make_pair(make_pair(x * y * log(z), "(z^x)^y"), 8));
sort(all.begin(), all.end(), cmp);
cout << all.back().first.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z, arr[12];
int main() {
ios::sync_with_stdio(0);
cin >> x >> y >> z;
arr[1] = pow(y, z) * log(x);
arr[2] = pow(z, y) * log(x);
arr[3] = y * z * log(x);
arr[4] = pow(x, z) * log(y);
arr[5] = pow(z, x) * log(y);
arr[6] = x * z * log(y);
arr[7] = pow(x, y) * log(z);
arr[8] = pow(y, x) * log(z);
arr[9] = x * y * log(z);
int mx = 1;
for (int i = 2; i < 10; ++i)
if (arr[i] > arr[mx]) mx = i;
if (mx == 1) cout << "x^y^z";
if (mx == 2) cout << "x^z^y";
if (mx == 3) cout << "(x^y)^z";
if (mx == 4) cout << "y^x^z";
if (mx == 5) cout << "y^z^x";
if (mx == 6) cout << "(y^x)^z";
if (mx == 7) cout << "z^x^y";
if (mx == 8) cout << "z^y^x";
if (mx == 9) cout << "(z^x)^y";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using PII = pair<int, int>;
using LL = long double;
vector<string> rasp = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
struct xx {
double x, y, z;
xx(){};
xx(double a, double b, double c) {
x = a;
y = b;
z = c;
}
bool operator>(const xx &oth) {
if (oth.x == 0.000 && oth.y == 0.00000 && oth.z == 0.0000) return 1;
double rez1 = log2(log2(x)) + log2(y) * z,
rez2 = log2(log2(oth.x)) + log2(oth.y) * oth.z;
return rez1 - rez2 > 0.00000001;
}
};
xx ans(0, 0, 0);
string rr;
void solve(LL x, LL y, LL z, int cod) {
if (x == 1.0) {
xx numar(1.0, 1.0, 1.0);
if (numar > ans) ans = numar, rr = rasp[cod];
return;
}
if (x < 1) return;
xx p1(x, y, z);
if (log2(x) > 0 && p1 > ans) ans = p1, rr = rasp[cod];
p1 = xx(x, z, y);
if (log2(x) > 0 && p1 > ans) ans = p1, rr = rasp[cod + 1];
p1 = xx(x, y * z, 1);
if (p1 > ans) ans = p1, rr = rasp[cod + 2];
}
LL best;
void solve2(LL x, LL y, LL z, int cod) {
LL pow1 = pow(x, pow(y, z));
if (pow1 > best) best = pow1, rr = rasp[cod];
pow1 = pow(x, pow(z, y));
if (pow1 > best) best = pow1, rr = rasp[cod + 1];
pow1 = pow(x, y * z);
if (pow1 > best) best = pow1, rr = rasp[cod + 2];
}
int main() {
LL x, y, z;
cin >> x >> y >> z;
if (x < 1 && y < 1 && z < 1) {
solve2(x, y, z, 0);
solve2(y, x, z, 3);
solve2(z, x, y, 6);
cout << rr;
return 0;
}
xx aa(x, y, z), bb(y, x, z), cc(z, x, y);
solve(x, y, z, 0);
solve(y, x, z, 3);
solve(z, x, y, 6);
cout << rr;
}
|
#include <bits/stdc++.h>
using namespace std;
long double values[12];
vector<string> expression = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long double x, y, z, a, b, c;
cin >> x >> y >> z;
a = (log(x));
b = (log(y));
c = (log(z));
values[0] = pow(y, z) * a;
values[1] = pow(z, y) * a;
values[2] = (z * y) * a;
values[3] = values[2];
values[4] = pow(x, z) * b;
values[5] = pow(z, x) * b;
values[6] = (z * x) * b;
values[7] = values[6];
values[8] = pow(x, y) * c;
values[9] = pow(y, x) * c;
values[10] = (x * y) * c;
values[11] = values[10];
int idx = 0;
long double ans = values[0];
for (int i = 1; i < 12; i++) {
if (values[i] > ans) {
ans = values[i];
idx = i;
}
}
cout << expression[idx] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string s[16] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double x, y, z, a[12], mx;
int i, k;
int main() {
cin >> x >> y >> z;
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = a[3] = (y * z) * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = a[7] = (x * z) * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = a[11] = (x * y) * log(z);
mx = a[0], k = 0;
for (int i = 1; i < 12; i++) {
if (a[i] > mx) {
mx = a[i];
k = i;
}
}
cout << s[k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool pid_comp_second(pair<int, double> a, pair<int, double> b) {
if (a.second == b.second) return a.first < b.first;
return a.second > b.second;
}
int main() {
double x, y, z;
cin >> x >> y >> z;
map<int, string> expr;
expr[1] = "x^y^z";
expr[2] = "x^z^y";
expr[3] = "(x^y)^z";
expr[5] = "y^x^z";
expr[6] = "y^z^x";
expr[7] = "(y^x)^z";
expr[9] = "z^x^y";
expr[10] = "z^y^x";
expr[11] = "(z^x)^y";
vector<pair<int, double> > nums;
if (x < 1 || x < 1 || x < 1) {
nums.push_back(make_pair(1, pow(y, z) * log(x)));
nums.push_back(make_pair(2, pow(z, y) * log(x)));
nums.push_back(make_pair(3, y * z * log(x)));
nums.push_back(make_pair(5, pow(x, z) * log(y)));
nums.push_back(make_pair(6, pow(z, x) * log(y)));
nums.push_back(make_pair(7, x * z * log(y)));
nums.push_back(make_pair(9, pow(x, y) * log(z)));
nums.push_back(make_pair(10, pow(y, x) * log(z)));
nums.push_back(make_pair(11, x * y * log(z)));
} else {
nums.push_back(make_pair(1, z * log(y) + log(log(x))));
nums.push_back(make_pair(2, y * log(z) + log(log(x))));
nums.push_back(make_pair(3, log(y) + log(z) + log(log(x))));
nums.push_back(make_pair(5, z * log(x) + log(log(y))));
nums.push_back(make_pair(6, x * log(z) + log(log(y))));
nums.push_back(make_pair(7, log(x) + log(z) + log(log(y))));
nums.push_back(make_pair(9, y * log(x) + log(log(z))));
nums.push_back(make_pair(10, x * log(y) + log(log(z))));
nums.push_back(make_pair(11, log(x) + log(y) + log(log(z))));
}
sort(nums.begin(), nums.end(), pid_comp_second);
cout << expr[nums[0].first] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
string hoge[9] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
int main() {
long double x, y, z;
cin >> x >> y >> z;
int check = 0;
long double comp = pow(y, z) * log10(x);
if (comp < (pow(z, y) * log10(x))) {
check = 1;
comp = pow(z, y) * log10(x);
}
if (comp < y * z * log10(x)) {
check = 2;
comp = y * z * log10(x);
}
if (comp < (pow(x, z) * log10(y))) {
check = 3;
comp = pow(x, z) * log10(y);
}
if (comp < (pow(z, x) * log10(y))) {
check = 4;
comp = pow(z, x) * log10(y);
}
if (comp < x * z * log10(y)) {
check = 5;
comp = x * z * log10(y);
}
if (comp < (pow(x, y) * log10(z))) {
check = 6;
comp = pow(x, y) * log10(z);
}
if (comp < (pow(y, x) * log10(z))) {
check = 7;
comp = pow(y, x) * log10(z);
}
if (comp < x * y * log10(z)) {
check = 8;
}
cout << hoge[check] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(complex<long double> a, complex<long double> b) {
if (fabs(imag(a)) < 1e-17 && fabs(imag(b)) < 1e-17) {
return (real(a) > real(b) + 1e-17);
}
if (fabs(imag(a)) < 1e-17 && fabs(imag(b)) >= 1e-17) {
return true;
}
if (fabs(imag(a)) >= 1e-17 && fabs(imag(b)) < 1e-17) {
return false;
}
if (fabs(imag(a)) >= 1e-17 && fabs(imag(b)) >= 1e-17) {
return real(a) < real(b);
}
}
int main() {
ios_base::sync_with_stdio(false);
long double a1, a2, a3;
cin >> a1 >> a2 >> a3;
complex<long double> x(a1, 0.0);
complex<long double> y(a2, 0.0);
complex<long double> z(a3, 0.0);
complex<long double> a[12];
a[0] = z * log(y) + log(log(x));
a[1] = y * log(z) + log(log(x));
a[2] = log(z) + log(y) + log(log(x));
a[3] = log(y) + log(z) + log(log(x));
a[4] = z * log(x) + log(log(y));
a[5] = x * log(z) + log(log(y));
a[6] = log(z) + log(x) + log(log(y));
a[7] = log(x) + log(z) + log(log(y));
a[8] = y * log(x) + log(log(z));
a[9] = x * log(y) + log(log(z));
a[10] = log(y) + log(x) + log(log(z));
a[11] = log(x) + log(y) + log(log(z));
complex<long double> ans = a[0];
int c = 0;
for (int i = 1; i < 12; i++) {
if (compare(a[i], ans)) {
c = i;
ans = a[i];
}
}
if (c == 0) {
cout << "x^y^z\n";
return 0;
}
if (c == 1) {
cout << "x^z^y\n";
return 0;
}
if (c == 2) {
cout << "(x^y)^z\n";
return 0;
}
if (c == 3) {
cout << "(x^z)^y\n";
return 0;
}
if (c == 4) {
cout << "y^x^z\n";
return 0;
}
if (c == 5) {
cout << "y^z^x\n";
return 0;
}
if (c == 6) {
cout << "(y^x)^z\n";
return 0;
}
if (c == 7) {
cout << "(y^z)^x\n";
return 0;
}
if (c == 8) {
cout << "z^x^y\n";
return 0;
}
if (c == 9) {
cout << "z^y^x\n";
return 0;
}
if (c == 10) {
cout << "(z^x)^y\n";
return 0;
}
if (c == 11) {
cout << "(z^y)^x\n";
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double get2(long double x, long double y, long double z) {
return y * z * log(x);
}
const long double eps = 1e-10;
bool bigger(long double a, long double b) { return a - b > 0; }
bool equal(long double a, long double b) { return abs(a - b) < eps; }
long double best;
int best_pos;
int pos;
void try1(long double x, long double y, long double z, bool sure = false) {
++pos;
long double val = pow(y, z) * log(x);
if (bigger(val, best) || sure) {
best = val;
best_pos = pos;
}
}
void try2(long double x, long double y, long double z, bool sure = false) {
++pos;
long double val = y * z * log(x);
if (bigger(val, best) || sure) {
best = val;
best_pos = pos;
}
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
try1(x, y, z, true);
try1(x, z, y);
try2(x, y, z);
try2(x, z, y);
try1(y, x, z);
try1(y, z, x);
try2(y, x, z);
try2(y, z, x);
try1(z, x, y);
try1(z, y, x);
try2(z, x, y);
try2(z, y, x);
if (best_pos == 1)
cout << "x^y^z\n";
else if (best_pos == 2)
cout << "x^z^y\n";
else if (best_pos == 3)
cout << "(x^y)^z\n";
else if (best_pos == 4)
cout << "(x^z)^y\n";
else if (best_pos == 5)
cout << "y^x^z\n";
else if (best_pos == 6)
cout << "y^z^x\n";
else if (best_pos == 7)
cout << "(y^x)^z\n";
else if (best_pos == 8)
cout << "(y^z)^x\n";
else if (best_pos == 9)
cout << "z^x^y\n";
else if (best_pos == 10)
cout << "z^y^x\n";
else if (best_pos == 11)
cout << "(z^x)^y\n";
else if (best_pos == 12)
cout << "(z^y)^x\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 12;
const long double eps = 1e-6;
long double PI = acos((long double)(-1));
long double x[3];
string s[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double maxi = -0x7FFFFFFF, mini = 0x7FFFFFFF;
long double res[maxn];
long double calc(string s) {
long double y[3];
int sz = s.size(), cnt = 0;
for (int i = 0; i < sz; i++)
if (s[i] == 'x' || s[i] == 'y' || s[i] == 'z') y[cnt++] = x[s[i] - 'x'];
if (s[0] == '(')
return y[1] * y[2] * log(y[0]);
else
return pow(y[1], y[2]) * log(y[0]);
}
int main() {
std::ios_base::sync_with_stdio(false);
for (int i = 0; i < 3; i++) cin >> x[i];
for (int i = 0; i < maxn; i++) {
res[i] = calc(s[i]);
maxi = max(maxi, res[i]);
}
int idx;
for (int i = 0; i < maxn; i++)
if (fabs(res[i] - maxi) < mini) {
mini = fabs(res[i] - maxi);
idx = i;
}
cout << s[idx] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long getnum() {
char c = getchar();
long long num, sign = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (num = 0; c >= '0' && c <= '9';) {
c -= '0';
num = num * 10 + c;
c = getchar();
}
return num * sign;
}
char S[40];
int main() {
long double a, b, c, p1, p2, p3;
int a1, a2, a3, b1, b2, b3;
cin >> a >> b >> c;
if (a <= 1.1 || b <= 1.1 || c <= 1.1) {
long double mx = pow(a, pow(b, c));
strcpy(S, "x^y^z");
if (pow(a, pow(c, b)) > mx) {
mx = pow(a, pow(c, b));
strcpy(S, "x^z^y");
}
if (pow(a, c * b) > mx) {
mx = pow(a, c * b);
strcpy(S, "(x^y)^z");
}
if (pow(b, pow(a, c)) > mx) {
mx = pow(b, pow(a, c));
strcpy(S, "y^x^z");
}
if (pow(b, pow(c, a)) > mx) {
mx = pow(b, pow(c, a));
strcpy(S, "y^z^x");
}
if (pow(b, a * c) > mx) {
mx = pow(b, a * c);
strcpy(S, "(y^x)^z");
}
if (pow(c, pow(a, b)) > mx) {
mx = pow(c, pow(a, b));
strcpy(S, "z^x^y");
}
if (pow(c, pow(b, a)) > mx) {
mx = pow(c, pow(b, a));
strcpy(S, "z^y^x");
}
if (pow(c, a * b) > mx) {
strcpy(S, "(z^x)^y");
}
puts(S);
return 0;
}
if (pow(b, c) >= b * c && pow(b, c) >= pow(c, b))
a1 = 1, p1 = pow(b, c);
else if (pow(c, b) >= b * c && pow(c, b) >= pow(b, c))
a1 = 2, p1 = pow(c, b);
else if (b * c >= pow(b, c) && b * c >= pow(c, b))
a1 = 3, p1 = b * c;
if (pow(a, c) >= a * c && pow(a, c) >= pow(c, a))
a2 = 1, p2 = pow(a, c);
else if (pow(c, a) >= a * c && pow(c, a) >= pow(a, c))
a2 = 2, p2 = pow(c, a);
else if (a * c >= pow(a, c) && a * c >= pow(c, a))
a2 = 3, p2 = a * c;
if (pow(a, b) >= a * b && pow(a, b) >= pow(b, a))
a3 = 1, p3 = pow(a, b);
else if (pow(b, a) >= b * a && pow(b, a) >= pow(a, b))
a3 = 2, p3 = pow(b, a);
else if (b * a >= pow(a, b) && b * a >= pow(b, a))
a3 = 3, p3 = a * b;
long double x1 = log(b) / log(a) * p2, x2 = log(c) / log(a) * p3;
if (p1 >= x1 && p1 >= x2) {
if (a1 == 1) puts("x^y^z");
if (a1 == 2) puts("x^z^y");
if (a1 == 3) puts("(x^y)^z");
} else if (x1 >= p1 && x1 >= x2) {
if (a2 == 1) puts("y^x^z");
if (a2 == 2) puts("y^z^x");
if (a2 == 3) puts("(y^x)^z");
} else if (x2 >= p1 && x2 >= x1) {
if (a3 == 1) puts("z^x^y");
if (a3 == 2) puts("z^y^x");
if (a3 == 3) puts("(z^x)^y");
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
long double a[13];
char q[13][100];
int main() {
strcpy(q[1], "x^y^z");
strcpy(q[2], "x^z^y");
strcpy(q[3], "(x^y)^z");
strcpy(q[4], "(x^z)^y");
strcpy(q[5], "y^x^z");
strcpy(q[6], "y^z^x");
strcpy(q[7], "(y^x)^z");
strcpy(q[8], "(y^z)^x");
strcpy(q[9], "z^x^y");
strcpy(q[10], "z^y^x");
strcpy(q[11], "(z^x)^y");
strcpy(q[12], "(z^y)^x");
while (cin >> x >> y >> z) {
long double t[6];
t[0] = pow(x, y);
t[1] = pow(x, z);
t[2] = pow(y, z);
t[3] = pow(y, x);
t[4] = pow(z, x);
t[5] = pow(z, y);
a[1] = t[2] * log(x);
a[2] = t[5] * log(x);
a[3] = y * z * log(x);
a[4] = y * z * log(x);
a[5] = t[1] * log(y);
a[6] = t[4] * log(y);
a[7] = z * x * log(y);
a[8] = z * x * log(y);
a[9] = t[0] * log(z);
a[10] = t[3] * log(z);
a[11] = y * x * log(z);
a[12] = y * x * log(z);
long double m = -DBL_MAX;
int c = 1;
for (int i = 1; i <= 12; i++) {
if (a[i] > m) {
m = a[i], c = i;
}
}
printf("%s\n", q[c]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z, mx, ans;
map<int, string> mp;
int main() {
mp[11] = "(z^x)^y";
mp[10] = "z^y^x";
mp[9] = "z^x^y";
mp[7] = "(y^x)^z";
mp[6] = "y^z^x";
mp[5] = "y^x^z";
mp[3] = "(x^y)^z";
mp[2] = "x^z^y";
mp[1] = "x^y^z";
cin >> x >> y >> z;
long double a = log(x);
long double b = log(y);
long double c = log(z);
mx = x * y * c;
ans = 11;
if (pow(y, x) * c >= mx) mx = pow(y, x) * c, ans = 10;
if (pow(x, y) * c >= mx) mx = pow(x, y) * c, ans = 9;
if (x * z * b >= mx) mx = x * z * b, ans = 7;
if (pow(z, x) * b >= mx) mx = pow(z, x) * b, ans = 6;
if (pow(x, z) * b >= mx) mx = pow(x, z) * b, ans = 5;
if (y * z * a >= mx) mx = y * z * a, ans = 3;
if (pow(z, y) * a >= mx) mx = pow(z, y) * a, ans = 2;
if (pow(y, z) * a >= mx) mx = pow(y, z) * a, ans = 1;
cout << mp[ans] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long double maxi = -100000.00;
vector<string> vec;
int c = 0;
void pushInVec() {
vec.push_back("x^y^z");
vec.push_back("x^z^y");
vec.push_back("(x^y)^z");
vec.push_back("(x^z)^y");
vec.push_back("y^x^z");
vec.push_back("y^z^x");
vec.push_back("(y^x)^z");
vec.push_back("(y^z)^x");
vec.push_back("z^x^y");
vec.push_back("z^y^x");
vec.push_back("(z^x)^y");
vec.push_back("(z^y)^x");
}
void solve1(long double x, long double y, long double z, int idx, int id = 0) {
long double res;
if (id)
res = pow(x, pow(y, z));
else
res = z * log(y) + log(log(x));
if (maxi < res) {
maxi = res;
c = idx;
}
}
void solve2(long double x, long double y, long double z, int idx, int id = 0) {
long double res;
if (id)
res = pow(x, y * z);
else
res = log(y) + log(z) + log(log(x));
if (maxi < res) {
maxi = res;
c = idx;
}
}
int main() {
pushInVec();
double x, y, z;
scanf("%lf %lf %lf", &x, &y, &z);
if (x <= 1.0 && y <= 1.0 && z <= 1.0) {
solve1(x, y, z, 0, 1);
solve1(x, z, y, 1, 1);
solve2(x, y, z, 2, 1);
solve2(x, z, y, 3, 1);
solve1(y, x, z, 4, 1);
solve1(y, z, x, 5, 1);
solve2(y, x, z, 6, 1);
solve2(y, z, x, 7, 1);
solve1(z, x, y, 8, 1);
solve1(z, y, x, 9, 1);
solve2(z, x, y, 10, 1);
solve2(z, y, x, 11, 1);
}
if (x > 1.0) {
solve1(x, y, z, 0);
solve1(x, z, y, 1);
solve2(x, y, z, 2);
solve2(x, z, y, 3);
}
if (y > 1.0) {
solve1(y, x, z, 4);
solve1(y, z, x, 5);
solve2(y, x, z, 6);
solve2(y, z, x, 7);
}
if (z > 1.0) {
solve1(z, x, y, 8);
solve1(z, y, x, 9);
solve2(z, x, y, 10);
solve2(z, y, x, 11);
}
cout << vec[c] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
double dx, dy, dz;
long double val[13];
char s[][20] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
scanf("%lf%lf%lf", &dx, &dy, &dz);
x = dx;
y = dy;
z = dz;
val[1] = pow(y, z) * log(x);
val[2] = pow(z, y) * log(x);
val[3] = val[4] = y * z * log(x);
val[5] = pow(x, z) * log(y);
val[6] = pow(z, x) * log(y);
val[7] = val[8] = x * z * log(y);
val[9] = pow(x, y) * log(z);
val[10] = pow(y, x) * log(z);
val[11] = val[12] = x * y * log(z);
int who = 0;
for (int i = 1; i <= 12; ++i) {
if (val[i] > val[who]) {
who = i;
}
}
if (who == 0) {
val[1] = pow(x, pow(y, z));
val[2] = pow(x, pow(z, y));
val[3] = val[4] = pow(x, y * z);
val[5] = pow(y, pow(x, z));
val[6] = pow(y, pow(z, x));
val[7] = val[8] = pow(y, x * z);
val[9] = pow(z, pow(x, y));
val[10] = pow(z, pow(y, x));
val[11] = val[12] = pow(z, x * y);
for (int i = 1; i <= 12; ++i) {
if (val[i] > val[who]) {
who = i;
}
}
if (!who) who = 1;
}
puts(s[who]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z;
cin >> x >> y >> z;
double array[13];
int index = 1;
for (int i = 0; i < 13; i++) {
array[i] = -9999999999999999;
}
if (((x > 1) || (y > 1) || (z > 1))) {
if (x > 1) {
array[1] = log(log(x)) + log(y) * z;
array[2] = log(log(x)) + log(z) * y;
array[3] = log(log(x)) + (log(y) + log(z));
array[4] = log(log(x)) + (log(y) + log(z));
}
if (y > 1) {
array[5] = log(log(y)) + log(x) * z;
array[6] = log(log(y)) + log(z) * x;
array[7] = log(log(y)) + (log(x) + log(z));
array[8] = log(log(y)) + (log(x) + log(z));
}
if (z > 1) {
array[9] = log(log(z)) + log(x) * y;
array[10] = log(log(z)) + log(y) * x;
array[11] = log(log(z)) + (log(x) + log(y));
array[12] = log(log(z)) + (log(x) + log(y));
}
double largest = array[1];
for (int i = 1; i < 13; i++) {
if (array[i] > largest) {
largest = array[i];
}
}
int index = 1, shouldicontinue = 1;
do {
if (largest == array[index]) {
shouldicontinue = 0;
}
index += 1;
} while (shouldicontinue == 1 && index < 13);
index -= 1;
if (index == 1) {
cout << "x^y^z";
} else if (index == 2) {
cout << "x^z^y";
} else if (index == 3) {
cout << "(x^y)^z";
} else if (index == 4) {
cout << "(x^z)^y";
} else if (index == 5) {
cout << "y^x^z";
} else if (index == 6) {
cout << "y^z^x";
} else if (index == 7) {
cout << "(y^x)^z";
} else if (index == 8) {
cout << "(y^z)^x";
} else if (index == 9) {
cout << "z^x^y";
} else if (index == 10) {
cout << "z^y^x";
} else if (index == 11) {
cout << "(z^x)^y";
} else
cout << "(z^y)^x";
} else if (x < 1 && y < 1 && z < 1) {
array[1] = log(log(1 / x)) + log(y) * z;
array[2] = log(log(1 / x)) + log(z) * y;
array[3] = log(log(1 / x)) + (log(y) + log(z));
array[4] = log(log(1 / x)) + (log(y) + log(z));
array[5] = log(log(1 / y)) + log(x) * z;
array[6] = log(log(1 / y)) + log(z) * x;
array[7] = log(log(1 / y)) + (log(x) + log(z));
array[8] = log(log(1 / y)) + (log(x) + log(z));
array[9] = log(log(1 / z)) + log(x) * y;
array[10] = log(log(1 / z)) + log(y) * x;
array[11] = log(log(1 / z)) + (log(x) + log(y));
array[12] = log(log(1 / z)) + (log(x) + log(y));
double smallest = array[1];
for (int i = 1; i < 13; i++) {
if (array[i] < smallest) {
smallest = array[i];
}
}
int index = 1, shouldicontinue = 1;
do {
if (smallest == array[index]) {
shouldicontinue = 0;
}
index += 1;
} while (shouldicontinue == 1 && index < 13);
index -= 1;
if (index == 1) {
cout << "x^y^z";
} else if (index == 2) {
cout << "x^z^y";
} else if (index == 3) {
cout << "(x^y)^z";
} else if (index == 4) {
cout << "(x^z)^y";
} else if (index == 5) {
cout << "y^x^z";
} else if (index == 6) {
cout << "y^z^x";
} else if (index == 7) {
cout << "(y^x)^z";
} else if (index == 8) {
cout << "(y^z)^x";
} else if (index == 9) {
cout << "z^x^y";
} else if (index == 10) {
cout << "z^y^x";
} else if (index == 11) {
cout << "(z^x)^y";
} else
cout << "(z^y)^x";
} else {
array[1] = pow(x, pow(y, z));
array[2] = pow(x, pow(z, y));
array[3] = pow(pow(x, y), z);
array[4] = pow(pow(x, y), z);
array[5] = pow(y, pow(x, z));
array[6] = pow(y, pow(z, x));
array[7] = pow(pow(y, x), z);
array[8] = pow(pow(y, x), z);
array[9] = pow(z, pow(x, y));
array[10] = pow(z, pow(y, x));
array[11] = pow(pow(z, y), x);
array[12] = pow(pow(z, y), x);
double largest = array[1];
for (int i = 1; i < 13; i++) {
if (array[i] > largest) {
largest = array[i];
}
}
int index = 1, shouldicontinue = 1;
do {
if (largest == array[index]) {
shouldicontinue = 0;
}
index += 1;
} while (shouldicontinue == 1 && index < 13);
index -= 1;
if (index == 1) {
cout << "x^y^z";
} else if (index == 2) {
cout << "x^z^y";
} else if (index == 3) {
cout << "(x^y)^z";
} else if (index == 4) {
cout << "(x^z)^y";
} else if (index == 5) {
cout << "y^x^z";
} else if (index == 6) {
cout << "y^z^x";
} else if (index == 7) {
cout << "(y^x)^z";
} else if (index == 8) {
cout << "(y^z)^x";
} else if (index == 9) {
cout << "z^x^y";
} else if (index == 10) {
cout << "z^y^x";
} else if (index == 11) {
cout << "(z^x)^y";
} else
cout << "(z^y)^x";
}
}
|
#include <bits/stdc++.h>
std::string ans[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
const double EPS = 1e-10;
long double best;
int id;
bool better(long double val) {
if (best < val) {
best = val;
return true;
}
return false;
}
void try2(long double x, long double y, long double z, int pos) {
long double val = z * y * log(x);
if (better(val)) id = pos;
}
void try1(long double x, long double y, long double z, int pos) {
long double val = powl(y, z) * log(x);
if (better(val)) id = pos;
}
int main(void) {
long double x, y, z;
std::cin >> x >> y >> z;
best = -1e12;
id = -1;
try1(x, y, z, 0);
try1(x, z, y, 1);
try2(x, y, z, 2);
try2(x, z, y, 3);
try1(y, x, z, 4);
try1(y, z, x, 5);
try2(y, x, z, 6);
try2(y, z, x, 7);
try1(z, x, y, 8);
try1(z, y, x, 9);
try2(z, x, y, 10);
try2(z, y, x, 11);
std::cout << ans[id] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e8;
const long double EPS = (1e-12);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
unsigned long long gcd(unsigned long long a, unsigned long long b) {
for (;;) {
if (a == 0) return b;
b %= a;
if (b == 0) return a;
a %= b;
}
}
unsigned long long lcm(unsigned long long a, unsigned long long b) {
unsigned long long temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
int main() {
ios::sync_with_stdio(false);
vector<pair<long double, int> > v;
map<int, string> mm;
mm[1] = "x^y^z";
mm[2] = "x^z^y";
mm[3] = "(x^y)^z";
mm[4] = "(x^z)^y";
mm[5] = "y^x^z";
mm[6] = "y^z^x";
mm[7] = "(y^x)^z";
mm[8] = "(y^z)^x";
mm[9] = "z^x^y";
mm[10] = "z^y^x";
mm[11] = "(z^x)^y";
mm[12] = "(z^y)^x";
long double x, y, z;
cin >> x >> y >> z;
long double a1 = log(x) * pow(y, z);
v.push_back(make_pair(a1, 1));
long double a2 = log(x) * pow(z, y);
v.push_back(make_pair(a2, 2));
long double a3 = log(x) * y * z;
v.push_back(make_pair(a3, 3));
long double a4 = a3;
v.push_back(make_pair(a4, 4));
long double a5 = log(y) * pow(x, z);
v.push_back(make_pair(a5, 5));
long double a6 = log(y) * pow(z, x);
v.push_back(make_pair(a6, 6));
long double a7 = log(y) * x * z;
v.push_back(make_pair(a7, 7));
long double a8 = a7;
v.push_back(make_pair(a8, 8));
long double a9 = log(z) * pow(x, y);
v.push_back(make_pair(a9, 9));
long double a10 = log(z) * pow(y, x);
v.push_back(make_pair(a10, 10));
long double a11 = log(z) * x * y;
v.push_back(make_pair(a11, 11));
long double a12 = a11;
v.push_back(make_pair(a12, 12));
int ind = v[0].second;
long double maxi = v[0].first;
for (int i = (1); i < (int)(12); ++i) {
if (dcmp(v[i].first, maxi) != 0 && v[i].first > maxi)
ind = v[i].second, maxi = v[i].first;
}
cout << mm[ind];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxx(int a, int b) { return a > b ? a : b; }
int minn(int a, int b) { return a < b ? a : b; }
long double abss(long double a) { return a < 0 ? (-a) : a; }
const long double eps = 1e-7;
void cmp(double, double, double, int);
long double res[4];
int num[4];
char *exps[15] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
double X, Y, Z;
scanf("%lf%lf%lf", &X, &Y, &Z);
cmp(X, Y, Z, 1);
cmp(Y, X, Z, 2);
cmp(Z, X, Y, 3);
long double tmax = res[1];
int p = 1;
for (int i = 2; i <= 3; i++) {
if (tmax < res[i] && abss(tmax - res[i]) > eps) {
tmax = res[i];
p = i;
}
}
int id = 4 * (p - 1) + num[p] - 1;
printf("%s", exps[id]);
return 0;
}
void cmp(double X, double Y, double Z, int flr) {
long double x = X, y = Y, z = Z;
long double tem[4];
tem[1] = powl(y, z) * (long double)log(x);
tem[2] = powl(z, y) * (long double)log(x);
tem[3] = (long double)y * z * log(x);
long double tmax = tem[1];
int p = 1;
for (int i = 2; i <= 3; i++) {
if (tmax < tem[i] && abss(tmax - tem[i]) > eps) {
tmax = tem[i];
p = i;
}
}
res[flr] = tmax;
num[flr] = p;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
string S[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int ans() {
int id = -1;
long double A[] = {
z * log(y) + log(log(x)), y * log(z) + log(log(x)),
log(y) + log(z) + log(log(x)), log(z) + log(y) + log(log(x)),
z * log(x) + log(log(y)), x * log(z) + log(log(y)),
log(x) + log(z) + log(log(y)), log(z) + log(x) + log(log(y)),
y * log(x) + log(log(z)), x * log(y) + log(log(z)),
log(y) + log(x) + log(log(z)), log(x) + log(y) + log(log(z)),
};
for (int i = 0; i < 12; i++) {
if (log(x) < 0 and i <= 3) continue;
if (log(y) < 0 and i > 3 and i <= 7) continue;
if (log(z) < 0 and i > 7) continue;
if (id == -1)
id = i;
else if (A[i] > A[id])
id = i;
}
if (id >= 0) return id;
long double B[] = {pow(x, pow(y, z)), pow(x, pow(z, y)), pow(x, y * z),
pow(x, y * z), pow(y, pow(x, z)), pow(y, pow(z, x)),
pow(y, x * z), pow(y, x * z), pow(z, pow(x, y)),
pow(z, pow(y, x)), pow(z, x * y), pow(z, y * x)};
for (int i = 0; i < 12; i++)
if (id == -1 || B[i] > B[id]) id = i;
return id;
}
int main() {
cin >> x >> y >> z;
x *= 1.0000000, y *= 1.0000000, z *= 1.0000000;
cout << S[ans()] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z;
cin >> x >> y >> z;
double a[12] = {-200, -200, -200, -200, -200, -200,
-200, -200, -200, -200, -200, -200};
string b[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
if ((x > 1 && y > 1 && z > 1) || (x > 1 && y > 1 && z <= 1) ||
(x > 1 && y <= 1 && z > 1) || (x <= 1 && y > 1 && z > 1) ||
(x <= 1 && y <= 1 && z > 1) || (x <= 1 && y > 1 && z <= 1) ||
(x > 1 && y <= 1 && z <= 1)) {
if (x > 1) {
a[2] = log(log(x) * y * z);
a[3] = log(log(x) * y * z);
a[0] = log(log(x)) + z * log(y);
a[1] = log(log(x)) + y * log(z);
}
if (y > 1) {
a[6] = log(log(y) * x * z);
a[7] = log(log(y) * x * z);
a[4] = log(log(y)) + z * log(x);
a[5] = log(log(y)) + x * log(z);
}
if (z > 1) {
a[10] = log(log(z) * y * x);
a[11] = log(log(z) * y * x);
a[9] = log(log(z)) + x * log(y);
a[8] = log(log(z)) + y * log(x);
}
} else {
a[0] = pow(x, pow(y, z));
a[1] = pow(x, pow(z, y));
a[2] = pow(x, y * z);
a[3] = pow(x, y * z);
a[4] = pow(y, pow(x, z));
a[5] = pow(y, pow(z, x));
a[6] = pow(y, z * x);
a[7] = pow(y, z * x);
a[8] = pow(z, pow(x, y));
a[9] = pow(z, pow(y, x));
a[10] = pow(z, x * y);
a[11] = pow(z, x * y);
}
double max = -10.0;
string str = "nothing bitch";
for (int i = 0; i < 12; i++) {
if (a[i] > max) {
max = a[i];
str = b[i];
}
}
cout << str << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[] = {
"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y",
};
long double ans[10];
const long double eps = 1e-8;
int main() {
double x, y, z;
scanf("%lf%lf%lf", &x, &y, &z);
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
ans[0] = logx * powl(y, z);
ans[1] = logx * powl(z, y);
ans[2] = logx * y * z;
ans[3] = logy * powl(x, z);
ans[4] = logy * powl(z, x);
ans[5] = logy * x * z;
ans[6] = logz * powl(x, y);
ans[7] = logz * powl(y, x);
ans[8] = logz * x * y;
int num = 0;
long double now = ans[0];
for (int i = 0; i < 9; ++i) {
if (ans[i] > now) {
now = ans[i];
num = i;
}
}
cout << a[num] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double get2(long double x, long double y, long double z) {
return y * z * log(x);
}
const long double eps = 1e-10;
bool bigger(long double a, long double b) { return a - b > 0; }
bool equal(long double a, long double b) { return abs(a - b) < eps; }
long double best;
int best_pos;
int pos;
void try1(long double x, long double y, long double z, bool sure = false) {
++pos;
long double val = pow(y, z) * log(x);
if (bigger(val, best) || sure) {
best = val;
best_pos = pos;
}
}
void try2(long double x, long double y, long double z, bool sure = false) {
++pos;
long double val = y * z * log(x);
if (bigger(val, best) || sure) {
best = val;
best_pos = pos;
}
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
try1(x, y, z, true);
try1(x, z, y);
try2(x, y, z);
try2(x, z, y);
try1(y, x, z);
try1(y, z, x);
try2(y, x, z);
try2(y, z, x);
try1(z, x, y);
try1(z, y, x);
try2(z, x, y);
try2(z, y, x);
if (best_pos == 1)
cout << "x^y^z\n";
else if (best_pos == 2)
cout << "x^z^y\n";
else if (best_pos == 3)
cout << "(x^y)^z\n";
else if (best_pos == 4)
cout << "(x^z)^y\n";
else if (best_pos == 5)
cout << "y^x^z\n";
else if (best_pos == 6)
cout << "y^z^x\n";
else if (best_pos == 7)
cout << "(y^x)^z\n";
else if (best_pos == 8)
cout << "(y^z)^x\n";
else if (best_pos == 9)
cout << "z^x^y\n";
else if (best_pos == 10)
cout << "z^y^x\n";
else if (best_pos == 11)
cout << "(z^x)^y\n";
else if (best_pos == 12)
cout << "(z^y)^x\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const long long Linf = (1uLL << 63) - 1;
const double EPS = 1e-7;
namespace IOSpace {
void get_int(int &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-'; t = getchar())
;
if (t == '-') neg = true, t = getchar();
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
}
void get_int(long long &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-'; t = getchar())
;
if (t == '-') neg = true, t = getchar();
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
}
void print_int(int x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
void print_int(long long x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
} // namespace IOSpace
using namespace IOSpace;
const int maxlog = 20;
const long long mod = 1000000007;
const int maxn = 10005;
char s[9][10] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
double lge[maxn];
int main() {
double x, y, z;
cin >> x >> y >> z;
if (x > 1.01) {
lge[0] = z * log2(y) + log2(log2(x));
lge[1] = y * log2(z) + log2(log2(x));
lge[2] = log2(y) + log2(z) + log2(log2(x));
} else
lge[0] = lge[1] = lge[2] = -inf;
if (y > 1.01) {
lge[3] = z * log2(x) + log2(log2(y));
lge[4] = x * log2(z) + log2(log2(y));
lge[5] = log2(x) + log2(z) + log2(log2(y));
} else
lge[3] = lge[4] = lge[5] = -inf;
if (z > 1.01) {
lge[6] = y * log2(x) + log2(log2(z));
lge[7] = x * log2(y) + log2(log2(z));
lge[8] = log2(x) + log2(y) + log2(log2(z));
} else
lge[6] = lge[7] = lge[8] = -inf;
if (x < 1.01 && y < 1.01 && z < 1.01) {
lge[0] = z * log2(y) + log2(log2(1 / x));
lge[1] = y * log2(z) + log2(log2(1 / x));
lge[2] = log2(y) + log2(z) + log2(log2(1 / x));
lge[3] = z * log2(x) + log2(log2(1 / y));
lge[4] = x * log2(z) + log2(log2(1 / y));
lge[5] = log2(x) + log2(z) + log2(log2(1 / y));
lge[6] = y * log2(x) + log2(log2(1 / z));
lge[7] = x * log2(y) + log2(log2(1 / z));
lge[8] = log2(x) + log2(y) + log2(log2(1 / z));
for (int i = 0; i < 9; i++) lge[i] *= -1;
}
int mx = 0;
for (int i = 1; i < 9; i++)
if (lge[mx] < lge[i] - EPS) mx = i;
cout << s[mx] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long double mx = -1;
string res;
void update(long double x, string y) {
if (x > mx) {
mx = x;
res = y;
}
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
update(log(x) * pow(y, z), "x^y^z");
update(log(x) * pow(z, y), "x^z^y");
update(log(x) * y * z, "(x^y)^z");
update(log(y) * pow(x, z), "y^x^z");
update(log(y) * pow(z, x), "y^z^x");
update(log(y) * x * z, "(y^x)^z");
update(log(z) * pow(x, y), "z^x^y");
update(log(z) * pow(y, x), "z^y^x");
update(log(z) * x * y, "(z^x)^y");
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double NN = -1e+300;
long double EPS = 1e-12;
long double f1(long double x, long double y, long double z) {
if (x <= 1.0) return NN;
return logl(logl(x)) + logl(y) * z;
}
long double f2(long double x, long double y, long double z) {
if (x <= 1.0) return NN;
return logl(logl(x) * y * z);
}
long double f(long double x, long double y, long double z, int t) {
switch (t) {
case 0:
return f1(x, y, z);
case 1:
return f1(x, z, y);
case 2:
return f2(x, y, z);
case 3:
return f2(x, z, y);
case 4:
return f1(y, x, z);
case 5:
return f1(y, z, x);
case 6:
return f2(y, x, z);
case 7:
return f2(y, z, x);
case 8:
return f1(z, x, y);
case 9:
return f1(z, y, x);
case 10:
return f2(z, x, y);
case 11:
return f2(z, y, x);
case 12:
if (x == 1.0) return -1e+299;
return f1(1 / x, y, z);
case 13:
if (x == 1.0) return -1e+299;
return f1(1 / x, z, y);
case 14:
if (x == 1.0) return -1e+299;
return f2(1 / x, y, z);
case 15:
if (x == 1.0) return -1e+299;
return f2(1 / x, z, y);
case 16:
if (y == 1.0) return -1e+299;
return f1(1 / y, x, z);
case 17:
if (y == 1.0) return -1e+299;
return f1(1 / y, z, x);
case 18:
if (y == 1.0) return -1e+299;
return f2(1 / y, x, z);
case 19:
if (y == 1.0) return -1e+299;
return f2(1 / y, z, x);
case 20:
if (z == 1.0) return -1e+299;
return f1(1 / z, x, y);
case 21:
if (z == 1.0) return -1e+299;
return f1(1 / z, y, x);
case 22:
if (z == 1.0) return -1e+299;
return f2(1 / z, x, y);
case 23:
if (z == 1.0) return -1e+299;
return f2(1 / z, y, x);
}
throw 1;
}
int main() {
string s[] = {
"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x",
};
long double x, y, z;
cin >> x >> y >> z;
string r = s[0];
long double w = NN;
for (int i = 0; i < 12; ++i) {
long double ww = f(x, y, z, i);
if (ww != NN && ww > w + EPS) {
w = ww;
r = s[i];
}
}
if (w == NN) {
for (int i = 0; i < 12; ++i) {
long double ww = f(x, y, z, i + 12);
if (ww != NN && -ww > w + EPS) {
w = -ww;
r = s[i];
}
}
}
cout << r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
long double mx;
int ans;
int main() {
ios::sync_with_stdio(false);
cin >> x >> y >> z;
mx = INT_MIN;
long double val;
val = pow(y, z) * log(x);
;
if (val > mx) {
mx = val;
ans = 1;
}
val = pow(z, y) * log(x);
;
if (val > mx) {
mx = val;
ans = 2;
}
val = y * z * log(x);
;
if (val > mx) {
mx = val;
ans = 3;
}
val = pow(x, z) * log(y);
;
if (val > mx) {
mx = val;
ans = 5;
}
val = pow(z, x) * log(y);
;
if (val > mx) {
mx = val;
ans = 6;
}
val = x * z * log(y);
;
if (val > mx) {
mx = val;
ans = 7;
}
val = pow(x, y) * log(z);
;
if (val > mx) {
mx = val;
ans = 9;
}
val = pow(y, x) * log(z);
;
if (val > mx) {
mx = val;
ans = 10;
}
val = x * y * log(z);
;
if (val > mx) {
mx = val;
ans = 11;
}
switch (ans) {
case 1:
cout << "x^y^z" << endl;
break;
case 2:
cout << "x^z^y" << endl;
break;
case 3:
cout << "(x^y)^z" << endl;
break;
case 5:
cout << "y^x^z" << endl;
break;
case 6:
cout << "y^z^x" << endl;
break;
case 7:
cout << "(y^x)^z" << endl;
break;
case 9:
cout << "z^x^y" << endl;
break;
case 10:
cout << "z^y^x" << endl;
break;
case 11:
cout << "(z^x)^y" << endl;
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
double maxans1, maxans2, tmp;
int main() {
double a[3];
cin >> a[0] >> a[1] >> a[2];
maxans1 = 1e30;
maxans2 = -1e30;
for (int i = 0; i < 3; ++i)
for (int method = 0; method < 2; ++method) {
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) {
if (i != j && i != k && j != k) {
double &x = a[i];
double &y = a[j];
double &z = a[k];
if (method == 0) {
if (log(x) <= 0 && z * log(y) + log(-log(x)) - maxans1 < -1e-10) {
maxans1 = z * log(y) + log(-log(x));
s1 = string(1, i + 'x') + "^" + string(1, j + 'x') + "^" +
string(1, k + 'x');
} else if (log(x) > 0 &&
z * log(y) + log(log(x)) - maxans2 > 1e-10) {
maxans2 = z * log(y) + log(log(x));
s2 = string(1, i + 'x') + "^" + string(1, j + 'x') + "^" +
string(1, k + 'x');
}
} else {
if (log(x) <= 0 &&
log(y) + log(z) + log(-log(x)) - maxans1 < -1e-10) {
maxans1 = log(y) + log(z) + log(-log(x));
s1 = "(" + string(1, i + 'x') + "^" + string(1, j + 'x') +
")^" + string(1, k + 'x');
} else if (log(x) > 0 &&
log(y) + log(z) + log(log(x)) - maxans2 > 1e-10) {
maxans2 = log(y) + log(z) + log(log(x));
s2 = "(" + string(1, i + 'x') + "^" + string(1, j + 'x') +
")^" + string(1, k + 'x');
}
}
}
}
}
if (s2 != "")
cout << s2 << endl;
else
cout << s1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
double Min, Max;
int xx, yy;
double ans[101], id[101];
double a[101], b[101];
const double eps = 1e-8;
char ch[5] = {'d', 'x', 'y', 'z'};
int dcmp(double x) { return fabs(x) <= eps ? 0 : (x > 0 ? 1 : -1); }
void Work(int i, int j, int k) {
if (dcmp(a[i] - 1.0) == 0) {
if (xx == -1) xx = i;
}
double y = a[j], z = a[k];
double tmp1 = z * log(y), tmp2 = y * log(z), tmp3 = log(y) + log(z);
ans[i] = tmp1, id[i] = 1;
if (dcmp(tmp2 - ans[i]) > 0) ans[i] = tmp2, id[i] = 2;
if (dcmp(tmp3 - ans[i]) > 0) ans[i] = tmp3, id[i] = 3;
ans[i] += log(log(a[i]));
if (dcmp(ans[i] - Max) > 0) Max = ans[i], xx = i, yy = id[i];
}
void Work2(int i, int j, int k) {
if (dcmp(a[i] - 1.0) == 0) return;
double y = b[j], z = b[k];
double tmp1 = z * log(y), tmp2 = y * log(z), tmp3 = log(y) + log(z);
ans[i] = tmp1, id[i] = 1;
if (dcmp(tmp2 - ans[i]) < 0) ans[i] = tmp2, id[i] = 2;
if (dcmp(tmp3 - ans[i]) < 0) ans[i] = tmp3, id[i] = 3;
ans[i] += log(log(a[i]));
if (dcmp(ans[i] - Min) < 0) Min = ans[i], xx = i, yy = id[i];
}
int main() {
scanf("%lf %lf %lf", &a[1], &a[2], &a[3]);
if (a[1] < 1.0 && a[2] < 1.0 && a[3] < 1.0) {
b[1] = a[1], b[2] = a[2], b[3] = a[3];
a[1] = 1.0 / a[1], a[2] = 1.0 / a[2], a[3] = 1.0 / a[3];
Min = 999999999.0, xx = 1, yy = 1;
Work2(1, 2, 3);
Work2(2, 1, 3);
Work2(3, 1, 2);
if (yy == 3) {
int idx = xx % 3 + 1, idy = (xx % 3 + 1) % 3 + 1;
if (idx > idy) swap(idx, idy);
printf("(%c^%c)^%c\n", ch[xx], ch[idx], ch[idy]);
} else {
printf("%c^", ch[xx]);
int idx = xx % 3 + 1, idy = (xx % 3 + 1) % 3 + 1;
if (idx > idy) swap(idx, idy);
if (yy == 1)
printf("%c^%c\n", ch[idx], ch[idy]);
else
printf("%c^%c\n", ch[idy], ch[idx]);
}
} else {
Max = -999999999.0, xx = -1, yy = 1;
if (a[1] >= 1.0) Work(1, 2, 3);
if (a[2] >= 1.0) Work(2, 1, 3);
if (a[3] >= 1.0) Work(3, 1, 2);
if (yy == 3) {
int idx = xx % 3 + 1, idy = (xx % 3 + 1) % 3 + 1;
if (idx > idy) swap(idx, idy);
printf("(%c^%c)^%c\n", ch[xx], ch[idx], ch[idy]);
} else {
printf("%c^", ch[xx]);
int idx = xx % 3 + 1, idy = (xx % 3 + 1) % 3 + 1;
if (idx > idy) swap(idx, idy);
if (yy == 1)
printf("%c^%c\n", ch[idx], ch[idy]);
else
printf("%c^%c\n", ch[idy], ch[idx]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char ans[9][10] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
long double a[9];
long double x, y, z;
int main() {
cin >> x >> y >> z;
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = y * z * log(x);
a[3] = pow(x, z) * log(y);
a[4] = pow(z, x) * log(y);
a[5] = x * z * log(y);
a[6] = pow(x, y) * log(z);
a[7] = pow(y, x) * log(z);
a[8] = x * y * log(z);
int ansv = 0;
for (int i = 1; i < 9; i++)
if (a[i] > a[ansv]) ansv = i;
printf("%s\n", ans[ansv]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {1, 0, 0, -1, 1, 1, -1, -1};
int dy[8] = {0, -1, 1, 0, -1, 1, -1, 1};
int main() {
double num[3];
for (int i = (0), loop_end_i = (3); i < (loop_end_i); i++)
scanf("%lf", num + i);
vector<pair<double, int>> pl, mi;
int one = -1;
double cal[12];
for (int i = (0), loop_end_i = (3); i < (loop_end_i); i++) {
double x = num[i], y = num[(i + 1) % 3], z = num[(i + 2) % 3];
vector<pair<double, int>> *vec = &pl;
if (i == 1) swap(y, z);
int rev = 1;
if (x == 1) {
if (one == -1) one = i * 4;
continue;
}
if (x < 1) {
vec = &mi;
x = 1 / x;
rev = 1;
}
vec->push_back(pair<double, int>(cal[i * 4 + 0] = z * log(y) + log(log(x)),
rev * (i * 4 + 0)));
vec->push_back(pair<double, int>(cal[i * 4 + 1] = y * log(z) + log(log(x)),
rev * (i * 4 + 1)));
vec->push_back(
pair<double, int>(cal[i * 4 + 2] = cal[i * 4 + 3] = log(y * z * log(x)),
rev * (i * 4 + 2)));
}
for (auto it = (pl).begin(); it != (pl).end(); ++it) {
}
sort((pl).begin(), (pl).end(), greater<pair<double, int>>());
sort((mi).begin(), (mi).end());
int ans;
double EPS = 1e-8;
if (pl.size()) {
double mic = pl[0].first;
for (int i = (0), loop_end_i = (12); i < (loop_end_i); i++) {
if (abs(cal[i] - mic) < EPS) {
ans = i;
break;
}
}
} else if (one != -1) {
ans = one;
} else {
double mic = mi[0].first;
for (int i = (0), loop_end_i = (12); i < (loop_end_i); i++) {
if (abs(cal[i] - mic) < EPS) {
ans = i;
break;
}
}
}
string pri[] = {
"x^y^z", "x^z^y", "(x^y)^z", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y", "(z^x)^y",
};
cout << pri[ans] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[13] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double f(long double x, long double y, long double z) {
return log(x) * pow(y, z);
}
long double g(long double x, long double y, long double z) {
return log(x) * (y * z);
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
long double val = -1.0;
int idx = -1;
if (val < f(x, y, z)) val = f(x, y, z), idx = 1;
if (val < f(x, z, y)) val = f(x, z, y), idx = 2;
if (val < g(x, y, z)) val = g(x, y, z), idx = 3;
if (val < g(x, z, y)) val = g(x, z, y), idx = 4;
if (val < f(y, x, z)) val = f(y, x, z), idx = 5;
if (val < f(y, z, x)) val = f(y, z, x), idx = 6;
if (val < g(y, x, z)) val = g(y, x, z), idx = 7;
if (val < g(y, z, x)) val = g(y, z, x), idx = 8;
if (val < f(z, x, y)) val = f(z, x, y), idx = 9;
if (val < f(z, y, x)) val = f(z, y, x), idx = 10;
if (val < g(z, x, y)) val = g(z, x, y), idx = 11;
if (val < g(z, y, x)) val = g(z, y, x), idx = 12;
cout << s[idx - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string ans[12];
long double l[12];
int main() {
ans[0] = "x^y^z";
ans[1] = "x^z^y";
ans[2] = ans[3] = "(x^y)^z";
ans[4] = "y^x^z";
ans[5] = "y^z^x";
ans[6] = ans[7] = "(y^x)^z";
ans[8] = "z^x^y";
ans[9] = "z^y^x";
ans[10] = ans[11] = "(z^x)^y";
long double x, y, z;
cin >> x >> y >> z;
l[0] = log(x) * pow(y, z);
l[1] = log(x) * pow(z, y);
l[2] = l[3] = log(x) * (y * z);
l[4] = log(y) * pow(x, z);
l[5] = log(y) * pow(z, x);
l[6] = l[7] = log(y) * (x * z);
l[8] = log(z) * pow(x, y);
l[9] = log(z) * pow(y, x);
l[10] = l[11] = log(z) * (x * y);
int mi = 0;
for (int i = 1; i < 12; i++)
if (l[i] > l[mi]) mi = i;
cout << ans[mi] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long power(long long x, long long y) {
long long t = 1;
while (y > 0) {
if (y % 2)
y -= 1, t = t * x % mod;
else
y /= 2, x = x * x % mod;
}
return t;
}
pair<pair<long double, long double>, int> a[12];
bool eq(pair<long double, long double> a, pair<long double, long double> b) {
long double x = a.first / b.first, y = b.second - a.second;
if (abs(y) > 15) return 0;
y = exp(y);
if (abs(x - y) < 1e-12)
return 1;
else
return 0;
}
int cmpl(pair<pair<long double, long double>, int> a,
pair<pair<long double, long double>, int> b) {
if (a.first.first == 0 && b.first.first == 0) return a.second < b.second;
if (a.first.first == 0) return b.first.first > 0;
if (b.first.first == 0) return a.first.first < 0;
if (a.first.first < 0 && b.first.first >= 0) return 1;
if (b.first.first < 0 && a.first.first >= 0) return 0;
if (a.first.first < 0 && b.first.first < 0) {
a.first.first *= -1;
b.first.first *= -1;
if (eq(a.first, b.first) == 1) return a.second < b.second;
return cmpl(b, a);
}
long double x = a.first.first / b.first.first,
y = b.first.second - a.first.second;
if (abs(y) > 15) {
return y > 0;
}
y = exp(y);
if (abs(x - y) <= 1e-12)
return a.second < b.second;
else
return x < y;
}
int cmp(pair<pair<long double, long double>, int> a,
pair<pair<long double, long double>, int> b) {
return cmpl(a, b);
}
string s[] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
int main() {
long double x, y, z;
double p1, p2, p3;
scanf("%lf%lf%lf", &p1, &p2, &p3);
x = p1, y = p2, z = p3;
long double lx = log(p1), ly = log(p2), lz = log(p3);
a[0] = make_pair(make_pair(-lx, z * ly), 0);
a[1] = make_pair(make_pair(-lx, y * lz), 1);
a[2] = make_pair(make_pair(-lx, lz + ly), 2);
a[3] = make_pair(make_pair(-ly, z * lx), 3);
a[4] = make_pair(make_pair(-ly, x * lz), 4);
a[5] = make_pair(make_pair(-ly, lz + lx), 5);
a[6] = make_pair(make_pair(-lz, y * lx), 6);
a[7] = make_pair(make_pair(-lz, x * ly), 7);
a[8] = make_pair(make_pair(-lz, ly + lx), 8);
for (int i = 0; i < 8; ++i)
if (abs(a[i].first.first) < 1e-9) a[i].first.first = 0;
for (int i = 0; i < 9; ++i)
for (int j = i + 1; j < 9; ++j)
if (cmp(a[i], a[j]) == 0) {
swap(a[i], a[j]);
}
cout << s[a[0].second] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[20];
long double ans[20];
long double EPS = 1e-12;
int sign(long double x) { return x < -EPS ? -1 : (x > EPS); }
int main(int argc, char const *argv[]) {
a[1] = "x^y^z";
a[2] = "x^z^y";
a[3] = "(x^y)^z";
a[4] = "(x^z)^y";
a[5] = "y^x^z";
a[6] = "y^z^x";
a[7] = "(y^x)^z";
a[8] = "(y^z)^x";
a[9] = "z^x^y";
a[10] = "z^y^x";
a[11] = "(z^x)^y";
a[12] = "(z^y)^x";
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long double x, y, z;
cin >> x >> y >> z;
ans[1] = pow(y, z) * log(x);
ans[2] = pow(z, y) * log(x);
ans[3] = y * z * log(x);
ans[4] = y * z * log(x);
ans[5] = pow(x, z) * log(y);
ans[6] = pow(z, x) * log(y);
ans[7] = x * z * log(y);
ans[8] = x * z * log(y);
ans[9] = pow(x, y) * log(z);
ans[10] = pow(y, x) * log(z);
ans[11] = y * x * log(z);
ans[12] = y * x * log(z);
long double maxi = ans[12];
int ind = 12;
for (int(i) = (11); (i) >= (1); --(i)) {
if (sign(ans[i] - maxi) >= 0) {
maxi = ans[i];
ind = i;
}
}
cout << a[ind] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i;
double x, y, z;
double a[9];
for (i = 0; i <= 8; i++) a[i] = -1e100;
char count[9][10] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
int max;
scanf("%lf%lf%lf", &x, &y, &z);
if (x <= 1 && y <= 1 && z <= 1) {
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = y * z * log(x);
a[3] = pow(x, z) * log(y);
a[4] = pow(z, x) * log(y);
a[5] = x * z * log(y);
a[6] = pow(x, y) * log(z);
a[7] = pow(y, x) * log(z);
a[8] = x * y * log(z);
} else {
if (x > 1) {
a[0] = z * log(y) + log(log(x));
a[1] = y * log(z) + log(log(x));
a[2] = log(y) + log(z) + log(log(x));
}
if (y > 1) {
a[3] = z * log(x) + log(log(y));
a[4] = x * log(z) + log(log(y));
a[5] = log(x) + log(z) + log(log(y));
}
if (z > 1) {
a[6] = y * log(x) + log(log(z));
a[7] = x * log(y) + log(log(z));
a[8] = log(x) + log(y) + log(log(z));
}
}
for (i = 1, max = 0; i <= 8; i++) {
if (a[i] > a[max] + 1e-6) max = i;
}
printf("%s\n", count[max]);
}
|
#include <bits/stdc++.h>
using namespace std;
string ans[12] = {
"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^x)^y",
};
int main() {
long double x, y, z, a[12], maxn = -1145141919810;
cin >> x >> y >> z;
if (x > 1 || y > 1 || z > 1) {
for (int i = 0; i < 12; i++) a[i] = maxn;
if (x > 1) a[0] = log10(log10(x)) + log10(y) * z;
if (x > 1) a[1] = log10(log10(x)) + log10(z) * y;
if (x > 1) a[2] = log10(log10(x)) + log10(y * z);
if (x > 1) a[3] = log10(log10(x)) + log10(y * z);
if (y > 1) a[4] = log10(log10(y)) + log10(x) * z;
if (y > 1) a[5] = log10(log10(y)) + log10(z) * x;
if (y > 1) a[6] = log10(log10(y)) + log10(x * z);
if (y > 1) a[7] = log10(log10(y)) + log10(x * z);
if (z > 1) a[8] = log10(log10(z)) + log10(x) * y;
if (z > 1) a[9] = log10(log10(z)) + log10(y) * x;
if (z > 1) a[10] = log10(log10(z)) + log10(x * y);
if (z > 1) a[11] = log10(log10(z)) + log10(x * y);
for (int i = 0; i < 12; i++) maxn = max(maxn, a[i]);
for (int i = 0; i < 12; i++)
if (maxn == a[i]) {
cout << ans[i];
return 0;
}
}
a[0] = pow(x, pow(y, z));
a[1] = pow(x, pow(z, y));
a[2] = pow(pow(x, y), z);
a[3] = pow(pow(x, z), y);
a[4] = pow(y, pow(x, z));
a[5] = pow(y, pow(z, x));
a[6] = pow(pow(y, x), z);
a[7] = pow(pow(y, z), x);
a[8] = pow(z, pow(x, y));
a[9] = pow(z, pow(y, x));
a[10] = pow(pow(z, x), y);
a[11] = pow(pow(z, y), x);
for (int i = 0; i < 12; i++) maxn = max(maxn, a[i]);
for (int i = 0; i < 12; i++)
if (maxn == a[i]) {
cout << ans[i];
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[16][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double a[12];
int main() {
double X, Y, Z;
while (scanf("%lf%lf%lf", &X, &Y, &Z) != EOF) {
long double x = X, y = Y, z = Z;
a[0] = powl(y, z) * logl(x);
a[1] = powl(z, y) * logl(x);
a[2] = z * y * logl(x);
a[3] = z * y * logl(x);
a[4] = powl(x, z) * logl(y);
a[5] = powl(z, x) * logl(y);
a[6] = z * x * logl(y);
a[7] = z * x * logl(y);
a[8] = powl(x, y) * logl(z);
a[9] = powl(y, x) * logl(z);
a[10] = x * y * logl(z);
a[11] = x * y * logl(z);
long double mx = -1e20;
int idx = 0;
for (int i = 0; i < 12; i++) {
if (mx < a[i]) mx = a[i], idx = i;
}
puts(s[idx]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double a[12];
char out[12][10] = {
"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x",
};
int main() {
double x, y, z;
while (~scanf("%lf%lf%lf", &x, &y, &z)) {
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
a[0] = logx * powl(y, z);
a[1] = logx * powl(z, y);
a[2] = logx * y * z;
a[3] = -1;
a[4] = logy * powl(x, z);
a[5] = logy * powl(z, x);
a[6] = logy * x * z;
a[7] = -1;
a[8] = logz * powl(x, y);
a[9] = logz * powl(y, x);
a[10] = logz * x * y;
a[11] = -1;
long double ans = -1;
int index = -1;
for (int i = 0; i < 12; i++) {
if (a[i] > ans && a[i] - ans >= 1e-10) {
ans = a[i];
index = i;
}
}
puts(out[index]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double INF = 1e18;
pair<long double, pair<int, string> > Cal(long double x, long double y,
long double z, string sx, string sy,
string sz, int k, int p) {
if (x < 1)
return pair<long double, pair<int, string> >(-INF,
pair<int, string>(-10000, ""));
if (x == 1)
return pair<long double, pair<int, string> >(
-1000, pair<int, string>(-p, sx + "^" + sy + "^" + sz));
pair<long double, pair<int, string> > a1 =
pair<long double, pair<int, string> >(
log(log(x)) + log(y) * z,
pair<int, string>(-p, sx + "^" + sy + "^" + sz));
pair<long double, pair<int, string> > a2 =
pair<long double, pair<int, string> >(
log(log(x)) + log(z) * y,
pair<int, string>(-p - 1, sx + "^" + sz + "^" + sy));
pair<long double, pair<int, string> > a3 =
pair<long double, pair<int, string> >(
log(log(x)) + log(y) + log(z),
pair<int, string>(-p - 2, "(" + sx + "^" + sy + ")^" + sz));
a1.first *= k;
a2.first *= k;
a3.first *= k;
return max(max(a1, a2), a3);
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
pair<long double, pair<int, string> > a1, a2, a3;
if (x >= 1 || y >= 1 || z >= 1) {
a1 = Cal(x, y, z, "x", "y", "z", 1, 1);
a2 = Cal(y, x, z, "y", "x", "z", 1, 5);
a3 = Cal(z, x, y, "z", "x", "y", 1, 9);
} else {
a1 = Cal(1 / x, y, z, "x", "y", "z", -1, 1);
a2 = Cal(1 / y, x, z, "y", "x", "z", -1, 5);
a3 = Cal(1 / z, x, y, "z", "x", "y", -1, 9);
}
cout << max(max(a1, a2), a3).second.second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = LLONG_MAX;
const long long ninf = LLONG_MIN;
const long double eps = 1e-10;
const long long N = 1000005;
const long long LOGN = log2(N);
bool check(long double x, long double y) {
return abs(x - y) < eps || abs(x - y) < eps * x;
}
int main() {
ios_base::sync_with_stdio(0);
long double x, y, z;
cin >> x >> y >> z;
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
long double ans = -11;
long double a[9];
a[0] = logx * pow(y, z);
a[1] = logx * pow(z, y);
a[2] = logx * y * z;
a[3] = logy * pow(x, z);
a[4] = logy * pow(z, x);
a[5] = logy * x * z;
a[6] = logz * pow(x, y);
a[7] = logz * pow(y, x);
a[8] = logz * x * y;
long long id;
for (int i = 0; i < 9; i++) {
if (ans < a[i]) {
ans = a[i];
id = i;
}
}
if (id == 0) {
cout << "x^y^z";
} else if (id == 1) {
cout << "x^z^y";
} else if (id == 2) {
cout << "(x^y)^z";
} else if (id == 3) {
cout << "y^x^z";
} else if (id == 4) {
cout << "y^z^x";
} else if (id == 5) {
cout << "(y^x)^z";
} else if (id == 6) {
cout << "z^x^y";
} else if (id == 7) {
cout << "z^y^x";
} else if (id == 8) {
cout << "(z^x)^y";
} else {
cout << "Fuck!!";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
string s;
long double val;
E(string ss = "", long double v = 0) {
s = ss;
val = v;
}
bool operator<(E o) const { return val > o.val; }
};
long double x, y, z;
vector<E> h;
int main() {
cin >> x >> y >> z;
if (max(max(x, y), z) > 1.01) {
if (x > 1.01) h.push_back(E("x^y^z", log(log(x)) + log(y) * z));
if (x > 1.01) h.push_back(E("x^z^y", log(log(x)) + log(z) * y));
if (x > 1.01) h.push_back(E("(x^y)^z", log(log(x)) + log(y * z)));
if (y > 1.01) h.push_back(E("y^x^z", log(log(y)) + log(x) * z));
if (y > 1.01) h.push_back(E("y^z^x", log(log(y)) + log(z) * x));
if (y > 1.01) h.push_back(E("(y^x)^z", log(log(y)) + log(z * x)));
if (z > 1.01) h.push_back(E("z^x^y", log(log(z)) + log(x) * y));
if (z > 1.01) h.push_back(E("z^y^x", log(log(z)) + log(y) * x));
if (z > 1.01) h.push_back(E("(z^x)^y", log(log(z)) + log(x * y)));
} else {
h.push_back(E("x^y^z", pow(x, pow(y, z))));
h.push_back(E("x^z^y", pow(x, pow(z, y))));
h.push_back(E("(x^y)^z", pow(x, y * z)));
h.push_back(E("y^x^z", pow(y, pow(x, z))));
h.push_back(E("y^z^x", pow(y, pow(z, x))));
h.push_back(E("(y^x)^z", pow(y, z * x)));
h.push_back(E("z^x^y", pow(z, pow(x, y))));
h.push_back(E("z^y^x", pow(z, pow(y, x))));
h.push_back(E("(z^x)^y", pow(z, x * y)));
}
stable_sort(h.begin(), h.end());
cout << h[0].s;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int inf = 1e9 + 7;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0') ch = getchar();
while (ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x;
}
long double x, y, z;
int main() {
cin >> x >> y >> z;
long double tx = log2(x), ty = log2(y), tz = log2(z);
long double ans = tx * pow(y, z);
int mj = 1;
long double res = tx * pow(z, y);
if (res > ans) {
ans = res;
mj = 2;
}
res = tx * y * z;
if (res > ans) {
ans = res;
mj = 3;
}
res = ty * pow(x, z);
if (res > ans) {
ans = res;
mj = 5;
}
res = ty * pow(z, x);
if (res > ans) {
ans = res;
mj = 6;
}
res = ty * x * z;
if (res > ans) {
ans = res;
mj = 7;
}
res = tz * pow(x, y);
if (res > ans) {
ans = res;
mj = 9;
}
res = tz * pow(y, x);
if (res > ans) {
ans = res;
mj = 10;
}
res = tz * x * y;
if (res > ans) {
ans = res;
mj = 11;
}
if (mj == 1)
puts("x^y^z");
else if (mj == 2)
puts("x^z^y");
else if (mj == 3)
puts("(x^y)^z");
else if (mj == 5)
puts("y^x^z");
else if (mj == 6)
puts("y^z^x");
else if (mj == 7)
puts("(y^x)^z");
else if (mj == 9)
puts("z^x^y");
else if (mj == 10)
puts("z^y^x");
else
puts("(z^x)^y");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str[10] = {"", "x^y^z", "x^z^y", "(x^y)^z", "y^x^z",
"y^z^x", "(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
long double a[11];
long double mx, x, y, z;
int m;
int main() {
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
cin >> x >> y >> z;
a[1] = log(x) * pow(y, z);
a[2] = log(x) * pow(z, y);
a[3] = y * z * log(x);
a[4] = log(y) * pow(x, z);
a[5] = log(y) * pow(z, x);
a[6] = x * z * log(y);
a[7] = log(z) * pow(x, y);
a[8] = log(z) * pow(y, x);
a[9] = x * y * log(z);
mx = a[1];
m = 1;
for (int i = 1; i <= 9; i++) {
if (a[i] > mx) {
mx = a[i];
m = i;
}
}
cout << str[m] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
string ans[] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
long double a[13];
int main() {
cin >> x >> y >> z;
a[1] = pow(y, z) * log(x);
a[2] = pow(z, y) * log(x);
a[3] = y * z * log(x);
a[4] = a[3];
a[5] = pow(x, z) * log(y);
a[6] = pow(z, x) * log(y);
a[7] = x * z * log(y);
a[8] = a[7];
a[9] = pow(x, y) * log(z);
a[10] = pow(y, x) * log(z);
a[11] = x * y * log(z);
a[12] = a[11];
int flag = 1;
long double MAX = a[1];
for (int i = 2; i <= 12; i++)
if (MAX < a[i]) {
MAX = a[i];
flag = i;
}
cout << ans[flag] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
long double x, y, z;
struct muielacomisie {
long double val;
int index;
string s;
muielacomisie(long double val, int index, string s) {
this->val = val;
this->index = index;
this->s = s;
}
};
bool cmp(muielacomisie a, muielacomisie b) {
if (fabs(a.val - b.val) < eps) return a.index < b.index;
return a.val > b.val;
}
vector<muielacomisie> v;
int main() {
cin.sync_with_stdio(false);
cin >> x >> y >> z;
v.push_back(muielacomisie(pow(y, z) * log10(x), 1, "x^y^z"));
v.push_back(muielacomisie(pow(z, y) * log10(x), 2, "x^z^y"));
v.push_back(muielacomisie(y * z * log10(x), 3, "(x^y)^z"));
v.push_back(muielacomisie(pow(x, z) * log10(y), 5, "y^x^z"));
v.push_back(muielacomisie(pow(z, x) * log10(y), 6, "y^z^x"));
v.push_back(muielacomisie(x * z * log10(y), 7, "(y^x)^z"));
v.push_back(muielacomisie(pow(x, y) * log10(z), 9, "z^x^y"));
v.push_back(muielacomisie(pow(y, x) * log10(z), 10, "z^y^x"));
v.push_back(muielacomisie(x * y * log10(z), 11, "(z^x)^y"));
sort(v.begin(), v.end(), cmp);
cout << v[0].s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z;
cin >> x >> y >> z;
double arr[12];
fill(arr, arr + 12, INT_MIN);
bool flag = false;
if (x <= 1 and y <= 1 and z <= 1) flag = 1;
if (x >= 1) {
if (x == 1)
arr[0] = arr[1] = arr[2] = arr[3] = INT_MIN;
else {
arr[0] = log(log(x)) + z * log(y);
arr[1] = log(log(x)) + y * log(z);
arr[2] = log(log(x)) + log(y) + log(z);
arr[3] = log(log(x)) + log(y) + log(z);
}
}
if (x < 1 and flag) {
arr[0] = log(log(1 / x)) + z * log(y);
arr[1] = log(log(1 / x)) + y * log(z);
arr[2] = log(log(1 / x)) + log(y) + log(z);
arr[3] = log(log(1 / x)) + log(y) + log(z);
}
if (y >= 1) {
if (y == 1)
arr[4] = arr[5] = arr[6] = arr[7] = INT_MIN;
else {
arr[4] = log(log(y)) + z * log(x);
arr[5] = log(log(y)) + x * log(z);
arr[6] = log(log(y)) + log(z) + log(x);
arr[7] = log(log(y)) + log(z) + log(x);
}
}
if (y < 1 and flag) {
arr[4] = log(log(1 / y)) + z * log(x);
arr[5] = log(log(1 / y)) + x * log(z);
arr[6] = log(log(1 / y)) + log(z) + log(x);
arr[7] = log(log(1 / y)) + log(z) + log(x);
}
if (z >= 1) {
if (z == 1)
arr[8] = arr[9] = arr[10] = arr[11] = INT_MIN;
else {
arr[8] = log(log(z)) + y * log(x);
arr[9] = log(log(z)) + x * log(y);
arr[10] = log(log(z)) + log(x) + log(y);
arr[11] = log(log(z)) + log(x) + log(y);
}
}
if (z < 1 and flag) {
arr[8] = log(log(1 / z)) + y * log(x);
arr[9] = log(log(1 / z)) + x * log(y);
arr[10] = log(log(1 / z)) + log(x) + log(y);
arr[11] = log(log(1 / z)) + log(x) + log(y);
}
map<double, string> m;
m[0] = "x^y^z";
m[1] = "x^z^y";
m[2] = "(x^y)^z";
m[3] = "(x^z)^y";
m[4] = "y^x^z";
m[5] = "y^z^x";
m[6] = "(y^x)^z";
m[7] = "(y^z)^x";
m[8] = "z^x^y";
m[9] = "z^y^x";
m[10] = "(z^x)^y";
m[11] = "(z^y)^x";
int ans = -1;
double maximum = -(1e12);
double minimum = 1e12;
for (int i = 0; i < 12; ++i)
if (flag) {
if (arr[i] < minimum) {
minimum = arr[i];
ans = i;
}
} else {
if (arr[i] > maximum) {
maximum = arr[i];
ans = i;
}
}
cout << m[ans] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long double, string> > v;
void f1(long double x, long double y, long double z, string s) {
v.push_back(make_pair(pow(y, z) * log(x), s));
}
void f2(long double x, long double y, long double z, string s) {
v.push_back(make_pair(z * y * log(x), s));
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
f1(x, y, z, "x^y^z");
f1(x, z, y, "x^z^y");
f2(x, y, z, "(x^y)^z");
f2(x, z, y, "(x^z)^y");
f1(y, x, z, "y^x^z");
f1(y, z, x, "y^z^x");
f2(y, x, z, "(y^x)^z");
f2(y, z, x, "(y^z)^x");
f1(z, x, y, "z^x^y");
f1(z, y, x, "z^y^x");
f2(z, x, y, "(z^x)^y");
f2(z, y, x, "(z^y)^x");
long double mn = v[0].first;
int ind = 0;
for (int i = 0; i < v.size(); i++)
if (mn < v[i].first) mn = v[i].first, ind = i;
cout << v[ind].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double mx, temp;
string res;
void Update(long double value, string s) {
if (value - mx > 1e-10) {
mx = value;
res = s;
}
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
mx = log(x) * pow(y, z);
res = "x^y^z";
Update(log(x) * pow(z, y), "x^z^y");
Update(log(x) * y * z, "(x^y)^z");
Update(log(x) * y * z, "(x^z)^y");
Update(log(y) * pow(x, z), "y^x^z");
Update(log(y) * pow(z, x), "y^z^x");
Update(log(y) * x * z, "(y^x)^z");
Update(log(y) * x * z, "(y^z)^x");
Update(log(z) * pow(x, y), "z^x^y");
Update(log(z) * pow(y, x), "z^y^x");
Update(log(z) * x * y, "(z^x)^y");
Update(log(z) * x * y, "(z^y)^x");
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(long double a, long double b) {
if (abs(a - b) < 1e-9) return 0;
if (a > b) return 0;
if (b > a) return 1;
}
int main() {
ios::sync_with_stdio(false);
string ans[9];
long double a, b, c;
long double val[9];
cin >> a >> b >> c;
ans[0] = "x^y^z";
ans[1] = "x^z^y";
ans[2] = "(x^y)^z";
ans[3] = "y^x^z";
ans[4] = "y^z^x";
ans[5] = "(y^x)^z";
ans[6] = "z^x^y";
ans[7] = "z^y^x";
ans[8] = "(z^x)^y";
val[0] = pow(b, c) * log10(a);
val[1] = pow(c, b) * log10(a);
val[2] = b * c * log10(a);
val[3] = pow(a, c) * log10(b);
val[4] = pow(c, a) * log10(b);
val[5] = a * c * log10(b);
val[6] = pow(a, b) * log10(c);
val[7] = pow(b, a) * log10(c);
val[8] = b * a * log10(c);
int id = 0;
for (int i = 1; i < 9; i++) {
int gg = compare(val[id], val[i]);
if (gg == 1) {
id = i;
}
}
cout << ans[id] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4010;
const char s[12][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double a[12];
long double x, y, z;
cin >> x >> y >> z;
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = a[3] = y * z * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = a[7] = x * z * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = a[11] = x * y * log(z);
int pos = 0;
for (int i = 1; i <= 11; i++) {
if (a[i] > a[pos]) pos = i;
}
printf("%s\n", s[pos]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double a[15];
long double x, y, z;
const long double eps = 1e-8;
char ans[12][15] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
cin >> x >> y >> z;
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
a[0] = powl(y, z) * logx;
a[1] = powl(z, y) * logx;
a[2] = y * z * logx;
a[3] = -1;
a[4] = powl(x, z) * logy;
a[5] = powl(z, x) * logy;
a[6] = x * z * logy;
a[7] = -1;
a[8] = powl(x, y) * logz;
a[9] = powl(y, x) * logz;
a[10] = x * y * logz;
a[11] = -1;
long double anss = a[0];
int idx = 0;
for (int i = 1; i < 12; i++) {
if (!fabs(anss - a[i]) < eps && a[i] > anss) {
anss = a[i];
idx = i;
}
}
printf("%s\n", ans[idx]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool eq(const long double &x, const long double &y) {
return abs(x - y) < 1e-18;
}
int main() {
const string ans[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double x, y, z;
cin >> x >> y >> z;
long double a[12];
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = z * y * log(x);
a[3] = a[2];
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = z * x * log(y);
a[7] = a[6];
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = y * x * log(z);
a[11] = a[10];
long double ma = -0x3f3f3f3f;
int p = 0;
for (int i = 0; i < 12; i++) {
if (!eq(a[i], ma) && a[i] > ma) {
ma = a[i];
p = i;
}
}
cout << ans[p] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const int INF = 1e9 + 10;
const double EPS = 1e-10;
long double x, y, z;
long double f1(long double x, long double y, long double z) {
return pow(y, z) * log(x);
}
long double f2(long double x, long double y, long double z) {
return y * z * log(x);
}
struct Node {
long double v;
int id;
friend bool operator<(Node A, Node B) {
if (A.v > B.v + EPS) return 1;
if (fabs(A.v - B.v) < EPS) return A.id < B.id;
return 0;
}
};
Node a[20];
int n;
const string s[14] = {
"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x",
};
int main() {
while (cin >> x >> y >> z) {
n = 12;
for (int i = 1; i <= n; i++) a[i].id = i;
a[1].v = f1(x, y, z);
a[2].v = f1(x, z, y);
a[3].v = f2(x, y, z);
a[4].v = f2(x, z, y);
a[5].v = f1(y, x, z);
a[6].v = f1(y, z, x);
a[7].v = f2(y, x, z);
a[8].v = f2(y, z, x);
a[9].v = f1(z, x, y);
a[10].v = f1(z, y, x);
a[11].v = f2(z, x, y);
a[12].v = f2(z, y, x);
sort(a + 1, a + n + 1);
if (a[1].id == 4 || a[1].id == 8 || a[1].id == 12) a[1].id--;
cout << s[a[1].id] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int SIZE = 3e5 + 5;
const long long INF = 1LL << 55;
const long double eps = 1e-20;
long double v[9];
string s[9] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
int main() {
long double x, y, z;
cin >> x >> y >> z;
if (x <= 1.1 && y <= 1.1 && z <= 1.1) {
v[0] = pow(x, pow(y, z));
v[1] = pow(x, pow(z, y));
v[2] = pow(x, y * z);
v[3] = pow(y, pow(x, z));
v[4] = pow(y, pow(z, x));
v[5] = pow(y, x * z);
v[6] = pow(z, pow(x, y));
v[7] = pow(z, pow(y, x));
v[8] = pow(z, x * y);
} else {
if (x > 1) {
v[0] = z * log2(y) + log2(log2(x));
v[1] = y * log2(z) + log2(log2(x));
v[2] = log2(y) + log2(z) + log2(log2(x));
} else
v[0] = v[1] = v[2] = -INF;
if (y > 1) {
v[3] = z * log2(x) + log2(log2(y));
v[4] = x * log2(z) + log2(log2(y));
v[5] = log2(x) + log2(z) + log2(log2(y));
} else
v[3] = v[4] = v[5] = -INF;
if (z > 1) {
v[6] = y * log2(x) + log2(log2(z));
v[7] = x * log2(y) + log2(log2(z));
v[8] = log2(x) + log2(y) + log2(log2(z));
} else
v[6] = v[7] = v[8] = -INF;
}
long double cm = -1LL << 60;
for (int i = 0; i < (9); ++i) cm = max(cm, v[i]);
for (int i = 0; i < (9); ++i) {
if (abs(cm - v[i]) <= eps) {
printf("%s", s[i].c_str());
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const char ans[13][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double cal(int op, long double x, long double y, long double z) {
long double res = 0;
switch (op) {
case 0:
res = pow(y, z) * log(x);
break;
case 1:
res = pow(z, y) * log(x);
break;
case 2:
case 3:
res = y * z * log(x);
break;
case 4:
res = pow(x, z) * log(y);
break;
case 5:
res = pow(z, x) * log(y);
break;
case 6:
case 7:
res = x * z * log(y);
break;
case 8:
res = pow(x, y) * log(z);
break;
case 9:
res = pow(y, x) * log(z);
break;
case 10:
case 11:
res = x * y * log(z);
break;
}
return res;
}
int main() {
long double a, b, c;
cin >> a >> b >> c;
long double res = cal(0, a, b, c);
int cur = 0;
for (int i = 1; i < 12; ++i) {
long double val = cal(i, a, b, c);
if (res < val) {
res = val;
cur = i;
}
}
cout << ans[cur] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1.01e9;
const long double EPS = 1e-9;
const long double PI = acos(-1.0L);
void precalc() {}
long double x, y, z;
bool read() {
double _x, _y, _z;
if (scanf("%lf%lf%lf", &_x, &_y, &_z) < 3) {
return 0;
}
x = _x, y = _y, z = _z;
return 1;
}
long double xs[3];
int perm[3];
int sign(long double x) { return x < -EPS ? -1 : x > EPS; }
pair<int, long double> getValue(int perm[3], int type) {
int first = 0;
if (!type) {
long double value = log(xs[perm[0]]);
first = sign(value);
if (!first) {
return make_pair(0, 0);
}
value *= first;
value = log(value) + log(xs[perm[1]]) * xs[perm[2]];
return make_pair(first, first * value);
} else {
long double value = log(xs[perm[0]]) * xs[perm[1]] * xs[perm[2]];
first = sign(value);
if (!first) {
return make_pair(0, 0);
}
value *= first;
value = log(value);
return make_pair(first, first * value);
}
}
void solve() {
xs[0] = x, xs[1] = y, xs[2] = z;
for (int i = 0; i < 3; ++i) {
perm[i] = i;
}
pair<int, long double> res(-1e9, 0);
string ans = "NO";
for (int iter = 0; iter < 3; ++iter) {
perm[0] = iter;
for (int i = 0, p = 1; i < 3; ++i) {
if (i == iter) {
continue;
}
perm[p++] = i;
}
for (int type = 0; type < 2; ++type) {
for (int rot = 0; rot < 2; ++rot) {
auto value = getValue(perm, type);
if ((res.first < value.first) ||
(res.first == value.first && res.second < value.second - EPS)) {
res = value;
ans = "";
if (type) {
ans += "(";
}
for (int i = 0; i < 3; ++i) {
if (i) {
ans += "^";
}
ans += (char)('x' + perm[i]);
if (type && i == 1) {
ans += ")";
}
}
}
swap(perm[1], perm[2]);
}
}
}
printf("%s\n", ans.c_str());
}
int main() {
srand(rdtsc());
precalc();
while (1) {
if (!read()) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double mx, tmp;
string res;
void Update(long double value, string s) {
if (value - mx > 1e-10) {
mx = value;
res = s;
}
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
mx = log(x) * pow(y, z);
res = "x^y^z";
Update(log(x) * pow(z, y), "x^z^y");
Update(log(x) * y * z, "(x^y)^z");
Update(log(x) * y * z, "(x^z)^y");
Update(log(y) * pow(x, z), "y^x^z");
Update(log(y) * pow(z, x), "y^z^x");
Update(log(y) * x * z, "(y^x)^z");
Update(log(y) * x * z, "(y^z)^x");
Update(log(z) * pow(x, y), "z^x^y");
Update(log(z) * pow(y, x), "z^y^x");
Update(log(z) * x * y, "(z^x)^y");
Update(log(z) * x * y, "(z^y)^x");
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const char s[12][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double a[12];
long double x, y, z;
int n = 0;
cin >> x >> y >> z;
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = y * z * log(x);
a[3] = z * y * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = x * z * log(y);
a[7] = z * x * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = x * y * log(z);
a[11] = y * x * log(z);
for (int i = 1; i <= 12; i++) {
if (a[i] > a[n]) n = i;
}
cout << s[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
const int INF = 1e9 + 7;
const double eps = 1e-10;
int N, M, T = INF, Cases = 0;
struct node {
double val;
bool nan;
string disc;
int num;
bool operator<(const node &A) const {
if (nan) {
if (A.nan)
return num < A.num;
else
return false;
}
if (A.nan) return true;
return val - A.val > eps || abs(val - A.val) < eps && num < A.num;
}
} a[MAXN];
double x, y, z;
int main() {
while (T-- && ~(scanf("%lf%lf%lf", &x, &y, &z))) {
for (int i = 0; i <= 12; i++) a[i].num = i, a[i].nan = false;
;
bool an = false;
if (x <= 1 && y <= 1 && z <= 1) an = true;
if (an)
a[1].val = pow(x, pow(y, z));
else if (x <= 1)
a[1].nan = true;
else
a[1].val = z * log(y) + log(log(x));
a[1].disc = "x^y^z";
if (an)
a[2].val = pow(x, pow(z, y));
else if (x <= 1)
a[2].nan = true;
else
a[2].val = y * log(z) + log(log(x));
a[2].disc = "x^z^y";
if (an)
a[3].val = pow(pow(x, y), z);
else if (x <= 1)
a[3].nan = true;
else
a[3].val = log(z * y * log(x));
a[3].disc = "(x^y)^z";
if (an)
a[4].val = pow(pow(x, z), y);
else if (x <= 1)
a[4].nan = true;
else
a[4].val = log(z * y * log(x));
a[4].disc = "(x^z)^y";
if (an)
a[5].val = pow(y, pow(x, z));
else if (y <= 1)
a[5].nan = true;
else
a[5].val = z * log(x) + log(log(y));
a[5].disc = "y^x^z";
if (an)
a[6].val = pow(y, pow(z, x));
else if (y <= 1)
a[6].nan = true;
else
a[6].val = x * log(z) + log(log(y));
a[6].disc = "y^z^x";
if (an)
a[7].val = pow(pow(y, x), z);
else if (y <= 1)
a[7].nan = true;
else
a[7].val = log(z * x * log(y));
a[7].disc = "(y^x)^z";
if (an)
a[8].val = pow(pow(y, z), x);
else if (y <= 1)
a[8].nan = true;
else
a[8].val = log(z * x * log(y));
a[8].disc = "(y^z)^x";
if (an)
a[9].val = pow(z, pow(x, y));
else if (z <= 1)
a[9].nan = true;
else
a[9].val = y * log(x) + log(log(z));
a[9].disc = "z^x^y";
if (an)
a[10].val = pow(z, pow(y, x));
else if (z <= 1)
a[10].nan = true;
else
a[10].val = x * log(y) + log(log(z));
a[10].disc = "z^y^x";
if (an)
a[11].val = pow(pow(z, x), y);
else if (z <= 1)
a[11].nan = true;
else
a[11].val = log(y * x * log(z));
a[11].disc = "(z^x)^y";
if (an)
a[12].val = pow(pow(z, y), x);
else if (z <= 1)
a[12].nan = true;
else
a[12].val = log(y * x * log(z));
a[12].disc = "(z^y)^x";
sort(a + 1, a + 13);
puts(a[1].disc.c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[50] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double x, y, z, a[12], max = 0;
int res;
cin >> x >> y >> z;
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = a[3] = z * y * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = a[7] = z * x * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = a[11] = x * y * log(z);
max = a[0];
res = 0;
for (int i = 1; i <= 11; ++i) {
if (max < a[i]) {
max = a[i];
res = i;
}
}
cout << s[res] << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (((a * b) / gcd(a, b))); }
long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
}
if (n > 1) result -= result / n;
return result;
}
long long binpow(long long a, long long n, long long c) {
long long res = 1;
while (n) {
if (n & 1) res *= a;
res %= c;
a *= a;
a %= c;
n >>= 1;
}
res = (res + c) % c;
return res;
}
void nxi(int& n) {
bool min = 0;
char c;
n = 0;
while ((c = getc(stdin)) && c <= 32)
;
if (c == '-')
min = 1;
else
n = c - 48;
while ((c = getc(stdin)) && c > 32) n = (n << 3) + (n << 1) + c - 48;
if (min) n = -n;
}
void prl(int n) {
if (n == 0) {
puts("0");
return;
}
if (n < 0) {
putchar('-');
n = -n;
}
static int s[10];
int top = 0;
while (n > 0) s[top++] = n % 10, n /= 10;
while (top--) putchar(s[top] + 48);
puts("");
}
using namespace std;
const int nmax = 1000010;
int n, a[nmax], b[nmax];
vector<pair<long double, long double> > v;
long double x, y, z;
long double calc(int n) {
if (n == 1) return pow(y, z) * log(x);
if (n == 2) return pow(z, y) * log(x);
if (n == 3) return y * z * log(x);
if (n == 4) return z * y * log(x);
if (n == 5) return pow(x, z) * log(y);
if (n == 6) return pow(z, x) * log(y);
if (n == 7) return x * z * log(y);
if (n == 8) return z * x * log(y);
if (n == 9) return pow(x, y) * log(z);
if (n == 10) return pow(y, x) * log(z);
if (n == 11) return x * y * log(z);
if (n == 12) return y * x * log(z);
}
long double calc2(int n) {
if (n == 1) return z * log(y) + log(log(x));
if (n == 2) return y * log(z) + log(log(x));
if (n == 3) return log(y) + log(z) + log(log(x));
if (n == 4) return log(z) + log(y) + log(log(x));
if (n == 5) return z * log(x) + log(log(y));
if (n == 6) return x * log(z) + log(log(y));
if (n == 7) return log(x) + log(z) + log(log(y));
if (n == 8) return log(z) + log(x) + log(log(y));
if (n == 9) return y * log(x) + log(log(z));
if (n == 10) return x * log(y) + log(log(z));
if (n == 11) return log(x) + log(y) + log(log(z));
if (n == 12) return log(y) + log(x) + log(log(z));
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(0);
cin >> x >> y >> z;
for (int i = 1; i <= 12; i++) v.push_back(make_pair(calc(i), -i));
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int num = -v[0].second;
if (num == 1)
puts("x^y^z");
else if (num == 2)
puts("x^z^y");
else if (num == 3)
puts("(x^y)^z");
else if (num == 4)
puts("(x^z)^y");
else if (num == 5)
puts("y^x^z");
else if (num == 6)
puts("y^z^x");
else if (num == 7)
puts("(y^x)^z");
else if (num == 8)
puts("(y^z)^x");
else if (num == 9)
puts("z^x^y");
else if (num == 10)
puts("z^y^x");
else if (num == 11)
puts("(z^x)^y");
else
puts("(z^y)^x");
return 0;
}
|
#include <bits/stdc++.h>
float a1(float x, float y, float z) {
if (x >= 1.0)
return z * log(y) + log(log(x));
else if (x < 1.0 && y < 1.0 && z < 1.0)
return z * log(y) + log(log(1 / x));
else
return 0.0 / 0.0;
}
float a2(float x, float y, float z) {
if (x >= 1.0)
return log(z) + log(y) + log(log(x));
else if (x < 1.0 && y < 1.0 && z < 1.0)
return log(z) + log(y) + log(log(1 / x));
else
return 0.0 / 0.0;
}
int main() {
float x, y, z;
scanf("%f %f %f", &x, &y, &z);
float a[12];
char pat[12][10] = {"x^y^z\0", "x^z^y\0", "(x^y)^z\0", "(x^z)^y\0",
"y^x^z\0", "y^z^x\0", "(y^x)^z\0", "(y^z)^x\0",
"z^x^y\0", "z^y^x\0", "(z^x)^y\0", "(z^y)^x\0"};
a[0] = a1(x, y, z);
a[1] = a1(x, z, y);
a[2] = a2(x, y, z);
a[3] = a2(x, z, y);
a[4] = a1(y, x, z);
a[5] = a1(y, z, x);
a[6] = a2(y, x, z);
a[7] = a2(y, z, x);
a[8] = a1(z, x, y);
a[9] = a1(z, y, x);
a[10] = a2(z, x, y);
a[11] = a2(z, y, x);
float ans;
int pos, i;
if (x >= 1.0) {
ans = a[0];
pos = 0;
} else if (y >= 1.0) {
ans = a[4];
pos = 4;
} else {
ans = a[8];
pos = 8;
}
if (x < 1 && y < 1 && z < 1) {
for (i = 11; i >= 0; --i) {
if (a[i] <= ans) {
ans = a[i];
pos = i;
}
}
} else {
for (i = 11; i >= 0; --i) {
if (a[i] >= ans) {
ans = a[i];
pos = i;
}
}
}
printf("%s", pat[pos]);
return 0;
}
|
#include <bits/stdc++.h>
const int MAX = 1e5 + 11;
using namespace std;
const int MOD = (const int)(1e9 + 7);
const int INF = (const int)1e9;
static double f(double x, double y, double z) {
double r = z * log(y) + log(log(x));
return isfinite(r) ? r : -INF;
}
static double g(double x, double y, double z) {
double r = log(z) + log(y) + log(log(x));
return isfinite(r) ? r : -INF;
}
static bool cmd(const pair<pair<double, int>, string> &a,
const pair<pair<double, int>, string> &b) {
if (a.first.first > b.first.first) {
return true;
}
if (fabs(a.first.first - b.first.first) < 0.00000001) {
return a.first.second < b.first.second;
}
return false;
}
static void solve(int test) {
double x, y, z;
scanf("%lf %lf %lf", &x, &y, &z);
bool was = false;
if (x <= 1 && y <= 1 && z <= 1) {
was = true;
if (x < 1) x *= 100000;
if (y < 1) y *= 100000;
if (z < 1) z *= 100000;
}
vector<pair<pair<double, int>, string>> all;
all.push_back({{f(x, y, z), 0}, "x^y^z"});
all.push_back({{f(x, z, y), 1}, "x^z^y"});
all.push_back({{g(x, y, z), 2}, "(x^y)^z"});
all.push_back({{g(x, z, y), 3}, "(x^z)^y"});
all.push_back({{f(y, x, z), 4}, "y^x^z"});
all.push_back({{f(y, z, x), 5}, "y^z^x"});
all.push_back({{g(y, x, z), 6}, "(y^x)^z"});
all.push_back({{g(y, z, x), 7}, "(y^z)^x"});
all.push_back({{f(z, x, y), 8}, "z^x^y"});
all.push_back({{f(z, y, x), 9}, "z^y^x"});
all.push_back({{g(z, x, y), 10}, "(z^x)^y"});
all.push_back({{g(z, y, x), 11}, "(z^y)^x"});
if (was) {
int idx = 0;
for (int i = 1; i < all.size(); ++i) {
if (all[i].first.first < all[idx].first.first) {
idx = i;
} else if (fabs(all[i].first.first < all[idx].first.first) < 0.000001 &&
all[i].first.second < all[idx].first.second) {
idx = i;
}
}
printf("%s", all[idx].second.c_str());
} else {
sort(all.begin(), all.end(), cmd);
printf("%s", all.front().second.c_str());
}
}
int main() {
ios_base::sync_with_stdio(0);
solve(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double loglog(long double x, long double y, long double z) {
return z * log(y) + log(log(x));
}
long double loglog1(long double x, long double y, long double z) {
return log(y) + log(z) + log(log(x));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long double x, y, z, val = -1000000000000000000;
cin >> x >> y >> z;
int side;
if (x < 1 && y < 1 && z < 1)
side = -1;
else if (x > 1 && y > 1 && z > 1)
side = 1;
else
side = 0;
int ind;
if (side == 1) {
if (val < loglog(x, y, z)) {
ind = 1;
val = loglog(x, y, z);
}
if (val < loglog(x, z, y)) {
ind = 2;
val = loglog(x, z, y);
}
if (val < loglog1(x, y, z)) {
ind = 3;
val = loglog1(x, y, z);
}
if (val < loglog(y, x, z)) {
ind = 5;
val = loglog(y, x, z);
}
if (val < loglog(y, z, x)) {
ind = 6;
val = loglog(y, z, x);
}
if (val < loglog1(y, x, z)) {
ind = 7;
val = loglog1(y, x, z);
}
if (val < loglog(z, x, y)) {
ind = 9;
val = loglog(z, x, y);
}
if (val < loglog(z, y, x)) {
ind = 10;
val = loglog(z, y, x);
}
if (val < loglog1(z, x, y)) {
ind = 11;
val = loglog1(z, x, y);
}
}
if (side == 0) {
if (x > 1) {
if (val < loglog(x, y, z)) {
ind = 1;
val = loglog(x, y, z);
}
if (val < loglog(x, z, y)) {
ind = 2;
val = loglog(x, z, y);
}
if (val < loglog1(x, y, z)) {
ind = 3;
val = loglog1(x, y, z);
}
}
if (y > 1) {
if (val < loglog(y, x, z)) {
ind = 5;
val = loglog(y, x, z);
}
if (val < loglog(y, z, x)) {
ind = 6;
val = loglog(y, z, x);
}
if (val < loglog1(y, x, z)) {
ind = 7;
val = loglog1(y, x, z);
}
}
if (z > 1) {
if (val < loglog(z, x, y)) {
ind = 9;
val = loglog(z, x, y);
}
if (val < loglog(z, y, x)) {
ind = 10;
val = loglog(z, y, x);
}
if (val < loglog1(z, x, y)) {
ind = 11;
val = loglog1(z, x, y);
}
}
if (max(x, max(y, z)) == 1) {
if (x == 1) {
ind = 1;
val = 1;
}
if (y == 1 && val < 1) {
ind = 5;
val = 1;
}
if (z == 1 && val < 1) {
ind = 9;
val = 1;
}
}
}
if (side == -1) {
val = 1000000000000000000;
x = 1 / x;
if (val > loglog(x, y, z)) {
ind = 1;
val = loglog(x, y, z);
}
if (val > loglog(x, z, y)) {
ind = 2;
val = loglog(x, z, y);
}
if (val > loglog1(x, y, z)) {
ind = 3;
val = loglog1(x, y, z);
}
x = 1 / x;
y = 1 / y;
if (val > loglog(y, x, z)) {
ind = 5;
val = loglog(y, x, z);
}
if (val > loglog(y, z, x)) {
ind = 6;
val = loglog(y, z, x);
}
if (val > loglog1(y, x, z)) {
ind = 7;
val = loglog1(y, x, z);
}
y = 1 / y;
z = 1 / z;
if (val > loglog(z, x, y)) {
ind = 9;
val = loglog(z, x, y);
}
if (val > loglog(z, y, x)) {
ind = 10;
val = loglog(z, y, x);
}
if (val > loglog1(z, x, y)) {
ind = 11;
val = loglog1(z, x, y);
}
z = 1 / z;
}
if (ind == 1) {
cout << "x^y^z" << endl;
}
if (ind == 2) {
cout << "x^z^y" << endl;
}
if (ind == 3) {
cout << "(x^y)^z" << endl;
}
if (ind == 5) {
cout << "y^x^z" << endl;
}
if (ind == 6) {
cout << "y^z^x" << endl;
}
if (ind == 7) {
cout << "(y^x)^z" << endl;
}
if (ind == 9) {
cout << "z^x^y" << endl;
}
if (ind == 10) {
cout << "z^y^x" << endl;
}
if (ind == 11) {
cout << "(z^x)^y" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<bool, long double>, string> a[13];
bool comp(pair<pair<bool, long double>, string> a,
pair<pair<bool, long double>, string> b) {
auto t1 = a.first, t2 = b.first;
if (t1.first != t2.first) return t1.first;
if (abs(t1.second - t2.second) <= 1e-6) return false;
return (t1.second < t2.second) ^ t1.first;
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
a[1] = {{x < 1, z * log10(y) + (x < 1 ? log10(-log10(x)) : log10(log10(x)))},
"x^y^z"};
a[2] = {{x < 1, y * log10(z) + (x < 1 ? log10(-log10(x)) : log10(log10(x)))},
"x^z^y"};
a[3] = {{x < 1, log10(y * z) + (x < 1 ? log10(-log10(x)) : log10(log10(x)))},
"(x^y)^z"};
a[4] = {{x < 1, log10(y * z) + (x < 1 ? log10(-log10(x)) : log10(log10(x)))},
"(x^z)^y"};
a[5] = {{y < 1, z * log10(x) + (y < 1 ? log10(-log10(y)) : log10(log10(y)))},
"y^x^z"};
a[6] = {{y < 1, x * log10(z) + (y < 1 ? log10(-log10(y)) : log10(log10(y)))},
"y^z^x"};
a[7] = {{y < 1, log10(z * x) + (y < 1 ? log10(-log10(y)) : log10(log10(y)))},
"(y^x)^z"};
a[8] = {{y < 1, log10(z * x) + (y < 1 ? log10(-log10(y)) : log10(log10(y)))},
"(y^z)^x"};
a[9] = {{z < 1, y * log10(x) + (z < 1 ? log10(-log10(z)) : log10(log10(z)))},
"z^x^y"};
a[10] = {{z < 1, x * log10(y) + (z < 1 ? log10(-log10(z)) : log10(log10(z)))},
"z^y^x"};
a[11] = {{z < 1, log10(y * x) + (z < 1 ? log10(-log10(z)) : log10(log10(z)))},
"(z^x)^y"};
a[12] = {{z < 1, log10(y * x) + (z < 1 ? log10(-log10(z)) : log10(log10(z)))},
"(z^y)^x"};
int ind = 1;
for (int i = 2; i <= 12; i++) ind = (comp(a[ind], a[i]) ? i : ind);
cout << a[ind].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
pair<complex<double>, pair<int, string> > eval[11];
int get(complex<double> x, complex<double> y) {
if (x.imag() == 0 && y.imag() == 0)
return x.real() > y.real();
else if (x.imag() != 0 && y.imag() == 0)
return false;
else if (x.imag() == 0 && y.imag() != 0)
return true;
else if (x.imag() != 0 && y.imag() != 0)
return x.real() < y.real();
return 0;
}
bool compare(pair<complex<double>, pair<int, string> > a,
pair<complex<double>, pair<int, string> > b) {
int x = get(a.first, b.first);
if (x != 0) return x > 0;
return a.second.first < b.second.first;
}
int main() {
double a, b, c;
cin >> a >> b >> c;
complex<double> x(a, 0), y(b, 0), z(c, 0);
eval[0].first = z * log(y) + log(log(x));
eval[0].second.second = "x^y^z";
eval[1].first = y * log(z) + log(log(x));
eval[1].second.second = "x^z^y";
eval[2].first = log(z * y) + log(log(x));
eval[2].second.second = "(x^y)^z";
eval[3].first = log(z * y) + log(log(x));
eval[3].second.second = "(x^z)^y";
eval[4].first = z * log(x) + log(log(y));
eval[4].second.second = "y^x^z";
eval[5].first = x * log(z) + log(log(y));
eval[5].second.second = "y^z^x";
eval[6].first = log(x * z) + log(log(y));
eval[6].second.second = "(y^x)^z";
eval[7].first = log(x * z) + log(log(y));
eval[7].second.second = "(y^z)^x";
eval[8].first = y * log(x) + log(log(z));
eval[8].second.second = "z^x^y";
eval[9].first = x * log(y) + log(log(z));
eval[9].second.second = "z^y^x";
eval[10].first = log(x * y) + log(log(z));
eval[10].second.second = "(z^x)^y";
eval[11].first = log(x * y) + log(log(z));
eval[11].second.second = "(z^y)^x";
for (int i = 0; i < 12; ++i) eval[i].second.first = i;
sort(eval, eval + 12, compare);
cout << eval[0].second.second;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5);
double xx, yy, zz;
long double x, y, z, a[15], mn;
int pos;
string second[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
cin >> xx >> yy >> zz;
x = xx;
y = yy;
z = zz;
long double logx = log(x), logy = log(y), logz = log(z);
a[1] = logx * pow(y, z);
a[2] = logx * pow(z, y);
a[3] = logx * y * z;
a[4] = a[3];
a[5] = logy * pow(x, z);
a[6] = logy * pow(z, x);
a[7] = logy * x * z;
a[8] = a[7];
a[9] = logz * pow(x, y);
a[10] = logz * pow(y, x);
a[11] = logz * x * y;
a[12] = a[11];
mn = a[1], pos = 0;
for (int i = 2; i <= 12; i++) {
if (mn < a[i]) {
mn = a[i];
pos = i - 1;
}
}
cout << second[pos];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char *a[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
const double minn = -1e18;
const double esp = 1e-6;
int main() {
double x, y, z;
while (scanf("%lf %lf %lf", &x, &y, &z) == 3) {
int flag = 0;
double p[12];
if (x > 1 || y > 1 || z > 1) {
p[0] = x > 1 ? z * log10(y) + log10(log10(x)) : minn;
p[1] = x > 1 ? y * log10(z) + log10(log10(x)) : minn;
p[2] = x > 1 ? log10(z) + log10(y * log10(x)) : minn;
p[3] = x > 1 ? log10(y) + log10(z * log10(x)) : minn;
p[4] = y > 1 ? z * log10(x) + log10(log10(y)) : minn;
p[5] = y > 1 ? x * log10(z) + log10(log10(y)) : minn;
p[6] = y > 1 ? log10(z) + log10(x * log10(y)) : minn;
p[7] = y > 1 ? log10(x) + log10(z * log10(y)) : minn;
p[8] = z > 1 ? y * log10(x) + log10(log10(z)) : minn;
p[9] = z > 1 ? x * log10(y) + log10(log10(z)) : minn;
p[10] = z > 1 ? log10(y) + log10(x * log10(z)) : minn;
p[11] = z > 1 ? log10(x) + log10(y * log10(z)) : minn;
} else {
p[0] = (double)pow(x, pow(y, z));
p[1] = (double)pow(x, pow(z, y));
p[2] = (double)pow(pow(x, y), z);
p[3] = (double)pow(pow(x, z), y);
p[4] = (double)pow(y, pow(x, z));
p[5] = (double)pow(y, pow(z, x));
p[6] = (double)pow(pow(y, x), z);
p[7] = (double)pow(pow(y, z), x);
p[8] = (double)pow(z, pow(x, y));
p[9] = (double)pow(z, pow(y, x));
p[10] = (double)pow(pow(z, x), y);
p[11] = (double)pow(pow(z, y), x);
}
double max_num = p[0];
for (int i = 0; i < 12; i++) {
if (p[i] > max_num && p[i] - max_num > esp) {
max_num = p[i];
flag = i;
}
}
printf("%s\n", a[flag]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
long double a[12];
int ans = 0;
const char s[12][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
cin >> x >> y >> z;
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = a[3] = y * z * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = a[7] = x * z * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = a[11] = x * y * log(z);
for (int i = 1; i <= 11; i++) {
if (a[i] > a[ans]) ans = i;
}
printf("%s\n", s[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int foo(double x, double y, double z, bool flag) {
double a1, a2, a3;
if (flag) {
a1 = z * log(y) + log(log(x));
a2 = y * log(z) + log(log(x));
a3 = log(y) + log(z) + log(log(x));
} else {
a1 = pow(x, pow(y, z));
a2 = pow(x, pow(z, y));
a3 = pow(x, y * z);
}
if (a1 - a2 >= -0.000001) {
if (a1 - a3 >= -0.000001) {
return 1;
} else {
return 3;
}
} else {
if (a2 - a3 >= -0.000001) {
return 2;
} else {
return 3;
}
}
}
double calc_log(double x, double y, double z, int op) {
if (op == 1) return (z * log(y) + log(log(x)));
if (op == 2) return (y * log(z) + log(log(x)));
if (op == 3) return (log(y) + log(z) + log(log(x)));
return 0;
}
double calc_exp(double x, double y, double z, int op) {
if (op == 1) return (pow(x, pow(y, z)));
if (op == 2) return (pow(x, pow(z, y)));
if (op == 3) return (pow(x, y * z));
return 0;
}
void print(char x, char y, char z, int op) {
if (op == 1) cout << x << "^" << y << "^" << z << endl;
if (op == 2) cout << x << "^" << z << "^" << y << endl;
if (op == 3) cout << "(" << x << "^" << y << ")^" << z << endl;
}
int main() {
double a, b, c, r1, r2, r3;
int op1, op2, op3;
cin >> a >> b >> c;
if ((a < 1.1 && b < 1.1) || (a < 1.1 && c < 1.1) || (b < 1.1 && c < 1.1)) {
op1 = foo(a, b, c, false);
r1 = calc_exp(a, b, c, op1);
op2 = foo(b, a, c, false);
r2 = calc_exp(b, a, c, op2);
op3 = foo(c, a, b, false);
r3 = calc_exp(c, a, b, op3);
} else {
if (a > 1) {
op1 = foo(a, b, c, true);
r1 = calc_log(a, b, c, op1);
} else {
r1 = -1000000000;
}
if (b > 1) {
op2 = foo(b, a, c, true);
r2 = calc_log(b, a, c, op2);
} else {
r2 = -1000000000;
}
if (c > 1) {
op3 = foo(c, a, b, true);
r3 = calc_log(c, a, b, op3);
} else {
r3 = -1000000000;
}
}
if (r1 - r2 >= -0.000001) {
if (r1 - r3 >= -0.000001) {
print('x', 'y', 'z', op1);
} else {
print('z', 'x', 'y', op3);
}
} else {
if (r2 - r3 >= -0.000001) {
print('y', 'x', 'z', op2);
} else {
print('z', 'x', 'y', op3);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[20];
double x, y, z;
double first(int idx) {
if (1 <= idx and idx <= 4) return log(x);
if (5 <= idx and idx <= 8) return log(y);
if (9 <= idx and idx <= 12) return log(z);
return 0.0;
}
double second(int idx) {
switch (idx) {
case 1:
return z * log(y);
case 2:
return y * log(z);
case 3:
return log(y) + log(z);
case 4:
return log(z) + log(y);
case 5:
return z * log(x);
case 6:
return x * log(z);
case 7:
return log(x) + log(z);
case 8:
return log(z) + log(x);
case 9:
return y * log(x);
case 10:
return x * log(y);
case 11:
return log(x) + log(y);
case 12:
return log(y) + log(x);
}
}
int cmp(int idx1, int idx2) {
double fs1 = first(idx1), fs2 = first(idx2);
if (fs1 == 0 or fs2 == 0) {
return fs1 < fs2;
}
if ((fs1 < 0) ^ (fs2 < 0)) {
return fs1 < fs2;
}
if (fs1 < 0 and fs2 < 0) {
return second(idx1) + log(-fs1) - (second(idx2) + log(-fs2)) > 1e-12;
} else {
return second(idx1) + log(fs1) - (second(idx2) + log(fs2)) < -1e-12;
}
}
int main() {
cin >> x >> y >> z;
int ans = 1;
for (int i = 2; i <= 12; i++) {
if (cmp(ans, i)) {
ans = i;
}
}
switch (ans) {
case 1:
cout << "x^y^z" << endl;
break;
case 2:
cout << "x^z^y" << endl;
break;
case 3:
cout << "(x^y)^z" << endl;
break;
case 4:
cout << "(x^z)^y" << endl;
break;
case 5:
cout << "y^x^z" << endl;
break;
case 6:
cout << "y^z^x" << endl;
break;
case 7:
cout << "(y^x)^z" << endl;
break;
case 8:
cout << "(y^z)^x" << endl;
break;
case 9:
cout << "z^x^y" << endl;
break;
case 10:
cout << "z^y^x" << endl;
break;
case 11:
cout << "(z^x)^y" << endl;
break;
case 12:
cout << "(z^y)^x" << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double esp = 1e-20;
long double ans[14];
int pos = 1;
long double get1(long double a, long double b, long double c) {
return powl(b, c) * logl(a);
}
long double get2(long double a, long double b, long double c) {
return b * c * logl(a);
}
char da[14][10] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double a, b, c;
cin >> a >> b >> c;
ans[1] = get1(a, b, c);
ans[2] = get1(a, c, b);
ans[3] = ans[4] = get2(a, b, c);
ans[5] = get1(b, a, c);
ans[6] = get1(b, c, a);
ans[7] = ans[8] = get2(b, a, c);
ans[9] = get1(c, a, b);
ans[10] = get1(c, b, a);
ans[11] = ans[12] = get2(c, a, b);
int id;
long double s = -1.1;
for (int i = 1; i <= 12; i++) {
if (s < ans[i]) {
s = ans[i];
id = i;
}
}
printf("%s", da[id]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[3];
struct node {
double x;
int id;
char s[20];
} ans[123];
int mx[] = {0, 1, 2, 5, 6, 9, 10};
int my[] = {0, 3, 4, 7, 8, 11, 12};
char en[] = {'x', 'y', 'z'};
bool cmp(node a, node b) {
if (fabs(a.x - b.x) < 1e-10) return a.id < b.id;
return a.x > b.x;
}
int flag = 0;
int main() {
cin >> a[en[0] - 'x'] >> a[en[1] - 'x'] >> a[en[2] - 'x'];
if (a[en[0] - 'x'] <= 1 && a[en[1] - 'x'] <= 1 && a[en[2] - 'x'] <= 1)
flag = 1;
int T = 6, t = 0;
while (T--) {
if (!flag)
ans[t].x = (a[en[0] - 'x'] < 1) ? -0x3f3f3f3f
: a[en[2] - 'x'] * log10(a[en[1] - 'x']) +
log10(log10(a[en[0] - 'x']));
else
ans[t].x = pow(a[en[0] - 'x'], pow(a[en[1] - 'x'], a[en[2] - 'x']));
ans[t].s[0] = en[0];
ans[t].s[2] = en[1];
ans[t].s[4] = en[2];
ans[t].s[1] = ans[t].s[3] = '^';
ans[t].s[5] = 0;
ans[t++].id = mx[6 - T];
if (!flag)
ans[t].x =
(a[en[0] - 'x'] < 1)
? -0x3f3f3f3f
: log10(a[en[2] - 'x'] * a[en[1] - 'x'] * log10(a[en[0] - 'x']));
else
ans[t].x = pow(a[en[0] - 'x'], a[en[1] - 'x'] * a[en[2] - 'x']);
ans[t].s[1] = en[0];
ans[t].s[3] = en[1];
ans[t].s[6] = en[2];
ans[t].s[0] = '(';
ans[t].s[2] = ans[t].s[5] = '^';
ans[t].s[4] = ')';
ans[t].s[7] = 0;
ans[t++].id = my[6 - T];
next_permutation(en, en + 3);
}
sort(ans, ans + 12, cmp);
cout << ans[0].s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z, xx, yy, zz, a[15];
int i;
bool flag = false, f[15];
cin >> x >> y >> z;
for (i = 0; i < 13; i++) f[i] = true;
if (x < 1 && y < 1 && z < 1) {
flag = true;
xx = 1.0 / x;
yy = 1.0 / y;
zz = 1.0 / z;
a[1] = z * log(y) + log(log(xx));
a[2] = y * log(z) + log(log(xx));
a[3] = log(z) + log(y) + log(log(xx));
a[4] = log(y) + log(z) + log(log(xx));
a[5] = z * log(x) + log(log(yy));
a[6] = x * log(z) + log(log(yy));
a[7] = log(log(yy)) + log(x) + log(z);
a[8] = log(log(yy)) + log(x) + log(z);
a[9] = y * log(x) + log(log(zz));
a[10] = x * log(y) + log(log(zz));
;
a[11] = log(x) + log(y) + log(log(zz));
a[12] = log(y) + log(x) + log(log(zz));
} else {
if (x < 1) {
f[1] = f[2] = f[3] = f[4] = false;
} else {
a[1] = z * log(y) + log(log(x));
a[2] = y * log(z) + log(log(x));
a[3] = log(z) + log(y) + log(log(x));
a[4] = log(y) + log(z) + log(log(x));
}
if (y < 1) {
f[5] = f[6] = f[7] = f[8] = false;
} else {
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(log(y)) + log(x) + log(z);
a[8] = log(log(y)) + log(x) + log(z);
}
if (z < 1) {
f[9] = f[10] = f[11] = f[12] = false;
} else {
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
;
a[11] = log(x) + log(y) + log(log(z));
a[12] = log(y) + log(x) + log(log(z));
}
}
int c = 1;
if (flag) {
for (i = 2; i <= 12; i++)
if (a[c] > a[i]) c = i;
} else {
for (i = 1; i <= 12; i++)
if (f[i]) {
c = i;
break;
}
for (i++; i <= 12; i++)
if (f[i] && a[c] < a[i]) c = i;
}
switch (c) {
case 1:
cout << "x^y^z";
break;
case 2:
cout << "x^z^y";
break;
case 3:
cout << "(x^y)^z";
break;
case 4:
cout << "(x^z)^y";
break;
case 5:
cout << "y^x^z";
break;
case 6:
cout << "y^z^x";
break;
case 7:
cout << "(y^x)^z";
break;
case 8:
cout << "(y^z)^x";
break;
case 9:
cout << "z^x^y";
break;
case 10:
cout << "z^y^x";
break;
case 11:
cout << "(z^x)^y";
break;
case 12:
cout << "(z^y)^x";
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<long double, string> &a,
const pair<long double, string> &b) {
return a.first < b.first;
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
pair<long double, string> vals[9] = {
{log(x) * pow(y, z), "x^y^z"}, {log(x) * pow(z, y), "x^z^y"},
{log(x) * y * z, "(x^y)^z"}, {log(y) * pow(x, z), "y^x^z"},
{log(y) * pow(z, x), "y^z^x"}, {log(y) * x * z, "(y^x)^z"},
{log(z) * pow(x, y), "z^x^y"}, {log(z) * pow(y, x), "z^y^x"},
{log(z) * x * y, "(z^x)^y"},
};
cout << max_element(vals, vals + 9, cmp)->second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-10;
int cmp(long double x) {
if (x < -eps) return -1;
return x > eps;
}
string s[9] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
int main() {
long double x, y, z, ans = -1e100, l[10];
cin >> x >> y >> z;
for (int i = 0; i < 9; i++) l[i] = -1e100;
if (cmp(x - 1) == 1) {
l[0] = z * log(y) + log(log(x));
l[1] = y * log(z) + log(log(x));
l[2] = log(y * z * log(x));
}
if (cmp(y - 1) == 1) {
l[3] = z * log(x) + log(log(y));
l[4] = x * log(z) + log(log(y));
l[5] = log(x * z * log(y));
}
if (cmp(z - 1) == 1) {
l[6] = y * log(x) + log(log(z));
l[7] = x * log(y) + log(log(z));
l[8] = log(y * x * log(z));
}
for (int i = 0; i < 9; i++) ans = max(ans, l[i]);
if (cmp(ans + 1e100) == 1) {
for (int i = 0; i < 9; i++)
if (cmp(l[i] - ans) != -1) {
cout << s[i] << endl;
return 0;
}
}
if (cmp(x - 1) == 0) {
cout << s[0] << endl;
return 0;
}
if (cmp(y - 1) == 0) {
cout << s[3] << endl;
return 0;
}
if (cmp(z - 1) == 0) {
cout << s[6] << endl;
return 0;
}
l[0] = z * log(y) + log(-log(x));
l[1] = y * log(z) + log(-log(x));
l[2] = log(-y * z * log(x));
l[3] = z * log(x) + log(-log(y));
l[4] = x * log(z) + log(-log(y));
l[5] = log(-x * z * log(y));
l[6] = y * log(x) + log(-log(z));
l[7] = x * log(y) + log(-log(z));
l[8] = log(-y * x * log(z));
ans = 1e100;
for (int i = 0; i < 9; i++) ans = min(ans, l[i]);
for (int i = 0; i < 9; i++)
if (cmp(l[i] - ans) != 1) {
cout << s[i] << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z, ans = -1;
string res;
int main() {
cin >> x >> y >> z;
if (log(x) * pow(y, z) > ans) ans = log(x) * pow(y, z), res = "x^y^z";
if (log(x) * pow(z, y) > ans) ans = log(x) * pow(z, y), res = "x^z^y";
if (log(x) * y * z > ans) ans = log(x) * y * z, res = "(x^y)^z";
if (log(y) * pow(x, z) > ans) ans = log(y) * pow(x, z), res = "y^x^z";
if (log(y) * pow(z, x) > ans) ans = log(y) * pow(z, x), res = "y^z^x";
if (log(y) * x * z > ans) ans = log(y) * x * z, res = "(y^x)^z";
if (log(z) * pow(x, y) > ans) ans = log(z) * pow(x, y), res = "z^x^y";
if (log(z) * pow(y, x) > ans) ans = log(z) * pow(y, x), res = "z^y^x";
if (log(z) * x * y > ans) ans = log(z) * y * x, res = "(z^x)^y";
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double x, y, z;
long double op = -9999999;
int id;
void u(long double val, int pid) {
if (val > op) {
op = val;
id = pid;
}
}
int main() {
scanf("%lf %lf %lf", &x, &y, &z);
if (x <= 1 && y <= 1 && z <= 1) {
if (x == 1)
u(0, 1);
else if (y == 1)
u(0, 5);
else if (z == 1)
u(0, 9);
else {
u(-z * log(y) - log(log(1 / x)), 1);
u(-y * log(z) - log(log(1 / x)), 2);
u(-log(y) - log(z) - log(log(1 / x)), 3);
u(-z * log(x) - log(log(1 / y)), 5);
u(-x * log(z) - log(log(1 / y)), 6);
u(-log(x) - log(z) - log(log(1 / y)), 7);
u(-y * log(x) - log(log(1 / z)), 9);
u(-x * log(y) - log(log(1 / z)), 10);
u(-log(x) - log(y) - log(log(1 / z)), 11);
}
} else {
if (x > 1) {
u(z * log(y) + log(log(x)), 1);
u(y * log(z) + log(log(x)), 2);
u(log(y) + log(z) + log(log(x)), 3);
}
if (y > 1) {
u(z * log(x) + log(log(y)), 5);
u(x * log(z) + log(log(y)), 6);
u(log(x) + log(z) + log(log(y)), 7);
}
if (z > 1) {
u(y * log(x) + log(log(z)), 9);
u(x * log(y) + log(log(z)), 10);
u(log(x) + log(y) + log(log(z)), 11);
}
}
if (id == 1)
printf("x^y^z\n");
else if (id == 2)
printf("x^z^y\n");
else if (id == 3)
printf("(x^y)^z\n");
else if (id == 5)
printf("y^x^z\n");
else if (id == 6)
printf("y^z^x\n");
else if (id == 7)
printf("(y^x)^z\n");
else if (id == 9)
printf("z^x^y\n");
else if (id == 10)
printf("z^y^x\n");
else if (id == 11)
printf("(z^x)^y\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[14];
double a[14];
vector<double> V;
int main() {
int i, in;
double m;
s[1] = "x^y^z";
s[2] = "x^z^y";
s[3] = "(x^y)^z";
s[5] = "y^x^z";
s[6] = "y^z^x";
s[7] = "(y^x)^z";
s[9] = "z^x^y";
s[10] = "z^y^x";
s[11] = "(z^x)^y";
double x, y, z;
cin >> x >> y >> z;
V.push_back(x);
V.push_back(y);
V.push_back(z);
sort(V.begin(), V.end());
if (V[1] <= 1) {
a[1] = pow(x, pow(y, z));
a[2] = pow(x, pow(z, y));
a[3] = pow(pow(x, y), z);
a[4] = a[3];
a[5] = pow(y, pow(x, z));
a[6] = pow(y, pow(z, x));
a[7] = pow(pow(y, x), z);
a[8] = a[7];
a[9] = pow(z, pow(x, y));
a[10] = pow(z, pow(y, x));
a[11] = pow(pow(z, y), x);
a[12] = a[11];
in = 1;
m = a[1];
for (i = 2; i <= 12; i++) {
if (a[i] > m) {
m = a[i];
in = i;
}
}
cout << s[in];
return 0;
}
if (V[0] > 1) {
a[1] = z * log(y) + log(log(x));
a[2] = y * log(z) + log(log(x));
a[3] = log(y * z * log(x));
a[4] = a[3];
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(x * z * log(y));
a[8] = a[7];
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
a[11] = log(x * y * log(z));
a[12] = a[11];
in = 1;
m = a[1];
for (i = 2; i <= 12; i++) {
if (a[i] > m) {
m = a[i];
in = i;
}
}
cout << s[in];
return 0;
}
if (x <= 1) {
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(x * z * log(y));
a[8] = a[7];
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
a[11] = log(x * y * log(z));
a[12] = a[11];
in = 5;
m = a[5];
for (i = 6; i <= 12; i++) {
if (a[i] > m) {
m = a[i];
in = i;
}
}
cout << s[in];
return 0;
}
if (y <= 1) {
a[1] = z * log(y) + log(log(x));
a[2] = y * log(z) + log(log(x));
a[3] = log(y * z * log(x));
a[4] = a[3];
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
a[11] = log(x * y * log(z));
a[12] = a[11];
in = 1;
m = a[1];
for (i = 2; i <= 4; i++) {
if (a[i] > m) {
m = a[i];
in = i;
}
}
for (i = 9; i <= 12; i++) {
if (a[i] > m) {
m = a[i];
in = i;
}
}
cout << s[in];
return 0;
}
if (z <= 1) {
a[1] = z * log(y) + log(log(x));
a[2] = y * log(z) + log(log(x));
a[3] = log(y * z * log(x));
a[4] = a[3];
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(x * z * log(y));
a[8] = a[7];
in = 1;
m = a[1];
for (i = 2; i <= 8; i++) {
if (a[i] > m) {
m = a[i];
in = i;
}
}
cout << s[in];
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double ans[13];
char s[13][13] = {" ", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double x, y, z;
double a, b, c;
scanf("%lf%lf%lf", &a, &b, &c);
x = a, y = b, z = c;
long double xx = log(x);
long double yy = log(y);
long double zz = log(z);
ans[1] = xx * pow(y, z);
ans[2] = xx * pow(z, y);
ans[3] = xx * y * z;
ans[4] = xx * y * z;
ans[5] = yy * pow(x, z);
ans[6] = yy * pow(z, x);
ans[7] = yy * x * z;
ans[8] = yy * x * z;
ans[9] = zz * pow(x, y);
ans[10] = zz * pow(y, x);
ans[11] = zz * x * y;
ans[12] = zz * y * x;
long double tmp = -1;
int id = 0;
for (int i = 1; i <= 12; i++)
if (tmp < ans[i]) {
tmp = ans[i];
id = i;
}
printf("%s", s[id]);
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
using namespace std;
long double resposta = -1 * INF;
int mp[3];
bool par = false;
long double calc(long double x, long double y, long double z, bool c) {
if (c) return z * y * log(x);
return pow(y, z) * log(x);
}
void calcula(int *v, map<int, long double> &p, bool c) {
do {
for (int i = 0; i < 3; i++) {
long double x = p.find(v[0])->second;
long double y = p.find(v[1])->second;
long double z = p.find(v[2])->second;
long double resp = calc(x, y, z, c);
if (resp > resposta) {
resposta = resp;
mp[0] = v[0], mp[1] = v[1], mp[2] = v[2];
par = c;
}
}
} while (next_permutation(v, v + 3));
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
map<int, char> m;
m[0] = 'x', m[1] = 'y', m[2] = 'z';
map<int, long double> p;
p[0] = x, p[1] = y, p[2] = z;
int v[] = {0, 1, 2};
calcula(v, p, false);
calcula(v, p, true);
char a, b, c;
a = m.find(mp[0])->second;
b = m.find(mp[1])->second;
c = m.find(mp[2])->second;
if (par) {
printf("(%c^%c)^%c\n", a, b, c);
} else
printf("%c^%c^%c\n", a, b, c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<double, int> a, pair<double, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
int main() {
ios_base::sync_with_stdio(0);
int ansi;
double x, y, z, x2, y2, z2;
vector<pair<double, int> > ans;
pair<double, int> aux;
string t[12];
t[0] = "x^y^z\n";
t[1] = "x^z^y\n";
t[2] = "(x^y)^z\n";
t[3] = "(x^z)^y\n";
t[4] = "y^x^z\n";
t[5] = "y^z^x\n";
t[6] = "(y^x)^z\n";
t[7] = "(y^z)^x\n";
t[8] = "z^x^y\n";
t[9] = "z^y^x\n";
t[10] = "(z^x)^y\n";
t[11] = "(z^y)^x\n";
cin >> x >> y >> z;
bool flag = false;
if (x <= 1 && y <= 1 && z <= 1) {
x2 = 1 / x;
y2 = 1 / y;
z2 = 1 / z;
flag = true;
}
if (x > 1 || flag) {
if (flag) swap(x, x2);
ans.push_back(make_pair(z * log(y) + log(log(x)), 0));
ans.push_back(make_pair(y * log(z) + log(log(x)), 1));
ans.push_back(make_pair(log(z) + log(y) + log(log(x)), 2));
ans.push_back(make_pair(log(z) + log(y) + log(log(x)), 3));
if (flag) swap(x, x2);
}
if (y > 1 || flag) {
if (flag) swap(y, y2);
ans.push_back(make_pair(z * log(x) + log(log(y)), 4));
ans.push_back(make_pair(x * log(z) + log(log(y)), 5));
ans.push_back(make_pair(log(z) + log(x) + log(log(y)), 6));
ans.push_back(make_pair(log(z) + log(x) + log(log(y)), 7));
if (flag) swap(y, y2);
}
if (z > 1 || flag) {
if (flag) swap(z, z2);
ans.push_back(make_pair(y * log(x) + log(log(z)), 8));
ans.push_back(make_pair(x * log(y) + log(log(z)), 9));
ans.push_back(make_pair(log(y) + log(x) + log(log(z)), 10));
ans.push_back(make_pair(log(y) + log(x) + log(log(z)), 11));
if (flag) swap(z, z2);
}
if (flag)
sort(ans.begin(), ans.end());
else
sort(ans.begin(), ans.end(), cmp);
cout << t[ans[0].second];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
const int maxn = 100100;
long double x, y, z;
long double a[15];
long double mx;
int id;
void solve() {
cin >> x >> y >> z;
a[1] = log(x) * pow(y, z);
a[2] = log(x) * pow(z, y);
a[3] = y * z * log(x);
a[5] = log(y) * pow(x, z);
a[6] = log(y) * pow(z, x);
a[7] = x * z * log(y);
a[9] = log(z) * pow(x, y);
a[10] = log(z) * pow(y, x);
a[11] = x * y * log(z);
mx = a[1];
id = 1;
for (int i = 1; i < 12; i++) {
if (i % 4 == 0) continue;
if (mx < a[i]) {
mx = a[i];
id = i;
}
}
if (id == 1) {
cout << "x^y^z";
}
if (id == 2) {
cout << "x^z^y";
}
if (id == 3) {
cout << "(x^y)^z";
}
if (id == 5) {
cout << "y^x^z";
}
if (id == 6) {
cout << "y^z^x";
}
if (id == 7) {
cout << "(y^x)^z";
}
if (id == 9) {
cout << "z^x^y";
}
if (id == 10) {
cout << "z^y^x";
}
if (id == 11) {
cout << "(z^x)^y";
}
return;
}
int main() {
if (0) {
freopen(
"rare"
".in",
"r", stdin);
freopen(
"rare"
".out",
"w", stdout);
}
solve();
}
|
#include <bits/stdc++.h>
int main() {
double x, y, z;
double max;
int ind = 0;
scanf("%lf %lf %lf", &x, &y, &z);
if (x - 1.0 < 1e-6 && y - 1.0 < 1e-6 && z - 1.0 < 1e-6) {
max = 1000000;
if (z * log(y) + log(log(1 / x)) - max < -1e-6) {
max = z * log(y) + log(log(1 / x));
ind = 1;
}
if (y * log(z) + log(log(1 / x)) - max < -1e-6) {
max = y * log(z) + log(log(1 / x));
ind = 2;
}
if (log(y) + log(z) + log(log(1 / x)) - max < -1e-6) {
max = log(y) + log(z) + log(log(1 / x));
ind = 3;
}
if (z * log(x) + log(log(1 / y)) - max < -1e-6) {
max = z * log(x) + log(log(1 / y));
ind = 5;
}
if (x * log(z) + log(log(1 / y)) - max < -1e-6) {
max = x * log(z) + log(log(1 / y));
ind = 6;
}
if (log(x) + log(z) + log(log(1 / y)) - max < -1e-6) {
max = log(x) + log(z) + log(log(1 / y));
ind = 7;
}
if (y * log(x) + log(log(1 / z)) - max < -1e-6) {
max = y * log(x) + log(log(1 / z));
ind = 9;
}
if (x * log(y) + log(log(1 / z)) - max < -1e-6) {
max = x * log(y) + log(log(1 / z));
ind = 10;
}
if (log(x) + log(y) + log(log(1 / z)) - max < -1e-6) {
max = log(x) + log(y) + log(log(1 / z));
ind = 11;
}
} else {
max = -1000;
if (x - 1.0 > 0.01) {
if (z * log(y) + log(log(x)) - max > 1e-6) {
max = z * log(y) + log(log(x));
ind = 1;
}
if (y * log(z) + log(log(x)) - max > 1e-6) {
max = y * log(z) + log(log(x));
ind = 2;
}
if (log(y) + log(z) + log(log(x)) - max > 1e-6) {
max = log(y) + log(z) + log(log(x));
ind = 3;
}
}
if (y - 1.0 > 0.01) {
if (z * log(x) + log(log(y)) - max > 1e-6) {
max = z * log(x) + log(log(y));
ind = 5;
}
if (x * log(z) + log(log(y)) - max > 1e-6) {
max = x * log(z) + log(log(y));
ind = 6;
}
if (log(x) + log(z) + log(log(y)) - max > 1e-6) {
max = log(x) + log(z) + log(log(y));
ind = 7;
}
}
if (z - 1.0 > 0.01) {
if (y * log(x) + log(log(z)) - max > 1e-6) {
max = y * log(x) + log(log(z));
ind = 9;
}
if (x * log(y) + log(log(z)) - max > 1e-6) {
max = x * log(y) + log(log(z));
ind = 10;
}
if (log(x) + log(y) + log(log(z)) - max > 1e-6) {
max = log(x) + log(y) + log(log(z));
ind = 11;
}
}
}
switch (ind) {
case 1:
printf("x^y^z\n");
break;
case 2:
printf("x^z^y\n");
break;
case 3:
printf("(x^y)^z\n");
break;
case 4:
printf("(x^z)^y\n");
break;
case 5:
printf("y^x^z\n");
break;
case 6:
printf("y^z^x\n");
break;
case 7:
printf("(y^x)^z\n");
break;
case 8:
printf("(y^z)^x\n");
break;
case 9:
printf("z^x^y\n");
break;
case 10:
printf("z^y^x\n");
break;
case 11:
printf("(z^x)^y\n");
break;
case 12:
printf("(z^y)^x\n");
break;
default:
printf("ERROR\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
string ans[100];
long double a[100];
long double kek;
int main() {
cin >> x >> y >> z;
if (x < 5 && y < 5 && z < 5) {
ans[1] = "x^y^z";
ans[2] = "x^z^y";
ans[3] = "(x^y)^z";
ans[4] = ans[3];
ans[5] = "y^x^z";
ans[6] = "y^z^x";
ans[7] = "(y^x)^z";
ans[8] = ans[7];
ans[9] = "z^x^y";
ans[10] = "z^y^x";
ans[11] = "(z^x)^y";
ans[12] = ans[11];
a[1] = pow(x, pow(y, z));
a[2] = pow(x, pow(z, y));
a[3] = pow(pow(x, y), z);
a[4] = pow(pow(x, z), y);
a[5] = pow(y, pow(x, z));
a[6] = pow(y, pow(z, x));
a[7] = pow(pow(y, x), z);
a[8] = pow(pow(y, z), x);
a[9] = pow(z, pow(x, y));
a[10] = pow(z, pow(y, x));
a[11] = pow(pow(z, x), y);
a[12] = pow(pow(z, y), x);
for (int i = 1; i < 13; i++) kek = max(kek, a[i]);
for (int i = 1; i < 13; i++)
if (kek == a[i]) {
cout << ans[i] << "\n";
return 0;
}
}
if (x >= 1 && y >= 1 && z >= 1) {
if (x == 1) {
if (y == 1) {
cout << "z^x^y\n";
return 0;
}
if (z == 1) {
cout << "y^x^z\n";
return 0;
}
if (y <= z) {
cout << "y^z^x\n";
return 0;
}
if (y >= z) {
cout << "z^y^x\n";
return 0;
}
}
if (y == 1) {
if (x == 1) {
cout << "z^x^y\n";
return 0;
}
if (z == 1) {
cout << "x^y^z\n";
return 0;
}
if (x <= z) {
cout << "x^z^y\n";
return 0;
}
if (x >= z) {
cout << "z^x^y\n";
return 0;
}
}
if (z == 1) {
if (y == 1) {
cout << "x^y^z\n";
return 0;
}
if (x == 1) {
cout << "y^x^z\n";
return 0;
}
if (x <= y) {
cout << "x^y^z\n";
return 0;
}
if (x >= y) {
cout << "y^x^z\n";
return 0;
}
}
if (z >= x && z >= y && x <= y)
cout << "x^y^z\n";
else if (y >= x && y >= z && x <= z)
cout << "x^z^y\n";
else if (z >= x && z >= y && x > y)
cout << "y^x^z\n";
else if (x >= y && x >= z && y <= z)
cout << "y^z^x\n";
else if (y >= x && y >= z && x > z)
cout << "z^x^y\n";
else if (x >= y && x >= z && y > z)
cout << "z^y^x\n";
return 0;
}
if (x >= 1 && y >= 1) {
if (x <= y)
cout << "(x^y)^z\n";
else
cout << "(y^x)^z\n";
return 0;
} else if (x >= 1 && z >= 1) {
if (x <= z)
cout << "(x^y)^z\n";
else
cout << "(z^x)^y\n";
return 0;
} else if (y >= 1 && z >= 1) {
if (y <= z)
cout << "(y^x)^z\n";
else
cout << "(z^x)^y\n";
return 0;
} else if (x >= 1) {
if (x == 1) {
cout << "x^y^z\n";
return 0;
}
if (pow(y, z) >= pow(z, y))
cout << "x^y^z\n";
else
cout << "x^z^y\n";
return 0;
} else if (y >= 1) {
if (y == 1) {
cout << "y^x^z\n";
return 0;
}
if (pow(x, z) >= pow(z, x))
cout << "y^x^z\n";
else
cout << "y^z^x\n";
return 0;
} else if (z >= 1) {
if (z == 1) {
cout << "z^x^y\n";
return 0;
}
if (pow(x, y) >= pow(y, x))
cout << "z^x^y\n";
else
cout << "z^y^x\n";
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
struct xy {
long double d;
int p;
} a[15];
bool cmp(xy a1, xy a2) {
if (a1.d != a2.d) return a1.d > a2.d;
return a1.p < a2.p;
}
int main() {
while (cin >> x >> y >> z) {
a[0].d = pow(y, z) * log(x);
a[0].p = 0;
a[1].d = pow(z, y) * log(x);
a[1].p = 1;
a[2].d = z * y * log(x);
a[2].p = 2;
a[3].d = a[2].d;
a[3].p = 3;
a[4].d = log(y) * pow(x, z);
a[4].p = 4;
a[5].d = log(y) * pow(z, x);
a[5].p = 5;
a[6].d = log(y) * x * z;
a[6].p = 6;
a[7].d = a[6].d;
a[7].p = 7;
a[8].d = log(z) * pow(x, y);
a[8].p = 8;
a[9].d = log(z) * pow(y, x);
a[9].p = 9;
a[10].d = y * x * log(z);
a[10].p = 10;
a[11].d = a[10].d;
a[11].p = 11;
sort(a, a + 12, cmp);
switch (a[0].p) {
case 0:
printf("x^y^z\n");
break;
case 1:
printf("x^z^y\n");
break;
case 2:
printf("(x^y)^z\n");
break;
case 3:
printf("(x^z)^y\n");
break;
case 4:
printf("y^x^z\n");
break;
case 5:
printf("y^z^x\n");
break;
case 6:
printf("(y^x)^z\n");
break;
case 7:
printf("(y^z)^x\n");
break;
case 8:
printf("z^x^y\n");
break;
case 9:
printf("z^y^x\n");
break;
case 10:
printf("(z^x)^y\n");
break;
case 11:
printf("(z^y)^x\n");
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int MAXN = 15;
string ans[MAXN] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double x, y, z, a[MAXN], ma;
int flag;
int main(int argc, char const *argv[]) {
cin >> x >> y >> z;
ma = a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = a[3] = z * y * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = a[7] = x * z * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = a[11] = x * y * log(z);
for (int i = 1; i < 12; ++i)
if (a[i] > ma) {
ma = a[i];
flag = i;
}
cout << ans[flag] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000001000;
const int mod = 1000 * 1000 * 1000 + 7;
const int mod9 = 1000 * 1000 * 1000 + 9;
const double PI = 3.1415926535897932;
double sqr(double first) { return first * first; };
long double sqr(long double first) { return first * first; };
long long sqr(long long first) { return first * first; };
long long sqr(int first) { return first * 1LL * first; };
long long gcd(long long a, long long b) {
while (b) a %= b, swap(a, b);
return a;
}
long long bpm(long long a, long long n = -2, long long m = mod) {
n = n >= 0 ? n : m + n;
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
long long dist(long long x1, long long y1, long long x2, long long y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
std::ostream& operator<<(std::ostream& os, pair<int, int> p) {
return os << "{" << p.first << " " << p.second << "}";
}
const int N = 200002;
string d[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double f(long double first, long double second, long double z) {
return pow(second, z) * log(first);
}
long double s(long double first, long double second, long double z) {
return z * second * logl(first);
}
int main() {
double first, second, z;
cin >> first >> second >> z;
long double a[12];
a[0] = f(first, second, z);
a[1] = f(first, z, second);
a[2] = s(first, second, z);
a[3] = s(first, z, second);
a[4] = f(second, first, z);
a[5] = f(second, z, first);
a[6] = s(second, first, z);
a[7] = s(second, z, first);
a[8] = f(z, first, second);
a[9] = f(z, second, first);
a[10] = s(z, first, second);
a[11] = s(z, second, first);
int mId = 0;
for (int i = 0; i < 11; i++)
if (a[i] > a[mId]) mId = i;
cout << d[mId] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
long double ans[13];
long double eps = 1e-14;
int main() {
cin >> x >> y >> z;
ans[1] = pow(y, z) * log(x);
ans[2] = pow(z, y) * log(x);
ans[3] = y * z * log(x);
ans[4] = ans[3];
ans[5] = pow(x, z) * log(y);
ans[6] = pow(z, x) * log(y);
ans[7] = x * z * log(y);
ans[8] = ans[7];
ans[9] = pow(x, y) * log(z);
ans[10] = pow(y, x) * log(z);
ans[11] = y * x * log(z);
ans[12] = ans[11];
int index = 1;
for (int i = 2; i <= 12; i++) {
if (ans[i] - ans[index] > eps) {
index = i;
}
}
switch (index) {
case 1:
puts("x^y^z");
break;
case 2:
puts("x^z^y");
break;
case 3:
puts("(x^y)^z");
break;
case 5:
puts("y^x^z");
break;
case 6:
puts("y^z^x");
break;
case 7:
puts("(y^x)^z");
break;
case 9:
puts("z^x^y");
break;
case 10:
puts("z^y^x");
break;
case 11:
puts("(z^x)^y");
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
long long int leap(long long int x) {
if ((x % 4 == 0 && x % 100 != 0) || x % 400 == 0) return 1;
return 0;
}
long long int nCr(long long int n, long long int r) {
if (r == 0)
return 1;
else
return nCr(n - 1, r - 1) * n / r;
}
long long int mod(long long int N, long long int M) {
long long int temp = N / M;
N -= temp * M;
return N;
}
long long int bigmod(long long int N, long long int M, long long int MOD) {
if (M == 0) return 1;
if ((M / 2) * 2 == M) {
long long int ret = bigmod(N, M / 2, MOD);
return ((ret % MOD) * (ret % MOD)) % MOD;
} else
return ((N % MOD) * bigmod(N, M - 1, MOD) % MOD) % MOD;
}
long long int modinverse(long long int a, long long int m) {
return bigmod(a, m - 2, m);
}
struct Euclid {
long long int x, y, d;
Euclid(){};
Euclid(long long int xx, long long int yy, long long int dd) {
x = xx, y = yy, d = dd;
}
};
Euclid Extended_gcd(long long int a, long long int b) {
if (!b) return Euclid(1, 0, a);
Euclid e = Extended_gcd(b, a % b);
return Euclid(e.y, e.x - a / b * e.y, e.d);
}
long long int Set(long long int N, long long int pos) {
return N | (1LL << pos);
}
long long int reset(long long int N, long long int pos) {
return N & ~(1LL << pos);
}
long long int check(long long int N, long long int pos) {
return (N & (1LL << pos));
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
long double fuckx = log(x);
long double fucky = log(y);
long double fuckz = log(z);
vector<pair<long double, int> > vec;
long double res;
res = fuckx * pow(y, z);
vec.push_back(make_pair(res, 1));
res = fuckx * pow(z, y);
vec.push_back(make_pair(res, 2));
res = fuckx * y * z;
vec.push_back(make_pair(res, 3));
res = fuckx * y * z;
vec.push_back(make_pair(res, 4));
res = fucky * pow(x, z);
vec.push_back(make_pair(res, 5));
res = fucky * pow(z, x);
vec.push_back(make_pair(res, 6));
res = fucky * x * z;
vec.push_back(make_pair(res, 7));
res = fucky * x * z;
vec.push_back(make_pair(res, 8));
res = fuckz * pow(x, y);
vec.push_back(make_pair(res, 9));
res = fuckz * pow(y, x);
vec.push_back(make_pair(res, 10));
res = fuckz * x * y;
vec.push_back(make_pair(res, 11));
res = fuckz * x * y;
vec.push_back(make_pair(res, 12));
long double maxi = -INFINITY;
int pos;
for (int i = 0; i < 12; i++) {
if (vec[i].first > maxi) {
maxi = vec[i].first;
pos = i + 1;
}
}
if (pos == 1) cout << "x^y^z" << endl;
if (pos == 2) cout << "x^z^y" << endl;
if (pos == 3) cout << "(x^y)^z" << endl;
if (pos == 4) cout << "(x^z)^y" << endl;
if (pos == 5) cout << "y^x^z" << endl;
if (pos == 6) cout << "y^z^x" << endl;
if (pos == 7) cout << "(y^x)^z" << endl;
if (pos == 8) cout << "(y^z)^x" << endl;
if (pos == 9) cout << "z^x^y" << endl;
if (pos == 10) cout << "z^y^x" << endl;
if (pos == 11) cout << "(z^x)^y" << endl;
if (pos == 12) cout << "(z^y)^x" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z;
struct node {
long double sum;
int id;
friend bool operator<(node a, node b) {
if (a.sum == b.sum) return a.id < b.id;
return a.sum > b.sum;
}
};
node s[20];
int main() {
int i;
while (cin >> x >> y >> z) {
for (i = 0; i < 12; i++) s[i].id = i + 1;
s[0].sum = pow(y, z) * log2(x);
s[1].sum = pow(z, y) * log2(x);
s[2].sum = y * z * log2(x);
s[3].sum = y * z * log2(x);
s[4].sum = pow(x, z) * log2(y);
s[5].sum = pow(z, x) * log2(y);
s[6].sum = x * z * log2(y);
s[7].sum = x * z * log2(y);
s[8].sum = pow(x, y) * log2(z);
s[9].sum = pow(y, x) * log2(z);
s[10].sum = x * y * log2(z);
s[11].sum = x * y * log2(z);
sort(s, s + 12);
if (s[0].id == 1) puts("x^y^z");
if (s[0].id == 2) puts("x^z^y");
if (s[0].id == 3) puts("(x^y)^z");
if (s[0].id == 4) puts("(x^z)^y");
if (s[0].id == 5) puts("y^x^z");
if (s[0].id == 6) puts("y^z^x");
if (s[0].id == 7) puts("(y^x)^z");
if (s[0].id == 8) puts("(y^z)^x");
if (s[0].id == 9) puts("z^x^y");
if (s[0].id == 10) puts("z^y^x");
if (s[0].id == 11) puts("(z^x)^y");
if (s[0].id == 12) puts("(z^y)^x");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.