内建控制-多重循环

一. 多重循环的基本使用

定义：

多重循环（也称为嵌套循环）是指在一个循环语句的循环体内部，又包含另一个或多个循环语句。它主要用于处理需要多层重复执行的任务，例如二维数组的遍历、矩阵运算、复杂模式的打印等。

简单来说，就是 "循环里面套循环"，外层循环执行一次，内层循环会完整执行一轮。

格式：

for (循环变量 <- 数据集) {  
  for(){  
    for(){  
    }  
  }  
}

说明：

1. for可以替换成while循环。
2. 循环的嵌套可以有多个，数量不限。
3. 里外层循环执行的次数不相同。

示例：

提问：

1.  println(i)会执行几次？ // 5
2.  println(i,j)会执行几次？ // 6

object base1001 {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 5){
      println(i)
      for(j <- 10 to 15){
        println(i, j)
      }
    }
  }
}

提问：

1.  println(i)会执行几次？ // 6
2.  println(k,i,j)会执行几次？ // 10

object practice100101 {
  def main(args: Array[String]): Unit = {
    var k = 0
    for(i <-0 to 5){ // 外层循环
      println(i)

      for(j <-11 to 20){ // 内层循环
        k = k + 1
        println(k,i,j)
      }
    }
  }
}

二. 输出特殊图形

编写代码打印输出如下图形:

1. 宝塔

1
22
333
4444
55555

代码如下：

object base {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 5) { // 外层循环
      for (j <- 1 to i) { // 每行输出几个数字
        print(i)
      }
      println() // 换行
    }
  }
}

2. 倒宝塔

55555
4444
333
22
1

代码如下：

object base {
  def main(args: Array[String]): Unit = {
    for (i <- 5 to 1 by -1) { // 这里的i 是由5依次递减1位数到1所得的
      for (j <- 1 to i) { //  j的范围由i决定的
        print(i)
      }
      println()
    }
  }
}

3. 二者结合

55555
4444
333
22
1
1
22
333
4444
55555

代码如下：

object base {
  def main(args: Array[String]): Unit = {
    for (i <- 5 to 1 by -1) { // 这里的i 是由5依次递减1位数到1所得的
      for (j <- 1 to i) { //  j的范围由i决定的
        print(i)
      }
      println()
    }
    for (i <- 1 to 5) { // 外层循环
      for (j <- 1 to i) { // 每行输出几个数字
        print(i)
      }
      println() // 换行
    }
  }
}

三. 打印乘法口诀表

乘法口诀表

方法一：

object base {
  def main(args: Array[String]): Unit = {
    for(i <-1 to 9){
      for(j <-1 to 9){
        printf(s"${j}×${i}=${i*j}\t")
      }
      println() // 换行
    }
  }
}

方法二:

object base {
  def main(args: Array[String]): Unit = {
    for(i <-1 to 9){
      for(j <-1 to 9){
        printf("%d×%d=%-4d", j, i, i*j)
      }
      println() // 换行
    }
  }
}

注意：

1. %d: 占位符，会输出一个整数
2. %-4d: 占位符，会输出一个整数，一共占据4个字符的空间大小，左对齐！
3. %4d: 占位符，会输出一个整数，一共占据4个字符的空间大小，右对齐！

四. 百鸡百钱问题

百鸡百钱

问题：

公鸡（鸡翁）1只，价格5钱； 母鸡（鸡母）1只，价格3钱； 小鸡（鸡雏）3只，价格1钱（即1钱买3只小鸡）； 用100钱买100只鸡，问公鸡、母鸡、小鸡各有多少只？

思路分析：

设公鸡 x，母鸡 y 只，小鸡是 100 - x - y。 同时 0 <= x <= 20, 0<=y<=33

5x + 3y + (100 - x - y) / 3 = 100

暴力求解: 1.将(0,0,100) 代入上述式子中看看是否成立？ 2.将(0,1, 99) 代入上述式子中看看是否成立？···

代码：

object base {
  def main(args: Array[String]): Unit = {
    var k = 0
    for (x <- 0 to 20) {
      for (y <- 0 to 33) {
        val z = 100 - x - y
        //  代入 5x + 3y + (100 - x - y) / 3 = 100 中
        if (5 * x + 3 * y + z / 3 == 100) {
          k += 1
          println(k, x, y, z)
        }
      }
    }
  }
}

代码分析：

• 循环部分：
  • 外层循环 for (x <- 0 to 20)：因为公鸡 5 钱 1 只，100 钱最多买 20 只公鸡，所以 x（公鸡数量）的取值范围是 0 到 20。
  • 内层循环 for (y <- 0 to 33)：母鸡 3 钱 1 只，100 钱最多买 33 只母鸡，所以 y（母鸡数量）的取值范围是 0 到 33。
• 计算小鸡数量：val z = 100 - x - y，根据总共买 100 只鸡，用总数减去公鸡和母鸡的数量，得到小鸡数量 z。
• 条件判断：if (5 * x + 3 * y + z / 3 == 100)，验证购买公鸡、母鸡、小鸡的总钱数是否为 100 钱，其中公鸡花费 5 * x 钱，母鸡花费 3 * y 钱，小鸡 3 只 1 钱，所以小鸡花费 z / 3 钱。
• 结果输出：当满足条件时，k（符合条件的情况计数）加 1，并打印出情况序号 k 以及公鸡、母鸡、小鸡的数量 x、y、z。