第1题：分离整数和小数
请编写函数fun,其功能是:分别求一个双精度数的整数部分和小数部分，并通过指针返回。
例如程序输入的数为：5104. 7583,则输出的整数部分是:5104,小数部分是0.758300。
#include <stdio.h>
void fun(double num,int *a,double *b){
*a=(int)(num);
*b=num-*a;
}
int main() {
double num;
int a;
double b;
printf("请输入浮点数num:");
scanf("%lf",&num);
fun(num,&a,&b);
printf("整数部分为为：%d\n",a);
printf("小数部分为为：%f\n",b);
return 0;
}
在C语言中，指针是一个变量，它存储的是另一个变量的内存地址，而不是值。通过使用指针，我们可以直接访问和操作存储在该地址的数据。
在给出的代码中，我们使用了两种类型的指针：int *和double *。
int *a：
- 这是一个指向整数的指针。在
fun函数中，它用于接收浮点数num的整数部分。当我们将num强制转换为int类型并赋值给*a时，我们实际上是将num的整数部分存储在由a指向的内存位置。- 在
main函数中，我们声明了一个整数变量a，并传递了它的地址（即&a）到fun函数中。这意味着fun函数可以通过这个地址来修改main函数中a的值。
double *b：
- 这是一个指向双精度浮点数的指针。在
fun函数中，它用于接收num的小数部分。由于小数部分仍然是浮点数，所以我们需要一个double类型的指针来存储它。- 我们通过将
num减去其整数部分（现在作为double处理，以避免整数除法）来得到小数部分，并将结果存储在*b中。- 在
main函数中，我们声明了一个双精度浮点数变量b，并传递了它的地址（即&b）到fun函数中。这样，fun函数可以通过这个地址来修改main函数中b的值。
使用指针的好处之一是，它们允许我们在函数之间传递大型数据结构（如数组或结构体）时，只需要传递它们的地址，而不是整个数据结构。这可以节省内存并提高效率。在这种情况下，我们使用了指针来修改main函数中的变量a和b，而不必将整个num值传递回main函数。
注意：当使用指针时，需要特别小心，确保不会访问无效的内存地址或修改不应该修改的数据。错误的指针使用可能导致程序崩溃或数据损坏。
第2题：统计单词的个数***
请编写函数fun,函数的功能是:统计一行字符串中单词的个数作为函数值返回。一行字符串在主函数中输入，规定所有单词由小写字母组成，单词之间由若干个空格隔开，一行的开始没有空格。
#include <stdio.h>
int fun(char *ss) {
int count = 0; // 单词计数
int inWord = 0; // 标志位，0表示当前不在单词中
// 遍历字符串
while (*ss != '\0') { // 当未到达字符串末尾时继续
if (*ss != ' ' && inWord==0) {
// 如果当前字符不是空格且不在单词中，开始新单词
inWord = 1;
count++;
} else if (*ss == ' ' && inWord ==1) {
// 如果当前字符是空格且在单词中，结束当前单词
inWord = 0;
}
ss++; // 移动到下一个字符
}
// 不需要额外的检查，因为在遇到字符串末尾的'\0'时，循环会自然结束
return count; // 返回单词总数
}
int main() {
char ss[] = "hi good world today news yes ";
printf("当前字符串内容为:\n%s\n", ss);
printf("单词的个数为：%d\n", fun(ss));
return 0;
}
主要思路：当前位置为字母，后一位置为空格或者’\0’，count++
inWord 是一个整型变量，用作一个标志位（flag），它的主要作用是跟踪当前是否正在处理一个单词。
注意字符串以"\0"结束
第3题：结构体***没明白
有一个很奇怪的车牌号，它是一个4位十进制数，是某一个数的平方数，且这4个数字从右至左一个比一个大。程序的功能是把这个车牌号找出来，部分程序已给出。
请编写函数fun,其功能是:将一个4位数的每一位数分离出来，
并依次存放在结构体变量成员中，通过函数值返回给主函数。
例如，一个4位数n为2579 ,则应把2放在res.m3中,把5放在res.m2中,把7放在res.m1中,把9放在res.m0中。
程序正确运行后的输出结果是:NO. is 1369
#include <stdio.h>
#include <math.h>
struct BITS {
int m3, m2, m1, m0;
};
struct BITS fun(int n) {
struct BITS res;
res.m0 = n % 10;
res.m1 = (n / 10) % 10;
res.m2 = (n / 100) % 10;
res.m3 = n / 1000;
return res;
}
int is_increasing(struct BITS bits) {
return bits.m0 < bits.m1 && bits.m1 < bits.m2 && bits.m2 < bits.m3;
}
int is_square(int num) {
int root = (int)sqrt(num);
return root * root == num;
}
int main() {
for (int i = 1000; i <= 9999; ++i) {
struct BITS bits = fun(i);
if (is_increasing(bits) && is_square(i)) {
printf("NO. is %d\n", i);
break; // 找到满足条件的数后，退出循环
}
}
return 0;
}
第4题：字符串逆转
请编写函数fun,其功能是将一例字字符串转换成与其逆向串面值相同的长整型整数。 可调用strlen函数求字符串的长度。
例如:在键盘输入字符串2345219, 函数返回长整型数9125432。
#include <stdio.h>
#include <string.h>
long fun(char *s) {
int i, n;
long a, r;
// 初始化变量
a = 0; // 用于存储当前字符转换为的数字
r = 0; // 用于累加逆序后的数值
n = strlen(s); // 获取字符串长度
// 从字符串的最后一个字符开始遍历到第一个字符
for (i = n - 1; i >= 0; i--) {
// 将字符转换为对应的数字（通过减去字符'0'的ASCII值）
a = *(s + i) - '0';
// 将之前的逆序数值乘以10，并加上当前字符对应的数字
r = r * 10 + a;
}
// 返回逆序后的长整型整数
return r;
}
int main() {
char input[100];
long result;
// 从键盘读取字符串
printf("请输入一个只包含数字的字符串: ");
scanf("%s", input);
// 调用fun函数并打印结果
result = fun(input);
printf("转换后的长整型数为: %ld\n", result);
return 0;
}
核心代码
for (i = n - 1; i >= 0; i- -) {
// 将字符转换为对应的数字（通过减去字符’0’的ASCII值）
a = *(s + i) - ‘0’;
// 将之前的逆序数值乘以10，并加上当前字符对应的数字
r = r * 10 + a;
}
第5题：统计字符串频率
请编写函数fun(charsp, intct),其功能是，对传给sp的字符串，分别统计两个相连 字母"ea"、“ou"和"iu"出现的次数(不能使用函数strstr()， 并将统计结果存入ct所指数组中。
例如:若字符串的内容为"abeaeafeeaoukgdoouuoioui fwieeotiu”,
则运行结果为3 ,3,1。
#include <stdio.h>
#include <string.h>
void fun(char *sp, int *ct) {
int i, len = strlen(sp);
ct[0] = 0;
ct[1] = 0;
ct[2] = 0;
for (i = 0; i < len - 1; i++) { // 注意这里的条件改为 i < len - 1
if (sp[i] == 'e' && sp[i + 1] == 'a') {
ct[0]++;
}
if (sp[i] == 'o' && sp[i + 1] == 'u') {
ct[1]++;
}
if (sp[i] == 'i' && sp[i + 1] == 'u') {
ct[2]++;
}
}
}
int main() {
char str[] = "abeaeafeeaoukgdoouuoioui fwieeotiu";
int count[3];
fun(str, count);
printf("ea: %d, ou: %d, iu: %d\n", count[0], count[1], count[2]);
return 0;
}
第6题：统计字符串频率
请编写函数fun,它的功能是:求出能整除形参x且不是偶数的所有整数，并按从小到大的顺序放在pp所指的数组中，这些除数的个数 通过形参n返回。
例如，若x中的值为:35,则有4个数符合要求，它们是:1,5,7,35。
#include <stdio.h>
// 函数声明：计算能整除x且不是偶数的所有整数，并存储在pp数组中，同时返回除数个数n
void fun(int x, int pp[], int *n) {
int i, k, j = 0; // 初始化变量：i用于循环遍历，k用于内部循环比较，j记录已找到的除数个数
// 遍历从1到x的所有整数，步长为2，以跳过偶数
for (i = 1; i <= x; i += 2) {
// 如果当前整数i能整除x，则它是一个除数
if ((x % i) == 0) {
// 将找到的除数i存入数组pp中，并增加j的计数
pp[j++] = i;
}
}
// 将找到的除数个数n赋值给形参指针n所指向的变量
*n = j;
// 使用冒泡排序对数组pp中的除数进行升序排序
for (i = 0; i < j - 1; i++) { // 外层循环，控制排序的轮数
for (k = i + 1; k < j; k++) { // 内层循环，比较相邻元素并进行交换
// 如果前一个元素大于后一个元素，则交换它们的位置
if (pp[i] > pp[k]) {
int temp = pp[i]; // 使用临时变量temp保存pp[i]的值
pp[i] = pp[k]; // 将pp[k]的值赋给pp[i]
pp[k] = temp; // 将temp的值赋给pp[k]，完成交换
}
}
}
}
int main() {
int x = 35; // 待检查的整数
int pp[100]; // 存储除数的数组，假设除数个数不超过100
int n; // 用于存储除数个数的变量
// 调用fun函数，找出所有符合条件的除数，并计算除数个数
fun(x, pp, &n);
// 打印所有找到的除数
printf("The divisors of %d that are not even are: ", x);
for (int i = 0; i < n; i++) {
printf("%d ", pp[i]);
}
printf("\n");
return 0;
}
第7题：删除重复的数
请编写函数fun,函数的功能是:删去一维数组中所有相同的数，使之只剩一个。数组中的数已按由小到大的顺序排列，函数返回删除 后数组中数据的个数。
例如，一维数组中的数据是：
2223445666677899 10 10 10ₒ删除后数组中的内容应该是:2 3 4 5 67 8 9 10ₒ
#include <stdio.h>
int fun(int a[], int *n) {
int i;
for (i = 0; i < *n - 1; ) {
if (a[i] == a[i + 1]) {
// 发现相邻元素相同，删除后面的元素
int j;
for (j = i + 1; j < *n; j++) {
a[j] = a[j + 1];
}
(*n)--; // 数组长度减一
} else {
// 如果没有找到相同的元素，则继续向后检查
i++;
}
}
return *n; // 返回删除后数组中的元素个数
}
int main() {
int a[] = {2, 2, 2, 3, 4, 4, 5, 6, 6, 6, 6, 7, 7, 8, 9, 9, 10, 10, 10};
int n = sizeof(a) / sizeof(a[0]); // 数组的元素个数
int remaining = fun(a, &n); // 调用函数删除重复元素，并获取剩余元素个数
// 打印删除后的数组内容
for (int i = 0; i < remaining; i++) {
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
由于数组已经按由小到大的顺序排列，如果发现相邻的元素相同，我们只需要将后面的元素向前移动，并减少数组的大小。
第8题：整理字符串
请编写函数fun,函数的功能是:将放在字符串数组中的M个字符串(每串的长度不超过N),按顺序合并组成一个新的字符串。
例如，字符串数组中的M个字符串为：
AAAA
BBBBBBB
CC
则合并后的字符串的内容应是:AAAABBBBBBBCCO
提示:strcat (a, b)的功能是将字符串b复制到字符串a的串尾上，成为一个新串。
#include <stdio.h>
#include <string.h>
#define M 3
#define N 20
void fun(char a[M][N], char *b) {
int i;
int b_len = 0; // 用于跟踪b数组当前长度
// 首先，初始化b为空字符串
b[0] = '\0';
// 遍历二维字符数组a的每一行
for (i = 0; i < M; i++) {
// 使用strcat将当前字符串追加到b
strcat(b + b_len, a[i]);
// 更新b的长度，以便下一次strcat可以正确追加
b_len += strlen(a[i]);
}
}
int main() {
char a[M][N] = {
"AAAA",
"BBBBBBB",
"CC"
};
// 分配足够的空间来存储合并后的字符串和结束符'\0'
char b[M * N + 1]; // 假设每个字符串都使用了N个字符的空间
fun(a, b);
printf("合并后的字符串是: %s\n", b);
return 0;
}
第9题：字符串转数字
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
long fun(char *s) {
int n = strlen(s);
long m = 0;
// 遍历字符串中的每个字符
for (int i = 0; i < n; i++) {
// 确保字符是有效的数字
if (s[i] < '0' || s[i] > '9') {
fprintf(stderr, "Invalid input: string contains non-digit characters\n");
exit(EXIT_FAILURE);
}
// 将字符转换为整数并累加到m上
m = m * 10 + (s[i] - '0');
}
return m;
}
int main() {
char str[50];
gets(str);
long num = fun(str);
printf("The number is: %ld\n", num);
return 0;
}
第10题：二维矩阵左下角置为0
#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#define MAX_N 100 // 定义n的最大值
// 函数定义，使数组左下半三角元素中的值全部置成0
void fun(int a[][MAX_N], int n) {
int i, j;
// 遍历方阵的每一个元素
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
// 判断当前元素是否位于左下半三角
if (i >= j) {
// 将左下半三角的元素置为0
a[i][j] = 0;
}
}
}
}
int main() {
int a[MAX_N][MAX_N], n, i, j;
// 询问用户需要几阶的方阵
printf("请输入需要几阶的方阵\n");
scanf("%d", &n);
// 初始化随机数生成器
srand(time(NULL));
// 为方阵填充随机数
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
a[i][j] = rand();
}
}
// 调用fun函数，将左下半三角元素置为0
fun(a, n);
// 打印修改后的方阵
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%-8d", a[i][j]);
}
printf("\n");
}
// 主函数正常结束，返回0
return 0;
}
第11题：四个数组成不同的三位数
请编写函数fun,其功能是:找出用1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数，然后把这些三位数按从小到大的顺序依次存入相应的数组xxx中，符合条件的个数由函数值返回。
#include <stdio.h>
int fun(int xxx[]) {
int i, j, l, k = 0;
for (i = 1; i <= 4; i++) { // 第一个数字可以是1到4
for (j = 1; j <= 4; j++) { // 第二个数字可以是1到4，但不能和第一个数字相同
if (j != i) {
for (l = 1; l <= 4; l++) { // 第三个数字可以是1到4，但不能和前两个数字相同
if (l != j && l != i) {
xxx[k++] = i * 100 + j * 10 + l; // 计算三位数并存入数组
}
}
}
}
}
return k; // 返回符合条件的个数
}
int main() {
int xxx[24]; // 数组大小至少为24，以存储所有可能的三位数
int count = fun(xxx); // 调用函数，并获取符合条件的个数
for (int i = 0; i < count; i++) {
printf("%d \n", xxx[i]); // 打印所有符合条件的三位数
}
printf("\n");
return 0;
}
第12题：回文数判断
请编写函数fun,函数的功能是:判断字符串是否为回文?若是，函数返回1,主函数中输出:YES;否则返回0,主函数中输出NO。
回文是指顺读和倒读都一样的字符串。
例如，字符串LEVEL是回文，而字符串123312就不是回文。
#include <stdio.h>
#include <string.h>
int fun(char *str) {
int count = strlen(str);
for (int i = 0; i < count / 2; i++) {
if (str[i] != str[count - i - 1]) {
return 0; // 发现不是回文，返回0
}
}
return 1; // 所有字符都匹配，是回文，返回1
}
int main() {
char str[100];
printf("请输入一个字符串: ");
scanf("%s", str); // 注意：%s不会读取空格，如果需要读取带空格的字符串，请使用其他方法
int result = fun(str);
if (result == 1) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
第13题：删除符号
假定输入的字符串中只包含字母和号。请编写函数fun,它的功能是:将字符串尾部的号全部删除，前面和中间的文号不删除。
例如，字符串中的内容为:ABCDEFG******,删除后，字符串中的内容应当是:*ABCDEFG。在编写函数时，不得使用C 语言提供的字符串函数。
#include <stdio.h>
void fun(char *a) {
int i, j, len;
// 第一次遍历找到字符串的原始长度
for (len = 0; a[len] != '\0'; len++);
// 从末尾开始向前查找，直到找到第一个非'*'字符
for (i = len - 1; i >= 0 && a[i] == '*'; i--);
// i现在指向第一个非'*'字符或字符串开头（如果所有字符都是'*'）
// 将i后面的所有字符都设置为'\0'
for (j = i + 1; j < len; j++) {
a[j] = '\0';
}
}
int main() {
char str[] = "****A*BC*DEF*G*******";
printf("原始字符串: %s\n", str);
fun(str);
printf("处理后的字符串: %s\n", str);
return 0;
}
第14题：交换数字
请编写函数void fun(int*dp, int n, int upordown),其功能是，找出dp所指数组中的
最小或最大值，并与其第1个元素交换。形参n为元素的个数，
形参upordown为查找标志:值为0时找最小值;值为1时找最大值。
#include <stdio.h>
void fun(int *dp, int n, int upordown) {
if (dp == NULL || n <= 0) {
// 如果dp为NULL或n小于等于0，则不执行任何操作
return;
}
int i, dorx = 0; // dorx用来存储最小或最大值的索引
if (upordown == 0) {
// 查找最小值
for (i = 1; i < n; i++) {
if (dp[dorx] > dp[i]) {
dorx = i;
}
}
} else if (upordown == 1) {
// 查找最大值
for (i = 1; i < n; i++) {
if (dp[dorx] < dp[i]) {
dorx = i;
}
}
} else {
// 如果upordown不是0或1，则不执行任何操作
return;
}
// 交换dp[0]和dp[dorx]的值
int temp = dp[0];
dp[0] = dp[dorx];
dp[dorx] = temp;
}
// 示例用法
int main() {
int dp[] = {5, 2, 9, 1, 5, 6};
int n = sizeof(dp) / sizeof(dp[0]);
printf("原始数组: ");
for (int i = 0; i < n; i++) {
printf("%d ", dp[i]);
}
printf("\n");
// 查找最小值并交换
fun(dp, n, 0);
printf("交换最小值后的数组: ");
for (int i = 0; i < n; i++) {
printf("%d ", dp[i]);
}
printf("\n");
// 查找最大值并交换
fun(dp, n, 1);
printf("交换最大值后的数组: ");
for (int i = 0; i < n; i++) {
printf("%d ", dp[i]);
}
printf("\n");
return 0;
}
1072
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
