PAT乙级考前总结（一)

数学相关的题目

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

直接一步步计数

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 个空格隔开，但一行中最后一个数字后没有空格。

#include <iostream>

#include <cstdio>

#include <algorithm>

using namespace std;

int main()

{

int k,t,f=-1;

int num[100];

cin>>k;

for(int i=0;i<k;++i) scanf("%d",&num[i]);

sort(num,num+k);//从小到大排序

for(int i=0;i<k;i++)

{

if(num[i]>0)//先确定是有效的数

{

//进行变换

int s=num[i];

while(s!=1)

{

if(s%2) s=(3*s+1)/2;

else s/=2;

for(int j=0;j<k;j++)

{

if(s==num[j]) num[j]=-1;//发现重复

}

}

}

}

for(int i=0;i<k;++i)

{

if(num[i]>0)//确定最小的关键数 ,用于控制输出格式

{

f=i;break;

}

}

for(int i=k-1;i>=0;i--)//从大到小输出

{

if(num[i]>0&&i!=f) cout<<num[i]<<' ';

if(num[i]>0&&i==f) cout<<num[i];

}

return 0;

}

1007 素数对猜想 （20 分）

1013 数素数 （20 分）

注意判断素数的方法

Bool su(int k)

{

int sqr=(int)sqrt(1.0*k);

for(int i=2;i<=sqr;i++)

{

if(k%i==0) return false;

}

return true;

}

1008 数组元素循环右移问题 （20 分）

题目略

#include <cstdio>

using namespace std;

int main()

{

int n,m;

int num[110];

scanf("%d %d",&n,&m);

for(int i=0;i<n;++i) scanf("%d",&num[i]);//储存

if(n==1) printf("%d",num[0]);//就一个数直接输出

else

{

m=m%n;//计算出有效的移动，m大于n时

if(m)//其实这里投机取巧了，因为移动后的结果显而易见，所以直接输出

{

for(int i=n-m;i<n;++i) printf("%d ",num[i]);//前半部分

for(int i=0;i<n-m-1;++i) printf("%d ",num[i]);//后半部分

printf("%d",num[n-m-1]);//最后一个数

}else //没有有效移动时原样输出

{

for(int i=0;i<n-1;++i) printf("%d ",num[i]);

printf("%d",num[n-1]);

}

}

return 0;

}

1010 一元多项式求导 （25 分）

参考了大神的做法，每输入一项就可以计算并输出，注意控制格式和0多项式。

#include <cstdio>

using namespace std;

int main()

{

int i=0,x,y,f=1;

while(scanf("%d %d",&x,&y)!=EOF)//判断输入

{

if(y>0)

{

if(f==1)//调整输出格式

{

printf("%d %d",x*y,y-1);f=0;

}else printf(" %d %d",x*y,y-1);

}

}

if(f==1) printf("0 0\n");//0多项式

return 0;

}

1011 A+B 和 C （15 分）

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

不是很懂此题的意图，用long long 型就过了。

1012 数字分类 （20 分）

给定一系列正整数，请按要求对数字进行分类，并输出以下 5 个数字：

A1= 能被 5 整除的数字中所有偶数的和；

A2 = 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n1−n2+n3−n4⋯；

A3= 被 5 除后余 2 的数字的个数；

A4= 被 5 除后余 3 的数字的平均数，精确到小数点后 1 位；

A5= 被 5 除后余 4 的数字中最大数字。

#include <cstdio>

using namespace std;

int main()

{

int n,x,a[5]={},b[5]={};//a纪录结果，b判断

scanf("%d",&n);

int s=0,t=1;

for(int i=0;i<n;i++)

{

scanf("%d",&x);

if(x%5==0&&x%2==0) //第一类

{

a[0]+=x;b[0]=1;

}

if(x%5==1)//第二类

{

b[1]=1;

if(t==1)//交替

{

a[1]+=x;t=0;

}else

{

a[1]-=x;t=1;

}

}

if(x%5==2) //第三类

{

a[2]++;b[2]=1;

}

if(x%5==3) //第四类

{

s++;a[3]+=x;b[3]=1;

}

if(x%5==4)//第五类

{

b[4]=1;

if(x>a[4]) a[4]=x;

}

}

for(int i=0;i<5;i++)

{

if(b[i])//存在时

{

if(i==3) printf("%.1lf ",((double)a[i])/s);//第三类记录的是和，这里要取平均数

else if(i==4) printf("%d",a[i]);

else printf("%d ",a[i]);

}else//不存在时

{

if(i==4) printf("N");

else printf("N ");

}

}

return 0;

}

大整数运算

1017 A除以B （20 分）

本题要求计算 A/B，其中 A 是不超过 1000 位的正整数，B 是 1 位正整数。你需要输出商数 Q 和余数 R，使得 A=B×Q+R 成立。

#include <cstdio>

#include <cstring>

using namespace std;

struct bign//定义大整数

{

int d[1010];

int len;

};

int main()

{

bign a,q;

char str[1010];

int b,r=0;

scanf("%s %d",str,&b);//输入

a.len=strlen(str);

for(int i=0;i<a.len;i++) a.d[i]=str[a.len-i-1]-'0';//从低位写入大整数

q.len=a.len;//先假设q的长度一样

for(int i=a.len-1;i>=0;i--)//计算

{

r=r*10+a.d[i];

if(r<b) q.d[i]=0;

else

{

q.d[i]=r/b;

r=r%b;//更新 r

}

}

while(q.len-1>=1&&q.d[q.len-1]==0)//去除结果中前面多的 0；

{

q.len--;

}

for(int i=q.len-1;i>=0;i--) printf("%d",q.d[i]);//输出

printf(" %d",r);

return 0;

}

1079 延迟的回文数 （20 分）

给定一个 k+1 位的正整数 N，写成 ak⋯a1a0的形式，其中对所有 i 有 0≤ai<10 且 ak>0。N 被称为一个回文数，当且仅当对所有 i 有 ai=ak−i。零也被定义为一个回文数。

非回文数也可以通过一系列操作变出回文数。首先将该数字逆转，再将逆转数与该数相加，如果和还不是一个回文数，就重复这个逆转再相加的操作，直到一个回文数出现。如果一个非回文数可以变出回文数，就称这个数为延迟的回文数。

给定任意一个正整数，本题要求你找到其变出的那个回文数。

输入格式：

输入在一行中给出一个不超过1000位的正整数。

输出格式：

对给定的整数，一行一行输出其变出回文数的过程。每行格式如下

A + B = C

其中 A 是原始的数字，B 是 A 的逆转数，C 是它们的和。A 从输入的整数开始。重复操作直到 C 在 10 步以内变成回文数，这时在一行中输出 C is a palindromic number.；或者如果 10 步都没能得到回文数，最后就在一行中输出 Not found in 10 iterations.。

#include <stdio.h>

#include <string.h>

#include <algorithm>

using namespace std;

struct bign//定义大整数结构

{

int num[1010];

int len;

}a,b;

bool judge(bign a)//判断是否为回文数

{

for(int i=0;i<=a.len/2;i++)

{

if(a.num[i]!=a.num[a.len-1-i]) return false;

}

return true;

}

void print(bign a)//打印

{

for(int i=0;i<a.len;i++) printf("%d",a.num[i]);

}

void change()//变换

{

for(int i=0;i<a.len;i++) b.num[i]=a.num[i];//把a.num复制到b.num

b.len=a.len;

reverse(b.num,b.num+a.len);//反转b.num

print(a);printf(" + ");print(b);//打印

for(int i=0;i<a.len;i++)//大整数加法

{

if(a.num[i]+b.num[i]>=10)

{

a.num[i]+=b.num[i]-10;

if(i==a.len-1)

{

a.num[i+1]=1;a.len++;

}else a.num[i+1]++;

}else a.num[i]+=b.num[i];

}

reverse(a.num,a.num+a.len);//由于之前是为了计算方便而从低位开始储存的，所以要反转

printf(" = ");print(a);printf("\n");//打印

}

char str[1010];

int main()

{

scanf("%s",str);

int l=strlen(str);

for(int i=0;i<l;i++) a.num[i]=str[i]-'0';

a.len=l;

if(judge(a))

{

print(a);printf(" is a palindromic number.");return 0;

}

change();

for(int i=1;i<10;i++)

{

if(judge(a))

{

print(a);printf(" is a palindromic number.");return 0;

}else

{

change();

}

}

printf("Not found in 10 iterations.");

return 0;

}

1019 数字黑洞 （20 分）

题略

#include <cstdio>

#include <algorithm>

using namespace std;

void z(int k)

{

int max=0,min=0,temp[4]={};

for(int i=0;i<4;i++)//将每一位写入数组

{

if(k) temp[i]=k%10;

k/=10;

}

sort(temp,temp+4);//从小到大排序

for(int i=0;i<4;i++)//转换成整数

{

max=max*10+temp[3-i];

min=min*10+temp[i];

}

printf("%04d - %04d = %04d\n",max,min,max-min);

if(max-min==6174||max-min==0) return;//判断是否结束

z(max-min); //递归调用

}

int main()

{

int n;

scanf("%d",&n);

z(n);

return 0;

}

1056 组合数的和 （15 分）根据题意计算咯

1049 数列的片段和 （20 分）

给定一个正数数列，我们可以从中截取任意的连续的几个数，称为片段。例如，给定数列 { 0.1, 0.2, 0.3, 0.4 }，我们有 (0.1) (0.1, 0.2) (0.1, 0.2, 0.3) (0.1, 0.2, 0.3, 0.4) (0.2) (0.2, 0.3) (0.2, 0.3, 0.4) (0.3) (0.3, 0.4) (0.4) 这 10 个片段。

给定正整数数列，求出全部片段包含的所有的数之和。如本例中 10 个片段总和是 0.1 + 0.3 + 0.6 + 1.0 + 0.2 + 0.5 + 0.9 + 0.3 + 0.7 + 0.4 = 5.0。

输入格式：

输入第一行给出一个不超过 10^5的正整数 N，表示数列中数的个数，第二行给出 N 个不超过 1.0 的正数，是数列中的数，其间以空格分隔。

输出格式：

在一行中输出该序列所有片段包含的数之和，精确到小数点后 2 位。

发现规律，每个数总共加了多少次。

#include <cstdio>

#include <algorithm>

using namespace std;

double d[100010];

int main()

{

int n;double sum=0;

scanf("%d",&n);

for(int i=0;i<n;i++) scanf("%lf",&d[i]);

for(int i=0;i<n;i++)

{

int t=n-i;

sum+=t*d[i]*(i+1);

}

printf("%.2lf",sum);

return 0;

}

1084 外观数列 （20 分）

外观数列是指具有以下特点的整数序列：

d, d1, d111, d113, d11231, d112213111, ...

它从不等于 1 的数字 d 开始，序列的第 n+1 项是对第 n 项的描述。比如第 2 项表示第 1 项有 1 个 d，所以就是 d1；第 2 项是 1 个 d（对应 d1）和 1 个 1（对应 11），所以第 3 项就是 d111。又比如第 4 项是 d113，其描述就是 1 个 d，2 个 1，1 个 3，所以下一项就是 d11231。当然这个定义对 d = 1 也成立。本题要求你推算任意给定数字 d 的外观数列的第 N 项。

输入格式：

输入第一行给出 [0,9] 范围内的一个整数 d、以及一个正整数 N（≤ 40），用空格分隔。

输出格式：

在一行中给出数字 d 的外观数列的第 N 项。

#include <stdio.h>

using namespace std;

int main()

{

int n,d,temp,pre[100000],ans[100000],sum,t,l=1;

scanf("%d%d",&d,&n);//pre记录前一项

ans[0]=d;pre[0]=d;

for(int i=2;i<=n;i++)

{

t=1;sum=0;temp=pre[0];//初始值

for(int j=0;j<l;j++)

{

if(pre[j]==temp) sum++;//sum记录连续重复的数

else

{

temp=pre[j];ans[t++]=sum;sum=1;ans[t++]=temp;//遇到新的数就要更新

}

if(j+1==l) ans[t++]=sum;//

}

l=t;//l纪录此项长度

for(int j=0;j<l;j++) pre[j]=ans[j];//更新pre，用于下一次循环

}

for(int i=0;i<l;i++) printf("%d",ans[i]);//输出

return 0;

}

1051 复数乘法 （15 分）

在判断是否为0时，因为是double型的，这里用了一个超小数来判断。

#include <stdio.h>

#include <math.h>

using namespace std;

#define eps 0.01

int main()

{

double r1,p1,r2,p2;

scanf("%lf%lf%lf%lf",&r1,&p1,&r2,&p2);

double a=r1*cos(p1)*r2*cos(p2)-r1*sin(p1)*r2*sin(p2);

if(fabs(a)<eps) a=0;

double b=r1*cos(p1)*r2*sin(p2)+r1*sin(p1)*r2*cos(p2);

if(fabs(b)<eps) b=0;

if(b<0) printf("%.2lf-%.2lfi",a,fabs(b));

else  printf("%.2lf+%.2lfi",a,b);

return 0;

}

1060 爱丁顿数 （25 分）

英国天文学家爱丁顿很喜欢骑车。据说他为了炫耀自己的骑车功力，还定义了一个“爱丁顿数” E ，即满足有 E 天骑车超过 E 英里的最大整数 E。据说爱丁顿自己的 E 等于87。

现给定某人 N 天的骑车距离，请你算出对应的爱丁顿数 E（≤N）。

输入格式：

输入第一行给出一个正整数 N (≤10^5)，即连续骑车的天数；第二行给出 N 个非负整数，代表每天的骑车距离。

输出格式：

在一行中给出 N 天的爱丁顿数。

科学家爱搞事情

#include <stdio.h>

#include <algorithm>

using namespace std;

int ride[100010];

int main()

{

int n,e=0;

scanf("%d",&n);

for(int i=1;i<=n;i++)

{

scanf("%d",&ride[i]);

}

sort(ride+1,ride+n+1);//从小到大排序

for(int i=1;i<=n;i++)

{

if(ride[i]>n-i+1)//当出现第一个骑行数大于n-i天数时即为所求

{

e=n-i+1;break;

}

}

printf("%d",e);

return 0;

}

1062 最简分数 （20 分）

一个分数一般写成两个整数相除的形式：N/M，其中 M 不为0。最简分数是指分子和分母没有公约数的分数表示形式。

现给定两个不相等的正分数 N1/M1和N2/M2，要求你按从小到大的顺序列出它们之间分母为 K 的最简分数。

输入格式：

输入在一行中按 N/M 的格式给出两个正分数，随后是一个正整数分母 K，其间以空格分隔。题目保证给出的所有整数都不超过 1000。

输出格式：

在一行中按 N/M 的格式列出两个给定分数之间分母为 K 的所有最简分数，按从小到大的顺序，其间以 1 个空格分隔。行首尾不得有多余空格。题目保证至少有 1 个输出。

#include <stdio.h>

#include <vector>

#include <math.h>

using namespace std;

vector<int> num;

int gcd(int a,int b)//求最大公约数

{

if(b==0) return a;

else return gcd(b,a%b);

}

//定义分数结构

struct fen{

int up;int down;

}a,b;

int main()

{

int k;

scanf("%d/%d %d/%d %d",&a.up,&a.down,&b.up,&b.down,&k);

double begin=(double)a.up*k/a.down,end=(double)b.up*k/b.down;//确定上下界

if(begin>end) //由于不知道两个输入谁大谁小所以要判断一下

{

double t=begin;

begin=end;end=t;

}

for(int i=floor(begin)+1;i<ceil(end);i++)//由于是整数所以要分别向下取整和向上取整

{

if(gcd(i,k)==1) num.push_back(i); //如果正好是最简，则将分子存入num

}

for(int i=0;i<num.size();i++)

{

if(i==0) printf("%d/%d",num[i],k);

else printf(" %d/%d",num[i],k);

}

return 0;

}

1034 有理数四则运算 （20 分）

本题要求编写程序，计算 2 个有理数的和、差、积、商。

输入格式：

输入在一行中按照 a1/b1 a2/b2 的格式给出两个分数形式的有理数，其中分子和分母全是整型范围内的整数，负号只可能出现在分子前，分母不为 0。

输出格式：

分别在 4 行中按照 有理数1 运算符 有理数2 = 结果 的格式顺序输出 2 个有理数的和、差、积、商。注意输出的每个有理数必须是该有理数的最简形式 k a/b，其中 k 是整数部分，a/b 是最简分数部分；若为负数，则须加括号；若除法分母为 0，则输出 Inf。题目保证正确的输出中没有超过整型范围的整数。

这一题更为复杂了，不得不参考了书上的做法，对于处理分数的一些套路，考前复习复习啊，此处就不好意思贴代码啦

1063 计算谱半径 （20 分）

居然就是个求最大值的问题

1064 朋友数 （20 分）

如果两个整数各位数字的和是一样的，则被称为是“朋友数”，而那个公共的和就是它们的“朋友证号”。例如 123 和 51 就是朋友数，因为 1+2+3 = 5+1 = 6，而 6 就是它们的朋友证号。给定一些整数，要求你统计一下它们中有多少个不同的朋友证号。

用set存每一个输入计算的结果，自动去重排序。

1087 有多少不同的值 （20 分）和1064一样的解法。

进制转换

1022 D进制的A+B （20 分）

1037 在霍格沃茨找零钱 （20 分）

1074 宇宙无敌加法器 （20 分）

地球人习惯使用十进制数，并且默认一个数字的每一位都是十进制的。而在 PAT 星人开挂的世界里，每个数字的每一位都是不同进制的，这种神奇的数字称为“PAT数”。每个 PAT 星人都必须熟记各位数字的进制表，例如“……0527”就表示最低位是 7 进制数、第 2 位是 2 进制数、第 3 位是 5 进制数、第 4 位是 10 进制数，等等。每一位的进制 d 或者是 0（表示十进制）、或者是 [2，9] 区间内的整数。理论上这个进制表应该包含无穷多位数字，但从实际应用出发，PAT 星人通常只需要记住前 20 位就够用了，以后各位默认为 10 进制。

在这样的数字系统中，即使是简单的加法运算也变得不简单。例如对应进制表“0527”，该如何计算“6203 + 415”呢？我们得首先计算最低位：3 + 5 = 8；因为最低位是 7 进制的，所以我们得到 1 和 1 个进位。第 2 位是：0 + 1 + 1（进位）= 2；因为此位是 2 进制的，所以我们得到 0 和 1 个进位。第 3 位是：2 + 4 + 1（进位）= 7；因为此位是 5 进制的，所以我们得到 2 和 1 个进位。第 4 位是：6 + 1（进位）= 7；因为此位是 10 进制的，所以我们就得到 7。最后我们得到：6203 + 415 = 7201。

输入格式：

输入首先在第一行给出一个 N 位的进制表（0 < N ≤ 20），以回车结束。 随后两行，每行给出一个不超过 N 位的非负的 PAT 数。

输出格式：

在一行中输出两个 PAT 数之和。

#include <stdio.h>

#include <string.h>

#include <algorithm>

using namespace std;

int jz[22]={0},a[22]={0},b[22]={0},c[22]={0};//储存

char str[22];

void change(char *s,int *z)//将字符串转换成数组

{

int l=strlen(s);

for(int i=0;i<l;i++) z[i]=s[l-1-i]-'0';

}

int main()

{

scanf("%s",str);

change(str,jz);//记录进制数组

scanf("%s",str);

change(str,a);int la=strlen(str);//记录第一个数

scanf("%s",str);

change(str,b);int lb=strlen(str);//记录第二个数

int lc=max(la,lb);//取最长的

for(int i=0;i<lc;i++)

{

int top;//确定此位的进制

if(jz[i]==0) top=10;else top=jz[i];

c[i]+=a[i]+b[i];//加法

if(c[i]>=top)//进位

{

c[i+1]+=c[i]/top;

c[i]%=top;

}

}

if(lc==1&&c[0]==0)

{

printf("0");return 0;

}

while(c[lc]!=0)//由于可能存在进位所以在循环后这一项可能不为0

{

lc++;

int top;

if(jz[lc-1]==0) top=10;else top=jz[lc-1];

c[lc]+=c[lc-1]/top;

c[lc-1]%=top;

}//加长后，虽然没有加数了，但由于进制，可能还会进位

reverse(c,c+lc);//反转

bool f=false;//控制输出，因为之前将数组初始化为0，反转后前面的0是无效的

for(int i=0;i<lc;i++)

{

if(c[i]) f=true;

if(f||lc==1) printf("%d",c[i]);

}

printf("\n");

return 0;

}

最后一个点死活过不了，据说是0+0，但是这一点我加上了还是不行。。

看到大佬的方法，用string储存，可以直接用+拼接，方法比较简洁。