本文为PAT甲级分类汇编系列文章。

计算类,指以数学运算为主或为背景的题。

题号 标题 分数 大意
1058 A+B in Hogwarts 20 特殊进制加法
1059 Prime Factors 25 分解素因数
1060 Are They Equal 25 一定精度下两数是否相等
1065 A+B and C (64bit) 20 大数加法与比较
1069 The Black Hole of Numbers 20 黑洞数
1073 Scientific Notation 20 科学计数法还原
1081 Rational Sum 20 有理数加法
1088 Rational Arithmetic 20 有理数运算
1096 Consecutive Factors 20 最长连续因数
1100 Mars Numbers 20 进制转换

这类题,普遍分数低,大多是20分。20分题放到乙级也没啥问题,比如1069、1081等。然而,即使是20分题,也可能要卡很久。

我挑了1059106510881096共4道来做。

1059:

题目要求输出一个数的素因数分解。这么简单的题就不多讲了吧,直接上代码:

 #include <iostream>
#include <map>
#include <cmath> bool isprime(int n)
{
int end = std::sqrt(n) + ;
for (int i = ; i != end; ++i)
if (n % i == )
return false;
return true;
} int main(int argc, char const *argv[])
{
long n;
std::cin >> n;
std::cout << n << '=';
if (n == )
{
std::cout << '';
return ;
}
std::map<int, int> factors;
int prime = ;
while (n > )
{
if (isprime(prime) && n % prime == )
{
++factors[prime];
n /= prime;
}
else
++prime;
}
int count = ;
for (const auto& pair : factors)
{
if (count++)
std::cout << '*';
std::cout << pair.first;
if (pair.second > )
std::cout << '^' << pair.second;
}
return ;
}

其实用 std::vector 也是可以的,但我懒。

需要注意的是 n== 的检查,不过这个很容易发现。

1065:

要求判断两个64位整数相加是否大于另一个数。注意两个64位整数相加以后如果还保存在64位整数中是可能溢出的,并且test case里面一定会有这种情况。

所以要用更大的整数来做计算。然而C++标准库中并没有提供128位整数。这时,伟大的g++出现了,它提供了 __int128_t :

 #include <iostream>

 int main(int argc, char const *argv[])
{
int t;
std::cin >> t;
std::cout << std::boolalpha; for (int i = ; i <= t; ++i)
{
__int128_t a, b, c;
int64_t ta, tb, tc;
std::cin >> ta >> tb >> tc;
a = ta; b = tb; c = tc;
std::cout << "Case #" << i << ": " << (a + b > c) << std::endl;
} return ;
}

于是这道题就被秒了。

C++标准库对整数类型的支持不太好,大整数的类只能自己写。至于是以二进制存储还是以十进制存储,那要看应用场景了。

1088:

在一个case上卡了好久,最后发现题目里有一句要用 long int ,WCNM。

难度没什么的,主要是对分子和分母有0或1的特殊情况的处理。

优雅的我写了一份很优雅的实现,又是template又是运算符重载的:

 #include <iostream>
#include <exception> template <typename T>
class Rational
{
public:
Rational() = default;
Rational(T _num, T _den)
: numerator(_num), denominator(_den)
{
reduce();
}
Rational(const Rational&) = default;
Rational& operator=(const Rational&) = default; Rational operator+(const Rational& _rhs) const noexcept
{
return Rational(numerator * _rhs.denominator + _rhs.numerator * denominator,
denominator * _rhs.denominator);
}
Rational operator-(const Rational& _rhs) const noexcept
{
return Rational(numerator * _rhs.denominator - _rhs.numerator * denominator,
denominator * _rhs.denominator);
}
Rational operator*(const Rational& _rhs) const noexcept
{
return Rational(numerator * _rhs.numerator,
denominator * _rhs.denominator);
}
Rational operator/(const Rational& _rhs) const
{
if (_rhs.numerator == )
throw std::exception();
return Rational(numerator * _rhs.denominator,
denominator * _rhs.numerator);
} template <typename U>
friend std::istream& operator>>(std::istream&, Rational<U>&);
template <typename U>
friend std::ostream& operator<<(std::ostream&, const Rational<U>&);
private:
static T gcd(T _lhs, T _rhs)
{
if (_lhs < )
_lhs = -_lhs;
if (_lhs < _rhs)
return gcd(_rhs, _lhs);
if (_rhs == )
return _lhs ? _lhs : ;
return gcd(_rhs, _lhs % _rhs);
} void reduce()
{
if (denominator < )
{
numerator = -numerator;
denominator = -denominator;
}
auto factor = gcd(numerator, denominator);
numerator /= factor;
denominator /= factor;
} T numerator;
T denominator;
}; template <typename T>
std::istream& operator>>(std::istream& _is, Rational<T>& _r)
{
T n, d;
std::cin >> n;
std::cin.get();
std::cin >> d;
_r = Rational<T>(n, d);
return _is;
} template <typename T>
std::ostream& operator<<(std::ostream& _os, const Rational<T>& _r)
{
auto r = _r;
bool neg = false;
if (r.numerator < )
{
neg = true;
r.numerator = -r.numerator;
_os << "(-";
}
if (r.denominator == )
_os << r.numerator;
else
{
if (r.numerator >= r.denominator)
{
_os << (r.numerator / r.denominator) << ' ';
r.numerator %= r.denominator;
}
_os << r.numerator << '/' << r.denominator;
}
if (neg)
_os << ')';
return _os;
} int main(int argc, char const *argv[])
{
Rational<long long> lhs, rhs;
std::cin >> lhs >> rhs;
std::cout << lhs << " + " << rhs << " = " << (lhs + rhs) << std::endl;
std::cout << lhs << " - " << rhs << " = " << (lhs - rhs) << std::endl;
std::cout << lhs << " * " << rhs << " = " << (lhs * rhs) << std::endl;
std::cout << lhs << " / " << rhs << " = ";
try
{
std::cout << (lhs / rhs) << std::endl;
}
catch(const std::exception& e)
{
std::cout << "Inf" << std::endl;
}
return ;
}

优雅个屁,考试要来不及的。

顺便讲讲写自定义类(特指有成员方法的类而非简单的结构体)和模板的技巧。

构造函数最好给一个默认的,Rule of Three/Five规定的方法最好显式 =default 写出来。

参数尽量用引用,看情况要不要加 const ,大多都是要加的。相应地,成员方法能用 const 修饰的一定要加上去。

对于模板类的友元函数,模板类中还要再套模板,而且要用不一样的类型名称。

以上规则如果不遵守,很可能会编译错误,而且错误信息看起来比较累。

1096:

要求输出给定整数的的分解中可以出现的最长连续因数。乍一看有一点难,但稍微想一想就会发现,这串因数不会太长,因为阶乘是很大的。所以可以一个一个试这串因数中的最小数,连续很多个因数只有没几种情况需要试,到连续两个的情况,也是O(sqrt(n))时间复杂度能搞定的。至于单个因数则需要单独讨论一下,因为试到根号n就可以了,而如果不停止的话会超时。

 #include <iostream>
#include <utility>
#include <cmath> int main(int argc, char const *argv[])
{
int n;
std::cin >> n; try
{
for (int count = ; count > ; --count)
{
for (int min = ; ; ++min)
{
long product = ;
for (int factor = min; factor != min + count; ++factor)
product *= factor;
if (product > n)
break;
if (n % product == )
throw std::pair<int, int>(count, min);
}
}
int end = std::sqrt(n) + ;
for (int factor = ; factor != end; ++factor)
if (n % factor == )
throw std::pair<int, int>(, factor);
throw std::pair<int, int>(, n);
}
catch(const std::pair<int, int>& pair)
{
std::cout << pair.first << std::endl;
for (int i = pair.second; i != pair.second + pair.first - ; ++i)
std::cout << i << '*';
std::cout << pair.second + pair.first - << std::endl;
} return ;
}

长度的初始值是11,是因为2*3*...*13是大于2^31的,而2*3*...*12是小于2^31的,因此长度不会超过11。

总之,计算类题目没有难度,但是要避坑。坑依然是边界条件,包括最小的数(0、1、2等)与很大的数(int放不下的)。

PAT甲级题分类汇编——计算的更多相关文章

  1. PAT甲级题分类汇编——杂项

    本文为PAT甲级分类汇编系列文章. 集合.散列.数学.算法,这几类的题目都比较少,放到一起讲. 题号 标题 分数 大意 类型 1063 Set Similarity 25 集合相似度 集合 1067 ...

  2. PAT甲级题分类汇编——图

    本文为PAT甲级分类汇编系列文章. 图,就是层序遍历和Dijkstra这一套,#include<queue> 是必须的. 题号 标题 分数 大意 时间 1072 Gas Station 3 ...

  3. PAT甲级题分类汇编——树

    本文为PAT甲级分类汇编系列文章. AVL树好难!(其实还好啦~) 我本来想着今天应该做不完树了,没想到电脑里有一份讲义,PPT和源代码都有,就一遍复习一遍抄码了一遍,更没想到的是编译一遍通过,再没想 ...

  4. PAT甲级题分类汇编——理论

    本文为PAT甲级分类汇编系列文章. 理论这一类,是让我觉得特别尴尬的题,纯粹是为了考数据结构而考数据结构.看那Author一栏清一色的某老师,就知道教数据结构的老师的思路就是和别人不一样. 题号 标题 ...

  5. PAT甲级题分类汇编——排序

    本文为PAT甲级分类汇编系列文章. 排序题,就是以排序算法为主的题.纯排序,用 std::sort 就能解决的那种,20分都算不上,只能放在乙级,甲级的排序题要么是排序的规则复杂,要么是排完序还要做点 ...

  6. PAT甲级题分类汇编——线性

    本文为PAT甲级分类汇编系列文章. 线性类,指线性时间复杂度可以完成的题.在1051到1100中,有7道: 题号 标题 分数 大意 时间 1054 The Dominant Color 20 寻找出现 ...

  7. PAT甲级题分类汇编——序言

    今天开个坑,分类整理PAT甲级题目(https://pintia.cn/problem-sets/994805342720868352/problems/type/7)中1051~1100部分.语言是 ...

  8. 【转载】【PAT】PAT甲级题型分类整理

    最短路径 Emergency (25)-PAT甲级真题(Dijkstra算法) Public Bike Management (30)-PAT甲级真题(Dijkstra + DFS) Travel P ...

  9. PAT甲级题解分类byZlc

    专题一  字符串处理 A1001 Format(20) #include<cstdio> int main () { ]; int a,b,sum; scanf ("%d %d& ...

随机推荐

  1. ubuntu之路——day11.2 快速搭建系统并进行迭代、在不同的划分上进行训练和测试

    快速搭建系统并进行迭代 1.建立dev/test set,并确定你的目标 2.快速建立初始化的系统 3.使用前面提到的bias/variance分析和错误分析来进行模型优化和迭代 针对以上的过程,An ...

  2. sql server 自增列,值突然增大1000的情况

    sql server 自增列,值突然增大1000的情况   解决方法: 1 打开配置管理器2左面点击sql服务3右面 右键点击SQL Server(MSSQLSERVER) 4点击 启动参数5 在参数 ...

  3. Vue CLI3和Vue CLI2环境搭建

    关于 Vue CLI 旧版本的安装以及创建项目 1.搭建 vue 的开发环境 ,安装 vue 的脚手架工具 官方命令行工具 npm install --global vue-cli / cnpm in ...

  4. osg编译日志

    1>------ 已启动全部重新生成: 项目: ZERO_CHECK, 配置: Debug x64 ------1> Checking Build System1> CMake do ...

  5. Java8的时间日期API

    原先的时间 api  大部分已经过时了 Date构造器 需要传入年月日  但是对时间的加减操作比较麻烦 Calenda  加减比较方便 使用 LocalDate. LocalTime. LocalDa ...

  6. Qt编写数据可视化大屏界面电子看板13-基础版

    一.前言 之前发布的Qt编写的可视化大屏电子看板系统,很多开发者比较感兴趣,也收到了很多反馈意见,纵观市面上的大屏系统,基本上都是B/S结构的web版本,需要在后台进行自定义配置模块,绑定数据源等,其 ...

  7. python flask框架学习(三)——豆瓣微信小程序案例(二)整理封装block,模板的继承

    我们所要实现的效果: 点击电影的更多,跳转到更多的电影页面:点击电视剧的更多,跳转到更多的电视剧页面. 三个页面的风格相同,可以设置一个模板,三个页面都继承这个模板 1.在指定模板之前,把css放在一 ...

  8. 函数返回new对象

    #include <iostream> using namespace std; // foo()函数本质上没什么问题,但建议你不要这样写代码 string &foo() { st ...

  9. 【计算机视觉】OpenCV篇(9) - 轮廓(寻找/绘制轮廓)

    什么是轮廓? 轮廓是一系列相连的点组成的曲线,代表了物体的基本外形. 轮廓与边缘好像挺像的? 是的,确实挺像,那么区别是什么呢?简而言之,轮廓是连续的,而边缘并不全都连续(见下图示例).其实边缘主要是 ...

  10. k8s中实现永久无法删除一个pod---也就是在deployment.yaml中定义副本数量

    参照:https://www.cnblogs.com/effortsing/p/10486960.html 这里面的deployment.yaml对应的pod就是永久无法删除的