有4名学生，每个学生考4门课，要求根据学号查询学生的全部成绩，请编写指针型函数 float *search (float (*pointer) [4], int n)。
#include <stdio.h>
// 定义一个函数 search，用于根据学生编号返回对应的成绩数组的指针
// 参数：
// - pointer: 指向二维数组的指针，每个子数组有4个元素
// - n: 学生编号
// 返回值：
// - 返回指向第 n 个学生成绩数组的指针
float* search(float (*pointer)[4], int n) {
// 返回第 n 个学生的成绩数组的指针
// 注意：数组索引从0开始，所以需要减1
return *(pointer + n - 1);
}
int main() {
// 定义一个静态二维数组，存储4个学生的4门课程成绩
static float score[][4] = {
{60, 70, 80, 90}, // 学生1的成绩
{50, 89, 67, 88}, // 学生2的成绩
{34, 78, 90, 66}, // 学生3的成绩
{80, 90, 70, 100} // 学生4的成绩
};
// 定义一个指向 float 的指针，用于存储搜索结果
float *p;
// 定义一个整数变量，用于存储用户输入的学生编号
int m;
// 提示用户输入学生编号
printf("enter the number of student :");
// 读取用户输入的学生编号
scanf("%d", &m);
// 输出指定学生编号的成绩
printf("the score of No.%d are:\n", m);
// 调用 search 函数，获取第 m 个学生的成绩数组的指针
p = search(score, m);
// 遍历成绩数组，输出每个成绩
for (int i = 0; i < 4; i++) {
// 输出每个成绩，保留两位小数，使用制表符对齐
printf("%5.2f\t", *(p + i));
}
// 换行
printf("\n");
return 0;
}以下程序是找出二维数组a中每行的最大值，并按一一对应的顺序放入一维数组s中。即：第零行中的最大值放入s[0] 中，第一行中的最大值放入s[1] 中，......。然后输出每行的行号和最大值。
#include <cstdio> // 包含标准输入输出库
#define M 6 // 定义二维数组的行数和列数均为6
int main() {
// 变量声明
int a[M][M]; // 定义MxM二维数组，用于存储矩阵数据
int s[M]; // 定义一维数组，用于存储每行的最大值
int i, j; // 循环控制变量
/* 数据输入部分 */
// 外层循环遍历行，内层循环遍历列
for (i = 0; i < M; i++) {
for (j = 0; j < M; j++) {
// 使用指针算术访问数组元素：
// *(a + i) 等效于 a[i]（获取第i行的首地址）
// *(a + i) + j 等效于 &a[i][j]（获取第i行第j列元素的地址）
scanf("%d", *(a + i) + j); // 读取输入到a[i][j]
}
}
/* 寻找每行最大值 */
for (i = 0; i < M; i++) {
*(s + i) = *(*(a + i)); // 初始化s[i]为当前行的第一个元素a[i][0]
// 遍历当前行的所有元素（从第2个元素开始）
for (j = 1; j < M; j++) {
// 使用指针访问元素：
// *(*(a + i) + j) 等效于 a[i][j]
if (*(s + i) < *(*(a + i) + j)) {
*(s + i) = *(*(a + i) + j); // 更新当前行的最大值
}
}
}
/* 结果输出 */
for (i = 0; i < M; i++) {
// %2d：保证行号至少占2位宽度（右对齐）
// %5d：保证最大值至少占5位宽度（右对齐）
printf("Row=%2d Max=%5d", i, *(s + i));
}
printf("\n"); // 输出换行符确保输出格式规范
return 0;
}编写一个程序实现两个矩阵的乘法运算，具体要求如下：(1)两个矩阵的行数与列数由用户从键盘输入。(2)两个矩阵的所有元素的值由用户从键盘输入。(3)使用函数来实现矩阵的乘法运算。(4)运算的结果应该输出到屏幕上。(5)程序中应该有简洁、明了的注释。
#include <cstdio>
#include <cstdlib>
#define MAX 10 // 定义矩阵的最大维度为10x10
int main()
{
int h1 = 0, h2 = 0, l1 = 0, l2 = 0; // 声明矩阵1的行列(h1,l1)，矩阵2的行列(h2,l2)
int arr1[MAX][MAX], arr2[MAX][MAX], res[MAX][MAX]; // 定义两个输入矩阵和结果矩阵
// 函数声明：计算矩阵乘法结果（存在逻辑错误）
void getRes(int h1, int h2, int l1, int l2, int arr1[MAX][MAX], int arr2[MAX][MAX], int res[MAX][MAX]);
// 输入矩阵1的维度
printf("input the h1 and l1:\n");
scanf("%d %d", &h1, &l1);
// 输入矩阵2的维度
printf("input the h2 and l2:\n");
scanf("%d %d", &h2, &l2);
// 输入矩阵1的元素
printf("---input the arr1----\n");
for (int i = 0; i < h1; ++i) {
for (int j = 0; j < l1; ++j) {
scanf("%d", &arr1[i][j]);
}
}
// 输入矩阵2的元素
printf("---input the arr2----\n");
for (int i = 0; i < h2; ++i) {
for (int j = 0; j < l2; ++j) {
scanf("%d", &arr2[i][j]);
}
}
// 计算矩阵乘积（注意：此处缺少维度合法性检查，当l1 != h2时会出错）
getRes(h1, h2, l1, l2, arr1, arr2, res);
// 输出结果矩阵
for (int i = 0; i < h1; ++i) {
for (int j = 0; j < l2; ++j) {
printf("%6d", res[i][j]); // 格式化输出每个元素
}
printf("\n");
}
}
// 矩阵乘法函数（存在逻辑错误）
void getRes(int h1, int h2, int l1, int l2, int arr1[MAX][MAX], int arr2[MAX][MAX], int res[MAX][MAX]) {
int ret = 0; // 临时存储乘积和
// 三重循环遍历矩阵
for (int i = 0; i < h1; ++i) { // 遍历结果矩阵的行
for (int j = 0; j < l2; ++j) { // 遍历结果矩阵的列（l2）
for (int k = 0; k < l1; ++k) {//k应循环至l1次（矩阵1的列数/矩阵2的行数）
ret += arr1[i][k] * arr2[k][j]; // 累加乘积
}
res[i][j] = ret; // 存储结果
ret = 0; // 重置临时变量
}
}
}
重要的是ret=0不能忘了。
求三个字符串的最长公共子串
编写程序，从键盘输入6名学生的5门课的成绩，分别统计出每个学生的平均成绩。
#include <cstdio>
#include <cstdlib>
/* 函数功能：计算二维数组中每行的平均值
* 参数：p - 指向包含5个float元素的数组指针（二维数组行指针）
* 返回值：动态分配的包含6个float元素的数组指针（存储每行的平均值）*/
float* getAve(float (*p)[5]) { // 行指针，指向包含5个元素的数组
float* ans = (float*)calloc(6, sizeof(float)); // 动态分配6个float空间（6个学生的平均分）
float sum = 0;
for (int i = 0; i < 6; ++i) { // 遍历6个学生
for (int j = 0; j < 5; ++j) { // 遍历5门课程
// 等价于 p[i][j]，使用指针算术运算访问元素
sum += *(*(p + i) + j); // 累加当前学生的5门课程成绩
}
ans[i] = sum / 5; // 计算当前学生的平均分
sum = 0; // 重置总分计数器
}
return ans; // 返回存储平均值的数组
}
int main() {
// 定义静态二维数组（实际存储6个学生的5门课程成绩）
static float score[6][5] = {
{60, 60, 60, 60, 60}, // 学生1
{50, 89, 67, 88, 34}, // 学生2
{34, 78, 90, 66, 33}, // 学生3
{80, 90, 70, 100, 78}, // 学生4
{80, 90, 70, 100, 90}, // 学生5
{23, 56, 67, 78, 90} // 学生6
};
float (*p)[5] = score; // 定义行指针指向二维数组首地址
float* ans = getAve(p); // 调用函数获取平均分数组
// 打印所有学生的平均分
for (int i = 0; i < 6; ++i) {
printf("学生%d平均分: %f\n", i+1, ans[i]); // 添加更清晰的输出格式
}
free(ans); // 释放动态分配的内存
return 0; // 明确返回值
}求3×3矩阵的主对角元素的和
#include <cstdio> // 包含标准输入输出库，用于scanf和printf函数
int main() {
int arr[3][3], sum = 0; // 定义3x3二维数组和累加器sum
// 双层循环读取用户输入的9个数字
for (int i = 0; i < 3; ++i) { // 外层循环控制行
for (int j = 0; j < 3; ++j) { // 内层循环控制列
scanf("%d", &arr[i][j]); // 读取用户输入的数字存入数组
// 当行号等于列号时（即矩阵主对角线）
if (i == j) {
sum += arr[i][j]; // 累加主对角线元素值
}
}
}
printf("%d", sum); // 输出主对角线元素之和
return 0;
}编程从键盘输入一个NxN的矩阵A，求矩阵B(B=A+A'),即将矩阵A与其转置矩阵A'相加，结果存放到矩阵B中。
```cpp
#include <cstdio> // 标准输入输出库
#define MAX 10 // 定义矩阵最大尺寸为10x10
int main() {
int A[MAX][MAX], B[MAX][MAX]; // 声明两个MAX尺寸的二维数组
int n, ret = 0; // n-矩阵维度，ret-临时存储计算结果
puts("input the n:"); // 提示输入矩阵维度
scanf("%d", &n); // 读取用户输入的维度
// 检查n是否超出MAX范围（潜在问题：缺少越界检查）
// if(n <=0 || n > MAX) { /* 错误处理 */ }
puts("---input the A----"); // 提示输入矩阵A
for (int i = 0; i < n; ++i) { // 行遍历
for (int j = 0; j < n; ++j) { // 列遍历
scanf("%d", &A[i][j]); // 读取A[i][j]的值
}
}
/* 计算对称和矩阵B
* B[i][j] = A[i][j] + A[j][i]
* 结果矩阵将是对称矩阵 */
for (int i = 0; i < n; ++i) { // 行遍历
for (int j = 0; j < n; ++j) { // 列遍历
ret = A[i][j] + A[j][i]; // 计算对称元素之和
B[i][j] = ret; // 存储到B矩阵
// 优化建议：可直接写成 B[i][j] = A[i][j] + A[j][i]
}
}
// 打印结果矩阵B
for (int i = 0; i < n; ++i) { // 行遍历
for (int j = 0; j < n; ++j) { // 列遍历
printf("%6d ", B[i][j]); // 格式化输出每个元素
}
printf("\n"); // 每行结束换行
}
}
编程从键盘输入一个方阵的行数及所有元素，求该方阵“右上三角”的元素之和。
#include <cstdio> // 标准输入输出库
#define MAX 10 // 定义矩阵最大尺寸为10x10
int main() {
int A[MAX][MAX]; // 声明MAX尺寸的二维数组
int n, sum = 0; // n-矩阵维度，sum-上三角元素累加和
puts("input the n:"); // 提示输入矩阵维度
scanf("%d", &n); // 读取用户输入的维度
// 潜在问题：未校验n的范围（需满足 0 < n <= MAX）
puts("---input the A----"); // 提示输入矩阵A
for (int i = 0; i < n; ++i) { // 行遍历
for (int j = 0; j < n; ++j) { // 列遍历
scanf("%d", &A[i][j]); // 读取矩阵元素
}
}
/* 计算上三角元素和（含主对角线）
* 通过 j = i 跳过下三角元素
* 当 i=0 时遍历 j=0→n-1
* 当 i=1 时遍历 j=1→n-1
* ... */
for (int i = 0; i < n; ++i) { // 行遍历
for (int j = i; j < n; ++j) { // 列从当前行号开始（上三角）
sum += A[i][j]; // 累加上三角元素
}
}
printf("the sum is:%d", sum); // 输出计算结果
}
编程从键盘输入一个MxN 的二维数组，求该数组中最外圈元素的平均值，并输出结果。
#include <cstdio> // 引入标准输入输出库
#define MAX 10 // 定义最大行列数为10
int main() {
int A[MAX][MAX], m, n, sum = , count = ; // 声明二维数组和变量
puts("input the m and n:"); // 提示输入行数m和列数n
scanf("%d %d", &m, &n); // 读取用户输入的行列数
puts("---input the A----"); // 提示输入数组元素
// 双层循环读取数组元素
for (int i = ; i < m; ++i) {
for (int j = ; j < n; ++j) {
scanf("%d", &A[i][j]); // 逐个读取元素存入二维数组
}
}
// 计算首行和末行的所有元素
for (int i = ; i < m; ++i) {
for (int j = ; j < n; ++j) {
if (i == || i == m-1) { // 判断是否是首行或末行
sum += A[i][j]; // 累加元素值
count++; // 计数加1
}
}
}
// 计算中间行的首列和末列元素（排除首末行）
for (int i = 1; i < m-1; ++i) {
for (int j = ; j < n; ++j) {
if (j == || j == n-1) { // 判断是否是首列或末列
sum += A[i][j]; // 累加元素值
count++; // 计数加1
}
}
}
// 输出平均值（保留两位小数）
printf("the ave sum is:%.2f", (float)sum/count);
}更简单的版本
#include <cstdio>
#define MAX 10
int main()
{
int A[MAX][MAX],m,n,sum = 0,count = 0;
puts("input the m and n:");
scanf("%d %d",&m,&n);
puts("---input the A----");
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d",&A[i][j]);
if (i==0 || i==m-1 || j==0 || j==n-1){
sum+=A[i][j];
count++;
}
}
}
printf("the ave sum is:%.2f",(float )sum/count);
}
编程产生一个10x10的方阵，要求该方阵副对角线上的元素均为2，其余元素均为0，输出该方阵。
#include <cstdio> // 包含标准输入输出库，用于puts和printf函数
#define MAX 10 // 定义常量MAX为10，表示矩阵维度
int main() {
int A[MAX][MAX]; // 声明10x10的二维整型数组
// 输出提示信息（此处实际为初始化矩阵，并非用户输入）
puts("---input the A----");
// 双重循环遍历矩阵每个元素
for (int i = 0; i < MAX; ++i) {
for (int j = 0; j < MAX; ++j) {
// 判断是否为反对角线位置（i+j = MAX-1时）
if (j + i == MAX - 1) {
A[i][j] = 2; // 反对角线元素赋值为2
} else {
A[i][j] = 0; // 其他位置元素赋值为0
}
}
}
// 打印生成的矩阵
for (int i = 0; i < MAX; ++i) {
for (int j = 0; j < MAX; ++j) {
printf("%d ", A[i][j]); // 输出每个元素加空格
}
printf("\n"); // 每行结束换行
}
return 0; // 正常结束程序
}
设某班级每位同学有3门课程的考试成绩，采用二维数组编程实现从键盘输入每个同学的成绩，并计算其平均成绩后输出。
#include <cstdio>
#define N 10
int main()
{
int scores[N][3],n;
float sum = 0;
float res[3] = {0};
puts("input n:");
scanf("%d",&n);
puts("---input the scores----");
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
scanf("%d",&scores[i][j]);
sum+=scores[i][j];
}
res[i] = sum/3;
sum = 0;
}
for (int i = 0; i < 3; ++i) {
printf("%.2f ",res[i]);
}
}
利用指向指针的指针和冒泡法对MXN矩阵进行处理，使每行元素按照从小到大的顺序排列。
// 引入标准输入输出库
#include <cstdio>
// 定义最大行列数为10
#define MAX 10
/* 冒泡排序函数（优化版）
* 参数：p - 数组首地址指针，n - 数组长度
* 功能：对数组进行升序排序，当某轮无交换时提前结束排序 */
void sort(int* p, int n) {
bool flag = false; // 交换标志位
for (int i = n-1; i >= 0; --i) { // 控制排序轮数
flag = false;
for (int j = 0; j < i; ++j) { // 遍历未排序元素
if (p[j] > p[j+1]) { // 相邻元素比较
// 元素交换
int t = p[j];
p[j] = p[j+1];
p[j+1] = t;
flag = true; // 标记发生交换
}
}
if (!flag) break; // 提前终止条件
}
}
int main() {
int a[MAX][MAX], m, n; // 二维数组存储矩阵
int** p; // 二级指针（行指针的指针）
int* pa[m]; // 行指针数组（存储每行首地址）
// 输入矩阵维度
puts("input m and n");
scanf("%d %d", &m, &n); // 注意：m,n不应超过MAX
// 输入矩阵数据
puts("---input a----");
for (int i = 0; i < m; ++i) {
pa[i] = a[i]; // 存储当前行首地址
for (int j = 0; j < n; ++j) {
scanf("%d", &a[i][j]);
}
}
p = pa; // 二级指针指向行指针数组
// 逐行排序
for (int i = 0; i < m; ++i) {
sort(p[i], n); // 对第i行排序
}
// 输出排序结果
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
printf("%d ", a[i][j]);
}
printf("\n"); // 每行输出后换行
}
return 0;
}
编写函数求 MxN 二维数组中每列的最小元素，将结果依次存入一维数组中。要求在 main()函数中进行数组的输入和输出。
#include <cstdio> // 引入标准输入输出库
#define MAX 10 // 定义二维数组最大维度
int main() {
int a[MAX][MAX], m, n; // 定义二维数组和行列变量（存在越界风险）
// 输入矩阵维度（未做输入校验，m/n超过MAX会越界）
puts("input m and n");
scanf("%d %d", &m, &n);
// 输入矩阵元素（行优先存储）
puts("---input a----");
for (int i = 0; i < m; ++i) { // 遍历行
for (int j = 0; j < n; ++j) { // 遍历列
scanf("%d", &a[i][j]); // 注意：i/j 对应行/列坐标
}
}
int res[n]; // 定义结果数组（C++中非法，属于变长数组VLA）
// 列最小值计算（修正后的正确逻辑）
for (int i = 0; i < n; ++i) { // 遍历每一列
int min = a[0][i]; // 初始化首行该列元素为最小值
for (int j = 0; j < m; ++j) { // 遍历该列所有行
if (a[j][i] < min) { // 注意下标顺序为[行][列]
min = a[j][i]; // 更新最小值
}
}
res[i] = min; // 存储该列最小值
}
// 输出结果（注意结果数量应与列数n一致）
for (int i = 0; i < n; ++i) {
printf("%d ", res[i]);
}
return 0; // 补充C++标准要求的返回语句
}
打印出杨辉三角形（如下图）
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
#include <cstdio> // 引入标准输入输出库（C++头文件，但代码实际使用C风格）
#define MAX 10 // 定义二维数组最大尺寸
int main() {
int a[MAX][MAX], m, n; // 声明二维数组（最大10x10），m-行数，n-列数（n未实际使用）
// 输入维度（存在严重安全隐患：未校验m,n范围）
puts("input m and n"); // 提示输入行数和列数
scanf("%d %d", &m, &n); // 读取输入值（若m/n>10将导致数组越界）
// 误导性提示：实际并未输入数组内容
puts("---input a----"); // 此处应删除，代码实际生成杨辉三角而非接收输入
/* 初始化边界值（存在三个问题）
1. 当m>10时数组越界
2. 当i>=n时a[i][i]列越界（如输入m=5,n=3）
3. i从0开始导致a[0][0]被重复初始化（无害但冗余）*/
for (int i = 0; i < m; ++i) {
a[i][0] = 1; // 每行首元素置1
a[i][i] = 1; // 对角线元素置1（i超过n-1时越界）
}
/* 计算杨辉三角核心部分（问题：
1. 未考虑列数n的限制
2. 当m<=2时此循环不执行） */
for (int i = 2; i < m; ++i) { // 从第三行开始计算
for (int j = 1; j < i; ++j) { // 遍历非边界元素
// 正确计算公式：a[i][j] = 上方两元素之和
a[i][j] = a[i-1][j-1] + a[i-1][j];
}
}
// 输出结果（问题：未考虑列数n的限制）
for (int i = 0; i < m; ++i) { // 遍历每行
for (int j = 0; j <= i; ++j) { // 输出三角形内容（j超过n-1时越界）
printf("%d ", a[i][j]); // 打印元素
}
printf("\n"); // 换行
}
return 0; // C++标准要求main函数返回int
}
提示输入一个字符串string,然后在string里面每个字母间加一个#,请用指针完成。
#include <cstdio> // 引入标准输入输出库
#include <cstring> // 引入字符串处理库
#define MAX 100 // 定义最大字符数组长度
int main() {
char s[MAX], temp[MAX]; // 定义源字符串和临时字符串数组
puts("input the string:"); // 提示输入字符串
gets(s); // 读取输入字符串（存在缓冲区溢出风险！）
char* p = s; // 指针指向源字符串首地址
int j = 0; // 临时数组索引
// 遍历源字符串（效率问题：strlen(s)每次循环都计算）
for (int i = 0; i < strlen(s); ++i) {
temp[j++] = p[i]; // 复制原字符到临时数组
temp[j++] = '#'; // 插入分隔符#
}
temp[--j] = '\0'; // 去掉最后一个#并添加字符串结束符
puts(temp); // 输出处理后的字符串
return 0; // C++标准要求返回语句
}
/* 代码功能说明：
将输入字符串每个字符后插入#符号
示例：
输入：abc
输出：a#b#c
潜在问题：
1. 使用危险的gets函数（建议改用fgets）
2. 临时数组长度可能溢出（最大支持长度应为2*MAX-1）
3. 循环中重复计算strlen(s)（建议预存长度）
4. 源字符串包含'\0'时处理异常 */
将p字符串中的小写字母移入字符数组a中。
#include <cstdio> // 引入标准输入输出库
int main() {
char a[20], *p = "asd2aASDas"; // 定义目标数组a（容量20）和源字符串指针
int i = 0, j = 0; // i-源字符串索引，j-目标数组索引
// 遍历源字符串（存在潜在问题）
while (*(p + i) != '\0') { // 等价于 p[i] != '\0'
// 检查当前字符是否为小写字母
if (*(p + i) >= 'a' && *(p + i) <= 'z') {
a[j] = *(p + i); // 将合法字符存入目标数组
j++; // 目标数组索引递增
}
i++; // 源字符串索引无条件递增
}
a[j] = '\0'; // 使用 a[j] = '\0'
puts(a); // 输出结果（可能含乱码）
return 0; // 程序结束
}
写一个函数，用“起泡法”对输入的10个字符按由小到大顺序排列。
#include <cstdio>
#include <cstring>
int main(){
char s[10];
gets(s);
void sort(char s[]);
sort(s);
puts(s);
}
void sort(char s[]){
int len = strlen(s);
bool flag;
for (int i = len-1; i>=0; --i) {
flag = false;
for (int j = 0; j < i; ++j) {
if (s[j] > s[j+1]){
char t = s[j+1];
s[j+1] = s[j];
s[j] = t;
flag = true;
}
}
if (!flag){
break;
}
}
}输入3个字符串，按由小到大的顺序输出。
#include <cstdio>
#include <cstring>
int main(){
char s1[10];
char s2[10];
char s3[10];
gets(s1);
gets(s2);
gets(s3);
void swap(char a[],char b[]);
if (strcmp(s1,s2)>0){
swap(s1,s2);
}
if (strcmp(s1,s3)>0){
swap(s1,s3);
}
if (strcmp(s2,s3)>0){
swap(s2,s3);
}
printf("%s %s %s",s1,s2,s3);
}
void swap(char a[],char b[]){
char t[20];
strcpy(t,a);
strcpy(a,b);
strcpy(b,t);
}
将10个字符串从小到大排序后输出。
#include <cstdio> // 包含标准输入输出函数
#include <cstring> // 包含字符串处理函数
int main() {
char s[10][10]; // 定义二维字符数组，存储10个最大长度为9的字符串（包含\0）
// 输入部分：循环读取10个字符串
for (int i = 0; i < 10; ++i) {
printf("input the No.%d:", i+1);
gets(s[i]); // ⚠️存在安全隐患！gets不检查输入长度，可能导致缓冲区溢出
}
// 冒泡排序：按字典序升序排列
for (int i = 9; i > 0 ; --i) { // 控制排序轮数
bool flag = false; // ⚠️修正：必须初始化flag！标记本轮是否有交换
for (int j = 0; j < i; ++j) { // 每轮比较相邻元素
if (strcmp(s[j], s[j+1]) > 0) { // 前>后时交换
char t[20]; // 临时交换缓冲区
strcpy(t, s[j+1]); // 三步完成字符串交换
strcpy(s[j+1], s[j]); // 不能用=直接赋值，需用strcpy
strcpy(s[j], t);
flag = true; // 标记本轮发生过交换
}
}
if (!flag) break; // 优化：若本轮无交换，说明已有序，提前结束
}
// 输出排序后的结果
for (int i = 0; i < 10; ++i) {
puts(s[i]); // 输出每个字符串（自动换行）
}
return 0;
}
以下程序计算鸡兔同笼问题，鸡兔共有88个头，244只脚，请问鸡和兔各有多少只？
#include <cstdio>
#include <cstring>
int main() {
int head,feet;
printf("input the head and feet:\n");
scanf("%d %d",&head,&feet);
void func(int head,int feet);
func(head,feet);
}
void func(int head,int feet){
for (int i = 0; i < head; ++i) {
int y = head - i;
if (i*2+y*4 == feet){
printf("rabbit is:%d and chicken is:%d",i,y);
}
}
}
根据以下给定公式计算e的值（取前n项）。
e=1+1/1! +1/2! +1/3! +.....+1/n!
#include <cstdio> // 包含标准输入输出库
// 计算整数i的阶乘函数，返回浮点型结果
float ji(int i) {
float res = 1; // 初始化结果为1（0! = 1）
for (int j = 1; j <= i; ++j) {
res *= j; // 累乘计算阶乘：1*2*3*...*i
}
return res; // 返回i!的浮点型结果（注意：i较大时会溢出或精度丢失）
}
int main() {
int n; // 输入的正整数n
float sum = 0; // 存储累加和：1! + 2! + ... + n!
scanf("%d", &n); // 读取n（⚠️未校验输入合法性，如n<=0或过大）
// 循环计算1!到n!的累加和
for (int i = 1; i <= n; ++i) {
sum += ji(i); // 调用阶乘函数并累加
}
printf("%.2f", sum); // 输出结果，保留两位小数
return 0;
}
根据下面给公式求值
#include<cstdio>
#include<cmath>
// 计算阶乘（返回double防止溢出）
double fac(int n) {
double sum = 1.0; // 改为double类型
for(int i=1; i<=n; i++) {
sum *= i;
}
return sum;
}
int main() {
double Yn = 0.0;
int n = 30;
for(int i=1; i<=n; i++) {
// 修正除法：使用浮点数运算
Yn += pow(1.0 / fac(i), 2); // 分子改为1.0
// 更高效的写法（避免调用pow）：
// double term = 1.0 / fac(i);
// Yn += term * term;
}
printf("%.6f\n", Yn); // 输出1.250000
return 0;
}
编写函数 min(x,y,z)，求 3 个整数中的最小值，并利用该函数求 5 个整数中的最小值。要求在主函数中输入5个整数，并输出结果。
#include<cstdio>
// 交换两个整数的值
// 参数：a, b 为指向要交换的两个整数的指针
void swap(int* a,int* b){
int t = *a; // 临时保存a的值
*a = *b; // 将b的值赋给a
*b = t; // 将临时保存的a的值赋给b
}
// 获取三个整数中的最小值
// 通过三次比较交换操作，确保第一个参数a存储最小值
// 参数：a, b, c 为要比较的三个整数
// 返回值：三个整数中的最小值
int getMin(int a,int b,int c){
// 比较a和b，确保a <= b
if (a>b){
swap(&a,&b);
}
// 比较a和c，确保a <= c
if (a>c){
swap(&a,&c);
}
// 比较b和c，确保b <= c（虽然不影响最小值，但使逻辑更清晰）
if (b>c){
swap(&b,&c);
}
return a; // 此时a已是三者中的最小值
}
int main() {
int a,b,c,d,e;
puts("input a b c d e"); // 提示输入五个整数
scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);
int min1 = getMin(a,b,c); // 获取前三个数的最小值
int min2 = getMin(min1,d,e); // 将前三个的最小值与后两个数比较，得到全局最小值
printf("min is %d",min2); // 输出最终结果
return 0;
}
编写一个求以下公式的函数
#include<cstdio>
#include <cmath> // 引入数学库，用于sqrt函数
// 计算从1到i的每个整数的平方根之和
// 参数：i - 需要计算的整数上限
// 返回值：平方根累加和的浮点结果
float func(int i){
float sum = 0.0; // 初始化累加器
for (int j = 1; j <= i; ++j) { // 遍历1到i的所有整数
sum += sqrt(j); // 累加每个整数的平方根
}
return sum;
}
int main(){
int n; // 用户输入的整数n
float sum = 0.0; // 存储最终结果的累加器
puts("input n:"); // 输入提示
scanf("%d", &n); // 读取用户输入的n
// 计算从func(1)到func(n)的累加和
for (int i = 1; i <= n; ++i) { // 遍历1到n的所有整数
sum += func(i); // 将每个func(i)的结果累加到总和中
}
// 输出结果，保留两位小数
printf("result is %.2f", sum); // 格式化输出最终结果
return 0;
}
算法设计：已知函数头为“int prime(int n)”，函数 prime 的功能：如果 n 是质数，返回 1；否则，返回 0。编写并调用函数 prime 输出 1000 以内所有的质数，每行输出 10 个质数。要求写出完整的程序。（注：质数是指在大于 1 的整数中，除了 1 和该整数自身外，不能被其他正整数整除的整数）
#include<cstdio>
#include <cmath> // 引入数学库用于sqrt函数
// 判断是否为质数的函数
// 参数：i - 需要判断的整数
// 返回值：true表示是质数，false表示不是质数
bool isPrime(int i){
// 遍历从2到sqrt(i)的所有可能因数
for (int j = 2; j <= sqrt(i); ++j) { // 优化：只需检查到平方根即可
if (i % j == 0) { // 如果能被整除则不是质数
return false;
}
}
return true; // 未找到因数则为质数
}
int main(){
int n; // 用户输入的上限值
int count = 0; // 质数计数器
scanf("%d",&n); // 读取用户输入的n
// 遍历2到n的所有数字
for (int i = 2; i <= n; ++i) { // 从2开始判断（1不是质数）
if (isPrime(i)){
printf("%d ",i); // 输出质数
count++; // 计数器自增
// 每输出10个质数换行
if (count%10 == 0 ){ // 当计数器是10的倍数时
printf("\n"); // 换行控制输出格式
}
}
}
}
编写函数，找出个大于给定整数 n 且紧随 n 的素数，要求在主函数中输入 n，并输出结果。
#include <stdio.h>
void func(int n){
while (1){
bool isPrime = true;
n++;
for (int i = 2; i*i<=n; ++i) {
if (n%i == 0){
isPrime = false;
break;
}
}
if (isPrime){
printf("%d",n);
return;
}
}
}
int main() {
int n;
puts("input the n:");
scanf("%d",&n);
func(n);
}
有 n 个整数，使前面各数顺序向后移 m 个位置，最后 m 个数变成最前面 m 个数。写一函数实现以上功能，在主函数中输入 n 个整数和输出调整后的 n 个数。
#include <stdio.h>
int main() {
int a[] = {1,2,3,4,5,6};
int n;
puts("input n:");
scanf("%d",&n);
int len = sizeof (a)/sizeof (a[0]);
int t[len];
for (int i = 0; i < len; ++i) {
t[(i+n)%len] = a[i];
}
for (int i = 0; i < len; ++i) {
printf("%d ",t[i]);
}
}
有一个内容为英文的文本文件file.txt文件中的单词是用空格分隔的，且两个单词之间只有一个空格，假定文件中单词数是少于50个，试编写一个程序，将文件file.txt的内容转存到一个新的文本文件file2.txt中，要求file2.txt中所有单词按英文词典中的排序方法进行排序(即按字母大小进行排序)，且单词之间使用1个空格进行分隔（可使用C语言的字符串函数）。
#include <cstdio> // 标准输入输出函数（如fopen, fgetc等）
#include <cstdlib> // 标准库函数（如exit）
#include <cstring> // 字符串操作函数（如strlen）
int main() {
// 文件指针声明：fp1用于读取源文件，fp2用于写入目标文件
FILE *fp1, *fp2;
fp1 = fopen("D:\\deskTop\\file1.txt", "r"); // 以只读模式打开源文件
fp2 = fopen("D:\\deskTop\\file2.txt", "w"); // 以写入模式创建目标文件
// 检查文件是否成功打开
if (!fp1 || !fp2) {
printf("open error!");
exit(-1); // 打开失败时强制退出程序
}
int c; // 存储从文件读取的字符（必须声明为int以正确处理EOF）
char s[100] = {}; // 缓冲区：存储单个单词（最多99字符 + 终止符）
int i = 0; // 缓冲区索引
// 逐字符读取源文件内容
while ((c = fgetc(fp1)) != EOF) {
if (c != ' ') { // 非空格字符：存入缓冲区
if (i < 99) // 防止缓冲区溢出（保留位置给终止符）
s[i++] = c; // 存储字符并递增索引
} else { // 遇到空格：处理当前单词
s[i] = '\0'; // 添加字符串终止符
// 冒泡排序：按升序排列字符
int len = strlen(s);
for (int j = len-1; j >=0; j--) { // 外层循环控制排序轮次
for (int k = 0; k < j; k++) { // 内层循环比较相邻字符
if (s[k] > s[k + 1]) { // 前一个字符更大则交换
char t = s[k];
s[k] = s[k + 1];
s[k + 1] = t;
}
}
}
fprintf(fp2, "%s ", s); // 将排序后的单词写入目标文件（带空格）
i = 0; // 重置缓冲区索引
memset(s, 0, sizeof(s)); // 清空缓冲区（可选，但确保安全性）
}
}
// 处理文件末尾最后一个单词（可能没有空格结尾）
if (i > 0) {
s[i] = '\0'; // 添加终止符
// 再次冒泡排序（与上述逻辑相同）
int len = strlen(s);
for (int j = 0; j < len - 1; j++) {
for (int k = 0; k < len - 1 - j; k++) {
if (s[k] > s[k + 1]) {
char t = s[k];
s[k] = s[k + 1];
s[k + 1] = t;
}
}
}
fprintf(fp2, "%s", s); // 写入单词（末尾不加空格）
}
fclose(fp1); // 关闭文件指针
fclose(fp2);
return 0; // 程序正常退出
}
编写函数，判断一个字符串是否是回文。在主函数中输入一个字符串，调用自定义函数，输出结果。所谓回文是指顺读和倒读都一样的字符串。如“XZYKYZX”是回文字符串。
#include <cstdio> // 用于标准输入输出函数，如gets和puts
#include <cstring> // 用于字符串处理函数，如strlen
// 判断字符串是否为回文串的函数
// 参数：s为待检查的字符数组，len为字符串长度
// 返回值：true表示是回文，false表示不是回文
bool judge(char s[], int len) {
bool flag = true; // 初始假设是回文串
// 遍历字符串的前半部分
for (int i = 0; i < len / 2; ++i) {
// 比较对称位置的字符，如s[0]和s[len-1]，s[1]和s[len-2]...
if (s[i] != s[len - i - 1]) {
flag = false; // 发现不匹配，标记为非回文
return flag; // 提前结束函数，返回false
}
}
return flag; // 全部对称位置字符匹配，返回true
}
int main() {
char s[100]; // 定义字符数组存储输入字符串（最多99字符+结尾'\0'）
gets(s); // 读取输入字符串（注意：gets存在缓冲区溢出风险，不推荐使用）
int len = strlen(s); // 计算字符串实际长度
// 调用判断函数并输出结果
if (judge(s, len)) {
puts("yes"); // 是回文输出"yes"
} else {
puts("no"); // 不是回文输出"no"
}
return 0;
}
输入“12345”转为int类型的12345。
#include <cstdio> // 提供标准输入输出函数（printf, gets）
#include <cstring> // 提供字符串处理函数（strlen）
// 字符串转整型数字函数
// 参数：p - 指向数字字符串的指针
// 返回值：转换后的整型数值
// 注意：仅处理纯数字字符串，遇到非数字字符将产生错误结果
int convert(char* p) {
int len = strlen(p); // 获取字符串长度
int sum = 0, k; // sum存储累计结果，k临时存储单个数字
for (int i = 0; i < len; ++i) {
printf("%c ", p[i]); // 调试输出：打印每个处理的字符
k = p[i] - '0'; // 将ASCII字符转换为数字（'0'->0, '1'->1...）
sum = sum * 10 + k; // 按十进制位累加（如12*10+3=123）
}
return sum;
}
int main() {
char s[10], *p; // 定义字符数组（最多存储9位数字）和指针
gets(s); // 读取输入字符串（存在缓冲区溢出风险！）
p = s; // 指针指向字符数组首地址
int sum = convert(p); // 调用转换函数
printf("%d", sum); // 输出最终结果
return 0;
}
/* 代码注意事项：
1. 安全性问题：gets()函数存在缓冲区溢出风险，建议改用fgets(s, sizeof(s), stdin)
2. 输入限制：只能正确处理纯数字字符串（如"123"）
3. 异常情况：
- 输入超过9个字符会导致缓冲区溢出
- 包含非数字字符（如"12a3"）将产生错误计算结果
- 空字符串会导致未定义行为（strlen=0，循环不执行，返回0）
4. 最大转换值：当输入"2147483647"时转换为INT_MAX，超过会溢出产生错误结果
*/