807编程题(可回看)

已于 2022-09-19 22:00:28 修改
阅读量242 收藏
点赞数 1
分类专栏： C 文章标签： c语言
于 2021-11-18 16:44:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45218721/article/details/121291340
版权

将从键盘读入的一个十六进制字符串转换成一个十进制数后输出。注意:
1.可以只考虑转换成的十进制大小不会超过 long int 型所能表示的最大数。
2. 只需处理正数，不处理负数。
3. 输入的字母可以是大写也可以小写。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<math.h>
#include<string.h>

//十六进制数据向十进制数据的转换
long int hexTodec(char str[], int* p)//这里的p代指main函数里面的flag标识
{
	int i;
	long int res = 0;

	//先判断，再计算
	for (i = 0; str[i] != '\0'; i++)
	{
		if (str[i] >= '0' && str[i] <= '9')
		{
			*p = 1;
		}
		else if (str[i] >= 'A' && str[i] <= 'F' || str[i] >= 'a' && str[i] <= 'f')
		{
			*p = 1;
		}
		else
		{
			*p = 0;
			break;
		}
	}

	if (1 == *p)
	{
		//符合判断条件则开始进行向十进制数据的转换
		int len = strlen(str);
		int m0 = 0;

		for (i = len - 1; i >= 0; i--)
		{
			if (str[i] >= '0' && str[i] <= '9')
			{
				res += (long)((str[i] - '0') * pow(16, m0));
				m0++;
			}
			else if (str[i] >= 'A' && str[i] <= 'F')
			{
				res += (long)((str[i] - 'A' + 10) * pow(16, m0));
				m0++;
			}
			else if (str[i] >= 'a' && str[i] <= 'f')
			{
				res += (long)((str[i] - 'a' + 10) * pow(16, m0));
				m0++;
			}
		}
	}

	return res;
}

int main()
{
	char str[20];
	int flag;	//标识数据是否合法，0表示非法
	long int result;

	printf("请输入十六进制的数据-->");
	gets_s(str);
	result = hexTodec(str, &flag);
	if (0 == flag)
	{
		printf("输入的非十六进制数据，不能正常转换为十进制数据。\n");
	}
	else
	{
		printf("\n转换数：%s\t\t转换结果：%ld\n", str, result);
	}
	printf("\n");
	return 0;
}

将读入的字符串 s1、s2 分别调用自定义函数 myswap() 反转，
然后调用自定义函数 merge() 将 s1、s2 按排列的顺序交叉合并到 s3 中，
s1 或 s2 中过长的剩余字符接在 s3 的尾部。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<string.h>
#define N 100

/*
	程序的功能是:
	将读入的字符串 s1、s2 分别调用自定义函数 myswap() 反转，
	然后调用自定义函数 merge() 将 s1、s2 按排列的顺序交叉合并到 s3 中，
	s1 或 s2 中过长的剩余字符接在 s3 的尾部。

	输入:abcdefg
		 1234
*/

//字符串的反转函数
char* reverseString(char* str)
{
	int i, j, len;
	char temp[N];

	len = strlen(str);

	for (i = 0,j = len - 1; i < len; i++, j--)
	{
		temp[j] = *(str + i);
	}
	//添加结束符
	temp[len] = '\0';
	strcpy(str, temp);

	return str;
}

//字符串交叉合并函数
char* mergeStr(char* strA, char* strB, char* strC)
{
	int i, j;
	int len1 = strlen(strA), len2 = strlen(strB);

	for (i = 0, j = 0; strA[i] != '\0' && strB[i] != '\0'; i++, j += 2)
	{
		strC[j] = strA[i];
		strC[j+1] = strB[i];
	}

	if (len1 > len2)
	{
		for (; strA[i] != '\0'; i++, j++)
		{
			strC[j] = strA[i];
		}
	}
	else
	{
		for (; strB[i] != '\0'; i++, j++)
		{
			strC[j] = strB[i];
		}
	}
	strC[j] = '\0';

	return strC;
}

int main()
{
	char strA[N], strB[N], strC[N];

	printf("请输入字符串A-->");
	gets_s(strA);
	printf("请输入字符串B-->");
	gets_s(strB);

	printf("\n字符串A的反序输出为-->%s",reverseString(strA));
	printf("\n字符串B的反序输出为-->%s",reverseString(strB));
	printf("\n");

	printf("\n字符串A、B的交叉合并输出为-->%s", mergeStr(strA,strB,strC));
	printf("\n");
	return 0;
}

在这里插入图片描述

n(3 < n < 200，从键盘读入)个学生围成一圈报数(本身从 1 到 n 顺序编学号)，
从第一个人开始顺序报 1，2，3，1，2，3，…;凡报到 3 的人退出圈子
要求根据输入 n 的值，输出每次退出的学生的学号， 并且找出最后一个留在圈子中的学生的学号。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<malloc.h>
#define M 3

/*
	n(3 < n < 200，从键盘读入)个学生围成一圈报数(本身从 1 到 n 顺序编学号)，
	从第一个人开始顺序报 1，2，3，1，2，3，...;凡报到 3 的人退出圈子
	要求根据输入 n 的值，输出每次退出的学生的学号，
	 并且找出最后一个留在圈子中的学生的学号。
*/

//定义单链表结点类型
typedef struct Node
{
	int data;				//数据域
	struct Node* next;		//指针域
}delNode;


//剔除相应结点，保留最后留下的那位
void  remain(int n)
{
	//利用尾插法建立单链表
	delNode* head, * tail;
	int i, j;

	head = tail = (delNode*)malloc(sizeof(delNode));	//分配结点空间

	//为节点编号
	for (i = 1; i < n; i++)
	{
		tail->data = i;
		tail->next= (delNode*)malloc(sizeof(delNode));
		tail = tail->next;		//移动尾指针
	}

	tail->data = i;
	//构成循环单链表(不需判断是否为表尾，在任意一个位置上的插入和删除操作是等价的)
	tail->next = head;		

	for (i = 1; i < n; i++)
	{
		//等于3则退出
		for (j = 1; j < M; j++)
		{
			tail = head;
			head = head->next;
		}
		tail->next = head->next;	//删除报数为3的结点

		printf("第%d个出去的是-->%d号\n",i,head->data);
		free(head);
		head = tail->next;
	}

	i = head->data;
	printf("\n  最后留下的是-->%d号\n", head->data);
	free(head);
}

int main()
{
	int num;
	do
	{
		printf("请输入3-200的n:  ");
		scanf("%d", &num);

	} while (num < 3 || num>200);
	printf("\n");
	remain(num);
	printf("\n");
	return 0;
}

在这里插入图片描述

在数组 array 中有 n 个整数，使其前面各数顺序向 后移 m(0 ≤ m ≤ n)个位置，让最后 m 个数变成最前面的 m 个数，编写该函数。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 10

/*
	在数组 array 中有 n 个整数，使其前面各数顺序向后移 m(0 ≤ m ≤ n)个位置，
	最后 m 个数变成最前面的 m 个数，编写该函数。

*/

//输入数组元素
void dataInput(int* num, int n)
{
	int i;
	printf("\n请输入%d个整型数据： \n", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", (num + i));
	}
}

//输出数组元素
void dataOutput(int* num, int n)
{
	int i;
	for (i = 0; i < n; i++)
	{
		printf("%4d", *(num + i));
	}
}

//移动后m个数变为前m个数
/*
	先将后m个数进行移动，再依次向后移动没有变换的数据，
	最后再让前面空出来的m个位置依次填入后m个数
*/
void moveDeal(int* num, int n, int m)
{
	int i, j, * p, count = 0;

	p = (int *)malloc(m * sizeof(int));		//为要进行移动的m个数开辟空间

	//直接将后m个数变成前m个数，相应位置数据对换，改变指针的指向
	for (i = n - m, j = 0; i <= n - 1; i++, j++)	//注意等号
	{
		*(p + j) = *(num + i);
	}

	//向后移动没被纳入移动范围的数据
	for (i = n - 1 - m, j = n - 1; i >= 0; i--, j--)
	{
		//让空出的最后一个位置接纳开始移动的前一个数据
		*(num + j) = *(num + i);
	}

	//让原数组的指针指向移动的新数据指针处
	for (i = 0; i < m; i++)
	{
		*(num + i) = *(p + i);
	}
	free(p);
}

int main()
{
	int* data;	//目的是为data数组动态分配存储空间
	int num, m;

	printf("请输入数组元素个数num = ");
	scanf("%d", &num);
	
    //根据输入的num大小来为此数组分配存储空间
	data = (int *)malloc(num * sizeof(int));		
	
	if (NULL == data)
	{
		printf("结点空间分配失败!\n");
		exit(1);
	}

	dataInput(data, num);
	printf("\n原数组元素-->");
	dataOutput(data, num);

	printf("\n\n请输入要移动的个数m = ");
	scanf("%d", &m);

	moveDeal(data, num, m);
	printf("\n新数组元素-->");
	dataOutput(data, num);
	printf("\n");
	return 0;
}

在这里插入图片描述

程序的功能是:
调用自定义函数 creat() 读入第一部分学生信息建立链表 A
调用自定义函数 creat() 读入第二部分学生信息建立链表 B，每个链表中的节点包括学号、成绩;
然后调用自定义函数 merge()将两个链表以节点的学号升序合并为一个链表 C。
三个链表的内容均调用自定义函数 print() 输出在屏幕上。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(struct Student)

/*
	程序的功能是:
	调用自定义函数 creat() 读入第一部分学生信息建立链表 A
	调用自定义函数 creat() 读入第二部分学生信息建立链表 B，
	每个链表中的节点包括学号、成绩;
	然后调用自定义函数 merge()将两个链表以节点的学号升序合并为一个链表 C。
	三个链表的内容均调用自定义函数 print() 输出在屏幕上。

	思路梳理：
		1. 建立所需结构体-->确立一个用来计数的全局变量sum
		2. 在main函数里面写清楚输出大概模型
		3. 建立各种链表所需函数：创建链表、输出链表数据、
		   按照某项来进行排序合并多个链表生成新的链表
*/

struct Student
{
	int num;
	float score;
	struct Student* next;
};

int sum = 0;

//相关调用函数声明
struct Student* creatDataList();
void printDataList(struct Student* stu);
struct Student* mergeNumRise(struct Student* stuA, struct Student* stuB);


int main()
{
	struct Student* stuA, * stuB, * stuC;		//注意不要忘写负号

	printf("请输入链表A的数据(学号 成绩)，输入(0 0)表示结束输入\n");
	stuA = creatDataList();
	printf("\n请输入链表B的数据(学号 成绩)，输入(0 0)表示结束输入\n");
	stuB = creatDataList();


	printf("\n链表A的信息如下：\n");
	printf("学号   成绩\n");
	printDataList(stuA);

	printf("\n链表B的信息如下：\n");
	printf("学号   成绩\n");
	printDataList(stuB);

	stuC = mergeNumRise(stuA, stuB);
	printf("\n两个链表总计%d位学生.\n", sum);
	printf("按照学号升序排序新生成的链表如下：\n");
	printf("\n学号   成绩\n");
	printDataList(stuC);
	printf("\n");

	return 0;
}


//创建链表
struct Student* creatDataList()
{
	struct Student* head, * p1, * p2;
	int flag = 0;

	head = p1 = p2 = (struct Student*)malloc(LEN);

	/*
		这里选择利用p1来读取输入的数据，确立结束输入的判断依据
	*/
	while (1)
	{
		sum++;
		printf("NO . %d-->", sum);
		scanf("%d %f", &p1->num, &p1->score);

		if (p1->num == 0 && p1->score == 0)
		{
			break;
		}

		//判定链表头结点是否为空，若为空则将让head = p1;
		//若不为空则让另外一个结构体指针p2的next指针指向p1
		if (head == NULL)
		{
			head = p1;
		}
		else
		{
			p2->next = p1;
		}

		//
		p2 = p1;
		p1 = (struct Student*)malloc(LEN);
		flag = 1;
	}

	sum--;				//减去输入0 0 的那项计数
	p2->next = NULL;	//结束数据的输入

	if (0 == flag)
	{
		return NULL;
	}

	return head;		//-------->为啥这里得返回head呀，
}

//打印链表数据
void printDataList(struct Student* stu)
{
	while (stu != NULL)
	{
		printf("%-5d  %.1f\n", stu->num, stu->score);
		stu = stu->next;
	}
}

//合并两个链表数据(按照学号信息升序排序)
struct Student* mergeNumRise(struct Student* stuA, struct Student* stuB)
{
	int i, temp_num;
	float temp_score;
	struct Student* head, * p;

	if (stuA == NULL && stuB == NULL)
	{
		return NULL;
	}
	else if (stuA != NULL && stuB == NULL)
	{
		head = stuA;
	}
	else if (stuA == NULL && stuB != NULL)
	{
		head = stuB;
	}
	else   
	{
		//两个链表均不为空，便从链表A依次遍历到链表B
		head = p = stuA;

		while (p->next != NULL)
		{
			p = p->next;
		}
		p->next = stuB;
	}

	for (i = 1; i < sum; i++)
	{
		p = head;
		while (p->next != NULL)
		{
			if (p->num > p->next->num)
			{
				temp_num = p->num;
				p->num = p->next->num;
				p->next->num = temp_num;

				temp_score = p->score;
				p->score = p->next->score;
				p->next->score = temp_score;
			}
			p = p->next;
		}
	}

	return head;
}

在这里插入图片描述

程序的功能是:
先从键盘上读入节点数 n，再调用自定义函数 creatlink() 从键盘读入每个 节点的数据、 建立链表，
接着调用自定义函数 printlink() 输出链表内容，
然后调用自定义函数 delodd() 实现删除所有的值为奇数的节点，
最后调用自定义函数 printlink() 输出链表中余下的节点。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(struct Link)

/*
	程序的功能是:
	先从键盘上读入节点数 n，
	再调用自定义函数 creatlink() 从键盘读入每个节点的数据、 建立链表，
	接着调用自定义函数 printlink() 输出链表内容，
	然后调用自定义函数 delodd() 实现删除所有的值为奇数的节点，
	最后调用自定义函数 printlink() 输出链表中余下的节点。

*/

struct Link
{
	int data;
	struct Link* next;
};

void printDataLink(struct Link* head);
struct Link* cratDataLink(int n);
struct Link* delOddsNode(struct Link* head);


int main()
{
	struct Link* head;
	int n;

	printf("请输入结点数 n = ");
	scanf("%d", &n);
	
	head = cratDataLink(n);
	printf("\n原链表数据为：\n");
	printDataLink(head);


	printf("\n删除值为奇数的节点后的链表为:\n");
	head = delOddsNode(head);
	printDataLink(head);
	printf("\n");

	return 0;
}

//创建链表
struct Link* cratDataLink(int n)
{
	struct Link* head, * p1, * p2;
	int i;

	if (0 == n)
	{
		return NULL;
	}
	head = p1 = p2 = (struct Link*)malloc(LEN);

	printf("\n请输入%d个整型数据：\n", n);
	for (i = 1; i <= n; i++)
	{
		scanf("%d", &p1->data);
		if (NULL == head)
		{
			head = p1;
		}
		else
		{
			p2->next = p1;
		}
		p2 = p1;
		p1 = (struct Link*)malloc(LEN);
	}
	p2->next = NULL;

	return head;
}

//打印链表数据
void printDataLink(Link* head)
{
	while (head !=NULL)
	{
		printf("%d-->", head->data);
		head = head->next;
	}
	printf("NULL\n");
}

//删除data为奇数的结点
struct Link* delOddsNode(struct Link* head)
{
	struct Link* p1, * p2;

	if (head == NULL)
	{
		return head;
	}

	p1 = head->next;
	p2 = head;

	while (p1!=NULL)
	{
		if (p1->data % 2 != 0)
		{
			p2->next = p1->next;
			free(p1);
			p1 = p2->next;
		}
		else
		{
			p2 = p1;
			p1 = p1->next;
		}
	}

	//若是头结点为奇数
	if (head->data % 2 != 0)
	{
		p2 = head;
		head = head->next;
		free(p2);
	}

	return head;
}

在这里插入图片描述

一个长度不超过 199 的字符串，字符串中只含字母和空格，空格用于分隔单词。
请将字符串中用空格分隔的单词在屏幕上输出来。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#define MAXSIZE 200

/*
	程序的功能是:
	一个长度不超过 199 的字符串，字符串中只含字母和空格，
	空格用于分隔单词。
	请将字符串中用空格分隔的单词在屏幕上输出来。
*/

int printWord(char* str, char** Pstr);


int main()
{
	char str[MAXSIZE], * pStr[MAXSIZE];
	int i, count;


	printf("请输入一行字符串(只包含字母与空格)-->");
	gets_s(str);

	count = printWord(str, pStr);
	printf("\n总计%d个单词，其输出如下：\n", count);

	for (i = 0; i < count; i++)
	{
		printf("%s--", pStr[i]);
	}
	printf("\n");
	return 0;
}


//输出用空格分隔开的单词
int printWord(char* str, char** Pstr)
{
	int count = 0, flag = 0;

	//利用指针数组记录单词的起始位置，把字符串中单词结束后的空格改为'\0'
	while (*str != '\0')
	{
		if (*str == ' ')
		{
			if (flag != 0)
			{
				*str = 0;
				flag = 0;
			}
		}
		else if (flag == 0)   //flag=0代表的是当前读取的是字母
		{
			flag = 1;
			*(Pstr + count) = str;
			count++;
		}
		str++;
	}

	return count;
}

在这里插入图片描述

程序的功能是:
从键盘读入 5 行 9 列整数保存到二维数组中，调用用户自定义函数查找数组中最大元素(约定只考虑仅有一个最大的情况)及其所在位置的行下标、列下标。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#define ROW 5
#define COLUMN 9

/*
	程序的功能是:
	从键盘读入 5 行 9 列整数保存到二维数组中，
	调用用户自定义函数查找数组中最大元素
	(约定只考虑仅有一个最大的情况)及其所在位置的行下标、列下标。
*/

void dataInput(int(*num)[COLUMN], int m, int n);
void dataOutput(int(*num)[COLUMN], int m, int n);
void searchMaxNum(int(*num)[COLUMN], int m, int n, int* Pmax, int* PmaxRow, int* PmaxCol);

int main()
{
	int data[ROW][COLUMN] = {
		{72,22,77,62,2,83,12,52,32},
		{75,35,74,65,5,287,25,55,15},
		{76,36,86,66,6,84,26,56,16},
		{13,33,53,3,963,43,23,45,181},
		{17,27,57,7,67,47,821,45,37}
	};
	int max, max_i, max_j;

	//dataInput(data, ROW, COLUMN);
	dataOutput(data, ROW, COLUMN);

	searchMaxNum(data, ROW, COLUMN, &max, &max_i, &max_j);
	printf("\nMax = %d\ni = %d\nj = %d", max, max_i, max_j);
	printf("\n");
	return 0;
}

//指针法寻找数组最大元素及下标
void searchMaxNum(int(*num)[COLUMN], int m, int n, int* Pmax, int* PmaxRow, int* PmaxCol)
{
	int i, j;

	//对数据初始化
	*Pmax = num[0][0], * PmaxRow = 0, * PmaxCol = 0;

	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			if (*(*(num + i) + j) > *Pmax)
			{
				*Pmax = *(*(num + i) + j);
				*PmaxRow = i + 1;
				*PmaxCol = j + 1;
			}
		}
	}
}

//数组元素输入
void dataInput(int(*num)[COLUMN], int m, int n)
{
	int i, j;

	printf("请输入%d行%d列数据： \n", m, n);
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", (*(num + i) + j));
		}
	}
}

//数组元素输出
void dataOutput(int(*num)[COLUMN], int m, int n)
{
	int i, j;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			printf("%6d", *(*(num + i) + j));	//注意用指针写数据的写法
		}
		printf("\n");
	}
}

运行结果

程序的功能是:
已知一学生信息结构体，从键盘输入一个整数 m，调用子函数 alloc_memery() 动态分配 m 个结构体存储空间，并将每个结构体的学号成员变量依次初始化为 1 - m。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(struct STUDENT)

/*
	程序的功能是:
	已知一学生信息结构体，从键盘输入一个整数 m，
	调用子函数 alloc_memery() 动态分配 m 个结构体存储空间，
	并将每个结构体的学号成员变量依次初始化为 1 ~ m。

*/

//将定义的结构体重新命名为STUD	
typedef struct STUDENT
{
	int stuId;				//学号
	char stuName[12];		//姓名
	float score;			//成绩
}STUD;


STUD* allocMemory(int m);

int main()
{
	int m, i;
	STUD* pStu;

	printf("请输入m = ");
	scanf("%d", &m);

	pStu = allocMemory(m);
	if (NULL != pStu)
	{
		printf("\n分配成功，学号依次初始化为：\n");
		for (i = 0; i < m; i++)
		{
			if (pStu[i].stuId == m)
			{
				printf("%d\n", m);
			}
			else
			{
				printf("%d-->", pStu[i].stuId);
			}
		}
		free(pStu);
	}
	else
	{
		printf("\n分配失败！\n");
	}
	printf("\n");
	return 0;
}


//动态分配存储空间
STUD* allocMemory(int m)
{
	//要为其结构体分配空间，首先得声明一个结构体变量
	STUD* Pstu;
	int i;

	Pstu = (STUD*)malloc(m * LEN);

	if (NULL == Pstu)
	{
		return Pstu;
	}

	//将每个结构体的学号成员变量依次初始化，1++
	for (i = 0; i < m; i++)
	{
		(Pstu + i)->stuId = i + 1;
	}

	return Pstu;
}

在这里插入图片描述

程序的功能是:
有五个学生，每个学生的数据包括学号、姓名(最长19字节)、三门课的成绩，
从键盘输入五个学生的数据，并计算每个学生的平均成绩，
最后显示最高平均分的学生的信息(包括学号,姓名, 三门课的成绩,平均分数)。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#define N 5
/*
	程序的功能是:
	有五个学生，每个学生的数据包括学号、姓名(最长19字节)、三门课的成绩，
	从键盘输入五个学生的数据，并计算每个学生的平均成绩，
	最后显示最高平均分的学生的信息(包括学号,姓名, 三门课的成绩,平均分数)。
*/

typedef struct  Student
{
	char name[20];
	int num;
	float score1, score2, score3, ave;
}STU;

void dataInput(STU* Pstu, int n);
int  Highest(STU* Pstu, int n);

int main()
{
	int high;
	STU myClass[N];

	dataInput(myClass, N);
	high = Highest(myClass, N);

	printf("\n均分最高的学生是：%8s\n学号：%d\n成绩1：%.2f\t成绩2：%.2f\t成绩3：%.2f\n",
		myClass[high].name, myClass[high].num, myClass[high].score1, myClass[high].score2, myClass[high].score3);

	return 0;
}

//信息输入函数
void dataInput(STU* Pstu, int n)
{
	int i;
	STU temp;

	printf("请输入%d位学生的信息：学号、姓名、成绩1、成绩2、成绩3：\n\n",n);
	for (i = 0; i < n; i++)
	{
		printf("NO . %d\t", i + 1);
		scanf("%d%s%f%f%f", &temp.num, temp.name, &temp.score1, &temp.score2, &temp.score3);
		Pstu[i] = temp;
		Pstu[i].ave = (Pstu[i].score1 + Pstu[i].score2 + Pstu[i].score3) / 3.0f;
	}
}

//寻找均分最高的学生
int Highest(STU* Pstu, int n)
{
	int i, pos = 0;
	float max = Pstu[0].ave;

	for (i = 0; i < n; i++)
	{
		if (Pstu[i].ave > max)
		{
			max = Pstu[i].ave;
			pos = i;
		}
	}
	return pos;
}

在这里插入图片描述

从键盘读入一行字符(约定:字符数 ≤ 127 字节，其中的空格不固定、有多有少)
和加密间隔(假定只输入正整数)，将加密后的文字输出。
具体加密方法示例为:对于输入“1 2 3 4 5 6 7 8 9abcd ef ghiA BCD EFGHI XYZ”、加密间隔为 9，
先去掉输入中的空格后输出为:123456789abcdefghiABCDEFGHIXYZ，然后按间隔 9 分组:
123456789
abcdefghi
ABCDEFGHI
XYZ
输出密码的方法为:从第 1 组开始，依次从每组各取 1 字符输出，每一轮取完后输出一个空格，则以上输入的密码输出为:1aAX 2bBY 3cCZ 4dD 5eE 6fF 7gG 8hH 9iI。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<string.h>
#define MAXSIZE 128

/*
	从键盘读入一行字符(约定:字符数 ≤ 127 字节，其中的空格不固定、有多有少)
    和加密间隔(假定只输入正整数)，将加密后的文字输出。具体加密方法
    示例为:对于输入“1 2 3 4 5 6 7  8 9abcd ef ghiA BCD EFG HI XYZ”、
    加密间隔为 9，
    先去掉输入中的空格后输出为:123456789abcdefghiABCDEFGHIXYZ，
    然后按间隔 9 分组:
       123456789
       abcdefghi
       ABCDEFGHI
       XYZ
    输出密码的方法为:从第 1 组开始，依次从每组各取 1 字符输出，
    每一轮取完后输出一个空格，
    则以上输入的密码输出为:1aAX 2bBY 3cCZ 4dD 5eE 6fF 7gG 8hH 9iI。

*/

int main()
{
    char strA[MAXSIZE], strB[MAXSIZE], res[MAXSIZE - 1][MAXSIZE];
    int encryptSpace, i, j, k, len, row, count = 0;     //加密间隔、

	printf("请输入一行字符串-->");
    gets_s(strA);
	printf("\n请输入加密间隔n =  ");
    scanf("%d", &encryptSpace);

    for (i = 0, j = 0; strA[i] != '\0'; i++)
    {
        if (strA[i] != ' ')
        {
            strB[j] = strA[i];
            j++;
        }
    }
    strB[j] = '\0';

	printf("\n去掉空格后的原密码内容为-->%s\n",strB);

    //对原密码按照加密间隔来进行分组
    for (i = 0, j = 0, k = 0; strB[i] != '\0'; i++)
    {
        res[j][k++] = strB[i];
       // k++;
        count++;
        if (count == encryptSpace)
        {
            res[j][k] = '\0';
            j++;
            k = 0;
            count = 0;
        }
    }

    len = strlen(strB);
    row = len / encryptSpace;

	printf("\n加密生成内容为-->");
    for (j = 0, k = 0; j < encryptSpace; j++)
    {
        for (i = 0; i < row; i++)
        {
            printf("%c", res[i][j]);
        }

        //处理未最后一行对应列不足row+1的数据
        if (k < len % encryptSpace)
        {
            printf("%c", res[row][k]);
            k ++;
        }
        printf(" ");
    }
	printf("\n");
	

	return 0;
}

在这里插入图片描述

编写一程序实现以下功能：
从键盘上读入一行字符（约定：字符数 ≤ 127 字节），判断其中的注释是否合法，不合法则报错，合法时则删除注释后再输出。
注意事项：
1. 程序中不能使用库函数 strstr() 或使用同名的变量、函数、单词。
2. 只考虑行内最多只包含一个注释的情况。
3. 不合法的注释情况有很多种，例如：“… * / ”缺注释开始标记、“ / … * / ”注释开始标记错误、“/ …”缺注释结束标记、“/* … * /”注释结束标记错误。

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#define MAXSIZE 128

int main()
{
	char str[MAXSIZE], res[MAXSIZE];
	int i, j, posA, posB, flagA = 0, flagB = 0;

	printf("请输入一行字符串-->");
	gets_s(str);

	for (i = 0; str[i] != '\0'; i++)
	{
		if (str[i] == '/' && str[i + 1] == '*')
		{
			posA = i;
			flagA = 1;
			break;
		}
	}

	for (i = 0; str[i] != '\0'; i++)
	{
		if (str[i] == '*' && str[i + 1] == '/')
		{
			posB = i;
			flagB = 1;
			break;
		}
	}

	//无注释
	if (flagA == 0 && flagB == 0)
	{
		printf("输出结果为-->%s",str);
	}
	else if (flagA == 1 && flagB == 1 && posA < posB)	//注释正确合法
	{
		printf("输出结果为-->");
		for (i = 0, j = 0; str[i] != '\0'; i++)
		{
			if (i<posA || i>posB + 1)
			{
				res[j++] = str[i];
			}
		}
		res[j] = '\0';
		puts(res);
	}
	else  //注释非法
	{
		printf("语句注释有误！");
	}
	printf("\n");
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

程序的功能是：
1. 创建一个链表，共有 N（N 由 #define 定义）个节点，第 1 个节点的数据域赋值为 0，第 2 个节点的数据域赋值为 1，以此类推，第 20 个节点的数据域赋值为 19。
3. 输出该链表节点的数据.
4. 通过改变指针域的指向，将链表倒序，并输出倒序后的链表各节点数据.

#define  _CRT_SECURE_NO_WARNINGS /*防止scanf使用报错*/
#include<stdio.h>
#include<stdlib.h>
#define N 20

/*
	程序的功能是：
	1. 创建一个链表，共有 N（N 由 #define 定义）个节点，
	第 1 个节点的数据域赋值为 0，第 2 个节点的数据域赋值为 1，
	以此类推，第 20 个节点的数据域赋值为 19。
	3. 输出该链表节点的数据.
	4. 通过改变指针域的指向，将链表倒序，并输出倒序后的链表各节点数据.
*/

struct Link
{
	int data;
	struct Link* next;
};

void printLink(struct Link* head, int n);
struct Link* creatLink(int n);
struct Link* reverseLink(struct Link* head);

int main()
{
	struct Link* Head;
	Head = creatLink(N);

	printf("\n原数据:");
	printLink(Head, N);

	Head = reverseLink(Head);
	printf("\n新数据:");
	printLink(Head, N);

	printf("\n");

	return 0;
}

//打印链表
void printLink(Link* head, int n)
{
	static struct Link* oLink[2][N];
	static int callNum = -1;
	int i = 0;

	callNum++;
	if (callNum > 1)
	{
		printf("输入错误，无效输出！\n");
		return;
	}

	while (head != NULL)
	{
		oLink[callNum][i] = head;
		i++;
		printf("%d  ", head->data);

		head = head->next;
	}
	printf("\n");

	if (1 == callNum)
	{
		for (i = 0; i < n; i++)
		{
			if (oLink[0][i] != oLink[1][n - i - 1])
			{
				printf("错误，链表逆序输出错误！\n");
				return;
			}
		}
	}
}

//创建链表
struct Link* creatLink(int n)
{
	struct Link* head, * p1, * p2;
	int i;

	head = p1 = p2 = (struct Link*)malloc(sizeof(struct Link));

	for (i = 0; i < n; i++)
	{
		p1->data = i;
		if (head == NULL)
		{
			head = p1;
		}
		else
		{
			p2->next = p1;
		}

		p2 = p1;
		p1 = (struct Link*)malloc(sizeof(struct Link));
	}
	p2->next = NULL;

	return head;
}

//链表数据逆置
struct Link* reverseLink(Link* head)
{
	struct Link* h, * p1, * p2;
	int flag = 0;

	h = p1 = p2 = head;

	while (h != NULL)
	{
		if (flag == 0)
		{
			h = h->next;
			p1->next = NULL;
			flag++;
		}
		else if (flag == 1)
		{
			p2 = p1;
			p1 = h;
			h = h->next;
			p1->next = p2;

		}
	}

	return p1;
}

在这里插入图片描述

是快卡黎嫩哦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
成都信息工程大学计算机考研历年807真题的编程题.zip
06-20
【成都信息工程大学计算机考研历年807真题的编程题.zip】是一个针对计算机科学与技术专业考研复习的重要资源包，主要涵盖了807科目历年来的编程题目。这个压缩包对于准备参加成都信息工程大学计算机专业研究生入学...
2021-05-21
l9z9y9的博客
05-21 94
建立一个2-4译码器的门级模型 一、实验目的 了解2-4译码器原理以及2-4译码器的应用 二、实验过程 1、打开quartus II，打开代码页面（Verilog HDL File)将代码粘贴到页面上。 module DEC2x4 (Z,A,B,Enable ); output [3:0] Z; input A,B,Enable; wire Abar,Bbar; not not0 (Abar,A), not1 (Bbar,B); nand nand0(Z[3],Enable,A,B), nand1(Z[0]
【成都信息工程大学】2015-807C语言程序设计
XING_Gou的博客
11-30 576
功能：将随机输入的10个字符，从大到小依次排序输出（冒泡排序）功能：输出数组a中在同下标情况下与b数组中元素不同的元素。运行结果： 12 4 17 24 27。
2021-12-06 自动化专业C语言上机作业参考答案18
fhzheng for c java javascript sql html css
12-07 7171
2021-12-06 自动化专业C语言上机作业参考答案18
2017年807程序综合设计答案解析
oneshit的博客
10-23 1865
一段废话：博主在备考成都信息工程大学2020年的硕士研究生，期间我找到了807的真题，但是大家似乎都没有答案。于是博主斗胆以自己半吊子的C/C++水平写出答案解析（包括知识点和链接等），供各位参考，共同学习进步。后面还会继续完善。 如有错误请及时通知我改正(qq 1435810914)，我会第一时间在博客上更新，避免误人子弟 //2019 10 06 //coded by user0914 ,...
2019年807程序综合设计答案解析
oneshit的博客
10-23 3217
一段废话：博主在备考成都信息工程大学2020年的硕士研究生，期间我找到了807的真题，但是大家似乎都没有答案。于是博主斗胆以自己半吊子的C/C++水平写出答案解析（包括知识点和链接等），供各位参考，共同学习进步。后面还会继续完善。 如有错误请及时通知我改正(qq 1435810914)，我会第一时间在博客上更新，避免误人子弟 //coded by user0914 ,qq 1435810914...
成都信息工程大学807历年真题
11-26
3. **题型分析**：通过对历年真题的分析，学生可以识别出常见的题型，比如选择题、填空题、简答题、编程题等。了解这些题型有助于制定复习策略，分配学习时间和精力。 4. **重点知识点**：通过比较不同年份的真题，...
北邮807软件工程2011-2017真题
12-02
4. **编程与算法**：虽然软件工程主要侧重于过程而非技术细节，但基础的编程知识和常见数据结构与算法的运用依然重要，可能会有相关的编程题目出现。 5. **软件项目管理**：包括进度控制、成本估算、质量管理、团队...
北邮807软件工程xx2011-2017真题全集
01-18
北邮807软件工程2011-2017真题全集是一份珍贵的学习资源，涵盖了北京邮电大学计算机学院软件工程专业硕士研究生入学考试在过去七年间的全部试题。这些试题对于备考该专业考试的学生来说具有极高的参考价值，能够帮助...
北邮考研807计算机真题
02-18
在【压缩包子文件的文件名称列表】中，虽然只有一个“软件”，但可以推测其中可能包含的是关于软件工程、软件设计、编程语言、算法分析等相关主题的真题和解析。考生需要对这些领域有深入的理解和扎实的实践能力。 ...
成信大807程序综合设计2015-2022历年真题及答案【持续更新中】
热门推荐
一万年太久，只争朝夕
09-26 1万+
快速导航2015年一、填空题二、程序改错题三、分析程序题四、算法设计及编程题2016年一、单项选择题二、判断题三、程序分析题四、程序设计题2017年一、单项选择题二、判断题三、程序分析题四、程序设计题2018年一、单项选择题二、判断题三、程序分析题四、程序设计题 2015年 此答案系学长自己做出来的答案，并非官方答案，有问题欢迎留言交流！由于答案不完整，大家也可以将自己做的以及相关想法写在留言栏里面，方便大家交流查阅，谢谢！ 一、填空题 (1) 1 (2) test1.txt (3) int FindM
2018年807程序综合设计答案解析
oneshit的博客
10-23 1701
一段废话：博主在备考成都信息工程大学2020年的硕士研究生，期间我找到了807的真题，但是大家似乎都没有答案。于是博主斗胆以自己半吊子的C/C++水平写出答案解析（包括知识点和链接等），供各位参考，共同学习进步。后面还会继续完善。 如有错误请及时通知我改正(qq 1435810914)，我会第一时间在博客上更新，避免误人子弟 //coded by user0914 ,qq 1435810914...
C语言——报数问题：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
soobinnim的博客
03-22 8978
int main() { int n; scanf("%d",&n); int a[100],*p; p=a;//a的首元地址 for(int i=0;i<n;i++) { *(p+i)=i+1;//如：输入5，这时数组里的数值就为[1,2,3,4,5] } int j=0;//偏移量 int k=0;//报数 int m=0;//记录退出的人数 while(m<n-1)//当退出人.
C语言编程在一个已知的字符串中查找最长单词，假定字符串中只含字母和空格，用空格来分隔单词。
duoduo_333的专栏
07-19 3799
//初学者,有什么问题请多多指教
c++ primer 第五版 翻译 第九章
安仔的博客
08-03 2491
第九章 顺序容器 内容： 9.1 顺序容器概览 9.2 容器库概览 9.3 顺序容器操作 9.4 vector如何增长 9.5 string的其他操作 9.6 容器适配器 本章小结 专业术语 本章是第三章的后续内容，用于完善对标准库顺序容器的知识介绍。顺序容器中元素的顺序对应于元素被添加的位置。标准库还定义了几个关联容器，他们的位置与关键字（key）有关。将在第十一章介绍关联容器相关的知识。 所有...
1.8字符串- 翻转子串
weixin_30768661的博客
02-04 214
假定我们都知道非常高效的算法来检查一个单词是否为其他字符串的子串。请将这个算法编写成一个函数，给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成，要求只能调用一次检查子串的函数。 给定两个字符串s1,s2,请返回bool值代表s2是否由s1旋转而成。字符串中字符为英文字母和空格，区分大小写，字符串长度小于等于1000。 测试样例： "Hello world","worldhell...
C/C++内存管理
最新发布
2401_82669797的博客
07-13 563
malloc只开空间，new既开空间又调用构造函数初始化。delete会调用析构函数，free不会。malloc和free：malloc的对象只是开辟了空间，并没有初始化，free后也只是普通的释放。new和delete：使用new，既可以开辟空间，又调用了构造函数从而完成初始化，而delete时调用了析构函数，以此释放空间。new的原理调用operator new函数申请空间在申请的空间上执行构造函数，完成对象的构造delete的原理在空间上执行析构函数，完成对象中资源的清理工作。
AC修炼计划（AtCoder Regular Contest 179）A~C
kyrietheshy的博客
07-11 325
比如第i位，假如我向这个数位放入的数字是j，首先，放入j的前提条件是在当前位数和上一个放入j的位数之间我们放入了至少一个a[j]，此时j可以放入，同时，放入了j后，j会使得后面所有a[x]=j的数字都可以放入，我们可以通过状态去枚举各个数字是否可以放入，能放入的话对应的二进制位数就是1，不能放入就是0。这题可以用dp的思想去求，通过题目的数据，我们可以大胆去猜，首先复杂度一定要带个n，其次m仅仅等于10也让我们可以发散性的去想到状压的。的复杂度，还可以再添一个m，所以最终的复杂度最多为O(nmlog。
【高中数学/指数、对数】已知a=e^0.03-1,b=3/103,c=ln1.03,则a、b、c的大小关系为？
一念非凡(46岁待业程序员)
07-13 868
运用指数函数、对数函数的知识解决问题：“已知a=e^0.03-1,b=3/103,c=ln1.03,则a、b、c的大小关系为”，并用Canvas绘制图像辅助分析。此题背后考察的其实是对y=e^x-1,y=x/1+x,y=ln(1+x)的图线的高度、位置、斜率的掌握程度。
可编程控制器技术练习题样本.doc
12-18
这篇练习题涉及到可编程控制器（PLC）的基本知识，包括硬件组件、编程元件、特殊辅助继电器的功能以及基本编程指令的应用。以下是各题目涉及的知识点详解： 1. 三菱FX2N-32MR的基本单元输入输出点数为32个，可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是快卡黎嫩哦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值