#全国大学生数学建模竞赛
#MWORKS体验官
a=[8,5,6,9,4,5,6,1,5,-1]
min_value=None
loop_count=0
for num in a:
loop_count += 1
if min_value==None or num<min_value:
min_value=num
print("矩阵a中的最小元素为：",min_value)
print("循环次数为：",loop_count)

你好那个是积分是sin（x根号y）还是sinx*根号y

#全国大学生数学建模竞赛 #MWORKS体验官
第一题使用python编写，思路为：利用单层for循环进行遍历，每次遍历跟新最小值min_val，同时对count进行累加，最后输出结果
代码如下
a=[8,5,6,9,4,5,6,1,5,-1]
count=0
min_val=a[0]
for i in range(1,len(a)):
count+=1
if min_val>a[i]:
min_val=a[i]

print(f"最小的元素是{min_val}“)
print(f"循环次数是{count}”)

#全国大学生数学建模竞赛 #MWORKS体验官 打卡第二天
打卡第二天，第二题

第一问，让求二重积分和三重积分，我使用scipy包里面的integrate函数，其中，dblquad用于求二重积分，tplquad用于求三重积分。dblquad的用法为，
dblquad(被积函数, 外层积分下限, 外层积分上限, 内层积分下限函数, 内层积分上限函数)。tplquad的用法类似。这样可以求出第一问的两道积分。

第二问，让求事件A发生的概率P，根据概率论知识，本题可以转化为求积分，我们可以先算出X,Y的联合概率密度，为1/4，然后再求积分，就能求出事件A的概率P。

第一问，（1）的结果为1.8668，（2）的结果为8.3050
第二问，P（A）为0.7854

python代码如下

from scipy.integrate import dblquad, tplquad
import numpy as np

# 第一问（1）
# 定义被积函数
def f1(x, y):
    return np.sin(x) * np.sqrt(y) + x

# 计算积分
result_1, _ = dblquad(f1, 0, 2, lambda y: 0, lambda y: 1)
print(f"积分(1)的结果为:{result_1:.4f}" )

# 第一问（2）
# 定义被积函数
def f2(x, y, z):
    return y * np.sin(x) + z * np.cos(x)

# 计算积分
result_2, _ = tplquad(f2, 0, np.pi, lambda z: 0, lambda z: 1, lambda z,y: -1, lambda z,y: 1)
print(f"积分(2)的结果为:{result_2:.4f}")

# 第2问
# 被积函数为x^2+y^2<=4
def f(x,y):
    return 1/4

def y_upper(x):
    return np.minimum(2, np.sqrt(4 - x**2))

result_3,_=dblquad(f,0,2,lambda x:0,lambda x:y_upper(x))
print(f"第2题的结果:{result_3:.4f}")

#全国大学生数学建模竞赛
#MWORKS体验官
打卡第一天，第一题

#全国大学生数学建模竞赛 #MWORKS体验官 打卡第三天
题目

思路
第一题
法一，使用LU分解。LU分解是将一个矩阵A分解为一个下三角矩阵L和一个上三角矩阵U的乘积。在Python中，可以使用Scipy库中的scipy.linalg.lu函数来进行LU分解。只需将X的系数和常数项传入函数即可求解行列式。见后面代码
法二，使用矩阵求逆。行列式矩阵求逆后，等号左边只剩X，后面即为X的对应解。见后面代码

第二题
在约束条件下的线性规划问题。首先将约束条件用算式表达出来，设x为每天生产的产品A的单位数，y为每天生产的产品B的单位数。总重量不超过1000，即3x+2y<=1000，且数量应该大于等于0，即x>=0,y>=0。利润最大，即40x+30y最大。我使用的是scipy.optimize库里面的linprog函数，该函数是求最小值，所以需要先对利润加负号。见后面代码

结果
第一题
法一(LU分解):x1 = 0.33, x2 = -1.67, x3 = 1.33
法二(矩阵求逆):x1 = 0.33, x2 = -1.67, x3 = 1.33
第二题
最优解:x = 0, y = 500
最大利润：15000 元

import numpy as np
# 第一题
A=np.array([
    [1,2,3],
    [-1,3,7],
    [9,0,3]
])

b=np.array([1,4,7])

# 法一(LU分解)
x1=np.linalg.solve(A,b)
print(f"法一(LU分解):x1 = {x1[0]:.2f}, x2 = {x1[1]:.2f}, x3 = {x1[2]:.2f}")

# 法二(矩阵求逆)
A_inv=np.linalg.inv(A)
x2=A_inv @ b
print(f"法二(矩阵求逆):x1 = {x2[0]:.2f}, x2 = {x2[1]:.2f}, x3 = {x2[2]:.2f}")


# 第二题
# 3x+2y<=1000，x>=0,y>=0
# 求40x+30y最大值，以及此时的x和y
from scipy.optimize import linprog

# 函数的系数
c=[-40,-30]

# 定义约束条件
# 3x+2y<=1000
A_ub = [[3,2]]
b_ub = [1000]

# x>=0,y>=0
bounds = [(0,None),(0,None)]

# 线性规划求解
result = linprog(c,A_ub=A_ub,b_ub=b_ub,bounds=bounds,method='highs')

if result.success:
    x = result.x[0]
    y = result.x[1]
    max_benefit = -result.fun
    print(f"第二题最优解:x = {x:.0f}, y = {y:.0f}")
    print(f"最大利润：{max_benefit:.0f} 元")

#全国大学生数学建模竞赛 #MWORKS体验官 打卡第四天

题目

思路
第一题：先生成20个原始点数据，然后生成100个插值点，计算他们的sin值，并把他们连起来，最后画出插值之后的图。
第二题：定义了一个find_min_number函数，用于查找满足题目条件的最小数。根据题目条件，应该从7开始循环，所有定义num起始为7，然后计算各位数字之和是否大于20，若大于20，则返回该数。若不大于20，则让num加7，进入下一次循环。因为是从7开始往大的数循环的，所以找到满足的数，即是最小的正整数。

答案
第一题如图所示

第二题，最小正整数为399

代码

# 第一题
import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d

# 生成[0,2pi]的20个数据
x = np.linspace(0, 2 * np.pi, 20)
# 计算20个值对应的sin值
y = np.sin(x)
# 对sim函数进行线性一维插值
f = interp1d(x, y, kind='linear')
# 生成100个新的插值点
x_new = np.linspace(0, 2 * np.pi, 100)
# 计算新插值点的sin值
y_new = f(x_new)
# 绘图，标记为圆形
plt.plot(x, y, 'o', label='原始数据')
# 用实线连接所有点
plt.plot(x_new, y_new, '-', label='线性插值')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('线性插值图')
plt.legend()
plt.show()

# 第二题
def find_min_number():
    # 从7开始循环
    num = 7
    while True:
        # 判断能否被7整除
        if num % 7 == 0:
            # 计算各位数字之和
            digit_sum = sum(int(digit) for digit in str(num))
            # 判断是否大于20
            if digit_sum > 20:
                return num
        num += 7

result = find_min_number()
print("满足条件的最小正整数为:", result)

#全国大学生数学建模竞赛 #MWORKS体验官 打卡第六天
题目

思路
第一题：使用scipy.optimize.root函数求解方程的根。首先，用equations定义了方程组的表达式，然后初始化猜测值[2, 2]，最后调用root函数求解方程组，并打印出结果
第二题：使用scipy.integrate.nquad函数计算多重积分。首先，定义了密度函数，上、下、侧边界表达式，然后把直角坐标系转化为柱坐标（由雅可比行列式可知，此时被积函数要多一个r），最后使用nquad函数计算三重积分，并打印最终结果

结果
第一题：方程组在 (2,2) 附近的根为:x = 2.2143, y = 2.9032
第二题：零件的总质量为：251.4367 g

结果截图

代码

# 第一问
from scipy.optimize import root
import numpy as np

# 定义方程组
def equations(vars):
    x, y = vars
    eq1 = x**2 - y - 2
    eq2 = y**2 - 2 * x - 4
    return [eq1, eq2]

# 初始猜测值
initial_guess = [2, 2]

# 求解方程组
result = root(equations, initial_guess)

x_sol, y_sol = result.x
print(f"方程组在 (2,2) 附近的根为:x = {x_sol:.4f}, y = {y_sol:.4f}")


# 第二问
from scipy.integrate import nquad
import numpy as np

# 定义密度函数
def density(x, y, z):
    return 2 + z

# 换成柱坐标，被积函数多一个r
def integrand(z, r, theta):
    return density(0, 0, z) * r

# 定义各变量的积分范围
def limits_theta():
    return [0, 2 * np.pi]

def limits_r(theta):
    return [0, 1]

def limits_z(theta, r):
    return [r, 4 - r**2]

# 计算三重积分
mass, _ = nquad(integrand, [limits_z, limits_r, limits_theta])

print(f"零件的总质量为：{mass:.4f} g")

#全国大学生数学建模竞赛
#MWORKS体验官
#打卡题目二
from scipy import integrate
import math
def f(x,y):
return math.sin(x)*math.sqrt(x)+x
double_result,double_error=integrate.dblquad(f,0,2,lambda x: 0,lambda x:1)
print("第1题：（1）二重积分结果：",double_result)

def g(x,y,z):
return ymath.sin(x)+zmath.cos(x)
triple_result,triple_error=integrate.tplquad(g,0,math.pi,lambda x:0,lambda x:1,lambda x,y:-1,lambda x,y:1)
print("第1题：（2）三重积分结果：",triple_result)

#用面积的比例计算概率
def fun(x,y):
return 1
sector_result,sector_error=integrate.dblquad(fun,0,2,lambda x:0,lambda x:math.sqrt(4-x**2))
rectangle_result,rectangle_error=integrate.dblquad(fun,0,2,lambda x:0,lambda x:2)
print("第2题：P(A)=",sector_result/rectangle_result)

#全国大学生数学建模竞赛
#MWORKS体验官
#打卡题目三
#1.方法一
print("第1题：方法一:")
import numpy as np
A=np.array([[1,2,3],[-1,3,7],[9,0,3]])
b=np.array([1,4,7])
x=np.linalg.solve(A,b)
print(f"x1={x[0]},x2={x[1]},x3={x[2]}")

#1.方法二
print("第1题：方法二")
import numpy as np
from scipy.linalg import lstsq
A=np.array([[1,2,3],[-1,3,7],[9,0,3]])
b=np.array([1,4,7])
x,residuals,rank,singular_values=lstsq(A,b)
print(f"x1={x[0]},x2={x[1]},x3={x[2]}")

print("第2题：")
from scipy.optimize import linprog
c=[-40,-30] #转换为最小化
A=[[3,2]]
b=1000
#变量非负约束
x_bounds=(0,None)
y_bounds=(0,None)
bounds=[x_bounds,y_bounds]
result=linprog(c,A_ub=A,b_ub=b,bounds=bounds,method='highs')
x_opt=int(round(result.x[0]))
y_opt=int(round(result.x[1]))
max_profit=-result.fun
print(f"产品A最优生产单位：{x_opt}")
print(f"产品B最优生产单位：{y_opt}")
print(f"最大利润：{max_profit}")