Problem:
Problem B:
Moonlight Farm
あなたは大人気webゲーム「ムーンライト牧場」に熱中している．このゲームの目的は，畑で作物を育て，それらを売却して収入を得て，その収入によって牧場を大きくしていくことである．
あなたは速く畑を大きくしたいと考えた．そこで手始めにゲーム中で育てることのできる作物を，時間あたりの収入効率にもとづいて並べることにした．
作物を育てるには種を買わなければならない．ここで作物
i
の種の名前は
L
i
，値段は
P
i
でそれぞれ与えられる．畑に種を植えると時間
A
i
後に芽が出る．芽が出てから時間
B
i
後に若葉が出る．若葉が出てから時間
C
i
後に葉が茂る．葉が茂ってから時間
D
i
後に花が咲く．花が咲いてから時間
E
i
後に実が成る．一つの種から
F
i
個の実が成り，それらの実は一つあたり
S
i
の価格で売れる．一部の作物は多期作であり，計
M
i
回実をつける．単期作の場合は
M
i
= 1で表される．多期作の作物は，
M
i
回目の実が成るまでは，実が成ったあと葉に戻る．ある種に対する収入は，その種から成った全ての実を売った金額から，種の値段を引いた値である．また，その種の収入効率は，その収入を，種を植えてから全ての実が成り終わるまでの時間で割った値である．
あなたの仕事は，入力として与えられる作物の情報に対して，それらを収入効率の降順に並べ替えて出力するプログラムを書くことである．
Input
入力はデータセットの列であり，各データセットは次のような形式で与えられる．
N
L
1
P
1
A
1
B
1
C
1
D
1
E
1
F
1
S
1
M
1
L
2
P
2
A
2
B
2
C
2
D
2
E
2
F
2
S
2
M
2
...
L
N
P
N
A
N
B
N
C
N
D
N
E
N
F
N
S
N
M
N
一行目はデータセットに含まれる作物の数
N
である (1 ≤ N ≤ 50)．
これに続く
N
行には，各行に一つの作物の情報が含まれる．各変数の意味は問題文中で述べた通りである．作物の名前
L
i
はアルファベット小文字のみからなる20文字以内の文字列であり，また 1 ≤
P
i
,
A
i
,
B
i
,
C
i
,
D
i
,
E
i
,
F
i
,
S
i
≤ 100, 1 ≤
M
i
≤ 5である．一つのケース内に同一の名前を持つ作物は存在しないと仮定して良い．
入力の終りはゼロを一つだけ含む行で表される．
Output
各データセットについて，各行に一つ，作物の名前を収入効率の降順に出力せよ．収入効率が同じ作物に対しては，それらの名前を辞書順の昇順に出力せよ．
各データセットの出力の後には“#”のみからなる1行を出力すること．
Sample Input
5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0
Output for the Sample Input
eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define rep(i, j, k) for (auto i = j; i < k; i++)
#define rrep(i, j, k) for (auto i = j; i > k; i--)
using namespace std;

void solve(int &n) {
  map<int, string> name;
  vector<pair<int, int>> v;
  rep(i, 0, n) {
    string l;
    int p, a, b, c, d, e, f, s, m;
    cin >> l >> p >> a >> b >> c >> d >> e >> f >> s >> m;
    int t = a + b + c + m * (d + e);
    int mon = m * f * s - p;
    v.push_back({mon, t});
    name[i] = l;
  }
  bool past[51];
  fill(past, past + 51, false);
  vector<string> ans;
  rep(i, 0, n) {
    rep(j, 0, n) {
      if (past[j]) continue;
      bool ok = true;
      rep(k, 0, n) {
        if (past[k]) continue;
        if (v[j].fi * v[k].se < v[k].fi * v[j].se) ok = false;
        if (v[j].fi * v[k].se == v[k].fi * v[j].se && name[j] > name[k]) ok = false;
      }
      if (ok) {
       ans.push_back(name[j]);
       past[j] = true;
      }
    }
  }
  rep(i, 0, n) cout << ans[i] << endl;
  cout << "#" << endl;
}

int main() {
  int n;
  while (cin >> n, n) solve(n);
}
accuracy: 1
time_ms: 10
memory_kb: 3004
final_rank: 3

code_snippet: #include <iostream>
#include <algorithm>
#include <string>
#define N 50
using namespace std;
struct data{
  string l;
  int p,a,b,c,d,e,f,s,m;
  double cal;
};
int main(){
  int n,i,j,time;
  struct data d[N];
  while(1){
    cin >> n;
    if(n==0) break;
    for(i=0;i<n;i++){
      cin >> d[i].l >> d[i].p >> d[i].a >> d[i].b >> d[i].c;
      cin >> d[i].d >> d[i].e >> d[i].f >> d[i].s >> d[i].m;
      time=(d[i].a+d[i].b+d[i].c+d[i].d+d[i].e);
      d[i].m--;
      time+=(d[i].d+d[i].e)*d[i].m;
      d[i].cal=((double)d[i].f*d[i].s*(d[i].m+1)-d[i].p)/time;
    }
    for(i=0;i<n;i++){
      for(j=1;j<n;j++){
    if(d[j].l<d[j-1].l) swap(d[j],d[j-1]);
      }
    }
    for(i=0;i<n;i++){
      for(j=1;j<n;j++){
    if(d[j].cal>d[j-1].cal) swap(d[j],d[j-1]);
      }
    }
    for(i=0;i<n;i++) cout << d[i].l << endl;
    cout << '#' << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1212
final_rank: 3

code_snippet: #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
	int n;
	string al("abcdefghijklmnopqrstuvwxyz");
	while(cin>>n){
		if(n==0) break;
		string s[n];
		int a[n][9];
		for(int i=0;i<n;i++){
			cin>>s[i];
			for(int j=0;j<=8;j++){
				cin>>a[i][j];
			}
		}
		double ef[n];
		for(int i=0;i<n;i++){
			double x=a[i][7]*a[i][6]*a[i][8]-a[i][0];
			double y=a[i][1]+a[i][2]+a[i][3]+(a[i][4]+a[i][5])*a[i][8];
			ef[i]=x/y;
		}
		for(int i=0;i<n;i++){
			double me=-100;
			int ms;
			for(int j=0;j<n;j++){
				if(ef[j]>me){
					me=ef[j];
					ms=j;
				}
				else if(ef[j]==me){
					for(int moji=0;moji<30;moji++){
						int m1=-1,m2=-1;
						for(int z=0;z<26;z++){
							if(s[ms][moji]==al[z]) m1=z;
							if(s[j][moji]==al[z]) m2=z;
						}
						if(m1<m2){
							break;
						}
						else if(m1>m2){
							ms=j;
							break;
						}
					}
				}
			}
			cout<<s[ms]<<endl;
			ef[ms]=-200;
		}
		cout<<"#"<<endl;
	}
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1216
final_rank: 5

code_snippet: #include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <bitset>
#include <fstream>
using namespace std;

#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl

typedef pair<double, string> P;

bool sorter(const P p1, const P p2){
    if(p1.first==p2.first) return p1.second < p2.second;
    else return p1.first > p2.first;
}

int main(){
    int n;
    while(cin>>n ,n){
        vector<P> vec;
        rep(i,n){
            int p,a,b,c,d,e,f,s,m;
            string l;
            cin>>l>>p>>a>>b>>c>>d>>e>>f>>s>>m;
            vec.pb(mp(1.*(f*s*m-p)/(a+b+c+(d+e)*m), l));
        }
        sort(all(vec), sorter);
        rep(i,n){
            cout<<vec[i].second<<endl;
        }
        cout<<"#"<<endl;
    }

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1224
final_rank: 1

code_snippet: #include<iostream>
#include<algorithm>
#include<string>

using namespace std;

#define NMAX 50

typedef struct s{
	string L;
	double P,A,B,C,D,E,F,S,M;
} S;

bool operator<(S a,S b){
	double aa=(a.F*a.S*a.M-a.P)/((a.A+a.B+a.C+a.D+a.E)+(a.D+a.E)*(a.M-1));
	double bb=(b.F*b.S*b.M-b.P)/((b.A+b.B+b.C+b.D+b.E)+(b.D+b.E)*(b.M-1));
	return aa>bb||(aa==bb&&a.L<b.L);
}

int main(){

	int N;
	S data[NMAX];

	while(1){
		cin>>N;
		if(N==0) break;

		for(int i=0;i<N;i++){
			cin>>data[i].L>>data[i].P>>data[i].A>>data[i].B>>data[i].C>>data[i].D>>data[i].E>>data[i].F>>data[i].S>>data[i].M;
		}

		sort(data,data+N);

		for(int i=0;i<N;i++){
			cout<<data[i].L<<endl;
		}
		cout<<"#"<<endl;
	}

}
accuracy: 1
time_ms: 10
memory_kb: 1256
final_rank: 2