scala打印九九乘法表的5种实现

使用scala打印九九乘法表，可以有多种实现方法，实现的过程充分的体现的scala语言的优势和巨大的简洁性和高效性，

下面我用了5种方法实现九九乘法表。

使用类似于java，c++等指令风格的的编程实现，源码如下：

//这里打印倒向九九乘法口诀表
/*指令风格的编程实现九九乘法表*/
def printMultiTable() {
  var i = 1 //这里只有i在作用范围内
  while (i <= 9) {
    var j = i //这里只有i和j在作用范围内
    while (j <= 9) {
      val prod = (i * j).toString() //这里只有i和j和prod在作用范围内
      var k = prod.length() //这里只有i和j和prod和k在作用范围内
      while (k < 4) {
        print(" ")
        k += 1
      }
      print(i + "*" + j + "=" + prod)
      j += 1
    }
    // i和j让在作用范围内，但是k已经不在作用范围内。
    println()
    i += 1
  }
  //i仍在范围内，j，prod，和k脱离了范围
}

执行的结果如下：

   1*1=1   1*2=2   1*3=3   1*4=4   1*5=5   1*6=6   1*7=7   1*8=8   1*9=9
   2*2=4   2*3=6   2*4=8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
   3*3=9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
6*6=36 6*7=42 6*8=48 6*9=54
7*7=49 7*8=56 7*9=63
8*8=64 8*9=72
9*9=81

发现是倒向的乘法口诀，

下面我们修改代码打印一个正向的九九乘法表，关键在while（j <=i）这个条件。

/**
 * 打印正向的九九乘法表
 */
def printMultiTable2() {
  var i = 1 //这里只有i在作用范围内
  while (i <= 9) {
    var j = 1 //这里只有i和j在作用范围内
    while (j <= i) {
      val prod = (i * j).toString() //这里只有i和j和prod在作用范围内
      var k = prod.length() //这里只有i和j和prod和k在作用范围内
      while (k < 4) {
        print(" ")
        k += 1
      }
      print(j + "*" + i + "=" + prod)
      j += 1
    }
    // i和j让在作用范围内，但是k已经不在作用范围内。
    println()
    i += 1
  }
  //i仍在范围内，j，prod，和k脱离了范围
}

执行结果如下：

   1*1=1
   1*2=2   2*2=4
   1*3=3   2*3=6   3*3=9
   1*4=4   2*4=8 3*4=12 4*4=16
   1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
   1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
   1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
   1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
   1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

scala的语法简洁性，和函数式的风格，我们可以使用函数风格实现该功能发现代码量会减少很多，逻辑也更加清晰：

源码如下：

//打印：打印乘法口诀发
def makeRowSeq(row: Int) =
  for (col <- 1 to row) yield {
    val prod = (row * col).toString()
    val padding = " " * (4 - prod.length())
    col + "*" + row + "=" + prod + padding
  }
def makeRow(row: Int) = makeRowSeq(row).mkString
/*函数风格的编程实现九九乘法表*/
def multiTable() = {
  val tableSeq = for (row <- 1 to 9) yield makeRow(row)
  println(tableSeq.mkString("\n"))
}

执行结果如下：

1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12 4*4=16
1*5=5   2*5=10 3*5=15 4*5=20 5*5=25
1*6=6   2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7   2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8   2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9   2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

使用scala的for循环嵌套的方式实现该功能，代码可以更加简洁，只需要5,6行代码即可实现，

充分体现了scala的语言的强大性。

def multiTable2() = {
  for(row <- 1 to 9 ; col <- 1 to row){
    val prod = (row * col).toString()
    val padding = " " * (4 - prod.length())
    print(col + "*" + row + "=" + prod + padding)
    if(row == col) println()
  }
}

执行结果如下：

1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12 4*4=16
1*5=5   2*5=10 3*5=15 4*5=20 5*5=25
1*6=6   2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7   2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8   2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9   2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

可以使用for嵌套循环和scala的s（）方法，使实现更加简单，scala果然博大精深，

源码如下：

def multiTable3 = {
  (
    for (
      i <- 1 to 9;
      j <- 1 to i;
      ss = s"$j*$i=${i * j}\t"
    ) yield {
      if (j == i) s"$ss\n" else ss
    }).foreach(print);
}

执行结果如下：

1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12   4*4=16
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25
1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36
1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49
1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64
1*9=9   2*9=18   3*9=27   4*9=36   5*9=45   6*9=54   7*9=63   8*9=72   9*9=81