共计 11777 个字符，预计需要花费 30 分钟才能阅读完成。
你也能够上程序咖(https://meta.chengxuka.com)，关上大学幕题板块，岂但有答案，解说，还能够在线答题。
题目 1：用筛选法求 100 之内的素数。
解：
所谓 ” 筛选法 ” 指的是 ” 埃拉托色尼（Eratosthenes）筛法 ”。埃拉托色尼是古希腊的驰名数学家。他采取的办法是，在一张纸上写上 1～1000 的全副整数，而后一一判断它们是否是素数，找出一个非素数，就把它挖掉，最初剩下的就是素数，见图 6.1。
具体做法如下∶
（1）先将 1 挖掉（因为 1 不是素数）。
（2）用 2 除它前面的各个数，把能被 2 整除的数挖掉，即把 2 的倍数挖掉。
（3）用 3 除它前面各数，把 3 的倍数挖掉。
（4）别离用 4，5…各数作为除数除这些数当前的各数。这个过程始终进行到在除数前面的数已全被挖掉为止。例如在图 6.1 中找 1～50 的素数，要始终进行到除数为 47 为止。事实上，能够简化，如果须要找 1～n 的素数，只须进行到除数为 $ \sqrt{n} $（取其整数）即可，例如对 1～50，只须进行到将 $ \sqrt{7} $ 作为除数即可。请读者思考为什么。
下面的算法可示意为∶
（1）挖去 1;
（2）用下一个未被挖去的数 p 除 p 前面个数，把 p 的倍数挖掉;
（3）查看 p 是否小于 $ \sqrt{n} $ 的整数局部（如果 n=1000，则查看 p<31 是否成立），如果是，则返回（2）继续执行，否则就完结;
（4）剩下的数就是素数。
用计算机解此题，能够定义一个数组 a。a[1]～a[n] 别离代表 1～n 这 n 个数。如果查看出数组 a 的某一元素的值是非素数，就使它变为 0，最初剩下不为 0 的就是素数。
程序如下：
#include <stdio.h>
#include <math.h> // 程序中用到求平方根函数 sqrt
int main()
{int i, j, n, a[101]; // 定义 a 数组蕴含 101 个元素
for (i = 1; i <= 100; i++) // a[0]不必，只用 a[1]～a[100]
a[i] = i; // 使 a[1]~a[100]的值为 1～100
a[1] = 0; // 先 "挖掉"a[1]
for (i = 2; i < sqrt(100); i++)
for (j = i + 1; j <= 100; j++)
{if (a[i] != 0 && a[j] != 0)
if (a[j] % a[i] == 0)
a[j] = 0; // 把非素数“挖掉 "
}
printf("\n");
for (i = 2, n = 0; i <= 100; i++)
{if (a[i] != 0) // 选出值不为 0 的数组元素, 即素数
{printf("%5d", a[i]); // 输入素数, 宽度为 5 列
n++; // 累积本行已输入的数据个数
}
if (n == 10)
{printf("\n");
n = 0;
}
}
printf("\n");
return 0;
}
运行后果：
题目 2：用抉择法对 10 个整数排序。
解：
抉择排序的思路为：设有 10 个元素 a[1]~a[10]，将 a[1] 与 a[2]~a[10] 比拟，若 a[1] 比 a[2]～a[10] 都小，则不进行替换，即无任何操作。若 a[2]～a[10] 中有一个以上比 a[1] 小，则将其中最大的一个（假如为 a[i]）与 a[1] 替换，此时 a[1] 中寄存了 10 个中最小的数。第 2 轮将 a[2] 与 a[3]～a[10] 比拟，将剩下 9 个数中的最小者 a[i] 与 a[2] 对换，此时 a[2] 中寄存的是 10 个中第二小的数。依此类推，共进行 9 轮比拟，a[1]~a[10] 就已按由小到大的程序寄存了。N- S 图如图 6.2 所示。
程序如下∶
#include <stdio.h>
int main()
{int i, j, min, temp, a[11];
printf("enter data:\n");
for (i = 1; i <= 10; i++)
{printf("a[%d]=", i);
scanf("%d", &a[i]); // 输人 10 个数
}
printf("\n");
printf("The orginal numbers:\n");
for (i = 1; i <= 10; i++)
printf("%5d", a[i]); // 输入这 10 个数
printf("\n");
for (i = 1; i <= 9; i++) // 以下 8 行是对 10 个数排序
{
min = i;
for (j = i + 1; j <= 10; j++)
if (a[min] > a[j])
min = j;
temp = a[i]; // 以下 3 即将 a[i+ 1]~a[10]中的最小值与 a[i]对换
a[i] = a[min];
a[min] = temp;
}
printf("\nThe sorted numbers:\n"); // 输入已排好序的 10 个数!
for (i = 1; i <= 10; i++)
printf("%5d", a[i]);
printf("\n");
return 0;
}
运行后果：
输出 10 个数后，程序输入后果。
题目 3：求一个 3×3 的整型矩阵对角线元素之和。
解：
答案代码：
#include <stdio.h>
int main()
{int a[3][3], sum = 0;
int i, j;
printf("enter data:\n");
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
scanf("%3d", &a[i][j]);
for (i = 0; i < 3; i++)
sum = sum + a[i][i];
printf("sum=%6d\n", sum);
return 0;
}
运行后果：
对于输出数据形式的探讨：
在程序的 scanf 语句中用 ”%d” 作为输出格局管制，下面输出数据的形式显然是可行的。其实也能够在一行中间断输出 9 个数据，如：
后果也一样。在输出完 9 个数据并按回车键后，这 9 个数据被送到内存中的输出缓冲区中，而后一一送到各个数组元素中。上面的输出形式也是正确的：
或者
都是能够的。
请思考，如果将程序第 7～9 行改为
for (j=0;j<3;j++)
scanf("%d %d %d" , &a[0][j], &a[1][j],&a[2][j]);应如何输出，是否必须一行输出 3 个数据，如：
答案是能够按此形式输出，也能够不按此形式输出，而采纳后面介绍的形式输出，不管分多少行、每行包含几个数据，只要求最初输出完 9 个数据即可。
程序中用的是整型数组，运行后果是正确的。如果用的是实型数组，只须将程序第 4 行的 int 改为 float 或 double 即可，在输出数据时可输出单精度或双精度的数。
题目 4：有一个已排好序的数组，要求输出一个数后，按原来排序的法则将它插入数组中。
解：
假如数组 a 有 n 个元素，而且已按升序排列，在插入一个数时按上面的办法解决：
（1）如果插入的数 num 比 a 数组最初一个数大，则将插入的数放在 a 数组开端。
（2）如果插入的数 num 不比 a 数组最初一个数大，则将它顺次和 a[0]～a[n-1] 比拟，直到呈现 a[i] > num 为止，这时示意 a[0]~a[i-1] 各元素的值比 num 小，a[i] ～a[n-1] 各元素的值比 num 大。num 理当插到 a[i-1] 之后、a[i] 之前。怎样才能实现此目标呢? 将 a[i]～a[n-1] 各元素向后移一个地位（即 a[i] 变成 a[i+1]，…，a[n-1]变成 a[n]。而后将 num 放在 a[i] 中。N- S 图如图 6.3 所示。
答案代码：
#include <stdio.h>
int main()
{int a[11] = {1, 4, 6, 9, 13, 16, 19, 28, 40, 100};
int temp1, temp2, number, end, i, j;
printf("array a:\n");
for (i = 0; i < 10; i++)
printf("%5d", a[i]);
printf("\n");
printf("insert data:");
scanf("%d", &number);
end = a[9];
if (number > end)
a[10] = number;
else
{for (i = 0; i < 10; i++)
{if (a[i] > number)
{temp1 = a[i];
a[i] = number;
for (j = i + 1; j < 11; j++)
{temp2 = a[j];
a[j] = temp1;
temp1 = temp2;
}
break;
}
}
}
printf("Now aray a:\n");
for (i = 0; i < 11; i++)
printf("%5d", a[i]);
printf("\n");
return 0;
}
运行后果：
题目 5：将一个数组中的值按逆序从新寄存。例如，原来程序为 8，6，5，4，1。要求改为 1，4，5，6，8。
解：
此题的思路是以两头的元素为核心，将其两侧对称的元素的值调换即可。例如，将 5 和 9 调换，将 8 和 6 调换。N- S 图见图 6.4。
答案代码：
#include <stdio.h>
#define N 5
int main()
{int a[N], i, temp;
printf("enter array a:\n");
for (i = 0; i < N; i++)
scanf("%d", &a[i]);
printf("array a:\n");
for (i = 0; i < N; i++)
printf("%4d", a[i]);
for (i = 0; i < N / 2; i++) // 循环的作用是将对称的元素的值调换
{temp = a[i];
a[i] = a[N - i - 1];
a[N - i - 1] = temp;
}
printf("\nNow,array a:\n");
for (i = 0; i < N; i++)
printf("%4d", a[i]);
printf("\n");
return 0;
}
运行后果：
题目 6：输入以下的杨辉三角形（要求输入 10 行）
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
...解：
杨辉三角形是 $ (a+b)^n $ 开展后各项的系数。例如:
$ (a+b)^0 $ 开展后为 1，系数为 1
$ (a+b)^1 $ 开展后为 $ a+b $，系数为 1，1
$ (a+b)^2 $ 开展后为 $（a^2+2ab+b^2) $，系数为 1，2，1
$ (a+b)^3 $ 开展后为 $（a^3+3a^2b+3ab^2+b^3) $，系数为 1，3，3，1
$ (a+b)^4 $ 开展后为 $（a^4+4a^3b+6a^2b^2+4ab^3+b^4) $，系数为 1，4，6，4，1
以上就是杨辉三角形的前 5 行。杨辉三角形各行的系数有以下的法则∶
（1）各行第 1 个数都是 1。
（2）各行最初一个数都是 1。
（3）从第 3 行起，除下面指出的第 1 个数和最初一个数外，其余各数是上一行同列和前一列两个数之和。例如，第 4 行第 2 个数（3）是第 3 行第 2 个数（2）和第 3 行第 1 个数（1）之和。能够这样示意∶
a[i][j]=a[i-1][j]+a[i-1]ij-1]其中，i 为行数，，为列数。
答案代码如下∶
#include <stdio.h>
#define N 10
int main()
{int i, j, a[N][N]; // 数组为 10 行 10 列
for (i = 0; i < N; i++)
{a[i][i] = 1; // 使对角线元素的值为 1
a[i][0] = 1; // 使第 1 列元素的值为 1
}
for (i = 2; i < N; i++) // 从第 3 行开始解决
for (j = 1; j <= i - 1; j++)
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
for (i = 0; i < N; i++)
{for (j = 0; j <= i; j++)
printf("%6d", a[i][j]); // 输入数组各元素的值
printf("\n");
}
printf("\n");
return 0;
}
阐明：数组元素的序号是从 0 开始算的，因而数组中 0 行 0 列的元素实际上就是杨辉三角形中第 1 行第 1 列的数据，余类推。
运行后果：
题目 7：输入 ” 魔方阵 ”。所谓魔方阵是指这样的方阵，它的每一行、每一列和对角线之和均相等。例如，三阶魔方阵为
8 1 6
3 5 7
4 9 2要求输入 1～n2 的自然数形成的魔方阵。
解：魔方阵中各数的排列法则如下∶
（1）将 1 放在第 1 行两头一列。
（2）从 2 开始直到 n×n 止，各数顺次按此规定寄存：每一个数寄存的行比前一个数的行数减 1，列数加 1（例如下面的三阶魔方阵，5 在 4 的上一行后一列）。
（3）如果上一数的行数为 1，则下一个数的行数为 n（指最下一行）。例如，1 在第 1 行，则 2 应放在最下一行，列数同样加 1。
（4）当上一个数的列数为 n 时，下一个数的列数应为 1，行数减 1。例如，2 在第 3 行最初一列，则 3 应放在第 2 行第 1 列。
（5）如果按下面规定确定的地位上已有数，或上一个数是第 1 行第 n 列时，则把下一个数放在上一个数的上面。例如，按下面的规定，4 应该放在第 1 行第 2 列，但该地位已被 1 占据，所以 4 就放在 3 的上面。因为 6 是第 1 行第 3 列（即最初一列），故 7 放在 6 上面。
按此办法能够失去任何阶的魔方阵。
N- S 图如图 6.5 所示。
答案代码：
#include <stdio.h>
int main()
{int a[15][15], i, j, k, p, n;
p = 1;
while (p == 1)
{printf("enter n(n= 1--15) :"); // 要求阶数为 1～15 的奇数
scanf("%d", &n);
if ((n != 0) && (n <= 15) && (n % 2 != 0))
p = 0;
}
// 初始化
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
a[i][j] = 0;
// 建设魔方阵
j = n / 2 + 1;
a[1][j] = 1;
for (k = 2; k <= n * n; k++)
{
i = i - 1;
j = j + 1;
if ((i < 1) && (j > n))
{
i = i + 2;
j = j - 1;
}
else
{if (i < 1)
i = n;
if (j > n)
j = 1;
}
if (a[i][j] == 0)
a[i][j] = k;
else
{
i = i + 2;
j = j - 1;
a[i][j] = k;
}
}
// 输入魔方阵
for (i = 1; i <= n; i++)
{for (j = 1; j <= n; j++)
printf("%5d", a[i][j]);
printf("\n");
}
return 0;
}
阐明：魔方阵的阶数应为奇数。
运行后果：
题目 8：找出一个二维数组中的鞍点，即该地位上的元素在该行上最大、在该列上最小。也可能没有鞍点。
解：一个二维数组最多有一个鞍点，也可能没有。解题思路是∶先找出一行中值最大的元素，而后查看它是否为该列中的最小值，如果是，则是鞍点（不须要再找别的鞍点了），输入该鞍点; 如果不是，再找下一行的最大数……如果每一行的最大数都不是鞍点，则此数组无鞍点。
答案代码：
#include <stdio.h>
#define N 4
#define M 5 // 数组为 4 行 5 列
int main()
{int i, j, k, a[N][M], max, maxj, flag;
printf("please input matrix: \n");
for (i = 0; i < N; i++) // 输人数组
for (j = 0; j < M; j++)
scanf("%d", &a[i][j]);
for (i = 0; i < N; i++)
{max = a[i][0]; // 开始时假如 a[i][0]最大
maxj = 0; // 将列号 0 赋给 maxj 保留
for (j = 0; j < M; j++) // 找出第 i 行中的最大数
if (a[i][j] > max)
{max = a[i][j]; // 将本行的最大数寄存在 max 中
maxj = j; // 将最大数所在的列号寄存在 maxj 中
}
flag = 1; // 先假如是鞍点，以 flag 为 1 代表
for (k = 0; k < N; k++)
if (max > a[k][maxj]) // 将最大数和其同列元素相比
{
flag = 0; // 如果 max 不是同列最小，示意不是鞍点，令 flag1 为 0
continue;
}
if (flag) // 如果 flagl 为 1 示意是鞍点
{printf("a[%d][%d]=%d\n", i, maxj, max); // 输入鞍点的值和所在行列号
break;
}
}
if (!flag) // 如果 flag 为 0 示意鞍点不存在
printf("It is not exist!\n");
return 0;
}
运行后果：
①
第 2～5 行是输出的数据，最初一行是输入的后果。
②
（无鞍点）
题目 9：有 15 个数按由大到小程序寄存在一个数组中，输出一个数，要求用折半查找法找出该数是数组中第几个元素的值。如果该数不在数组中，则输入 ” 无此数 ”。
解：从表列中查一个数最简略的办法是从第 1 个数开始程序查找，将要找的数与表列中的数一一比拟，直到找到为止（如果表列中无此数，则应找到最初一个数，而后断定 ” 找不到 ”）。
但这种 ” 程序查找法 ” 效率低，如果表列中有 1000 个数，且要找的数恰好是第 1000 个数，则要进行 999 次比拟能力失去后果。均匀比拟次数为 500 次。
折半查找法是效率较高的一种办法。基本思路如下：
如果有已按由小到大排好序的 9 个数，a[1]～a[9]，其值别离为
1,3,5,7,9,11,13,15,17
若输出一个数 3，想查 3 是否在此数列中，先找出表列中居中的数，即 a[5]，将要找的数 3 与 a[5] 比拟，今 [a5] 的值是 9，发现 a[5]>3，显然 3 该当在 a[1]~a[5] 这部分，而不会在 a[6]～a[9]这部分。这样就能够放大查找范畴，甩掉 a[6]～a[9] 这部分，行将查找范畴放大为一半。再找 a[1]～a[5]的居中的数，即 a[3]，将要找的数 3 与 a[3]比拟，a[3]的值是 5，发现 a[3]>3，显然 3 该当在 a[1]～a[3]这部分。这样又将查找范畴放大一半。再将 3 与 a[1]～a[3] 的居中的数 a[2]比拟，发现要找的数 3 等于 a[2]，查找完结。一共比拟了 3 次。如果表列中有 n 个数，则最多比拟的次数为 $ int(log_2n) +1 $。
N- S 图如图 6.6 所示。
答案代码：
#include <stdio.h>
#define N 15
int main()
{int i, number, top, bott, mid, loca, a[N], flag = 1, sign;
char c;
printf("enter data:\n");
scanf("%d", &a[0]); // 输出第 1 个数
i = 1;
while (i < N) // 查看数是否已输出结束
{scanf("%d", &a[i]); // 输出下一个数
if (a[i] >= a[i - 1]) // 如果输人的数不小于前一个数
i++; // 使数的序号加 1
else
printf("enter this data again:\n"); // 要求从新输出此数
}
printf("\n");
for (i = 0; i < N; i++)
printf("%5d", a[i]); // 输入全副 15 个数
printf("\n");
while (flag)
{printf("input number to look for:"); // 问你要查找哪个数
scanf("%d", &number); // 输出要查找的数
sign = 0; // sign 为 0 示意尚未找到
top = 0; // top 是查找区间的起始地位
bott = N - 1; // bott 是查找区间的最末地位
if ((number < a[0]) || (number > a[N - 1])) // 要查的数不在查找区间内
loca = -1; // 示意找不到
while ((!sign) && (top <= bott))
{mid = (bott + top) / 2; // 找出两头元素的下标
if (number == a[mid]) // 如果要查找的数正好等于两头元素
{
loca = mid; // 记下该下标
printf("Has found %d,its position is %d\n", number, loca + 1); // 因为下标从 0 算起，而人们习惯从 1 算起，因而输入数的地位要加 1
sign = 1; // 示意找到了
}
else if (number < a[mid]) // 如果要查找的数小于两头元素的值
bott = mid - 1; // 只须在下标为 0～mid- 1 的元素中找
else // 如果要查找的数不小于两头元素的值
top = mid + 1;
} // 只须在下标为 mid+1～bott 的元素中找
if (!sign || loca == -1) // sign 为 0 或 loca 等于—1，意味着找不到
printf("cannot find %d.\n", number); // 输入 "找不到"
printf("continue or not(Y/N)?"); // 问你是否持续查找
scanf("%c", &c); // 不想持续查找输出 'N' 或 'n'
if (c == 'N' || c == 'n')
flag = 0; // lag 为开关变量. 控制程序是否完结运行
}
return 0;
}
运行后果：
以上运行状况是这样的∶开始输出 3 个数，因为程序不是由小到大，程序不接管，要求从新输出。再输出 15 个数，而后程序输入这 15 个数，供核查。程序询问要找哪个数，输出 7，输入 ” 找不到 7 ″。问是否持续找数，答复 y 示意 yes，再问找哪个数，输出 12，输入 ” 找到了。它是第 7 个数 ”。
题目 10：有一篇文章，共有 3 行文字，每行有 80 个字符。要求别离统计出其中英文大写字母、小写字母、数字、空格以及其余字符的个数。
解：N- S 图如图 6.7 所示。
答案代码：
#include <stdio.h>
int main()
{
int i, j, upp, low, dig, spa, oth;
char text[3][80];
upp = low = dig = spa = oth = 0;
for (i = 0; i < 3; i++)
{printf("please input line %d:\n", i + 1);
gets(text[i]);
for (j = 0; j < 80 && text[i][j] != '\0'; j++)
{if (text[i][j] >= 'A' && text[i][j] <= 'Z')
upp++;
else if (text[i][j] >= 'a' && text[i][j] <= 'z')
low++;
else if (text[i][j] >= '0' && text[i][j] <= '9')
dig++;
else if (text[i][j] == ' ')
spa++;
else
oth++;
}
}
printf("\n");
printf("upper case :%d\n", upp);
printf("lower case :%d\n", low);
printf("digit :%d\n", dig);
printf("space :%d\n", spa);
printf("other :%d\n", oth);
return 0;
}
运行后果：
先后输出了 3 行字符，程序统计出后果。
阐明：数组 text 的行号为 0～2，但在提醒用户输出各行数据时，要求用户输出第 1 行、第 2 行、第 3 行; 而不是第 0 行、第 1 行、第 2 行，这齐全是关照人们的习惯。为此，在程序第 6 行中输入行数时用 i+1，而不必 i。这样并不影响程序对数组的解决，程序其余中央数组的第 1 个下标值依然是 0～2。
题目 11：输入以下图案
*****
*****
*****
*****
*****解：
答案代码：
#include <stdio.h>
int main()
{char a[5] = {'*', '*', '*', '*', '*'};
int i, j, k;
char space = ' ';
for (i = 0; i < 5; i++)
{printf("\n");
printf(" ");
for (j = 1; j <= i; j++)
printf("%c", space);
for (k = 0; k < 5; k++)
printf("%c", a[k]);
}
printf("\n");
return 0;
}
运行后果：
题目 12：有一行电文，已按上面法则译成密码∶
A→Z a→z
B→Y b→y
C→X c→x
….
即第 1 个字母变成第 26 个字母，第 i 个字母变成第（26-i+1）个字母，非字母字符不变。要求编程序将明码译回原文，并输入明码和原文。
解：能够定义一个数组 ch，在其中寄存电文。如果字符 ch[j] 是大写字母，则它是 26 个字母中的第（ch[j]-64）个大写字母。例如，若 ch[j] 的值是大写字母 ‘B’，它的 ASCII 码为 66，它应是字母表中第（66-64）个大写字母，即第 2 个字母。按明码规定应将它转换为第（26-i+1）个大写字母，即第（26-2+1）= 25 个大写字母。而 26-i+1=26 – (ch[j] – 64）+1=26+64-ch[j] + 1，即 91-ch[j]（如 ch[j] 等于 ‘B’，91-‘B’=91-66=25，ch[j] 应将它转换为第 25 个大写字母）。该字母的 ASCII 码为 91-ch[j] + 64，而 91-ch[j] 的值 为 25，因而 91-ch[j]+64=25+64=89，89 是 ‘Y’ 的 ASCII 码。表达式 91-ch[i]+64 能够间接示意为 155-ch[j]。小写字母状况与此类似，但因为小写字母 ‘a’ 的 ASCII 码为 97，因而解决小写字母的公式应改为：26+96-ch[j]+1+96=123-ch[j]+96=219—ch[j]。例如，若 ch[j] 的值为 ‘b’，则其替换对象为 219—’b’=219—98=121，它是 ‘y’ 的 ASCII 码。
因为此明码的法则是对称转换，即第 1 个字母转换为最初一个字母，最初一个字母转换为第 1 个字母，因而从原文译为明码和从明码译为原文，都是用同一个公式。
N- S 图如图 6.8 所示。
答案代码：
（1）用两个字符数组别离寄存原文和明码
#include <stdio.h>
int main()
{
int j, n;
char ch[80], tran[80];
printf("input cipher code:");
gets(ch);
printf("\ncipher code :%s", ch);
j = 0;
while (ch[j] != '\0')
{if ((ch[j] >= 'A') && (ch[j] <= 'Z'))
tran[j] = 155 - ch[j];
else if ((ch[j] >= 'a') && (ch[j] <= 'z'))
tran[j] = 219 - ch[j];
else
tran[j] = ch[j];
j++;
}
n = j;
printf("\noriginal text:");
for (j = 0; j < n; j++)
putchar(tran[j]);
printf("\n");
return 0;
}
运行后果：
（2）只用一个字符数组
#include <stdio.h>
int main()
{
int j, n;
char ch[80];
printf("input cipher code:\n");
gets(ch);
printf("\ncipher code:%s\n", ch);
j = 0;
while (ch[j] != '\0')
{if ((ch[j] >= 'A') && (ch[j] <= 'Z'))
ch[j] = 155 - ch[j];
else if ((ch[j] >= 'a') && (ch[j] <= 'z'))
ch[j] = 219 - ch[j];
else
ch[j] = ch[j];
j++;
}
n = j;
printf("original text:");
for (j = 0; j < n; j++)
putchar(ch[j]);
printf("\n");
return 0;
}
运行后果：
题目 13：编一程序，将两个字符串连接起来，不要用 strcat 函数。
解：
N- S 图如图 6.9 所示。
答案代码：
#include <stdio.h>
int main()
{char s1[80], s2[40];
int i = 0, j = 0;
printf("input string1:");
scanf("%s", s1);
printf("input string2:");
scanf("%s", s2);
while (s1[i] != '\0')
i++;
while (s2[j] != '\0')
s1[i++] = s2[j++];
s1[i] = '\0';
printf("\nThe new string is :%s\n", s1);
return 0;
}
运行后果：
题目 14：编一个程序，将两个字符串 sl 和 s2 比拟，若 s1>s2，输入一个负数; 若 s1=s2. 输入 0; 若 sl<s2，输入一个正数。不要用 strcpy 函数。两个字符串用 gets 函数读入。输入的负数或正数的绝对值应是相比拟的两个字符串相应字符的 ASCII 码的差值。例如，”A” 与 ”C” 相比，因为 ”A”<“C”，应输入正数，同时因为 ’A’ 与 ’C’ 的 ASCII 码差值为 2，因而应输入 ”-2″。同理∶”And” 和 ”Aid” 比拟，依据第 2 个字符比拟后果，”n” 比 ”i” 大 5，因而应输入 ”5″。
解：
#include <stdio.h>
int main()
{
int i, resu;
char s1[100], s2[100];
printf("input string1:");
gets(s1);
printf("\ninput string2:");
gets(s2);
i = 0;
while ((s1[i] == s2[i]) && (s1[i] != '\0'))
i++;
if (s1[i] == '\0' && s2[i] == '\0')
resu = 0;
else
resu = s1[i] - s2[i];
printf("\nresult:%d.\n", resu);
return 0;
}
运行后果：
题目 15：编写一个程序，将字符数组 s2 中的全副字符复制到字符数组 s1 中。不必 strcpy 函数。复制时，\0’ 也要复制过来。\0’ 前面的字符不复制。
解：
#include <stdio.h>
int main()
{char s1[80], s2[80];
int i;
printf("input s2:");
scanf("%s", s2);
for (i = 0; i <= strlen(s2); i++)
s1[i] = s2[i];
printf("s1:%s\n", s1);
return 0;
}
运行后果：
