Go: // You Are the Judge(審判は君だ！)
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2400&lang=jp
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type Team struct {
	TID         int
	Accepted    int
	WrongAnswer map[int]int
	Penalty     int
}

type Teams []Team

func (t Teams) Len() int      { return len(t) }
func (t Teams) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
func (t Teams) Less(i, j int) bool {
	// より多くの問題を解いたチームは順位が上になる
	if t[i].Accepted > t[j].Accepted {
		return true
	} else if t[i].Accepted == t[j].Accepted {
		// 解いた問題が同じ場合、ペナルティの少ないチームのほうが順位が上になる
		if t[i].Penalty < t[j].Penalty {
			return true
		} else if t[i].Penalty == t[j].Penalty {
			// 解いた問題もペナルティも同じ場合、チーム番号が小さいほうのチームが順位が上になる
			if t[i].TID < t[j].TID {
				return true
			}
		}
	}
	return false
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	for {
		t, p, r := nextInt(sc), nextInt(sc), nextInt(sc)
		if t == 0 && p == 0 && r == 0 {
			break
		}

		teams := []Team{}
		for tID := 0; tID < t; tID++ {
			teams = append(teams, Team{tID + 1, 0, map[int]int{}, 0})
		}

		for i := 0; i < r; i++ {
			tID, pID, time, message := nextInt(sc), nextInt(sc), nextInt(sc), nextString(sc)
			tID--

			if message == "CORRECT" {
				teams[tID].Accepted++
				wa, _ := teams[tID].WrongAnswer[pID]
				teams[tID].Penalty += wa*1200 + time
			} else {
				teams[tID].WrongAnswer[pID]++
			}
		}

		sort.Sort(Teams(teams))

		for _, team := range teams {
			fmt.Println(team.TID, team.Accepted, team.Penalty)
		}
	}
}

func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

func nextString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

C++: #include <bits/stdc++.h>
using namespace std;
#define FOR(i, s, n) for(int i = s; i < (int)n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= (int)n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << "\n"
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define MP make_pair
#define EACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define NCLR(a) memset((a), -1 ,sizeof(a))
#define dump(x) cout << #x << " = " << (x) << "\n";
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << "\n";
#define sq(n) (n) * (n)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef priority_queue<int> maxpq;
typedef priority_queue< int, vector<int>, greater<int> > minpq;
typedef complex<double> P;
static const double EPS = 1e-10;
static const double PI = acos( -1.0 );
static const int mod = 1000000007;
static const int INF = 1 << 29;
static const LL LL_INF = 1152921504606846976;
static const int dx[] = { -1, 0, 1, 0, 1, -1, 1, -1 };
static const int dy[] = { 0, -1, 0, 1, 1, 1, -1, -1 };


map<PII, int> m;
int main() {
	vector<pair<PII, int> > team;
	int t, r, p;
	while ( ~scanf( "%d %d %d", &t, &p, &r ) && t && p && r ) {
		team.resize( t );
		for ( int i = 0; i < t; i++ ) {
			team[ i ] = pair<PII, int>( PII( 0, 0 ), -i - 1 );
		}
		for ( int i = 0; i < r; i++ ) {
			int tid, pid, time;
			string str;
			cin >> tid >> pid >> time >> str;
			if ( str == "WRONG" ) {
				m[ make_pair( tid, pid ) ]++;
			}
			else {
				team[ tid - 1 ].first.first++;
				team[ tid - 1 ].first.second -= ( m[ make_pair( tid, pid ) ] * 1200 ) + time;
			}
		}
		sort( team.rbegin(), team.rend() );
		for ( int i = 0; i < team.size(); i++ ) {
			printf( "%d %d %d\n", -team[ i ].second, team[ i ].first.first, -team[ i ].first.second );
		}

		m.clear();
	}
	return 0;
}

C++: #include <vector>
#include <iostream>
#include <utility>
#include <algorithm>
#include <string>
#include <deque>
#include <queue>
#include <tuple>
#include <queue>
#include <functional>
#include <cmath>
#include <iomanip>
#include <map>
#include <set>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
#include <complex>
#include <iterator>
#include <array>
#include <memory>
#include <stack>
#define vi vector<int>
#define vvi vector<vector<int> >
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,s,n) for(int i=s;i<n;i++)
#define all(in) in.begin(), in.end()
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<double,double>pdd;
typedef pair<ll,ll>pll;
class data{
public:
    ll penalty=0;
    ll corect=0;
    bool flag[1000];
    int wrong[1000]={0};
    void inti(){penalty=0; corect=0;rep(i,1000)flag[i]=false;}
};
int main(){
    int t,p,r;
    while(cin>>t>>p>>r,t+p+r){
        map<string,data>mp;
        vector<string>ujimatu;
        vector<data>gotiusa(t+1);
        rep(i,t+1)gotiusa[i].inti();
        rep(i,r){
            int tid,pid,_time;
            string s;
            cin>>tid>>pid>>_time>>s;
            if(s=="WRONG"){
                if(gotiusa[tid].flag[pid])continue;
                gotiusa[tid].wrong[pid]++;
            }else{
                if(gotiusa[tid].flag[pid])continue;
                gotiusa[tid].penalty+=gotiusa[tid].wrong[pid]*1200+_time;
                gotiusa[tid].corect++;
                gotiusa[tid].flag[pid]=true;
            }
        }
        typedef pair<pii,int>piii;
        vector<piii>rize(t+1);
        rep(i,t+1){
        if(!i)continue;
        rize.push_back(piii(pii(gotiusa[i].corect,-gotiusa[i].penalty),-i));
        }
        sort(all(rize),greater<piii>());
        rep(i,t)cout<<-1*rize[i].second<<" "<<gotiusa[-1*rize[i].second].corect<<" "<<gotiusa[-1*rize[i].second].penalty<<endl;
        }
}

C++: #include <stdio.h>
#include <stdlib.h>

typedef struct {int id, solved, penalty;} Team;

int compare(const void *a, const void *b) {
	const Team ta = *(Team *)a, tb = *(Team *)b;

	if (ta.solved != tb.solved)
		return tb.solved - ta.solved;
	if (ta.penalty != tb.penalty)
		return ta.penalty - tb.penalty;
	return ta.id - tb.id;
}

int main(void) {
	int i;
	int t, p, r;

	while (scanf("%d %d %d", &t, &p, &r), t) {
		Team team[50] = {0};
		int wrong[50][10] = {0};

		for (i = 0; i < t; i++)
			team[i].id = i + 1;

		for (i = 0; i < r; i++) {
			int tid, pid, t;
			char mes[10];

			scanf("%d %d %d %s", &tid, &pid, &t, mes);
			tid--;
			pid--;

			if (mes[0] == 'C') {
				team[tid].solved++;
				team[tid].penalty += wrong[tid][pid] * 1200 + t;
			} else
				wrong[tid][pid]++;
		}

		qsort(team, t, sizeof(Team), &compare);

		for (i = 0; i < t; i++)
			printf("%d %d %d\n", team[i].id, team[i].solved, team[i].penalty);
	}

	return 0;
}