XJTU大计基例题分享（第14周）

最新推荐文章于 2024-09-08 15:12:17 发布

还不滚去学习orz

最新推荐文章于 2024-09-08 15:12:17 发布

阅读量1.1k

点赞数 20

文章标签：算法 c++

本文链接：https://blog.csdn.net/2301_81233036/article/details/135299742

版权

仅为个人拙见，只是分享一下自己的思路和做法，希望大家多批评指正

K进制数的转换。输入非负整数a将其转换为K进制数，2 <= K <= 32。

K进制数使用的符号是0～9, A, ...V来表示（字母是大写）

输入：一个十进制非负整数a和一个正整数K, 2<=K<=32。空格分隔。
输出：K进制表示的整数。

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

int main()
{
	int k, a;
	scanf("%d%d", &a, &k);
	const char f[32] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','G','K','L','M','N','O','P','Q','R','S','T','U','V' };//方便使用的符号，下标及对应的数字
	char K[100];
	
	int i = 0;
	do {
		int b = a % k;
		a = a / k;
		K[i++] = f[b];//按位储存入K

	} while (a != 0);//直到a==0
	

	for (int j = i-1; j >= 0; j--)//逆序输出
	{
		printf("%c", K[j]);
	}
	return 0;
}

任意输入一个自然数，将该数乘以3，

输出乘积和乘积中各位数字组成的最大数。

例如，输入 5370 ，乘3结果为16110，则输出为 16110 61110。

输入格式：自然数 n
输出格式：乘3结果和乘积中各位数字组成的最大数，空格隔开。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
void Bubblesort(int* b, int i);
int main()
{
	int n, a;
	scanf("%d", &n);
	a = n * 3;
	printf("%d ", a);
	int b[100];
	int i = 0;
	do
	{
		b[i++] = a % 10;//将a的每一位分别储存进数组b
		a /= 10;

	} while (a != 0);
	Bubblesort(b, i);//冒泡排序
	for (int j = 0; j < i; j++)//正序输出
	{
		printf("%d", b[j]);
	}
	printf("\n");
	return 0;
}
void Bubblesort(int* b, int i)
{
	for (int j = 0; j < i; j++)
	{
		for (int k = i - 1; k > j; k--)
		{
			if (b[k] > b[k - 1])
			{
				int temp = b[k];
				b[k] = b[k - 1];
				b[k - 1] = temp;
			}
		}
	}
}

每天一开始，第一个在机房里签字的人会打开门，最后一个签字的人会锁上门。根据签到的记录，你应该找到那天开门和锁门的人。记录保证每个人的签到时间必须早于签退时间，并且没有两个人同时签到或签退。

输入：一天的记录，记录以正整数M开头，M是记录总数，后跟M行，每行的格式为：

ID_number Sign_in_time Sign_out_time，其中时间以HH:MM:SS格式给定，ID number是一个不超过15个字符的字符串。

输出：在一行中输出当天开锁和锁门的人员的ID号。这两个ID号必须用一个空格隔开。

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

struct record//结构体定义
{
	char id[12];
	char open[8];
	char lock[8];
};
int main()
{
	int m;
	scanf("%d", &m);
	struct record r[100], min, max;
	for (int i = 0; i < m; i++)
	{
		scanf("%s%s%s", &r[i].id, &r[i].open, &r[i].lock);

	}
	min = max = r[0];
	for (int i = 1; i < m; i++)//寻找最早签到与最晚锁们
	{
		if (strcmp(min.open, r[i].open) > 0)
			min = r[i];
		if (strcmp(max.lock, r[i].lock) < 0)
			max = r[i];
	}
	printf("%s %s\n", min.id, max.id);
	return 0;
}

有n个小孩围成一圈，从1顺序排号。从第一个人开始报数（1~k报数），凡报到k的人退出圈子，问最后留下的人原来排在第几号。

输入：人数（不超过1000），以及报数的k（不超过3000），空格分隔。

输出：最后留下的人的编号

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int fun(int n, int k);
int main()
{
	int n, k;
	scanf("%d%d", &n, &k);
	printf("%d\n", fun(n, k));
	return 0;
}
int fun(int n, int k)
{
	int a[1000];
	for (int i = 0; i < n; i++)
		a[i] = i + 1;
	int j = -1;//确保从下标为0开始
	int t = 0;//已经剔除的人数
	while (1)
	{
		for (int i = 0; i < k;)//报数
		{
			j = (j + 1) % n;//循环报数
			if (a[j] != 0)//若元素还在圈子则报数
				i++;
		}
		if (t == n-1)//只剩一个人则退出
			break;
		a[j] = 0;//剔除
		t++;//剔除人数+1
	}
	return j + 1;//j为下标，j+1为编号
}

编写程序，删除字符串中间的所有星号*，如果首尾有*号，保留不变。字符串长度不超过200。

如：输入***street*****music***，则输出***streetmusic***

输入：带*号的字符串（字符串中不含空格）。

输出：中间没有*号的字符串。

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

int main()
{
	char str[200];
	scanf("%s", str);
	int i = 0;
	while (str[i] == '*')
		i++;
	while (str[i] != '*')//找到第二串*的开始下标
		i++;
	int flag = 0;//判断第二串*是中间的还是尾部的
	for (int j = i; str[j]; j++)
	{
		if (str[j] != '*')
			flag = 1;
	}
	if (flag == 1) //若是中间的*，执行删除操作
	{
		for (i; str[i] == '*'; )
		{
			for (int j = i; str[j]; j++)
				str[j] = str[j + 1];
		}
	}
	printf("%s\n", str);
	return 0;
}

6.某部队进行新兵队列训练，将新兵从1开始按顺序依次编号，并排成一行横队，训练的规则如下：从头开始1至2报数，凡报到2的出列，剩下的向小序号方向靠拢，再从头开始进行1至3报数，凡报到3的出列，剩下的向小序号方向靠拢，继续从头开始进行1至2报数，以后从头开始轮流进行1至2报数、1至3报数直到剩下的人数不超过三人为止。编写程序，输入数N为最开始的新兵人数（2 < N < 6000），输出剩下的新兵最初的编号。

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

int main()
{
	int n;
	scanf("%d", &n);
	if (n <= 3)//如果本来不超过3人，直接输出
	{
		int a = 1;
		do
		{
			printf("%d ", a++);
		} while (a < n);
		printf("%d\n", n);
	}
	else
	{
		int b[6000];
		for (int i = 0; i < n; i++)
			b[i] = i + 1;//编号
		int k = 0;//剔除人数
		int t = -1;//下标
		while (1)
		{
			do {
				for (int i = 0; i < 2;)
				{
					t = t + 1;
					if (t >= n)//下标超过已编号数组范围
						break;
					if (b[t] != 0)//未被剔除才报数
						i++;
				}
				if (t < n) //t在范围内
                {
					b[t] = 0;
					k++;//剔除人数+1
				}
			} while (t < n-1);//判断整个队列是否报数完
			if (k >= n - 3)//剩余不超过3
				break;
			t = -1;//重新从0开始

			do {
				for (int i = 0; i < 3;)
				{
					t = t + 1;
					if (t >= n)
						break;
					if (b[t] != 0)
						i++;
				}
				if (t < n) {
					b[t] = 0;
					k++;
				}
			} while (t < n - 2);
			if (k >= n - 3)
				break;
			t = -1;
		}
		int c[3];
		int j = 0;
		for (int i = 0; i < n; i++)//将剩余编号给数组c
		{
			if (b[i] != 0)
				c[j++] = b[i];
		}
		k==n-3? printf("%d %d %d\n", c[0], c[1], c[2]):printf("%d %d\n",c[0],c[1]);	}
	return 0;
}

输入两个整型数组（假设数组的大小为不超过100）的各个元素，输出不是两个数组共有的元素，并从小到大排序输出。

允许一个数组内具有重复的元素，如该元素在另一个数组中没有（非共有）则所有重复的元素都需要输出。

输入：输入分为2行，分别输入2个数组中的整数，每行的第一个整数N>0指示该数组需要输入的整数个数，随后输入N个整数。

输出：两个数组的元素中非共有的元素，并且从小到大进行排序.

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void Bubblesort(int* sh, int j);
int main()
{
	int n1, n2;
	int a1[100], a2[100];
	scanf("%d", &n1);
	for (int i = 0; i < n1; i++)
	{
		scanf("%d", &a1[i]);
	}
	scanf("%d", &n2);
	for (int i = 0; i < n2; i++)
	{
		scanf("%d", &a2[i]);
	}
	int j = 0;
	int sh[100];
	for (int i = 0; i < n1; i++)//将a1中独有元素放入sh
	{
		int flag = 0;//是否共有的标志
		for (int j = 0; j < n2; j++)
		{
			if (a1[i] == a2[j])
				flag = 1;
		}
		if (flag == 0)
			sh[j++] = a1[i];
	}
	for (int i = 0; i < n2; i++)//将a2独有元素放入sh
	{
		int flag = 0;
		for (int j = 0; j < n1; j++)
		{
			if (a2[i] == a1[j])
				flag = 1;
		}
		if (flag == 0)
			sh[j++] = a2[i];
	}
	Bubblesort(sh, j);//冒泡排序
	for (int i = 0; i < j - 1; i++)
		printf("%d ", sh[i]);
	printf("%d\n", sh[j - 1]);
	return 0;
}
void Bubblesort(int* sh, int j)
{
	for (int i = 0; i < j; i++)
	{
		for (int k = j - 1; k > i; k--)
		{
			if (sh[k] < sh[k - 1])
			{
				int temp = sh[k];
				sh[k] = sh[k - 1];
				sh[k - 1] = temp;
			}
		}
	}
}

给定N个“分子/分母”形式的有理数，计算这些分数的和。

输入格式：第一行输入一个正整数N（1<N<=100），然后下一行N个有理数“a1/b1 a2/b2…”，其中所有的分子和分母都在“int”的范围内。如果有负数，则符号必须出现在分子的前面。

输出格式：输出最简单形式的和，“整数分子/分母”，其中“整数”是和的整数部分，“分子”<“分母”，分子和分母没有公因数。如果整数部分为0，则必须仅输出小数部分。如果结果是一个整数，则仅输出该整数且后面没有空格。如：

1/2 1/2

-1/2 -1/2 -1/2

-1 1/2

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
typedef struct ratinal
{
	int zi;
	int mu;
}rat;//有理数结构体
rat Add(rat sum, rat input);
int Gyueshu(int zi, int mu);

int main()
{
	int n;
	scanf("%d", &n);
	rat sum = { 0,1 };//初始化sum
	for (int i = 0; i < n; i++)
	{
		rat input;
		scanf("%d/%d", &input.zi, &input.mu);
		sum = Add(sum, input);
	}
	if (sum.zi < 0)//负数情况
	{
		printf("-");
		sum.zi = -sum.zi;
	}
	if (sum.zi < sum.mu)//真分数
		printf("%d/%d\n", sum.zi, sum.mu);
	else if(sum.zi%sum.mu==0)//只有整数
	{	
		printf("%d\n", sum.zi / sum.mu);
	}
	else//假分数情况
	{
		int zheng = sum.zi / sum.mu;
		printf("%d ", zheng);
		sum.zi -= sum.mu * zheng;
		printf("%d/%d\n", sum.zi, sum.mu);
	}
	return 0;
}
rat Add(rat sum, rat input)
{
	rat z;
	z.mu = sum.mu * input.mu;//通分求和
	z.zi = sum.zi * input.mu + input.zi * sum.mu;
	int yueshu;
	yueshu = Gyueshu(z.zi, z.mu);
	z.zi /= yueshu;
	z.mu /= yueshu;
	return z;
}
int Gyueshu(int zi, int mu)//最大公约数
{
	int g = mu;//g一定假定为mu，因为mu一定为正数
	while (zi % g || mu % g)
		g--;
	return g;
}

输入一个带有空格的字符串（包含字母、数字、空格以及其他符号），提取字符串中的数字转换为整数并输出，字符串中的非数字字符视为分割符。输出数据间以空格分隔，末尾没有空格，并换行输出所有整数的和值。若字符串中没有任何数字时，输出“NO”。输入的字符串长度不超过80。

输入：一行字符串(含有空格）。

输出格式：第一行：转换后的各整数间用一个空格分隔，第二行：和值。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int fun(char* instr, char str[][50]);
int fun2(char* str);

int main()
{
	char instr[80];
	gets(instr);
	int i = 0;
	while (instr[i])//将非数字元素统一为*
	{
		if (!(instr[i] >= '0' && instr[i] <= '9'))
		{
			instr[i] = '*';
		}
		i++;
	}
	char str[40][50];
	int m;
	m = fun(instr, str);
	if(m==0)
	{
		printf("NO\n");
		return 0;
	}
	int num[100] = { 0 };
	int sum = 0;

	for (int i=0 ; i < m; i++)
	{
		num[i] = fun2(str[i]);
		sum += num[i];
	}
	for (int i = 0; i < m - 1; i++)
	{
		printf("%d ", num[i]);
	}
	printf("%d\n%d\n", num[m - 1],sum);

	return 0;
}
int fun(char* instr, char str[][50])
{
	int i = 0;
	int m = 0;
	int n = 0;
	while (instr[i] == '*'&&instr[i]!=0)
		i++;
	while (instr[i] != 0)
	{
		while (instr[i] != '*' && instr[i] != 0)
		{
			str[m][n++] = instr[i++];//若为数字则存入二位数组
			
		}
		str[m++][n] = 0;//每行末尾加终止符
		n = 0;//n归0
		while (instr[i] == '*' && instr[i] != 0)
			i++;
	}
	return m;//m为存入个数
}
int fun2(char* str)//将字符转换为数字
{
	int n = 0;
	int len = strlen(str);
	for (int i = 0; i < len; i++)
	{
		n = n * 10 + (str[i] - '0');
	}
	return n;
}

10.

输入两个字符串s, t，(字符串中没有空格，包含大小写字母、数字以及其他符号）

按从小到大顺序输出在s或t中出现过(不区分大小写)的所有字符，所有字母均按大写输出

重复的字符只输出1次。

s,t长度不超过100。

输入：1行，两个字符串中间用空格隔开，字符串不含空格

输出：结果字符串，按ASCII编码从小到大排序。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
void delete(char s[]);
void Bubble(char s[]);

int main()
{
	char s[200], t[100];
	scanf("%s%s", s, t);
	strcat(s, t);//连接st，储存到s中
	_strupr(s);//变大写
	delete(s);//删除重复字符
	Bubble(s);//冒泡排序
	printf("%s\n", s);
	return 0;
}
void delete(char s[])
{
	for (int i = 0; s[i]; i++)
	{
		for (int j = i + 1; s[j]; j++)
		{
			if (s[i] == s[j])
			{
				for (int k = j; s[k]; k++)
					s[k] = s[k + 1];
				j--;
			}
		}
	}
}
void Bubble(char s[])
{
	int len = strlen(s);
	for (int i = 0; i < len; i++)
	{
		for (int j = len - 1; j > i; j--)
		{
			if (s[j] < s[j - 1])
			{
				char temp;
				temp = s[j];
				s[j] = s[j - 1];
				s[j - 1] = temp;
			}
		}
	}
}