go 多重循环控制

╰半橙微兮° 2021-07-25 01:47 429阅读 0赞

# 一 基本介绍 #

1 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的 for 称为外层循环，在里面的 for 循环称为内层循环。建议：一般使用两层，最多不要超过三层。

2 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

3 外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m\*n 次。

# 二 应用实战 #

### **1 统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分，并统计 3 个班的及格人数。要求学生的成绩从键盘输入。** ###

**a 编程时两大绝招**

先易后难：即将一个复杂的问题先分解成简单的问题，先解决简单问题，再解决复杂问题。

先死后活：数字先写死，最后再用变量替换。

**b 思路分析**

第一步

（1）统计1个班成绩情况，每个班有5名同学, 求出该班的平均分，这里用到先易后难。

（2）学生数就是5个，这里用到先死后活。

（3）声明一个 sum 统计班级的总分。

第二步

（1）统计3个班成绩情况，每个班有5名同学, 求出每个班的平均分。

（2）代码中用 j 表示第几个班级。

（3）定义一个变量存放总成绩。

第三步

（1）把代码做活

（2）定义两个变量，表示班级的个数和班级的人数。

第四步

（1）声明以变量 passCount 用于保存及格人数。

**c 代码**

package main
    
    import "fmt"
    
    func main() {
       var classNum int = 2
       var stuNum int = 5
       var totalSum float64 = 0.0
       var passCount int = 0
       for j := 1; j <= classNum; j++ {
          sum := 0.0
          for i := 1; i <= stuNum; i++ {
             var score float64
             fmt.Printf("请输入第%d班 第%d个学生的成绩 \n", j, i)
             fmt.Scanln(&score)
             //累计总分
             sum += score
             //判断分数是否及格
             if score >= 60 {
                passCount++
             }
          }
          fmt.Printf("第%d个班级的平均分是%v\n", j, sum/float64(stuNum))
          //将各个班的总成绩累计到totalSum
          totalSum += sum
       }
       fmt.Printf("各个班级的总成绩%v 所有班级平均分是%v\n", totalSum, totalSum/float64(stuNum*classNum))
       fmt.Printf("及格人数为%v\n", passCount)
    }

**d 测试**

请输入第1班 第1个学生的成绩
    10
    请输入第1班 第2个学生的成绩
    10
    请输入第1班 第3个学生的成绩
    10
    请输入第1班 第4个学生的成绩
    10
    请输入第1班 第5个学生的成绩
    10
    第1个班级的平均分是10
    请输入第2班 第1个学生的成绩
    20
    请输入第2班 第2个学生的成绩
    20
    请输入第2班 第3个学生的成绩
    20
    请输入第2班 第4个学生的成绩
    20
    请输入第2班 第5个学生的成绩
    20
    第2个班级的平均分是20
    各个班级的总成绩150 所有班级平均分是15
    及格人数为0

### 2 打印金字塔经典案例 ###

**a 编程思路**

第一步：打印一个矩形

\*\*

第二步：打印半个金字塔

\*             1 个 \*

\*\*            2 个 \*

\*\*\*          3 个 \*

第三步：打印整个金字塔

\*             1层 1 个\*  规律：2 \* 层数 - 1   空格 2 规律 总层数-当前层数

\*\*\*           2层 3 个\*  规律：2 \* 层数 - 1   空格 1 规律 总层数-当前层数

\*\*\*\*\*         3层 5 个\*  规律：2 \* 层数 - 1   空格 0 规律 总层数-当前层数

第四步：将层数做成一个变量, 先死后活。

var totalLevel int

第五步：打印空心金字塔

\* \*

\*\*\*\*\*

给每行打印\*号时，需要考虑是打印 \* 还是打印空格。

每层的第一个和最后一个是打印\*, 其它就应该是空的，即输出空格。

一个例外情况：最后层（底层）是全部打\*。

**b 代码**

package main
    
    import (
       "fmt"
    )
    
    func main() {
       var totalLevel int = 9
       // i 表示层数
       for i := 1; i <= totalLevel; i++ {
          // 在打印 * 前先打印空格
          for k := 1; k <= totalLevel-i; k++ {
             fmt.Print(" ")
          }
          // j 表示每层打印多少*
          for j := 1; j <= 2*i-1; j++ {
             if j == 1 || j == 2*i-1 || i == totalLevel {
                fmt.Print("*")
             } else {
                fmt.Print(" ")
             }
          }
          fmt.Println()
       }
    }

**c  测试**

*
           * *
          *   *
         *     *
        *       *
       *         *
      *           *
     *             *
    *****************

### 3 打印出九九乘法表 ###

**a 代码**

package main
    
    import "fmt"
    
    func main() {
       // i 表示层数
       var num int = 9
       for i := 1; i <= num; i++ {
          for j := 1; j <= i; j++ {
             fmt.Printf("%v * %v = %v \t", j, i, j*i)
          }
          fmt.Println()
       }
    }

**b 测试**

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