#七种基本算法：解析算法，枚举算法，递推算法，递归算法，排序算法，查找算法，分治算法
#解析算法
#1.根据定义计算组合数
import math
n, i = input("请输入整数n,i:").split(' ')
n = int(n)
i = int(i)
b = math.factorial(n) / (math.factorial(i) * math.factorial(n - i))
print(b)
#2.计算一元二次方程的根
def root(a , b , c):
if not isinstance(a, (int, float, complex)) or abs(a) < 1e-6:
print("error")
if not isinstance(b ,(int, float, complex)):
print("error")
if not isinstance(c, (int, float, complex)):
print("error")
d = b ** 2 - 4 * a * c
x1 = (-b + d ** 0.5) / (2 * a)
x2 = (-b - d ** 0.5) / (2 * a)
if isinstance(x1, complex): #complex为复数
x1 = round(x1.real, 3) + round(x1.imag, 3) * 1j #round(x,3)取三位有效数字
x2 = round(x2.real, 3) + round(x2.imag, 3) * 1j
return (x1, x2)
return (round(x1, 3), round(x2, 3))
a, b, c = input("请输入a,b,c:").split(' ')
a = int(a)
b = int(b)
c = int(c)
r = root(a, b, c)
if isinstance(r, tuple):
print('x1 = {0[0]}\nx2 = {0[1]}'.format(r))
#3.并联电阻的计算(1/R = 1/R1 + 1/R2 + 1/R3 + ... + 1/Rn)
def compute(R_set):
#R_middle = sum([1/r for r in R_set]) 产生列表的两种方法：①列表推导式 ②map + lambda
R_middle = sum(map(lambda x:1/x, R_set))
return 1/R_middle
R_end = round(compute([50, 30,20]), 3)
print(R_end)
#4.根据公式计算圆的面积
import math
def compute_area(r):
return math.pi * r *r
print(round(compute_area(3), 3))
#5.已知三角形的两个边长和夹角角度，计算第三条边长(c**2=a**2+b**2+2*a*b*cos(theta))
from math import cos, pi
def compute_line(a, b, theta):
c = theta / 180 * pi #把角度换为弧度
return (a**2 + b**2 + 2*a*b*cos(c))**0.5
print(compute_line(3, 4, 90))
#6.编写程序，执行后用户输入摄氏温度，由程序转为华氏温度并输出（F=1.8C+32）
def tempurature(C):
return 1.8 * C + 32
C = input("请输入华氏温度：")
C = float(C)
hC = tempurature(C)
print(hC)
#枚举算法
#7.输出由1,2,3,4这4个数字组成的每位上的数字都不相同的所有三位数。
org = [1, 2, 3, 4]
all_set = []
for i in org:
for j in org:
for k in org:
if i != j and i !=k and j != k:
set = str(i) + str(j) + str(k)
all_set.append(set) #列表添加元素
all_set = str(all_set).lstrip('[')
all_set = all_set.rstrip(']')
print(all_set)
#itertools提供一个排序函数permutations(),它可以用来返回从n个元素中任选i个元素组成的所有排序
from itertools import permutations
def demo(digits, num):
for item in permutations(digits, num):
print(int(''.join(map(str, item))),end=',')
demo([1,2,3,4], 3)
#8.编写函数，接收一个正偶数的参数，输出两个素数，并且这两个素数之和等于原来的正整数。
#如果存在多组符合条件的素数，则全部输出。
def isPrime(a):
num = 0
for i in range(2, a): #range：起始， 最终， 步长 [2,3,4,5,...,a-1]
if a%i == 0:
num += 1
if num == 0:
flag = 1
else:
flag = 0
return flag
def demo(a):
all_set = []
for i in range(2,a):
if isPrime(i) and isPrime(a-i) and (a-i)!=1:
exam = [i,a-i]
all_set.append(exam)
return all_set
print(demo(30))
#范例
def IsPrime(P):
if P == 2: #2是素数，直接返回
return True
if P % 2 == 0: #除2以外的其他偶数都不是素数，直接返回
return False
for i in range(3, int(P**0.5)+1, 2): #判断3~P的平方根之内有没有P的因数
if P % i == 0:
return False #如果有因数，则P不是素数
return True #如果没有因数，则P是素数
def demo(n):
if isinstance(n, int) and n>0 and n%2 == 0: #重要
for i in range(2, n//2+1):
if IsPrime(i) and IsPrime(n-i):
print(i,'+',n-i,'=',n)
demo(30)
#编写程序，输出所有的3位水仙花数 （153=1**3+5**3+3**3）
def showflow():
for i in range(100,1000):
if i == (int(str(i)[0])**3 + int(str(i)[1])**3 + int(str(i)[2])**3):
print(i)
showflow()
#范例
for i in range(100, 1000):
bai, shi, ge = map(int, str(i)) #map的用法
if ge**3 + shi **3 + bai ** 3 == i:
print(i)
#编写程序，寻找指定位数的黑洞数
from itertools import permutations
def searchnum(n):
for i in range(10**(n-1),10**n):
num_list = []
[num_list.append(j) for j in str(i)]
all_list = []
for item in permutations(num_list, n):
num_ = int(''.join(map(str, item)))
all_list.append(num_)
max_num = max(all_list)
min_num = min(all_list)
if (max_num - min_num) == i:
print(i)
print('&&&')
searchnum(4)
#范例
def main(n):
start = 10**(n-1)
end = 10**n
for i in range(start,end):
big = ''.join(sorted(str(i), reverse=True))
little = ''.join(reversed(big))
big, little = map(int, (big, little))
if big - little == i:
print(i)
n=4
main(4)
#啤酒问题。一位酒商共有5桶葡萄酒和1桶啤酒，6个桶的容量分别为30升，32升，36升，38升，40升和62升，并且只卖整桶酒，不零卖。第一位
#顾客买走了2整桶葡萄酒，第二位顾客买走的葡萄酒是第一位顾客的2倍。那么，本来有多少升啤酒呢？
#解析第一位顾客买了2整桶，第二位顾客买了3整桶，剩下的1桶就是啤酒的容量，且葡萄酒的总数能被3整除
buckets = {30, 32, 36, 38, 40, 62}
total = sum(buckets)
for item in buckets:
if (total - item) % 3 == 0:
print(item)
break
#递推算法
#使用递推法计算阶乘 n!=1*2*3*4*...*(n-1)*n
def fac(n):
result = 1
for i in range(1, n+1):
result = result * i
return result
print(fac(6))
#使用递推法计算组合数
def cni(n,i):
return fac(n)/(fac(i)*fac(n-i))
print(cni(6,2))
#使用递推算法求解爬楼梯问题。假设一段楼梯共15个台阶，小明一步最多上3个台阶，那么小明上这段楼梯共有多少种方法？
#f(n)=f(n-1)+f(n-2)+f(n-3),其中n=15,14,13,...,5,4
def climbStairsl(n):
#递推法
a = 1
b = 2
c = 4
for i in range(n-3):
c, b, a = a+b+c, c, b
return c
print(climbStairsl(15))
#递归算法
#使用递归算法求解爬楼梯问题。假设一段楼梯共15个台阶，小明一步最多上3个台阶，那么小明上这段楼梯共有多少种方法？
def climbStairs2(n):
first3 = {1:1, 2:2, 3:4}
if n in first3.keys():
return first3[n]
else:
return climbStairs2(n-1) + climbStairs2(n-2) + climbStairs2(n-3)
print(climbStairs2(15))
#使用递归法计算整数的阶乘
def fac(n):
if n == 1:
return 1
else:
return n * fac(n-1)
print(fac(6))
#使用递归法计算组合数
def cni(n,i):
if n==i or i==0:
return 1
return cni(n-1,i) + cni(n-1,i-1)
print(cni(7,5))
#使用递归法计算斐波那契数列
def fib(n):
if n == 1 or n == 2:
return 1
else:
return fib(n-1)+fib(n-2)
print(fib(8))
#排序算法
#编写程序，使用选择法对列表中的元素进行排序
def selectSort(lst, reverse=False):
if reverse == False:
for i in range(0,len(lst)):
for j in range(i+1,len(lst)):
if lst[j] < lst[i]:
mid_num = lst[j]
lst[j] = lst[i]
lst[i] = mid_num
else:
for i in range(0,len(lst)):
for j in range(i+1,len(lst)):
if lst[j] > lst[i]:
mid_num = lst[j]
lst[j] = lst[i]
lst[i] = mid_num
return lst
print(selectSort([1,3,5,2,4,9],reverse=True))
#范例
def selectsort(lst, reverse=False):
length = len(lst)
for i in range(0, length):
#假设剩余元素中第一个最小或最大
m = i
#扫描剩余元素
for j in range(i+1, length):
#如果有更小或更大，就记录下它的位置
exp = 'lst[j] < lst[m]'
if reverse:
exp = 'lst[j]>lst[m]'
#内置函数eval()用来对字符串进行求值
if eval(exp):
m=j
#如果发现更小或更大的，就交换值
if m != i:
lst[i], lst[m] = lst[m], lst[i]
print(lst)
lst = [1,3,5,2,4,9]
print(lst, '\n')
selectsort(lst)
#查找算法案例
#编写程序，使用顺序查找法判断列表中是否存在给定的元素，如果存在就返回它在列表中的位置（索引），否则返回False
def find_index(lst, item):
for id, val in enumerate(lst):
if val == item:
return id
return False
print(find_index([1,2,3],3))