Problem:
You Are the Judge
審判は君だ！
English text is not available in this practice contest.
あなたはプログラミングコンテスト iCPC の審判だ。今日も何事もなく試合が終わり、後は結果を出力するだけだと思いきや、突然システムが停止してしまった！
これでは結果が出力できない！　でも、大丈夫。我々にはログがある。
あなたは優れたプログラマーであり、かつて iCPC で輝かしい成績を残したこともある。
そこであなたはシステムログから各チームの成績を割り出し、チームの順位表を出力するプログラムを作成することにした。
入力としてチームの数、問題の数、システムログが与えられる。
シムテムログは以下の 2 種類のレコードからなる。
レコード
内容
効果
tID pID time CORRECT
時刻 time に、チーム tID が 問題 pID に正解するプログラムを送信。
チーム tID の正解数に1が加算される。
チーム tID のペナルティに、(チーム tID の問題 pID に対する誤答数*1200+time)が加算される。
以後, チーム tID の問題 pID に対する解答は棄却され、システムログにも送信履歴が残らない。
tID pID time WRONG
時刻 time に、チーム tID が 問題 pID に誤答するプログラムを送信。
チーム tID の 問題 pID に対する誤答数に1が加算される。
※上記のシステムログはこの問題のために簡略化されたものであり、本番のICPCで見られるシステムログと異なることに留意せよ
iCPCにおける順位付けのルールは以下の通りである。
より多くの問題を解いたチームは順位が上になる
解いた問題が同じ場合、ペナルティの少ないチームのほうが順位が上になる
解いた問題もペナルティも同じ場合、チーム番号が小さいほうのチームが順位が上になる
入力より与えられるコンテストの情報・システムログから各チームの成績を割り出し、チームの順位表を出力せよ。
Input
入力は複数のデータセットからなる。各データセットは以下の形式で与えられる。
T
P
R
tID
1
pID
1
time
1
message
1
tID
2
pID
2
time
2
message
2
...
tID
R
pID
R
time
R
message
R
データセットの1行目には 参加チーム数 T 、問題数 P、システムログのレコード数 R が含まれる。
続くR行にはシステムログの各レコードが含まれる。
システムログのレコードとして、チーム番号 tID
i
、問題番号 pID
i
、試合開始からの経過時間 time
i
、メッセージの種類 message
i
が含まれる。
入力は以下の制約を満たす。
1 ≤ T ≤ 50
1 ≤ P ≤ 10
1 ≤ R ≤ 500
1 ≤ tID
i
≤ T
1 ≤ pID
i
≤ P
1 ≤ time
i
≤ 10800
message
i
は CORRECT, WRONGのいずれか
システムログのレコードは、時刻の小さいものから順に与えられ、複数のレコードの時刻が同じになることはない
入力の終わりはスペースで区切られた3個の0で与えられる。
Output
与えられたシステムログより各チームの成績・順位を割り出し、順位が上のチームから順に、チーム番号、正解数、ペナルティ を出力せよ。
Sample Input
3 3 5
3 1 800 WRONG
1 1 1200 CORRECT
3 1 1400 CORRECT
1 2 2400 CORRECT
1 3 3600 CORRECT
5 2 5
3 1 1000 WRONG
5 2 2000 CORRECT
3 1 2800 CORRECT
4 1 4000 CORRECT
5 1 5000 CORRECT
6 3 15
2 1 10 WRONG
3 3 15 WRONG
3 3 20 CORRECT
1 1 50 CORRECT
4 2 60 WRONG
1 2 70 WRONG
4 1 80 CORRECT
1 2 90 WRONG
1 2 150 CORRECT
3 1 160 WRONG
3 1 180 CORRECT
3 2 210 WRONG
5 3 500 CORRECT
4 2 720 CORRECT
5 1 1500 CORRECT
0 0 0
Output for Sample Input
1 3 7200
3 1 2600
2 0 0
5 2 7000
3 1 4000
4 1 4000
1 0 0
2 0 0
4 2 2000
5 2 2000
1 2 2600
3 2 2600
2 0 0
6 0 0

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

bool solve() {
    int T, P, R;
    cin >> T >> P >> R;
    if (T == 0 && P == 0 && R == 0) return false;
    vector<vector<bool>> AC(T, vector<bool>(P, false));
    vector<vector<int>> WA(T, vector<int>(P, 0));
    vector<int> cnt(T, 0), time(T, 0);
    while (R--) {
        int t, p, cur;
        string s;
        cin >> t >> p >> cur >> s;
        t--, p--;
        if (AC[t][p]) continue;
        if (s == "CORRECT") {
            AC[t][p] = true;
            cnt[t]++;
            time[t] += cur + 1200 * WA[t][p];
        } else {
            WA[t][p]++;
        }
    }
    vector<int> ord(T);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&] (int i, int j) {
        return cnt[i] == cnt[j] ? time[i] == time[j] ? i < j : time[i] < time[j] : cnt[i] > cnt[j];
    });
    for (int i : ord) {
        cout << i + 1 << ' ' << cnt[i] << ' ' << time[i] << '\n';
    }
    return true;
}

int main() {
    while (solve()) {}
}
accuracy: 1
time_ms: 10
memory_kb: 3456
final_rank: 15

code_snippet: // AOJ 2400 - You Are the Judge
// JAG Practice Contest for Japan Domestic 2012 - Problem B

#include <bits/stdc++.h>
using namespace std;

bool solving() {
  int T, P, R; cin >> T >> P >> R;
  if(T == 0) return false;

  vector<int> tID(R), pID(R), t(R);
  vector<string> m(R);
  for(int i=0; i<R; ++i) {
    cin >> tID[i] >> pID[i] >> t[i] >> m[i];
    --tID[i]; --pID[i];
  }

  vector<vector<int>> WA(T, vector<int>(P));
  vector<pair<pair<int,int>, int>> score(T);
  for(int i=0; i<T; ++i) score[i].second = i+1;
  for(int i=0; i<R; ++i) {
    if(m[i] == "CORRECT") {
      --score[tID[i]].first.first;
      score[tID[i]].first.second += t[i] + 1200 * WA[tID[i]][pID[i]];
    } else {
      ++WA[tID[i]][pID[i]];
    }
  }
  sort(score.begin(), score.end());
  for(int i=0; i<T; ++i) {
    cout << score[i].second << ' ' << -score[i].first.first << ' ' << score[i].first.second << endl;
  }
  return true;
}

int main() {
  while(solving()) {}
}
accuracy: 1
time_ms: 10
memory_kb: 3404
final_rank: 10

code_snippet: #include<atcoder/all>
using namespace atcoder;

#include <bits/stdc++.h>
template<class T> inline bool chmin(T&a, T b){if(a > b){a = b; return true;}else{return false;}}
template<class T> inline bool chmax(T&a, T b){if(a < b){a = b; return true;}else{return false;}}
#define ll long long
#define double long double
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define mod (ll)(1e9+7)
#define inf (ll)(3e18+7)
#define eps (double)(1e-9)
#define pi (double) acos(-1)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
using namespace std;

struct ans {
    int idx, ac, pena;

    bool operator < (const ans &S) const {
        if(ac != S.ac) {
            return ac < S.ac;
        } else if (pena != S.pena) {
            return pena > S.pena;
        } else {
            return idx > S.idx;
        }
    }
};

void solve() {
    int t, p, r;
    cin >> t >> p >> r;
    
    if(t == 0 && p == 0 && r == 0)exit(0);
    
    vector<vector<int>> locked(t, vector<int>(p, 0));
    vector<vector<int>> pen(t, vector<int>(p));

    vector<ans> vec(t);
    rep(i, t)vec[i] = {i+1, 0, 0};

    rep(i, r) {
        int tid, pid, ti;
        string message;
        cin >> tid >> pid >> ti >> message;

        tid--;
        pid--;

        if(locked[tid][pid]) {
            continue;
        }
        
        if(message == "WRONG") {
            pen[tid][pid]++;
        } else {
            locked[tid][pid] = true;

            vec[tid].ac += 1;
            vec[tid].pena += 1200 * pen[tid][pid] + ti;
        }
    }

    sort(rall(vec));
    rep(i, t) {
        cout << vec[i].idx << " " << vec[i].ac << " " << vec[i].pena << endl;
    }
}

int main() {
    while(true)solve();
}
accuracy: 1
time_ms: 10
memory_kb: 3584
final_rank: 18

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main(){
  while(true){
    int t,p,r;
    cin>>t>>p>>r;
    if(t==0)break;
    vector<vector<bool>>solved(t,vector<bool>(p,false));
    vector<int>pena(t,0);
    vector<vector<int>>wa(t,vector<int>(p,0));
    while(r--){
      int tid,pid,time;
      string mes;
      cin>>tid>>pid>>time>>mes;
      tid--,pid--;
      if(solved[tid][pid])continue;
      if(mes=="CORRECT"){
        solved[tid][pid]=true;
        pena[tid]+=wa[tid][pid]*1200+time;
      }
      else wa[tid][pid]++;
    }
    vector<int>ans(t);
    iota(ans.begin(),ans.end(),0);
    sort(ans.begin(),ans.end(),[&](int l,int r){
      int acl=0,acr=0;
      for(int i=0;i<p;i++){
        acl+=solved[l][i];
        acr+=solved[r][i];
      }
      if(acl!=acr)return acl>acr;
      if(pena[l]!=pena[r])return pena[l]<pena[r];
      return l<r;
    });
    for(int i:ans){
      int ac=0;
      for(int j=0;j<p;j++)ac+=solved[i][j];
      cout<<i+1<<' '<<ac<<' '<<pena[i]<<endl;
    }
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3340
final_rank: 2

code_snippet: #include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

bool compareTeams(const vector<int>& a, const vector<int>& b) {
    if (a[0] != b[0]) {
        return a[0] > b[0];
    }
    if (a[1] != b[1]) {
        return a[1] < b[1];
    }
    return a[2] < b[2];
}

int main(void)
{
    int t, p, r;
    while (true)
    {
        cin >> t >> p >> r;
        if (t == 0 && p == 0 && r == 0)
        {
            break;
        }

        vector<int> correctCount(t, 0), penalty(t, 0);
        vector<vector<int> > wrongCount(t, vector<int>(p, 0));

        for (int i = 0; i < r; i++)
        {
            int teamId, questionId, time;
            string kindAns;
            cin >> teamId >> questionId >> time >> kindAns;

            if (kindAns == "WRONG")
            {
                wrongCount[teamId - 1][questionId - 1]++;
            }
            else if (kindAns == "CORRECT")
            {
                correctCount[teamId - 1]++;
                penalty[teamId - 1] += time + wrongCount[teamId - 1][questionId - 1] * 1200;
            }
        }

        vector<vector<int> > teams(t, vector<int>(3));

        for (int i = 0; i < t; i++)
        {
            teams[i][0] = correctCount[i];
            teams[i][1] = penalty[i];
            teams[i][2] = i + 1;
        }

        sort(teams.begin(), teams.end(), compareTeams);

        for (int i = 0; i < t;i++)
        {
            cout << teams[i][2] << " " << teams[i][0] << " " << teams[i][1] << endl;
        }
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3224
final_rank: 20

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
#define all(x) x.begin(),x.end()
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }
template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }

int solve() {
    int T, P, R;
    std::cin >> T >> P >> R;
    if (T == 0) return 1;
    std::vector<int> p(T), c(T);
    std::vector w(T, std::vector<int>(P));
    const int OK = -1;
    for (int i = 0; i < R; i++) {
        int tid, pid, ti;
        std::string mes;
        std::cin >> tid >> pid >> ti >> mes;
        tid--;
        pid--;
        if (w[tid][pid] == OK) continue;
        if (mes == "CORRECT") {
            p[tid] += ti + w[tid][pid] * 1200;
            c[tid]++;
            w[tid][pid] = OK;
        } else {
            w[tid][pid]++;
        }
    }
    using Tu = std::tuple<int, int, int>;
    std::vector<Tu> data;
    for (int i = 0; i < T; i++) {
        data.emplace_back(-c[i], p[i], i);
    }
    std::sort(data.begin(), data.end());
    for (int i = 0; i < T; i++) {
        auto [a, b, c] = data[i];
        std::cout << c + 1 << ' ' << -a << ' ' << b << std::endl;
    }
    return 0;
}

int main() {
    while (!solve());
}
accuracy: 1
time_ms: 10
memory_kb: 3456
final_rank: 15

code_snippet: #include<bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using ll=long long;
#define overload4(_1, _2, _3, _4, name, ...) name
#define rep1(n) for(ll i = 0; i < (n); ++i)
#define rep2(i, n) for(ll i = 0; i < (n); ++i)
#define rep3(i, a, b) for(ll i = (a); i < (b); ++i)
#define rep4(i, a, b, c) for(ll i = (a); i < (b); i += (c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep1(n) for(ll i=n;i--;)
#define rrep2(i,n) for(ll i=n;i--;)
#define rrep3(i,a,b) for(ll i=b;i-->(a);)
#define rrep4(i,a,b,c) for(ll i=(a)+((b)-(a)-1)/(c)*(c);i>=(a);i-=c)
#define rrep(...) overload4(__VA_ARGS__,rrep4,rrep3,rrep2,rrep1)(__VA_ARGS__)
//# define each(i,...) for(auto&& i:__VA_ARGS__)
//#define each1(i,a) for(auto&&i:a)
//#define each2(x,y,a) for(auto&&[x,y]:a)
//#define each3(x,y,z,a) for(auto&&[x,y,z]:a)
//#define each(...) overload4(__VA_ARGS__,each3,each2,each1)(__VA_ARGS__)
#define all(i) begin(i), end(i)
#define rall(i) (i).rbegin(), (i).rend()
#define Sort(a) sort(all(a))
#define Rev(a) reverse(all(a))
#define elif else if
template<class T> bool chmin(T &a, const T &b){ if(a > b){ a = b; return 1; } else return 0; }
template<class T> bool chmax(T &a, const T &b){ if(a < b){ a = b; return 1; } else return 0; }
template<class T> ll sum(const T& a){ return accumulate(all(a), 0LL); }
template<class T> auto min(const T& a){ return *min_element(all(a)); }
template<class T> auto max(const T& a){ return *max_element(all(a)); }
vector<ll> iota(ll n, ll begin = 0){ vector<ll> a(n); iota(a.begin(), a.end(), begin); return a; }
const int INF =0x3fffffff;
const ll INFll =0x1fffffffffffffff;// 4times ok
const int MOD= int(1e9)+7;
const int MODD=998244353;
using P= pair<int,int>;
using Pl= pair<ll,ll>;
using ld=long double;
using VVl=vector<vector<ll>>;
using VVd=vector<vector<ld>>;
using Vd=vector<ld>;
using tuplis =array<ll, 3>;
using quatro=array<ll,4>;
#define vec(type,name,...) vector<type> name(__VA_ARGS__)
#define vv(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
template<class T> using pq = priority_queue<T, vector<T>, greater<T>>;
const ll four[] = {0, 1, 0, -1, 0};
const ll eight[] = {0, 1, 1, 0, -1, -1, 1, -1, 0};
const ld EPS = 1e-9;
const ld PI = 3.1415926535897932;
ll gcd(ll a, ll b){ while(b){ ll c = b; b = a % b; a = c; } return a; }
ll lcm(ll a, ll b){ if(!a || !b) return 0; return a * b / gcd(a, b); }
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ a%=p; ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll isqr(ll x){ll r=sqrt(x)-1;while((r+1)*(r+1)<=x)r++;return r;}
vector<ll> divisor(ll x){vector<ll> ans; for(ll i = 1; i * i <= x; i++) if(x % i == 0) ans.push_back(i); rrep(ans.size() - (ans.back() * ans.back() == x)) ans.push_back(x / ans[i]); return ans; }
int scan(){ return getchar(); }
void scan(int& a){ scanf("%d", &a); }
void scan(unsigned& a){ scanf("%u", &a); }
void scan(long& a){ scanf("%ld", &a); }
void scan(long long& a){ scanf("%lld", &a); }
void scan(unsigned long long& a){ scanf("%llu", &a); }
void scan(char& a){ do{ a = getchar(); }while(a == ' ' || a == '\n'); }
void scan(float& a){ scanf("%f", &a); }
void scan(double& a){ scanf("%lf", &a); }
void scan(long double& a){ scanf("%Lf", &a); }
void scan(vector<bool>& a){ for(unsigned i = 0; i < a.size(); i++){ int b; scan(b); a[i] = b; } }
void scan(char a[]){ scanf("%s", a); }
void scan(string& a){ cin >> a; }
template<class T> void scan(vector<T>&);
template<class T, size_t size> void scan(array<T, size>&);
template<class T, class L> void scan(pair<T, L>&);
template<class T, size_t size> void scan(T(&)[size]);
template<class T> void scan(vector<T>& a){ for(auto&& i : a) scan(i); }
template<class T> void scan(deque<T>& a){ for(auto&& i : a) scan(i); }
template<class T, size_t size> void scan(array<T, size>& a){ for(auto&& i : a) scan(i); }
template<class T, class L> void scan(pair<T, L>& p){ scan(p.first); scan(p.second); }
template<class T, size_t size> void scan(T (&a)[size]){ for(auto&& i : a) scan(i); }
template<class T> void scan(T& a){ cin >> a; }
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){ scan(head); in(tail...); }
void print(){ putchar(' '); }
void print(bool a){ printf("%d", a); }
void print(int a){ printf("%d", a); }
void print(unsigned a){ printf("%u", a); }
void print(long a){ printf("%ld", a); }
void print(long long a){ printf("%lld", a); }
void print(unsigned long long a){ printf("%llu", a); }
void print(char a){ printf("%c", a); }
void print(char a[]){ printf("%s", a); }
void print(const char a[]){ printf("%s", a); }
void print(float a){ printf("%.15f", a); }
void print(double a){ printf("%.15f", a); }
void print(long double a){ printf("%.15Lf", a); }
void print(const string& a){ for(auto&& i : a) print(i); }
template<class T> void print(const complex<T>& a){ if(a.real() >= 0) print('+'); print(a.real()); if(a.imag() >= 0) print('+'); print(a.imag()); print('i'); }
template<class T> void print(const vector<T>&);
template<class T, size_t size> void print(const array<T, size>&);
template<class T, class L> void print(const pair<T, L>& p);
template<class T, size_t size> void print(const T (&)[size]);
template<class T> void print(const vector<T>& a){ if(a.empty()) return; print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar(' '); print(*i); } }
template<class T> void print(const deque<T>& a){ if(a.empty()) return; print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar(' '); print(*i); } }
template<class T, size_t size> void print(const array<T, size>& a){ print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar(' '); print(*i); } }
template<class T, class L> void print(const pair<T, L>& p){ print(p.first); putchar(' '); print(p.second); }
template<class T, size_t size> void print(const T (&a)[size]){ print(a[0]); for(auto i = a; ++i != end(a); ){ putchar(' '); print(*i); } }
template<class T> void print(const T& a){ cout << a; }
int out(){ putchar('\n'); return 0; }
template<class T> int out(const T& t){ print(t); putchar('\n'); return 0; }
template<class Head, class... Tail> int out(const Head& head, const Tail&... tail){ print(head); putchar(' '); out(tail...); return 0; }
#define INT(...) int __VA_ARGS__; in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__; in(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__; in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__; in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__; in(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__; in(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__; in(__VA_ARGS__)
#define VEC(type,name,size) vector<type> name(size); in(name)
#define VV(type, name, h, w) vector<vector<type>> name(h, vector<type>(w)); in(name)

bool solve(){
    LL(t,p,r);
    if(t==0)return false;
    vec(Pl,score,t);
    map<Pl,ll>cnt;
    rep(r){
        LL(ti,pi,mi);
        STR(x);
        ll j=0;
        if(x=="WRONG")j=1;
        ti--;
        if(j!=0){
            cnt[{ti,pi}]++;
        }
        else{
            score[ti].first++;
            score[ti].second+=mi+cnt[{ti,pi}]*1200;
        }
    }
    vector<tuplis>X;
    rep(t){
        X.push_back({score[i].first,-score[i].second,-i});
    }
    Sort(X);
    Rev(X);
    rep(t){
        out(-X[i][2]+1,X[i][0],-X[i][1]);
    }
    return true;
}

int main(){
    ll t=1;
//    in(t);
    while(solve());
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3588
final_rank: 19

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
    while(true){
        ll T,P,R;
        cin >> T >> P >> R;
        if(T==0&&P==0&&R==0)break;
        vector<ll>tID(R);
        vector<ll>pID(R);
        vector<ll>time(R);
        vector<string>message(R);
        for(ll i=0;i<R;i++){
            cin >> tID[i] >> pID[i] >> time[i] >> message[i];
        }

        vector<vector<ll>>WA_cnt(P,vector<ll>(T));
        vector<tuple<ll,ll,ll>>info(T,{0,0,0});
        for(ll i=0;i<T;i++){
            get<2>(info[i])=i;
        }
        for(ll i=0;i<R;i++){
            if(message[i]=="WRONG"){
                WA_cnt[pID[i]-1][tID[i]-1]++;
            }else{
                get<0>(info[tID[i]-1])++;
                get<1>(info[tID[i]-1])+=WA_cnt[pID[i]-1][tID[i]-1]*1200+time[i];
            }
        }
        for(ll i=0;i<T;i++){
            get<1>(info[i]) = 100000000-get<1>(info[i]);
            get<2>(info[i]) = 100-get<2>(info[i]);
        }

        sort(info.rbegin(),info.rend());
        for(int i=0;i<T;i++){
            cout << 100-get<2>(info[i])+1 << " " << get<0>(info[i]) << " " << 100000000-get<1>(info[i]) << endl;
        }
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3400
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;

#define rep(i,k,n) for (int i = k; i < (n); ++i)
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
typedef long long ll;
typedef pair<ll, ll> P;
const long long INF = 1e17;

int main(){
    while(true){
        int t,p,r;
        cin >> t>>p>>r;
        if(t==0){
            break;
        }

        vector<int> tID(r),pID(r),time(r);
        vector<string> message(r);

        vector<int> ac(t),pena(t);
        vector wa(t,vector<int>(p));

        for(int i=0;i<r;i++){
            int x,y;
            cin >> x >> y;
            x--;
            y--;
            tID[i] = x;
            pID[i] = y;
            cin >> time[i] >> message[i];
        }

        for(int i=0;i<r;i++){
            if(wa[tID[i]][pID[i]]==-1)continue;
            if(message[i]=="CORRECT"){
                ac[tID[i]]++;
                pena[tID[i]] += wa[tID[i]][pID[i]]*1200 + time[i];
                wa[tID[i]][pID[i]] = -1;
            }
            if(message[i]=="WRONG"){
                wa[tID[i]][pID[i]]++;
            }
        }

        vector<tuple<int,int,int>> cnt(t);
        for(int i=0;i<t;i++){
            cnt[i] = {-ac[i],pena[i],i};
        }
        sort(cnt.begin(),cnt.end());

        for(int i=0;i<t;i++){
            cout << get<2>(cnt[i]) + 1 << ' ' << -get<0>(cnt[i]) << ' ' << get<1>(cnt[i]) <<endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3400
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (long long i=0;i<n;i++)
#define loop(i,m,n) for(long long i=m;i<=n;i++)
#define range(value,range) for(const auto &value : range)
#define ll long long
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define vdbg(a) rep(ii,a.size()){cout<<a[ii]<<" ";}cout<<endl;
#define vvdbg(a) rep(ii,a.size()){rep(jj,a[ii].size()){cout<<a[ii][jj]<<" ";}cout<<endl;}
#define inf 4000000000000000000LL
#define mod 998244353

ll solve() {
    ll t,p,r;
    cin>>t>>p>>r;
    if(t==0&&p==0&&r==0)return 1;

    vvl g(t,vl(p,0));
    vvl ans(t,vl(3,0));
    rep(i,t)ans[i][2]=i+1;
    rep(z,r){
        ll tid,pid,time;
        string mes;
        cin>>tid>>pid>>time>>mes,pid--,tid--;
        if(mes=="WRONG"){
            g[tid][pid]++;
        }else{
            ans[tid][0]--;
            ans[tid][1]+=1200*g[tid][pid]+time;
        }
    }
    sort(ans.begin(),ans.end());
    rep(i,t)ans[i][0]*=-1;
    rep(i,t){
        cout<<ans[i][2]<<" "<<ans[i][0]<<" "<<ans[i][1]<<endl;
    }
    //vvdbg(ans);
    return 0;
}
int main(){
	while(1){
		if(solve()==1)break;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3460
final_rank: 17

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (long long i=0;i<n;i++)
#define loop(i,m,n) for(long long i=m;i<=n;i++)
#define range(value,range) for(const auto &value : range)
#define ll long long
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define vdbg(a) rep(ii,a.size()){cout<<a[ii]<<" ";}cout<<endl;
#define vvdbg(a) rep(ii,a.size()){rep(jj,a[ii].size()){cout<<a[ii][jj]<<" ";}cout<<endl;}
#define inf 4000000000000000000LL
#define mod 998244353

ll solve() {
    ll t,p,r;
    cin>>t>>p>>r;
    if(t==0&&p==0&&r==0)return 1;

    vvl g(t,vl(p,0));
    vvl ans(t,vl(3,0));
    rep(i,t)ans[i][2]=i+1;
    rep(z,r){
        ll tid,pid,time;
        string mes;
        cin>>tid>>pid>>time>>mes,pid--,tid--;
        if(mes=="WRONG"){
            g[tid][pid]++;
        }else{
            ans[tid][0]--;
            ans[tid][1]+=1200*g[tid][pid]+time;
        }
    }
    sort(ans.begin(),ans.end());
    rep(i,t)ans[i][0]*=-1;
    rep(i,t){
        cout<<ans[i][2]<<" "<<ans[i][0]<<" "<<ans[i][1]<<endl;
    }
    //vvdbg(ans);
    return 0;
}
int main(){
	while(1){
		if(solve()==1)break;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3372
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;

void solve(ll t, ll p, ll r){
    vector<ll> ac(t, 0);
    vector<ll> pena(t, 0);
    vector<vector<ll>> wa_cnt(t, vector<ll>(p, 0));

    for(int rid = 0; rid < r; rid++){
        ll tid, pid, time; string msg;
        cin >> tid >> pid >> time >> msg;
        tid--; pid--;

        if(msg == "CORRECT"){
            ac[tid]++;
            pena[tid] += (wa_cnt[tid][pid] * 1200 + time);
        }
        else if(msg == "WRONG"){
            wa_cnt[tid][pid]++;
        }
        else{
            cerr << "Invalid msg" << endl;
            assert(false);
        }
    }

    vector<int> ord(t);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](const auto &p, const auto & q){
        if(ac[p] != ac[q]) return ac[p] > ac[q];
        else if(pena[p] != pena[q]) return pena[p] < pena[q];
        else return p < q;
    });

    for(int i = 0; i < ord.size(); i++){
        int tid = ord[i];
        cout << tid+1 << " " << ac[tid] << " " << pena[tid] << endl;
    }
}

int main(){
    while(true){
        ll t, p, r; cin >> t >> p >> r;
        if(t == 0 && p == 0 && r == 0) break;
        else solve(t, p, r);
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3444
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define all(a) a.begin(),a.end()
#define reps(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
#define rreps(i, a, n) for (int i = (a); i > (int)(n); i--)
const long long mod = 1000000007;
const long long INF = 1e18;

int t,p,r;

void solve() {
    vector<vector<int>> v (t,vector<int> (3));
    map<pair<int,int>,int> mp;
    rep(i,t) {
        v[i][0] = 0;
        v[i][1] = 0;
        v[i][2] = (i+1);
    }
    int tm, te, num;
    string acc;
    rep(w,r) {
        cin >> te >> num >> tm >> acc;
        if (acc == "CORRECT") {
            v[te-1][0]--;
            if (mp.find({te,num}) != mp.end()) {
                v[te-1][1] += tm + mp[{te,num}]*1200;
            }
            else {
                v[te-1][1] += tm;
            }
        }
        else {
            mp[{te,num}]++;
        }
    }

    sort(all(v));
    rep(i,t) {
        cout << v[i][2] << ' ' <<  -v[i][0] << ' ' << v[i][1] << endl;
    }
    return;
}



int main() {
    while (true) {
        cin >> t >> p >> r;
        if (t == 0) {
            return 0;
        }
        solve();
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3396
final_rank: 7

code_snippet: #include <bits/stdc++.h>

using namespace std;

int main() {
    while (true) {
        int t, p, r;
        cin >> t >> p >> r;

        if (t == 0 && p == 0 && r == 0) {
            break;
        }

        int tid[r], pid[r], ttime[r];
        string message[r];
        for (int i = 0; i < r; i++) {
            cin >> tid[i] >> pid[i] >> ttime[i] >> message[i];
        }

        int acproblem[t+1];
        int waproblem[t+1][p+1];
        int penalty[t+1];
        memset(acproblem, 0, sizeof(acproblem));
        memset(waproblem, 0, sizeof(waproblem));
        memset(penalty, 0, sizeof(penalty));
        for (int i = 0; i < r; i++) {
            if (message[i] == "CORRECT") {
                acproblem[tid[i]]++;
                penalty[tid[i]] += waproblem[tid[i]][pid[i]]*1200 + ttime[i];
            } else {
                waproblem[tid[i]][pid[i]]++;
            }
        }

        vector<tuple<int, int, int> > viii(t);
        for (int i = 1; i <= t; i++) {
            viii[i-1] = {-acproblem[i], penalty[i], i};
        }

        sort(viii.begin(), viii.end());

        for (int i = 0; i < t; i++) {
            cout << get<2>(viii[i]) << " " << -get<0>(viii[i]) << " " << get<1>(viii[i]) << endl;
        }
    }

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3368
final_rank: 5

code_snippet: #include <bits/stdc++.h>

bool solve() {
    int T, P, R; std::cin >> T >> P >> R;
    if (T == 0 and P == 0 and R == 0) return false;

    std::vector<int> count(T), penalty(T);
    std::vector ac(T, std::vector<bool>(P));
    std::vector wa(T, std::vector<int>(P));
    for (int _{} ; _ < R ; _++) {
        int t, p, time; std::cin >> t >> p >> time;
        t--; p--;
        std::string s; std::cin >> s;
        if (ac[t][p]) continue;
        if (s[0] == 'C') {
            ac[t][p] = true;
            count[t]++;
            penalty[t] += time + wa[t][p] * 1200;
        }
        else {
            wa[t][p]++;
        }
    }

    std::vector<int> ans(T);
    std::iota(ans.begin(), ans.end(), 0);
    std::sort(ans.begin(), ans.end(), [&](int i, int j) -> bool {
            if (count[i] != count[j]) return count[i] > count[j];
            else if (penalty[i] != penalty[j]) return penalty[i] < penalty[j];
            else return i < j;
            });
    for (int i{} ; i < T ; i++) {
        int v{ans[i]};
        std::cout << v + 1 << ' ' << count[v] << ' ' << penalty[v] << '\n';
    }
    return true;
}

int main() {
    for (int i{} ; solve() ; i++) {
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3444
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
    while(1) {
        int T, P, R;
        cin >> T >> P >> R;
        if (T == 0 && P == 0 && R == 0) return 0;
        vector<int> Pena(T,0), AC(T,0);
        vector<vector<int>> WA(T, vector<int>(P, 0));
        for (int i = 0; i < R; i++) {
            int TID, PID, TIME;
            string S;
            cin >> TID >> PID >> TIME >> S;
            TID--, PID--;
            if (S == "CORRECT") {
                AC[TID]++;
                Pena[TID]+=WA[TID][PID]*1200+TIME;
            }
            else if (S == "WRONG") {
                WA[TID][PID]++;
            }
        }
        vector<pair<int, pair<int, int> > > V;
        for (int i = 0; i < T; i++) V.push_back({P - AC[i], {Pena[i], i}});
        sort(V.begin(), V.end());
        for (int i = 0; i < T; i++) {
            cout << V[i].second.second + 1 << ' ' << P - V[i].first << ' ' << V[i].second.first << endl;
        }
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3444
final_rank: 11

code_snippet: #include <bits/stdc++.h>

int solve() {
    int n, m, q;
    std::cin >> n >> m >> q;
    if (n == 0) return 1;

    std::vector<std::pair<int, int>> result(n);
    std::vector penalty(n, std::vector<int>(m));

    for (int i = 0; i < q; i++) {
        int a, b, t;
        std::string s;
        std::cin >> a >> b >> t >> s;
        a--; b--;
        if (s == "CORRECT") {
            result[a].first++;
            result[a].second += penalty[a][b] + t;
        } else {
            penalty[a][b] += 1200;
        }
    }

    std::vector<int> ans(n);
    std::iota(ans.begin(), ans.end(), 0);
    std::sort(ans.rbegin(), ans.rend(), 
            [&](int lhs, int rhs) {
                auto [la, lb] = result[lhs];
                auto [ra, rb] = result[rhs];
                if (la == ra && lb == rb) {
                    return rhs < lhs;
                }
                if (la == ra) {
                    return rb < lb;
                }
                return la < ra;
            });

    for (auto i: ans) {
        auto [a, b] = result[i];
        std::cout << i + 1 << ' ' << a << ' ' << b << std::endl;
    }
    return 0;
}

int main() {
    while (!solve());
}
accuracy: 1
time_ms: 10
memory_kb: 3360
final_rank: 3

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> Pi;
typedef pair<Pi, int> PPi;
int main(){
    int t, p, r, td, pd, ti;
    string ms;
    while(cin >> t >> p >> r, t){
        int score[51][11]={};
        int wrong[51][11]={};
        int sum[51]={};
        for(int i=0;i<r;i++){
            cin >> td >> pd >> ti >> ms;
            if(ms == "CORRECT"){
                if(score[td][pd]>0) continue;
                score[td][pd] = ti;
                sum[td]++;
            } else if(ms == "WRONG"){
                wrong[td][pd]++;
            }
        }
        int pena[51]={};
        PPi ppi[51];
        for(int i=1;i<=t;i++){
            for(int j=1;j<=p;j++){
                if(score[i][j]>0) pena[i] += wrong[i][j]*1200 + score[i][j];
            }
            ppi[i-1] = PPi(Pi(-sum[i], pena[i]), i);
        }
        sort(ppi, ppi+t);
        for(int i=0;i<t;i++){
            Pi pi = ppi[i].first;
            cout << ppi[i].second << " " << -pi.first << " " << pi.second << endl;
        }
    }
    return(0);
}
accuracy: 1
time_ms: 10
memory_kb: 3176
final_rank: 1

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <stdio.h>
#include <math.h>
#include <set>
#include <map>
#include <queue>
#include <cassert>
#include <numeric>
#include <cstdio>


using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define P pair<int, int>


int main() {
	int t, p, r;
	int tid, pid, time;
	string message;

	cin >> t >> p >> r;
	while (t != 0) {
		vector<int>point(t);
		vector<int>penalty(t);
		vector<vector<int>>table(t, vector<int>(p));
		for (int i = 0;i < r;i++) {
			cin >> tid >> pid >> time >> message;
			tid--;pid--;
			if (message == "WRONG") {
				table[tid][pid]++;
			}
			else {
				point[tid]++;
				penalty[tid] += table[tid][pid] * 1200 + time;
			}
		}
		vector<vector<pair<int, int>>>table2(p+1);
		for (int i = 0;i < t;i++) {
			table2[point[i]].push_back(pair<int, int>(penalty[i], i + 1));
		}
		for (int i = 0;i < p+1;i++) {
			sort(table2[i].begin(), table2[i].end());
		}
		for (int i = p;i >=0;i--) {
			for (auto k : table2[i]) {
				cout << k.second << ' ' << i << ' ' << k.first << endl;
			}
		}
		cin >> t >> p >> r;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3360
final_rank: 3

code_snippet: #include "bits/stdc++.h"
using namespace std;
int main() {
	int T, P, R;
	cin >> T >> P >> R;
	while(T != 0) {
		vector<vector<int>> pena(T, vector<int>(P));
		vector<int> correct(T);
		vector<int> time(T);
		using TU = tuple<int, int, int>;
		for(int i = 0; i < R; i++) {
			int tID, pID, timeD;
			cin >> tID >> pID >> timeD;
			tID--;
			pID--;
			string message;
			cin >> message;
			if(message == "CORRECT") {
				correct[tID]++;
				time[tID] += timeD;
				time[tID] += pena[tID][pID] * 1200;
			} else {
				pena[tID][pID]++;
			}
		}
		vector<TU> VT;
		for(int i = 0; i < T; i++) {
			VT.emplace_back(correct[i], -time[i], -i);
		}
		sort(VT.begin(), VT.end());
		reverse(VT.begin(), VT.end());
		for(int i = 0; i < T; i++) {
			auto [c, t, id] = VT[i];
			t = -t;
			id = -id + 1;
			cout << id << " " << c << " " << t << endl;
		}
		cin >> T >> P >> R;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 3452
final_rank: 14