Submission #732210

---

Source Code Expand

object Main extends App {
  import java.{ util => ju }
  import scala.annotation._
  import scala.collection._
  import scala.collection.{ mutable => mu }
  import scala.collection.JavaConverters._
  import scala.math._

  val sc = new ju.Scanner(System.in)

  solveD()

  def solveA() {
    println(sc.nextInt() - sc.nextInt())
  }

  def solveB() {
    val m = sc.nextInt()

    val s = m match {
      case (a) if a < 100    => "00"
      case (a) if a < 6000   => "%02d".format(a / 100)
      case (a) if a < 35000  => a / 1000 + 50
      case (a) if a <= 70000 => (a / 1000 - 30) / 5 + 80
      case _                 => "89"
    }

    println(s)
  }

  def solveC() {
    val deg, dis = sc.nextInt()
    val sPerm = scala.math.BigDecimal(dis.toDouble / 60.0).setScale(1, scala.math.BigDecimal.RoundingMode.HALF_UP).toDouble
    val windPow = getWindPower(sPerm)
    if (windPow == 0) {
      println("C 0")
      return
    }
    val windDir = getWindDir(deg)
    println(windDir + " " + windPow)
  }

  def solveD() {
    val N = sc.nextInt()
    var table = new Array[Int](24 * 60 / 5 + 1)
    (0 until N).foreach { _ =>
      val Array(s, e) = sc.next().split("-").map(_.toInt).map(x => x / 100 * 60 + x % 100)
      table(s / 5) += 1
      table((e + 4) / 5) -= 1
    }

    //    println(table.deep)
    var s = -1
    var v = 0
    for (i <- 0 until table.length) {
      v += table(i)
      if (s > -1 && v == 0) {
        printf("%02d%02d-%02d%02d\r\n", s * 5 / 60, s * 5 % 60, i * 5 / 60, i * 5 % 60)
        s = -1
      } else if (s == -1 && v > 0) {
        s = i
      }
    }

  }

  def solveDOther() {
    val table = Array.fill(1441)(0)
    (1 to sc.nextInt()).foreach { _ =>
      val Array(s, e) = sc.next().split("-").map(_.toInt).map(x => (x / 100 * 60) + (x % 100))
      val s2 = s / 5 * 5
      val e2 = if (e % 5 == 0) e else (e / 5 + 1) * 5
      table(s2) += 1
      table(e2) -= 1
    }

    var start: List[Int] = Nil
    var end: List[Int] = Nil
    table.zipWithIndex.foldLeft(0) {
      case (acc, (c, i)) =>
        val sum = acc + c
        if (acc == 0 && c >= 1) start ::= i
        if (acc >= 1 && sum == 0) end ::= i
        sum
    }

    def minToHHMM(min: Int) = (min / 60).formatted("%02d") + (min % 60).formatted("%02d")

    (start zip end).reverse.map {
      case (s, e) => minToHHMM(s) + "-" + minToHHMM(e)
    }.foreach(println)

    def t2n(x: Int) = (x / 100) * 12 + (x % 100) / 5 // hhmm -> 5min table index
    def n2t(x: Int) = (x / 12) * 100 + (x % 12) * 5 // 5min table index -> hhmm
  }

  def getWindDir(s: Int): String = {
    var index = 112
    s match {
      case (a) if a <= index           => "N"
      case (a) if a <= index + 225 * 1 => "NNE"
      case (a) if a <= index + 225 * 2 => "NE"
      case (a) if a <= index + 225 * 3 => "ENE"
      case (a) if a <= 1012            => "E"
      case (a) if a <= 1237            => "ESE"
      case (a) if a <= 1462            => "SE"
      case (a) if a <= 1687            => "SSE"
      case (a) if a <= 1912            => "S"
      case (a) if a <= 2137            => "SSW"
      case (a) if a <= 2362            => "SW"
      case (a) if a <= 2587            => "WSW"
      case (a) if a <= 2812            => "W"
      case (a) if a <= 3037            => "WNW"
      case (a) if a <= 3262            => "NW"
      case (a) if a <= 3487            => "NNW"
      case _                           => "N"
    }
  }

  def getWindPower(s: Double): Int = {
    s match {
      case (a) if a < 0.3  => 0
      case (a) if a < 1.6  => 1
      case (a) if a < 3.4  => 2
      case (a) if a < 5.5  => 3
      case (a) if a < 8.0  => 4
      case (a) if a < 10.8 => 5
      case (a) if a < 13.9 => 6
      case (a) if a < 17.2 => 7
      case (a) if a < 20.8 => 8
      case (a) if a < 24.5 => 9
      case (a) if a < 28.5 => 10
      case (a) if a < 32.7 => 11
      case _               => 12
    }
  }
}

Submission Info

Judge Result