从基础试题看效率问题

写在前面的话

一个优秀的程序员应该不仅是能够轻松的解决日常工作中的难题，同时最重要的一点是，在解决问题的时候兼顾效率问题，这是身为一个程序员所应该培养的习惯。那么下面我们就来看几个例子。

求100以内的素数

这道题算是非常基础的试题了，让我们来试着解答一下。

1. 简单算法，一个数能被从2开始到自身的平方根的正整数整除，就是合数。

import datetime
start = datetime.datetime.now()
n = 100
count = 0
for i in range(2,n):
	for j in range(2, int(i**0.5)+1):
		if i%j == 0:
			break
	else:
		count += 1
		print(i)
delta= (datetime.datetime.now - start).total_seconds()
print(count)
print(delta)

上面我们得到一个简单的计算过程，在初步处理完问题后我们就要思考一下，现在如何优化上面这段代码，使其效率更高？

2.使用奇数，因为素数一定是奇数，所以我们只需将奇数中的素数挑选出来即可。

import datetime
start = datetime.datetime.now()
n = 100
count = 1
for i in range(3,n,2):
	for j in range(3,int(i**0.5)+1,2):
		if i%j == 0:
		break
	else:
		count += 1
		print(x)
delta=(datetime,datetime,now() - strat).total_seconds()
print(count)
peint(delta)

得到上面这段代码后我们需要继续思考质数的相关性质，质数一定不能整除1和本身之间的整数，合数一定 可以分解为几个质数的乘积，2是质数，那么我们不难想到下面这段代码。

3.存储质数

import datetime
start = datetime.datetime.now()
n = 100
count = 1
primenumbers = [2] #质数列表
for i in range(3,n,2):
	flag = False
	edge = int(i**0.5)
	for j in primenumbers:
		if i > edge:
		flag = True
		break
		if i%j == 0:
			break
	if flag: 
		primenumbers.append(i)
		count += 1
delta=(datetime.datetime.now() - start).total_seconds()
print(count)
print(delta)

通过运行时间长短的判断，我们得出目前的这段代码是效率最高的。 但是难道就这样，不能再提高了么？

孪生素数性质：
大于3的素数只有6N-1和6N+1两种形式，如果6N+1都是素数便称为孪生素数。

根据孪生素数的性质，我们不难想到另外一种解题思路：

import datetime
start = datetime.datetime.now()
n = 100
count = 3
x = 7
step = 4
while x < n:
	if x%5 != 0 :
		for i in range(3,int(x**0.5)+1,2)
			if x % j == 0:
				break
		else:
			count += 1
	x += step
	step = 4 if step == 2 else 2
delta = (datetime.datetime.now()-start).total_seconds()
print(count)
print(delta)

由上面几段代码可知，我们的目标不应该是解决问题，而是要努力在解决问题的过程中，解决运行效率的问题。

杨辉三角

相信杨辉三角大家都不陌生，那么下面我们就来试着写几段。

triangle = [[1],[1,1]]
for i in range(2,6):
	cur = [1]
	pre = triangle[i-1]
	for j in range(i-1):
		cur.append(pre[j] + pre[j+1])
	cur.append(1)
	triangle.append(cur)
print(triangle)

#第二种方法
triangle = []
n = 6
for i in range(n):
	cur = [1]
	triangle.append(cur)
	if i == 0:continue
	pre = triangle[i-1]
	for j in range(i-1):
		cur.append(pre[j] + pre[j+1])
	cur.append(1)
print(triangle)

根据上面这个模型，我们不难发现其对称性，那么如何利用其对称性这个特点，来写呢？

triangle = []
n = 6 
for i in range(n):
	row = [1] * (i + 1)
	triangle.append(row)
	for j in range(1,i//2+1):
		val = triangle[i-1][j+1] + triangle[i-1][j]
		row[j] = val
		if i != 2*j:
			row[-j-1] = val
print(triangle)
#另一种中点的处理
triangle = [[1],[1,1]]
n = 10
for i in range(2,n):
	row = [1]*(i+1)
	triangle.append(row)
	for j in range(i//2):
		val = triangle[i-1][j] + triangle[i-1][j+1]
		row[j+1] = val
		if i != 2*(j+1):
			row[-(j+2)] = val
print(triangle)

上面的方法效率并不是很高，那么我们能否在利用对称性的同时，只开辟一个列表来实现杨辉三角呢？

n = 6
row = [1]*n
for i in range(n):
	old = 1
	for j in range(i//2):
		val = old + row[j+1]
		old = row[j+1]
		row[j+1] = val
		if i != 2*(j+1):
			row[i-(j+1)] = val
	print(row[:i+1])

也可以写成下面这个样子：

n = 6
row = [1]*n
for i in range(n):
	old = 1
	for j in range(i//2):
		row[j+1],old = old + row[j+1],row[j+1]
		if i != 2*(j+1):
			row[i-(j+1)] = row [j+1]
	print(row[:i+1])

由此可见，效率问题贯穿全程，在生产工作中是非常重要的一个考量因素，因此如果想要成为一个优秀的程序员，就要从一开始养成良好的习惯，时时刻刻注意时间复杂度的问题。