C++算法设计与分析课后习题【第三章】
- 前言
- 一、求2+22+222+2222+...+22...(n个2)...22(精确计算)
- 二、编写一个算法，其功能是给一维数组a输入任意6个整数，假设为5，7，4，8，9，1，然后建立一个具有如图 3-4 所示的方阵，并打印出来（屏幕输出）。
- 三、编程打印形如图 3-5 所示的n×n方阵。
- 四、编程打印形如图 3-6 所示的n×n方阵的上三角阵。
- 五、编写程序打印形如图 3-7 和图 3-8 所示的 n×n 方阵。
- 六、键盘输入一个含有括号的四则运算表达式，可能含有多余的括号，编程整理该表达式，去掉所有多余的括号，原表达式中所有变量和运算符相对位置保持不变，并保持与原表达式等价。
- 七、写出计算ackermann函数ack(m,n)的递归计算函数。对于m≥0，n≥0，ack(m,n)定义为：
- 八、判断s字符串是否为“回文”的递归函数。
- 九、有一只经过训练的蜜蜂只能爬向右侧相邻的蜂房，不能反向爬行。如图 3-9 试求出蜜蜂从蜂房a爬到蜂房b的可能路线数(0<a<b<100)
- 十，狼找兔子问题：一座山周围有n个洞，顺时针编号为0,1,2,3,4,...,n-1.一只狼从0号洞开始，顺时针方向计数，每当经过第m个洞时，就进洞找兔子。例如n=5，m=3，狼经过的洞依次为0,3,1,4,2,0。输入m,n。试问兔子有没有幸免的机会？如果有该藏在哪？
- 十一，请编程求1×2×3×...×n所得的数末尾有多少个0？(n由键盘输入，1000＜n＜10000)
- 十二，有52张牌，使它们全部正面朝上，第一轮是从第2张开始，凡是2的倍数位置上的牌翻成正面朝下；第二轮从第3张牌开始，凡是3的倍数位置上的牌，正面朝上的翻成正面朝下，正面朝下的翻成正面朝上；第三轮从第4张牌开始，凡是4的倍数位置上的牌按上面相同规则翻转，以此类推，直到翻的牌超过104张为止。统计最后有几张牌正面朝上，以及他们的位置号。
- 十三，A，B，C，D，E 5人为某次竞赛的前五名，他们在名次公布前猜名次。A说：B得第三名，C得第五名。B说：D得第二名，E得第四名。C说：B得第一名，E得第四名。D说：C得第一名，B得第二名。E说：D得第二名，A得第三名。结果每个人都猜对了一半，实际名次是什么呢？
- 十四，编写算法求满足以下条件的3位整数n：它是完全平方数，其中又有两位数字相同，如144、676等。
- 十五，两个乒乓球队进行比赛，各出3人。甲队为A、B、C 3人，乙队为X、Y、Z 3人，已抽签决定比赛名单。有人向队员打听比赛的名单，A说他不和X比，C说他不和X、Z比，请编写算法找出3对赛手的名单？
- 十六，编写算法对输入的一个整数，判断它能否被4，7，9整除，并输出以下信息之一：能同时被4，7，9整除；能被其中两个数（要指出哪两个）整除；能被其中一个数（要指出哪一个）整除；不能被4，7，9任一个整除。
- 十七，完成给“余”猜数的游戏：心里先想好一个1~100之间的整数x，将它分别除以3，4和7并得到3个余数。把这三个余数输入计算机，计算机能马上猜出这个数
- 十八，求这样的两个数据：5位数=2×4位数，9个数字互不相同。
- 十九，写一函数，输入一个十六进制数，输出相应的十进制数。
- 二十，用1，2，3，4，5，6，7，8，9 这9个数字，填入□中使等式成立，每个数字恰好用一次：□□×□□□=□□□□。
- 二十一，求这样的6位数：SQRT（6位数）=3位数，9个数字互不相同（SQRT表示开平方）。
- 二十二，键盘输入n个正整数，把它们看作一个“数圈”，求其中连续4个数之和的最大者。
- 二十三，输入一个5位数以内的正整数，完成以下操作：①判断它是一个几位数。②请按序输出其各位数字。③逆序输出其各位数字。
- 二十四，乘式还原，有乘法运算如下。式中8个⚪位置上的数字全部是素数，请还原这算式。
- 二十五，乘式还原，有乘法运算如下。式中18个⚪位置上的数字全部是素数（2，3，5或7），请还原这算式。
- 二十六，读入自然数m和n（0≤m＜n≤1000），判断分数m/n是有限小数还是循环小数。如果m/n是有限小数，则输出分数的值；如果m/n为循环小数，则把循环的部分在括号中打印输出。
- 二十七，月份翻译：编程当输入数据为1~12时，翻译成对应的英语月份，如输入“3”翻译输出“march”。
Wild Chicken Programing TANXL
前言
本文所有代码皆为本人原创，为了提升测试的效率，所有代码都包含了一个while的无限循环，实际情况下可能不需要考虑大循环。本文目的仅为记录本人学习历程，所以所有代码都可以一键复制。
拯救中文互联网，知识不收费从我做起。
一、求2+22+222+2222+…+22…(n个2)…22(精确计算)
这题的看似简单，但是要求是精确计算n个2相加，一旦超出了int的最大值2147483647之后就会出现错误，所以要把每位数据都单独储存在数组里面进行逐一的计算！
#include <iostream>
using namespace std;
int main()
{
int n, a[100]{}, b[100]{}, c;
while (1)
{
cout << endl << "请输入N的值:";
cin >> n;
c = n;//保留n原始值
for (; n > 0; n--)
{
for (int i = n - 1; i >= 0; i--)//加数赋值
b[i] = 2;
for (int i = n - 1; i >= 0; i--)
{
a[i] += b[i];//逐位相加
while (a[i] > 9)//while确保某一位小于10
{
a[i] -= 10;
a[i + 1]++;//进位
}
}
}
cout << "精确计算的值为 : ";
for (int i = c - 1; i >= 0; i--)//输出结果
{
cout << a[i];
a[i] = 0;//用于继续测试，数组回到初始状态
}
}
}
变量解释
n代表题目中的“2+22+222+2222+…+22…(n个2)…22”的n
a[100]代表累计相加的值（最后的输出结果）
b[100]用于表示n不同的情况下不同的加数
c与n等价，因为b[100]的处理需要n递减，所以引入c代表n的原始值用于输出结果。
运行截图
二、编写一个算法，其功能是给一维数组a输入任意6个整数，假设为5，7，4，8，9，1，然后建立一个具有如图 3-4 所示的方阵，并打印出来（屏幕输出）。
这题难度不大，只需要在输出之后数组索引值+1到上限后返到0就行了，所以我稍微提升了一下难度——把默认的输入六个整数调整为了输入任意个整数，如果是实验要交代码的话，只需要把数组上限改为6、n直接初始化为6，去掉n的输入赋值。
#include <iostream>
using namespace std;
int main()
{
int a[20]{}, n;
while (1)
{
cout << "请输入要输入的整数数量(<20) : ";
cin >> n;
cout << "请输入" << n << "个数字（逐一输入或空格间断） : " << endl;//cin的特性：空格间断
for (int i = 0; i < n; i++)
{
cout << "No ." << i + 1 << " :";
cin >> a[i];
}
for (int i = 0; i < n; i++)
{
for (int i = 0; i < n; i++)
{
cout << a[i] << " ";//输出数组
}
cout << endl;
int temp = a[n - 1];//取出末尾的值
for (int i = n - 1; i >= 0; i--)//循环从后往前，给后面的数赋前面的值
{
if (i != 0)//当i=0时直接给末尾赋值
a[i] = a[i - 1];
else
a[i] = temp;
}
}
}
}
变量解释
a[20]用于储存输入的整数，同时也用于输出
n用于储存输入的整数数量，原题只用赋值为6即可
temp字面意思，用于临时储存被覆盖的索引最后一位的值
运行截图
三、编程打印形如图 3-5 所示的n×n方阵。
这题只需要先计算出总共的圈数i，然后因为是n×n的矩阵，所以一条边的索引最大值为n-1，然后将一个环划为四个部分（如上图1 ~ 6为一个部分、7 ~ 12、13 ~ 18、19 ~ 24），第一部分横向的最大值就是n-1-i，第二部分纵向的最大值也同理，三四部分则从最大值到环（i）的值递减，本解在原有基础上调整了n的值，可用于输入更改矩阵。
#include <iostream>
using namespace std;
int main()
{
int i, j, n, k = 1, a[20][20];
while (1)
{
cout << "请输入矩阵的边长 : ";
cin >> n;
for (i = 0; i < n / 2; i++)//计算出环的总数
{
for (j = i; j < n - i - 1; j++)
a[i][j] = k++;//矩阵第一部分：上方
for (j = i; j < n - i - 1; j++)
a[j][n - i - 1] = k++;//矩阵第二部分：右边
for (j = n - i - 1; j > i; j--)
a[n - i - 1][j] = k++;//矩阵第三部分：下方
for (j = n - i - 1; j > i; j--)
a[j][i] = k++;//矩阵第四部分：左边
}
if (n % 2 != 0)//当边长为奇数时，给正中间单独的一个数赋值
a[(n - 1) / 2][(n - 1) / 2] = n * n;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
cout << a[i][j] << "\t";//输出结果
}
cout << endl << endl << endl << endl;
}
}
}
变量解释
n代表矩阵的边长
a[20][20]用于储存矩阵的数据，同时也用于输出
i代表环的数量，用边长除二即可计算出环的总数量
j用于表示在环计算中根据i变化的变量
k是用于填充二维数组a的数据，在代码中表示为k++(每次使用后+1)
运行截图
四、编程打印形如图 3-6 所示的n×n方阵的上三角阵。
这题与上面的方阵题类似，只是修改了一些条件。入手方面与矩形找环一样，由于是三角形，所以从左下方到右上方算一环，每一环的数字从下到上依次递增，数字的索引值都是X减一Y加一，环的个数与n长度相同，每一环的数据也与n相同。
#include <iostream>
using namespace std;
int main()
{
int i, n, a[20][20], k, temp2 = 0, x, y;
while (1)
{
for (x = 0; x <= 19; x++)
for (y = 0; y <= 19; y++)
a[x][y] = 0;//数组所有值初始化为0
k = 1;//k值重置，用于再次输出三角形
cout << "请输入上三角形上方的边长 : ";
cin >> n;
for (i = 0; i < n; i++)
{
a[i][0] = k++;//环的第一个数据
for (int temp1 = i; temp1 > 0;)//temp1的操作在for循环中会导致temp1的值过早或过晚的改变
{
a[--temp1][++temp2] = k++;//所以把temp1的递减操作放到了循环里面
}
temp2 = 0;//每次使用完temp2后重置temp2的值用于下个环使用
}
for (x = 0; x < n; x++)
{
for (y = 0; y < n; y++)
{
if (a[x][y] != 0)//初始化所有值默认为0，而正常运行时不会出现0，所以排除0的数据
cout << a[x][y] << "\t";
}
cout << endl << endl << endl;
}
}
}
变量解释
i代表环数，从索引0到n-1（边长）的环
n代表三角形两个直角边的边长
a[20][20]用于储存三角形数据，同时也用于输出
k代表储存到数组中的数据，每次使用后加一
temp1用于临时的替代i来递减，而不影响i的值
temp2用于代表环中数据的y值，从0开始，每次使用前递增
x用于初始化、输出x轴数据
y用于初始化、输出y轴数据
运行截图
五、编写程序打印形如图 3-7 和图 3-8 所示的 n×n 方阵。
与第三题类似，同样是找环，唯一的区别是环内数字不用递增，而是统一的数字。本题只需要将第三题环内递增的k++改成根据环数即可，总体区别不大。
#include <iostream>
using namespace std;
int main()
{
int i, j, r, n, a[50][50]{};//C++的{}初始化更简便
while (1)
{
cout << "请输入矩阵的边长 : ";
cin >> n;
r = n / 2;//求出环数（不包括只有一个数字的环）
for (i = 0; i < r; i++)
{
for (j = i; j < n - i - 1; j++)//上方
a[i][j] = i + 1;
for (j = i; j < n - i - 1; j++)//右边
a[j][n - i - 1] = i + 1;
for (j = n - i - 1; j > i; j--)//下方
a[n - i - 1][j] = i + 1;
for (j = n - i - 1; j > i; j--)//左边
a[j][i] = i + 1;
}
if (n % 2 != 0)//矩阵边长为奇数时触发
a[(n + 1) / 2 - 1][(n + 1) / 2 - 1] = r + 1;//中心点赋值
for (int x = 0; x < n; x++)
{
for (int y = 0; y < n; y++)
{
cout << a[x][y] << "\t";//输出结果
}
cout << endl << endl << endl << endl;
}
}
}
变量解释
n代表矩阵的边长
a[50][50]用于储存矩阵的数据，同时也用于输出
i代表环的数量（第几个环），用边长除二即可计算出环的总数量
j用于表示在环计算中根据i变化的变量
r代表环数的最大值，同时用于给中心点赋值
x用于初始化、输出x轴数据
y用于初始化、输出y轴数据
运行截图
六、键盘输入一个含有括号的四则运算表达式，可能含有多余的括号，编程整理该表达式，去掉所有多余的括号，原表达式中所有变量和运算符相对位置保持不变，并保持与原表达式等价。
由于对输入流等问题了解不够深入，这题大概花了我四个小时左右，解题步骤大概分为以下几步：第一步、解决输入一整行数据的问题。第二步、处理输入的值，检查所有左括号和右括号的位置，我这里先使用了一个KH数组用于标记，1用来标记左括号，2用来标记右括号，然后再用for循环遍历取出所有坐标，存放到单独的L和R数组中。第三步、对所有左右括号的的位置进行计算，找出两两之间最近的两个左右括号，并记录下左右括号的坐标。第四步、检查左括号左边和右括号的右边（要考虑临界值），如果有乘号或除号则跳出，不处理这一对括号。反之，如果没有的话，就去掉这一对括号，如果括号的左边是减号，还要修改括号内部的加减号。第五步、多次循环解决所有括号。由于使用的输入是String，所以在修改括号时没有办法直接修改内容，所以使用空格替代了原来应该去掉的括号，在最后输出时跳过了空格部分的输出。
#include<iostream>
#include<string>
using namespace std;
string s;
int main()
{
int kh[100]{}, L[10]{}, R[10]{}, i, j, min, max, tempmin = 100, x = -1, y = -1;
while (1)
{
cout << "请输入一行四则运算表达式 : " << endl;
getline(cin, s);
for (i = 0; i < s.length(); i++)//根据String长度遍历
{
if (s[i] == '(')//左括号则赋值为1
kh[i] = 1;
if (s[i] == ')')//右括号则赋值为2
kh[i] = 2;
}
for (i = 0; i < s.length(); i++)//再次遍历
{
if (kh[i] == 1)
{
for (int temp = 0; temp < 9; temp++)
{
if (L[temp] == 0)//数组temp索引等于0则存入左括号坐标
{
L[temp] = i;
break;
}
else
continue;//不等于，即已经存入过了数据，则继续使索引加一再次判断
}
}
if (kh[i] == 2)
{
for (int temp = 0; temp < 9; temp++)
{
if (R[temp] == 0)//数组temp索引等于0则存入右括号坐标
{
R[temp] = i;
break;
}
else
continue;//不等于，即已经存入过了数据，则继续使索引加一再次判断
}
}
}
for (int temp = 0; temp < 5; temp++)//最多支持五个括号对同时出现，可通过修改最大值提升
{
tempmin = 100;
x = -1;
y = -1;
for (i = 0; i < 9; i++)
{
for (j = 0; j < 9; j++)
{
if (R[j] - L[i] > 0 && R[j] - L[i] < tempmin)
{
tempmin = R[j] - L[i];
max = L[i];//max赋值差距最小的左括号坐标
min = R[j];//min赋值差距最小的右括号坐标
x = j;//记录最小的右括号坐标
y = i;//记录最小的左括号坐标
}
}
}
if (x != -1 && y != -1)//已经使用过的数据归零，避免再次调用
{
R[x] = 0;
L[y] = 0;
}
//下一行代码用于输出最下差值的坐标
//cout << "max : " << max << " min : " << min << endl;
if (max == 0 && min == 100)
break;
if (max == 0 && min == s.length() - 1)//左括号坐标为0右括号为最右边的情况
{//此情况不用考虑左边为减号的情况
s[max] = ' ';
s[min] = ' ';//修改原输入的string的值
}
else if (max != 0 && min != s.length() - 1)//左括号坐标不为0右括号不在最右边的情况
{
if (s[max - 1] == '*' || s[max - 1] == '/' || s[min + 1] == '*' || s[min + 1] == '/')//判断是否为不可去掉括号的符号
continue;
else if (s[max - 1] == '-')//考虑左边为减号的情况，修改括号内的加减号
{
for (i = max; i < min; i++)
{
if (s[i] == '+')
{
s[i] = '-';
s[max] = ' ';
s[min] = ' ';
break;//退出循环，否则会多次赋值
}
if (s[i] == '-')
{
s[i] = '+';
s[max] = ' ';
s[min] = ' ';
break;//退出循环，否则会多次赋值
}
}
}
else
{
s[max] = ' ';
s[min] = ' ';//修改原输入的string的值
}
}
else if (max == 0 && min != s.length() - 1)//左括号坐标为0右括号不在最右边的情况
{
if (s[min + 1] == '*' || s[min + 1] == '/')//判断是否为不可去掉括号的符号
continue;
else
{
s[max] = ' ';
s[min] = ' ';//修改原输入的string的值
}
}
else if (max != 0 && min == s.length() - 1)//左括号坐标不为0右括号在最右边的情况
{
if (s[max - 1] == '*' || s[max - 1] == '/')//判断是否为不可去掉括号的符号
continue;
else if (s[max - 1] == '-')
{
for (i = max; i < min; i++)//考虑左边为减号的情况，修改括号内的加减号
{
if (s[i] == '+')//左括号的左边是减号的情况下，括号内的加号改为减号
{
s[i] = '-';
s[max] = ' ';
s[min] = ' ';
break;//退出循环，否则会多次赋值
}
if (s[i] == '-')//左括号的左边是减号的情况下，括号内的减号改为加号
{
s[i] = '+';
s[max] = ' ';
s[min] = ' ';
break;//退出循环，否则会多次赋值
}
}
}
else
{
s[max] = ' ';
s[min] = ' ';//修改原输入的string的值
}
}
for (i = 0; i < 9; i++)
{//下面这一行代码用于测试时输出左右括号的坐标
//cout << "L[" << i << "] : " << L[i] << " R[" << i << "] : " << R[i] << endl;
if (L[i] == max)
L[i] = 0;
if (R[i] == min)
R[i] = 0;
}
}
cout << "输出结果 : ";
for (i = 0; i < s.length(); i++)//输出时跳过空格
{
if (s[i] != ' ')
cout << s[i];
}
cout << endl;
max = 0;
min = 100;
for (i = 0; i < 9; i++)//坐标记录数组复原
{
L[i] = 0;
R[i] = 0;
}
for (i = 0; i < 99; i++)//标记坐标数组复原
{
kh[i] = 0;
}
}
}
变量解释
kh[100]用于存放左右括号的坐标，如果是左括号则存放1，右括号则存放2
L[10]用于存放从KH数组中取出的左括号坐标，如果kh第i个数据为1则将i存入L数组
R[10]用于存放从KH数组中取出的右括号坐标，如果kh第i个数据为1则将i存入R数组
i临时用于各种for循环
j临时用于各种for循环
max存放计算出最接近的括号对的左括号，用于代码大量更改过，max和min的名称并没有实际意义
min存放计算出最接近的括号对的右括号，用于代码大量更改过，max和min的名称并没有实际意义
tempmin临时储存左右括号相差的距离，用于比较新计算的数据
运行截图
七、写出计算ackermann函数ack(m,n)的递归计算函数。对于m≥0，n≥0，ack(m,n)定义为：
这一题实际递归计算时，如果M，N都大于或等于5，结果就需要很久计算，但是题目只要求写出具体代码，没有对输入输出、计算时间进行要求。
#include <iostream>
using namespace std;
int ack(int m, int n)
{
//cout << "ackermann( " << m << " , " << n << " ) " << endl;
//在Vs2019中取消上面的注释可以输出M，N大于等于的情况，但是需要大量时间逐行输出
//如果不取消上面的注释，直接输入“5 5”就会直接报错
if (m == 0)
return n + 1;
else if (n == 0)
return ack(m - 1, 1);
else
return ack(m - 1, ack(m, n - 1));
}
int main()
{
int m, n;
cout << "输入M、N的值（空格间断）:";
cin >> m >> n;
cout << ack(m, n);
}
变量解释
m主动输入的m值，用于ack函数进行计算
n主动输入的n值，用于ack函数进行计算
运行截图
八、判断s字符串是否为“回文”的递归函数。
这题可以利用第六题的代码进行读取字符串，然后比较第一个和最后一个字符是否相同，如果是，则左边索引加一，右边索引减一，一直递归执行。如果此时左右索引相等，则输出肯定的结果。如果判断到左右索引指向的字符不相同，则输出否定的结果。
#include <iostream>
#include<string>
using namespace std;
string s;
bool Check(int L,int R)
{
if (L == R)//字符串长度为单数时，判断到左右索引相等为止
return true;
if (R - L == 1 && s[L] == s[R])//字符串长度为偶数时，判断到左右索引相减为一为止
return true;
if (s[L] == s[R])//左右索引指向的字符相等时继续递归执行
return(Check(L + 1, R - 1));
else//如果不相等，则返回false
return false;
}
int main()
{
while (1)
{
cout << "请输入一个字符串 : ";
cin >> s;
if (Check(0,s.length()-1))//布尔值
cout << "该字符串为回文" << endl;
else
cout << "该字符串不为回文" << endl;
}
}
变量解释
L字符串左边的索引，从0开始
R字符串右边的索引，从字符串的长度减一开始
运行截图
九、有一只经过训练的蜜蜂只能爬向右侧相邻的蜂房，不能反向爬行。如图 3-9 试求出蜜蜂从蜂房a爬到蜂房b的可能路线数(0<a<b<100)
如图可知，从a到b的可能路线数等于从a到b-1和从a到b-2的可能路线之和（当b-2小于a时为0，等于a时为1），所以根据此原理递归即可算出结果。
#include <iostream>
using namespace std;
int t[100];
int Check(int c)
{
if (c < 0)//b减a小于0时，由于不能向右走，所以可行路线为0
return 0;
else if (c == 0 || c == 1)//b减a为0或1时，到自己或自己加一的可行路线为1
return 1;
else
return(Check(c - 1) + Check(c - 2));//都不满足就返回c减1和c减2，继续递归计算
}
int main()
{
int a, b;
while (1)
{
cout << "请输入起始位置-蜂房a : ";
cin >> a;
cout << "请输入终止位置-蜂房b : ";
cin >> b;
cout << "蜂房a到蜂房b的可能路线有 " << Check(b - a) << " 个" << endl;
}
}
变量解释
c输入的终止位置与起始位置的差值
运行截图
十，狼找兔子问题：一座山周围有n个洞，顺时针编号为0,1,2,3,4,…,n-1.一只狼从0号洞开始，顺时针方向计数，每当经过第m个洞时，就进洞找兔子。例如n=5，m=3，狼经过的洞依次为0,3,1,4,2,0。输入m,n。试问兔子有没有幸免的机会？如果有该藏在哪？
由题意可知，在洞的数量n与狼每经过的m个洞便进入的m最小公倍数不为1时，兔子有机会可以生存。
#include <iostream>
using namespace std;
int main()
{
int n, m, cave[20]{}, flag{};
while (1)
{
cout << "请输入洞的数量 : ";
cin >> n;
cout << "请输入狼每经过几个洞就进洞 : ";
cin >> m;
for (int x = 2; x < m; x++)//检测m和n的最小公倍数，从2开始可以不判断公倍数为1的情况
{
for (int y = 2; y < n; y++)
{
if (n * x == m * y && (x != m && y != n))//搜寻最小公倍数
flag = 1;
}
}
if (n % m == 0 || flag)
cout << "兔子有机会生存!" << endl;
else//在n不是m的非零整数倍且无非一公倍数的情况下，兔子没有机会生存
cout << "兔子无法幸存" << endl;
for (int i = 0; i < n*n; i += m)
cave[i%n] = 1;//i%n在i值超出n时，变到下一个周期的合理位置
if (n % m == 0 || flag)
{
cout << "兔子躲在以下位置可以生存(从0开始) :";
for (int i = 0; i < n; i++)
{
if (cave[i] != 1)//输出狼没进过的洞的编号
cout << i << " ";
}
}
cout << endl;
}
}
变量解释
n洞的总数量
m请输入狼每经过m个洞就进洞
cave[20]初始化所有值为0，如果狼进去过则赋值为1
flag用于标记n,m是否有非1的最小公倍数是则为1否为0
运行截图
十一，请编程求1×2×3×…×n所得的数末尾有多少个0？(n由键盘输入，1000＜n＜10000)
看似需要巨量的计算，用数组存储每一位计算等…，但是这题的算法其实非常简单，只需要计算后面相乘的数字能被5整除的数字的数量即可(因为2的倍数出现的比5要多，所以可以不考虑2)，因为末尾0出现的来源只有5的倍数。这道题提醒了我们不能一拿到题目就开始做，要仔细分析题目的意思，想出最有效的解决思路。
#include <iostream>
using namespace std;
int main()
{
int n, count{};
while (1)
{
cout << "请输入N的数值 (1000<n<10000) :";
cin >> n;
while (n > 1)
{
n /= 5;//当前n能被5整除的数字的数量
count += n;//count增加
}
cout << endl << n << " 末尾有 " << count << " 个0" << endl;
count = 0;
}
}
变量解释
count储存n能被5及5的n次方整除的数字的数量
运行截图
十二，有52张牌，使它们全部正面朝上，第一轮是从第2张开始，凡是2的倍数位置上的牌翻成正面朝下；第二轮从第3张牌开始，凡是3的倍数位置上的牌，正面朝上的翻成正面朝下，正面朝下的翻成正面朝上；第三轮从第4张牌开始，凡是4的倍数位置上的牌按上面相同规则翻转，以此类推，直到翻的牌超过104张为止。统计最后有几张牌正面朝上，以及他们的位置号。
书的前面有类似的例题，难度不大，先声明一个长度为52的数组，然后统一赋值为1，接下来创建一个大循环用于计算是否翻了超过104张牌，然后小循环用于遍历数组，查找能被当前倍数整除的数字编号并修改值，小循环执行后倍数的数字加一。
#include <iostream>
using namespace std;
int main()
{
int a[52], count{}, b{ 2 }, countUP{};
for (int i = 0; i < 52; i++)
a[i] = 1;
while (count <= 104)//大循环退出条件
{
for (int i = 0; i < 52; i++)//遍历数组
{
if ((i + 1) % b == 0)//检查是否能整除
{
if (a[i] == 1)//如果为正面朝上
{
a[i] = 0;//则改为正面朝下
count++;//翻牌次数加一
if (count > 104)//如果翻牌次数大于104则退出循环
break;
}
else if (a[i] == 0)//如果为正面朝下
{
a[i] = 1;//则改为正面朝上
count++;//翻牌次数加一
if (count > 104)//如果翻牌次数大于104则退出循环
break;
}
}
}
b++;
}
cout << "第 ";
for (int i = 0; i < 52; i++)//输出值
{
if (a[i] == 1)
{
countUP++;
cout << i+1 << "、";
}
}
cout << " 张牌正面朝上 一共有" << countUP << "张" << endl;
}
变量解释
a[52]用于储存卡牌信息，1为正面朝上，0为正面朝下
count计数器，用于计算翻的牌的次数
b倍数，从2开始每次使用后递增
countUP用于最后输出阶段计算正面朝上的卡牌个数
运行截图
十三，A，B，C，D，E 5人为某次竞赛的前五名，他们在名次公布前猜名次。A说：B得第三名，C得第五名。B说：D得第二名，E得第四名。C说：B得第一名，E得第四名。D说：C得第一名，B得第二名。E说：D得第二名，A得第三名。结果每个人都猜对了一半，实际名次是什么呢？
同样是例题中出现过的题目，核心思想就是(名称 = = 排名)＋(名称 = = 排名) = = 1，然后就能很快得出结果。
#include <iostream>
using namespace std;
int main()
{
int a, b, c, d, e;
for (a = 1; a <= 5; a++)
{
for (b = 1; b <= 5; b++)
{
if (b != a)//在上一个循环的基础上继续，但是b不能与a名次相同
{
for (c = 1; c <= 5; c++)
{
if (c != a && c != b)//在上一个循环的基础上继续，但是c不能与a,b名次相同
{
for (d = 1; d <= 5; d++)
{
if (d != a && d != b && d != c)//在上一个循环的基础上继续，但是e不能与a,b,c名次相同
{
e = 15 - a - b - c - d;//五个人的排名总数为1+2+3+4+5 可由此得出e的排名，而不需要额外的一个循环
if (((b == 3) + (c == 5) == 1) && ((d == 2) + (e == 4) == 1) && ((b == 1) + (e == 4) == 1) && ((c == 1) + (b == 2) == 1) && ((d == 2) + (a == 3) == 1))
{
cout << " a : " << a << endl << " b : " << b << endl << " c : " << c << endl << " d : " << d << endl << " e : " << e << endl;
}
}
}
}
}
}
}
}
}
变量解释
a A的排名
b B的排名
c C的排名
d D的排名
e E的排名
运行截图
十四，编写算法求满足以下条件的3位整数n：它是完全平方数，其中又有两位数字相同，如144、676等。
没有难度，逐一检查每位的数字即可。
#include <iostream>
using namespace std;
int main()
{
int d[3]{}, e;
for (int i = 10; i <= 31; i++)//只有10到31之间的数字的完全平方有三位
{
e = i * i;//临时代表完全平方数，避免修改i的值
for (int j = 0; j < 3; j++)
{
d[j] = e % 10;//从高位开始存入
e /= 10;
}
if (d[0] == d[1] || d[0] == d[2] || d[1] == d[2])
{
for (int j = 2; j >= 0; j--)
{
cout << d[j];//从高位取出
}
cout << " ";
}
}
}
变量解释
d[3]用于存放某一三位完全平方数的所有位数字
e用于临时代表某三位完全平方数
运行截图
十五，两个乒乓球队进行比赛，各出3人。甲队为A、B、C 3人，乙队为X、Y、Z 3人，已抽签决定比赛名单。有人向队员打听比赛的名单，A说他不和X比，C说他不和X、Z比，请编写算法找出3对赛手的名单？
类似于第十三题，基本的解题思路几乎一致。
#include <iostream>
using namespace std;
int main()
{
int a, b, c;
for (a = 1; a <= 3; a++)
{
for (b = 1; b <= 3; b++)
{
if (b != a)//不可能两个人跟一个人比
{
c = 6 - a - b;//总排名数减去其他两个人的排名
if (a != 1 && c != 1 && c != 3)//A不和X比，C不和X、Z比
cout << "A : " << a << " B : " << b << " C : " << c << endl;
}
}
}
}
变量解释
a代表队员A
b代表队员B
c代表队员C
运行截图
十六，编写算法对输入的一个整数，判断它能否被4，7，9整除，并输出以下信息之一：能同时被4，7，9整除；能被其中两个数（要指出哪两个）整除；能被其中一个数（要指出哪一个）整除；不能被4，7，9任一个整除。
由于要求计算三个的结果并记录，可以先声明一个为零的变量，当第N个条件成立时给此变量加上2的N-1次方，就可以达到标记的目的，在后面的SWITCH中每一个值都有其独特的意义。
#include <iostream>
using namespace std;
int main()
{
int a, n{};
while (1)
{
n = 0;//重置n的值
cout << "请输入一个数 : ";
cin >> a;
if (a % 4 == 0)
n += 1;
if (a % 7 == 0)
n += 2;
if (a % 9 == 0)
n += 4;
switch (n)//根据n的值来选择
{
case 1:
cout << "能被其中一个数 4 整除" << endl;
break;
case 2:
cout << "能被其中一个数 7 整除" << endl;
break;
case 3:
cout << "能被其中两个数 4 7 整除" << endl;
break;
case 4:
cout << "能被其中一个数 9 整除" << endl;
break;
case 5:
cout << "能被其中两个数 4 9 整除" << endl;
break;
case 6:
cout << "能被其中两个数 7 9 整除" << endl;
break;
case 7:
cout << "能同时被 4 7 9 整除" << endl;
break;
default:
cout << "不能被 4 7 9 任一个整除" << endl;
break;
}
}
}
变量解释
a用户输入的，用于计算的数字
n用于存放被整除的信息
运行截图
十七，完成给“余”猜数的游戏：心里先想好一个1~100之间的整数x，将它分别除以3，4和7并得到3个余数。把这三个余数输入计算机，计算机能马上猜出这个数
Please think of a number between 1 and 100
Your number divided by 3 has a remainder of 1
Your number divided by 5 has a remainder of 0
Your number divided by 7 has a remainder of 5
let me think a moment …
Your number was 40
在基础例题篇有完全一样的题目，在此采用简单的For循环方法遍历找出。
#include <iostream>
using namespace std;
int main()
{
int a, b, c, i;
while (1)
{
i = 1;
cout << "Please think of a number between 1 and 100" << endl;
cout << "Your number divided by 3 has a remainder of ";
cin >> a;
cout << "Your number divided by 5 has a remainder of ";
cin >> b;
cout << "Your number divided by 7 has a remainder of ";
cin >> c;
cout << "let me think a moment …" << endl;
for (i = 1; i < 100; i++)
{
if (i % 3 == a && i % 5 == b && i % 7 == c)//搜索条件
{
break;//找到后退出，并保留i的值
}
}
if (i != 100)//i=100时不满足以上条件
cout << "Your number was " << i << endl;
}
}
变量解释
a用户想的数字除以3余下的值
b用户想的数字除以5余下的值
c用户想的数字除以7余下的值
i用于搜索并保存满足条件的值
运行截图
十八，求这样的两个数据：5位数=2×4位数，9个数字互不相同。
先设定一个大小为10的初始值为0的数组，每次出现一个数字就给这个编号赋值为1，如果在一次检验中发现某编号已经赋值为1，则给标记值赋值为1并退出检验循环，在大循环中用根据标记值的if函数进行下一轮循环并将数组复原。
#include <iostream>
using namespace std;
int main()
{
int a[10]{}, b, c, d, f, flag = 0;;
for (b = 12345; b < 98765; b++)//五位数的最小值12345最大值98765
{
for (c = 1234; c < 9876; c++)//四位数的最小值1234最大值9876
{
if (b == c * 2)
{
d = b;//临时替代b，c的变量，避免原值被修改
f = c;
for (int i = 0; i < 5; i++)//对五位数的每一位进行检验
{
if (a[d % 10 - 1] == 0)//如果未出现，则标记为已出现
a[d % 10 - 1] = 1;
else//如果已出现则退出循环
{
flag = 1;//标记值为1时复原数组继续外面的大循环
break;
}
d /= 10;
}
for (int i = 0; i < 4; i++)//对四位数的每一位进行检验
{
if (a[f % 10 - 1] == 0)//如果未出现，则标记为已出现
a[f % 10 - 1] = 1;
else
{
flag = 1;//标记值为1时复原数组继续外面的大循环
break;
}
f /= 10;
}
if (flag == 1)
{
for (int i = 0; i < 9; i++)//复原数组
a[i] = 0;
flag = 0;//复原标记值
continue;
}
else
cout << b << " = 2 × " << c << endl;//输出结果
}
}
}
}
变量解释
a[10]用于存放每一个数字是否出现的数据
b代表题目中的五位数
c代表题目中的四位数
e临时替代b的变量，避免原值被修改
f临时替代c的变量，避免原值被修改
flag标记是否出现重复数字
运行截图
十九，写一函数，输入一个十六进制数，输出相应的十进制数。
先声明一个char数组然后输入数组，再由strlen得到数组的长度，在接下来的循环中，由于执行的方向并不对应输入的16进制每一位在数组中的存放方向，所以次数为数组的长度减去循环数加一。代码中包含用于测试的Cout。
#include <iostream>
#include<math.h>
using namespace std;
int main()
{
char a[50];
int b, c{};
while (1)
{
c = 0;
cin >> a;
b = strlen(a);//获取数组长度
//cout << "b :" << b << endl;
for (int i = 0; i < b; i++)
{
//cout << "i :" << i << " Pow(16,i) :" << pow(16, i) << endl;
switch (a[i])
{
case 'a':
c += pow(16, b - (i + 1)) * 10;//pow来源为math.h头文件，用于求出16的X次方
//cout << "c :" << c << endl;//由于读取的与实际存放的数据方向是相反的，所以需要改成b-(i+1)而不是i-1
break;
case 'b':
c += pow(16, b - (i + 1)) * 11;
//cout << "c :" << c << endl;
break;
case 'c':
c += pow(16, b - (i + 1)) * 12;
//cout << "c :" << c << endl;
break;
case 'd':
c += pow(16, b - (i + 1)) * 13;
//cout << "c :" << c << endl;
break;
case 'e':
c += pow(16, b - (i + 1)) * 14;
//cout << "c :" << c << endl;
break;
case 'f':
c += pow(16, b - (i + 1)) * 15;
//cout << "c :" << c << endl;
break;
default:
c += pow(16, b - (i + 1)) * (a[i] - 48);//小于10的部分
//cout << "c :" << c << endl;
break;
}
}
cout <<"转换至16进制 :"<< c << endl;
}
}
变量解释
a[50]用于存放用户输入的16进制数
b通过strlen获取a数组的长度
c用于存放输出的10进制数
运行截图
二十，用1，2，3，4，5，6，7，8，9 这9个数字，填入□中使等式成立，每个数字恰好用一次：□□×□□□=□□□□。
三个变量用for循环找出可以满足条件的三个值，再用一个长度为10的数组判断每个数字出现的次数，如果某个数字超过一次出现则舍弃。
#include <iostream>
using namespace std;
int main()
{
int a[10]{}, b, c, d, tb, tc, td, flag{};
for (b = 12; b <= 98; b++)//两位数循环
{
for (c = 123; c <= 987; c++)//三位数循环
{
for (d = 1234; d <= 9876; d++)//四位数循环
{
if (b * c == d)//判断是否满足条件，如果是则继续往下，否则继续循环
{
tb = b;//避免原值被修改
tc = c;
td = d;
while (tb > 0)//取出两位数的每一位
{
if (a[(tb % 10) - 1] == 0)
a[(tb % 10) - 1] = 1;
else
flag = 1;
tb /= 10;
}
while (tc > 0)//取出三位数的每一位
{
if (a[(tc % 10) - 1] == 0)
a[(tc % 10) - 1] = 1;
else
flag = 1;
tc /= 10;
}
while (td > 0)//取出四位数的每一位
{
if (a[(td % 10) - 1] == 0)
a[(td % 10) - 1] = 1;
else
flag = 1;
td /= 10;
}
if (flag != 1)//未出现重复时输出结果
cout << b << "×" << c << "=" << d << endl;
else//否则重置数组，继续进行循环
{
for (int i = 0; i < 9; i++)
a[i] = 0;
flag = 0;
}
}
}
}
}
}
变量解释
a[10]初始化为0，用于标记某数字是否出现过
b代表算式中的两位数
c代表算式中的三位数
d代表算式中的四位数
tb用于临时替代变量b，避免b的值被修改
tc用于临时替代变量c，避免c的值被修改
td用于临时替代变量d，避免d的值被修改
flag用于标记是否有重复数字出现
运行截图
二十一，求这样的6位数：SQRT（6位数）=3位数，9个数字互不相同（SQRT表示开平方）。
本题思路与代码跟上一题几乎完全一致。
#include <iostream>
using namespace std;
int main()
{
int a[10], b, c, tb, tc, flag{};
for (b = 123; b < 987; b++)
{
for (c = 123456; c < 987654; c++)
{
if (b * b == c)
{
tb = b;//避免原值被修改
tc = c;
while (tb > 0)//取出三位数的每一位
{
if (a[(tb % 10) - 1] == 0)
a[(tb % 10) - 1] = 1;
else
flag = 1;
tb /= 10;
}
while (tc > 0)//取出六位数的每一位
{
if (a[(tc % 10) - 1] == 0)
a[(tc % 10) - 1] = 1;
else
flag = 1;
tc /= 10;
}
if (flag != 1)//未出现重复时输出结果
cout << "SQRT(" << c << ") = " << b << endl;
else//否则重置数组，继续进行循环
{
for (int i = 0; i < 9; i++)
a[i] = 0;
flag = 0;
}
}
}
}
}
变量解释
a[10]初始化为0，用于标记某数字是否出现过
b代表算式中的三位数
c代表算式中的六位数
tb用于临时替代变量b，避免b的值被修改
tc用于临时替代变量c，避免c的值被修改
flag用于标记是否有重复数字出现
运行截图
二十二，键盘输入n个正整数，把它们看作一个“数圈”，求其中连续4个数之和的最大者。
本题唯一难点就是数圈，而数圈的实现只需要把索引值改成索引值除N的余即可。
#include <iostream>
using namespace std;
int main()
{
int a[100]{}, b{}, n, max{};
while (1)
{
cout << "请输入N的值 : ";
cin >> n;
for (int i = 0; i < n; i++)//输入数据
cin >> a[i];
for (int i = 0; i < n; i++)
{
if ((a[i] + a[(i + 1) % n] + a[(i + 2) % n] + a[(i + 3) % n]) > max)//数圈判断最大的四位数
{
max = a[i] + a[(i + 1) % n] + a[(i + 2) % n] + a[(i + 3) % n];//如果比现有max大，就给max赋此四个数相加的值
b = i;//同时记下起始索引
}
}
cout << "数圈连续四位最大的数字是 : " << a[b] << " " << a[(b + 1) % n] << " " << a[(b + 2) % n] << " " << a[(b + 3) % n] << endl;
}
}
变量解释
a[100]用于存放用户输入的数据
b用于记录出现的最大的四个数的起始索引
n用于记录有几个数据输入
max用于存放四个数相加的最大值
运行截图
二十三，输入一个5位数以内的正整数，完成以下操作：①判断它是一个几位数。②请按序输出其各位数字。③逆序输出其各位数字。
只需要用循环将输入的正整数除十求余判断是否大于0即可获取输入正整数的位数，正逆序的输出只需要考虑索引值的开始和结束即可。
#include <iostream>
using namespace std;
int main()
{
int a, c[5]{}, count{};
while (1)
{
count = 0;
cout << "请输入一个数字(5位以内) : ";
cin >> a;
if (a == 0)//由于循环在a=0时直接跳过了，所以需要在此考虑a为0的情况
count = 1;
for (int i = 0; a > 0; i++)
{
c[i] = a % 10;//存放最低位
a /= 10;
count++;
}
cout << "此数字为 " << count << " 位数" << endl;
cout << "按序输出 : ";
for (int i = count - 1; i >= 0; i--)
{
cout << c[i] << " ";
}
cout << endl;
cout << "逆序输出 : ";
for (int i = 0; i < count; i++)
{
cout << c[i] << " ";
c[i] = 0;
}
cout << endl;
}
}
变量解释
a为用户输入的数字
c[5]用于存放输入的数据的每一位
count用于计算输入数据的位数
运行截图
二十四，乘式还原，有乘法运算如下。式中8个⚪位置上的数字全部是素数，请还原这算式。
完全遍历可快速解决。
#include <iostream>
using namespace std;
int main()
{
int a, b, c, d,e,flag{};
for (a = 1; a < 10; a++)
{
for (b = 100; b < 1000; b++)
{
for (c = 1000; c < 10000; c++)
{
if (a * b == c)
{
if (a != 2 && a != 3 && a != 5 && a != 7)//如果不满足任何条件则不为素数退出这一轮循环
continue;
d = b;
e = c;
while (d > 0)//用于确认每一位都检查到了
{
if (d % 10 != 2 && d % 10 != 3 && d % 10 != 5 && d % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
d /= 10;//下一位
}
while (e > 0)//用于确认每一位都检查到了
{
if (e % 10 != 2 && e % 10 != 3 && e % 10 != 5 && e % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
e /= 10;//下一位
}
if (flag == 1)//如果flag为1则复原flag的值并退出循环，不输出
{
flag = 0;
continue;
}
cout << a << " × " << b << " = " << c << endl;
}
}
}
}
}
变量解释
a代表被乘数
b代表乘数
c代表商
d用于临时替代b避免原值被修改
e用于临时替代c避免原值被修改
flag用于标记bc中的每一位是否为素数
运行截图
二十五，乘式还原，有乘法运算如下。式中18个⚪位置上的数字全部是素数（2，3，5或7），请还原这算式。
与上一题思路一致，但有部分细节不一样,只需要多考虑几个数字的每一位即可。
#include <iostream>
using namespace std;
int main()
{
int a, b, c, d, e, f, flag{};
for (a = 100; a < 1000; a++)//被乘数
{
for (b = 10; b < 100; b++)//乘数
{
for (c = 10000; c < 100000; c++)//结果
{
if (a * b == c)
{
d = b;
while (d > 0)//用于确认每一位都检查到了
{
if (d % 10 != 2 && d % 10 != 3 && d % 10 != 5 && d % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
d /= 10;//下一位
}
e = a;
while (e > 0)//用于确认每一位都检查到了
{
if (e % 10 != 2 && e % 10 != 3 && e % 10 != 5 && e % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
e /= 10;//下一位
}
f = c;
while (f > 0)//用于确认每一位都检查到了
{
if (f % 10 != 2 && f % 10 != 3 && f % 10 != 5 && f % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
f /= 10;//下一位
}
d = b;
int temp1 = d % 10;
d /= 10;
int temp2 = d;
int temp3 = temp1 * a;
int temp4 = temp2 * a / 10;
while (temp3 > 0)
{
if (temp3 % 10 != 2 && temp3 % 10 != 3 && temp3 % 10 != 5 && temp3 % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
temp3 /= 10;//下一位
}
while (temp4 > 0)
{
if (temp4 % 10 != 2 && temp4 % 10 != 3 && temp4 % 10 != 5 && temp4 % 10 != 7)//如果不满足任何条件则不为素数退出这一轮循环
{
flag = 1;
break;
}
temp4 /= 10;//下一位
}
if (flag == 1)//如果flag为1则复原flag的值并退出循环，不输出
{
flag = 0;
continue;
}
cout << a << " × " << b << " = " << c << endl;
}
}
}
}
}
变量解释
a代表被乘数
b代表乘数
c代表商
d用于临时替代b避免原值被修改
e用于临时替代a避免原值被修改
f用于临时替代c避免原值被修改
flag用于标记算式中所有数字的每一位是否为素数
temp1用于临时表示b的个位数
temp2用于临时表示b的十位数
temp3用于临时表示b的个位数乘以a
temp4用于临时表示b的十位数乘以a
运行截图
二十六，读入自然数m和n（0≤m＜n≤1000），判断分数m/n是有限小数还是循环小数。如果m/n是有限小数，则输出分数的值；如果m/n为循环小数，则把循环的部分在括号中打印输出。
这题做的有点晕，代码也有些乱，但是基本实现了题目要求的功能。
#include <iostream>
using namespace std;
int main()
{
double m, n;
int c, flag{};
int a, b[15]{}, i{};
while (1)
{
cout << "请分别输入M和N的值 : ";
cin >> m >> n;
cout.precision(15);
cout << m / n;
c = m / n * 1000000000;
while (c)
{
b[i] = c % 10;
c /= 10;
i++;
}
for (int i = 0; i < 15; i++)
{
if (flag == 1)
break;
for (int y = i + 1; y < 15; y++)
{
if (b[i] == b[i + 1] == b[i + 2] && b[i] != 0)
{
cout << "(" << b[i] << ")" << endl;
main();
}
if (b[i] == b[y])
{
for (int d = 1; d < y - i; d++)
{
if (b[i + d] == b[y + d])
continue;
else
flag == 1;
break;
}
if (flag == 1)
break;
else
{
int d = y - i - 1;
if (b[i + d] == 0)
{
cout << endl;
main();
}
else
{
cout << "(";
for (d; d >= 0; d--)
cout << b[i + d];
cout << ")" << endl;
main();
flag == 1;
}
}
if (flag == 1)
break;
}
}
if (flag == 1)
break;
}
for (int i = 0; i < 15; i++)
b[i] = 0;
flag = 0;
}
}
变量解释
m用户输入的被除数
n用户输入的除数
运行截图
二十七，月份翻译：编程当输入数据为1~12时，翻译成对应的英语月份，如输入“3”翻译输出“march”。
没有难度。
#include <iostream>
using namespace std;
int main()
{
int a;
while (1)
{
cout << " 请输入一个数字 : ";
cin >> a;
switch (a)
{
case 1:
cout << "January" << endl;
break;
case 2:
cout << "February" << endl;
break;
case 3:
cout << "March" << endl;
break;
case 4:
cout << "April" << endl;
break;
case 5:
cout << "May" << endl;
break;
case 6:
cout << "June" << endl;
break;
case 7:
cout << "July" << endl;
break;
case 8:
cout << "August" << endl;
break;
case 9:
cout << "September" << endl;
break;
case 10:
cout << "October" << endl;
break;
case 11:
cout << "November" << endl;
break;
case 12:
cout << "December" << endl;
break;
}
}
}
变量解释
a用户输入的月份数字
运行截图
1788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
