牛客网刷题 | BC82 乘法表

目前主要分为三个专栏，后续还会添加：

专栏如下： C语言刷题解析 C语言系列文章我的成长经历

感谢阅读！

初来乍到，如有错误请指出，感谢！

描述

输出九九乘法表，输出格式见样例。

输入描述：

此题没有输入

输出描述：

输出乘法表，对齐方式见样例输出

示例1

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循环，外层循环控制乘法表的行数，从1到9。

内层循环控制每行中的乘法运算，从1到外层循环的当前值。

在每次内层循环中，计算乘法结果，并打印出来。

为了保持输出格式的对齐，我们可以使用printf函数的格式化输出，通过在数字前填充空格来实现。

代码 1 ：

# include <stdio.h>
int main ()
//row 行
//list 列
{
    for(int row = 1;row<10;row++)//外层循环
    {
        for(int list= 1;list<=row;list++)//内层循环
        {
            int sum = list*row;//计算乘积
            printf("%d*%d=%2d ",list,row,sum);
        }
        printf("\n");
    }
    return 0;
}

代码 2 ：

# include<stdio.h>

int main(){
    

for ( int i=1;i<10;i++){
    for ( int j=1;j<=i;j++){
        if(j==i&&i*j<10)printf("%d*%d= %d",j,i,i*j);
        if(j!=i&&i*j<10) printf("%d*%d= %d ",j,i,i*j);
        if(j!=i&&i*j>=10) printf("%d*%d=%d ",j,i,i*j);
        if(j==i&&i*j>=10)printf("%d*%d=%d",j,i,i*j);
    }printf("\n");
}

}

代码 3 ：

#include <stdio.h>

int main() 
{
    int i, j, product;
    // 外层循环控制乘法表的行数
    for (i = 1; i <= 9; i++) 
    {
        // 内层循环控制每行中的乘法运算
        for (j = 1; j <= i; j++)
        {
            // 计算乘积
            product = i * j;
            // 格式化输出，确保对齐
            // 使用%5d可以保证数字占5个字符位，不足的位用空格填充
            printf("%5d", product);
        }
        // 每行结束后换行
        printf("\n");
    }
    return 0;
}

知识点：嵌套循环

以下内容来自：

C 嵌套循环 | 菜鸟教程 (runoob.com)

外层循环（Outer Loop）：控制嵌套循环的整体迭代次数。在乘法表的例子中，外层循环控制了乘法表的行数。

内层循环（Inner Loop）：在每一次外层循环的迭代中，内层循环都会完全执行一次。在乘法表的例子中，内层循环控制了每行中乘法运算的次数。

迭代逻辑：外层循环的迭代变量通常控制迭代的大范围，而内层循环的迭代变量控制小范围或细节。例如，在打印乘法表时，外层循环的迭代变量i控制了乘法表的行数，而内层循环的迭代变量j控制了每行中乘法运算的次数。

循环体：每个循环都有自己的循环体，即循环内部的代码块，这个代码块会在每次循环迭代时执行。

控制流程：在嵌套循环中，控制流程可能会变得复杂，因为内层循环的结束不会导致外层循环的结束，而是等待内层循环完全执行完毕后，外层循环才继续下一次迭代。

注意事项：在编写嵌套循环时，需要确保内层循环在逻辑上正确地依赖于外层循环，并且循环的结束条件清晰，以避免无限循环。

C 语言允许在一个循环内使用另一个循环，下面演示几个实例来说明这个概念。

语法

C 语言中 嵌套 for 循环 语句的语法：

for (initialization; condition; increment/decrement)
{
    statement(s);
    for (initialization; condition; increment/decrement)
    {
        statement(s);
        ... ... ...
    }
    ... ... ...
}

流程图：

C 语言中 嵌套 while 循环 语句的语法：

while (condition1)
{
    statement(s);
    while (condition2)
    {
        statement(s);
        ... ... ...
    }
    ... ... ...
}

C 语言中 嵌套 do...while 循环 语句的语法：

do
{
    statement(s);
    do
    {
        statement(s);
        ... ... ...
    }while (condition2);
    ... ... ...
}while (condition1);

流程图：

关于嵌套循环有一点值得注意，您可以在任何类型的循环内嵌套其他任何类型的循环。比如，一个 for 循环可以嵌套在一个 while 循环内，反之亦然。

实例

下面的程序使用了一个嵌套的 for 循环来查找 2 到 100 中的质数：

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int i, j;
   
   for(i=2; i<100; i++) 
    {
      for(j=2; j <= (i/j); j++)
        if(!(i%j)) break; // 如果找到，则不是质数
      if(j > (i/j)) printf("%d 是质数\n", i);
   }
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

2 是质数
3 是质数
5 是质数
7 是质数
11 是质数
13 是质数
17 是质数
19 是质数
23 是质数
29 是质数
31 是质数
37 是质数
41 是质数
43 是质数
47 是质数
53 是质数
59 是质数
61 是质数
67 是质数
71 是质数
73 是质数
79 是质数
83 是质数
89 是质数
97 是质数

while 嵌套实例

#include <stdio.h>
int main()
{
    int i=1,j;
    while (i <= 5)
    {
        j=1;
        while (j <= i )
        {
            printf("%d ",j);
            j++;
        }
        printf("\n");
        i++;
    }
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

do-while 嵌套实例

#include <stdio.h>
int main()
{
    int i=1,j;
    do
    {
        j=1;
        do
        {
            printf("*");
            j++;
        }while(j <= i);
        i++;
        printf("\n");
    }while(i <= 5);
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：