Submission #3310681

---

Source Code Expand

object Main {
  sealed trait TimeRangeListClass {
    def hasNext: Boolean
  }
  case object TimeRangeListEmpty extends TimeRangeListClass {
    def hasNext: Boolean = false
  }
  class TimeRangeList(
      var timeRange: TimeRange,
      var next: TimeRangeListClass
  ) extends TimeRangeListClass {
    def hasNext: Boolean = {
      next match {
        case TimeRangeListEmpty => false
        case _ => true
      }
    }

    def insert( other: TimeRange ): TimeRangeList = {
      if ( timeRange.isOverlapping( other ) ) {
        val ( t, n ) = merge( timeRange.combine( other ) )
        this.timeRange = t
        this.next = n
        this
      } else {
        if ( timeRange.startTime < other.startTime ) {
          next match {
            case TimeRangeListEmpty =>
              this.next = new TimeRangeList(other, TimeRangeListEmpty)
              ()
            case t: TimeRangeList =>
              if ( t.timeRange.startTime > other.startTime &&
                  ! t.timeRange.isOverlapping( other )) {
                this.next = new TimeRangeList( other, t)
                ()
              } else {
                t.insert(other)
                ()
              }
          }
          this
        } else {
          new TimeRangeList( other, this )
        }
      }
    }

    def merge( other: TimeRange ): ( TimeRange, TimeRangeListClass ) = {
      next match {
        case TimeRangeListEmpty => ( other, TimeRangeListEmpty )
        case t: TimeRangeList =>
          if ( t.timeRange.isOverlapping( other ) ) {
            t.merge( other.combine( t.timeRange ) )
          } else {
            ( other, next )
          }
      }
    }

    def print(): Unit = {
      val startStr = f"${timeRange.startTime}%04d"
      val endStr = f"${timeRange.endTime}%04d"
      println(s"$startStr-$endStr")
      next match {
        case TimeRangeListEmpty => ()
        case t: TimeRangeList => t.print()
      }
    }
  }


  def main(args: Array[String]): Unit = {
    val N = io.StdIn.readLine().toInt

    val elms = io.StdIn.readLine().split( "-", 2)
    val timeRange = TimeRange( makeStartTime( elms( 0 ) ), makeEndTime( elms( 1 )  ))

    var timeRangeList: TimeRangeList = new TimeRangeList( timeRange, TimeRangeListEmpty )

    ( 2 to N ).foreach{ _ =>
      val elms = io.StdIn.readLine().split( "-", 2)
      val timeRange = TimeRange( makeStartTime( elms( 0 ) ), makeEndTime( elms( 1 )  ))
      timeRangeList = timeRangeList.insert( timeRange )
    }

    timeRangeList.print()
  }

  case class TimeRange( startTime: Int, endTime: Int ) {
    def isOverlapping( timerange: TimeRange ): Boolean = {
      val maxOfStartTime =
        if ( startTime > timerange.startTime ) {
          startTime
        } else {
          timerange.startTime
        }
      val minOfEndTime =
        if (endTime < timerange.endTime) {
          endTime
        } else {
          timerange.endTime
        }
      if (maxOfStartTime == minOfEndTime) {
        true
      } else if (maxOfStartTime < minOfEndTime) {
        true
      } else {
        false
      }
    }

    def combine(timerange: TimeRange): TimeRange = {
      val minOfStartTime =
        if (startTime < timerange.startTime) {
          startTime
        } else {
          timerange.startTime
        }
      val maxOfEndTime =
        if ( endTime > timerange.endTime) {
          endTime
        } else {
          timerange.endTime
        }
      TimeRange(minOfStartTime, maxOfEndTime)
    }
  }

  def makeStartTime( timeString: String ): Int = {
    val hour = timeString.substring( 0, 2 ).toInt
    val minute = timeString.substring(2).toInt
    val oneDegreeInMinute = minute % 10
    val roundMinute = if ( oneDegreeInMinute < 5 ) {
      minute - oneDegreeInMinute
    } else {
      minute - oneDegreeInMinute + 5
    }
    hour * 100 + roundMinute
  }
  def makeEndTime( timeString: String ): Int = {
    val hour = timeString.substring( 0, 2 ).toInt
    val minute = timeString.substring(2).toInt
    val oneDegreeInMinute = minute % 10
    if ( oneDegreeInMinute == 0 ) {
      hour * 100 + minute
    } else if ( 0 < oneDegreeInMinute && oneDegreeInMinute <= 5 ) {
      ( hour * 100 ) + minute - oneDegreeInMinute + 5
    } else {
      val tmp = minute - oneDegreeInMinute + 10
      if ( tmp >= 60 ) {
        ( hour + 1 ) * 100
      } else {
        hour * 100 + tmp
      }
    }
  }
}

Submission Info

Judge Result