B
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <deque>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define REP(i, n) for(int i=0; i<(int)n; ++i)
#define FOR(i, c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(),(c).end()
#define each(i, c) FOR(i, c)
typedef long long int lli;
using namespace std;
int main(int argc, char *argv[])
{
int n;
while (cin >> n) {
double p[n];
for (int i = 0; i < n; ++i) {
cin >> p[i];
}
double x = accumulate(p, p + n, 0LL);
printf("%.10lf\n", x / (n * 100.0) * 100.0);
}
return 0;
}
C
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <deque>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define REP(i, n) for(int i=0; i<(int)n; ++i)
#define FOR(i, c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(),(c).end()
#define each(i, c) FOR(i, c)
typedef long long int lli;
using namespace std;
const string S = "BERLAND";
map<string, int> _name;
map<int, string> rev;
int name(string s)
{
if (_name.count(s)) ; else {
int tmp = _name.size();
_name[s] = tmp;
rev[tmp] = s;
}
return _name[s];
}
const int N = 4;
pair<int, int> g[N][N];
struct T {
int t, w, l;
string name;
T (int _t, int _w, int _l, string n)
: t(_t), w(_w), l(_l), name(n) {}
};
bool operator < (const T &a, const T &b)
{
if (a.t != b.t) return a.t < b.t;
int diffA = a.w - a.l;
int diffB = b.w - b.l;
if (diffA != diffB) return diffA < diffB;
if (a.w != b.w) return a.w < b.w;
return a.name > b.name;
}
bool solve(void)
{
int p[N];
int win[N];
int lose[N];
fill(p, p + N, 0);
fill(win, win + N, 0);
fill(lose, lose + N, 0);
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if (g[i][j].first == g[i][j].second) {
p[i] += 1;
p[j] += 1;
} else if (g[i][j].first < g[i][j].second) {
p[j] += 3;
} else if (g[i][j].first > g[i][j].second) {
p[i] += 3;
}
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
if (i == j) continue;
win[i] += g[i][j].first;
lose[i] += g[i][j].second;
}
}
vector<T> v;
for (int i = 0; i < N; ++i) {
v.push_back(T(p[i], win[i], lose[i], rev[i]));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
return v[0].name == S || v[1].name == S;
}
pair<int, int> better(pair<int, int> a, pair<int, int> b)
{
if (a.first == -1) return b;
int diffA = a.first - a.second;
int diffB = b.first - b.second;
if (diffA != diffB) return diffA < diffB ? a : b;
return a.second < b.second ? a : b;
}
int main(int argc, char *argv[])
{
while (true) {
_name.clear();
rev.clear();
fill(&g[0][0], &g[N - 1][N], make_pair(-1, -1));
for (int i = 0; i < 5; ++i) {
string a, b;
char c;
int n, m;
cin >> a >> b >> n >> c >> m;
g[name(a)][name(b)] = make_pair(n, m);
g[name(b)][name(a)] = make_pair(m, n);
}
if (_name.size() != 4) break;
int i = name(S);
pair<int, int> res = make_pair(-1, -1);
for (int j = 0; j < N; ++j) {
if (i == j) continue;
if (g[i][j].first == -1) {
for (int x = 0; x <= 100; ++x) {
for (int y = 0; y < x; ++y) {
if (x > y) ; else continue;
g[i][j] = make_pair(x, y);
g[j][i] = make_pair(y, x);
if (solve()) res = better(res, make_pair(x, y));
}
}
} else { continue; };
break;
}
if (res.first != -1) cout << res.first << ":" << res.second << endl;
else cout << "IMPOSSIBLE" << endl;
}
return 0;
}
D
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <deque>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define REP(i, n) for(int i=0; i<(int)n; ++i)
#define FOR(i, c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(),(c).end()
#define each(i, c) FOR(i, c)
typedef long long int lli;
using namespace std;
struct F {
string name;
vector<string> args;
F (string n, vector<string> a) : name(n), args(a) {};
};
bool match(F &a, F &b)
{
if (a.name != b.name) return false;
if (a.args.size() != b.args.size()) return false;
const int size = a.args.size();
for (int i = 0; i < size; ++i) {
if (a.args[i] == "T") continue;
if (a.args[i] != b.args[i]) return false;
}
return true;
}
int main(int argc, char *argv[])
{
int func;
while (cin >> func) {
cin.ignore();
vector<F> fs;
for (int i = 0; i < func; ++i) {
string ret;
string name;
string line;
getline(cin, line);
replace(line.begin(), line.end(), ',', ' ');
replace(line.begin(), line.end(), '(', ' ');
replace(line.begin(), line.end(), ')', ' ');
istringstream iss(line);
iss >> ret;
iss >> name;
vector<string> v;
for (string s; iss >> s; v.push_back(s)) ;
fs.push_back(F(name, v));
}
map<string, string> ts;
int var;
cin >> var;
for (int i = 0; i < var; ++i) {
string type;
string name;
cin >> type >> name;
ts[name] = type;
}
cin.ignore();
int call;
cin >> call;
cin.ignore();
while (call--) {
string name;
string line;
getline(cin, line);
replace(line.begin(), line.end(), ',', ' ');
replace(line.begin(), line.end(), '(', ' ');
replace(line.begin(), line.end(), ')', ' ');
istringstream iss(line);
iss >> name;
vector<string> v;
int cnt = 0;
for (string s; iss >> s; v.push_back(ts[s])) ;
for (int i = 0; i < func; ++i) {
F f(name, v);
cnt += match(fs[i], f);
}
cout << cnt << endl;
}
}
return 0;
}
