#!/usr/bin/env-python
#编码：utf8
'''
数学多于：mod:`math`标准库，没有numpy
'''
从 __未来__ 进口 分开 #到处都是“真正的分裂”
__作者__ = “菲利普·古列尔梅蒂”
__版权__ = “版权所有2012，Philippe Guglielmetti”
__学分__ = [
"https://pypi.python.org/pypi/primefac"
"https://github.com/tokland/pyeuler/blob/master/pyeulel/toolset.py",
"http://blog.dreamshire.com/common-functions-routines-project-euler/",
]
__许可证__ = “LGPL”
进口 六, 测井
从 六个移动 进口 地图, 减少, 滤波器, zip_最长, 范围
进口 数学, 数学库, 操作人员, itertools软件, 分数, 数字, 随机的，随机的
从 古利卜 进口 itertools2, 装饰师
inf公司=浮动(“Inf”) #无穷大
每股收益 = 2.2204460492503131e-16号 #numpy.finfo（np.float64）.eps
尝试:
南=数学.南
除了:
南=浮动(“南”) #不是数字
#定义一些在所有支持的python版本中都不可用的数学函数
尝试:
化学机械抛光=数学.合作管理计划
除了 属性错误:
[文档] 定义 合作管理计划(x个,年):
“”比较两个对象x和y，并根据结果返回一个整数。
如果x<y，则返回值为负值；如果x==y，则为零；如果x>y，则严格为正值。
'''
返回 签名(x个-年)
尝试:
日志2=数学.日志2
除了 属性错误:
定义 日志2(x个):返回 数学.日志(x个,2)
尝试:
isclose公司=数学.isclose公司
除了 属性错误:
定义 isclose公司(一, b条, 关系（_T）=2009年1月, 绝对值（_T）=0):
''大致相等。在浮点运算中使用此选项而不是a==b
实施https://www.python.org/dev/peps/pep-0485/
：param a，b：要测试相对接近度的两个值
：param rel_tol：相对公差
它是相对于a或b的较大绝对值允许的误差量。
例如，要将公差设置为5%，则传递tol=0.05。
默认公差为1e-9，确保两个值在
大约9位十进制数字。rel_tol必须大于0.0
：param abs_tol：最小绝对公差级别--用于接近零的比较。
'''
# https://github.com/PythonCHB/close_pep/blob/master/isclose.py
如果 一 == b条: #短路精确相等
返回 真的
如果 rel_tol（rel_tol） < 0 或 绝对值（_T） < 0:
提升 值错误('错误容差必须为非负')
#使用cmath，这样它就可以处理复杂的ot浮点
如果 数学.isinf公司(防抱死制动系统(一)) 或 数学.isinf公司(防抱死制动系统(b条)):
#这包括两个无穷大相反符号的情况，或
#一个无穷大和一个有限数。相反符号的两个无穷大
#否则会有无限的相对公差。
返回 False（错误）
差异 = 防抱死制动系统(b条 - 一)
返回 (((差异 <= 防抱死制动系统(rel_tol（rel_tol） * b条)) 或
(差异 <= 防抱死制动系统(关系（_T） * 一))) 或
(差异 <= 绝对值（_T）))
[文档]定义 全部关闭(一, b条, 关系（_T）=2009年1月, 绝对值（_T）=0):
“”：return：如果两个数组在一个容差内按元素相等，则为True。“”
#https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.allclose.html
对于 x个,年 在里面 zip_最长(一,b条):
如果 x个 是 无 或 年 是 无:
返回 False（错误）
如果 不 isclose公司(x个 ,年 , 关系（_T）=关系（_T）, 绝对值（_T）=绝对值（_T）):
返回 False（错误）
返回 真的
#基本有用功能
[文档]定义 is编号（_N）(x个):
“”：return:如果x是任何类型的数字，包括Complex“”，则返回True
# http://stackoverflow.com/questions/4187185/how-can-i-checkif-my-python-object-is-a-number
返回 isinstance公司(x个, 数字.编号)
[文档]定义 is_complex（复杂）(x个):
返回 isinstance公司(x个,复杂的)
[文档]定义 实际（_R）(x个):
返回 is_number（编号）(x个) 和 不 is_complex（复杂）(x个)
[文档]定义 签名(数):
“”：返回：如果数字为正，则返回1；如果数字为负，则返回-1；如果==0，则返回0“”
如果 数<0:
返回 -1
如果 数>0:
返回 1
返回 0
#四舍五入
[文档]定义 打印(v（v）):
'''
：return：最接近浮点v的int值
'''
返回 整数(圆(v（v）))
[文档]定义 集成（_I）(x个, 关系（_T）=0, 绝对值（_T）=0):
'''
：return：如果float x是公差范围内的整数，则为True
'''
如果 isinstance公司(x个, 六.整数类型):
返回 真的
尝试:
如果 关系（_T）+绝对值（_T）==0:
返回 x个==打印(x个)
返回 isclose公司(x个,圆(x个),关系（_T）=关系（_T）,绝对值（_T）=绝对值（_T）)
除了 类型错误: #对于复合物
返回 False（错误）
[文档]定义 整数或浮点(x个, 关系（_T）=0, 绝对值（_T）=0):
'''
：param x:int或float
：return:int，如果x（几乎）是整数，否则为float
'''
返回 打印(x个) 如果 集成（_I）(x个, 关系（_T）, 绝对值（_T）) 其他的 x个
#数学函数的改进版本
[文档]定义 gcd公司(*参数):
''任意数量参数的最大公约数''
#http://code.activestate.com/recipes/577512-gcd-of-an-任意列表/
L（左） = 列表(参数) #如果生成了参数
b条=L（左）[0] #如果只有一个参数，将返回
虽然 伦恩(L（左）) > 1:
一 = L（左）[-2]
b条 = L（左）[-1]
L（左） = L（左）[:-2]
虽然 一:
一, b条 = b条%一, 一
L（左）.追加(b条)
返回 防抱死制动系统(b条)
[文档]定义 生命周期管理(*参数):
“”“任意数量整数的最小公共倍数”“”
如果 伦恩(参数)<=2:
返回 穆尔(参数) // gcd公司(*参数)
#TODO:更好
物件=生命周期管理(参数[0],参数[1])
对于 n个 在里面 参数[2:]:
物件=生命周期管理(物件,n个)
返回 物件
[文档]定义 xgcd公司(一,b条):
''扩展GCD
：return：（gcd，x，y）其中gcd是a和b的最大公约数
如果b非零，用b的符号；如果b为0，用a的符号。
数字x，y是这样的，即gcd=ax+by.''
#取自http://anh.cs.luc.edu/331/code/xgcd.py
上一版本, x个 = 1, 0; 肉汤, 年 = 0, 1
虽然 b条:
q个, 第页 = divmod公司(一,b条)
x个, 上一版本 = 上一版本 - q个*x个, x个
年, 肉汤 = 肉汤 - q个*年, 年
一, b条 = b条, 第页
返回 一, 上一版本, 肉汤
[文档]定义 互质(*参数):
“”：return:如果参数彼此互质，则为True“”
返回 gcd公司(*参数)==1
[文档]定义 互质_gen(限制):
“”生成互质对
使用Farey序列
'''
# https://www.quora.com/What-are-the-fastst-algorithms-for-generating-coprime-pairs（网址：https://www.quora.com/What-are-the-fastst-algorithms-for-generating-coprime-pairs）
推迟决定 = []
n个,d日 = 0,1 #n，d是起始分数n/d（0,1）
N个 = D类 = 1 #N，D是初始停止分数N/D（1,1）
虽然 真的:
媒体_ = d日 + D类
如果 媒体_ <= 限制:
中位数n = n个 + N个
推迟决定.追加((中位数n, 媒体_, N个, D类))
N个 = 中位数n
D类 = 介质_d
其他的:
产量 n个, d日 #分子/分母
如果 推迟决定:
n个, d日, N个, D类 = 推迟决定.流行音乐()
其他的:
打破
[文档]定义 卡迈克尔(n个):
'''
Carmichael函数
：return:int最小正整数m，这样，对于1到n之间的每一个与n互素的整数a，a ^m mod n=1。
：参数n:int
：请参阅：https://en.wikipedia.org/wiki/Carmichael_function网站
：参见：https://oeis.org/A002322
也称为约化总指数函数或最小通用指数函数。
'''
互质 = [x个 对于 x个 在里面 范围(1, n个) 如果 gcd公司(x个, n个) == 1]
k个 = 1
虽然 不 全部的(功率(x个, k个, n个) == 1 对于 x个 在里面 互质):
k个 += 1
返回 k个
#https://en.wikipedia.org/wiki/Primitive_root_module_n
#代码分解自http://stackoverflow.com/questions/40190849/efficient-finding-primitive-roots-moduleo-n-using-python
[文档]定义 is_primitive_root(x个,米,秒={}):
如果x是m的本原根，则“”返回True
：param s：m的互素集（如果已知）
'''
如果 不 秒:
秒={n个 对于 n个 在里面 范围(1, 米) 如果 互质(n个, 米) }
返回 {功率(x个, 第页, 米) 对于 第页 在里面 范围(1, 米)}==秒
[文档]定义 基本根根(米):
“”“生成模m的本原根”“”
必需设置 = {号码 对于 号码 在里面 范围(1, 米) 如果 互质(号码, 米) }
对于 n个 在里面 范围(1, 米):
如果 is_primitive_root(n个,米,必需_集):
产量 n个
[文档]定义 基元根(模):
返回 列表(基本根根(模))
[文档]定义 方庭(一, b条, c（c）, allow_complex（允许复合）=False（错误）):
“”求解二次方程aX^2+bX+c=0
：参数a、b、c：浮点
：param allow_complex：如果为True，函数将返回复数根
：return:x1，x2实际或复杂解决方案
'''
鉴别的 = b条*b条 - 4 *一*c（c）
如果 allow_complex（允许复合）:
d日=数学库.平方英尺(鉴别的)
其他的:
d日=数学.平方英尺(鉴别的)
返回 (-b条 + d日) / (2*一), (-b条 - d日) / (2*一)
[文档]定义 塞尔迪夫(一, b条):
返回 -(-一 // b条) #简单而聪明
[文档]定义 首次公开募股(x个,年,z（z）=0):
'''
：param x：number（int或float）
：param y:int功率
：param z:int可选模量
：如果可能，返回：（x**y）%z作为整数
'''
如果 年<0 :
如果 z（z）:
提升 未实现错误('不允许负功率的模数')
其他的:
返回 1/首次公开募股(x个,-年)
一,b条=1,x个
虽然 年>0:
如果 年%2 == 1:
一=(一*b条)%z（z） 如果 z（z） 其他的 一*b条
b条 = (b条*b条)%z（z） 如果 z（z） 其他的 b条*b条
年=年//2
返回 一
[文档]定义 功率(x个,年,z（z）=0):
'''
：返回：（x**y）%z作为整数
'''
如果 不 isinstance公司(年,六.整数类型):
如果 z（z）==0:
返回 六.内置.功率(x个,年) #切换到Py3中的浮点。。。
其他的:
返回 六.内置.功率(x个,年,z（z）) #在Py3中切换到浮点。。。
其他的:
返回 首次公开募股(x个,年,z（z）)
[文档]定义 平方英尺(n个):
''平方根
：return:int、float或complex取决于n
'''
如果 类型(n个) 是 整数:
秒=isqrt公司(n个)
如果 秒*秒==n个:
返回 秒
如果 n个<0:
返回 数学库.平方英尺(n个)
返回 数学.平方英尺(n个)
[文档]定义 isqrt公司(n个):
''整数平方根
：return：最大整数x，其中x*x<=n
'''
# http://stackoverflow.com/questions/15390807/integer-square-root-in-python网址
# https://projecteuler.net/thread=549#235536
n个=整数(n个)
x个 = n个
年 = (x个 + 1) // 2
虽然 年 < x个:
x个 = 年
年 = (x个 + n个 // x个) // 2
返回 x个
[文档]定义 icbrt(n个):
''整数立方根
：return：最大整数x，其中x*x*x<=n
'''
# https://projecteuler.net/thread=549#235536
如果 n个 <= 0:
返回 0
x个 = 整数(n个 ** (1 / 三。) * (1 + 1e-12))
虽然 真的:
年 = (2 * x个 + n个 // (x个 * x个)) // 三
如果 年 >= x个:
返回 x个
x个 = 年
[文档]定义 is_正方形(n个):
秒=isqrt公司(n个)
返回 秒*秒==n个
[文档]定义 介绍者(n个, 第页=2):
“”整数r-th根
：return:int，小于或等于n的r次方根的最大整数。
对于负n，返回大于或等于n的r次方根的最小整数，如果r是偶数，则返回None。
'''
#复制自https://pypi.python.org/pypi/primefac
如果 n个 < 0: 返回 无 如果 第页%2 == 0 其他的 -介绍者(-n个, 第页)
如果 n个 < 2: 返回 n个
如果 第页 == 2: 返回 isqrt公司(n个)
降低, 上面的 = 0, n个
虽然 降低 != 上面的 - 1:
中间 = (降低 + 上面的) // 2
米 = 中间**第页
如果 米 == n个: 返回 中间
否则如果 米 < n个: 降低 = 中间
否则如果 米 > n个: 上面的 = 中间
返回 降低
[文档]定义 is_power（电源）(n个):
'''
：return：整数，当平方/立方/等时，生成n，
如果不存在此类整数，则为0。
请注意，这个数字的幂将是素数
#复制自https://pypi.python.org/pypi/primefac
对于 第页 在里面 素数_gen():
第页 = 介绍者(n个, 第页)
如果 第页 是 无: 持续
如果 第页 ** 第页 == n个: 返回 第页
如果 第页 == 1: 返回 0
[文档]定义 乘(x个, 年):
'''
Karatsuba快速乘法算法
https://en.wikipedia.org/wiki/Karatsuba_algorithm
版权所有（c）2014 Nayuki项目
http://www.nayuki.io/page/karatsuba-multiplication
'''
_CUTOFF（切断） = 1536 #_CUTOFF>=64，否则将有无限递归。
如果 x个.位长度（_L）() <= _CUTOFF（切断） 或 年.位长度（_L）() <= _CUTOFF（切断）: #基本情况
返回 x个 * 年
其他的:
n个 = 最大值(x个.位长度（_L）(), 年.比特长度())
一半 = (n个 + 32) // 64 * 32
面具 = (1 << 一半) - 1
xlow（xlow） = x个 & 面具
伊洛 = 年 & 面具
x高 = x个 >> 一半
y高 = 年 >> 一半
一 = 乘(x高, y高)
b条 = 乘(xlow（xlow） + x高, 伊洛 + y高)
c（c） = 乘(xlow（xlow）, 伊洛)
d日 = b条 - 一 - c（c）
返回 (((一 << 一半) + d日) << 一半) + c（c）
#向量运算
[文档]定义 阿克苏姆(它):
“”“产生可迭代的累计和：accsum（count（1））->1,3,6,10，…”“”
返回 itertools2.滴(1, itertools2.减少(操作人员.添加, 它, 0))
累加=阿克苏姆 #numpy别名
[文档]定义 穆尔(数字,初始化=1):
'''
：return：nums的乘积
'''
返回 减少(操作人员.穆尔, 数字, 初始化)
[文档]定义 点_vv(一,b条,违约=0):
向量的“”dot积
：param a：向量（可迭代）
：param b：向量（可迭代）
：param default：乘法运算符的默认值
'''
返回 总和(地图( 操作人员.穆尔, 一, b条),违约)
[文档]定义 点最小值(一,b条,违约=0):
向量的“”dot积
：param a：矩阵（iterable或iterable）
：param b：向量（可迭代）
：param default：乘法运算符的默认值
'''
返回 [点_vv(线,b条,违约) 对于 线 在里面 一]
[文档]定义 点_毫米(一,b条,违约=0):
矩阵的“”dot乘积
：param a：矩阵（iterable或iterable）
：param b：矩阵（iterable或iterable）
：param default：乘法运算符的默认值
'''
返回 转置([点_mv(一,科尔) 对于 科尔 在里面 拉链(*b条)])
[文档]定义 点(一,b条,违约=0):
''点积
通用但速度慢：如果知道a和b的尺寸，请使用dotvv、dotmv或dotmm
'''
如果 itertools2.ndim公司(一)==2: #矩阵
如果 itertools2.ndim公司(b条)==2: #矩阵*矩阵
返回 点_毫米(一,b条,违约)
其他的: #矩阵*向量
返回 点_mv(一,b条,违约)
其他的: #向量*向量
返回 点_vv(一,b条,违约)
#一些基本矩阵运算
[文档]定义 零点(形状):
'''
：参见：https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html
'''
返回 ([0]*形状[1])*形状[0]
[文档]定义 诊断(v（v）):
'''
创建一个二维数组，将展平的输入作为对角线。
：param v：如果v是二维数组，则返回其对角线的副本。
如果v是一维数组，则返回对角线上有v的二维数组
：参见：https://docs.scipy.org/doc/numpy/reference/regenerated/numpy.diag.html#numpy.diag
'''
秒=伦恩(v（v）)
如果 itertools2.ndim公司(v（v）)==2:
返回 [v（v）[我][我] 对于 我 在里面 范围(秒)]
物件=[]
对于 我,x个 在里面 列举(v（v）):
线=[x个]+[0]*(秒-1)
线=线[-我:]+线[:-我]
物件.追加(线)
返回 物件
[文档]定义 身份(n个):
返回 诊断([1]*n个)
眼睛=身份 #现在的别名
[文档]定义 转置(米):
'''
：return：矩阵m转置
'''
#确保结果是列表列表
返回 列表(地图(列表,列表(拉链(*米))))
[文档]定义 最大限度(米):
'''
比较N个数组并返回一个包含元素最大值的新数组
：param m：数组列表（矩阵）
：return：m的每列中找到的最大值列表
：参见：http://docs.scipy.org/doc/numpy/reference/generated/numpy.maximum.html
'''
返回 [最大值(c（c）) 对于 c（c） 在里面 转置(米)]
[文档]定义 最低限度(米):
'''
比较N个数组并返回一个新数组，该数组包含元素方向的最小值
：param m：数组列表（矩阵）
：return：在m的每列中找到的最小值列表
：参见：http://docs.scipy.org/doc/numpy/reference/generated/numpy.miminum.html
'''
返回 [最小值(c（c）) 对于 c（c） 在里面 转置(米)]
[文档]定义 维卡德(一,b条,填充值=0):
“不等长向量的加法”
返回 [我[0]+我[1] 对于 我 在里面 zip_最长(一,b条,填充值=填充值)]
[文档]定义 vecsub公司(一,b条,填充值=0):
''等长向量的替换''
返回 [我[0]-我[1] 对于 我 在里面 zip_最长(一,b条,填充值=填充值)]
[文档]定义 vecneg公司(一):
''一元否定''
返回 列表(地图(操作人员.否定,一))
[文档]定义 vecmul公司(一,b条):
“不等长向量的乘积”
如果 isinstance公司(一,(整数,浮动)):
返回 [x个*一 对于 x个 在里面 b条]
如果 isinstance公司(b条,(整数,浮动)):
返回 [x个*b条 对于 x个 在里面 一]
返回 [减少(操作人员.穆尔,我) 对于 我 在里面 拉链(一,b条)]
[文档]定义 vecdiv公司(一,b条):
“不等长向量的商”
如果 isinstance公司(b条,(整数,浮动)):
返回 [浮动(x个)/b条 对于 x个 在里面 一]
返回 [减少(操作人员.特鲁迪夫,我) 对于 我 在里面 拉链(一,b条)]
[文档]定义 灰泥比例尺(一,b条):
“”比较两个列表中的值。返回三对数，其中[a<b，a==b，a>b]“”
物件=[0,0,0]
对于 人工智能,双 在里面 拉链(一,b条):
如果 人工智能<双:
物件[0]+=1
否则如果 人工智能==双:
物件[1]+=1
其他的:
物件[2]+=1
返回 物件
[文档]定义 坐(x个,低的=0,高的=无):
“”使x在低值和高值之间饱和“”
如果 isinstance公司(x个,(整数,浮动)):
如果 低的 是 不 无: x个=最大值(x个,低的)
如果 高的 是 不 无: x个=最小值(x个,高的)
返回 x个
返回 [坐(_,低的,高的) 对于 _ 在里面 x个]
#规范和距离
[文档]定义 标准2(v（v）):
'''
：return：向量v的“正常”欧几里得范数
'''
返回 平方英尺(总和(x个*x个 对于 x个 在里面 v（v）))
[文档]定义 标准_1(v（v）):
'''
：return：向量v的“曼哈顿”范数
'''
返回 总和(防抱死制动系统(x个) 对于 x个 在里面 v（v）)
[文档]定义 标准inf(v（v）):
'''
：return：向量v的无穷范数
'''
返回 最大值(防抱死制动系统(x个) 对于 x个 在里面 v（v）)
[文档]定义 规范(v（v）,秩序=2):
'''
：参见：http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.norm.html
'''
返回 总和(防抱死制动系统(x个)**秩序 对于 x个 在里面 v（v）)**(1/秩序)
[文档]定义 距离(一,b条,规范=标准2):
返回 规范(vecsub公司(一,b条))
[文档]定义 车辆单元(v（v）,规范=标准2):
'''
：return：向量规格化
'''
返回 vecdiv公司(v（v）,规范(v（v）))
[文档]定义 汉明(第1页, s2秒):
“计算两个迭代词之间的汉明距离”
返回 总和(c1级 != 二氧化碳 对于 c1级, 二氧化碳 在里面 拉链(第1页, s2秒))
[文档]定义 集合列表(一,b条):
'''
：参见：http://stackoverflow.com/questions/11316539/calculating-the-distance-between两个无序集
'''
c（c） = 一.交叉(b条)
返回 平方英尺(伦恩(一-c（c）)*2 + 伦恩(b条-c（c）)*2)
[文档]定义 集合_levenshtein(一,b条):
“”连胜距离
：参见：http://en.wikipedia.org/wiki/Levenshtein_distance
'''
c（c） = 一.交叉(b条)
返回 伦恩(一-c（c）)+伦恩(b条-c（c）)
[文档]定义 列文施泰因(序列1, 序列2):
''水平距离
：return：两个迭代器之间的距离
：参见：http://en.wikipedia.org/wiki/Levenshtein_distance
'''
# http://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#Python
奥纳戈 = 无
这一排 = 列表(范围(1, 伦恩(序列2) + 1)) + [0]
对于 x个 在里面 范围(伦恩(序列1)):
_, 奥纳戈, 这一排 = 奥纳戈, 这一排, [0] * 伦恩(序列2) + [x个 + 1]
对于 年 在里面 范围(伦恩(序列2)):
德尔科斯 = 奥纳戈[年] + 1
增加成本 = 这一排[年 - 1] + 1
子成本 = 奥纳戈[年 - 1] + (序列1[x个] != 序列2[年])
这一排[年] = 最小值(德尔科斯, 附加成本, 子成本)
返回 这一排[伦恩(序列2) - 1]
#统计数据
#已移至stats.py
#数字函数
#主要来自https://github.com/tokland/pyeuler/blob/master/pyeulel/toolset.py
[文档]定义 重现(签名, 值, cst公司=0, 最大值=无, 国防部=0):
''复发通用生成器
：param签名：定义重复的因素
：param values：初始值列表
'''
值=列表(值) #允许元组或迭代器
因素=列表(颠倒的(签名))
对于 n个 在里面 值:
如果 国防部:
n个=n个%国防部
产量 n个
值=值[-伦恩(签名):]
虽然 真的:
n个=点_vv(因素,值)
如果 最大值 和 n个>最大值: 打破
n个=n个+cst公司
如果 国防部: n个=n个%国防部
产量 n个
值=值[1:]
值.追加(n个)
[文档]定义 斐波纳契根(最大值=无,国防部=0):
“生成fibonacci序列”
返回 重现([1,1],[0,1],最大值=最大值,国防部=国防部)
[文档]定义 斐波那契(n个,国防部=0):
“”fibonacci系列第n个元素
：param n:int可以非常高，如1e19！
：param mod:int可选模块
'''
如果 n个 < 0:
提升 值错误(“未实现否定参数”)
#http://stackoverflow.com/a/28549402/1395973
#使用http://mathworld.wolfram.com/FibonacciQ-Matrix.html
返回 mod_matpow模式([[1,1],[1,0]],n个,国防部)[0][1]
[文档]定义 is_fibonacci公司(n个):
“”如果n在斐波那契数列中，则返回True“”
# http://www.geeksforeks.org/check-number-fibonacci-number/
返回 平方（_S）(5*n个*n个 + 4) 或 平方（_S）(5*n个*n个 - 4)
[文档]定义 皮萨诺周期(国防部):
如果 国防部<2: 返回 [0]
序列号=[0,1]
我=伦恩(序列号)
秒=[]
对于 我,n个 在里面 列举(斐波纳契根(国防部=国防部)):
秒.追加(n个)
如果 我>我 和 秒[-我:]==序列号:
返回 秒[:-我]
[文档]定义 比萨诺周期(国防部):
如果 国防部<2: 返回 1
旗帜=False（错误） #已找到0
对于 我,n个 在里面 列举(斐波纳契根(国防部=国防部)):
如果 不 旗帜:
旗帜=n个==0
否则如果 我>三:
如果 n个==1:
返回 我-1
旗帜=False（错误）
[文档]定义 拼贴(n个):
如果 n个 % 2 == 0:
返回 n个 // 2
其他的:
返回 三 * n个 + 1
[文档]定义 collatz_gen公司(n个=0):
产量 n个
虽然 真的:
n个=科拉茨(n个)
产量 n个
[文档]@装饰师.记下
定义 collatz周期(n个):
如果 n个==1: 返回 1
返回 1+collatz周期(拼贴(n个))
[文档]定义 帕斯卡根():
“按行读取帕斯卡三角形：C（n，k）=二项式（n，k）=n/（k！*（n-k）！），0<=k<=n。
https://oeis.org/A007318
'''
__作者__ = “尼克·霍布森<nickh@qbyte.org>'
#代码来自https://oeis.org/A007318/A007318.py.txt具有其他相关功能
对于 行 在里面 itertools软件.计数():
x个 = 1
产量 x个
对于 米 在里面 范围(行):
x个 = (x个 * (行 - 米)) // (米 + 1)
产量 x个
[文档]定义 加泰罗尼亚语(n个):
加泰罗尼亚数字：C（n）=二项式（2n，n）/（n+1）=（2n）/（n！（n+1）！）。
'''
返回 二项式(2*n个,n个)//(n个+1) #结果总是int
[文档]定义 加泰罗尼亚根():
“生成加泰罗尼亚数字：C（n）=二项式（2n，n）/（n+1）=（2n）/（n！（n+1）！）。
也称为Segner数。
'''
产量 1
最后的=1
产量 最后的
对于 n个 在里面 itertools软件.计数(1):
最后的=最后的*(4*n个+2)//(n个+2)
产量 最后的
[文档]定义 是_pythagoreantriple(一,b条,c（c）):
返回 一*一+b条*b条 == c（c）*c（c）
[文档]定义 primitive_triples（基元_三元组）():
“”生成原始勾股三元组x<y<z
按斜边z排序，然后按最长边y排序
通过Berggren矩阵和三叉树的宽度优先遍历
：参见：https://en.wikipedia.org/wiki/Tree_of_primitive_Pythagorean_triples网站
'''
钥匙=λ x个:(x个[2],x个[1])
从 分类集装箱 进口 带关键字的排序列表
三元组=带关键字的排序列表(钥匙=钥匙)
三元组.添加([三,4,5])
一个 = [[ 1,-2, 2], [ 2,-1, 2], [ 2,-2, 三]]
B类 = [[ 1, 2, 2], [ 2, 1, 2], [ 2, 2, 三]]
C类 = [[-1, 2, 2], [-2, 1, 2], [-2, 2, 三]]
虽然 三元组:
(一,b条,c（c）) = 三元组.流行音乐(0)
产量 (一,b条,c（c）)
#使用Berggren矩阵将这个三元组展开为3个新的三元组
对于 X（X） 在里面 [一个,B类,C类]:
三倍的=[总和(x个*年 对于 (x个,年) 在里面 拉链([一,b条,c（c）],X（X）[我])) 对于 我 在里面 范围(三)]
如果 三倍的[0]>三倍的[1]: #确保x<y<z
三倍的[0],三倍的[1]=三倍的[1],三倍的[0]
三元组.添加(三倍的)
[文档]定义 三元组():
“”生成所有勾股三元组三元组x<y<z
按斜边z排序，然后按最长边y排序
'''
一本正经的=[] #到目前为止的基元三元组列表
钥匙=λ x个:(x个[2],x个[1])
从 分类集装箱 进口 带关键字的排序列表
萨米兹=带关键字的排序列表(钥匙=钥匙) #具有相同z的temp三元组
缓冲器=带关键字的排序列表(钥匙=钥匙) #z较小的三元组的温度
对于 pt（磅） 在里面 primitive_triples（基元_三元组）():
z（z）=pt（磅）[2]
如果 萨梅兹 和 z（z）!=萨米兹[0][2]: #冲洗samez
虽然 萨米兹:
产量 萨米兹.流行音乐(0)
萨米兹.添加(pt（磅）)
#构建已经找到的较小倍数的原语缓冲区
对于 我,下午 在里面 列举(一本正经的):
第页,米=下午[0:2]
虽然 真的:
毫赫兹=米*第页[2]
如果 毫米 < z（z）:
缓冲器.添加(元组(米*x个 对于 x个 在里面 第页))
否则如果 毫赫兹 == z（z）:
#我们需要另一个缓冲区，因为下一个pt可能有
#z与前一个相同，但y小于
#前一个pt的倍数。。。
萨米兹.添加(元组(米*x个 对于 x个 在里面 第页))
其他的:
打破
米+=1
一本正经的[我][1]=米 #更新下一个循环的乘数
虽然 缓冲器: #冲洗缓冲器
产量 缓冲器.流行音乐(0)
一本正经的.追加([pt（磅）,2]) #将原语添加到列表
[文档]定义 约数(n个):
'''
：参数n:int
：return：n的所有除数：除数（12）->1,2,3,6,12
包括1和n，
除了1，它返回单个1以避免与除数之和混淆。。。
'''
如果 n个==1:
产量 1
其他的:
所有因素 = [[如果**第页 对于 第页 在里面 itertools2.愤怒(0,英尺/平方英尺)] 对于 (如果, 英尺/平方英尺) 在里面 因式分解(n个)]
#只要结果的顺序不同，就不要在此处使用itertools2.product
对于 纳秒 在里面 itertools软件.产品(*所有因素):
产量 穆尔(纳秒)
[文档]定义 proper_除数(n个):
“”：return:n的所有除数，但n本身除外。“”
返回 (除数 对于 除数 在里面 约数(n个) 如果 除数 != n个)
_筛子，筛子=列表（） #表示素性的布尔数组
[文档]定义 筛子，筛子(n个, 一个罪=False（错误）):
从2到素数<n的“”素数
非常快（n<10000000），只需0.4秒。
例子：
>>>主索（25）
[2, 3, 5, 7, 11, 13, 17, 19, 23]
算法和Python来源：Robert William Hanks
http://stackoverflow.com/questions/17773352/python-sieve-prime-numbers
'''
n个=整数(n个) #允许n=1E9，即浮动
如果 n个<2: 返回 []
如果 n个==2: 返回 [1] 如果 一个罪 其他的 []
全球的 _筛子，筛子
如果 n个>伦恩(_筛子，筛子): #重新计算筛子
#TODO:放大筛子。。。
# http://stackoverflow.com/questions/2068372/fastst-way-to-list-all-primes-below-n-in-python/3035188#3035188
_筛子，筛子 = [False（错误）,False（错误）,真的,真的]+[False（错误）,真的] * ((n个-4)//2)
#断言（len（_sieve）==n）
对于 我 在里面 范围(三,整数(n个**0.5)+1,2):
如果 _筛子，筛子[我]:
_筛子，筛子[我*我::2*我]=[False（错误）]*整数((n个-我*我-1)/(2*我)+1)
返回 ([1,2] 如果 一个罪 其他的 [2]) + [我 对于 我 在里面 范围(三,n个,2) 如果 _筛子，筛子[我]]
_素数=筛子，筛子(1000) #素数高达1000
_素数_集 = 设置(_素数) #加速下面的美国首要性测试
[文档]定义 素数(n个):
“”n个第一素数的记忆列表
：warning：不要用大n调用，而是使用prime_gen
'''
米=n个-伦恩(_素数)
如果 米>0:
更多=列表(itertools2.拿(米,素数_gen(_素数[-1]+1)))
_素数.延伸(更多)
_素数_集.联盟(设置(更多))
返回 _素数[:n个]
[文档]定义 是首选项（_E）(n个,电子束=(2,)):
“欧拉的素性测试
：param n:int要测试的数字
：param eb：测试依据
：return：如果不是素数，则为False；如果是素数，也为True，但对于许多伪素数。。。
：参见：https://en.wikipedia.org/wiki/Euler_pseudoprime网站
'''
# https://pypi.python.org/pypi/primefac
对于 b条 在里面 电子束:
如果 b条 >= n个: 持续
如果 不 功率(b条, n个-1, n个) == 1:
返回 False（错误）
第页 = n个 - 1
虽然 第页%2 == 0: 第页 //= 2
c（c） = 功率(b条, 第页, n个)
如果 c（c） == 1: 持续
虽然 c（c） != 1 和 c（c） != n个-1: c（c） = 功率(c（c）, 2, n个)
如果 c（c） == 1: 返回 False（错误）
返回 真的 #根据欧拉的说法
[文档]定义 是素数（_P）(n个, 一个罪=False（错误）, 结核=(三,5,7,11), 电子束=(2,), 磁共振波谱=无):
''主要的素性测试。
：param n:int要测试的数字
：param oneisprime：bool如果1应该被视为素数，则为True（很久以前是）
：param tb：试验划分依据
：param eb：欧拉试验依据
：param mrb:Miller-Rabin基础，无时自动
：请参阅：https://en.wikipedia.org/wiki/Baillie%E2%80%93PSW_primality_test
这是BPSW测试的一个实现（Baillie-Pomerance-Selfrigge-Wagstaff）
对于速度有一些预置，对于所有小于2^64的数字都是确定的
事实上，虽然人们推测存在无限多的误报，
目前还没有发现假阳性。
预过滤器包括针对2的试验划分和元组tb的元素，
检查n是否平方，并对元组eb中的基进行Euler素性测试。
如果数字小于3825123056546413051，我们使用Miller-Rabin检验
基于一组已知在该范围内测试具有确定性的基础。
'''
# https://pypi.python.org/pypi/primefac
如果 n个 <= 0: 返回 False（错误）
如果 n个 == 1: 返回 一次犯罪
如果 n个<伦恩(_筛子，筛子): 返回 _筛子，筛子[n个]
如果 n个 在里面 _素数_集: 返回 真的
如果 任何(n个%第页 == 0 对于 第页 在里面 结核): 返回 False（错误）
如果 平方（_S）(n个): 返回 False（错误） #它很快。。。
如果 不 是首选项（_E）(n个): 返回 False（错误） #欧拉试验
秒, d日 = 功率因数(n个)
如果 不 sprp（sprp）(n个, 2, 秒, d日): 返回 False（错误）
如果 n个 < 2047: 返回 真的
#BPSW有两个阶段：基于2的SPRP和SLPRP。
#我们刚刚完成了SPRP；现在我们进行SLPRP
如果 n个 >= 3825123056546413051:
d日 = 5
虽然 真的:
如果 gcd公司(d日, n个) > 1:
第页, q个 = 0, 0
打破
如果 雅各比(d日, n个) == -1:
第页, q个 = 1, (1 - d日) // 4
打破
d日 = -d日 - 2*d日//防抱死制动系统(d日)
如果 第页 == 0: 返回 n个 == d日
秒, t吨 = pfactor（功率因数）(n个 + 2)
u个, v（v）, u2型, 第2版, 米 = 1, 第页, 1, 第页, t吨//2
k个 = q个
虽然 米 > 0:
u2型, 第2版, q个 = (u2型*第2版)%n个, (第2版*第2版-2*q个)%n个, (q个*q个)%n个
如果 米%2 == 1:
u个, v（v） = u2型*v（v）+u个*第2版, 第2版*v（v）+u2型*u个*d日
如果 u个%2 == 1: u个 += n个
如果 v（v）%2 == 1: v（v） += n个
u个, v（v）, k个 = (u个//2)%n个, (v（v）//2)%n个, (q个*k个)%n个
米 //= 2
如果 (u个 == 0) 或 (v（v） == 0): 返回 真的
对于 我 在里面 范围(1, 秒):
v（v）, k个 = (v（v）*v（v）-2*k个)%n个, (k个*k个)%n个
如果 v（v） == 0: 返回 真的
返回 False（错误）
#米勒·拉宾
如果 不 磁共振波谱:
如果 n个 < 1373653: 磁共振波谱 = [三]
否则如果 n个 < 25326001: 磁共振波谱 = [三,5]
否则如果 n个 < 3215031751: 磁共振波谱 = [三,5,7]
否则如果 n个 < 2152302898747: 磁共振波谱 = [三,5,7,11]
否则如果 n个 < 3474749660383: 磁共振波谱 = [三,5,6,11,13]
否则如果 n个 < 341550071728321: 磁共振波谱 = [三,5,7,11,13,17] #这个数字对于素数（19+1）也是一个假阳性。
否则如果 n个 < 3825123056546413051: 磁共振波谱 = [三,5,7,11,13,17,19,23] #对于素数（31+1）也是一个假阳性。
返回 全部的(sprp程序(n个, b条, 秒, d日) 对于 b条 在里面 磁共振波谱)
[文档]定义 下一素数(n个):
“”“确定严格大于n的最小素数，这似乎很有效率。”“”
#来自https://pypi.python.org/pypi/primefac
如果 n个 < 2: 返回 2
如果 n个 == 2: 返回 三
n个 = (n个 + 1) | 1 #第一个奇数大于n
米 = n个 % 6
如果 米 == 三:
如果 是素数（_P）(n个+2): 返回 n个+2
n个 += 4
否则如果 米 == 5:
如果 是素数（_P）(n个): 返回 n个
n个 += 2
对于 米 在里面 itertools软件.计数(n个, 6):
如果 是素数（_P）(米 ): 返回 米
如果 是素数（_P）(米+4): 返回 米+4
[文档]定义 预备犯(n个):
“”“确定严格小于n的最大素数，效率很低”“”
如果 n个<三: 返回 无
如果 n个==三: 返回 2
n个 = n个 | 1 #奇数为n，偶数为n+1
虽然 真的:
n个-=2
如果 是素数（_P）(n个):
返回 n个
[文档]定义 素数_gen(开始=2,停止=无):
“”从开始生成质数“”
如果 开始==1:
产量 1 #如果我们明确要求
开始=2
如果 停止 是 无 或 停止>开始:
n个=开始-1 #包含启动（如果它是素数）
虽然 真的:
n个=下一素数(n个)
如果 (停止 是 无) 或 n个<=停止:
产量 n个
其他的:
打破
其他的: #向后
n个=开始+1
虽然 真的:
n个=预备犯(n个)
如果 n个 和 n个>=停止:
产量 n个
其他的:
打破
[文档]定义 随机素数(位):
“”返回指定位长度的随机数“”
进口 随机的，随机的
虽然 真的:
n个 = 随机的，随机的.获取随机比特(位-1)+2**(位-1);
n个=下一素数(n个-1)
如果 n个<2**位: 返回 n个
[文档]定义 欧几里得根():
“”生成欧几里得数：前n个素数的1+乘积“”
n个 = 1
对于 第页 在里面 素数_gen(1):
n个 = n个 * 第页
产量 n个+1
[文档]定义 主要因素(号码, 开始=2):
“”生成num的所有素因子（有序）“”
对于 第页 在里面 素数_gen(开始):
如果 号码==1:
打破
如果 是素数（_P）(号码): #因为它很快
产量 号码
打破
如果 第页>号码:
打破
虽然 号码 % 第页==0:
产量 第页
号码=号码//第页
[文档]定义 液化石油气(n个):
“最大素因子”
如果 n个<4 : 返回 n个
返回 itertools2.第一(主要因素(n个))
[文档]定义 全球生产总值(n个):
“最大素因子”
如果 n个<4 : 返回 n个
返回 itertools2.最后的(主要因素(n个))
[文档]定义 素数除数(号码, 开始=2):
“”生成num“”的唯一素除数（有序）
返回 itertools2.独特的(prime_factors（_F）(号码,开始))
[文档]定义 是多个（_M）(n个,因素) :
“”如果n只有因子作为主因子，则返回True“”
返回 不 设置(素数除数(n个))-设置(因素)
[文档]定义 因式分解(n个):
“”找到n的素因子及其频率。例子：
>>>系数（786456）
[(2,3), (3,3), (11,1), (331,1)]
'''
如果 n个==1: #使许多事情变得非常简单。。。
返回 [(1,1)]
返回 itertools2.压缩(prime_factors（_F）(n个))
[文档]定义 因素(n个):
对于 (第页,e（电子）) 在里面 因式分解(n个):
产量 第页**e（电子）
[文档]定义 除数的数量(n个):
#http://mathschallenge.net/index.php？section=faq&ref=number/number_of_diviators
物件=1
如果 n个>1:
对于 (第页,e（电子）) 在里面 因式分解(n个):
物件=物件*(e（电子）+1)
返回 物件
[文档]定义 欧米茄(n个):
“不同素数除以n”
返回 itertools2.count_unique（唯一）(主要因素(n个))
[文档]定义 大欧米茄(n个):
“”“n的素数除数以重数计算”“”
返回 itertools2.伊伦(主要因素(n个))
[文档]定义 莫比乌斯(n个):
“Möbius（或Moebius）函数mu（n）。
mu（1）=1；
mu（n）=（-1）^k，如果n是k个不同素数的乘积；
否则mu（n）=0。
'''
如果 n个==1: 返回 1
物件=1
对于 第页,q个 在里面 因式分解(n个):
如果 q个>1: 返回 0
物件=-物件
返回 物件
[文档]定义 euler_phi(n个):
''欧拉指向函数
：参见：http://stackoverflow.com/questions/1019040/how-many-numbers-blow-n-are-coprimes-to-n
'''
如果 n个<=1:
返回 n个
返回 整数(穆尔((1 - 1 / 第页 对于 第页, _ 在里面 因式分解(n个)),n个))
托蒂恩=euler_phi #别名。totiten在sympy中可用
[文档]定义 坎普纳(n个):
“”Kempner函数，也称为Smarandache函数
：return:int最小正整数m，以便n除以m！。
：参数n:int
：参见：https://en.wikipedia.org/wiki/Kempner_function网站
：参见：http://mathworld.wolfram.com/SmarandacheFunction.html
'''
如果 n个==1: 返回 1
如果 是素数（_P）(n个) : 返回 n个
@装饰工人.记下
定义 _净现值(n个,第页):
#n ^p。使用https://codereview.stackexchange.com/a/129868/37671
k个=0
虽然 第页 > n个:
k个 += n个
第页 -= n个 + 1
t吨=k个
虽然 t吨%n个!=0:
t吨=t吨//n个
第页-=1
第页=最大值(0,第页)
返回 (k个 + 第页) * n个;
返回 最大值(_净现值(如果,第页) 对于 如果,第页 在里面 因式分解(n个))
[文档]定义 prime_k倍(星座):
'''
生成具有指定差异的素数元组
：param星座：要返回的素数之间的int差异的可迭代性
：注意：负int表示差值不能是质数
：参见：https://en.wikipedia.org/wiki/Prime_k-tuple（英文）
（0，2）双素数
（0，4）类素数
（0，6）性感素数
（0，2，6），（0，4，6）素数三元组
（0，6，12，-18）性感三胞胎
（0，2，6，8）素数四胞胎
（0，6，12，18）性感四胞胎
（0，2，6，8，12），（0，4，6，10，12）五组素数
（0，4，6，10，12，16）六重素数
'''
差异=星座[1:]
对于 第页 在里面 素数_gen():
物件=[第页]
对于 d日 在里面 差异:
如果 是素数（_P）(第页+防抱死制动系统(d日)) == (d日<0):
物件=无
打破
物件.追加(第页+d日)
如果 物件:
产量 元组(物件)
[文档]定义 双素数():
返回 prime_k倍((0, 2))
[文档]定义 表哥_罪犯():
返回 prime_k倍((0, 4))
[文档]定义 性犯罪():
返回 素数_k元组((0, 6))
[文档]定义 性素triplets():
返回 prime_k倍((0, 6, 12, -18)) #排除四分音符
[文档]定义 性素四胞胎():
返回 prime_k倍((0, 6, 12, 18))
[文档]定义 卢卡斯·莱默 (第页):
梅森指数p的卢卡斯·莱默素性检验
：param p:int（参数p:int）
：return:如果2^p-1是质数，则为True
'''
# http://rosettacode.org/wiki/Lucas-Lehmer_test#Python
如果 第页 == 2:
返回 真的
否则如果 不 是素数（_P）(第页):
返回 False（错误）
其他的:
百万英镑 = (1 << 第页) - 1 #2^p-1岁
秒 = 4
对于 我 在里面 范围(三, 第页 + 1):
秒 = (秒*秒 - 2) % 百万英镑
返回 秒 == 0
#数字操作
[文档]定义 数字生成(号码, 基础=10):
“”在基BACKWARDS中生成num的int位数“”
如果 号码 == 0:
产量 0
虽然 号码:
号码,雷姆=divmod公司(数量,基础)
产量 雷姆
[文档]定义 数字(号码, 基础=10, 转速=False（错误）):
'''
：return：num的数字列表，以基数表示，可以颠倒
'''
物件=列表(数字生成(号码,基础))
如果 不 转速:
物件.颠倒()
返回 物件
[文档]定义 数字和(号码, 如果=无, 基础=10):
''数字总和
：param num：数字
：param f:int应用于每个数字的幂或函数
：param base：可选底座
：return：num的f（数字）之和
数字和（num）->数字和
digsum（num，base=2）->num二进制表示中的1位数
数字和（num，2）->数字平方和
数字和（num，f=lambda x:x**x）->位数之和等于其幂
'''
d日=数字生成(数量,基础)
如果 如果 是 无:
返回 总和(d日)
如果 is编号（_N）(如果):
第页=如果
如果=λ x个:功率(x个,第页)
尝试:
返回 总和(地图(如果,d日))
除了 属性错误:
通过
d日=[如果(x个,我) 对于 我,x个 在里面 列举(d日)]
返回 总和(d日)
[文档]定义 整数_指数(一,b条=10):
'''
：returns:int除以a的b的最大幂。
：参见：https://reference.wolfram.com/language/ref/IntegerExponent.html
'''
物件=0
对于 d日 在里面 数字生成(一, b条):
如果 d日>0 : 打破
物件+=1
返回 物件
追踪_零= 整数_指数
[文档]定义 电源(v（v）):
'''
：返回：v[0]**v[1]**v[2]。。。
：参见：http://ajcr.net#巨蟒-功率消耗/
'''
返回 减少(λ x个,年:年**x个, 颠倒的(v（v）))
[文档]定义 携带(一,b条,基础=10,销售时点情报系统=0):
'''
：return：在基数中加a+b所需的整数进位数
'''
携带, 回答 = 0, 0 #到目前为止，我们还没有任何套利条款，而且我们还没有进行任何交易
对于 一,二 在里面 zip_最长(数字生成(一,基础), 数字生成(b条,基础), 填充值=0):
携带 = (一+二+携带)//基础
回答 += 携带>0 #如果我们再次进行进位，则增加进位项的数量
返回 回答
[文档]定义 动力传动系统(n个):
'''
：返回：v[0]**v[1]*v[2]**v[3]**（v[-1]或0）
：作者：#Chai Wah Wu，2017年6月16日
：参见：http://oeis.org/A133500
'''
秒 = 字符串(n个)
我 = 伦恩(秒)
米 = 整数(秒[-1]) 如果 我 % 2 其他的 1
对于 我 在里面 范围(0, 我-1, 2):
米 *= 整数(秒[我])**整数(秒[我+1])
返回 米
[文档]定义 字符串基础（_B）(号码, 基础=10, 数字 = '0123456789abcdefghijklmnopqrstuvwxyz'):
'''
：return：num在base中的字符串表示
：param num:int数字（十进制）
：param base:int base，默认为10
：param numbers：包含所有字符的字符串，表示基数中的数字。忽略base-th后的字符
'''
如果 基础==10 和 数字[:10]=='0123456789':
返回 字符串(号码)
如果 基础==2 和 数字[:2]=='01':
返回 "{0:b}".格式(整数(号码))
如果 基础 < 2 或 基础 > 伦恩(数字):
提升 值错误(“str_base:base必须介于2和之间%d日" % 伦恩(数字))
如果 号码 < 0:
签名 = '-'
号码 = -号码
其他的:
签名 = ''
结果 = ''
对于 d日 在里面 数字生成(号码,基础):
结果 = 数字[d日] + 结果
返回 签名 + 结果
[文档]定义 内部基准（_B）(号码, 基础):
'''
：return:int表示基数中的num
：param num:int数字（十进制）
：param base：int base，<=10
'''
返回 整数(字符串基础（_B）(号码,基础))
[文档]定义 数字_来自_位数(数字, 基础=10):
'''
：param digits：表示给定基数中数字的字符串或数字列表
：param base:int base，默认为10
：return:int数字
'''
如果 isinstance公司(数字,六.字符串类型):
返回 整数(数字,基础)
物件,如果=0,1
对于 x个 在里面 颠倒的(列表(数字)):
物件=物件+整数(x个*如果)
如果=如果*基础
返回 物件
[文档]定义 颠倒(我):
返回 整数(字符串(我)[::-1])
[文档]定义 is_palindromic（正向）(号码, 基础=10):
''检查base'base'中的'num'是否是回文，如果可以的话，就这样
从左到右、从右到左等量阅读
如果 基础==10:
返回 号码==颠倒(号码)
数字1 = 列表(数字生成(号码, 基础))
返回 数字1 == 列表(颠倒的(数字1))
[文档]定义 is_anagram（安纳格拉姆）(数字1, 数量2, 基础=10):
“”“检查”“num1”“和”“num2”“的基数是否相同”“”
数字1=已排序(字符串基础（_B）(数字1,基础))
数字2=已排序(字符串基础（_B）(数量2,基础))
返回 数字1==数字2
[文档]定义 是_数字(号码, 基础=10):
'''
：return：如果num包含指定基数中的所有数字，则为True
'''
n个=字符串基础（_B）(号码,基础)
返回 伦恩(n个)>=基础 和 不 “123456789abcdefghijklmnopqrstuvwxyz”[:基础-1].带(n个)
#return set（已排序（digits_from_num（num，base））==set（range（base））#慢速
[文档]定义 有弹性的(n个,向上的=False（错误）,向下=False（错误）):
'''
：param n:int要测试的数字
：param up:bool
：param down:bool
bouncy（x）对bouncy数返回True（数字构成严格非单调序列）（A152054）
bouncy（x，True，None）对数字顺序不减的数字返回True（OEIS A009994）
bouncy（x，None，True）对数字按非递增顺序排列的数字返回True（OEIS A009996）
'''
秒=字符串(n个)
第1页=''.参加(已排序(秒))
物件=真的
如果 向上的 是 不 无:
物件 = 物件 和 向上的==(秒==第1页)
如果 向下 是 不 无:
物件 = 物件 和 向下==(秒==第1页[::-1])
返回 物件
[文档]定义 重新定义（_G）(基础=10, 数字=1):
“”生成重新单位“”
n个=数字
产量 0 #与定义一致
虽然 真的:
产量 n个
n个=n个*基础+数字
[文档]定义 重新组合(n个, 基础=10, 数字=1):
'''
：return:nth重新单位
'''
如果 n个==0: 返回 0
如果 数字==1:
返回 (基础**n个 - 1)//(基础-1)
返回 整数(字符串(数字)*n个,基础)
#重复小数https://en.wikipedia.org/wiki/Repeating_decimal网站
# https://stackoverflow.com/a/36531120/1395973
[文档]定义 理性str(n个,d日):
整数, 十进制的, 转移, 重复, 周期 = 理性形式(n个,d日)
秒 = 字符串(整数)
如果 不 (十进制的 或 重复):
返回 秒
秒 = 秒 + "."
如果 十进制的 或 转移:
秒 = 秒 + "{:0{}}”.格式(十进制的, 转移)
如果 重复:
秒 = 秒 + "({:0{}})".格式(重复, 周期)
返回 秒
[文档]定义 理性周期(号码,兽穴):
“num/den十进制扩展的周期部分。任何初始0都放置在循环结束时。
：参见：https://oeis.org/A036275
'''
_, _, _, 数字, 周期 = 理性形式(号码,兽穴)
里兹=周期-数字位数(数字)
返回 数字*首次公开募股(10,里兹)
#多边形数
[文档]定义 四面体的(n个):
'''
：return:int第n个四面体数
：参见：https://en.wikipedia.org/wiki/四面体_编号
'''
返回 n个*(n个+1)*(n个+2)//6
[文档]定义 平方和(n个):
'''
：返回：1^2+2^2+3^2+…+n ^2个
：参见：https://en.wikipedia.org/wiki/Square_pyramdial_number（英文）
'''
返回 n个*(n个+1)*(2*n个+1)//6
金字塔形的 = 平方和
[文档]定义 多维数据集总和(n个):
'''
：返回：1^3+2^3+3^3+…+n ^3个
：参见：https://en.wikipedia.org/wiki/Squared_triangular_number
'''
一=三角形(n个)
返回 一*一 #根据尼科马科斯定理
[文档]定义 伯努利根(初始化=1):
“贝努利数生成器
：param init:int-1或+1。
*B1=-1/2的“第一伯努利数”为-1
*B1=+1/2的“第二伯努利数”为+1
https://en.wikipedia.org/wiki/Bernoulli_number（英文）
https://rosettacode.org/wiki/Bernoulli_numbers#Python:_Optimised_task_algorithm
'''
B类, 米 = [], 0
虽然 真的:
B类.追加(分数.分数(1, 米+1))
对于 j个 在里面 范围(米, 0, -1):
B类[j个-1] = j个*(B类[j个-1] - B类[j个])
产量 初始化*B类[0] 如果 米==1 其他的 B类[0]#（即Bm）
米 += 1
[文档]定义 伯努利(n个,初始化=1):
返回 itertools2.塔克恩(n个,伯努利根(初始化))
[文档]定义 福勒哈伯(n个,第页):
前n个正整数的p次幂之和
：返回：1^p+2^p+3^p+…+n ^p（平方英寸）
：参见：https://en.wikipedia.org/wiki/Faluhaber%27s_formula
'''
秒=0
对于 j个,一 在里面 列举(伯努利根()):
如果 j个>第页 : 打破
秒=秒+二项式(第页+1,j个)*一*n个**(第页+1-j个)
返回 秒//(第页+1)
[文档]定义 快乐（_H）(n个):
#https://en.wikipedia.org/wiki/Happy_number（英文）
虽然 n个 > 1 和 n个 != 89 和 n个 != 4:
n个 = 数字和(n个,2) #数字平方和
返回 n个==1
[文档]定义 利什列塞(n个):
虽然 真的:
第页 = 颠倒(n个)
产量 n个,第页
如果 n个==第页 : 打破
n个 += 第页
[文档]定义 荔枝计数(n个, 限制=96):
“n变成回文之前的lychrel迭代次数
：param n:int要测试的数字
：param limit：int最大循环数。
默认值96对应于已知的最迟钝的非莱氏数
：warning：有回文lychrel数字，例如4994
'''
对于 我 在里面 itertools软件.计数():
第页=颠倒(n个)
如果 第页 == n个 或 我==限制:
返回 我
n个=n个+第页
[文档]定义 是_lychrel(n个,限制=96):
'''
：warning：有回文lychrel数字，例如4994
'''
第页=荔枝计数(n个, 限制)
如果 第页>=限制:
返回 真的
如果 第页==0: #回文数。。。
返回 荔枝计数(n个+颠倒(n个),限制)+1>=限制 #... 可以是莱瑟尔！
返回 False（错误）
[文档]定义 多边形的(秒, n个):
#https://en.wikipedia.org/wiki/Polygonal_number（英文）
返回 ((秒-2)*n个*n个-(秒-4)*n个)//2
[文档]定义 三角形(n个):
'''
：return：第n个三角形编号，定义为[1，n]个值的总和。
：参见：http://en.wikipedia.org/wiki/Triangular_number
'''
返回 多边形的(三,n个) #（n*（n+1））/2
三角形=三角形
[文档]定义 是三角形（_T）(x个):
'''
：return：如果x是三角形数字，则为True
'''
返回 is_正方形(1 + 8*x个)
是三角形的=是三角形（_T）
[文档]定义 广场(n个):
返回 多边形的(4,n个) #n*n个
[文档]定义 五边形的(n个):
'''
：return：第n个五边形数
：参见：https://en.wikipedia.org/wiki/Pentagonal_number（英文）
'''
返回 多边形(5,n个) #n*（3*n-1）/2
[文档]定义 是五边形（_P）(n个):
'''
：return：如果x是五边形数字，则为True
'''
如果 n个<1:
返回 False（错误）
n个=1+24*n个
秒=isqrt公司(n个)
如果 秒*秒 != n个:
返回 False（错误）
返回 集成（_I）((1+秒)/6)
[文档]定义 六边形(n个):
'''
：return：第n个六角形数字
：参见：https://en.wikipedia.org/wiki/Hexagonal_number（六边形编号）
'''
返回 多边形的(6,n个) #n*（2*n-1）
[文档]定义 是六边形(n个):
返回 (1 + 平方英尺(1 + (8 * n个))) % 4 == 0
[文档]定义 七边形的(n个):
返回 多边形的(7,n个) #（n*（5*n-3））/2
[文档]定义 是七边形的(n个):
返回 (三 + 平方英尺(9 + (40 * n个))) % 10 == 0
[文档]定义 八角形的(n个):
返回 多边形的(8,n个) #（n*（3*n-2））
[文档]定义 是直角的(n个):
返回 (2 + 平方英尺(4 + (12 * n个))) % 6 == 0
[文档]@装饰师.记下
定义 隔板(n个):
''配分函数p（n）
给出非负整数n的分区数
转换为正整数。
（将零分为一个正整数，
即空分区，因为空和被定义为0。）
：参见：http://oeis.org/wiki/Partition_function网站 https://oeis.org/A000041
'''
#待办事项：http://code.activestate.com/recipes/218332-generator-for-integer-partitions/
定义 非零整数(n个):
对于 k个 在里面 范围(1, n个):
产量 k个
产量 -k个
如果 n个 == 0:
返回 1
否则如果 n个 < 0:
返回 0
结果 = 0
对于 k个 在里面 非零整数(n个 + 1):
签名 = 1 如果 (k个 - 1) % 2==0 其他的 -1
结果 += 签名 * 隔板(n个 - 五边形的(k个))
返回 结果
[文档]@装饰师.记下
定义 分区Q(n个,d日=0):
#http://mathworld.wolfram.com/PartitionFunctionQ.html
#http://reference.wolfram.com/language/ref/PartitionsQ.html
#https://oeis.org/A000009
#https://codegolf.stackexchange.com/a/71945/17547
如果 n个==0: 返回 1
返回 总和(分区Q(n个-k个,n个-2*k个+1) 对于 k个 在里面 范围(1,n个-d日+1))
[文档]定义 获取卡迪纳名称(号码):
“获取数字的基数（0到100万）”
数字 = {
0: “零”, 1: “一个”, 2: “两个”, 三: “三个”, 4: “四个”, 5: “五”,
6: “六”, 7: “七”, 8: “八”, 9: “九”, 10: “十”,
11: “十一”, 12: “十二”, 13: “十三”, 14: “十四”,
15: “十五”, 16: “十六”, 17: “十七”, 18: “十八”,
19: “十九”, 20: “二十”, 30: “三十”, 40: “四十”,
50: “五十”, 60: “六十”, 70: “七十”, 80: “八十”, 90: “九十”,
}
定义 _获取（_T）(n个):
一, b条 = divmod公司(n个, 10)
返回 (数字[n个] 如果 (n个 在里面 数字) 其他的 "%秒-%秒" % (数字[10*一], 数字[b条]))
定义 _获得数百(n个):
经皮电刺激神经疗法 = n个 % 100
数百 = (n个 // 100) % 10
返回 滤波器(布尔,[
数百 > 0 和 数字[数百],
数百 > 0 和 “百”,
数百 > 0 和 经皮电刺激神经疗法 和 “和”,
(不 数百 或 经皮电刺激神经疗法 > 0) 和 _获取（_T）(经皮电刺激神经疗法),
])
阻碍=数字(号码,1000,转速=真的) #按1000分组
物件=''
对于 硬盘驱动器,单词 在里面 拉链(阻碍,['',“千”,“百万”,“十亿”]):
如果 高密度单元==0: 持续 #跳过
尝试:
物件=' '.参加(_获得数百(高密度单元))+单词+物件
除了:
通过
返回 物件
[文档]定义 丰度(n个):
返回 总和(约数(n个))-2*n个
[文档]定义 完美（_P）(n个):
'''
：return：如果n不足，返回-1；如果完美，返回0；如果丰富，返回1
：参见：https://en.wikipedia.org/wiki/Perfect_number（英文）,
https://en.wikipedia.org/wiki/Abundant_number,
https://en.wikipedia.org/wiki/缺陷编号
'''
#返回符号（丰度（n））#简单，但对于较大的n可能较慢
对于 秒 在里面 itertools2.积累(约数(n个)):
如果 秒>2*n个:
返回 1
返回 0 如果 秒==2*n个 其他的 -1
[文档]定义 数字位数(号码, 基础=10):
“”“num的返回位数（以base'表示）”“”
#log（num，base）不精确，而len（str（nu姆，base））又慢又丑
号码=防抱死制动系统(号码)
对于 我 在里面 itertools软件.计数():
如果 号码<基础: 返回 我+1
号码=号码//基础
[文档]定义 脉轮(n个):
“”解x，y整数的x^2-n*y^2=1
https://en.wikipedia.org/wiki/Pell%27s_equation
https://en.wikipedia.org/wiki/Chakravala_method
'''
# https://github.com/timothy-reasa/Python-Project-Euler/blob/master/solutions/euler66.py
米 = 1
k个 = 1
一 = 1
b条 = 0
虽然 k个 != 1 或 b条 == 0:
米 = k个 * (米//k个+1) - 米
米 = 米 - 整数((米 - 平方英尺(n个))//k个) * k个
速度A = (一*米 + n个*b条) // 防抱死制动系统(k个)
b条 = (一 + b条*米) // 防抱死制动系统(k个)
k个 = (米*米 - n个) // k个
一 = 温度A
返回 一,b条
#组合学
阶乘的=数学.阶乘的 #不知道它在那里。。。
[文档]定义 保理商(n个,k个):
k阶n的多因子，n（！！…！）。
这是n个跳过k个值的多因素。例如，
factorialk（17,4）=17！！！！=17 * 13 * 9 * 5 * 1
特别是，对于任何整数``n``，我们都有
factorialk（n，1）=阶乘（n）
factorialk（n，2）=factorial2（n）
：param n:int计算多因子。如果`n`<0，则返回值为0。
：param k:int多因子的顺序。
：return:int“n”的Multifactrial。
'''
#scipy中的代码，extact=true
如果 n个 < -1:
返回 0
如果 n个 <= 0:
返回 1
val值=穆尔(范围(n个, 0, -k个))
返回 val值
[文档]定义 阶乘2(n个):
返回 工厂(n个,2)
[文档]定义 阶乘生成(如果=λ x个:x个):
''阶乘生成器
：param f：在每个步骤应用的可选函数
'''
最后的=1
产量 最后的
对于 n个 在里面 itertools软件.计数(1):
最后的=如果(最后的*n个)
产量 最后的
[文档]定义 二项式(n个,k个):
“”系数“n选择k”
：参数：n，k int
：return:int，在k中选择n个项目的方法数，无序
：参见：https://en.wikipedia.org/wiki/二项式
'''
#return阶乘（n）//（阶乘（k）*阶乘（n-k））#非常慢
#代码来自https://en.wikipedia.org/wiki/binnominal#二项式in_programming_languages
如果 k个 < 0 或 k个 > n个:
返回 0
如果 k个 == 0 或 k个 == n个:
返回 1
k个 = 最小值(k个, n个 - k个) #利用对称性
如果 k个>1电子8:
提升 溢出错误(“k”=%d日太大'%k个)
c（c） = 1
对于 我 在里面 范围(k个):
c（c） = c（c） * (n个 - 我) // (我 + 1)
返回 整数(c（c）)
选择=二项式 #别名
合并=二项式 #别名
[文档]定义 二项式指数(n个,k个,第页):
'''
：return:int除以二项式（n，k）的p的最大幂
'''
如果 是素数（_P）(第页):
返回 携带(k个,n个-k个,第页) # https://en.wikipedia.org/wiki/Kummer%27s_ethemath
返回 最小值(二项式指数(n个,k个,一)//b条 对于 一,b条 在里面 因式分解(第页))
[文档]定义 日志系数(n个):
'''
：return：通过Ramanujan公式对ln（n！）进行浮点近似
'''
返回 n个*数学.日志(n个) - n个 + (数学.日志(n个*(1+4*n个*(1+2*n个))))/6 + 数学.日志(数学.圆周率)/2
[文档]定义 对数对数(n个,k个):
'''
：return：ln的浮点近似值（二项式（n，k））
'''
返回 日志系数(n个) - 日志_要素(k个) - 日志系数(n个 - k个)
[文档]定义 伊洛格(一,b条,上限（_B）=False（错误）):
''离散对数x，使b^x=a
：参数a，b：整数
：parameter upper_bound:bool。如果为True，则返回b^x>=a的最小x
：return:x integer，例如b^x=a、upper_bound或None
https://en.wikipedia.org/wiki/Discrete_logarithm（英文）
'''
#TODO:使用baby_step_giant_step或http://anh.cs.luc.edu/331/code/PohligHellman.py或类似
#现在是蛮力。。。
我 = 0
虽然 一 >= b条:
一 //= b条
我 += 1
返回 我
第页=1
对于 x个 在里面 itertools软件.计数():
如果 第页==一: 返回 x个
如果 第页>一: 返回 x个 如果 上限（_B） 其他的 无
第页=b条*第页
#来自“正确的计算方法”：网址：http://www.plunk.org/~舱口/右侧.php
[文档]定义 角(u个,v（v）,单元=真的):
'''
：param u，v：可迭代向量
：param unit:bool如果向量是单位向量，则为True。假增加计算
：returns：u和v单位向量i之间的浮点角度n弧度
'''
如果 不 单元:
u个=车辆单元(u个)
v（v）=车辆单元(v（v）)
如果 点_vv(u个,v（v）) >=0:
返回 2*数学.阿辛(距离(v（v）,u个)/2)
其他的:
返回 数学.圆周率 - 2*数学.阿辛(距离(vecneg公司(v（v）),u个)/2)
[文档]定义 sin_over_x(x个):
''数字安全sin（x）/x''
如果 1 + x个*x个 == 1:
返回 1
其他的:
返回 数学.罪(x个)/x个
[文档]定义 球面线性插值(u个,v（v）,t吨):
“”球面线性插值
：param u，v:3D单位向量
：param t：[0,1]间隔中的浮点
：return：在u和v之间插值的向量
'''
一=角(u个,v（v）)
傅=(1-t吨)*sin_over_x((1-t吨)*一)/sin_over_x(一)
功能性车辆=t吨*sin_over_x(t吨*一)/sin_over_x(一)
返回 维卡德([傅*x个 对于 x个 在里面 u个],[功能性车辆*x个 对于 x个 在里面 v（v）])
#插值
[文档]定义 成比例的(非西亚特,投票):
“”使用https://en.wikipedia.org/wiki/Hagenbach-Bishoff_quota方法
：param nseats:int要分配的座位数
：param pools：int或float的可迭代加权每一方
：result：分配给各方的ints席位列表
'''
配额=总和(投票)/(1+非西亚特) #强制浮动
压裂=[投票/配额 对于 投票 在里面 投票]
物件=[整数(如果) 对于 如果 在里面 压裂]
n个=非西亚特-总和(物件) #剩余可分配座位数
如果 n个==0: 返回 物件 #已完成
如果 n个<0: 返回 [最小值(x个,非西亚特) 对于 x个 在里面 物件] #处理票数=[0,0，..，1,0，…，0]的情况
#将剩余席位让给余下席位最多的n个政党
剩余物=vecsub公司(压裂,物件)
限制=已排序(剩余物,颠倒=真的)[n个-1]
对于 我,第页 在里面 列举(剩余物):
如果 第页>=限制:
物件[我]+=1
n个-=1 #尝试处理完全平等
如果 n个==0: 返回 物件 #已完成
[文档]定义 三角形分区(x个,n个):
“”将1除以n个分数，这样：
-他们的总和是1
-它们遵循三角形线性重分区（对不起，目前没有更好的名称），其中x/1是最大值
'''
定义 _积分(x1个,2个):
x1和x2之间三角形下的返回积分
如果 2个<=x个:
返回 (x1个 + 2个) * 浮动(2个 - x1个) / x个
否则如果 x1个>=x个:
返回 (2-x1个-2个) * 浮动(x1个-2个) / (x个-1)
其他的: #三角形顶部：
返回 _积分(x1个,x个)+_积分(x个,2个)
w个=1/n个 #切片的宽度
返回 [_积分(我*w个,(我+1)*w个) 对于 我 在里面 范围(n个)]
[文档]定义 矩形_分区(x个,n个,小时):
“”将1除以n个分数，这样：
-他们的总和是1
-它们沿着高度h<1的脉冲进行再分配
'''
w个=1/n个 #切片宽度和脉冲宽度
x个=最大值(x个,w个/2)
x个=最小值(x个,1-w个/2)
xa公司,xb（十亿英镑）=x个-w个/2,x个+w个/2 #开始，结束脉冲
哦=(1-小时)/(n个-1) #基准面
定义 _积分(x1个,2个):
x1和x2之间的返回积分
如果 2个<=xa公司 或 x1个>=xb（十亿英镑）:
返回 哦
否则如果 x1个<xa公司:
返回 浮动(哦*(xa公司-x1个)+小时*(w个-(xa公司-x1个)))/w个
其他的: #x1≤xb
返回 浮动(小时*(xb（十亿英镑）-x1个)+哦*(w个-(xb公司-x1个)))/w个
返回 [_积分(我*w个,(我+1)*w个) 对于 我 在里面 范围(n个)]
[文档]定义 德布瑞恩(k个, n个):
'''
字母k的De Bruijn序列和长度n的子序列。
https://en.wikipedia.org/wiki/De_Bruijn_sequence（英文）
'''
尝试:
#让我们看看k是否可以转换为整数；
#如果是的话，把我们的字母表列出来
_ = 整数(k个)
字母表 = 列表(地图(字符串, 范围(k个)))
除了 (值错误, 类型错误):
字母表 = k个
k个 = 伦恩(k个)
一 = [0] * k个 * n个
序列 = []
定义 数据库(t吨, 第页):
如果 t吨 > n个:
如果 n个 % 第页 == 0:
序列.延伸(一[1:第页 + 1])
其他的:
一[t吨] = 一[t吨 - 第页]
数据库(t吨 + 1, 第页)
对于 j个 在里面 范围(一[t吨 - 第页] + 1, k个):
一[t吨] = j个
数据库(t吨 + 1, t吨)
数据库(1, 1)
返回 "".参加(字母表[我] 对于 我 在里面 序列)
“”模运算
最初动机：https://www.hackdrak.com/challenges/ncr
代码转换自http://comeoncdeon.wordpress.com/2011/07/31/combination网站/
另请参见http://userpages.umbc.edu/~rcampbel/Computers/Python/lib/numbthy.py
数学代码来自http://thales.math.uqam.ca/~罗兰/包/二项式系数。米
'''
#参见http://anh.cs.luc.edu/331/code/mod.py对于MOD类
[文档]定义 模块输入(一,b条):
# http://rosettacode.org/wiki/Chinese_remainder_theorem#Python
如果 是素数（_P）(b条): #使用欧拉定理
返回 首次公开募股(一,b条-2,b条)
b0（b0） = b条
x0个, x1个 = 0, 1
如果 b条 == 1: 返回 1
虽然 一 > 1:
q个 = 一 // b条
一, b条 = b条, 一%b条
x0个, x1个 = x1个 - q个 * x0个, x0个
如果 x1个 < 0: x1个 += b0（b0）
返回 x1个
[文档]定义 修改div(一,b条,米):
'''
：return:x，这样（b*x）mod m=a mod m
'''
返回 一*修改（_V）(b条,米)
[文档]定义 修改_操作(n个,米):
'''
：return:n！模式m
'''
物件 = 1
虽然 n个 > 0:
对于 我 在里面 范围(2,n个%米+1):
物件 = (物件 * 我) % 米
n个=n个//米
如果 n个%2 > 0 :
物件 = 米 - 物件
返回 物件%米
[文档]定义 中文_维护者(米, 一):
'''http://en.wikipedia.org/wiki/Chinese_remainder_theorem
：param m：int模列表
：param a:int余数列表
：return：最小的int x，使x mod ni=ai
'''
# http://rosettacode.org/wiki/Chinese_remainder_theorem#Python
物件 = 0
触头=复数(米)
对于 米, a_i 在里面 拉链(米, 一):
第页 = 触头 // 米
物件 += a_i * 修改（_V）(第页, 米) * 第页
返回 物件 % 触头
定义 _计数(n个, 第页):
'''
：return：n中p的幂
'''
k个=0;
虽然 n个>=第页:
k个+=n个//第页
n个=n个//第页
返回 k个;
[文档]定义 mod_binomial（模态_非模态）(n个,k个,米,q个=无):
“”计算大n，k，m的C（n，k）mod m
：param n:int元素总数
：param k:int要选取的元素数
：param m:int模（或内部使用的（m，p）元组的可迭代）
：param q：质数m的可选整数幂m，内部使用
'''
#该函数实现了递归调用的3种情况：
#1:m是素数pi^qi的幂的因式分解
#2：中国剩余定理用于组合所有C（n，k）mod pi^qi
#3:Lucas或Andrew Granville定理用于计算C（n，k）mod pi^qi
如果 类型(米) 是 整数:
如果 q个 是 无:
返回 mod_binomial（模态_非模态）(n个,k个,因式分解(米))
#3
否则如果 q个==1: #使用http://en.wikipedia.org/wiki/Lucas'_主题
镍=数字生成(n个,米)
ki公司=数字生成(k个,米)
物件=1
对于 一,b条 在里面 拉链(镍,ki公司):
物件*=二项式(一,b条)
如果 物件==0: 打破
返回 物件
#参见http://codechef17.rssing.com/chan-12597213/all_p5.html
'''
elif q==3：
返回模态（n*m，k*m，m）
'''
#目前没有选择。。。。
返回 二项式(n个,k个)%(米**q个)
其他的: #2
#使用http://en.wikipedia.org/wiki/Chinese_remainder_theorem
第页,如果=[],[]
对于 第页,q个 在里面 米:
第页.追加(mod_binomial（模态_非模态）(n个,k个,第页,q个))
如果.追加(第页**q个)
返回 中文_维护者(如果,第页)
[文档]定义 baby_step_giant_step婴儿步(年, 一, n个):
“”解决了离散对数问题（DLP）y=a**x mod n
'''
#http://l34rn-p14y.blogspot.it/2013/11/baby-step-giant-step-algorithm-python.html
秒 = 整数(数学.天花板(数学.平方英尺(n个)))
一个 = [年 * 功率(一, 第页, n个) % n个 对于 第页 在里面 范围(秒)]
对于 t吨 在里面 范围(1,秒+1):
价值 = 功率(一, t吨*秒, n个)
如果 价值 在里面 一个:
返回 (t吨 * 秒 - 一个.指数(价值)) % n个
#灵感来自http://stackoverflow.com/questions/28548457/nth-fibonacci-number-for-n-as-big-as-1019
[文档]定义 mod_最大值(一个,B类, 国防部=0):
如果 不 国防部:
返回 点_毫米(一个,B类)
返回 [[总和(一*b条 对于 一,b条 在里面 拉链(低（_R）,列（_C）))%国防部 对于 列（_C） 在里面 拉链(*B类)] 对于 行（_R） 在里面 一个]
[文档]定义 mod_matpow模式(米, 权力, 国防部=0):
如果 权力 < 0:
提升 未实现错误
结果 = 身份(2)
对于 权力 在里面 数字(权力,2,真的):
如果 权力:
结果 = mod_最大值(结果, 米, 国防部)
米 = mod_最大值(米, 米, 国防部)
返回 结果
#事实上，numpy.linalg.matrix_power对大功率有一个缺陷
# https://github.com/numpy/numpy/issues/5166
#因此我们在上面的功能更好：-）
矩阵_幂=mod_matpow模式
[文档]定义 mod_sqrt模式(n个, 第页):
“”模块sqrt（n）mod p
'''
断言 是素数（_P）(第页),“p必须是质数”
一 = n个%第页
如果 第页%4 == 三: 返回 功率(一, (第页+1) >> 2, 第页)
否则如果 第页%8 == 5:
v（v） = 功率(一 << 1, (第页-5) >> 三, 第页)
我 = ((一*v（v）*v（v） << 1) % 第页) - 1
返回 (一*v（v）*我)%第页
否则如果 第页%8 == 1: #Shank方法
q个, e（电子） = 第页-1, 0
虽然 q个&1 == 0:
e（电子） += 1
q个 >>= 1
n个 = 2
虽然 传说(n个, 第页) != -1: n个 += 1
w个, x个, 年, 第页 = 功率(一, q个, 第页), 功率(一, (q个+1) >> 1, 第页), 功率(n个, q个, 第页), e（电子）
虽然 真的:
如果 w个 == 1: 返回 x个
v（v）, k个 = w个, 0
虽然 v（v） != 1 和 k个+1 < 第页:
v（v） = (v（v）*v（v）)%第页
k个 += 1
如果 k个 == 0: 返回 x个
d日 = 功率(年, 1 << (第页-k个-1), 第页)
x个, 年 = (x个*d日)%第页, (d日*d日)%第页
w个, 第页 = (w个*年)%第页, k个
其他的: 返回 一 #p==2
[文档]定义 mod_fac（_F）(n个, 国防部, mod _ is_质数=False（错误）):
“”模阶乘
：返回n！%模
如果模是素数，使用威尔逊定理
https://en.wikipedia.org/wiki/Wilson%27s_ethemation
'''
如果 n个 >= 国防部 : #那么mod是n的一个因子！
返回 0
如果 n个<20: #对于小n，朴素算法可能更快
返回 阶乘的(n个)%国防部
如果 mod _ is_质数 或 是素数（_P）(国防部): #使用威尔逊定理：（n-1）！==-1（模数）
结果 = 国防部 - 1; #避免负数：-1==模-1（模-模）
对于 我 在里面 范围(国防部 - 1,n个,-1):
结果 *= 修改（_V）(我, 国防部)
结果 %= 国防部
返回 结果
其他的:
返回 itertools2.第n个(n个,阶乘生成(λ x个:x个%国防部))
[文档]定义 pi_数字_生成():
“”将圆周率数字生成为INTEGERS序列！
使用Jeremy Gibbons插口生成器
：参见：http://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/spigot.pdf
'''
#代码来自http://davidbau.com/archives/2010/03/14/python_pipy_spigot.html
q个, 第页, t吨, j个 = 1, 180, 60, 2
虽然 真的:
u个, 年 = 三*(三*j个+1)*(三*j个+2), (q个*(27*j个-12)+5*第页)//(5*t吨)
产量 年
q个, 第页, t吨, j个 = 10*q个*j个*(2*j个-1), 10*u个*(q个*(5*j个-2)+第页-年*t吨), t吨*u个, j个+1
#------------------------------------------------------------------------------
#因子分解代码取自https://pypi.python.org/pypi/primefac
#
# http://programmingpraxis.com/2010/04/23/modern-elliptic-curve-factorization-part-1/
# http://programmingpraxis.com/2010/04/27/modern-elliptic-curve-factorization-part-2/
#------------------------------------------------------------------------------
[文档]定义 pfactor（功率因数）(n个):
''sprp的Helper函数。
返回元组（x，y），其中n-1==（2**x）*y和y是奇数。
我们把这个部分分开，这样就不会浪费时间
当我们要根据多个基数检查n时，重新计算每个基数的s和d。
'''
# https://pypi.python.org/pypi/primefac
秒, d日, q个 = 0, n个-1, 2
虽然 不 d日 & q个 - 1:
秒, q个 = 秒+1, q个*2
返回 秒, d日 // (q个 // 2)
[文档]定义 sprp程序(n个, 一, 秒=无, d日=无):
“”“使用强概率素性检验以a为基础检查n的素性。
如果存在，s和d应分别为第一项和第二项，
函数pfactor（n）“”返回的元组的
# https://pypi.python.org/pypi/primefac
如果 n个%2 == 0:
返回 False（错误）
如果 (秒 是 无) 或 (d日 是 无):
秒, d日 = pfactor（功率因数）(n个)
x个 = 功率(一, d日, n个)
如果 x个 == 1:
返回 真的
对于 我 在里面 范围(秒):
如果 x个 == n个 - 1: 返回 真的
x个 = 功率(x个, 2, n个)
返回 False（错误）
[文档]定义 雅各比(一, 第页):
“”计算雅可比符号（a|p），其中p是正奇数。
：参见：https://en.wikipedia.org/wiki/Jacobi_symbol
'''
# https://pypi.python.org/pypi/primefac
如果 (第页%2 == 0) 或 (第页 < 0): 返回 无 #p必须是正奇数
如果 (一 == 0) 或 (一 == 1): 返回 一
一, t吨 = 一%第页, 1
虽然 一 != 0:
虽然 不 一 & 1:
一 //= 2
如果 第页 & 7 在里面 (三, 5): t吨 *= -1
一, 第页 = 第页, 一
如果 (一 & 三 == 三) 和 (第页 & 三) == 三:
t吨 *= -1
一 %= 第页
返回 t吨 如果 第页 == 1 其他的 0
[文档]定义 民意测验Rho_brent(n个):
布伦特对波拉德rho算法的改进。
：return:int n如果n是质数
否则，我们会一直吃力，直到找到一个严格介于1和n之间的因子n。
：参见：https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
'''
如果 是素数（_P）(n个): 返回 n个
克 = n个
虽然 克 == n个:
年, c（c）, 米, 克, 第页, q个 = 随机范围(1, n个), 随机范围(1, n个), 随机范围(1, n个), 1, 1, 1
虽然 克==1:
x个, k个 = 年, 0
对于 我 在里面 范围(第页): 年 = (年**2 + c（c）) % n个
虽然 k个 < 第页 和 克 == 1:
年 = 年
对于 我 在里面 范围(最小值(米, 第页-k个)):
年 = (年**2 + c（c）) % n个
q个 = q个 * 防抱死制动系统(x个-年) % n个
克, k个 = gcd公司(q个, n个), k个+米
第页 *= 2
如果 克==n个:
虽然 真的:
年 = (年**2+c（c）)%n个
克 = gcd公司(防抱死制动系统(x个-年), n个)
如果 克 > 1: 打破
返回 克
[文档]定义 投票_pm1(n个, 地下一层=100, 地下二层=1000): #TODO:什么是最佳默认边界以及增加它们的方法？
“波拉德的p+1算法，两阶段版本。
：如果n是质数，则返回：n；否则，我们会一直吃力，直到找到一个严格介于1和n之间的因子n。
'''
如果 是素数（_P）(n个): 返回 n个
米 = is_power（电源）(n个)
如果 米: 返回 米
虽然 真的:
第页 = 素数_根()
q个 = 2 #TODO:q的其他初始值如何？
第页 = 第页.下一个()
虽然 第页 <= 地下一层: q个, 第页 = 功率(q个, 第页**伊洛格(地下一层, 第页), n个), 第页.下一个()
克 = gcd公司(q个-1, n个)
如果 1 < 克 < n个: 返回 克
虽然 第页 <= 地下二层: q个, 第页 = 功率(q个, 第页, n个), 第页.下一个()
克 = gcd公司(q个-1, n个)
如果 1 < 克 < n个: 返回 克
#这些边界失败。增加并重试。
地下一层 *= 10
地下二层 *= 10
[文档]定义 姆卢卡斯(v（v）, 一, n个):
williams_pp1（）的“”Helper函数。
沿Lucas序列模n乘以。
'''
第1版, 第2版 = v（v）, (v（v）**2 - 2) % n个
对于 一点 在里面 箱子(一)[三:]:
如果 一点 == "0":
第1版, 第2版 = ((第1版**2 - 2) % n个, (第1版*第2版 - v（v）) % n个)
其他的:
第1版, 第2版 = ((第1版*第2版 - v（v）) % n个, (第2版**2 - 2) % n个)
返回 第1版
[文档]定义 威廉_第1页(n个):
威廉姆斯p+1算法。
：return:n，如果n是质数
否则，我们会一直吃力，直到找到一个严格介于1和n之间的因子n。
'''
如果 是素数（_P）(n个): 返回 n个
米 = is_power（电源）(n个)
如果 米: 返回 米
对于 v（v） 在里面 itertools软件.计数(1):
对于 第页 在里面 素数_gen():
e（电子） = 伊洛格(isqrt公司(n个), 第页)
如果 e（电子） == 0: 打破
对于 _ 在里面 范围(e（电子）): v（v） = 姆卢卡斯(v（v）, 第页, n个)
克 = gcd公司(v（v） - 2, n个)
如果 1 < 克 < n个: 返回 克
如果 克 == n个: 打破
[文档]定义 ecadd公司(第1页, 第2页, p0, n个):
#将两个点p1和p2相加，给定点P0=p1-p2模n
x1个,z1（零） = 第1页; 2个,z2型 = 第2页; x0个,z0（零） = 第0页
t1时间, t2时间 = (x1个-z1（零）)*(2个+z2型), (x1个+z1（零）)*(2个-z2型)
返回 (z0（零）*功率(t1时间+t2时间,2,n个) % n个, x0个*功率(t1时间-t2时间,2,n个) % n个)
[文档]定义 埃克杜布(第页, 一个, n个):
#模n上的双点p
x个, z（z） = 第页; 安, 广告 = 一个
t1时间, t2时间 = 功率(x个+z（z）,2,n个), 功率(x个-z（z）,2,n个)
t吨 = t1时间 - t2时间
返回 (t1时间*t2时间*4*广告 % n个, (4*广告*t2时间 + t吨*安)*t吨 % n个)
[文档]定义 埃克穆尔(米, 第页, 一个, n个):
#将曲线A上的点p乘以m的模n
如果 米 == 0: 返回 (0, 0)
否则如果 米 == 1: 返回 第页
其他的:
q个 = 埃克杜布(第页, 一个, n个)
如果 米 == 2: 返回 q个
b条 = 1
虽然 b条 < 米: b条 *= 2
b条 //= 4
第页 = 第页
虽然 b条:
如果 米&b条: q个, 第页 = 埃克杜布(q个, 一个, n个), ecadd公司(q个, 第页, 第页, n个)
其他的: q个, 第页 = ecadd公司(第页, q个, 第页, n个), 埃克杜布(第页, 一个, n个)
b条 //= 2
返回 第页
[文档]定义 系数_ecm(n个, 地下一层=10, 地下二层=20):
“”使用椭圆曲线方法的因子n，
使用蒙哥马利曲线和类似算法
波拉德p-1方法的两阶段变体。
：return:n，如果n是质数
否则，我们会一直跳，直到找到一个严格介于1和n之间的因子n
'''
#TODO:确定B1和B2的最佳默认值以及增加它们和iters的最佳方法
#TODO:我们目前根据需要从筛子中计算素数列表，但这意味着我们在每个
#迭代。虽然它不是特别高效的存储器，但我们可能能够提高时间效率
#通过提前计算我们需要的素数（比如在开始时计算一次，然后每次增加一次
#bounds）并将其保存在列表中，然后在这些列表上迭代内部while循环。
如果 是素数（_P）(n个): 返回 n个
米 = is_power（电源）(n个)
如果 米: 返回 米
iters公司 = 1
虽然 真的:
对于 _ 在里面 范围(iters公司): #TODO:多处理？
#TODO:我们真的想调用随机化器吗？为什么种子不是B1、B2和iters的函数？
#托多：有些种子比其他种子好吗？
种子 = 随机的，随机的.随机范围(6, n个)
u个, v（v） = (种子**2 - 5) % n个, 4*种子 % n个
第页 = 功率(u个, 三, n个)
问, C类 = (功率(v（v）-u个,三,n个)*(三*u个+v（v）) % n个, 4*第页*v（v） % n个), (第页, 功率(v（v）,三,n个))
第页 = 素数_gen()
第页 = 六.下一个(第页)
虽然 第页 <= 地下一层: 问, 第页 = 埃克穆尔(第页**伊洛格(地下一层, 第页), 问, C类, n个), 六.下一个(第页)
克 = gcd公司(问[1], n个)
如果 1 < 克 < n个: 返回 克
虽然 第页 <= 地下二层:
#“有一个简单的编码技巧可以加快第二阶段的速度，
#我们将i从B1+1迭代到B2，每个步骤加上2Q；当i为素数时，当前Q可以累加
#到正在运行的解决方案中。再次，我们将最大公约数的计算推迟到
#迭代。
#TODO:执行此技巧并比较性能。
问 = 埃克穆尔(第页, 问, C类, n个)
克 *= 问[1]
克 %= n个
第页 = 六.下一个(第页)
克 = gcd公司(克, n个)
如果 1 < 克 < n个: 返回 克
#此种子失败。用一个新的再试一次。
#这些边界失败。增加并重试。
地下一层 *= 三
地下二层 *= 三
iters公司 *= 2
#勒让德符号（a|m）
#托多：哪个更快？
[文档]定义 传说(一, 第页):
“”用于编译Legendre符号（a|p）的函数。
如果p是复合的，则返回值没有意义
：参见：https://en.wikipedia.org/wiki/Legendre_symbol
'''
返回 ((功率(一, (第页-1) >> 1, 第页) + 1) % 第页) - 1
[文档]定义 传奇2(一, 第页): #TODO:很确定这会计算雅各比符号
“”用于编译Legendre符号（a|p）的函数。
如果p是复合的，则返回值没有意义
：参见：https://en.wikipedia.org/wiki/传奇符号
'''
如果 一 == 0: 返回 0
x个, 年, L（左） = 一, 第页, 1
虽然 1:
如果 x个 > (年 >> 1):
x个 = 年 - x个
如果 年 & 三 == 三: L（左） = -L（左）
虽然 x个 & 三 == 0: x个 >>= 2
如果 x个 & 1 == 0:
x个 >>= 1
如果 年 & 7 == 三 或 年 & 7 == 5: L（左） = -L（左）
如果 x个 == 1: 返回 ((L（左）+1) % 第页) - 1
如果 x个 & 三 == 三 和 年 & 三 == 三: L（左） = -L（左）
x个, 年 = 年 % x个, x个