python3.7里面的简单的算法做法小结

---恢复内容开始---

1、

# 创建一个列表，列表的内容为200以内的能同时被3和7整除的数字，并要求降序排序
lsa = [i for i in range(1,201) if i%3==0 and i%7==0]
lsa.sort(reverse=True)
print(lsa)

# 结果是：
[189, 168, 147, 126, 105, 84, 63, 42, 21]

2、

# 创建一个列表，列表内存储5个字符串，将这个列表以字符串长度升序排序，输出列表，查看排序结果

ls = ["heel", "world", "s", "niasdf", "asdfasdfasdf"]
print(sorted(ls, key=lambda x: len(x)))

# 结果是：
['s', 'heel', 'world', 'niasdf', 'asdfasdfasdf']

3、
# 输入三角形的三条边并求面积

import math
a = int(input('请输入第一条边'))
b = int(input('请输入第二条边'))
c = int(input('请输入第三条边'))

p = (a+b+c)/2
s = math.sqrt(p*(p-a)*(p-b)*(p-c))
print(s)

4 、
# 判断一个数是不是质数， 就是只能被1和它本身整除整除的数

def sushu(num):
    if num > 1 :
        for i in range(2,num//2):
            if num % i == 0:
                return "这不是一个质数"

        else:
                return '这是一个质数'

print(sushu(int(input('请输入一个数：'))))

5、# 求一个数的阶乘 例：5的阶乘是 1*2*3*4*5 

def jie(n):
    if n==1:
        return 1;
    elif n > 1:
        return  n*jie(n-1);
print(jie(int(input("请输入需要阶乘的数:"))))
# 结果是 120

6、 # 求1到999以内任意一个数的递归的和

def digui(n):
    if n==1:
        return 1
    elif 1 < n < 999:
        return n+digui(n-1)
print(digui(int(input("请输入一个数:"))))

7、 # 求某个数的n次方的值

def hanshu(a,b):
    return a**b

print(hanshu(3,2))

# 结果是 9

8，#  冒泡排序
def maopao(list1):
    for i in range(len(list1)-1):
        for j in range(len(list)-1-i):
            if list1[j] > list1[j+1]:
               list1[j], list1[j+1] = list1[j+1], list1[j]
    return list1
print(maopao([9, 7, 5, 3, 1, 2, 4, 6, 8]))

#  结果是： [1, 2, 3, 4, 5, 6, 7, 8, 9]


9. 快速排序
def quick(alist, left, right):
    key = alist[left]
    while left < right:
       while left < right and alist[right] >= key:
          right -= 1
       while left < right and alist[left] <= key:
          left += 1
       alist[left], alist[right] = alist[right], alist[left]
    alist[alist.index(key)], alist[left] = alist[left], alist[alist.index(key)]
    return left
def interval(alist,left, right):
    if left < right:
       key_index = quick(alist, left, right)
       interval(alist, left, key_index)
       interval(alist, key_index+1, right)
alist = [9, 2, 5, 7, 3, 6]
interval(alist, 0, len(alist)-1)
print(alist)

# 结果是 ：  [2, 3, 5, 6, 7, 9]



    

---恢复内容结束---