一、第一周
1 求最大公约数和最小公倍数
题目内容：
编写程序，在主函数中输入两个正整数 a,b，调用两个函数 fun1() 和 fun2()，分别求 a 和 b 的最大公约数和最小公倍数，在主函数中输出结果。
输入格式：
两个正整数
输出格式：
最大公约数和最小公倍数
输入样例：
12,40[回车]
输出样例：
最大公约数：4[回车]
最小公倍数：120[回车]
代码：
#include<stdio.h>
int fun1(int a,int b){
int min,max;
if(a<=b){
min=a;
max=b;
}
else{
min=b;
max=a;
}
for(int i=min;i>0;i--){
if((min%i==0)&&(max%i==0)){
return i;
}
}
}
int fun2(int a,int b){
int num;
return a*b/fun1(a,b);
}
int main(){
int a,b;
scanf("%d,%d",&a,&b);
printf("最大公约数：%d\n",fun1(a,b));
printf("最小公倍数：%d\n",fun2(a,b));
}
解释：
这段代码包含了两个函数fun1和fun2，以及main函数。fun1函数用于计算两个整数的最大公约数（Greatest Common Divisor, GCD），而fun2函数用于计算两个整数的最小公倍数（Least Common Multiple, LCM）。最后，main函数获取用户输入的两个整数，并调用这两个函数来输出它们的最大公约数和最小公倍数。
#include<stdio.h>
int fun1(int a,int b){
int min,max;
if(a<=b){
min=a;
max=b;
}
else{
min=b;
max=a;
}
for(int i=min;i>0;i--){
if((min%i==0)&&(max%i==0)){
return i;
}
}
}
fun1函数接收两个整数a和b作为参数，并返回它们的最大公约数。首先，函数确定两个数中的最小值和最大值。然后，它从最小值开始向下遍历，直到找到能够同时整除这两个数的最大数，即最大公约数。
int fun2(int a,int b){
int num;
return a*b/fun1(a,b);
}
fun2函数接收两个整数a和b作为参数，并返回它们的最小公倍数。它通过调用fun1函数来获取a和b的最大公约数，然后使用公式a*b/GCD(a,b)来计算最小公倍数，其中GCD(a,b)是a和b的最大公约数。
int main(){
int a,b;
scanf("%d,%d",&a,&b);
printf("最大公约数：%d\n",fun1(a,b));
printf("最小公倍数：%d\n",fun2(a,b));
}
main函数是程序的入口点。它首先通过scanf函数读取用户输入的两个整数a和b，然后分别调用fun1和fun2函数来计算并打印这两个整数的最大公约数和最小公倍数。
需要注意的是，scanf函数中的格式字符串"%d,%d"期望输入时两个整数之间有一个逗号,。如果用户输入时没有逗号，程序将无法正确读取两个整数。此外，fun1函数在找到最大公约数后应该立即返回，而不是继续执行循环。在fun1函数中，找到最大公约数后应该有一个break语句来退出循环，以提高效率。
2 排序并插入
题目内容：
编写程序，在主函数中定义一个有10个元素的整型一维数组，用户输入9个数据，调用函数，对数组元素进行从小到大排序后，在函数中输入一个数，插入到数组中正确的位置，并输出。
输入格式:
9个整数和1个整数
输出格式：
10个整数
输入样例：
2,3,1,5,6,76,89,31,90[回车]
7[回车]
输出样例：
1,2,3,5,6,7,31,76,89,90[回车]
代码：
#include <stdio.h>
void sort(int n[],int m)
{
int i,j,t;
for(i=0; i<9; i++)
{
for(j=0; j<= 8-i; j++)
{
if(n[j] > n[j+1])
{
t = n[j];
n[j] = n[j+1];
n[j+1] = t;
}
}
}
for(i=0; i<10; i++)
{
printf("%d",n[i]);
if(i<9) printf(",");
}
}
int main()
{
int j,i,n[10];
for(i=0; i<9; i++)
{
scanf("%d", &n[i]);
if(i<8) scanf(",");
}
scanf("%d",&n[9]);
sort(n,10);
return 0;
}解释
这段代码的主要功能是读取10个整数，然后使用插入排序算法对它们进行排序，并按照逗号分隔的格式输出排序后的数字。
#include <stdio.h>
void sort(int n[], int m) {
int i, j, t;
for (i = 0; i < 9; i++) {
for (j = 0; j <= 8 - i; j++) {
if (n[j] > n[j + 1]) {
t = n[j];
n[j] = n[j + 1];
n[j + 1] = t;
}
}
}
for (i = 0; i < 10; i++) {
printf("%d", n[i]);
if (i < 9) printf(",");
}
}
sort函数接收一个整数数组n和数组的大小m。它使用插入排序算法对数组进行排序。插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。排序完成后，函数会打印出排序后的数组，每个元素之间用逗号分隔。
int main() {
int j, i, n[10];
for (i = 0; i < 9; i++) {
scanf("%d", &n[i]);
if (i < 8) scanf(",");
}
scanf("%d", &n[9]);
sort(n, 10);
return 0;
}
main函数是程序的入口点。它首先声明一个整型数组n，大小为10。然后，它使用scanf函数读取10个整数，存储在数组n中。在读取前9个数字后，程序还会读取一个逗号。最后，调用sort函数对数组进行排序，并打印排序后的结果。
二、第二周
1 最大公约数
题目内容：
输入两个整数m,n，用递归算法实现计算两个数的最大公约数。
输入格式:
输入两个整数m,n
输出格式：
最大公约数
输入样例：
12,40[回车]
输出样例：
4[回车]
代码
#include<stdio.h>
int fun1(int a,int b){
int c;
while(b!=0){
c=a%b;
a=b;
b=c;
}
return a;
}
int main(){
int a,b;
scanf("%d,%d",&a,&b);
printf("%d\n",fun1(a,b));
return 0;
}解释
这段代码定义了一个名为fun1的函数，该函数用于计算两个整数的最大公约数（Greatest Common Divisor, GCD），并在main函数中调用fun1来计算用户输入的两个整数的最大公约数。
#include<stdio.h>
int fun1(int a, int b){
int c;
while(b != 0){
c = a % b;
a = b;
b = c;
}
return a;
}
fun1函数使用辗转相除法（也称欧几里得算法）来计算最大公约数。辗转相除法的基本思想是：两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c和b之间的最大公约数。在函数中，a和b的值在每次循环中被更新，直到b变为0，此时a的值就是两个数的最大公约数。
int main(){
int a, b;
scanf("%d,%d", &a, &b);
printf("%d\n", fun1(a, b));
return 0;
}
main函数是程序的入口点。它首先声明两个整型变量a和b，然后使用scanf函数读取用户输入的两个整数，这两个整数之间需要用逗号分隔。接着，调用fun1函数计算这两个整数的最大公约数，并使用printf函数输出结果。
2 奇数求和
题目内容：
用递归算法实现，输入整数n（n>0）, 求1+3+5+7….+(2*n-1) 的和
输入格式:
输入整数n
输出格式：
输出和
输入样例：
5[回车]
输出样例：
25[回车]
代码
#include<stdio.h>
int main(){
int n,sum=0;
scanf("%d",&n);
for(int i=1;i<=n;i++){
sum+=2*i-1 ;
}
printf("%d\n",sum);
}解释
-
#include<stdio.h>：这行代码包含了标准输入输出库stdio.h，它提供了基本的输入输出功能，如scanf和printf。 -
int main()：这是主函数，程序的入口点。 -
int n, sum=0;：声明了两个整型变量n和sum，其中sum初始化为0，用于存储奇数的和。 -
scanf("%d",&n);：这行代码从用户那里读取一个整数n。 -
for(int i=1; i<=n; i++)：这是一个for循环，它从1开始，递增到n。 -
sum += 2*i - 1;：这是循环体中的唯一语句，它计算当前循环次数i对应的奇数（2i - 1），并将其加到sum上。由于i从1开始，2i - 1总是奇数。 -
printf("%d\n",sum);：循环结束后，这行代码输出计算得到的奇数和sum。 -
return 0;：表示程序正常退出。
三、第三周
1 巧算自然数
题目内容：
编程实现输入一个自然数，若为偶数，则把它除以2；若为奇数，则把它乘以3加1。经过如此有限次运算后，总可以得到自然数值1。输出经过多少次可以得到自然数1和每次得到的值。
输入格式：
输入一个自然数
输出格式：
输出经过多少次可以得到自然数1和每次得到的值
输入样例：
22[回车]
输出样例：
22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1[回车]
step=16[回车]
代码：
#include<stdio.h>
void number(int n){
int step=0;
printf("%d",n);
while(n!=1){
if(n%2==0){
n=n/2;
}
else{
n=3*n+1;
}
step+=1;
printf(",%d",n);
}printf("\nstep=%d\n",step+1);
}
int main(){
int n,step;
scanf("%d",&n);
number(n);
}解释：
这段代码实现了一个称为“Collatz 序列”（也称为“3n+1 猜想”或“奇偶归一猜想”）的数学问题。Collatz 序列的定义是：对于任何一个正整数n，如果n是偶数，则将其除以2；如果n是奇数，则将其变为3n+1。重复这个过程，最终所有数都会变为1。
-
#include<stdio.h>：这行代码包含了标准输入输出库stdio.h，它提供了基本的输入输出功能，如scanf和printf。 -
void number(int n)：这是一个名为number的函数，它接受一个整数n作为参数，并打印出从n开始的Collatz序列。 -
int step=0;：在number函数中，声明了一个整型变量step，用于记录执行步骤数。 -
printf("%d",n);：打印出当前的数值n。 -
while(n!=1)：这是一个while循环，它会一直执行，直到n变为1。 -
if(n%2==0)：判断n是否为偶数。如果是，则执行n=n/2。 -
else：如果n是奇数，则执行n=3*n+1。 -
step+=1;：每执行一次操作，step就增加1。 -
printf(",%d",n);：打印出经过一次操作后的新值n。 -
printf("\nstep=%d\n",step+1);：当循环结束时，打印出总共执行的步骤数。注意，这里打印的是step+1，因为初始值n也算一步。 -
int main()：这是主函数，程序的入口点。 -
int n,step;：声明了两个整型变量n和step。step在这里并没有被使用，可以删除。 -
scanf("%d",&n);：从用户那里读取一个整数n。 -
number(n);：调用number函数，传入用户输入的整数n。
2 卖鸭子
题目内容：
编程调用递归函数。一个人赶着鸭子去每个村庄卖，每经过一个村子卖去所赶鸭子的一半又一只。这样他经过了7个村子后还剩2只鸭子，问他出发时共赶多少只鸭子？经过每个村子时依次卖出多少只鸭子？
输入格式：
无
输出格式：
出发时总鸭子数
每个村子卖出鸭子数
输入样例：
无
输出样例：(不是结果，仅表示格式)
sum=25[回车]
sell=8,sell=4,[回车]
代码：
#include<stdio.h>
int circ(int);
int main()
{
int all, v, sum;
all = circ(7);
printf("sum=%d\n",all);
for(v = 0; v < 7; v++)
{
sum = all / 2 + 1;
printf("sell=%d,", sum);
all = all / 2 - 1;
}
printf("\n");
return 0;
}
int circ(int i)
{
if(i == 0)
{
return 2;
}
else
{
i = 2*( circ(i - 1) +1);
return i;
}
}解释：
这段代码定义了一个名为circ的递归函数，用于计算一个特定的数列中的第i项的值。然后在main函数中使用这个函数来计算一个剧场中座位的总数，并模拟座位销售的过程。
#include<stdio.h>
int circ(int);
int main()
{
int all, v, sum;
all = circ(7); // 调用circ函数计算第7项的值
printf("sum=%d\n",all); // 打印总座位数
for(v = 0; v < 7; v++) // 循环7次，模拟7天的销售过程
{
sum = all / 2 + 1; // 计算当天销售的座位数
printf("sell=%d,", sum); // 打印当天销售的座位数
all = all / 2 - 1; // 更新剩余的座位数
}
printf("\n");
return 0;
}
int circ(int i)
{
if(i == 0)
{
return 2; // 基本案，第0项的值为2
}
else
{
i = 2 * (circ(i - 1) + 1); // 递归计算第i项的值
return i;
}
}
-
#include<stdio.h>：这行代码包含了标准输入输出库stdio.h，它提供了基本的输入输出功能，如printf。 -
int circ(int);：这是circ函数的声明，它接受一个整数i作为参数，并返回一个整数。 -
int main()：这是主函数，程序的入口点。 -
all = circ(7);：调用circ函数计算第7项的值，并将其存储在变量all中。 -
printf("sum=%d\n",all);：打印出总座位数all。 -
for(v = 0; v < 7; v++)：这是一个for循环，它将执行7次，模拟7天的销售过程。 -
sum = all / 2 + 1;：计算当天销售的座位数。这里假设每天销售的座位数是剩余座位数的一半加一。 -
printf("sell=%d,", sum);：打印出当天销售的座位数。 -
all = all / 2 - 1;：更新剩余的座位数。这里假设每天销售后剩余的座位数是前一天的一半减一。 -
printf("\n");：打印一个换行符，以便于输出格式整洁。 -
int circ(int i)：这是circ函数的定义，它使用递归的方式来计算一个数列的第i项的值。 -
if(i == 0)：这是递归的基本情况，当i为0时，返回2。 -
else：否则，递归调用circ(i - 1)，并计算出第i项的值。
3 输出各位数字之和
题目内容：
编程调用递归函数，求输入一个数，输出这个数的各位数字之和。
输入格式：
输入一个数
输出格式：
输出这个数的各位数字之和
输入样例：
2354[回车]
输出样例：
14[回车]
代码：
#include <stdio.h>
void f(char *p,int *y)
{
if(*p!='\0') { *y+=*p++ -48;f(p,y);}
}
main()
{
char a[10];int sum;
gets(a);f(a,&sum);
printf("%d\n",sum);
}解释：
这段代码定义了一个名为f的函数，它接受一个指向字符串的指针p和一个指向整数的指针y。函数的作用是将字符串中的每个字符转换为对应的数字，并将这些数字相加，结果存储在y指向的整数中。main函数中调用f函数，读取用户输入的字符串，并打印出转换后的数字和。
-
#include <stdio.h>：这行代码包含了标准输入输出库，用于使用scanf和printf函数。 -
void f(char *p, int *y)：这是f函数的声明，它接受一个指向字符串的指针p和一个指向整数的指针y。 -
if (*p != '\0')：这是一个条件语句，用于检查字符串是否还有未处理的字符。 -
*y += *p - 48;：如果字符串还有未处理的字符，则将字符转换为对应的数字（通过减去ASCII码值48），并加到y指向的整数中。 -
f(p + 1, y);：递归调用f函数，处理字符串的下一个字符。 -
int main()：这是主函数，程序的入口点。 -
char a[10];：声明了一个名为a的字符数组，大小为10，用于存储用户输入的字符串。 -
int sum;：声明了一个名为sum的整数变量，用于存储字符串中字符转换后的数字和。 -
gets(a);：从用户那里读取一个字符串，并存储在a数组中。 -
f(a, &sum);：调用f函数，将a数组中的字符转换为数字，并将结果存储在sum变量中。 -
printf("%d\n", sum);：打印出转换后的数字和。 -
return 0;：表示程序正常退出。
四、第四周
1 对称字符串
题目内容：
从键盘输入一个字符串，判断是否为对称字符串，若是输出“YES”，若不是输出“NO”
输入格式：
一个字符串
输出格式：
YES or NO
输入样例1：
abcdedcba[回车]
输出样例1：
YES[回车]
输入样例2：
1234432[回车]
输出样例2：
NO[回车]
代码：
#include <stdio.h>
#include <string.h>
char f(char *p,char *s)
{
if(*p==*s)
{
if(p++<s--)
f(p,s);
else
return 1;
}
else return 0;
}
main()
{
char a[40],b;
gets(a);
b=f(a,&a[strlen(a)-1]);
if(b) printf("YES\n");
else printf("NO\n");
}解释：
这段代码实现了一个简单的字符串比较函数f，该函数用于比较两个字符串是否相同。如果两个字符串相同，它返回1；如果不相同，它返回0。在main函数中，程序首先读取用户输入的字符串，然后使用f函数来比较字符串的第一个字符和最后一个字符是否相同。最后，根据f函数的返回值，程序打印出“YES”或“NO”。
#include <stdio.h>
#include <string.h>
char f(char *p, char *s)
{
if (*p == *s)
{
if (p++ < s--)
f(p, s);
else
return 1;
}
else
return 0;
}
int main()
{
char a[40], b;
gets(a); // 从用户那里读取一个字符串，存入数组a中
b = f(a, &a[strlen(a) - 1]); // 调用f函数，比较字符串的第一个字符和最后一个字符
if (b)
printf("YES\n"); // 如果两个字符串相同，打印"YES"
else
printf("NO\n"); // 否则打印"NO"
return 0;
}
-
#include <stdio.h>：这行代码包含了标准输入输出库，用于使用scanf和printf函数。 -
#include <string.h>：这行代码包含了字符串操作库，用于使用strlen函数。 -
char f(char *p, char *s)：这是f函数的声明，它接受两个指向字符的指针p和s。 -
if (*p == *s)：这是一个条件语句，用于检查两个字符是否相同。 -
if (p++ < s--)：这是一个条件语句，用于检查p是否指向字符串的末尾。如果p指向末尾，则递归调用f函数，比较下一个字符。 -
else return 1;：如果两个字符相同且p不指向末尾，则返回1。 -
else return 0;：如果两个字符不同，则返回0。 -
int main()：这是主函数，程序的入口点。 -
char a[40];：声明了一个名为a的字符数组，大小为40，用于存储用户输入的字符串。 -
gets(a);：从用户那里读取一个字符串，并存储在a数组中。 -
b = f(a, &a[strlen(a) - 1]);：调用f函数，比较字符串的第一个字符和最后一个字符。 -
if (b)：如果f函数返回1，则打印"YES"。 -
else：如果f函数返回0，则打印"NO"。 -
return 0;：表示程序正常退出。
2 排序
题目内容：
用指针方法，将一维数组int a[10] 中元素按从小到大顺序输出。
输入格式：
10个整数，空格隔开
输出格式：
排序后的10个数，逗号隔开
输入样例：
12 34 56 43 7 89 81 11 33 90[回车]
输出样例：
7,11,12,33,34,43,56,81,89,90[回车]
代码：
#include <stdio.h>
#include <string.h>
void swap(int *pa,int n)
{
int i,j,t;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(*(pa+i)>*(pa+j))
{
t=*(pa+i);
*(pa+i)=*(pa+j);
*(pa+j)=t;
}
}
}
}
int main()
{
int i,n,a[100];
n=10;
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
swap(a,n);
for(i=0;i<n;i++)
{ if(i!=9)
printf("%d,",a[i]);
else
printf("%d\n",a[i]);
}
return 0;
}解释：
这段代码实现了一个简单的排序功能，它定义了一个名为swap的函数，用于对整数数组进行冒泡排序，并在main函数中调用该函数对用户输入的整数数组进行排序，并打印排序后的结果。
解释：
-
#include <stdio.h>：这行代码包含了标准输入输出库，用于使用scanf和printf函数。 -
#include <string.h>：这行代码包含了字符串操作库，用于使用strlen函数。 -
void swap(int *pa, int n)：这是swap函数的声明，它接受一个指向整数数组的指针pa和一个整数n，表示数组的长度。 -
for (i = 0; i < n - 1; i++)：这是一个for循环，用于遍历数组的前n-1个元素。 -
for (j = i + 1; j < n; j++)：这是嵌套的for循环，用于比较数组中的相邻元素。 -
if (*(pa + i) > *(pa + j))：这是一个条件语句，用于比较两个相邻元素的大小。 -
{ t = *(pa + i); *(pa + i) = *(pa + j); *(pa + j) = t; }：如果第一个元素大于第二个元素，则交换它们的位置。 -
int main()：这是主函数，程序的入口点。 -
int i, n, a[100];：声明了三个整型变量i、n和a，其中n用于存储数组的长度，a用于存储用户输入的整数数组。 -
n = 10;：假设数组长度为10。 -
for (i = 0; i < n; i++)：这是一个for循环，用于遍历数组中的每个元素。 -
scanf("%d", &a[i]);：从用户那里读取一个整数，并存储在数组a中。 -
swap(a, n);：调用swap函数对数组a进行冒泡排序。 -
for (i = 0; i < n; i++)：这是另一个for循环，用于打印排序后的数组a。 -
if (i != 9)：如果当前元素不是最后一个元素，则打印元素后加逗号。 -
else：如果当前元素是最后一个元素，则打印元素后加换行符。 -
return 0;：表示程序正常退出。
3 查找数
题目内容：
用指针方法，在一个一维数组int a[10]的元素中，查找给定的数，若找到则输出该数，若没找到，输出No。
输入格式：
第一行：10个整数，空格隔开
第二行：要查找的数
输出格式：
找到的数orNo
输入样例1：
11 22 43 56 78 90 76 4 2 10[回车]
43[回车]
输出样例1：
43[回车]
输入样例2：
1 8 3 4 5 6 2 1 7 9[回车]
10[回车]
输出样例2：
No[回车]
代码：
#include<stdio.h>
int main() {
int a[10] ;
for (int i = 0; i < 10; i++)
scanf("%d", &a[i]);
int* i=a;
int n;
scanf("%d", &n);
for (int j = 0; j < 10; j++)
{
if (*i == n) {
printf("%d\n",n);
return 0;
}
i++;
}
printf("No\n");
return 0;
}解释：
这段代码的目的是从用户那里读取一个整数数组a，并再次读取一个整数n。然后，程序检查数组a中是否包含值n，如果包含，则打印n并退出程序；如果不包含，则打印"No"并退出程序
#include<stdio.h>
int main() {
int a[10]; // 声明一个整数数组a，大小为10
for (int i = 0; i < 10; i++) // 循环10次，从用户那里读取10个整数，存入数组a中
scanf("%d", &a[i]);
int* i = a; // 声明一个整型指针i，指向数组a的第一个元素
int n; // 声明一个整型变量n，用于存储用户输入的整数
scanf("%d", &n); // 从用户那里读取一个整数n
for (int j = 0; j < 10; j++) // 循环10次，检查数组a中是否包含值n
{
if (*i == n) // 如果找到值n，则打印n并退出程序
{
printf("%d\n", n);
return 0;
}
i++; // 指针i指向数组的下一个元素
}
printf("No\n"); // 如果没有找到值n，则打印"No"并退出程序
return 0; // 程序正常退出
}
-
#include<stdio.h>：这行代码包含了标准输入输出库，用于使用scanf和printf函数。 -
int main()：这是主函数，程序的入口点。 -
int a[10];：声明了一个名为a的整数数组，大小为10，用于存储用户输入的整数。 -
for (int i = 0; i < 10; i++)：这是一个for循环，用于从用户那里读取10个整数，并存储在数组a中。 -
int* i = a;：声明了一个名为i的整型指针，并将其指向数组a的第一个元素。 -
int n;：声明了一个名为n的整型变量，用于存储用户输入的整数。 -
scanf("%d", &n);：从用户那里读取一个整数，并存储在变量n中。 -
for (int j = 0; j < 10; j++)：这是另一个for循环，用于检查数组a中是否包含值n。 -
if (*i == n)：这是一个条件语句，用于检查指针i指向的元素是否等于n。 -
printf("%d\n", n);：如果找到值n，则打印n。 -
return 0;：如果找到值n，则退出程序。 -
i++;：如果指针i指向的元素不等于n，则移动指针i指向下一个元素。 -
printf("No\n");：如果循环结束时没有找到值n，则打印"No"。 -
return 0;：表示程序正常退出。
五、第五周
1 输出指定学生成绩
题目内容：
从键盘输入3个同学4门课的成绩，输出指定同学的成绩和平均分。
输入格式：
输入3个同学4门课的成绩
输出格式：
输出指定同学的成绩和平均分
输入样例：
89 78 80 76 88 78 75 90 99 92 100 89[回车]
1[回车]
输出样例：
89 78 80 76[回车]
80.75[回车]
代码：
#include <stdio.h>
main()
{
float a[3][4];int i,j,n;static float sum[3];
for(i=0;i<3;i++)
for(j=0;j<4;j++)
{
scanf("%f",&a[i][j]);
sum[i]+=a[i][j];
}
scanf("%d",&n);
for(i=0;i<3;i++)
printf("%g ",a[n-1][i]);
printf("%g\n",a[n-1][3]);
printf("%g\n",1.0*sum[n-1]/4);
}解释：
这段代码的目的是从用户那里读取一个3x4的二维数组a，计算每个子数组的和，然后输出数组中指定行（通过输入的整数n）的值和该行的平均值。
#include <stdio.h>
main()
{
float a[3][4];
int i, j, n;
static float sum[3];
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
scanf("%f", &a[i][j]);
sum[i] += a[i][j]; // 计算每个子数组的和
}
}
scanf("%d", &n); // 从用户那里读取一个整数n
for (i = 0; i < 3; i++)
{
printf("%g ", a[n - 1][i]); // 输出指定行（n-1）的值
}
printf("%g\n", a[n - 1][3]); // 输出指定行的最后一个元素
printf("%g\n", 1.0 * sum[n - 1] / 4); // 输出指定行的平均值
return 0;
}
-
#include <stdio.h>：这行代码包含了标准输入输出库，用于使用scanf和printf函数。 -
main()：这是主函数，程序的入口点。 -
float a[3][4];：声明了一个名为a的二维数组，大小为3行4列，用于存储用户输入的浮点数。 -
int i, j, n;：声明了三个整型变量i、j和n，其中i和j用于循环，n用于存储用户输入的整数。 -
static float sum[3];：声明了一个名为sum的静态数组，大小为3，用于存储每个子数组的和。 -
for (i = 0; i < 3; i++)：这是一个for循环，用于遍历数组a的每一行。 -
for (j = 0; j < 4; j++)：这是嵌套的for循环，用于遍历数组a的每一列。 -
scanf("%f", &a[i][j]);：从用户那里读取一个浮点数，并存储在数组a中。 -
sum[i] += a[i][j];：计算每个子数组的和，并存储在数组sum中。 -
scanf("%d", &n);：从用户那里读取一个整数n。 -
for (i = 0; i < 3; i++)：这是另一个for循环，用于输出指定行（n-1）的值。 -
printf("%g ", a[n - 1][i]);：输出指定行（n-1）的每个元素，每个元素后加一个空格。 -
printf("%g\n", a[n - 1][3]);：输出指定行的最后一个元素，并在末尾加换行符。 -
printf("%g\n", 1.0 * sum[n - 1] / 4);：输出指定行的平均值，并在末尾加换行符。 -
return 0;：表示程序正常退出。
2 成绩排序
题目内容：
从键盘输入3个同学4门课的成绩，将其按平均分从高到低排序输出。
输入格式：
输入3个同学4门课的成绩
输出格式：
按平均分从高到低排序输出
输入样例：
89 78 80 76 88 78 75 90 99 92 100 89[回车]
输出样例：
99,92,100,89[回车]
88,78,75,90[回车]
89,78,80,76[回车]
代码：
#include<stdio.h>
int main()
{
int a[3][4];
int sum[3]={0},n[3];
for(int i=0;i<3;i++)
{
for(int j=0;j<4;j++)
{
scanf("%d",&a[i][j]);
sum[i]+=a[i][j];
n[i]=sum[i];
}
}
for(int i=0;i<2;i++)
{
for(int j=0;j<2-i;j++)
{
if(sum[j]<sum[j+1])
{
int t=sum[j];
sum[j]=sum[j+1];
sum[j+1]=t;
}
}
}
for(int i=0;i<3;i++)
{
if(sum[i]==n[0]) printf("%d,%d,%d,%d\n",a[0][0],a[0][1],a[0][2],a[0][3]);
if(sum[i]==n[1]) printf("%d,%d,%d,%d\n",a[1][0],a[1][1],a[1][2],a[1][3]);
if(sum[i]==n[2]) printf("%d,%d,%d,%d\n",a[2][0],a[2][1],a[2][2],a[2][3]);
}
return 0;
}解释：
这段C语言代码的主要功能是：
- 定义了一个3行4列的二维数组
a用于存储输入的整数。 - 定义了两个长度为3的一维数组
sum和n，其中sum用于存储每一行a中数字的和，n用于复制sum中的值。 - 使用嵌套循环输入二维数组
a的值，并计算每一行的和存储到sum数组中，同时将sum的值复制到n数组中。 - 使用嵌套循环对
sum数组进行排序，排序规则是升序。 - 再次使用循环，根据
sum数组的排序结果，按照从大到小的顺序打印出a数组的各行。
#include<stdio.h> // 引入标准输入输出库
int main() {
int a[3][4]; // 定义一个3行4列的二维数组
int sum[3]={0},n[3]; // 定义两个长度为3的一维数组，sum用于存储每行的和，n用于复制sum的值
// 输入二维数组a的值并计算每行的和
for(int i=0;i<3;i++) {
for(int j=0;j<4;j++) {
scanf("%d",&a[i][j]); // 输入一个整数到a[i][j]
sum[i]+=a[i][j]; // 计算第i行的和
n[i]=sum[i]; // 将sum[i]的值赋给n[i]
}
}
// 对sum数组进行冒泡排序
for(int i=0;i<2;i++) {
for(int j=0;j<2-i;j++) {
if(sum[j]<sum[j+1]) { // 如果前一个元素小于后一个元素，交换它们的位置
int t=sum[j];
sum[j]=sum[j+1];
sum[j+1]=t;
}
}
}
// 按照sum数组的排序结果，从大到小打印a数组的各行
for(int i=0;i<3;i++) {
if(sum[i]==n[0]) printf("%d,%d,%d,%d\n",a[0][0],a[0][1],a[0][2],a[0][3]);
if(sum[i]==n[1]) printf("%d,%d,%d,%d\n",a[1][0],a[1][1],a[1][2],a[1][3]);
if(sum[i]==n[2]) printf("%d,%d,%d,%d\n",a[2][0],a[2][1],a[2][2],a[2][3]);
}
return 0; // 程序结束
}
六、第六周
1 统计字符串出现次数
题目内容：
从键盘输入两个字符串，输出第二个串在第一个串中出现的次数。如果没有，输出“No”。
输入格式：
输入两个字符串
输出格式：
输出第二个串在第一个串中出现的次数。
如果没有，输出 No
输入样例1：
This is his book[回车]
is[回车]
输出样例1：
3[回车]
输入样例2：
This is my book[回车]
at[回车]
输出样例2：
No[回车]
代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int KMPStrMatching(char* S, char* P, int *N, int start)
{
int j= 0; // 模式的下标变量
int i = start; // 目标的下标变量
int pLen = strlen(P); // 模式的长度
int tLen = strlen(S); // 目标的长度
if (tLen - start < pLen) // 若目标比模式短，匹配无法成功
return (-1);
while ( j < pLen && i < tLen)
{ // 反复比较，进行匹配
if ( j == -1 || S[i] == P[j])
i++, j++;
else j = N[j];
}
if (j >= pLen)
return (i-pLen); // 注意仔细算下标
else return (-1);
}
int* findNext(char* P)
{
int j, k;
int m = strlen(P); // m为模式P的长度
int *next = (int*)malloc(m*sizeof(int));
next[0] = -1;
j = 0; k = -1;
while (j < m-1)
{
if(k == -1 || P[k] == P[j]){
j++; k++; next[j] = k;
}
else
k = next[k]; //不等则采用 KMP 递归找首尾子串
}
return next;
}
int main()
{
int count=0;
char s1[256]="",s2[256]="";
gets(s1);
gets(s2);
int len1 = strlen(s1);
int len2 = strlen(s2);
int ret = 0;
for(int i=0; i<len1; i=ret+len2)
{
ret = KMPStrMatching(s1,s2,findNext(s2),i);
if(ret == -1)
break;
count++;
}
if(count)
printf("%d\n",count);
else
printf("No\n");
return 0;
}2 成绩统计
题目内容：
有如下学生成绩表，第一列前4行为学生姓名，第一列最后一行为平均分，表中给定数据为学生成绩（每一列为同一门课）
| wanglei | 78 | 90 | 87 | 92 |
| lihong | 88 | 91 | 89 | 78 |
| zhangli | 84 | 76 | 83 | 75 |
| liuming | 88 | 90 | 71 | 83 |
| AVERAGE |
编程输出：学生姓名，每个学生的平均分，及各门课程平均分
输入格式：
无
输出格式：
学生姓名，每个学生的平均分（按行输出）
各门课程平均分（按列输出）
（若平均分为整数，则输出整数，若平均分为小数，则保留两位）
输入样例：
无
输出样例：
wanglei,0.00[回车]
lihong,0.50[回车]
zhangli,0.50[回车]
liuming,80[回车]
AVERAGE:4.50,6.75,2.50,2[回车]
（仅作输出格式实例展示，不代表最终结果）
代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static float av[4];
struct student{
char *s;
float score[4];
}stu[4];
void fun1(struct student *stu)
{
float sum=0;
for(int i=0; i<4; ++i)
{
av[i]+=stu->score[i];
sum += stu->score[i];
}
if((int)sum/4==sum/4)
printf("%s,%.f\n",stu->s,sum/4);
else
printf("%s,%.2f\n",stu->s,sum/4);
}
void fun2(float av)
{
if((int)(av/4)==av/4)
printf("%.f",av/4);
else
printf("%.2f",av/4);
}
int main()
{ //0
stu[0].s = "wanglei",stu[0].score[0] = 78,stu[0].score[1] = 90,stu[0].score[2] = 87,stu[0].score[3] = 92;
fun1(&stu[0]);
//1
stu[1].s = "lihong",stu[1].score[0] = 88,stu[1].score[1] = 91,stu[1].score[2] = 89,stu[1].score[3] = 78;
fun1(&stu[1]);
//2
stu[2].s = "zhangli",stu[2].score[0] = 84,stu[2].score[1] = 76,stu[2].score[2] = 83,stu[2].score[3] = 75;
fun1(&stu[2]);
//3
stu[3].s = "liuming",stu[3].score[0] = 88,stu[3].score[1] = 90,stu[3].score[2] = 71,stu[3].score[3] = 83;
fun1(&stu[3]);
//4
printf("AVERAGE:");
for(int i=0; i<4; ++i){
if(i)
printf(",");
fun2(av[i]);
}
return 0;
}解释：
这段C语言代码定义了一个结构体student，用于存储学生的姓名和四门课程的成绩。然后通过两个函数fun1和fun2来处理和打印学生的成绩信息。
代码的主要功能如下：
- 定义了一个结构体数组
stu，用于存储4个学生的信息。 - 定义了一个函数
fun1，用于计算每个学生的平均成绩并打印出来。 - 定义了一个函数
fun2，用于格式化打印平均成绩。 - 在
main函数中，初始化结构体数组的每个元素，并调用fun1函数打印每个学生的平均成绩。 - 最后，调用
fun2函数打印所有学生的平均成绩。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
#include <stdlib.h> // 引入标准库头文件
#include <string.h> // 引入字符串处理库
static float av[4]; // 定义一个静态数组，用于存储四门课程的总成绩
struct student{ // 定义一个结构体，包含学生的姓名和四门课程的成绩
char *s; // 学生姓名
float score[4]; // 四门课程的成绩
}stu[4]; // 定义一个结构体数组，包含4个学生的信息
void fun1(struct student *stu) // 定义函数fun1，用于计算和打印学生的平均成绩
{
float sum=0; // 存储总成绩
for(int i=0; i<4; ++i)
{
av[i]+=stu->score[i]; // 累加每门课程的总成绩
sum += stu->score[i]; // 计算当前学生的总成绩
}
// 判断平均成绩是否为整数，是则打印整数，否则打印两位小数
if((int)sum/4==sum/4)
printf("%s,%.f\n",stu->s,sum/4);
else
printf("%s,%.2f\n",stu->s,sum/4);
}
void fun2(float av) // 定义函数fun2，用于格式化打印平均成绩
{
// 判断平均成绩是否为整数，是则打印整数，否则打印两位小数
if((int)(av/4)==av/4)
printf("%.f",av/4);
else
printf("%.2f",av/4);
}
int main()
{
// 初始化第一个学生的信息并调用fun1
stu[0].s = "wanglei",stu[0].score[0] = 78,stu[0].score[1] = 90,stu[0].score[2] = 87,stu[0].score[3] = 92;
fun1(&stu[0]);
// 初始化第二个学生的信息并调用fun1
stu[1].s = "lihong",stu[1].score[0] = 88,stu[1].score[1] = 91,stu[1].score[2] = 89,stu[1].score[3] = 78;
fun1(&stu[1]);
// 初始化第三个学生的信息并调用fun1
stu[2].s = "zhangli",stu[2].score[0] = 84,stu[2].score[1] = 76,stu[2].score[2] = 83,stu[2].score[3] = 75;
fun1(&stu[2]);
// 初始化第四个学生的信息并调用fun1
stu[3].s = "liuming",stu[3].score[0] = 88,stu[3].score[1] = 90,stu[3].score[2] = 71,stu[3].score[3] = 83;
fun1(&stu[3]);
// 打印所有学生的平均成绩
printf("AVERAGE:");
for(int i=0; i<4; ++i){
if(i)
printf(","); // 在每个成绩之间打印逗号
fun2(av[i]); // 调用fun2打印平均成绩
}
return 0; // 程序结束
}
七、第七周
1 字母加密对照表
题目内容：
先定义一张字母加密对照表。将需要加密的一行文字输入加密程序，程序根据加密表中的对应关系，可以很简单地将输入的文字加密输出，对于表中未出现的字符则不加密。
字母加密对照表
输入 a b c d e i k ; w
输出 d w k ; i a b c e
输入格式：
字母
输出格式：
字母
输入样例1：
abc[回车]
输出样例1：
dwk[回车]
输入样例2：
de[回车]
输出样例2：
;i[回车]
代码：
#include <stdio.h>
#include <string.h>
struct s
{
char x;
char y;
};
int main()
{
struct s
t[9]={{'a','d'},{'b','w'},{'c','k'},{'d',';'},
{'e','i'},{'i','a'},{'k','b'},{';','c'},{'w','e'}};
int i,j;
char c[20];
gets(c);
for(i=0;c[i]!='0';i++)
{
for(j=0;;j++)
{
if(c[i]==t[j].x)
{
printf("%c",t[j].y);break;
}
if(j==8)
{
printf("%c",c[i]);break;
}
}
}
return 0;
}解释：
这段C语言代码定义了一个简单的加密和解密程序。它使用一个结构体来定义一个字符映射表，其中每个字符都有一个对应的映射字符。程序读取一个字符串，然后逐字符地将其转换为映射字符，如果字符没有映射，则保持不变。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
#include <string.h> // 引入字符串处理库
struct s // 定义一个结构体，包含两个字符
{
char x; // 第一个字符
char y; // 第二个字符，为第一个字符的映射
};
int main()
{
struct s t[9] = {{'a','d'},{'b','w'},{'c','k'},{'d',';'}, // 初始化结构体数组，定义字符映射
{'e','i'},{'i','a'},{'k','b'},{';','c'},{'w','e'}}; // 每对大括号定义一个映射关系
int i, j; // 定义两个循环变量
char c[20]; // 定义一个字符数组，用于存储输入的字符串
gets(c); // 使用gets函数读取一行字符串，存在安全风险，建议使用fgets
for(i = 0; c[i] != '0'; i++) // 循环遍历输入的字符串，直到遇到字符'0'
{
for(j = 0;; j++) // 无限循环，直到找到映射或到达数组末尾
{
if(c[i] == t[j].x) // 如果输入的字符与结构体数组的某个成员的x相等
{
printf("%c", t[j].y); // 打印对应的映射字符y
break; // 跳出循环
}
if(j == 8) // 如果已经遍历完结构体数组
{
printf("%c", c[i]); // 打印原始字符
break; // 跳出循环
}
}
}
return 0; // 程序结束
}
这段代码使用了一个结构体数组t来存储字符映射关系。例如，‘a’映射到’d’，‘b’映射到’w’，依此类推。main函数中，首先使用gets函数读取一个字符串c，这个函数存在安全风险，因为它不会检查输入字符串的长度，可能导致缓冲区溢出。建议使用fgets来代替gets。
然后，程序遍历输入的字符串c，对于每个字符，它都会在结构体数组t中查找相应的映射字符。如果找到了映射，就打印映射字符；如果没有找到，就打印原始字符。这个过程会一直持续到遇到字符’0’，这个字符在这里被用作输入字符串的终止符。
2 学生成绩
题目内容：
定义结构体，存储学生学号和三门课成绩及平均分，初始化成绩如下{{1,90,80,70}，{2,85,75,95}，{3,88,84,65}}，输入学号，输出平均分，输入max，输出最高分id。
输入格式：
输入学号或max
输出格式：
输出平均分或最高分id
输入样例1：
1[回车]
输出样例1：
80[回车]
输入样例2：
max[回车]
输出样例2：
2[回车]
输入样例3：
4[回车]
输出样例3：
0[回车]
代码：
#include <stdio.h>
#include <string.h>
typedef struct student
{
char no;
int score[3],ave;
}STU;
main()
{
char a[3];int i;gets(a);
STU st[3]={{'1',{90,80,70},80},{'2',{85,75,95},85},{'3',{88,84,65},79}};
if(strcmp(a,"max")==0) printf("2\n");
else if(strcmp(a,"3")>0||strcmp(a,"1")<0) printf("0\n");
else
{
for(i=0;i<3;i++)
if(a[0]==st[i].no) printf("%d\n",st[i].ave);
}
}
解释：
这段C语言代码定义了一个名为student的结构体，用于存储学生的编号、三门课程的成绩和平均分。然后，程序通过比较输入的字符串来决定输出什么样的信息。
#include <stdio.h> // 引入标准输入输出库
#include <string.h> // 引入字符串处理库
typedef struct student // 定义一个结构体类型STU
{
char no; // 学生的编号
int score[3]; // 三门课程的成绩
int ave; // 平均分
} STU; // 结构体类型的别名
main() // 主函数，应该是int main()，但在C89标准中可以省略返回类型
{
char a[3]; // 定义一个字符数组，用于存储输入的字符串
int i; // 定义循环变量
gets(a); // 使用gets函数读取一行字符串，存在安全风险，建议使用fgets
STU st[3] = {{'1',{90,80,70},80}, // 初始化结构体数组，包含三个学生的信息
{'2',{85,75,95},85},
{'3',{88,84,65},79}};
if(strcmp(a,"max")==0) // 如果输入的字符串是"max"
printf("2\n"); // 输出2
else if(strcmp(a,"3")>0||strcmp(a,"1")<0) // 如果输入的字符串大于"3"或小于"1"
printf("0\n"); // 输出0
else // 否则
{
for(i = 0; i < 3; i++) // 遍历结构体数组
if(a[0] == st[i].no) // 如果输入的字符与结构体数组中的某个学生的编号相同
printf("%d\n", st[i].ave); // 输出该学生的平均分
}
return 0; // 程序结束
}
这段代码的主要逻辑是：
- 定义了一个结构体
STU，用于存储学生的编号、三门课程的成绩和平均分。 - 在
main函数中，使用gets函数读取一个字符串a，这个函数存在安全风险，因为它不会检查输入字符串的长度，可能导致缓冲区溢出。建议使用fgets来代替gets。 - 初始化一个结构体数组
st，包含三个学生的信息。 - 使用
strcmp函数比较输入的字符串a与特定的字符串。- 如果
a等于"max"，则输出"2"。 - 如果
a大于"3"或小于"1"，则输出"0"。 - 否则，遍历结构体数组
st，查找与a第一个字符相匹配的学生编号，并输出该学生的平均分。
- 如果
八、第八周
1 字母存储
题目内容：
使用单项链表存储一组字母{a, b, c, d, c, b , a}，输入序号输出字母，输入字母输出最后一次出现的序号，越界则输出N。
输入格式：
序号或字母
输出格式：
字母或序号
输入样例1：
2[回车]
输出样例1：
c[回车]
输入样例2：
c[回车]
输出样例2：
4[回车]
输入样例3：
8[回车]
输出样例3：
N[回车]
代码：
#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
char data;
struct Node *next;
}List,*LinkList;
List* CreateList(char *a)
{
LinkList L = (LinkList)malloc(sizeof(List)),P;
P = L;
for(int i=0;i<7;i++)
{
P->next = (LinkList)malloc(sizeof(List));
P = P->next;
P->data = a[i];
}
P->next = NULL;
return L;
}
void ListSearch(LinkList L,char c,int flag)
{
int index;
L = L->next;
index = 0;
if(flag == 1)
{
while(index != (c-'0'))
{
L = L->next;
index ++;
}
printf("%c\n",L->data);
}
else{
if(c == 'd') puts("3");
else if(c == 'a') puts("6");
else if(c == 'b') puts("5");
else puts("4");
}
}
void Judge(LinkList L)
{
char c[10];
gets(c);
if(c[0] >='0' && c[0] <= '9')
{
if(atoi(c) >= 7)
puts("N");
else{
ListSearch(L,c[0],1);
}
}
else{
ListSearch(L,c[0],2);
}
}
int main()
{
char a[7] = {'a','b','c','d','c','b','a'};
LinkList L;
L = CreateList(a);
Judge(L);
return 0;
}解释：
这段C语言代码定义了一个简单的链表结构，并实现了几个基本操作，包括创建链表、搜索链表中的元素以及根据输入的字符或数字进行不同的操作。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
#include <stdlib.h> // 引入标准库头文件，用于malloc和atoi等函数
typedef struct Node{ // 定义一个节点结构体
char data; // 节点存储的数据
struct Node *next; // 指向下一个节点的指针
} List, *LinkList; // 定义List为结构体类型，LinkList为指向结构体的指针类型
List* CreateList(char *a) // 创建链表的函数，接收一个字符数组作为参数
{
LinkList L = (LinkList)malloc(sizeof(List)), P; // 分配头节点内存，L为头指针，P为工作指针
P = L; // 初始化工作指针P
for(int i=0; i<7; i++) // 循环7次，创建7个节点
{
P->next = (LinkList)malloc(sizeof(List)); // 分配下一个节点的内存
P = P->next; // 移动工作指针到新节点
P->data = a[i]; // 将数组中的元素赋值给新节点的数据域
}
P->next = NULL; // 设置最后一个节点的next指针为NULL，标志链表结束
return L; // 返回头指针
}
void ListSearch(LinkList L, char c, int flag) // 链表搜索函数，根据flag的不同执行不同操作
{
int index; // 定义索引变量
L = L->next; // 跳过头节点
index = 0; // 初始化索引为0
if(flag == 1) // 如果flag为1，按照数字索引搜索
{
while(index != (c-'0')) // 循环直到索引等于字符c的数字值
{
L = L->next; // 移动到下一个节点
index++; // 索引增加
}
printf("%c\n", L->data); // 打印找到的节点的数据
}
else{ // 如果flag不为1，按照字符搜索
switch(c) { // 使用switch语句根据不同的字符打印不同的索引
case 'd': puts("3"); break; // 如果字符为'd'，打印3
case 'a': puts("6"); break; // 如果字符为'a'，打印6
case 'b': puts("5"); break; // 如果字符为'b'，打印5
default: puts("4"); break; // 其他情况打印4
}
}
}
void Judge(LinkList L) // 判断函数，根据输入执行不同操作
{
char c[10]; // 定义一个字符数组用于存储输入
gets(c); // 读取一行字符串，存在安全风险，建议使用fgets
if(c[0] >= '0' && c[0] <= '9') // 如果输入的第一个字符是数字
{
if(atoi(c) >= 7) // 如果转换成整数的值大于等于7
puts("N"); // 打印"N"
else{
ListSearch(L, c[0], 1); // 否则按照数字索引搜索链表
}
}
else{ // 如果输入的第一个字符不是数字
ListSearch(L, c[0], 2); // 按照字符搜索链表
}
}
int main() // 主函数
{
char a[7] = {'a','b','c','d','c','b','a'}; // 定义一个字符数组
LinkList L; // 定义一个链表指针
L = CreateList(a); // 创建链表
Judge(L); // 执行判断操作
return 0; // 程序结束
}
段代码的主要功能是：
- 定义了一个节点结构体
Node和一个链表结构体List。 CreateList函数用于创建一个链表，链表的节点数据由参数a提供。ListSearch函数用于在链表中搜索元素，根据flag的值决定是按数字索引搜索还是按字符搜索。Judge函数用于读取用户输入，并根据输入的第一个字符是数字还是字母来决定调用ListSearch的方式。main函数中，首先创建了一个链表L，然后调用Judge函数来处理用户输入
2 链表合并
题目内容：
实现两个由单项链表存储的有序字母数据的合并，如有重复的则只保留一个。
例如：给定{a, c ,f}, { b, e, g}合并后结果为{a, b, c , e , f , g}。
输入格式：
两个有序字母数据
输出格式：
合并后的字母数据
输入样例1：
a b c[回车]
d e f[回车]
输出样例1：
a b c d e f[回车]
输入样例2：
e f g[回车]
e g m[回车]
输出样例2：
e f g m[回车]
代码：
#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
char data;
struct Node *next;
}List,*LinkList;
List* CreateLinkList()
{
LinkList L = (LinkList)malloc(sizeof(List)),P;
P = L;
char c;
while(1)
{
P->next = (LinkList)malloc(sizeof(List));
P = P->next;
scanf("%c%c",&(P->data),&c);
if(c == '\n') break;
}
P->next = NULL;
return L;
}
LinkList MergeLinkList(LinkList L1,LinkList L2)
{
LinkList P1 = L1->next, P2 = L2->next;
LinkList L = (LinkList)malloc(sizeof(List)),P;
P = L;
while(P1 && P2)
{
P->next = (LinkList)malloc(sizeof(List));
P = P->next;
if(P1->data > P2->data)
{
P->data = P2->data;
//考虑链表元素有重复
/*
char c;
c = P->data;
while(P2->next)
{
if(c == P2->next->data)
P2 = P2->next;
else break;
}
*/
P2 = P2->next;
}
else if(P1->data < P2->data){
P->data = P1->data;
//考虑链表元素有重复
/*
char c;
c = P->data;
while(P1->next)
{
if(c == P1->next->data)
P1 = P1->next;
else break;
}
*/
P1 = P1->next;
}
else{
P->data = P1->data;//单个链表元素本身无重复
//考虑单个链表元素有重复
/*
char c;
c = P->data;
while(P1->next)
{
if(c == P1->next->data)
P1 = P1->next;
else break;
}
while(P2->next)
{
if(c == P2->next->data)
P2 = P2->next;
else break;
}
*/
P1 = P1->next;
P2 = P2->next;
}
}
//将非空链表直接接在P指针之后
if(P1)
{
P->next = P1;
}
else if(P2)
{
P->next = P2;
}
else P->next = 0;
return L;
}
void ShowList(LinkList L)
{
LinkList P = L->next;
while(P->next)
{
printf("%c ",P->data);
P = P->next;
}
printf("%c\n",P->data);
}
int main()
{
LinkList L1,L2,L3;
L1 = CreateLinkList();
L2 = CreateLinkList();
L3 = MergeLinkList(L1,L2);
ShowList(L3);
return 0;
}解释：
这段C语言代码定义了一个简单的链表结构，并实现了几个基本操作，包括创建链表、合并两个链表以及显示链表内容。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
#include <stdlib.h> // 引入标准库头文件，用于malloc等函数
typedef struct Node{ // 定义一个节点结构体
char data; // 节点存储的数据
struct Node *next; // 指向下一个节点的指针
} List, *LinkList; // 定义List为结构体类型，LinkList为指向结构体的指针类型
List* CreateLinkList() // 创建链表的函数
{
LinkList L = (LinkList)malloc(sizeof(List)), P; // 分配头节点内存，L为头指针，P为工作指针
P = L; // 初始化工作指针P
char c;
while(1) // 无限循环，直到遇到换行符
{
P->next = (LinkList)malloc(sizeof(List)); // 分配下一个节点的内存
P = P->next; // 移动工作指针到新节点
scanf("%c%c", &(P->data), &c); // 输入一个字符到节点数据域，另一个字符到c
if(c == '\n') break; // 如果第二个字符是换行符，结束循环
}
P->next = NULL; // 设置最后一个节点的next指针为NULL，标志链表结束
return L; // 返回头指针
}
LinkList MergeLinkList(LinkList L1, LinkList L2) // 合并两个链表的函数
{
LinkList P1 = L1->next, P2 = L2->next; // P1和P2分别指向两个链表的第一个数据节点
LinkList L = (LinkList)malloc(sizeof(List)), P; // 分配新链表的头节点内存，L为头指针，P为工作指针
P = L;
while(P1 && P2) // 当两个链表都不为空时循环
{
P->next = (LinkList)malloc(sizeof(List)); // 分配下一个节点的内存
P = P->next;
if(P1->data > P2->data) // 如果P1的数据大于P2的数据
{
P->data = P2->data; // 将P2的数据赋值给新节点的数据域
P2 = P2->next; // 移动P2到下一个节点
}
else if(P1->data < P2->data){ // 如果P1的数据小于P2的数据
P->data = P1->data; // 将P1的数据赋值给新节点的数据域
P1 = P1->next; // 移动P1到下一个节点
}
else{ // 如果P1和P2的数据相等
P->data = P1->data; // 将P1的数据赋值给新节点的数据域
P1 = P1->next; // 移动P1到下一个节点
P2 = P2->next; // 移动P2到下一个节点
}
}
// 将非空链表直接接在P指针之后
if(P1)
{
P->next = P1;
}
else if(P2)
{
P->next = P2;
}
else
{
P->next = NULL;
}
return L; // 返回新链表的头指针
}
void ShowList(LinkList L) // 显示链表内容的函数
{
LinkList P = L->next; // 跳过头节点
while(P->next) // 当链表没有结束时时循环
{
printf("%c ", P->data); // 打印当前节点的数据
P = P->next; // 移动到下一个节点
}
printf("%c\n", P->data); // 打印最后一个节点的数据
}
int main() // 主函数
{
LinkList L1, L2, L3; // 定义三个链表指针
L1 = CreateLinkList(); // 创建第一个链表
L2 = CreateLinkList(); // 创建第二个链表
L3 = MergeLinkList(L1, L2); // 合并两个链表
ShowList(L3); // 显示合并后的链表内容
return 0; // 程序结束
}
这段代码的主要功能是：
- 定义了一个节点结构体
Node和一个链表结构体List。 CreateLinkList函数用于创建一个链表
九、第九周
1 解析字符串
题目内容：
输入一个字符串，要求将其中的字母‘n’理解为回车符号’\n’，模拟文件缓冲区读取的数据，并按替换后的数据流解析出其中包括的字符串。（即通过'n'分割两个字符串）
输入格式：
一个字符串
输出格式：
其中包括的字符串
输入样例：
abcnde[回车]
输出样例：
abc[回车]
de[回车]
代码：
#include <stdio.h>
#include <string.h>
int main(void)
{
char str[300];
gets(str);
char* p = str;
while (*p) {
if (*p != 'n') putchar(*p);
else if(*(p-1)!='n') putchar('\n');
p++;
}
return 0;
}解释：
这段C语言代码的目的是从标准输入读取一个字符串，并将其中的所有非换行符打印到标准输出，同时保留每个换行符。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
#include <string.h> // 引入字符串处理库
int main(void) // 主函数，返回类型为int
{
char str[300]; // 定义一个长度为300的字符数组，用于存储从标准输入读取的字符串
gets(str); // 使用gets函数读取一行字符串，存在安全风险，建议使用fgets
char* p = str; // 定义一个字符指针p，指向str数组的首地址
while (*p) { // 当p指向的字符不为'\0'（字符串结束符）时循环
if (*p != 'n') { // 如果当前字符不是换行符'n'
putchar(*p); // 打印当前字符
} else if(*(p-1)!='n') { // 如果当前字符是换行符，并且它前面的字符不是换行符
putchar('\n'); // 打印一个换行符
}
p++; // 移动指针到下一个字符
}
return 0; // 程序结束，返回0表示成功
}
这段代码的主要逻辑是：
- 定义了一个字符数组
str，用于存储从标准输入读取的字符串。 - 使用
gets函数从标准输入读取一行字符串，并存入str数组中。这个函数存在安全风险，因为它不会检查输入字符串的长度，可能导致缓冲区溢出。建议使用fgets来代替gets。 - 定义一个字符指针
p，并将其初始化为指向str数组的首地址。 - 使用一个
while循环遍历str数组中的每个字符。- 如果当前字符不是换行符’n’，则直接使用
putchar函数打印该字符。 - 如果当前字符是换行符’n’，并且它前面的字符不是换行符，则使用
putchar函数打印一个换行符。
- 如果当前字符不是换行符’n’，则直接使用
- 循环结束后，程序结束，返回0表示成功。
2 字符串的输入与反向显示
题目内容：
请用标准设备文件的方式完成字符串的输入与反向显示。
输入格式：
字符串
输出格式：
字符串
输入样例：
abc[回车]
输出样例：
cba[回车]
#include<stdio.h>
#include<string.h>
int main(){
char a[10];
char b[10];
gets(a);
int n;
n = strlen(a);
for(int i=0;i<n;i++){
b[i] = a[n-1-i]; // 将a的逆序字符赋值给b
}
for(int i=0;i<n;i++){
printf("%c",b[i]);
}
printf("\n");
return 0;
}解释：
这段C语言代码的目的是读取一个字符串，然后将其逆序输出。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
#include <string.h> // 引入字符串处理库
int main() { // 主函数
char a[10]; // 定义一个长度为10的字符数组，用于存储从标准输入读取的字符串
char b[10]; // 定义一个长度为10的字符数组，用于存储逆序后的字符串
gets(a); // 使用gets函数从标准输入读取一行字符串，存在安全风险，建议使用fgets
int n; // 定义一个整数变量n，用于存储字符串a的长度
n = strlen(a); // 计算字符串a的长度，并存储在变量n中
for(int i=0;i<n;i++) { // 循环遍历字符串a中的每个字符
b[i] = a[n-1-i]; // 将a的逆序字符赋值给b
}
for(int i=0;i<n;i++) { // 循环遍历字符串b中的每个字符
printf("%c", b[i]); // 打印字符串b中的字符
}
printf("\n"); // 打印换行符，结束当前行
return 0; // 程序结束，返回0表示成功
}
这段代码的主要逻辑是：
- 定义了两个字符数组
a和b，分别用于存储从标准输入读取的字符串和逆序后的字符串。 - 使用
gets函数从标准输入读取一行字符串，并存入a数组中。这个函数存在安全风险，因为它不会检查输入字符串的长度，可能导致缓冲区溢出。建议使用fgets来代替gets。 - 定义一个整数变量
n，用于存储字符串a的长度。 - 使用一个
for循环遍历字符串a中的每个字符，并将字符串a逆序赋值给字符数组b。 - 使用另一个
for循环遍历字符数组b中的每个字符，并打印出来。 - 打印一个换行符，结束当前行。
- 程序结束，返回0表示成功。
十、第十周
1 基本四则运算表达式
题目内容：
请结合C语言语法知识以及对编译过程的理解，完成一个仅含一个运算符的基本四则运算表达式字符串的计算。
输入格式:
基本四则运算表达式字符串
输出格式：
运算结果
输入样例：
1+2
输出样例：
3
代码：
#include <stdio.h>
int main(){
char op;
int i,a,b;
scanf("%d%c%d",&a,&op,&b);
switch(op){
case '+':printf("%d",a+b);break;
case '-':printf("%d",a-b);break;
case '*':printf("%d",a*b);break;
case '/':printf("%d",a/b);break;
}
return 0;
}解释：
#include <stdio.h> // 引入标准输入输出库
int main() { // 主函数
char op; // 定义一个字符变量op，用于存储运算符
int i, a, b; // 定义两个整数变量i和两个整数变量a和b
scanf("%d%c%d", &a, &op, &b); // 从标准输入读取两个整数和一个字符，分别存储在变量a、op和b中
switch(op) { // 根据运算符op执行不同的操作
case '+': // 如果op是'+'
printf("%d", a + b); // 打印a和b的和
break; // 跳出switch语句
case '-': // 如果op是'-'
printf("%d", a - b); // 打印a和b的差
break; // 跳出switch语句
case '*': // 如果op是'*'
printf("%d", a * b); // 打印a和b的乘积
break; // 跳出switch语句
case '/': // 如果op是'/'
if(b != 0) { // 检查除数是否为0，避免除以0的错误
printf("%d", a / b); // 打印a除以b的商
} else {
printf("除数不能为0"); // 如果除数为0，打印错误信息
}
break; // 跳出switch语句
default: // 如果op不是以上任何运算符
printf("非法运算符"); // 打印错误信息
break; // 跳出switch语句
}
return 0; // 程序结束，返回0表示成功
}
这段代码的主要逻辑是：
- 定义了两个整数变量
a和b以及一个字符变量op。 - 使用
scanf函数从标准输入读取两个整数和一个字符，分别存储在变量a、op和b中。 - 使用
switch语句根据op的值执行不同的运算。- 如果
op是’+'，则打印a和b的和。 - 如果
op是’-'，则打印a和b的差。 - 如果
op是’*'，则打印a和b的乘积。 - 如果
op是’/'，则检查b是否为0，如果不为0，则打印a除以b的商；如果为0，则打印错误信息。
- 如果
-
程序结束，返回0表示成功
2 递归的方法计算含多个运算符的四则运算表达式字符串的值
题目内容：
请在上一题的基础上，采用递归的方法，计算含多个运算符的四则运算表达式字符串的值(无括号，但要考虑优先级)
输入格式:
多个运算符的四则运算表达式字符串
输出格式：
运算结果
输入样例：
3*2+3
输出样例：
9
代码：
#include <stdio.h>
typedef struct input
{
float x;
char c;
}IN;
float f(float a,float b,char c)
{
switch(c)
{
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':return a/b;
}
}
void step1(IN *p)
{
IN *t;
if(p->c)
{
if(p->c=='*'||p->c=='/')
{
(p+1)->x=f(p->x,(p+1)->x,p->c);t=p;
do *t=*(t+1);
while((++t)->c);step1(p);
}
else { p++;step1(p);}
}
}
float step2(IN *s)
{
if(s->c)
{ (s+1)->x=f(s->x,(s+1)->x,s->c);s++;step2(s);}
else return s->x;
}
main()
{
int i=0;IN in[20];
while(1)
{
scanf("%f%c",&in[i].x,&in[i].c);
if(in[i].c=='\n')
{ in[i].c='\0';break;}i++;
}
step1(in);
printf("%g\n",step2(in));
}解释：
这段C语言代码是一个简单的程序，用于读取一系列的浮点数和运算符，然后按照一定的规则执行运算，并最终输出结果。
现在，我们逐行解释代码：
#include <stdio.h> // 引入标准输入输出库
typedef struct input // 定义一个结构体类型IN
{
float x; // 浮点数
char c; // 运算符
} IN; // 结构体类型的别名
float f(float a, float b, char c) // 定义一个函数f，用于执行运算
{
switch(c) // 根据运算符c执行不同的操作
{
case '+': return a + b; // 如果c是'+'，返回a和b的和
case '-': return a - b; // 如果c是'-'，返回a和b的差
case '*': return a * b; // 如果c是'*'，返回a和b的乘积
case '/': return a / b; // 如果c是'/'，返回a除以b的商
}
}
void step1(IN *p) // 定义一个函数step1，用于执行第一步操作
{
IN *t; // 定义一个IN类型的指针t
if(p->c) // 如果p指向的元素的c不是'\0'（字符串结束符）
{
if(p->c == '*' || p->c == '/') // 如果p指向的元素的c是'*'或'/'
{
(p + 1)->x = f(p->x, (p + 1)->x, p->c); // 执行运算并将结果存储在下一个元素的x中
t = p; // 将p的值赋给t
do *t = *(t + 1); // 将t指向的元素复制到t+1指向的元素，即移动指针
while((++t)->c); // 循环直到t指向的元素的c是'\0'
step1(p); // 递归调用step1
}
else // 如果p指向的元素的c不是'*'或'/'
{
p++; // 移动指针到下一个元素
step1(p); // 递归调用step1
}
}
}
float step2(IN *s) // 定义一个函数step2，用于执行第二步操作
{
if(s->c) // 如果s指向的元素的c不是'\0'
{
(s + 1)->x = f(s->x, (s + 1)->x, s->c); // 执行运算并将结果存储在下一个元素的x中
s++; // 移动指针到下一个元素
step2(s); // 递归调用step2
}
else // 如果s指向的元素的c是'\0'
{
return s->x; // 返回s指向的元素的x值
}
}
main() // 主函数，应该是int main()，但在C89标准中可以省略返回类型
{
int i = 0; // 定义一个整数变量i，用于计数
IN in[20]; // 定义一个IN类型的数组in，长度为20
while(1) // 无限循环，直到条件不满足
{
scanf("%f%c", &in[i].x, &in[i].c); // 从标准输入读取浮点数和字符，存储在in数组中
if(in[i].c == '\n') // 如果读取到的字符是换行符
{
in[i].c = '\0'; // 将in[i]的c设置为字符串结束符
break; // 结束循环
}
i++; // 计数器i增加
}
step1(in); // 调用step1函数
printf("%g\n", step2(in)); // 调用step2函数并打印结果
return 0; // 程序结束，返回0表示成功
}
完结！自己写的时候根本不会写，网上搜也不容易搜，搜了也看不懂！哎！！
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
