基于Python数据+代码=算法①算法入门的一些基础代码

1.打印九九乘法表

1.1基础版

for i in range(1,10):
    for j in range(1,i+1):
        print("{}×{}={}".format(i,j,i*j),end=' ')
    print('')

1×1=1 
2×1=2 2×2=4 
3×1=3 3×2=6 3×3=9 
4×1=4 4×2=8 4×3=12 4×4=16 
5×1=5 5×2=10 5×3=15 5×4=20 5×5=25 
6×1=6 6×2=12 6×3=18 6×4=24 6×5=30 6×6=36 
7×1=7 7×2=14 7×3=21 7×4=28 7×5=35 7×6=42 7×7=49 
8×1=8 8×2=16 8×3=24 8×4=32 8×5=40 8×6=48 8×7=56 8×8=64 
9×1=9 9×2=18 9×3=27 9×4=36 9×5=45 9×6=54 9×7=63 9×8=72 9×9=81 

1.2升级版

需求：【1X1=1 -> 一一得一】形式

# 先定一个数字转化函数
_MAPPING = (u'零', u'一', u'二', u'三', u'四', u'五', u'六', u'七', u'八', u'九', u'十', u'十一', u'十二', u'十三', u'十四', u'十五', u'十六', u'十七',u'十八', u'十九')
_P0 = (u'', u'十', u'百', u'千',)
_S4 = 10 ** 4
def _to_chinese4(num):
    assert (0 <= num and num < _S4)
    if num < 20:
        return _MAPPING[num]
    else:
        lst = []
        while num >= 10:
            lst.append(num % 10)
            num = num / 10
        lst.append(num)
        c = len(lst)  # 位数
        result = u''

        for idx, val in enumerate(lst):
            val = int(val)
            if val != 0:
                result += _P0[idx] + _MAPPING[val]
                if idx < c - 1 and lst[idx + 1] == 0:
                    result += u'零'
        return result[::-1]

_to_chinese4(1) 

'一'

转化函数参考：https://www.jianshu.com/p/c87581f9aaa4

for i in range(1,10):
    for j in range(1,i+1):
        print("{}{}得{}".format(_to_chinese4(j) ,_to_chinese4(i) ,_to_chinese4(i*j) ),end=' ')
    print('')

一一得一 
一二得二 二二得四 
一三得三 二三得六 三三得九 
一四得四 二四得八 三四得十二 四四得十六 
一五得五 二五得十 三五得十五 四五得二十 五五得二十五 
一六得六 二六得十二 三六得十八 四六得二十四 五六得三十 六六得三十六 
一七得七 二七得十四 三七得二十一 四七得二十八 五七得三十五 六七得四十二 七七得四十九 
一八得八 二八得十六 三八得二十四 四八得三十二 五八得四十 六八得四十八 七八得五十六 八八得六十四 
一九得九 二九得十八 三九得二十七 四九得三十六 五九得四十五 六九得五十四 七九得六十三 八九得七十二 九九得八十一 

感悟：算法质量四要素

• 数据
• 时间效率
• 空间效率
• 硬件

2.加法算法，体验时间与空间效率

2.1 时间效率

2.1.1 方法1：${\sum }_{i=0}^{10000}i$

import time
time_start = time.time()
sum = 0
for i in range(100001):
    sum += i
print(sum)

time_end = time.time()
time1 = time_end-time_start
print('='*30)
print('所耗时间为：{}'.format(time1))

5000050000
==============================
所耗时间为：0.008975744247436523

2.1.2 方法2：$n(n+1)/2$

time_start = time.time()
sum = 0
def sum_function(n):
    sum = n*(n+1)/2
    print(sum)
sum_function(10000)
time_end = time.time()
time1 = time_end-time_start
print('='*30)
print('所耗时间为：{}'.format(time1))

50005000.0
==============================
所耗时间为：0.0

感悟：执行一次叫做$O(1)$,也叫作常阶数，执行n次叫做$O(n)$,也叫作线性阶数，还有对数阶数$O(log(n))$、平方阶数$O(n^2)$、立方阶数$O(n^3)$、阶乘阶数$O(n!)$

关系为：$O(1)<O(log(n))<O(n)<O(n^2)<O(n^3)<O(n!)$

2.2 空间效率

2.2.1 全元素载入空间

# 传统方法54张牌，随机抽取5张
Poker=['黑A','黑2','黑3','黑4','黑5','黑6','黑7','黑8','黑9','黑10','黑J','黑Q','黑K',
      '红A','红2','红3','红4','红5','红6','红7','红8','红9','红10','红J','红Q','红K',
      '梅A','梅2','梅3','梅4','梅5','梅6','梅7','梅8','梅9','梅10','梅J','梅Q','梅K',
      '方A','方2','方3','方4','方5','方6','方7','方8','方9','方10','方J','方Q','方K',
      '小王','大王']
print('一副牌有%d张'%(len(Poker)))
import random
Show=random.sample(Poker,5)        #随机抽取5张，展现
print(Show)

一副牌有54张
['方10', '黑8', '红2', '小王', '红7']

2.2.2 选择性利用空间

#=========================高空间利用率算法
'''
   这里默认规则为黑A到黑K顺序编号为1到13，红A到红K编号为14到26，梅A到梅K编号为27到39，
   方A到方K编号为40到52，小王编号53，大王编号54
'''
shape=['J','Q','K','小王','大王']
Show1=[]
Show2=[]
def getCards(name,r,Show2,shape=None):      #从同一花色13张牌里取一张牌
    if r==1 : 
        Show2.append(name+'A')
    elif r<=10:
        Show2.append(name+str(r))
    else:
        Show2.append(name+shape[r-11])  #考虑J、Q、K
#
for x in range(5):                #随机抽取5个值
    y=random.randint(1,55)        #在[1,54]范围里随机抽取一个整数
    Show1.append(y)
for r in Show1:                   #确定5张牌
    if r<=13:                     #取黑桃里的13张牌
        getCards('黑',r,Show2,shape)
    elif r>13 and r<=26:          #取红桃里的13张牌
       
        getCards('红',r-13,Show2,shape) 
    elif r>27 and r<=39:          #取梅花里的13张牌
       
        getCards('梅',r-26,Show2,shape)  
    elif r>40 and r<=52:          #取方块里的13张牌
       
        getCards('方',r-39,Show2,shape)
    else:
        Show2.append(shape[r%50])  #取小王或大王
print(Show2)                       #取出的5张牌
        
        

['方2', '梅J', '方10', '方K', '黑K']

感悟：1.所谓空间，就是存储空间与资源分配，算法1将54个元素全部传入到了空间，这会给空间造成压力（因为现在元素个数少），算法2就比较优秀了，只需要传入5个元素，当然Show1和Show2也会被分配空间，但是空间压力远不及算法1

2.空间和时间在算法执行上需要我们去取舍！以空间换取时间，或者以时间换取空间！

2.3 求x=10的阶乘

def factorial_function(n):
    multiplication = 1
    if n<=1:
        print("{} factorial = 1".format(n))
    else:
        for i in range(1,n+1):
            multiplication = i*multiplication
    return multiplication
factorial_function(10)

3628800

2.4 干一些好玩的事

2.4.1 笛卡尔的心

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0,2*np.pi,500)
a = 6
rho = a*(1-np.sin(x))
plt.subplot(polar=True)
plt.plot(x,rho,c='red')
plt.text(0,15,'Love you!',color='m')
plt.show()

2.4.2 蒙特卡洛求$\pi$

from random import random
n = 100000
def count_point(n):
    count = 0
    for i in range(1,n+1):
        x = random()*2-1  # 产生x，y的随机数，落入正方形内
        y = random()*2-1  
        if x ** 2 + y ** 2 < 1: # 数点
            count += 1
    return count
print('总实验次数为：%d，蒙特卡洛近似圆周率值为：%f'%(n,4*count_point(n)/n))

总实验次数为：100000，蒙特卡洛近似圆周率值为：3.142680

2.4.3 求最大公约数

def Common_Divisor(a,b):
    a_factor = []
    b_factor = []
    for i in range(1,int(a+1/2)+1):
        if a % i == 0:
            a_factor.append(i)
    for j in range(1,int(b+1/2)+1):
        if b % j == 0:
            b_factor.append(j)
    return [new for new in b_factor if new in a_factor] # 取交集
max(Common_Divisor(12,2))

2

2.4.4 求最小公倍数

由于两个数的乘积等于这两个数的最大公约数与最小公倍数的积
a*b = Common_Divisor(a,b)*最小公倍数

from functools import reduce
12*60/max(Common_Divisor(12,60))

60.0

2.4.5 闰年问题

def Leap_Year(year):
    if year % 4 == 0 and year % 100 !=0:
        return 1
    elif y % 400 == 0:
        return 1
    else:
        return 0

try:
    year = int(input('请输入年份：'))
    if year >= 0:
        leap_year = Leap_Year(year)
        if leap_year:
            print('%d是闰年'%(year))
        else:
            print('%d不是闰年'%(year))
    else:
        print('输入年份不对！')
except:
    print('输入有误！请重新输入！')
    
        

请输入年份：2004
2004是闰年

2.4.6 求三维空间三角形面积

tips：

1. 已知三维空间的坐标
2. 利用欧氏距离求三位的距离
3. 利用海伦公式求任意三角形的面积

import numpy as np
# 已知三个坐标
A = np.array([1,1,1])
B = np.array([1,2,3])
C = np.array([4,4,4])
# 欧式距离公式
Distance_AB = np.sqrt(np.sum((A-B)**2))
Distance_BC = np.sqrt(np.sum((B-C)**2))
Distance_AC = np.sqrt(np.sum((A-C)**2))
# 海伦公式求面积
s = (Distance_AB+Distance_AC+Distance_BC)/2
area = np.sqrt(s*(s-Distance_AB)*(s-Distance_AC)*(s-Distance_BC))
print('该任意三角形面积为%.2f'%(area))

该任意三角形面积为3.67