PAT Basic Level Practice (中文)

最新推荐文章于 2024-05-20 20:08:58 发布

Yiisen

最新推荐文章于 2024-05-20 20:08:58 发布

阅读量264

点赞数

分类专栏： PAT 文章标签：算法

本文链接：https://blog.csdn.net/yoojr/article/details/105192666

版权

PAT 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

PAT	BASIC	LEVEL	PRACTICE	（中文）
1001	1002	1003	1004	1005
1006	1007	1008	1009	1010
1011	1012	1013	1014	1015
1016	1017	1018	1019	1020
1021	1022	1023	1024	1025
1026	1027	1028	1029	1030
1031	1032	1033	1034	1035
1036	1037	1038	1039	1040
1041	1042	1043	1044	1045
1046	1047	1048	1049	1050
1051	1052	1053	1054	1055
1056	1057	1058	1059	1060
1061	1062	1063	1064	1065
1066	1067	1068	1069	1070
1071	1072	1073	1074	1075
1076	1077	1078	1079	1080
1081	1082	1083	1084	1085
1086	1087	1088	1089	1090
1091	1092	1093	1094	1095

1001 害死人不偿命的(3n+1)猜想 (15)

#include <cstdio>

int main(){
    int n, steps = 0;
    scanf("%d",&n);
    while(n>1)
    {
        if(n%2==0)
            n=n/2;
        else
            n=(3*n+1)/2;
        steps++;
    }
    printf("%d\n",steps);
    return 0;
}

1002 写出这个数 (20)

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s;
    cin>>s;
    int sum=0;
    string str[10]={"ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};

    for(int i=0;i<s.length();i++)
    {
        sum += (s[i] - '0');
    }

    string num = to_string(sum);

    for(int i=0;i<num.length();i++)
    {
        if(i != 0) cout<<" ";
        cout<<str[num[i] - '0'];
    }
    return 0;
}

1003 我要通过！ (20)

#include <iostream>
#include <map>
using namespace std;

int main()
{
	int n, p = 0, t = 0;
	string s;
	cin>>n;
	for(int i = 0; i < n; i++)
	{
		cin>>s;
		map<char, int> m;
		for(int j = 0; j < s.size(); j++)
		{
			m[s[j]]++; //记录P、A、T字符的数量
			if(s[j] == 'P')	p = j;	//记录P的位置
			if(s[j] == 'T')	t = j;	//记录T的位置
		}
		
		if(m['P'] == 1 && m['A'] != 0 && m['T'] == 1 && m.size() == 3 && t-p != 1 && p * (t-p-1) == s.length()-t-1)
			printf("YES\n");
		else
			printf("NO\n");
	}
	return 0;
}

1004 成绩排名 (20)

// 读入 n（>0）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。
// 
// 输入格式：
// 每个测试输入包含 1 个测试用例，格式为
// 
// 第 1 行：正整数 n
// 第 2 行：第 1 个学生的姓名 学号 成绩
// 第 3 行：第 2 个学生的姓名 学号 成绩
//   ... ... ...
// 第 n+1 行：第 n 个学生的姓名 学号 成绩
//     
// 其中姓名和学号均为不超过 10 个字符的字符串，成绩为 0 到 100 之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。
// 
// 输出格式：
// 对每个测试用例输出 2 行，第 1 行是成绩最高学生的姓名和学号，第 2 行是成绩最低学生的姓名和学号，字符串间有 1 空格。
// 
// 输入样例：
// 3
// Joe Math990112 89
// Mike CS991301 100
// Mary EE990830 95
// 
// 输出样例：
// Mike CS991301
// Joe Math990112

/*
 * map<int vector<string> >存储 int型对应分数，vector存储姓名、学号
 * 记录
 */

#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	map<int, vector<string> > m;
	string name, id;
	int num, max=0, min=100;
	vector<string> vs;
	
	for(int i = 0; i < n; i++)
	{
		cin>>name>>id>>num;
		vs.push_back(name);
		vs.push_back(id);
		m[num] = vs;
		max = (num>max?num:max);
		min = (num<min?num:min);
		vs.clear();
	}
	
	cout<<m[max][0]<<" "<<m[max][1]<<endl;
	cout<<m[min][0]<<" "<<m[min][1]<<endl;
	
	
	
	return 0;
}

1005 继续(3n+1)猜想 (25)

// 卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里，情况稍微有些复杂。
// 
// 当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4 个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。我们称一个数列中的某个数 n 为“关键数”，如果 n 不能被数列中的其他数字所覆盖。
// 现在给定一系列待验证的数字，我们只需要验证其中的几个关键数，就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字，并按从大到小的顺序输出它们。
// 
// 输入格式：
// 每个测试输入包含 1 个测试用例，第 1 行给出一个正整数 K (<100)，第 2 行给出 K 个互不相同的待验证的正整数 n (1<n≤100)的值，数字间用空格隔开。
// 
// 输出格式：
// 每个测试用例的输出占一行，按从大到小的顺序输出关键数字。数字间用 1 个空格隔开，但一行中最后一个数字后没有空格。
// 
// 输入样例：
// 6
// 3 5 6 7 8 11
//    
// 输出样例：
// 7 6



#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;

bool cmp(int a, int b)
{
	return a > b;
}

int main()
{
	int k, n, flag = 0;
	cin>>k;
	vector<int> v(k);
	map<int, bool> m;
	for(int i = 0; i < k; i++)
	{
		cin>>n;
		v[i] = n;
		while(n != 1)
		{
			if(n % 2 != 0) n = 3 * n + 1;
			n = n / 2;
			if(m[n] == true) break;
			m[n] = true;
		}
	}
	
	sort(v.begin(), v.end(), cmp);
	for(int i = 0; i < v.size(); i++)
	{
		if(m[v[i]] != true)
		{
			if(flag == 1)
				cout<<" ";
			cout<<v[i];
			flag = 1;
		}
	}
	cout<<endl;

	
	return 0;
		
}

1006 换个格式输出整数 (15)

// 让我们用字母 B 来表示“百”、字母 S 表示“十”，用 12...n 来表示不为零的个位数字 n（<10），换个格式来输出任一个不超过 3 位的正整数。例如 234 应该被输出为 BBSSS1234，因为它有 2 个“百”、3 个“十”、以及个位的 4。
// 
// 输入格式：
// 每个测试输入包含 1 个测试用例，给出正整数 n（<1000）。
// 
// 输出格式：
// 每个测试用例的输出占一行，用规定的格式输出 n。
// 
// 输入样例 1：
// 234
//     
// 输出样例 1：
// BBSSS1234
//   
// 输入样例 2：
// 23
//     
// 输出样例 2：
// SS123

#include <iostream>
using namespace std;

int main()
{
	int n, b, s, g;
	cin>>n;
	b = n / 100;
	s = n % 100 / 10;
	g = n % 10;
	
	for(int i = 0; i < b; i++)
		cout<<"B";
	for(int i = 0; i < s; i++)
		cout<<"S";
	for(int i = 0; i < g; i++)
		cout<<i+1;
	cout<<endl;
  return 0;
}

1007 素数对猜想 (20)

题目： 让我们定义 $d_n$ 为： $d_n$ = $p_{n+1}$ − $p_n$ ,其中 $p_i$ 是第i个素数。显然有 $d_1$ = 1，且对于n>1有 $d_n$ 是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。

现给定任意正整数N( < $10^5$ )，请计算不超过N的满足猜想的素数对的个数。

输入格式:
输入在一行给出正整数N。

输出格式:
在一行中输出不超过N的满足猜想的素数对的个数。

输入样例:
20

输出样例:
4

#include <iostream>
#include <cmath>
using namespace std;
const int maxn = 100001;
int prime[maxn], num = 0;
bool p[maxn] = {0};

//prime数组是不超过n的素数表
void findPrime(int n)
{
	for(int i = 2; i <= n; i++)
	{
		if(p[i] == false)
		{
			prime[num++] = i;
			for(int j = i + i; j <= n; j += i)
				p[j] = true;
		}
	}
}
// 2 3 5 7 11 13 15 17 19

int main()
{
	int N, d, ans = 0;
	scanf("%d", &N);
	findPrime(N);
	for(int i = 0; i < num - 1; i++)
	{
		d = prime[i+1] - prime[i];
		if(d == 2)
			ans++;
	}
			
	printf("%d\n", ans);
	
	return 0;
}

1008 数组元素循环右移问题 (20)

题目一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（ ≥ 0）个位置，即将A中的数据由（ $A_0$ $A_1$ ··· $A_{N−1}$ ）变换为（ $A_{N−M}$ ··· $A_{N−1}$ $A_0$ $A_1$ ··· $A_{N−M−1}$ ）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:
每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。

输出格式:
在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例:
6 2
1 2 3 4 5 6

输出样例:
5 6 1 2 3 4

#include <iostream>
using namespace std;
//类似天勤数据结构绪论第一个例子
//前 N-M 个元素逆置， 然后末尾 M 个元素逆置，最后整体逆置一次
//M一定要M%N一次，要不然答案肯定是部分正确，因为那些N倍数位的移动是多余的。

void reverse(int a[], int l, int r)
{
	int i, j, temp;
	for(i = l, j = r; i < j; i++, j--)
	{
		temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
}

int main()
{
	int N, M;
	cin>>N>>M;
	int A[N];
	for(int i = 0; i < N; i++)
		cin>>A[i];
	M %= N;
	reverse(A, 0, N - M - 1);
	reverse(A, N - M, N - 1);
	reverse(A, 0, N - 1);
	
	for(int i = 0; i < N; i++)
	{
		if(i > 0) cout<<" ";
		cout<<A[i];
	}
	cout<<endl;
	return 0;
}

1009 说反话 (20)【部分正确 17】

// 给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。
// 
// 输入格式：
// 测试输入包含一个测试用例，在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用 1 个空格分开，输入保证句子末尾没有多余的空格。
// 
// 输出格式：
// 每个测试用例的输出占一行，输出倒序后的句子。
// 
// 输入样例：
// Hello World Here I Come
// 
// 输出样例：
// Come I Here World Hello

// 类似栈先进后出的操作
// 不用该方法，用begin end指向字符串

#include <iostream>
using namespace std;

int main()
{
	int begin, end, i, j;		//end固定在一个单词的末尾，begin扫描至该单词的头部
	string str;
	getline(cin, str);
	begin = 0, end = str.length();
	
	for(i = str.size() - 1; i >=0;)
	{
		if((str[i] >= 'a' && str[i] <='z') || (str[i] >= 'A' && str[i] <= 'Z'))
		{
			begin = end = i;
			while((str[i] >= 'a' && str[i] <='z') || (str[i] >= 'A' && str[i] <= 'Z'))
				i--;
			begin = i + 1;
			for(j = begin; j <= end; j++)
				cout<<str[j];
			if(i != -1) cout<<" ";
		}
		else 
			i--;
	}
	
	cout<<endl;
	return 0;
}

1010 一元多项式求导 (25)

题目： 设计函数求一元多项式的导数。（注： $x^n$ （n为整数）的一阶导数为 $nx^{n−1}$ 。）

输入格式:
以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过 1000 的整数）。数字间以空格分隔。

输出格式:
以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是 0，但是表示为 0 0。

输入样例:
3 4 -5 2 6 1 -2 0

输出样例:
12 3 -10 1 6 0

#include <iostream>
using namespace std;
int main() 
{
    int a, b, flag = 0;
    while (cin >> a >> b) {
        if (b != 0) {
        if (flag == 1) cout << " ";
        cout << a * b << " " << b - 1;
         flag = 1;
        }  
    }
    if (flag == 0) cout << "0 0";
    return 0;
}

1011 A+B 和 C (15)

题目： 给定区间 [ $2^{31}$ , $2^{31}$ ] 内的 3 个整数 A、B 和 C，请判断 A+B 是否大于 C。

输入格式：

输入第 1 行给出正整数 T (≤10)，是测试用例的个数。随后给出 T 组测试用例，每组占一行，顺序给出 A、B 和 C。整数间以空格分隔。

输出格式：

对每组测试用例，在一行中输出 Case #X: true 如果 A+B>C，否则输出 Case #X: false，其中 X 是测试用例的编号（从 1 开始）。

输入样例：
4
1 2 3
2 3 4
2147483647 0 2147483646
0 -2147483648 -2147483647
输出样例：
Case #1: false
Case #2: true
Case #3: true
Case #4: false

#include <cstdio>



int main()
{
	int T;
	scanf("%d", &T);
	long long a[T][3];
	for(int i = 0; i < T; i++)
		scanf("%lld%lld%lld", &a[i][0], &a[i][1], &a[i][2]);
		
	for(int i = 0; i < T; i++)
		printf("Case #%d: %s\n", i + 1, a[i][0] + a[i][1] > a[i][2] ? "true" : "false"); 
	return 0;
}

1012 说反话 (20)

//最菜的办法
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	int nums[n];
	memset(nums, 0, sizeof(nums));
	for(int i = 0; i < n; i++)
	{
		scanf("%d", &nums[i]);
	}
	
	int A[5] = {0};
	bool flag[5]  = {false};
	double t2 = 0;
	double a3 = 0;
	
	for(int i = 0; i < n; i++)
	{
		switch(nums[i] % 5)
		{
			case 0:
				if(nums[i] % 2 == 0)
				{
					A[0] += nums[i];
					flag[0] = true;
				}
				break;
			case 1:
				{
					A[1] += pow(-1.0, t2)*nums[i];
					t2++;
					flag[1] = true;
				}
				break;
			case 2:
				{
					A[2]++;
					flag[2] = true;
				}
				break;
			case 3:
				{
					A[3] += nums[i];
					a3++;
					flag[3] = true;
				}
				break;
			case 4:
				{
					A[4] = max(A[4], nums[i]);
					flag[4] = true;
				}
				break;
		}
	}
	
	for(int i = 0; i < 5; i++)
	{
		switch(i)
		{
			case 0:
				if(flag[0] == true)
					printf("%d ", A[0]);
				else
					printf("N ");
				break;
			case 1:
				if(flag[1] == true)
					printf("%d ", A[1]);
				else
					printf("N ");
				break;
			case 2:
				if(flag[2] == true)
					printf("%d ", A[2]);
				else
					printf("N ");
				break;
			case 3:
				if(flag[3] == true)
					printf("%.1f ", (double)A[3] / a3);
				else
					printf("N ");
				break;
			case 4:
				if(flag[4] == true)
					printf("%d", A[4]);
				else
					printf("N");
				break;
		}
	}
	
	return 0;
}

1013 数素数 (20)

题目： 令 $P_i$ 表示第 i 个素数。现任给两个正整数 M ≤ N ≤ $10^4$ ，请输出 $P_M$ 到 $P_N$ 的所有素数。

输入格式：

输入在一行中给出 M 和 N，其间以空格分隔。

输出格式：

输出从 $P_M$ 到 $P_N$ 的所有素数，每 10 个数字占 1 行，其间以空格分隔，但行末不得有多余空格。

输入样例：
5 27
输出样例：
11 13 17 19 23 29 31 37 41 43
47 53 59 61 67 71 73 79 83 89
97 101 103

#include <cstdio>
//先找出素数表

const int maxn = 1000001;
int prime[maxn], num = 0;
bool p[maxn] = {false};

void findPrime(int n)
{
	for(int i = 2; i < maxn; i++)
	{
		if(p[i] == false)
		{
			prime[num++] = i;
			if(num > n) break;
			for(int j = i + i; j < maxn; j += i)
			{
				p[j] = true;
			}
		}
	}
}

int main()
{
	int M, N, count = 0;
	scanf("%d%d", &M, &N);
	findPrime(N);
	
	for(int i = M; i <= N; i++)
	{
		printf("%d", prime[i - 1]);
		count++;
		if(count % 10 != 0 && i < N) printf(" ");
		else printf("\n");
	}
	return 0;
}

Yiisen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
PAT Basic Level Practice (中文)

PAT乙级1001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034...
复制链接

扫一扫