#数组里面找最大值和最小值
“”"
假设下标为min=0的元素最小，从下标1开始向后遍历，若遇到更小的元素，则更改min的值。遍历结束后，数组中下标为min的元素即为数组中最小的元素。
“”"
arr = [2,354,4,2,57,65,433]
amax = arr[0]
amin = arr[0]
for i in arr:
if amax<i:
amax = i
if amin>i:
amin = i
print(amin)
print(amax)
“”"
某智能化矿山实习张某生使用C#编码实现了运输卡车数据信息从云端到本地的自动同步，其方法和步骤如下：1、从云端车辆信息表中查询所有车辆信息；2、将本地车辆信息表中的所有数据删除；
3、将查询到的云端数据全部插入本地车辆信息表。每间隔2分钟，执行一次上述3个步骤，程序运行稳定，得到了领导和同事们的一致认可和好评。请论述此方法优缺点，是否有优化空间？
“”"
“”"
优点
- 数据一致性：通过定期从云端获取最新的车辆信息并完全覆盖本地数据，确保了本地数据与云端数据的一致性。无论云端数据如何变化，本地总能在固定时间间隔后获取到最新版本。
- 实现简单：整个同步流程逻辑清晰，操作步骤明确，易于理解和实现。从查询云端数据、删除本地数据到插入新数据，每个步骤都相对独立且简单，对于开发人员来说，编码和维护成本较低。
- 稳定性高：程序运行稳定，能够满足矿山运输卡车数据信息同步的基本需求，这在实际生产环境中是非常重要的，确保了数据的可靠传输和使用。
缺点
- 数据冗余与性能问题：每次同步都删除本地所有数据再重新插入，即使大部分数据并没有发生变化，这会造成大量不必要的数据操作。特别是当数据量较大时，删除和插入操作会带来较高的数据库I/O开销，影响系统性能，也可能导致网络带宽的浪费。
- 数据丢失风险：在删除本地数据和插入云端数据这两个步骤之间，如果出现程序异常、网络故障或数据库故障等问题，可能会导致本地数据已删除但新数据未成功插入，从而造成数据丢失。
- 缺乏灵活性：固定每2分钟同步一次，无法根据实际数据变化情况进行动态调整。如果云端数据很少发生变化，频繁同步会浪费资源；而如果云端数据变化频繁，2分钟的间隔可能又无法及时反映最新数据。
优化空间
- 增量同步：记录每次同步后云端数据的变化（例如通过时间戳、版本号或者数据库日志等方式），下次同步时只获取变化的数据，并在本地进行相应的更新、插入或删除操作，而不是全量删除和插入，这样可以大大减少数据操作量，提高同步效率。
- 事务处理：将删除本地数据和插入云端数据这两个操作放在一个数据库事务中执行。如果在操作过程中出现异常，事务可以回滚，保证本地数据的完整性，避免数据丢失。
- 动态同步策略：根据云端数据的变化频率动态调整同步间隔。例如，可以通过监控云端数据的变化情况，当变化频繁时缩短同步间隔，当变化较少时延长同步间隔。还可以提供手动触发同步的功能，以便在特殊情况下及时获取最新数据。
- 错误处理与日志记录：增强程序的错误处理机制，在同步过程中出现错误时，能够及时捕获并进行相应处理，如重试、报警等。同时，记录详细的同步日志，方便排查问题和监控同步过程。
“”"
import random
#生成-1~20的随机数
a = random.randint(-1, 20)
print(a)
“”"
二、已知r()函数可随机生成[0,1]之间的随机数字，请问如何根据r()函数随机生成[5,15]的随机数字？（10分）
算法思想：r()函数可生成[0,1]之间随机数字，则10r()可生成[0,10]之间的随机数字，10r()+5即可生成[5,15]之间的随机数字
def solution():
return 10*r()+5
“”"
#一筐鸡蛋，一个一个拿，几个几个拿，什么时候刚好拿完
for num in range(1, 10000):
flag = True
for i in range(1, 11):
if num % i!= 0:
flag = False
break
if flag:
print(f"符合条件的鸡蛋数量是：{num}")
“”"
一筐鸡蛋，1个1个拿刚好拿完，2个2个拿还剩1个，3个3个拿刚好拿完，4个4个拿还剩1个，5个5个拿还剩1个，
6个6个拿还剩3个，7个7个拿刚好拿完，8个8个拿还剩1个，9个9个拿刚好拿完，
请问这筐鸡蛋共多少个？写出算法思想并借助Python、Java、C#或C++语言实现
“”"
def find_egg_count():
num = 63 # 从63开始，因为是7和9的最小公倍数
while True:
if (num % 2 == 1 and num % 4 == 1 and num % 5 == 1 and num % 6 == 3 and num % 8 == 1):
return num
num += 63
print(find_egg_count())
#在python中用大数据的方法求解圆周率
“”"
蒙特卡罗方法的原理：
蒙特卡罗方法是一种基于随机采样的统计模拟方法，可用于解决许多数学问题，包括计算圆周率。其核心思想是通过大量的随机试验，根据随机事件发生的频率来估计某个未知量。
在计算圆周率中的应用：
考虑一个单位正方形（边长为 1），其四个顶点坐标为 (0,0)、(0,1)、(1,0) 和 (1,1)，在这个正方形内画一个单位圆（半径为 1，圆心在原点），根据圆的方程 x² + y² = 1。
对于单位正方形内的任意一点 (x,y)，可以通过 x² + y² 的值来判断该点是否在单位圆内：
如果 x² + y² ≤ 1，则该点在单位圆内；
如果 x² + y² > 1，则该点在单位圆外。
“”"
模拟的总点数
total_points = 1000000
落在圆内的点数
points_inside_circle = 0
for _ in range(total_points):
x = random.uniform(0, 1)
y = random.uniform(0, 1)
# 判断点是否在单位圆内（单位圆半径为1，圆心在原点，根据圆的方程判断）
if x ** 2 + y ** 2 <= 1:
points_inside_circle += 1
根据几何概率关系，计算圆周率的近似值
pi_approx = 4 * points_inside_circle / total_points
print(“近似圆周率为:”, pi_approx)
#p np npc
“”"
P问题：
P 问题是指可以在多项式时间内使用确定性算法求解的一类问题。这里的多项式时间是指算法的运行时间可以表示为输入规模n的多项式函数，通常表示为O(N)
对于 P 问题，我们可以高效地找到问题的解，其算法的时间复杂度随着输入规模的增长而增长的速度相对较慢，因此在实际应用中可以处理较大规模的输入。
举例：最短路径问题（例如 Dijkstra 算法）,排序问题（如快速排序）：给定一系列数字，将它们按顺序排列。
np:NP问题是指可以在多项式时间内验证一个解是否正确的问题。
也就是说，对于 NP 问题，给定一个可能的解，我们可以在多项式时间内检查这个解是否满足问题的条件，但找到这个解可能需要非多项式的时间。
NP 问题包含了许多实际中难以求解但易于验证的问题，其求解可能需要搜索大量的可能性空间。
举例：
旅行商问题（TSP）：给定一个城市集合和每对城市之间的距离，一个旅行商需要访问每个城市恰好一次并回到起始城市，找到一条最短的巡回路线。
NPC 问题是 NP 问题的一个子集，满足以下两个条件：
它是一个 NP 问题。
任何一个 NP 问题都可以在多项式时间内归约到该问题。归约意味着可以将一个 NP 问题的实例转换为 NPC 问题的实例，使得求解 NPC 问题的实例等价于求解原 NP 问题的实例。
举例：
布尔可满足性问题（SAT）：
问题描述：给定一个布尔公式（由变量、逻辑与、逻辑或、逻辑非组成），是否存在一种变量的赋值，使得该公式为真
“”"
#熟悉的算法
“”"
遗传算法思想：
MFO算法是一种基于自然界中飞蛾围绕火焰飞行行为的启发式优化算法，主要用于解决各种优化问题，如函数优化、组合优化等。
算法步骤如下：
1）待求变量初始化，在搜索空间中随机生成飞蛾位置，并评估每只飞蛾对应的适应度值。
2）将飞蛾空间位置以适应度值递增的顺序排序后赋值给火焰，作为第一代中火焰的空间位置。
3）通过自适应机制减少火焰的数量
4）通过螺旋飞行公式更新当前代飞蛾的位置。
5）将更新后的飞蛾位置与火焰位置的适应度值重新排序，选取适应度值更优的空间位置更新为下一代火焰的位置
6）输出并显示结果，程序结束
遗传算法应用领域：
1.函数优化：连续函数优化、多目标函数优化，工业过程优化等。
2.工程设计：结构设计优化、电路设计优化等。
3.机器学习：神经网络训练、特征选择等。
4.图像处理：图像分割、图像压缩等。
5.信号处理：滤波器设计、信号参数估计等。
“”"
import numpy as np
import random
import copy
import math
def initialization(pop, ub, lb, dim):
‘’’ 种群初始化函数’‘’
‘’’
pop:为种群数量 dim:每个个体的维度 ub:每个维度的变量上边界，维度为[dim,1]
lb:为每个维度的变量下边界，维度为[dim,1]
X:为输出的种群，维度[pop,dim]
‘’’
X = np.zeros([pop, dim]) # 声明空间
for i in range(pop):
for j in range(dim):
#生成[lb,ub]之间的随机数
X[i, j] = (ub[j] - lb[j]) * np.random.random() + lb[j]
return X
def BorderCheck(X, ub, lb, pop, dim):
‘’‘边界检查函数’‘’
‘’’
dim:为每个个体数据的维度大小
X:为输入数据，维度为[pop,dim]
ub:为个体数据上边界，维度为[dim,1]
lb:为个体数据下边界，维度为[dim,1]
pop:为种群数量
‘’’
for i in range(pop):
for j in range(dim):
if X[i, j] > ub[j]:
X[i, j] = ub[j]
elif X[i, j] < lb[j]:
X[i, j] = lb[j]
return X
def CaculateFitness(X, fun):
‘’‘计算种群的所有个体的适应度值’‘’
pop = X.shape[0]
fitness = np.zeros([pop, 1])
for i in range(pop):
fitness[i] = fun(X[i, :])
return fitness
def SortFitness(Fit):
‘’‘适应度值排序’‘’
‘’’
输入为适应度值
输出为排序后的适应度值，和索引
‘’’
fitness = np.sort(Fit, axis=0)
index = np.argsort(Fit, axis=0)
return fitness, index
def SortPosition(X, index):
‘’‘根据适应度值对位置进行排序’‘’
Xnew = np.zeros(X.shape)
for i in range(X.shape[0]):
Xnew[i, :] = X[index[i], :]
return Xnew
def MFO(pop, dim, lb, ub, MaxIter, fun):
‘’‘飞蛾扑火优化算法’‘’
‘’’
输入：
pop:为种群数量
dim:每个个体的维度
ub:为个体上边界信息，维度为[1,dim]
lb:为个体下边界信息，维度为[1,dim]
fun:为适应度函数接口
MaxIter:为最大迭代次数
输出：
GbestScore:最优解对应的适应度值
GbestPositon:最优解
Curve:迭代曲线
‘’’
r = 2; # 参数
X = initialization(pop, ub, lb, dim) # 初始化种群
fitness = CaculateFitness(X, fun) # 计算适应度值
fitnessS, sortIndex = SortFitness(fitness) # 对适应度值排序
Xs = SortPosition(X, sortIndex) # 种群排序后，初始化火焰位置
GbestScore = copy.copy(fitnessS[0]) # 最优适应度值
GbestPositon = np.zeros([1, dim])
GbestPositon[0, :] = copy.copy(Xs[0, :]) # 最优解
for iter in range(MaxIter):
print(“第” + str(iter) + “次迭代”)
Flame_no = round(pop - iter * ((pop - 1) / MaxIter)) # 火焰数量更新
r = -1 + iter * (-1) / MaxIter # r 线性从-1降到-2
# 飞蛾扑火行为
for i in range(pop):
for j in range(dim):
ccc = i if i<=Flame_no else Flame_no
distance_to_flame = np.abs(Xs[ccc, j] - X[i, j]) # 飞蛾与火焰的距离
b = 1
t = (r - 1) * random.random() + 1
# 螺旋飞行
X[i, j] = distance_to_flame * np.exp(b * t) * np.cos(t * 2 * np.pi) + Xs[ccc, j]
X = BorderCheck(X, ub, lb, pop, dim) # 边界检测fitness = CaculateFitness(X, fun) # 计算适应度值fitnessS, sortIndex = SortFitness(fitness) # 对适应度值排序Xs = SortPosition(X, sortIndex) # 种群排序，作为下一代火焰的位置if fitnessS[0] <= GbestScore: # 更新全局最优GbestScore = copy.copy(fitnessS[0])GbestPositon[0, :] = copy.copy(Xs[0, :])
return GbestScore, GbestPositon
def objf(x):
return math.sin(2x[0]) ** 2 + math.cos(2x[1]) ** 2
设置参数
pop = 30 # 种群数量
MaxIter = 200 # 最大迭代次数
dim = 2 # 维度
lb = [-5, -5] # 下边界
ub = [5, 5] # 上边界
选择适应度函数
原始算法
GbestScore, GbestPositon = MFO(pop, dim, lb, ub, MaxIter, objf)
print(‘------原始算法结果--------------’)
print(‘最优适应度值：’, GbestScore)
print(‘最优解：’, GbestPositon)
#冒泡排序
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
示例
arr = [64, 34, 25, 12, 22, 11, 90]
print(bubble_sort(arr))