python算法

欢迎学习python

基础print、奇数、闰年、平方根、随机数、摄氏温度、月份天数、

a = 12.345
b = 12.345
a1 = round(a, 2)
print(a1)
print("%.2f" % b)
# 12.35
print('交换后 x 的值为: %d' %x)
print('交换后 y 的值为:', y)
print('交换后 x 的值为: {}'.format(x))
print(str + '你好')
print('hello\nrunoob')  # 换行
# hello
# runoob

a = '123456'
print("翻转字符串", a[::-1])

# 中止程序
for i in "python":
    if i =="y":
        break 
print("当前字母：", i)
# p

# 最大数
print(max(1, 2))
print(max('a', 'b'))
print("80, 100, 1000 最大值为: ", max(80, 100, 1000))
print("-20, 100, 400最大值为: ", max(-20, 100, 400))
print("-80, -20, -10最大值为: ", max(-80, -20, -10))
print("0, 100, -400最大值为:", max(0, 100, -400))
i = 2
num = 4
print(i,"乘于",num//i,"是",num)
print(num//i)

# Python 判断奇数偶数
# 如果是偶数除于 2 余数为 0
# 如果余数为 1 则为奇数
num = 3
if (num % 2) == 0:
   print("{0} 是偶数".format(num))
else:
   print("{0} 是奇数".format(num))

# 判断是否闰年
year = int(input("输入一个年份: "))
if (year % 4) == 0:
   if (year % 100) == 0:
       if (year % 400) == 0:
           print("{0} 是闰年".format(year)) # 整百年能被400整除的是闰年
       else:
           print("{0} 不是闰年".format(year))
   else:
       print("{0} 是闰年".format(year)) # 非整百年能被4整除的为闰年
else:
   print("{0} 不是闰年".format(year))

# 平方根
num = float(input('请输入一个数字： '))
num_sqrt = num ** 0.5
print(' %0.3f 的平方根为 %0.3f'%(num ,num_sqrt))
# 4.000 的平方根为 2.000

# 随机生成数
# 生成 0 ~ 9 之间的随机数
# 导入 random(随机数) 模块 
import random 
print(random.randint(0,9))

# 用户输入摄氏温度
# 接收用户输入
celsius = float(input('输入摄氏温度: '))
# 计算华氏温度
fahrenheit = (celsius * 1.8) + 32
print('%0.1f 摄氏温度转为华氏温度为 %0.1f ' %(celsius,fahrenheit))

# 计算每个月得天数
# 输出的是一个元组，第一个元素是所查月份的第一天对应的是星期几（0-6）
# 第二个元素是这个月的天数。
import calendar
monthRange = calendar.monthrange(2016,9)
print(monthRange) # (3,30) monthRange[1]

# 计算某年所有得天数
import calendar
sum = 0
year = 2022
for i in range(1, 13):
    print(i)    # 1 2 3 4 5 6 7 8 9 10 11 12
    monthRange = calendar.monthrange(year,i)
    sum += monthRange[1]
print(sum)
# 365

# 判断是否是质数
# 用户输入数字
num = 5
 
# 质数大于 1
if num > 1:
   # 查看因子
   for i in range(2,num):
       if (num % i) == 0:
           print(num,"不是质数")
           print(i,"乘于",num//i,"是",num)
           break
   else:
       print(num,"是质数")
       
# 如果输入的数字小于或等于 1，不是质数
else:
   print(num,"不是质数")

# 合并字符串
def Merge(dict1, dict2): 
    return(dict2.update(dict1)) 

# 两个字典
dict1 = {'a': 10, 'b': 8} 
dict2 = {'d': 6, 'c': 4} 
# 返回  None 
print(Merge(dict1, dict2)) 
# dict2 合并了 dict1
print(dict2)  # {'d': 6, 'c': 4, 'a': 10, 'b': 8}
print(dict1)  # {'a': 10, 'b': 8}

二分查找

def binarySearch (arr, l, r, x):
    # 基本判断
    if r >= l:
        mid = int(l + (r - l)/2)
        # 元素整好的中间位置
        if arr[mid] == x:
            return mid
        # 元素小于中间位置的元素，只需要再比较左边的元素
        elif arr[mid] > x:
            return binarySearch(arr, l, mid-1, x)
        # 元素大于中间位置的元素，只需要再比较右边的元素
        else:
            return binarySearch(arr, mid+1, r, x)
    else:
        # 不存在
        return -1
# 测试数组

arr = [ 2, 3, 4, 10, 40 ]
x = 10
# 函数调用
result = binarySearch(arr, 0, len(arr)-1, x)
if result != -1:
    print ("元素在数组中的索引为 %d" % result )
else:
    print ("元素不在数组中")

是否是回文

a = '1234567'
b = a[::-1]
l = len(a)
flag = 'yes'
print("Hello,World", a[::-1])
for j in range(0, l):
    if a[j] == b[j]:
        flag = 'yes'
    else:
       flag = 'no'
       break
print("", flag)

最大公约数

def hcf(x, y):
   # 获取最小值
   if x > y:
       smaller = y
   else:
       smaller = x
 
   for i in range(1,smaller + 1):
       if((x % i == 0) and (y % i == 0)):
           hcf = i
   return hcf
num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))
print( num1,"和", num2,"的最大公约数为", hcf(num1, num2))

循坏下标

for i in range(len(A)):  # 012345...len(A)
for i in range(0, len(A)):  # 012345...len(A)
for i in range(1, len(A)):  # 12345...len(A)

冒泡排序

def bubbleSort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        # Last i elements are already in place
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
 
arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(arr)
print ("排序后的数组:")
for i in range(len(arr)):
    print ("%d" %arr[i]),

插入排序

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

def insertionSort(arr): 
    for i in range(1, len(arr)): 
        key = arr[i] 
        j = i-1
        while j >=0 and key < arr[j]:
            arr[j+1] = arr[j] 
            j -= 1
        arr[j+1] = key 
arr = [12, 11, 13, 5, 6] 
insertionSort(arr)
print ("排序后的数组:") 
for i in range(len(arr)): 
    print ("%d" %arr[i])

选择排序

它的工作原理如下:
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

A = [64, 25, 12, 22, 11] 
  
for i in range(len(A)): 
    min_idx = i 
    for j in range(i+1, len(A)): 
        if A[min_idx] > A[j]: 
            min_idx = j 
    A[i], A[min_idx] = A[min_idx], A[i] 
  
print ("排序后的数组：") 
for i in range(len(A)): 
    print("%d" %A[i])

快速排序

策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列

1. 挑选基准值：从数列中挑出一个元素，称为"基准"（pivot）;
2. 分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成;
3. 递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。

递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。
选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。

def partition(arr,low,high): 
    i = ( low-1 )         # 最小元素索引
    pivot = arr[high] 

    for j in range(low , high): 
        # 当前元素小于或等于 pivot 
        if arr[j] <= pivot: 
           i = i+1 
           arr[i],arr[j] = arr[j],arr[i] 
    arr[i+1],arr[high] = arr[high],arr[i+1] 
    return ( i+1 )

# arr[] --> 排序数组
# low  --> 起始索引
# high  --> 结束索引
  
# 快速排序函数
def quickSort(arr,low,high): 
    if low < high: 
        pi = partition(arr,low,high) 
        quickSort(arr, low, pi-1) 
        quickSort(arr, pi+1, high) 
        
arr = [10, 7, 8, 9, 1, 5] 
n = len(arr) 
quickSort(arr,0,n-1) 

print ("排序后的数组:") 
for i in range(n): 
    print ("%d" %arr[i]),

归并排序

采用分治法
1.分割：递归地把当前序列平均分割成两半。
2.集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

def merge(arr, l, m, r): 
    n1 = m - l + 1
    n2 = r- m 
  
    # 创建临时数组
    L = [0] * (n1)
    R = [0] * (n2)
  
    # 拷贝数据到临时数组 arrays L[] 和 R[] 
    for i in range(0 , n1): 
        L[i] = arr[l + i] 
  
    for j in range(0 , n2): 
        R[j] = arr[m + 1 + j] 
  
    # 归并临时数组到 arr[l..r] 
    i = 0     # 初始化第一个子数组的索引
    j = 0     # 初始化第二个子数组的索引
    k = l     # 初始归并子数组的索引
  
    while i < n1 and j < n2 : 
        if L[i] <= R[j]: 
            arr[k] = L[i] 
            i += 1
        else: 
            arr[k] = R[j] 
            j += 1
        k += 1
    # 拷贝 L[] 的保留元素
    while i < n1: 
        arr[k] = L[i] 
        i += 1
        k += 1
    # 拷贝 R[] 的保留元素
    while j < n2: 
        arr[k] = R[j] 
        j += 1
        k += 1
def mergeSort(arr,l,r): 
    if l < r:  
        m = int((l+(r-1))/2)
        mergeSort(arr, l, m) 
        mergeSort(arr, m+1, r) 
        merge(arr, l, m, r) 
 
arr = [12, 11, 13, 5, 6, 7] 
n = len(arr) 
print ("给定的数组") 
for i in range(n): 
    print ("%d" %arr[i]), 
  
mergeSort(arr,0,n-1) 
print ("\n\n排序后的数组") 
for i in range(n): 
    print ("%d" %arr[i]),

指定范围内的素数

# 输出指定范围内的素数
 
# take input from the user
lower = int(input("输入区间最小值: "))
upper = int(input("输入区间最大值: "))
for num in range(lower,upper + 1):
    # 素数大于 1
    if num > 1:
        for i in range(2,num):
            if (num % i) == 0:
                break
        else:
            print(num)