43道C语言练习

江城暮

于 2021-04-14 15:42:13 发布

阅读量463

点赞数

分类专栏： C语言练习

本文链接：https://blog.csdn.net/qq_39087432/article/details/115700603

版权

C语言练习专栏收录该内容

8 篇文章 1 订阅

订阅专栏

有3个数据a, b, c，它们由键盘输入，编写程序将它们按从小到大排序。

#include<stdio.h>
#define swap(x,y) { int tmp; tmp = x; x = y; y = tmp; }
int main() {
	int a, b, c;

	printf("请输入a,b,c的值：");
	scanf("%d %d %d", &a, &b, &c);

	if (a <= b && a <= c)
	{
		if (b > c)
		{
			swap(b, c);
		}
	}

	if (b <= a && b <= c)
	{
		if (a <= c)
		{
			swap(a, b);
		}
		else
		{
			swap(a, b);
			swap(b, c);
		}
	}

	if (c <= a && c <= b)
	{
		if (b <= a)
		{
			swap(a, c);
		}
		else
		{
			swap(a, c);
			swap(b, c);
		}
	}

	printf("3个数由小到大依次为：%d, %d, %d.\n", a, b, c);
	system("pause");
	return 0;
}

给出一个不多于5位数的正整数，要求：（1）求出它是几位数；（2）分别输出每一位数字；（3）按逆序输出每一位数字。

#include<stdio.h>
#include<math.h>

int main() {
	int num;	//输入值
	int digit;	//输入位数
	int a, b, c, d, e;		//a：万，b：千，c：百，d：十，e：个

	printf("请输入一个不多于5位的正整数：");
	scanf("%d", &num);

	while (num > 99999 || num <= 0)
	{
		printf("输入数据不合法，请重新输入一个不多于5位的正整数：");
		scanf("%d", &num);
	}

	e = num % 10;	num /= 10;
	d = num % 10;	num /= 10;
	c = num % 10;	num /= 10;
	b = num % 10;	num /= 10;
	a = num % 10;

	if (a > 0)
	{
		printf("这是个5位数.\n");
		printf("每一位数字为：%d, %d, %d, %d, %d.\n", a, b, c, d, e);
		printf("逆序为：%d, %d, %d, %d, %d.\n", e, d, c, b, a);
	}
	else if (b > 0)
	{
		printf("这是个4位数.\n");
		printf("每一位数字为：%d, %d, %d, %d.\n", b, c, d, e);
		printf("逆序为：%d, %d, %d, %d.\n", e, d, c, b);
	}
	else if (c > 0)
	{
		printf("这是个3位数.\n");
		printf("每一位数字为：%d, %d, %d.\n", c, d, e);
		printf("逆序为：%d, %d, %d.\n", e, d, c);

	}
	else if (d > 0)
	{
		printf("这是个2位数.\n");
		printf("每一位数字为：%d, %d.\n", d, e);
		printf("逆序为：%d, %d.\n", e, d);
	}
	else
	{
		printf("这是个1位数.\n");
		printf("每一位数字为：%d.\n", e);
		printf("逆序为：%d.\n", e);
	}

	return 0;
}

编写程序，将20个数读入计算机，并统计出其中正数、负数和零的个数。

#include<stdio.h>
#include<math.h>

int main() {
	float num;	//输入数
	int positive = 0, negative = 0, zero = 0;

	printf("请输入20个数：\n");
	for (int i = 0; i < 20; ++i)
	{
		scanf("%f", &num);
		if (num > 0)
			++positive;
		else if (num < 0)
			++negative;
		else
			++zero;
	}

	printf("其中正数有%d个，负数有%d个，0有%d个。\n", positive, negative, zero);
	return 0;
}

编写程序，找到1到999之间能被3整除且至少有一位数字是5的所有整数，要求每行显示5个整数。

#include<stdio.h>
#include<math.h>

int main() {
	int cnt = 0;	//用于记录符合条件的个数

	printf("符合条件的整数有：\n");
	for (int num = 1; num <= 999; ++num)
	{
		if (num % 3 == 0)
		{
			//充分利用短路特性
			if (num % 10 == 5 || (num / 10) % 10 == 5 || num / 100 == 5)
			{
				printf("%-7d", num);
				++cnt;
				if (cnt % 5 == 0)
					printf("\n");
			}
		}
	}

	return 0;
}

编写程序，打印出所有的“水仙花数”。所谓“水仙花数”是指一个三位数，其各位数字里放和等于该数本身。

#include<stdio.h>
#include<math.h>

int main() {
	int a, b, c;	//a：百，b：十，c：个

	printf("符合条件的整数有：\n");
	for (int num = 100; num <= 999; ++num)
	{
		c = num % 10;
		b = (num / 10) % 10;
		a = num / 100;

		if (num == pow(a, 3) + pow(b, 3) + pow(c, 3))
		{
			printf("%-7d", num);
		}
	}
	return 0;
}

将一组数据存放在一维数组中，并将它们排好序，从键盘输入一个数，要求按原来的顺序将它插入到数组合适的位置上。

#include<stdio.h>
#include<stdlib.h>
#define capacity 20

int cmp(const void * x, const void * y) {
	return *(int*)x - *(int*)y;
}
int main() {
	int a[capacity], length = 0, tmp = 0;

	printf("请输入要排序的一组数（请以-1结束）：\n");
	while (1)
	{
		scanf("%d", &tmp);
		if (tmp == -1 || length == 20)
		{
			break;
		}
		else
		{
			a[length++] = tmp;
		}
	}

	//对输入的数据进行排序
	qsort(a, length, sizeof(a[0]), cmp);
	printf("排序后的数据为：\n");
	for (int i = 0; i < length; ++i)
	{
		printf("%2d", a[i]);
	}
	printf("\n");

	//fflush(stdin);
	printf("请输入要插入的数据：");
	scanf("%d", &tmp);
	int p = length;
	while (tmp < a[p-1])
	{
		a[p] = a[p-1];
		--p;
	}
	a[p] = tmp;

	printf("最后的数据为：\n");
	for (int i = 0; i < length+1; ++i)
	{
		printf("%2d", a[i]);
	}
	return 0;
}

输入一串字符串，以“$”结束，分别统计其中数字字符0，1，2，…，9出现的次数

#include<stdio.h>
#include<string.h>
#define capacity 128

int main() {
	char ch[capacity] = { 0 }, tmp;
	int length = 0, i;
	int n[10] = { 0 };

	printf("请输入字符串（请以$结束）：\n");
	while (1)
	{
		scanf("%c", &tmp);
		if (tmp == '$' || length == capacity)
		{
			break;
		}
		else
		{
			ch[length++] = tmp;
		}
	}

	for (i = 0; i < length; ++i)
	{
		if ('0' <= ch[i] && ch[i] <= '9')
			++n[ch[i] - '0'];
	}

	printf("\n统计数据为：\n");
	for (i = 0; i < 10; ++i)
	{
		printf("字符%d的个数有%d个；\n", i, n[i]);
	}
	return 0;
}

输入一串字符串，以"$"结束，分别统计各大写字母出现的次数，并按字母出现的多少输出（先输出出现次数最多的，次数相同的按字母表顺序输出，不出现的字母不输出）

#include<stdio.h>
#include<string.h>
#define capacity 128

int main() {
	char ch[capacity] = { 0 }, tmp;
	int length = 0, i, j;
	int n[26] = { 0 };

	printf("请输入字符串（请以$结束）：\n");
	while (1)
	{
		scanf("%c", &tmp);
		if (tmp == '$' || length == capacity)
		{
			break;
		}
		else
		{
			ch[length++] = tmp;
		}
	}

	for (i = 0; i < length; ++i)
	{
		if ('A' <= ch[i] && ch[i] <= 'Z')
			++n[ch[i] - 'A'];
	}

	int max;
	printf("\n统计数据为：\n");
	for (i = 0; i < 26; ++i)
	{
		max = 0;
		for (j = 0; j < 26; ++j)
		{
			if (n[j] > n[max]) max = j;
		}
		if (n[max] != 0)
		{
			printf("字符%c的个数有%d个；\n", max+'A', n[max]);
			n[max] = 0;		/*****notice*****/
		}
		else
		{
			break;
		}	
	}
	return 0;
}

用筛选法求100之内的素数

#include<stdio.h>
#include<math.h>
#define num 100
int main() {
	int n[num+1], i, j;

	for (i = 1; i <= num; ++i)
	{
		n[i] = 1;
	}

	for (i = 2; i <= sqrt(num); ++i)
	{
		if (n[i] == 1)
		{
			for (j = 2; i * j <= num; ++j)
				n[i*j] = 0;
		}
	}

	int cnt = 0;
	printf("100以内的素数为：\n");
	for (i = 2; i <= num; ++i)
	{
		if (n[i] == 1)
		{
			printf("%-5d", i);
			if (++cnt % 10 == 0)
				printf("\n");
		}
			
	}
	printf("\n");
	return 0;
}

用冒泡排序或选择排序法对20个数据进行排序后输出，并给出现在每个元素所对应的原来的次序

#include<stdio.h>
typedef int bool;
#define true 1
#define false 0
#define swap(x, y) { int t = x; x = y; y = t; }

int main() {
	int num[21], pos[21];
	int i, j;
	bool flag;

	printf("请输入20个数\n");
		for (i = 1; i < 21; ++i)
		{
			scanf("%d", &num[i]);
			pos[i] = i;
		}

	//冒泡排序
	for (i = 1; i != 20; ++i)
	{
		flag = false;
		for (j = 20; j >= i + 1; --j)
		{
			if (num[j] < num[j - 1])
			{
				flag = true;
				swap(num[j], num[j - 1]);
				swap(pos[j], pos[j - 1]);
			}
		}
		if (flag == false) break;
	}

	printf("\n最终结果为：\n");
	printf("顺序  原次序\n");
	for (i = 1; i < 21; ++i)
	{
		printf("%-6d %-3d\n", num[i], pos[i]);
	}
	return 0;
}

a为一个含有20个元素的数组，编写程序，把20个数据读入该数组，找出其中最大值和最小值，输出两者的值和相应的下标。最后将数组个元素按从大到小的顺序重新排序，并将其输出出来。

#include <stdio.h>
#define swap(x, y) { int tmp = x; x = y; y = tmp; }
int main() {
	int a[20];
	int max, max_pos, min, min_pos;
	int i, j, k, tmp;

	printf("请输入20个数：\n");
	for (i = 0; i < 20; ++i)
	{
		scanf("%d", &a[i]);
	}

	max = a[0];
	max_pos = 0;
	min = a[0];
	min_pos = 0;

	for (i = 1; i < 20; ++i)
	{
		if (a[i] > max)
		{
			max = a[i];
			max_pos = i;
		}
		if (a[i] < min)
		{
			min = a[i];
			min_pos = i;
		}
	}

	printf("\n最大值：%-4d, 位置：%-4d\n", max, max_pos + 1);
	printf("最小值：%-4d, 位置：%-4d\n", min, min_pos + 1);

	//简单选择排序，变量k用于记录每趟遍历中数据最大的元素下标
	for (i = 0; i < 20; ++i)
	{
		k = i;
		for (j = i + 1; j < 20; ++j)
		{
			if (a[j] > a[k])
				k = j;
		}
		if (k != i)
			swap(a[i], a[k]);
	}

	printf("\n将数据按递减顺序排序：\n");
	for (i = 0; i < 20; ++i)
	{
		printf("%-4d", a[i]);
	}

	return 0;
}

编写程序，不用标准函数strcat()，将两个字符串连接起来

#include <stdio.h>

int main() {
	char str1[50], str2[50];
	char str[100];
	int i, len1;

	printf("请输入字符串1:");
	scanf("%s", &str1);
	printf("请输入字符串2:");
	scanf("%s", &str2);

	for (i = 0; str1[i] != '\0'; ++i)
		str[i] = str1[i];

	len1 = i;

	for (i = 0; str2[i] != '\0'; ++i)
		str[len1 + i] = str2[i];

	str[len1 + i] = '\0';

	printf("\n连接后的字符串为：\n");
	puts(str);

	return 0;
}

编写程序，不用标准函数strlen，求出字符串的长度，并将长度打印出来

#include<stdio.h>

int main() {
	char a[100];
	int i = 0, length = 0;

	printf("请输入字符串：");
	scanf("%s", &a);

	while (a[i++] != '\0')
		++length;

	printf("输入字符串长度为：%d\n", length);
}

编写插入排序程序。以任意次序读入20个数据，将第一个数放入数组a的第一个元素中，以后读入的数应与已存入数组a中的数进行比较，确定它在从小到大的排列中的位置。将该位置及其后面的元素向后推移一个位置，将新读入的数据填入空出的位置中。这样在数组a中的数从事从小到大排列的。20个数据处理完后输出数组a。

#include<stdio.h>

int main() {
	int a[20];
	int i, j, k, tmp;

	//输入并排序
	printf("依次输入20个数：\n");
	printf("1:");
	scanf("%d", &a[0]);
	for (i = 1; i < 20; ++i)
	{
		//输入下一个数据
		printf("%d:", i + 1);
		scanf("%d", &tmp);

		j = i - 1;
		//如果新输入的数据大于有序序列的最后一个数，则直接赋值
		if (tmp > a[j])
		{
			a[i] = tmp;
		}
		else
		{
			//移动数据，直至找到正确的插入位置
			while (tmp < a[j] && j > -1)
			{
				a[j + 1] = a[j];
				--j;
			}

			a[j + 1] = tmp;
		}
	}

	printf("排序后的数组为:\n");
	for (i = 0; i < 20; ++i)
	{
		printf("%-2d  ", a[i]);
	}
	printf("\n");

	return 0;
}

从键盘上输入10个整数，去掉重复的。将其剩余的由大到小排序输出。

#include<stdio.h>

int main() {
	int num[10];	//记录从键盘输入的10个整数
	int res[10];	//记录去掉重复值的排序结果
	int i, j, k, length = 0;

	printf("请输入10个整数：\n");
	for (i = 0; i < 10; ++i)
	{
		scanf("%d", &num[i]);
	}

	for (i = 0; i < 10; ++i)
	{
		//当数组a中没有数据或新输入的数据大于有序序列的最后一个元素时，直接插入
		if (length == 0 || num[i] > res[length - 1])
		{
			res[length] = num[i];
			++length;
		}
		else
		{
			for (j = 0; j < length; ++j)
			{
				if (res[j] == num[i])
				{
					break;
				}
				else if (num[i] < res[j])
				{
					for (k = length; k > j; --k)
					{
						res[k] = res[k - 1];
					}
					res[j] = num[i];
					++length;
					break;
				}
				else
				{
					//新加入的数据比当前所指的数据大，则下标-1，继续循环
					continue;
				}
			}
		}
	}

	printf("结果是：\n");
		for (i = length - 1; i >= 0; --i)
		{
			printf("%d ", res[i]);
		}
	printf("\n");

	return 0;
}

编写一个函数，使从键盘上输入的一个字符串按反序存放，并在主函数中输入和输出该字符串。

#include<stdio.h>
#define CAPACITY 40		//输入字符串的最大长度
#define swap(x, y) { char c = x; x = y; y = c; }

void convert(char *str) {
	char tmp;
	int i = 0, length = 0;

	while (str[length] != '\0')
		++length;

	for (i = 0; i < length / 2; ++i)
	{
		swap(str[i], str[length - i - 1]);
	}
}

int main() {
	char str[CAPACITY];
	printf("请输入字符串：");
	scanf("%s", &str);

	convert(str);

	printf("求逆后的字符串为：");
	puts(str);

	return 0;
}

输入5名大学生4门功课的成绩。然后求出：
- 每个大学生的总分；
- 每门课程的平均分；
- 输出总分最高的学生的姓名和总分数。

#include<stdio.h>
#define NUM_OF_STU 5

typedef struct Student {
	char name[10];
	int course[4];
}Student, *pStruct;

void average(Student stu[], int number_of_courses) {
	float sum, avg;
	for (int i = 0; i < number_of_courses; ++i)
	{
		sum = 0;
		avg = 0;
		for (int j = 0; j < NUM_OF_STU; ++j)
		{
			sum += stu[j].course[i];
		}
		avg = sum / NUM_OF_STU;
        //6表示最小长度，小数点也占一位，2表示小数的精度
		printf("第%d门课程的平均分为%4.2f\n", i+1, avg);
	}
}

void sum(Student stu[], int number_of_courses) {
	int sum[NUM_OF_STU] = { 0 };
	int max_score = 0;
	char *first = stu[1].name;

	for (int i = 0; i < NUM_OF_STU; ++i)
	{
		for (int j = 0; j < number_of_courses; ++j)
		{
			sum[i] += stu[i].course[j];
		}

		if (sum[i] > max_score)
		{
			max_score = sum[i];
			first = stu[i].name;
		}

		//输出每个人的总分
		printf("%s的总分为%d\n", stu[i].name, sum[i]);
	}

	printf("\n第一名是%s，总分为%d\n", first, max_score);
}

int main() {
	Student stu[NUM_OF_STU];
	int i;

	printf("输入学生的姓名以及他们4门功课的成绩：\n");
	for (i = 0; i < NUM_OF_STU; ++i)
	{
		printf("%d:", i + 1);
		scanf("%s %d %d %d %d", &stu[i].name, &stu[i].course[0], &stu[i].course[1],
			&stu[i].course[2], &stu[i].course[3]);
	}
	printf("\n");

	//计算每门课程的平均分
	average(stu, 4);
	printf("\n");

	//计算每个大学生的总分并输出
	sum(stu, 4);

	return 0;
}

编写一个函数，输入一个十进制的数，输出相应的二进制数、八进制数、十六进制数。

#include<stdio.h>
#include<math.h>

int decToBin(int num, int bin[]) {
	int length = 0;

	while (num != 1)
	{
		bin[length] = num % 2;
		num = num / 2;
		++length;
	}
	bin[length] = 1;
	++length;

	return length;
}

void printBin(int bin[], int bin_length) {
	printf("\n二进制：");
	for (int i = bin_length - 1; i >= 0; --i)
	{
		printf("%d", bin[i]);
	}
	printf("\n\n");
}

int binToOct(int bin[], int oct[], int bin_length) {
	int i = 0, length = 0;

	while (i <= bin_length-1)
	{
		//以下条件语句在每次循环中只有一个会被执行
		if (i + 2 < bin_length-1)
		{
			if (bin[i] != 0)
				oct[length] += (int)pow(2, 0);

			if (bin[i + 1] != 0)
				oct[length] += (int)pow(2, 1);

			if (bin[i + 2] != 0)
				oct[length] += (int)pow(2, 2);

			i += 2;
		}
		else if (i + 1 <= bin_length-1)
		{
			if (bin[i] != 0)
				oct[length] += (int)pow(2, 0);

			if (bin[i + 1] != 0)
				oct[length] += (int)pow(2, 1);

			i += 1;
		}
		else
		{
			oct[length] = bin[i];
		}

		++length;
		++i;
	}

	return length;
}

void printOct(int oct[], int oct_length) {
	printf("八进制：");
	for (int i = oct_length - 1; i >= 0; --i)
	{
		printf("%d", oct[i]);
	}
	printf("\n\n");
}

int binToHex(int bin[], int hex[], int bin_length) {
	int i = 0, length = 0;
	while (i <= bin_length-1)
	{
		if (i + 3 <= bin_length-1)
		{
			if (bin[i] != 0)
				hex[length] += (int)pow(2, 0);

			if (bin[i + 1] != 0)
				hex[length] += (int)pow(2, 1);

			if (bin[i + 2] != 0)
				hex[length] += (int)pow(2, 2);

			if (bin[i + 3] != 0)
				hex[length] += (int)pow(2, 3);

			i += 3;
		}
		else if (i + 2 <= bin_length-1)
		{
			if (bin[i] != 0)
				hex[length] += (int)pow(2, 0);

			if (bin[i + 1] != 0)
				hex[length] += (int)pow(2, 1);

			if (bin[i + 2] != 0)
				hex[length] += (int)pow(2, 2);

			i += 2;
		}
		else if (i + 1 <= bin_length-1)
		{
			if (bin[i] != 0)
				hex[length] += (int)pow(2, 0);

			if (bin[i + 1] != 0)
				hex[length] += (int)pow(2, 1);

			i += 1;
		}
		else
		{
			hex[length] = bin[i];
		}

		++length;
		++i;
	}

	return length;
}

void printHex(int hex[], int hex_length) {
	char c = '\0';
	printf("十六进制：");
	for (int i = hex_length - 1; i >= 0; --i)
	{
		if (hex[i] < 10)
			printf("%d", hex[i]);
		else
			printf("%c", hex[i] - 10 + 'A');
	}
	printf("\n");
}

int main() {
	int num, i;
	printf("请输入一个十进制数：");
	scanf("%d", &num);

	int bin[100];	//用于存放二进制数
	int oct[50];	//用于存放八进制数
	int hex[20];	//用于存放十六进制数

	//初始化三个数组
	for (i = 0; i < 100; ++i) bin[i] = 0;
	for (i = 0; i < 50; ++i) oct[i] = 0;
	for (i = 0; i < 20; ++i) hex[i] = 0;

	//十进制转二进制
	int bin_length = decToBin(num, bin);

	//二进制转八进制
	int oct_length = binToOct(bin, oct, bin_length);

	//二进制转十六进制
	int hex_length = binToHex(bin, hex, bin_length);

	printBin(bin, bin_length);

	printOct(oct, oct_length);

	printHex(hex, hex_length);

	return 0;
}

用递归法，求n!（n>=0）

#include <stdio.h>

int factorial(int num) {
	if (num == 1)
		return 1;
	else
		return num * factorial(num - 1);
}

int main() {
	int num;

	printf("请输入一个正整数：");
	scanf("%d", &num);

	printf("%d! = %d\n", num, factorial(num));
}

编写一个函数digit(n, k)，其功能是返回数n的从右边开始的第k个数字的值。例如：digit(25469, 3) = 4，digit(724, 4) = 0.

#include <stdio.h>
#include <math.h>
#define MAX 1000

int digit(int n, int k) {
	int i;
	int remainder = n % 10;		//用于保存余数
	for (i = 1; i < k; ++i)
	{
		n = n / 10;
		remainder = n % 10;
	}
	return remainder;
}

int main() {
	int n, k;
	printf("请输入n和k的值：\nn = ");
	scanf("%d", &n);
	printf("k = ");
	scanf("%d", &k);

	printf("digit(%d, %d) = %d\n", n, k, digit(n, k));

	return 0;
}

编写一个用于回答星期几的函数，3个参数分别表示年、月、日，函数的输出为该年月日是星期几。

#include<stdio.h>

void enterDate(int * year, int * month, int * date) {
	do
	{
		printf("请输入不小于1970的年份：");
		scanf("%d", year);
	} while (*year < 1970);

	do
	{
		printf("请输入一个合法月份：");
		scanf("%d", month);
	} while (*month < 1 || *month > 12);

	do
	{
		printf("请输入一个合法日期：");
		scanf("%d", date);
		if (*month == 2)
		{
			if (*year % 4 == 0 && *year % 100 != 0 || *year % 400 == 0)
			{
				//闰年的2月
				if (1 <= *date && *date <= 29)
					break;
				else
					continue;
			}
			else
			{
				//平年的2月
				if (1 <= *date && *date <= 28)
					break;
				else
					continue;
			}
		}
		else if (*month == 4 || *month == 6 || *month == 9 || *month == 11)
		{
			//小月
			if (1 <= *date && *date <= 30)
				break;
			else
				continue;
		}
		else
		{
			//大月
			if (1 <= *date && *date <= 31)
				break;
			else
				continue;
		}
	} while (1);
}

int getDay(int year, int month, int date) {
	//已知1970年1月1日是星期四

	int v_year = 1970, v_month = 1;		//v_year, v_month用于控制循环
	int v_day = 0;		//v_day用于记录从1970年1月1日至输入日期经过的天数

	while (v_year < year)
	{
		if (v_year % 4 == 0 && v_year % 100 != 0 || v_year % 400 == 0)
		{
			//闰年
			v_day += 366;
		}
		else
		{
			//平年
			v_day += 365;
		}
		++v_year;
	}

	while (v_month < month)
	{
		if (v_month == 4 || v_month == 6 || v_month == 9 || v_month == 11)
		{
			//小月
			v_day += 30;
		}
		else if (v_month == 2)
		{
			if (v_year % 4 == 0 && v_year % 100 != 0 || v_year % 400 == 0)
			{
				v_day += 29;
			}
			else
			{
				v_day += 28;
			}
		}
		else
		{
			v_day += 31;
		}
		++v_month;
	}

	v_day += date - 1;
	return (v_day + 4) % 7;
}

int main() {
	int year = 0, month = 0, date = 0;

	enterDate(&year, &month, &date);

	//printf("%d %d %d", year, month, date);

	int day = getDay(year, month, date);

	printf("\n%d年%d月%d日是星期%d\n", year, month, date, day);

	return 0;
}

求给定的5个数中的最大值（用函数编制求3个数的最大值两次调用此函数）

#include<stdio.h>

int findMax(int x, int y, int z) {
	if (x < y)
		x = y;
	if (x < z)
		x = z;
	return x;
}

int main() {
	int a[5];
	int max;

	printf("请输入5个整数：\n");
	for (int i = 0; i < 5; ++i)
	{
		scanf("%d", &a[i]);
	}

	max = findMax(findMax(a[0], a[1], a[2]), a[3], a[4]);

	printf("最大的数为%d\n", max);
}

用递归的方法编写程序，输入一个非负整数，结果输出这个数的逆序十进制数。

#include<stdio.h>

void printInverse(int num) {
	if (num < 10)
	{
		printf("%d", num);
	}
	else
	{
		printf("%d", num % 10);
		printInverse(num / 10);
	}
}

int main() {
	int num;
	printf("请输入一个非负整数：");
	scanf("%d", &num);

	printf("逆序输出为：");
	printInverse(num);
	return 0;
}

设计下面两个函数：
- 函数readoctal()，读入八进制序列，转换成十进制正整数；
- 函数writeoctal()，将十进制正整数转换成相应的八进制数字序列，并打印出来。

#include<stdio.h>
#include<string.h>
#include<math.h>

int readOctal(char oct[]) {
	int i, tmp = 0;
	int length = strlen(oct);

	for (i = 0; i < length; ++i)
	{
		tmp += (int)(oct[length - i - 1] - '0') * pow(8, i);
	}
	return tmp;
}

char * writeOctal(int num) {
	int oct[50], length, i;

	//char res[50] = { 0 };		
    //在栈区申请的空间在函数结束后会被清理，因此res所指空间应当从堆区申请
	char * res = (int*)malloc(sizeof(char) * 50);

	//获得八进制数的逆序排列
	for (length = 0; num != 0; ++length, num /= 8)
	{
		oct[length] = num % 8;
	}

	for (i = 0; i < length; ++i)
	{
		res[i] = oct[length - i - 1] + '0';
	}
	res[length] = '\0';
	return res;
}

int main() {
	char oct[100];

	printf("请输入一个八进制序列：");
	scanf("%s", &oct);
	printf("转换为十进制数是：%d\n\n", readOctal(oct));

	int num;

	printf("请输入一个正整数：");
	scanf("%d", &num);
	printf("转换为八进制数是：%s\n", writeOctal(num));
	return 0;
}

变成实现查找字符串s2在字符串s1中第一次出现的位置，若找到则返回位置，否则返回0.

#include<stdio.h>
#include<string.h>

int match(char * s1, char * s2) {
	int i, j, offset = 0;
	int s1_length = strlen(s1), s2_length = strlen(s2);
	for (i = 0; i < s1_length - s2_length; ++i)
	{
		if (*(s1 + i) == *s2)
		{
			offset = i + 1;
			for (j = 1; j < s2_length; ++j)
			{
				if (*(s1 + i + j) != *(s2 + j))
					break;
			}
			if (j == s2_length)
				return offset;
		}
	}
	return 0;
}

int main() {
	char s1[20], s2[20];
	int pos;

	printf("请输入s1：\n");
	scanf("%s", s1);
	printf("请输入s2：\n");
	scanf("%s", s2);

	if (strlen(s1) < strlen(s2))
	{
		printf("s1中没有找到s2.\n");
		exit(0);
	}
	else
	{
		pos = match(s1, s2);
		if (pos)
		{
			printf("s2在s1中第一次出现的位置为：%d\n", pos);
			return 0;
		}
		else
		{
			printf("s1中没有找到s2.\n");
			exit(0);
		}
	}
}

函数expand(s, t)在把字符串s复制到字符串t时，将其中的换行符和制表符转换成可见的转义字符表示，即用\n表示换行符，用\t表示制表符，请用指针的方法实现。

#include<stdio.h>

void expand(char *str1, char * str2)
{
	//注意'\0'、'\t'、'\n'、'\\'都只占一个字符，其次对指针str1、str2的偏移不影响主函数中的s和t
	while (*str1 != '\0')
	{
		//str1非空
		if (*str1 == '\n')
		{
			*str2 = '\\';
			++str2;
			*str2 = 'n';
			++str2;
		}
		else if (*str1 == '\t')
		{
			*str2 = '\\';
			++str2;
			*str2 = 't';
			++str2;
		}
		else
		{
			*str2 = *str1;
			++str2;
		}
		++str1;
	}
	*str2 = '\0';
}

int main() {
	//极端情况下，输入的均是转义字符，那么每一个转义字符都将在t中占用2个字符的位置
	char s[16] = { 0 }, t[31] = { 0 };

	printf("请输入字符串s：\n");

	//scanf()读取匹配format(格式)字符串的输入. 当读取到一个控制字符, 它把值放置到下一个变量.
	//空白(tabs, 空格等等)会跳过.
	//scanf("%s", &s);

	//gets()函数从STDIN(标准输入)读取字符并把它们加载到str(字符串)里,直到遇到新行(\n)或到达EOF.
	//gets(s);

	for (int i = 0; i < 15; ++i)
	{
		scanf("%c", &s[i]);
	}
	s[15] = '\0';

	//将字符串s复制到t中
	expand(s, t);

	printf("转换后的字符串为：\n%s", t);

	return 0;
}

写一个函数getint，它把输入的一串数字字符转换为整数。

#include<stdio.h>
#include<string.h>
#include<math.h>

int getint(char * str, int length) {
	int num = 0;

	for (int i = length; i > 0; --i)
	{
		num += (*str - '0') * pow(10, i - 1);
		++str;
	}

	return num;
}

int main() {
	char str[16];
	int res = 0, length = 0, i;


loop:
	printf("请输入由数字字符组成的字符串：");
	scanf("%s", str);
	length = strlen(str);
	for (i = 0; i < length; ++i)
	{
		if (str[i] < '0' || str[i] > '9')
			goto loop;
	}

	res = getint(str, length);
	if (res)
		printf("结果是：%d", res);

	return 0;
}

写一个函数squeeze(s1, s2)，它删去字符串s1中与字符串s2中的任意字符相匹配的字符。

#include<stdio.h>
#include<string.h>

void squeeze(char * s1, char * s2) {
	int length1 = strlen(s1), length2 = strlen(s2);
	char *p1 = s1, *p2 = s2;
	int i, j, k = 0;

	for (i = 0; i < length1; ++i, ++p1)
	{
		for (j = 0; j < length2; ++j, ++p2)
		{
			if (*p1 == *p2)
				break;
		}

		if (j == length2)
		{
			*(s1 + k) = *p1;	/*****notice*****/
			++k;
		}
		p2 = s2;
	}
	*(s1 + k) = '\0';
}

int main() {
	char str1[16] = { 0 }, str2[16] = { 0 };

	printf("请输入字符串s1：");
	gets(str1);
	printf("请输入字符串s2：");
	scanf("%s", str2);

	squeeze(str1, str2);
	puts(str1);

	return 0;
}

用指针的方法实现三个字符串的排序输出，字符串排序的规则是：首先比较两个字符串的第1个字符，字符值比较大的那个字符串给两个字符串中的大者；如果相等，则比较第2个字符，依次类推。假设有字符串s1：“asd”，s2：“asc”，那么根据上述规则s1>s2.

#include<stdio.h>

int comp(char * s1, char * s2) {
	//s1,s2的偏移不影响调用函数的指针
	while (1)
	{
		if (*s1 == '\0' && *s2 == '\0')
		{
			return 0;
		}

		if (*s1 != '\0' && *s2 != '\0')
		{
			if (*s1 == *s2)
			{
				++s1;
				++s2;
			}
			else if (*s1 > *s2)
			{
				return 1;
			}
			else
			{
				return -1;
			}
		}

		if (*s1 == '\0')
			return -1;

		if (*s2 == '\0')
			return 1;
	}
}

void sort(char * s1, char * s2, char * s3, int order[]) {
	if (comp(s1, s2) > -1 && comp(s1, s3) > -1)
	{
		//s1最大
		order[0] = 1;
		if (comp(s2, s3) > -1)
		{
			//s3最小
			order[1] = 2;
			order[2] = 3;
		}
		else
		{
			//s2最小
			order[1] = 3;
			order[2] = 2;
		}
	}

	if (comp(s2, s1) > -1 && comp(s2, s3) > -1)
	{
		//s2最大
		order[0] = 2;
		if (comp(s1, s3) > -1)
		{
			//s3最小
			order[1] = 1;
			order[2] = 3;
		}
		else
		{
			//s1最小
			order[1] = 3;
			order[2] = 1;
		}
	}

	if (comp(s3, s2) > -1 && comp(s3, s1) > -1)
	{
		//s3最大
		order[0] = 3;
		if (comp(s1, s2) > -1)
		{
			//s2最小
			order[1] = 1;
			order[2] = 2;
		}
		else
		{
			//s1最小
			order[1] = 2;
			order[2] = 1;
		}
	}
}

int main() {
	char str1[20] = { 0 }, str2[20] = { 0 }, str3[20] = { 0 };
	int order[3] = { 0 };
	int i;

	printf("请输入三个字符串：\n");
	printf("s1 = ");
	scanf("%s", str1);
	printf("s2 = ");
	scanf("%s", str2);
	printf("s3 = ");
	scanf("%s", str3);

	sort(str1, str2, str3, order);

	for (i = 0; i < 3; ++i)
	{
		if (i != 2)
			printf("s%d > ", order[i]);
		else
			printf("s%d\n", order[i]);
	}

	return 0;
}

有一个字符串，包含n个字符。写一个函数，将此字符串中从第m个字符开始的全部字符复制成为另一个字符串。

#include<stdio.h>
#include<string.h>

void copy(char * s1, char * s2, int pos) {
	while (pos)		//找到要拷贝的位置
	{
		++s1;
		--pos;
	}

	while (*s1 != '\0')
	{
		*s2 = *s1;
		++s1;
		++s2;
	}

	*s2 = '\0';
}

int main() {
	char s1[20] = { 0 }, s2[20] = { 20 };
	int pos;

	printf("请输入字符串：");
	scanf("%s", s1);

	do
	{
		printf("请输入合法的拷贝位置：");
		scanf("%d", &pos);
	} while (strlen(s1) < pos);

	//将字符串s1第pos个位置后的字符复制给s2
	copy(s1, s2, pos);

	printf("拷贝后的字符串为：%s\n", s2);
	return 0;
}

用指针数组和指向指针的指针的方法实现对3个字符串的排序，并将结果输出。

#include<stdio.h>
#include<string.h>

void sort(char** p, int order[]) {
	int i, j, tmp;

	for (i = 0; i < 3; ++i)
	{
		for (j = i + 1; j < 3; ++j)
		{
			if (strcmp(*(p + i), *(p + j)) < 0)
			{
				tmp = order[i];
				order[i] = order[j];
				order[j] = tmp;
			}
		}
	}
}

int main() {
	int i;
	char **p;
	char *pstr[3];
	char str[3][20];
	int order[3];

	for (i = 0; i < 3; ++i)
	{
		pstr[i] = str[i];
		order[i] = i + 1;
	}

	printf("请输入字符串：\n");
	for (i = 0; i < 3; ++i)
	{
		printf("s%d：", i + 1);
		scanf("%s", pstr[i]);
	}

	p = pstr;

	sort(p, order);

	printf("比较的结果是：\n");
		for (i = 0; i < 3; ++i)
		{
			if (i != 2)
				printf("s%d > ", order[i]);
			else
				printf("s%d\n\n", order[i]);
		}
}

编写函数实现自己的strcat()，即实现两个字符串的合并

#include<stdio.h>
#include<string.h>

void catenate(char * str1, char *str2) {
	while (*str1 != '\0')
	{	
		++str1;
	}

	while (*str2 != '\0')
	{
		*str1 = *str2;
		++str1;
		++str2;
	}

	*str1 = '\0';
}
int main() {
	char str1[50] = { 0 }, str2[50] = { 0 };

	printf("请输入第一个字符串：");
	scanf("%s", str1);
	printf("请输入第二个字符串：");
	scanf("%s", str2);

	//将str2拼接在str1的后面，
	catenate(str1, str2);

	printf("合并后的字符串为：%s\n", str1);
	return 0;
}

简述结构体和数组的区别。
结构体是一种复杂的数据类型，它与数组的区别是：数组是相同类型的有序变量的集合，二机构提是不同类型的有序变量的集合。数组元素是同类型的，即同“质”的；结构体的成员是不同类型的，即异“质”的。
图书馆的图书检索卡上包括：书名（book_name），作者姓名（author），出版日期（publish_date），登录号（register_num），书价（price）等内容。根据这五项内容定义一个结构体类型（index_cards）.

typedef struct date
{
	int month;
	int day;
	int year;
}date;

typedef struct index_cards
{
	char book_name[40];
	char author[20];
	date publish_date;
	long register_num;
	float price;
}index_cards;

定义一个结构体变量（包括年、月、日）。计算该日在本年中是第几天。

#include<stdio.h>

typedef struct date
{
	int month;
	int day;
	int year;
}date;

int main() {
	date myDate;
	int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

	int i, cnt = 0;

loop:
	printf("请以‘年/月/日’格式输入一个合法日期：");
	scanf("%d/%d/%d", &myDate.year, &myDate.month, &myDate.day);

	if (myDate.year < 1)
		goto loop;

	if (myDate.month < 1 || myDate.month > 12)
		goto loop;

	if (myDate.month == 2)
	{
		if (myDate.year % 4 == 0 && myDate.year % 100 != 0 || myDate.year % 400 == 0)
		{
			//闰年
			if (myDate.day < 1 || myDate.day > 29)
				goto loop;
		}
		else
		{
			//平年
			if (myDate.day < 1 || myDate.day > 28)
				goto loop;
		}
	}
	else if (myDate.month == 4 || myDate.month == 6 || myDate.month == 9 || myDate.month == 11)
	{
		if (myDate.day < 1 || myDate.day > 30)
			goto loop;
	}
	else
	{
		if (myDate.day < 1 || myDate.day > 31)
			goto loop;
	}

	//开始计算天数
	if (myDate.year % 4 == 0 && myDate.year % 100 != 0 || myDate.year % 400 == 0)
	{
		days[2] += 1;
	}

	for (i = 1; i < myDate.month; ++i)
	{
		cnt = cnt + days[i];
	}

	cnt += myDate.day;
	printf("输入日期是该年的第%d天。\n", cnt);
	return 0;
}

使用结构体数组存放三个学生的学号、姓名、性别和三门单科成绩。输出总分最高的学生以及有一科或一科以上不及格的学生的各项数据。

#include<stdio.h>
#define N 3

typedef struct student
{
	long stu_no;
	char name[20];
	char sex;
	float score1;
	float score2;
	float score3;
}student;

int main() {
	int i, max_num = 0;			//max_num存放最高分学生下标
	float score, max_score;		//max_score存放总成绩最高分

	student stu[N];

	for (i = 0; i < N; ++i)
	{
		printf("请输入第%d个学生的信息：\n", i + 1);
		printf("学号：");
		scanf("%ld", &stu[i].stu_no);
		printf("姓名：");
		scanf("%s", &stu[i].name);
		printf("性别M/F：");
		scanf("%s", &stu[i].sex);
		printf("成绩1：");
		scanf("%f", &stu[i].score1);
		printf("成绩2：");
		scanf("%f", &stu[i].score2);
		printf("成绩3：");
		scanf("%f", &stu[i].score3);
	}

	//查找第一名学生信息
	max_score = stu[0].score1 + stu[0].score2 + stu[0].score3;
	for (i = 1; i < N; ++i)
	{
		score = stu[i].score1 + stu[i].score2 + stu[i].score3;
		if (score > max_score)
		{
			max_score = score;
			max_num = i;
		}
	}
	printf("总分最高的学生：学号：%ld, 姓名：%s, 性别：%c, 成绩1：%4.2f, 成绩2：%4.2f，成绩3：%4.2f\n\n",
		stu[max_num].stu_no, stu[max_num].name, stu[max_num].sex,
		stu[max_num].score1, stu[max_num].score2, stu[max_num].score3);

	//查找至少有一门成绩不及格学生信息
	printf("有课程不及格的学生:\n");
	printf("学号 姓名 性别 成绩1 成绩2 成绩3\n");
	for (i = 0; i < N; ++i)
	{
		if (stu[i].score1 < 60 || stu[i].score2 < 60 || stu[i].score3 < 60)
		{
			printf("%2ld   %s  %c   %4.2f %4.2f %4.2f\n", stu[i].stu_no, stu[i].name, stu[i].sex,
				stu[i].score1, stu[i].score2, stu[i].score3);
		}
	}
}

编写一个候选人得票的统计程序。设有n个候选人，每次输入一个的票的候选人的名字，要求最后输出每个人的投票结果。

#include<stdio.h>
#include<string.h>
#define N 5

typedef struct candidate
{
	char name[20];
	int vote;
}candidate;

int main() {
	candidate man[N] = { {"mike", 0},
						{"jacky", 0},
						{"rose", 0},
						{"jury", 0},
						{"peter", 0} };

	char votename[20];
	int i;

	printf("-----------------------------\n");
	for (i = 0; i < N; ++i)
	{
		printf("%s  ", man[i].name);
	}
	printf("\n-----------------------------\n");
	printf("根据以上候选人名单投票，并以\"end\"结束：\n");

	while (1)
	{
		scanf("%s", votename);
		for (i = 0; i < N; ++i)
		{
			if (strcmp(votename, man[i].name) == 0)
				++man[i].vote;		//记票
		}
		if (strcmp(votename, "end") == 0)
			break;
	}

	printf("-----------------------------\n");
	printf("统计结果为：\n");
		for (i = 0; i < N; ++i)
		{
			printf("name:%-10s vote:%d\n", man[i].name, man[i].vote);
		}
}

(1)设已定义

struct
{
	char c1;
	char c2;
}arr[2] = { {'a', 'b'}, {'c', 'd'} }, *p = arr;

请写出++p->c1和(++p)->c1的值。
答：++p->c1的值是b，(++p)->c1的值是c。

(2)设已定义

struct
{
	int num;
	char * name;
}arr[2] = { {1, "Li Lei"}, {2, "Han meimei"} }, *p;
p = arr;

请写出*p->name和(++p)->name的值。
答：p->name的值是Li lei，*(++p)->name的值是Han meimei。（实际上只能输出L和H）

写出下列程序的执行结果

#include<stdio.h>
struct two_ch
{
	char ch1;
	char ch2;
};

union struct_int
{
	int a;
	struct two_ch b;
}c;

void main()
{
	c.a = 0x4567;
	printf("integer a:%x\n", c.a);
	printf("char ch1:%c\n", c.b.ch1);
	printf("char ch2:%c\n", c.b.ch2);
	c.b.ch1 = 0x67;
	printf("integer a:%x\n", c.a);
	getchar();
}

答：执行结果为
integer a:4567
char ch1:g
char ch2:E
integer a:4567

编写一个程序，它把一个文件的内容复制到另一个文件上，在复制时把大写字母改为小写字母

#include<stdio.h>
#include<stdlib.h>

int main() {
	FILE *fp1, *fp2;
	char ch;

	fp1 = fopen("file", "r");
	if (fp1 == NULL)
	{
		printf("file文件打开失败！\n");
		exit(0);
	}

	fp2 = fopen("new_file", "w");
	if (fp2 == NULL)
	{
		printf("new_file文件打开失败！\n");
		exit(0);
	}

	ch = fgetc(fp1);
	while (ch != EOF)
	{
		if ('A' <= ch && ch <= 'Z')
		{
			ch = ch + 'a' - 'A';
		}
		fputc(ch, fp2);
		ch = fgetc(fp1);
	}

	fclose(fp1);
	fclose(fp2);
	printf("完成转换及复制！\n");
	return 0;
}

写一个比较两个文件的程序，打印出两个文件首次不同的行和字符的位置

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int comp(char * s1, char * s2) {
	int pos = 0;
	while (1)
	{
		if (s1[pos] == '\0' && s2[pos] == '\0')
		{
			return 0;
		}

		if (s1[pos] == '\0' || s2[pos] == '\0' || s1[pos] != s2[pos])
		{
			return pos + 1;
		}

		++pos;
	}
}

int main() {
	FILE *fp1, *fp2;
	char line1[50], line2[50];
	int line_num = 1, row_num = 1;

	fp1 = fopen("file1", "r");
	if (fp1 == NULL)
	{
		printf("file1文件打开失败！\n");
		exit(0);
	}

	fp2 = fopen("file2", "r");
	if (fp2 == NULL)
	{
		printf("file2文件打开失败！\n");
		exit(0);
	}

	while (!feof(fp1) && !feof(fp2))
	{
		//fscanf：遇到空格时不会再读入
		//fscanf(fp1, "%s", line1);
		//fscanf(fp2, "%s", line2);
		
		//fgets：当读到换行符或文件结束标记或读够size个字符时，停止读入。
		fgets(line1, 50, fp1);
		fgets(line2, 50, fp2);

		//比较读入的一行字符串，将不同位置返回row_num
		row_num = comp(line1, line2);

		if (row_num != 0)
		{
			break;
		}

		row_num = 1;
		++line_num;
	}

	fclose(fp1);
	fclose(fp2);

	printf("\n首次不同的位置是第%d行的第%d个字符处。\n", line_num, row_num);
	return 0;
}

有两个磁盘文件A和B，各存放一行字母，今要求把这两个文件中的信息合并（按字母顺序排列），输出到一个新文件C中去。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define swap(x, y) { char ch = x; x = y; y = ch; }

int main() {
	FILE *fp1, *fp2, *fp3;
	char buffer1[128] = { 0 }, buffer2[128] = { 0 };
	int length, i, j;		//length表示buffer中字符的长度

	fp1 = fopen("A", "r");
	if (fp1 == NULL)
	{
		printf("A文件打开失败！\n");
		exit(0);
	}

	fp2 = fopen("B", "r");
	if (fp2 == NULL)
	{
		printf("B文件打开失败！\n");
		exit(0);
	}

	//将A、B文件中的数据读入buffer中
	fgets(buffer1, 128, fp1);
	fclose(fp1);
	fgets(buffer2, 128, fp2);
	fclose(fp2);
	strcat(buffer1, buffer2);
	printf("A+B: %s\n", buffer1);

	length = strlen(buffer1);
	//对字符数组c进行冒泡排序
	for (i = 0; i < length; ++i)
	{
		for (j = length - 1; j >= i + 1; --j)
		{
			if (buffer1[j] < buffer1[j - 1])
			{
				swap(buffer1[j], buffer1[j - 1]);
			}
		}
	}


	fp3 = fopen("C", "w");
	if (fp2 == NULL)
	{
		printf("C文件打开失败！\n");
		exit(0);
	}
	printf("C: %s", buffer1);
	fputs(buffer1, fp3);
	fclose(fp3);

	return 0;
}

有一个班的学生，每个学生有7门功课的成绩，从键盘输入数据（包括：学号，姓名，性别，7门功课的成绩），计算出每个学生的平均成绩，将输入的数据及计算处的平均成绩输出到文件“student.dat”中。

#include<stdio.h>
#include<stdlib.h>
#define NUM 3
typedef struct student
{
	char id[10];		//学号
	char name[10];		//姓名
	char sex;			//性别
	float course[3];	//课程成绩
	float avg;			//平均成绩
}student;

int main() {
	int i, j;
	student stu[NUM];
	FILE * fp;

	fp = fopen("student.dat", "w");
	if (fp == NULL)
	{
		printf("student.dat文件打开失败！\n");
		exit(0);
	}

	for (i = 0; i < NUM; ++i)
	{
		printf("请输入第%d个学生的信息：\n", i + 1);
		printf("学号：");
		scanf("%s", &stu[i].id);
		printf("姓名：");
		scanf("%s", &stu[i].name);
		printf("性别：");
		scanf("%s", &stu[i].sex);
		for (j = 0; j < 3; ++j)
		{
			printf("课程%d：", j + 1);
			scanf("%f", &stu[i].course[j]);
		}

		stu[i].avg = (stu[i].course[0] + stu[i].course[1] + stu[i].course[2]) / 3;
		printf("\n");
	}

	//写入文件
	fprintf(fp, "学号 姓名 性别 课程1 课程2 课程3 平均成绩\n");
	printf("学号 姓名 性别 课程1 课程2 课程3 平均成绩\n");

	for (i = 0; i < NUM; ++i)
	{
		fprintf(fp, "%s %s %c %5.2f %5.2f %5.2f %5.2f\n", stu[i].id, stu[i].name, stu[i].sex, 
			stu[i].course[0],stu[i].course[1], stu[i].course[2], stu[i].avg);
		printf("%s %s %c %5.2f %5.2f %5.2f %5.2f\n", stu[i].id, stu[i].name, stu[i].sex, 
			stu[i].course[0],stu[i].course[1], stu[i].course[2], stu[i].avg);
	}

	fclose(fp);
	return 0;
}

江城暮

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
43道C语言练习

有3个数据a, b, c，它们由键盘输入，编写程序将它们按从小到大排序。#include<stdio.h>#define swap(x,y) { int tmp; tmp = x; x = y; y = tmp; }int main() { int a, b, c; printf("请输入a,b,c的值："); scanf("%d %d %d", &a, &b, &c); if (a <= b && a <= c) {.
复制链接

扫一扫

专栏目录