华科计算机考研机试真题汇总上篇(C语言)

最新推荐文章于 2024-02-23 15:50:01 发布

zuel_newer

最新推荐文章于 2024-02-23 15:50:01 发布

阅读量2.9k

点赞数 12

分类专栏： C语言文章标签： c语言数据结构

本文链接：https://blog.csdn.net/znufe_newer/article/details/105293088

版权

C语言专栏收录该内容

11 篇文章 5 订阅

订阅专栏

一、2000年华科机试题

1.阶乘

题目描述：

输入n，求y1=1!+3!+…m!(m是小于等于n的最大奇数） y2=2!+4!+…p!(p是小于等于n的最大偶数)。

输入描述：

每组输入包括1个整数：n。

输出描述：

可能有多组测试数据，对于每组数据，输出题目要求的y1和y2。

#include<stdio.h>
//阶乘
int cal(int num)
{
	int N = 1,i;
	for(i = 1; i <= num; i++)
		N *= i;
	return N;
}
//累加
long add(int num)
{
	long N = 0;
	while(num > 0)
	{ 
		N += cal(num);
		num -= 2;
	}
	return N;
}
int main()
{
	long n;
	while(scanf("%d",&n) != EOF)
	{
		if(n % 2)
			printf("%ld %ld\n", add(n), add(n-1));
		else 	
			printf("%ld %ld\n", add(n-1), add(n));
	}
	return 0;
}

2.对称矩阵

题目描述：

输入一个N维矩阵，判断是否对称。

输入描述：

输入第一行包括一个数：N(1<=N<=100)，表示矩阵的维数。接下来的N行，每行包括N个数，表示N*N矩阵的元素。

输出描述：

可能有多组测试数据，对于每组数据，输出"Yes!”表示矩阵为对称矩阵，输出"No!”表示矩阵不是对称矩阵。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		int **array, i, j;
		//动态分配二维数组，也可直接定义大数组
		array = (int **)malloc(sizeof(int *) * N);
		for(i = 0; i < N; i++)
			array[i] = (int *)malloc(sizeof(int) * N);
		for(i = 0; i < N; i++)
			for(j = 0; j < N ;j++)
				scanf("%d", &array[i][j]);
		int flag=1;
		for(i = 0; i < N; i++)
			for(j = i + 1; j < N ;j++)
				if(array[i][j] != array[j][i])
					flag = 0;
		if(flag)
			printf("Yes!\n");
		else	printf("No!\n");
		free(array);
	}
	return 0;
}

3.遍历链表

题目描述：

建立一个升序链表并遍历输出。

输入描述：

输入的每个案例中第一行包括1个整数：n(1<=n<=1000)，接下来的一行包括n个整数。

输出描述：

可能有多组测试数据，对于每组数据，将n个整数建立升序链表，之后遍历链表并输出。

#include<stdio.h>
#include<stdlib.h>
typedef struct LNode
{
	int num;
	struct LNode *next;
}LNode, *LinkList;
void insertList(LinkList L,int temp)
{
	LNode *p = L -> next;
	LNode *q = L;
	//找到插入位置
	while(p != NULL && temp > p->num)
	{
		q = p;
		p = p->next;
	}
	p=(LNode *)malloc(sizeof(LNode));
	p->num = temp;
	p->next = q->next;
	q->next = p;	
}

void deleteList(LinkList L)
{
	LNode *p = L -> next;
	LNode *q = L;
	do
	{
		free(q);
		q = p;
		p = p->next;
	}while(p);

}
int main()
{
	int n;
	while(scanf("%d", &n) != EOF)
	{
		LinkList L = (LNode *)malloc(sizeof(LNode));
		L->next = NULL;
		int temp;
		for(int i = 0; i < n; i++)
		{
			scanf("%d", &temp);
			insertList(L,temp);
		}
		LNode *p = L->next;
		while(p)
		{
			printf("%d ",p->num);
			p = p->next;
		}
		printf("\n");
		deleteList(L);
	}
	return 0;
}

二、2001年华科机试题

1.找位置

题目描述：

对给定的一个字符串，找出有重复的字符，并给出其位置，如：abcaaAB12ab12 输出：a，1；a，4；a，5；a，10，b，2；b，11，1，8；1，12， 2，9；2，13。

输入描述：

输入包括一个由字母和数字组成的字符串，其长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据，按照样例输出的格式将字符出现的位置标出。
1.下标从0开始。
2.相同的字母在一行表示出其出现过的位置。
注意：牛客网OJ需另谋它法

#include<stdio.h>
int main()
{
	int count[128] = {0};		//计数数组
	int str[128][100];			//位置数组
	char ch;
	int flag = 0;					//记录当前位置
	while((ch = getchar()) != '\n')
	{
		str[ch][count[ch]] = flag;
		count[ch]++;
		flag++;
	}
	for(int i = 0; i<128 ; i++)
		if(count[i] > 1)
		{
			for(int j =0; j < count[i]; j++)
			{
				if(j != (count[i]-1))
					printf("%c:%d,", i, str[i][j]);
				else printf("%c:%d\n", i, str[i][j]);
			}
		}
	return 0;
}

2.最大的两个数

题目描述：

输入一个四行五列的矩阵，找出每列最大的两个数。

输入描述：

接下来的四行每行包括五个整数。代表一个四行五列的矩阵，矩阵元素全部是整数。

输出描述：

可能有多组测试数据，对于每组数据，按照样例输出的格式将每列最大的两个数输出，如果最大的两个数中的一个数在这一列中有多个相同的值，则行值取行值小的那一个。输出时要保留原矩阵的行列顺序，即在原矩阵中行值小的，在输出矩阵中的行值依然小。

#include<stdio.h>
int main()
{
	int i, j, num, array[2][5];
	for(i = 0; i < 4; i++)
		for(j = 0; j < 5; j++)
		{
			scanf("%d", &num);
			if(i == 0 || i == 1)
			//前两行直接放入数组
				array[i][j] = num;
			else if(num > array[0][j] || num > array[1][j])
			{//判断num是否会放入数组							
				if(array[0][j] < array[1][j])
			//将第二行放入第一行，然后num放入第二行保留原有顺序
					array[0][j] = array[1][j];
				array[1][j] = num;
			}

		}
	for(i = 0; i < 2; i++)
	{
		for(j =0; j < 5; j++)
			printf("%d ", array[i][j]);
		printf("\n");
	}
}

3.链表删除最大数

题目描述：

建立一个链表，以输入0为结束，删除其中数值最大的元素，并输出删除元素后的链表（不能用数组）。

#include<stdio.h>
#include<stdlib.h>
typedef struct LinkNode
{
	int num;
	struct LinkNode *next;
}LNode, *LinkList;
//插入元素
void _stdcall insertList(LinkList L, int num)
{
	LNode *p = L, *q;
	while(p->next)
		p = p->next;
	q = (LNode *)malloc(sizeof(LNode));
	q ->num = num;
	p->next = q;
	q->next = NULL;		
}
//删除最大值
void _stdcall deleteList(LinkList L, int num)
{
	LNode *q = L, *p = L->next;
	while(p)
	{
		if(p->num==num)
		{
			q->next = p->next;
			free(p);
			p = q->next;
		}
		else
		{
			q = p;
			p = p->next;
		}
	}
}
//释放链表内存
void deleteList(LinkList L)
{
	LNode *p = L -> next;
	LNode *q = L;
	do
	{
		free(q);
		q = p;
		p = p->next;
	}while(p);

}
int main()
{
	int n,max;
	scanf("%d", &n);
	max = n;
	LinkList L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	while(n)
	{
		insertList(L, n);
		scanf("%d", &n);
		if(n > max)
			max = n;
	}
	deleteList(L, max);
	LNode *p = L->next;
	while(p)
	{
		printf("%d ",p->num);
		p = p->next;
	}
	deleteList(L);
	return 0;
}

三、2002年华科机试题

1.统计单词

题目描述：

编写一个程序，读入用户输入的，以“.”结尾的一行文字，统计一共有多少个单词，并分别输出每个单词含有多少个字符。（凡是以一个或多个空格隔开的部分就为一个单词）

输入描述：

输入包括1行字符串，以“.”结束，字符串中包含多个单词，单词之间以一个或多个空格隔开。

输出描述：

可能有多组测试数据，对于每组数据，输出字符串中每个单词包含的字母的个数。

//方法一
#include<stdio.h>
int main()
{
	char ch;
	int count = 0;
	while((ch = getchar()) != '.')
	{
		if(ch != ' ')
			count++;
		else if(count)
		{
			printf("%d ", count);
			count = 0;
		}
	}
	//输出最后一个单词字母个数
	printf("%d\n", count);
	return 0;
}
//方法二更好
#include<stdio.h>
#include<string.h>
int main()
{
	char str[20];
	while(scanf("%s", str) != EOF)
	{
		int len = strlen(str);
		if(str[len-1] != '.') //判断是否是最后一个单词
			printf("%d ", len);
		else printf("%d\n", len-1);
	}
	return 0;
}

2.守形数

题目描述：

守形数是这样一种整数，它的平方的低位部分等于它本身。比如25的平方是625，低位部分是25，因此25是一个守形数。编一个程序，判断N是否为守形数。

输入描述：

输入包括1个整数N，2<=N<100。

输出描述：

可能有多组测试数据，对于每组数据，输出"Yes!”表示N是守形数，输出"No!”表示N不是守形数。

#include<stdio.h>
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		int temp, flag=0, count = 10;
		temp = N*N;
		while(temp > count)
		{
			if(temp % count == N)
				flag = 1;
			count*=10;
		}
		if(flag)
			printf("Yes!\n");
		else printf("No!\n");
	}
	return 0;
}

3.二叉树遍历

题目描述：

二叉树的前序、中序、后序遍历的定义：前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树；中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树；后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定前序遍历与中序遍历能够唯一确定后序遍历）。

输入描述：

两个字符串，其长度n均小于等于26。第一行为前序遍历，第二行为中序遍历。二叉树中的结点名称以大写字母表示：A，B，C…最多26个结点。

输出描述：

输入样例可能有多组，对于每组测试样例，输出一行，为后序遍历的字符串。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct BiNode
{
	char data;
	struct BiNode *lchild, *rchild;
}BiNode,*BTree;
 
//前中序确定后序
BTree preInTree(char preOrder[],int pl,int pr,char inOrder[],int il,int ir)
{
	//以{FDXEAG}和{XDEFAG}为例
	int i = 0;
	int len_p = pr-pl+1, len_i = ir - il + 1;
	BiNode *p = (BiNode*)malloc(sizeof(BiNode));
	if(len_p <= 0 || len_i <= 0)						
        return NULL;
	while(inOrder[il+i] != preOrder[pl])			//找到前序遍历首节点在中序遍历的位置
		i++;
	
	p->data = preOrder[pl];
	//i=3,{DXE}和{XDE}
	p->lchild = preInTree(preOrder, pl+1, pl+i, inOrder, il, il+i-1);	
	//{AG}和{AG}
	p->rchild = preInTree(preOrder, pl+i+1, pr, inOrder, il+i+1, ir);
	//递归返回按后序输出
	printf("%c", preOrder[pl]);
	return p;
}
int main()
{
	char a[30],b[30];
    while(scanf("%s%s", a, b) != EOF)
	{
		BTree BT = preInTree(a, 0, strlen(a)-1, b, 0, strlen(b)-1);
		printf("\n");
	}
	//注意释放内存
	return 0;
}

四、2003~2004年华科机试题

1.特殊排序

题目描述：

输入一系列整数，将其中最大的数挑出(如果有多个，则挑出一个即可)，并将剩下的数进行排序，如果无剩余的数，则输出-1。

输入描述：

输入第一行包括1个整数N，1<=N<=1000，代表输入数据的个数，接下来的一行有N个整数。

输出描述：

可能有多组测试数据，对于每组数据，第一行输出一个整数，代表N个整数中的最大值，并将此值从数组中去除，将剩下的数进行排序。第二行将排序的结果输出。

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

int cmp_int(const void *a, const void *b)
{
	return *(int *)a-*(int *)b;	
}
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		int *array = (int *)malloc(sizeof(int)*N);
		int i, max, flag;
		for(i = 0; i < N; i++)
		{
			scanf("%d", &array[i]);
			if(i==0 || max < array[i])
			{
				max = array[i];
				flag = i;
			}
		}
		printf("%d\n",max);
		if(N==1)
		{
			printf("-1\n");
			continue;
		}
		//将最后一项移到最大值所在位置
		array[flag] = array[N-1];
		//qsort对前N-1项排序
		qsort(array, N-1, sizeof(array[0]), cmp_int);
		for(i = 0;i < N-1; i++)
			printf("%d ",array[i]);
		printf("\n");
		free(array);
	}
	return 0;
}

2.打印日期

题目描述：

给出年分m和一年中的第n天，算出第n天是几月几号。

输入描述：

输入包括两个整数y(1<=y<=3000)，n(1<=n<=366)。

输出描述：

可能有多组测试数据，对于每组数据，按 yyyy-mm-dd的格式将输入中对应的日期打印出来。

#include<stdio.h>
int main()
{
	int y, n;
	while(scanf("%d%d", &y, &n) != EOF)
	{
		int count = 0, i = 0, month = 1, day;
		int date[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
		//判断是否为闰年
		if((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
			date[1] = 29;
		while((n - date[i]) > 0)
		{
			n -= date[i];
			month++;
			i++;
		}
		day = n;
		printf("%d-%02d-%02d\n", y, month, day);
	}
	return 0;
}

3.最小年龄的3个职工

题目描述：

职工有职工号，姓名，年龄.输入n个职工的信息，找出3个年龄最小的职工打印出来。

输入描述：

输入第一行包括1个整数N，1<=N<=30，代表输入数据的个数。
接下来的N行有N个职工的信息：
包括职工号(整数)，姓名(字符串，长度不超过10)，年龄(1<=age<=100)。

输出描述：

可能有多组测试数据，对于每组数据，输出结果行数为N和3的较小值，分别为年龄最小的职工的信息。关键字顺序：年龄>工号>姓名，从小到大。
注意：qsort可参考快速排序及qsort( )

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct worker
{
	int no;
	char name[10];
	int age;
};
int cmp_worker(const void *a, const void *b)
{
	if((*(worker *)a).age != (*(worker *)b).age)
		return (*(worker *)a).age - (*(worker *)b).age;
	else if((*(worker *)a).no != (*(worker *)b).no)
		return (*(worker *)a).no - (*(worker *)b).no;
	else 
		return strcmp((*(worker *)a).name, (*(worker *)b).name);
}
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		int i;
		worker w[30];
		for(i = 0;i < N; i++)
			scanf("%d%s%d", &w[i].no, w[i].name, &w[i].age);
		qsort(w, N, sizeof(w[0]), cmp_worker);
		N = N > 3?3:N;
		for(i = 0;i < N; i++)
			printf("%d %s %d\n", w[i].no, w[i].name, w[i].age);
	}
	return 0;
}

五、2005年华科机试题

1.二叉排序树

题目描述：

二叉排序树，也称为二叉查找树。可以是一颗空树，也可以是一颗具有如下特性的非空二叉树： 1. 若左子树非空，则左子树上所有节点关键字值均不大于根节点的关键字值； 2. 若右子树非空，则右子树上所有节点关键字值均不小于根节点的关键字值； 3. 左、右子树本身也是一颗二叉排序树。现在给你N个关键字值各不相同的节点，要求你按顺序插入一个初始为空树的二叉排序树中，每次插入后成功后，求相应的父亲节点的关键字值，如果没有父亲节点，则输出-1。

输入描述：

输入包含多组测试数据，每组测试数据两行。第一行，一个数字N（N<=100），表示待插入的节点数。第二行，N个互不相同的正整数，表示要顺序插入节点的关键字值，这些值不超过10^8。

输出描述：

输出共N行，每次插入节点后，该节点对应的父亲节点的关键字值。

#include<stdio.h>
#include<stdlib.h>
typedef struct BiNode
{
	int num;
	struct BiNode *lchild, *rchild;
}BiNode, *BTree;
BTree insert(BTree BT, int num, int *father)
{
	//递归找到插入结点位置
	if(BT == NULL)
	{
		printf("%d\n", *father);
		BT = (BTree)malloc(sizeof(BiNode));
		BT->num = num;
		BT->lchild = NULL;
		BT->rchild = NULL;
		return BT;
	}
	else if(num < BT->num)
		BT->lchild = insert(BT->lchild, num, &BT->num);
	else if(num > BT->num)
		BT->rchild = insert(BT->rchild, num, &BT->num);
	return BT;
}
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		BTree BT = NULL;
		int num, father = -1;
		for(int i = 0; i < N; i++)
		{
			scanf("%d", &num);
			BT = insert(BT, num, &father);
		}
		//可再定义一个函数释放内存
	}
	return 0;
}
}

2.前中后序遍历

题目描述：

输入一系列整数，建立二叉排序树，并进行前序，中序，后序遍历。

输入描述：

输入第一行包括一个整数n(1<=n<=100)。接下来的一行包括n个整数。

输出描述：

可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。每种遍历结果输出一行。每行最后一个数据之后有一个空格。输入中可能有重复元素，但是输出的二叉树遍历序列中重复元素不用输出。

#include<stdio.h>
#include<stdlib.h>
typedef int Elemtype;
typedef struct BiTNode{
	Elemtype data;
	struct  BiTNode *lchild, *rchild;
}BiNode, *BTree;
//前、中、后序遍历
void preorder(BTree BT)					
{
	if(BT)
	{
		printf("%d ", BT->data);
		preorder(BT->lchild);
		preorder(BT->rchild);
	}
}
void inorder(BTree BT)
{
	if(BT)
	{
		inorder(BT->lchild);
		printf("%d ", BT->data);
		inorder(BT->rchild);
	}
}
void postorder(BTree BT)
{
	if(BT)
	{
		postorder(BT->lchild);
		postorder(BT->rchild);
		printf("%d ", BT->data);
	}
}
//二叉排序树的插入
BTree insert(BTree &BT, int num)
{
	if(BT == NULL)
	{
		BT = (BiNode *)malloc(sizeof(BiNode));
		BT->data = num;
		BT->lchild = NULL;
		BT->rchild = NULL;
		return BT;
	}
	else if(num < BT->data)
		BT->lchild = insert(BT->lchild, num);
	else if(num > BT->data)
		BT->rchild = insert(BT->rchild, num);
	return BT;
}
int main()
{
	int N;
	while(scanf("%d",&N)!=EOF)
	{
		int i,num;
		BTree BT = NULL;
		for(i = 0; i < N; i++)
		{
			scanf("%d", &num);
			insert(BT, num);
		}
		preorder(BT);
		printf("\n");
		inorder(BT);
		printf("\n");
		postorder(BT);
        printf("\n");
	}
	return 0;
}

六、2006年华科机试题

1.排序

题目描述：

对输入的n个数进行排序并输出。

输入描述：

输入的第一行包括一个整数n(1<=n<=100)。接下来的一行包括n个整数。

输出描述：

可能有多组测试数据，对于每组数据，将排序后的n个整数输出，每个数后面都有一个空格。每组测试数据的结果占一行。

//冒泡排序
#include<stdio.h>
int main()
{
	int N, i, j, temp, array[100];
	while(scanf("%d", &N) != EOF)
	{
		for(i = 0; i < N; i++)
			scanf("%d", &array[i]);
		for(i = 0; i<N-1; i++)
			for(j = 0;j < N-1-i; j++)
				if(array[j] > array[j+1])
				{
					temp = array[j+1];
					array[j+1] = array[j];
					array[j] = temp;
				}
		for(i = 0; i < N; i++)
			printf("%d ", array[i]);
		printf("\n");
	}
	return 0;
}

2.IP地址

题目描述：

输入一个ip地址串，判断是否合法。

输入描述：

每行有一个IP地址，IP地址的形式为a.b.c.d，其中a、b、c、d都是整数。

输出描述：

可能有多组测试数据，对于每组数据，如果IP地址合法则输出"Yes!”，否则输出"No!”。合法的IP地址为：a、b、c、d都是0-255的整数。

#include<stdio.h>
int main()
{
	int a, b, c, d;
	while(scanf("%d.%d.%d.%d", &a, &b, &c, &d) != EOF)
	if(a >= 0 && a <= 255 && b >= 0 && b <= 255 && c >= 0 && c <= 255 && d >= 0 && d <= 255)
		printf("Yes!\n");
	else printf("No!\n");
	return 0;
}

3.大整数排序

题目描述：

对N个长度最长可达到1000的数进行排序。

输入描述：

输入第一行为一个整数N，(1<=N<=100)。接下来的N行每行有一个数，数的长度范围为1<=len<=1000。每个数都是一个正数，并且保证不包含前缀零。

输出描述：

可能有多组测试数据，对于每组数据，将给出的N个数从小到大进行排序，输出排序后的结果，每个数占一行。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int cmp_str(const void *a,const void *b)
{
	int len_a = strlen((char *)a);
	int len_b = strlen((char *)b);
	if(len_a != len_b)
		return len_a-len_b;
	else
		return strcmp((char *)a, (char *)b);
}
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		char str[1000][1000];
		int i;
		for(i = 0; i < N; i++)
			scanf("%s", str[i]);
		qsort(str, N, sizeof(str[0]), cmp_str);
		for(i = 0; i < N; i++)
			printf("%s\n", str[i]);
	}
	return 0;
}

七、2007年华科机试题

1.矩阵最大值

题目描述：

编写一个程序输入一个mXn的矩阵存储并输出，并且求出每行的最大值和每行的总和。要求把每行总和放入每行最大值的位置，如果有多个最大值，取下标值最小的那一个作为最大值。最后将结果矩阵输出。

输入描述：

输入的第一行包括两个整数m、n(1<=m,n<=100)，分别代表矩阵的行和列的维数。接下来的m行每行有n个数，代表矩阵的元素。

输出描述：

可能有多组测试数据，对于每组数据，输出按题目要求执行后的矩阵。

#include<stdio.h>
int main()
{
	int m, n;
	int array[100][100];
	while(scanf("%d%d", &m, &n) != EOF)
	{
		int max, flag;		//每一行最大值和最大值的下标
		int i, j, sum;
		for(i = 0; i < m; i++)
		{
			sum = 0;		//每一行的和
			for(j = 0; j < n; j++)
			{
				scanf("%d", &array[i][j]);
				if(!j || array[i][j] > max)
				{
					max = array[i][j];
					flag = j;
				}
				sum +=array[i][j];
			}
			array[i][flag] = sum;
		}
		for(i = 0; i < m; i++)
		{
			for(j = 0; j < n; j++)
			{
				printf("%d ", array[i][j]);
			}
			printf("\n");
		}
	}
	return 0;
}

2.回文字符串

题目描述：

给出一个长度不超过1000的字符串，判断它是不是回文字符串(顺读，逆读均相同)。

输入描述：

输入包括一行字符串，其长度不超过1000。

输出描述：

可能有多组测试数据，对于每组数据，如果是回文字符串则输出"Yes!”，否则输出"No!"。

#include<stdio.h>
#include<string.h>
int main()
{
	char str[1001];
	while(scanf("%s", str) != EOF)
	{
		int len = strlen(str);
		int i, flag = 1;
		for(i = 0; i <= len/2; i++)
		{
			if(str[i] != str[len-1-i])
				flag = 0;
		}
		if(flag)
			printf("Yes!\n");
		else printf("No!\n");
	}
	return 0;
}

3.矩阵转置

题目描述：

输入一个N*N的矩阵，将其转置后输出。要求：不得使用任何数组(就地逆置)。

输入描述：

输入的第一行包括一个整数N,(1<=N<=100)，代表矩阵的维数。接下来的N行每行有N个整数，分别代表矩阵的元素。

输出描述：

可能有多组测试数据，对于每组数据，将输入的矩阵转置后输出。

#include<stdio.h>
int main()
{
	//不能使用辅助数组
	int i, j, N, array[100][100];
	scanf("%d", &N);
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			scanf("%d", &array[j][i]);
		}
	}
	for(i = 0; i < N; i++)
		for(j = 0; j < N; j++)
		{
			printf("%d ", array[i][j]);
			if(j == N-1)
				printf("\n");
		}
		
	return 0;
}

八、2008年华科机试题

1.N阶楼梯上楼问题

题目描述：

N阶楼梯上楼问题：一次可以走两阶或一阶，问有多少种上楼方式。（要求采用非递归）

输入描述：

输入包括一个整数N,(1<=N<90)。

输出描述：

可能有多组测试数据，对于每组数据，输出当楼梯阶数是N时的上楼方式个数。

#include<stdio.h>
int main(){
    int n;
    int F[90];
    while(scanf("%d", &n) != EOF)
	{
		//前两阶台阶上楼方式个数 
        F[1] = 1,F[2] = 2;			         
        for(int i = 3; i <= n; i++)
		{
			//n > 2时方式个数有两种情况
			//1.前一步走了1个台阶即F[i-1]种
			//2.前一步走了2个台阶即F[i-2]种
            F[i] = F[i-1] + F[i-2]; 
        }
        printf("%d", F[n]);
    }
    return 0;
}

2.八进制

题目描述：

输入一个整数，将其转换成八进制数输出

输入描述：

输入包括一个整数N(0<=N<=100000)。

输出描述：

可能有多组测试数据，对于每组数据，输出N的八进制表示数。

//方法一
#include<stdio.h>
int main()
{
    int n;
    while(scanf("%d", &n) != EOF)
    {
        printf("%o\n", n);
    }
}
//方法二
#include<stdio.h>
int main()
{
    int n;
    while(scanf("%d", &n) != EOF)
    {
		int i = 0, array[15];
        do
		{
			array[i++] = n%8;
			n /= 8;
		}while(n);
		while(i--)
			printf("%d", array[i]);
		printf("\n");
    }
}
//方法三：递归略

3.最长&最短文本

题目描述：

输入多行字符串，请按照原文本中的顺序输出其中最短和最长的字符串，如果最短和最长的字符串不止一个，请全部输出。

输入描述：

输入包括多行字符串，字符串的长度len(1<=len<=1000)。

输出描述：

按照原文本中的顺序输出其中最短和最长的字符串，如果最短和最长的字符串不止一个，请全部输出。

#include<stdio.h>
#include<string.h>
int main(){
    int m = 0;
    char str[1002][1002];
    while (scanf("%s", str[m]) != EOF)
        m++;
    unsigned int min = strlen(str[0]);
    unsigned int max = min;
	int i;
    for (i = 0; i < m; ++i)
	{
        if (strlen(str[i]) > max)
            max = strlen(str[i]);
        if (strlen(str[i]) < min)
            min = strlen(str[i]);
    }
    for (i = 0; i < m; ++i)
        if (strlen(str[i]) == min)
            printf("%s\n", str[i]);
    for (i = 0; i < m; ++i)
        if (strlen(str[i]) == max)
            printf("%s\n", str[i]);
    return 0;
}

九、2009~2010年华科机试题

1.成绩排序

题目描述：

有N个学生的数据，将学生数据按成绩从低到高排序，如果成绩相同则按姓名字符的字典序由小到大排序，如果姓名的字典序也相同则按照学生的年龄从小到大排序，并输出N个学生排序后的信息。

输入描述：

测试数据有多组，每组输入第一行有一个整数N（N<=1000），接下来的N行包括N个学生的数据。每个学生的数据包括姓名（长度不超过100的字符串）、年龄（整形数）、成绩（小于等于100的正数）。

输出描述：

将学生信息按成绩进行排序，成绩相同的则按姓名的字母序进行排序。
然后输出学生信息，按照如下格式：姓名年龄成绩，学生姓名的字母序区分字母的大小写，如A要比a的字母序靠前(因为A的ASC码比a的ASC码要小)。

//qsort用法
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct 
{
	char name[100];
	int age;
	int grade;
}student;
int cmp_stu(const void *a, const void *b)
{
	if((*(student *)a).grade != (*(student *)b).grade)
		return (*(student *)a).grade - (*(student *)b).grade;
	else if(strcmp((*(student *)a).name,(*(student *)b).name))
		return strcmp((*(student *)a).name,(*(student *)b).name);
	else 
		return (*(student *)a).age - (*(student *)b).age;
}
int main()
{
	int N;
	while(scanf("%d", &N) != EOF)
	{
		int i;
		student *stu = (student *)malloc(sizeof(student)*N);
		for(i = 0; i < N; i++)
		{
			scanf("%s%d%d", stu[i].name, &stu[i].age, &stu[i].grade);
		}
		qsort(stu, N, sizeof(stu[0]), cmp_stu);
		for(i = 0; i < N; i++)
			printf("%s %d %d\n", stu[i].name, stu[i].age, stu[i].grade);
	}
	return 0;
}

2.字符串连接

题目描述：

不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来。

输入描述：

每一行包括两个字符串，长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据，不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来，输出连接后的字符串。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	char c, *str;
	int n = 1;
	while((c = getchar()) != '\n')
	{
		if(c == ' ')
			continue;
		if(n == 1)
			str = (char*)malloc(sizeof(char));
		else
			str = (char*)realloc(str, sizeof(char)*n);
		str[n-1] = c;
		n++;
	}
	str[n-1] = '\0';
	printf("%s\n", str);
	return 0;
}

//还可以定义一个函数
//cpy(char *dst, char *src){
//		while(*dst++ = *src++); }

3.奇偶校验

题目描述：

输入一个字符串，然后对每个字符进行奇校验，最后输出校验后的二进制数(如’3’，输出：10110011)。

输入描述：

输入包括一个字符串，字符串长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据，对于字符串中的每一个字符，输出按题目进行奇偶校验后的数，每个字符校验的结果占一行。

#include<stdio.h>
int main()
{
	char c, str[8];
	while((c = getchar()) != '\n')
	{
		int i, num, count;
		num = c;
		count = 0;
		for(i = 7; i > 0; i--)
		{
			str[i] = num%2+'0';
			num = num/2;
			if(str[i] == '1')
				count++;
		}
		if(count%2 == 1)
			str[0]='0';
		else
			str[0] = '1';
		for(i = 0; i < 8 ; i++)
			printf("%c", str[i]);
		printf("\n");
	}
	return 0;
}

4.a + b

题目描述：

实现一个加法器，使其能够输出a+b的值。

输入描述：

输入包括两个数a和b，其中a和b的位数不超过1000位。

输出描述：

可能有多组测试数据，对于每组数据，输出a+b的值。

#include<stdio.h>
#include<string.h>
int convert(char str[], int num[])               //将字母转变为数字，按照低位到高位存放
{
	int i, len = strlen(str);
	for(i = 0; i < len; i++)
	{
		num[i] = str[len-i-1] - '0';
	}
	return len;
}
int main()
{
	char str1[1001], str2[1001];
	int n1, n2, n;
	while(scanf("%s%s", str1, str2) != EOF)
	{
		
		 int a[1001] = {0}, b[1001] = {0}, i, flag = 0;   //数组置0，flag为进位
		 n1 = convert(str1,a);
		 n2 = convert(str2,b);
		 n = n1 >= n2?n1:n2;
		 for(i = 0;i < n; i++)
		 {
			int temp = (a[i] + b[i] + flag)/10;	   //商为进位，余数为当前位结果
            a[i] = (a[i] + b[i] + flag)%10;
            flag = temp;
		 }
		if(flag)							   //最高位产生进位
			a[n++] = flag;
		for(i = n-1; i >= 0; i--)
            printf("%d", a[i]);
	    printf("\n");
	}
	return 0;
}