import scala.collection.mutable
import scala.io.StdIn

/**
  * Created by Administrator on 2016/11/25 0025.
  */


class Question($star: Int) {
  val star = $star
  private[this] var _countSolved: Int = 0

  def countSolved: Int = _countSolved

  private def countSolved_=(value: Int): Unit = {
    _countSolved = value
  }


  def beSolved: Int = {
    _countSolved += 1
    _countSolved
  }

}

class User($name: String) {
  private var totalScore = -1
  private var mapQuesIndex2Score = new mutable.HashMap[Int,Double]()

  def toString(problems: mutable.HashMap[Int, Question]): String = {
    def singleQustionCalc(question: Question, solvedOrder: Int): Double = {
      math.floor(50 * question.star + (50 * question.star) / ((8 + 2 * solvedOrder) / 10.0))
    }

    if (totalScore == -1) {
      for(i<-problems.keys){
        if(mapQuesIndex2SolvedOrder.contains(i)){
          mapQuesIndex2Score+=(i->singleQustionCalc(problems(i),mapQuesIndex2SolvedOrder(i)))
        }else{
          mapQuesIndex2Score+=(i->0.0)
        }
      }
      totalScore = {
        var $ = 0.0
        for(i<-mapQuesIndex2Score.keys){
          $+=mapQuesIndex2Score(i)
        }
        $.toInt
      }
    }
    var result = {
      var $ = ""
      for(i<- 0 until mapQuesIndex2Score.size){
        if(i>0){
          $+=" "
        }
        $+=mapQuesIndex2Score(i).toInt
      }
      $+=(" "+totalScore)
      $
    }
    result
  }

  def getTotal:Int={
    require(totalScore>=0)
    return totalScore
  }

  private var order = 0
  val name = $name
  private var mapQuesIndex2SolvedOrder = new mutable.HashMap[Int, Int]()

  def setOrder(int: Int): User = {
    this.order = int
    this
  }
  def getOrder:Int=order

  def solve(index: Int, solvedOrder: Int): User = {
    mapQuesIndex2SolvedOrder += (index -> solvedOrder)
    this
  }
}

object Users {
  /**
    * 0->Question1{star 1;2 men solved me}
    */
  private var problemsIndex2Question = new mutable.HashMap[Int, Question]()
  private var users = new mutable.LinkedHashMap[String, User]()
  private var usersList:List[(String, User)] = null

  def initStars(ints: Array[Int]): Users.type = {
    for (i <- ints.indices) {
      problemsIndex2Question += (i -> new Question(ints(i)))
    }
    return this
  }

  private def char2Index(chars: String): Int = chars.charAt(0) - 'A'

  def whoSolvedWhich(name: String, problem: String): Users.type = {
    val proIndex = char2Index(problem)
    if (problemsIndex2Question.contains(proIndex)) {
      problemsIndex2Question(proIndex).beSolved
    } else {
      //不可能啊 应该都在
      throw new Exception("I'll never show")
    }
    if (users.contains(name)) {
      users(name).solve(proIndex, problemsIndex2Question(proIndex).countSolved)
    } else {
      users.+=(name -> new User(name).solve(proIndex, problemsIndex2Question(proIndex).countSolved))
    }
    return this
  }

  def setUserOrder(name: String, order: Int): Users.type = {
    require(users.contains(name), "这个函数必须在whoSolvedWhich后执行")
    users(name).setOrder(order)
    return this
  }

  def sortUsers: Users.type ={
    usersList = users.toList
    for(i<-usersList){
      i._2.toString(problemsIndex2Question)
    }

    usersList = usersList.sortWith((a,b)=>{
      (a._2.getTotal>b._2.getTotal) match {
        case true=>true
        case false=>{
          (a._2.getTotal<b._2.getTotal) match {
            case true=>false
            case false=>a._2.getOrder<b._2.getOrder
          }
        }
      }
    })

    this
  }

  def printAfterSort={
    for(i<-usersList.indices){
      println(s"${i+1} ${usersList(i)._1} ${usersList(i)._2.toString(problemsIndex2Question)}")
    }
  }


}

/*object UserOrder{
  private var map = new mutable.HashMap[String,Int]()
  def push(username:String): UserOrder.type ={
    if(!map.contains(username)){
      map+=(username->(map.size+1))
    }else{
      for(i<-map.keys if map(i) > map(username)){
        map(i)-=1
      }
      map(username) = map.size
    }
    return this
  }
  def getMap: mutable.Map[String, Int] = map
}*/

object Main extends App {
  //  val order = UserOrder
  val users = Users.initStars(
    {
      //noinspection ScalaUnusedSymbol
      val countQuestions = StdIn.readInt()
      StdIn.readLine().split(" ").map(x => x.toInt)
    }
  )

  val T = StdIn.readInt()


  for (i <- 1 to T) {
    /**
      * name=username
      * ques = "ABCD...."
      */
    val Array(name, ques) = StdIn.readLine().split(" ")
    Users.whoSolvedWhich(name, ques).setUserOrder(name, i)
    //    order.push(name)

  }
  users.sortUsers.printAfterSort


  print("")


}