Scala 解决 Enigma problem Part 1

enigma problem 详见 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1009

我想要尝试使用scala去实现，但还没有完成；目前只是实现了加密的步骤；（原题是需要解密的， 但我想理解了加密的过程，应该对解密会用帮助， 有时间会试着实现解密的部分）。 当然重点仍然是学习scala

 

以下是代码部分

 

/**
 *
 */
package com.me.acm.problems.acm1009

/**
 * @author Blues
 *
 */

object App {
  val CharSeq = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray
  val CharSeqLowerCae = CharSeq.map(c => c.toLower)
  def main(args: Array[String]): Unit = {
    readAndProcess(readLine, 1)
  }

  def readAndProcess(line: String, counter: Int) {
    val num = line.toInt
    if (num > 0) {

      val input = new Input(CharSeqLowerCae.take(num))
      var preDevice: Device = input;
      for (i <- 0 until 3) {
        val rotorLine = readLine
        val rotor = new Rotor(rotorLine.toCharArray, new Some(preDevice))
        preDevice = rotor
      }

      val output = new Output(CharSeq.take(num), new Some(preDevice))

      process(readLine, input, counter)

      readAndProcess(readLine, counter + 1)
    }
  }

  def process(line: String, input: Input, counter: Int) {
    val num = line.toInt
    if (num > 0) {
      val text = readLine.toCharArray()
      val encrptedArray = for (c <- text) yield {
        input.encrpt(c)
      }

      println("Enigma " + counter + ":")
      println(encrptedArray.mkString(""))
    }
  }
}

abstract class Device(val codes: Array[Char]) {
  var nextDevice: Option[Device] = None
  val preDevice: Option[Device] = None
  def encrpt(inputIndex: Int): Char

  def readyForNextToMove: Boolean
}

class Input(codes: Array[Char]) extends Device(codes) {
  def encrpt(inputIndex: Int): Char = {
    nextDevice match {
      case Some(next) => next.encrpt(inputIndex)
      case None => if (inputIndex < codes.length) codes(inputIndex) else '0'
    }
  }

  def encrpt(c: Char): Char = {
    encrpt(App.CharSeqLowerCae.indexOf(c))
  }

  def readyForNextToMove: Boolean = true
}

class Rotor(codes: Array[Char], override val preDevice: Some[Device]) extends Device(codes) {
  preDevice match {
    case Some(pre) => pre.nextDevice = new Some(this)
  }
  var stepCounter = 0

  var tunnels = for {
    i <- 0 until codes.length
  } yield {
    val code = codes(i)
    (i, App.CharSeq.indexOf(code))
  }

  def encrpt(inputIndex: Int): Char = {
    val tunnel = tunnels.find(_._1 == inputIndex)
    val outputIndex = tunnel match {
      case Some(x) => x._2
      case None => -1
    }

//    println("found: " + inputIndex + ", " + outputIndex)

    val encrpted = if (outputIndex >= 0) {
      this.nextDevice match {
        case Some(next) => next.encrpt(outputIndex)
        case None => '0'
      }
    } else {
      '0'
    }

    preDevice match {
      case Some(pre) => {
        if (pre.readyForNextToMove) {
          move
        }
      }
    }

    encrpted
  }

  private def move() {
    tunnels = for {
      tunnel <- tunnels
    } yield {
      ((tunnel._1 + 1) % codes.length, (tunnel._2 + 1) % codes.length)
    }
    stepCounter += 1
  }

  def readyForNextToMove: Boolean = if (stepCounter > 0) stepCounter % codes.length == 0 else false
}

class Output(codes: Array[Char], override val preDevice: Some[Device]) extends Device(codes) {
  preDevice match {
    case Some(pre) => pre.nextDevice = new Some(this)
  }
  override def encrpt(inputIndex: Int): Char = {
    if (inputIndex < codes.length) codes(inputIndex) else '0'
  }

  def readyForNextToMove = false
} 

 我觉得有几个需要注意的地方：

1. scala 的option + pattern match 非常强大，这里主要是为了避免NPE；

2. 代码里的tunnel是个Tuple2， 相应的还有Tuple3， Tuple4， 一直到Tuple22， 这个也非常好用； Tuple2的定义就是类似(x, y)形式；如果用Java实现，必须定义一个class；

3. class 里面声明的变量必须要初始化，比如nextDevice，这里必须要给它一个初始值；理由是如果不提供， scala编译器无法将之和abstract 方法定义区分开。这个和Java还是很不一样的。