//设置package包名称以及导入依赖的类
package org.nason.euler.twenty

import scala.util.Sorting
object ProblemTwentyTwo {
  
  def main(args: Array[String]) {
    println( solution )
  }
  
  def solution =
  {
    val lines = io.Source.fromFile(dataPath).getLines() toArray
    // split comma-separated values and strip "
    val values = (lines(0) split ",") map ( s => s.substring(1,s.length-1) )
    Sorting.quickSort(values)
    def nameToValue( s:String ) = { s map (_.toInt - 'A' + 1) reduceLeft(_+_) }
    (values map ( nameToValue(_) ) zipWithIndex)
       .map( i => ((i._2+1) * i._1).toLong )
       .reduceLeft( _+_ )
  }
  
  val dataPath = "/home/sorensjm/workspace/euler/data/problem22.txt"
} 

//设置package包名称以及导入依赖的类
package sio.core.syntax

import cats.kernel.Order
import sio.core.MutSyntax

import scala.annotation.tailrec
import scala.reflect.ClassTag
import scala.util.Sorting

import sio.core._

trait STArraySyntax {
  implicit class STArraySyntax[S, E](handle: STArray[S, E]) extends MutSyntax[S, Array[E]](handle) {
    def length: Int = unsafePure { _.length }

    def get(i: Int): ST[S, E] = lift { _.apply(i) }
    def set(i: Int, x: E): ST[S, Unit] = lift { _.update(i, x) }

    def transform(f: E => E): ST[S, Unit] = lift { a =>
      @tailrec def go(i: Int): Unit =
        if (i < a.length) {
          a.update(i, f(a(i)))
          go(i + 1)
        } else ()
      go(0)
    }

    def stableSort(implicit E: Order[E], CT: ClassTag[E]): ST[S, Unit] =
      lift { a => Sorting.stableSort(a)(CT, E.toOrdering) }
    def quickSort(implicit E: Order[E], CT: ClassTag[E]): ST[S, Unit] =
      lift { a => Sorting.quickSort(a)(E.toOrdering) }
  }
} 

//设置package包名称以及导入依赖的类
package com.gaiam.gcsis.util

import org.joda.time.{Interval => JInterval}
import org.joda.time.Instant
import org.joda.time.ReadableInstant
import scala.util.Sorting

class IntervalSchedule(seq: Seq[JInterval]) {
    val intervals: Array[JInterval] = Sorting.stableSort(seq, (a: JInterval, b: JInterval) => a.getStart.compareTo(b.getStart) <= 0)

    private def combine(i1: JInterval, i2: JInterval) = {
        if (i1.contains(i2)) i1
        else if (i2.contains(i1)) i2
        else new JInterval(i1.getStart, i2.getEnd)
    }

    def continuousInterval(from: ReadableInstant) = {
        intervals.foldLeft[Option[JInterval]](None)(
            (result, interval) => {
             (result, interval) match {
                case (None, i: JInterval) if i.contains(from) => Some(i)
                case (None, _) => None
                case (Some(res: JInterval), i: JInterval) if res.overlaps(i) || res.abuts(i) => Some(combine(res, i))
                case _ => result
             }
            })
    }
}