fork download

package garden
 
abstract class Tree {
  def elements: Int
  def insert(x: String): Tree
}
 
case object Tree {
  def apply(): Tree = Empty
  def apply(a: String): Tree = Leaf1(a)
  def apply(a: String, b: String): Tree = Leaf2(a, b)
  def apply(a: String, b: String, c: String): Tree = Internal1(Leaf1(a), b, Leaf1(c))
}
 
case object Empty extends Tree {
  override def elements = 0
 
  def insert(x: String): Tree = Leaf1(x)
 
  override def toString = "()"
}
 
case class Leaf1(a: String) extends Tree {
  override def elements = 1
 
  def insert(x: String): Tree = {
    val order = x.compareTo(a)
    if (order < 0) Leaf2(x, a)
    else if (order > 0) Leaf2(a, x)
    else this
  }
 
  override def toString = "(" + a + ")"
}
 
case class Leaf2(a: String, b: String) extends Tree {
  override def elements = 2
 
  def insert(x: String): Tree = {
    var order = x.compareTo(a)
    if (order < 0) return Tree(x, a, b)
    if (order == 0) return this
    order = x.compareTo(b)
    if (order < 0) return Tree(a, x, b)
    if (order == 0) return this
    return Tree(a, b, x)
  }
 
  override def toString = "(" + a + " " + b + ")"
}
 
case class Internal1(a: Tree, b: String, c: Tree) extends Tree {
  override def elements = 1
 
  def insert(x: String): Tree = {
    val order = x.compareTo(b)
    if (order < 0) {
      val a_ = a.insert(x)
      if (a_.elements < a.elements) {
        val a__ = a_.asInstanceOf[Internal1]
        Internal2(a__.a, a__.b, a__.c, b, c)
      } else Internal1(a_, b, c)
    } else if (order > 0) {
      val c_ = c.insert(x)
      if (c_.elements < c.elements) {
        val c__ = c_.asInstanceOf[Internal1]
        Internal2(a, b, c__.a, c__.b, c__.c)
      } else Internal1(a, b, c_)
    } else this
  }
 
  override def toString = "(" + a.toString + " " + b + " " + c.toString + ")"
}
 
case class Internal2(a: Tree, b: String, c: Tree, d: String, e: Tree) extends Tree {
  override def elements = 2
 
  def insert(x: String): Tree = {
    var order = x.compareTo(b)
    if (order < 0) {
      val a_ = a.insert(x)
      if (a_.elements < a.elements) Internal1(a_, b, Internal1(c, d, e))
      else Internal2(a_, b, c, d, e)
    } else if (order > 0) {
      order = x.compareTo(d)
      if (order < 0) {
        val c_ = c.insert(x)
        if (c_.elements < c.elements) {
          val c__ = c_.asInstanceOf[Internal1]
          Internal1(Internal1(a, b, c__.a), c__.b, Internal1(c__.c, d, e))
        } else Internal2(a, b, c_, d, e)
      } else if (order > 0) {
        val e_ = e.insert(x)
        if (e_.elements < e.elements) Internal1(Internal1(a, b, c), d, e_)
        else Internal2(a, b, c, d, e_)
      } else this
    } else this
  }
 
  override def toString = "(" + a.toString + " " + b + " " + c.toString + " " + d + " " + e.toString + ")"
}
 
object Main {
  def main(args: Array[String]) {
    var a = Tree()
    println(a)
    for (x <- 'a' to 'z') {
      a = a.insert(x.toString)
      println(a)
    }
  }
}
 

Usage: scalac <options> <source files>
where possible standard options include:
  -Dproperty=value                Pass -Dproperty=value directly to the runtime system.
  -J<flag>                        Pass <flag> directly to the runtime system.
  -P:<plugin>:<opt>               Pass an option to a plugin
  -X                              Print a synopsis of advanced options.
  -bootclasspath <path>           Override location of bootstrap class files.
  -classpath <path>               Specify where to find user class files.
  -d <directory|jar>              destination for generated classfiles.
  -dependencyfile <file>          Set dependency tracking file.
  -deprecation                    Emit warning and location for usages of deprecated APIs.
  -encoding <encoding>            Specify character encoding used by source files.
  -explaintypes                   Explain type errors in more detail.
  -extdirs <path>                 Override location of installed extensions.
  -feature                        Emit warning and location for usages of features that should be imported explicitly.
  -g:<level>                      Set level of generated debugging info. (none,source,line,vars,notailcalls) default:vars
  -help                           Print a synopsis of standard options
  -javabootclasspath <path>       Override java boot classpath.
  -javaextdirs <path>             Override java extdirs classpath.
  -language:<_,feature,-feature>  Enable or disable language features: `_' for all, `-language:help' to list
  -no-specialization              Ignore @specialize annotations.
  -nobootcp                       Do not use the boot classpath for the scala jars.
  -nowarn                         Generate no warnings.
  -optimise                       Generates faster bytecode by applying optimisations to the program
  -print                          Print program with Scala-specific features removed.
  -sourcepath <path>              Specify location(s) of source files.
  -target:<target>                Target platform for object files. All JVM 1.5 targets are deprecated. (jvm-1.5,jvm-1.6,jvm-1.7,jvm-1.8) default:jvm-1.6
  -toolcp <path>                  Add to the runner classpath.
  -unchecked                      Enable additional warnings where generated code depends on assumptions.
  -uniqid                         Uniquely tag all identifiers in debugging output.
  -usejavacp                      Utilize the java.class.path in classpath resolution.
  -usemanifestcp                  Utilize the manifest in classpath resolution.
  -verbose                        Output messages about what the compiler is doing.
  -version                        Print product version and exit.
  @<file>                         A text file containing compiler arguments (options and source files)

spoj: The program compiled successfully, but Main.class was not found.
      Class Main should contain method: def main(args: Array[String]).

Standard output is empty