编程交流——第4期

文本处理和动态规划

任务一、

要求：

（1）计算2的13次方并将数字结果反转（如‘4321’→‘1234’）

（2）用步骤（1）所得结果的最后两位生成新的数字（如‘1123’→‘23’），计算其完全平方数的最少数量（如12 = 4 + 4 + 4，值为3）

（3）依次计算21，22，23，…，212，用所得结果生成一个一维数组，并计算其方差

（4）生成一个txt文件，将步骤（3）所得数组和方差保存至txt文件中

任务二、

要求：

（1）读取文本数组中每个元素x进行映射，映射函数为y=x²+2，将所得结果覆写入原txt（如‘[1,2]’→‘[3,6]’）

（2）将新数组每个元素的值视为柱子的高度，底边长为1，紧密排列且无量纲，计算其在降雨之后最多能接多少雨水（两侧无边界）

示例：原始数组[0,1,0,2,1,0,1,3,2,1,2,1]计算雨水时，下图是其表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）

推荐代码格式（Python 版本）

import XXX

# 任务一

class Solution(object):

    def isScramble(self, s1, s2):

        """

        :type s1: str

        :type s2: str

        :rtype: bool

        """

class Solution(object):

    def numSquares(self, n):

        """

        :type n: int

        :rtype: int

        """

# 任务二

class Solution(object):

    def trap(self, height):

        """

        :type height: List[int]

        :rtype: int

        """

开发情况——任务一：

#开发人：dwk

import numpy as np

# 步骤（1）：计算2的13次方并将结果反转
result = str(2 ** 13)
reversed_result = result[::-1]
print("反转后的结果：", reversed_result)

# 步骤（2）：用步骤（1）的结果的最后两位生成新的数字，并计算完全平方数的最少数量
last_two_digits = int(reversed_result[-2:])
num_squares = 0

while last_two_digits > 0:
    largest_square = int(last_two_digits ** 0.5) ** 2
    num_squares += 1
    last_two_digits -= largest_square

print("完全平方数的最少数量：", num_squares)

# 步骤（3）：依次计算步骤（2）的结果，并生成一个一维数组
result_array = []
current_num = int(reversed_result)

while current_num > 0:
    last_two_digits = current_num % 100
    num_squares = 0

    while last_two_digits > 0:
        largest_square = int(last_two_digits ** 0.5) ** 2
        num_squares += 1
        last_two_digits -= largest_square

    result_array.append(num_squares)
    current_num //= 100

print("生成的一维数组：", result_array)

# 步骤（4）：生成一个txt文件，将步骤（3）的数组和方差保存至txt文件中
variance = np.var(result_array)

with open("result.txt", "w") as file:
    file.write("数组：\n")
    file.write(str(result_array))
    file.write("\n\n")
    file.write("方差：\n")
    file.write(str(variance))
    file.write("\n")

print("结果已保存至result.txt文件中。")

# 开发人：hyr
# 开发时间：2023/5/8
import math

# Part 1
num = str(2 ** 13)[::-1]  # 计算2的13次方并反转
print("Part 1:", num)

# Part 2
last_two_digits = int(num[:2])
squares = [i**2 for i in range(1, int(math.sqrt(last_two_digits))+1)]
dp = [float('inf') for _ in range(last_two_digits+1)]
dp[0] = 0
for i in range(1, last_two_digits+1):
    for square in squares:
        if i >= square:
            dp[i] = min(dp[i], dp[i-square] + 1)
print("Part 2:", dp[last_two_digits])

# Part 3
arr = [2 ** i for i in range(1, 13)]
mean = sum(arr) / len(arr)
variance = sum((x - mean) ** 2 for x in arr) / len(arr)
print("Part 3:", arr, variance)


# Part 4
with open('result.txt', 'w') as file:
    file.write(f"Array: {arr}\n")
    file.write(f"Variance: {variance}\n")

# -*-coding:utf-8 -*-
"""
作者：XJQ
时间：2023年05月18日
"""
import os
import numpy as np
class Solution1(object):
    # 定义构造方法
    def __init__(self,s1,s2):
        self.s1=s1
        self.s2=s2
    def  isScramble(self):
        num = str(self.s1** self.s2)[::-1]
        print(num)
        num = str(self.s1** self.s2)[::-1][-2:]
        num = int(num)
        cnt = 0
        while num > 0:
            cnt += 1
            num -= int(cnt ** 2)
        if num < 0:
            cnt -= 1
        print(cnt)
        num = str(self.s1 ** self.s2)[::-1][-2:]
x = Solution1(2,13)
x.isScramble()


class Solution2(object):
    def __init__(self,path):
        self.path=path
    def numSquares(self):
        arr = []
        for i in range(12):
            if i > 0:
                arr.append(2 ** i)
        variance = np.var(arr)
        print(arr)
        print("方差是%f"%(variance))
        filename = self.path
        if os.path.exists(filename):
            os.remove(filename)
        with open(filename, 'w') as f:
            f.write(' '.join(map(str, arr)) + '\n')
            f.write(str(variance))
            f.close()
x2=Solution2("result.txt")
x2.numSquares()

# 开发人：zk
# 步骤1
num1 = 2 ** 13   # 计算2的13次方
str_num1 = str(num1)   # 将数字转为字符串
reverse_num1 = str_num1[::-1]   # 反转字符串
print(reverse_num1)

# 步骤2
last_two_digits = int(reverse_num1[0:2])   # 取出最后两位数字
square_num = last_two_digits ** 2   # 计算完全平方数
print(square_num)

# 步骤3
lst = []   # 定义一个空数组
for i in range(1, 12+1):
    num = 2 ** i   # 计算2的i次方
    lst.append(num)   # 将计算结果添加到数组中
print(lst)
import numpy as np   # 引入numpy库，用于计算方差
variance = np.var(lst)   # 计算方差
print(variance)

# 步骤4
file = open("output.txt", "w")   # 打开一个名为output的txt文件，以写入模式打开
file.write("lst: " + str(lst) + "\n")   # 写入数组
file.write("variance: " + str(variance))   # 写入方差
file.close()   # 关闭文件

开发情况——任务二：

# 开发人：dwk
import ast
import matplotlib.pyplot as plt
import numpy as np

array  = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]

# 进行映射计算并覆写到原txt文件
mapped_array = [x**2 + 2 for x in array]

# 计算数组中柱子之间的雨水接收量
def calculate_rainwater(array):
    n = len(array)
    if n < 3:
        return 0

    left_max = [0] * n
    right_max = [0] * n

    left_max[0] = array[0]
    for i in range(1, n):
        left_max[i] = max(left_max[i - 1], array[i])

    right_max[n - 1] = array[n - 1]
    for i in range(n - 2, -1, -1):
        right_max[i] = max(right_max[i + 1], array[i])

    water = 0
    for i in range(n):
        water += min(left_max[i], right_max[i]) - array[i]

    return water


# 计算雨水接收量
rainwater = calculate_rainwater(array)
print("降雨后能接收的最大雨水量：", rainwater)

# 绘制雨水

plt.figure('ori terrain')
x_list = [_ for _ in range(len(array))]  # 构建横坐标
plt.bar(x_list, mapped_array, width=1, color='k')   # 原始地形

plt.figure('terrain with water')
plt.bar(x_list, mapped_array, width=1, color='k')   # 原始地形
plt.bar(x_list, rainwater, width=1, color='b', alpha=0.5)  # 含水地形
plt.show()

# 开发人：hwy
# 开发时间：2023/5/10
import matplotlib.pyplot as plt
import numpy as np

# 读取文本文件
filename = r"F:\第四期编程\text4mission2.txt"
with open(filename, 'r') as f:
    content = f.read()

# 将文本内容转换为列表
lst = eval(content)

# 映射函数
def mapping(x):
    return x ** 2 + 2

# 对每个元素进行映射
lst = [mapping(x) for x in lst]

# 将新列表写回文件
with open(filename, 'w') as f:
    f.write(str(lst))

# 绘制柱状图
fig, ax = plt.subplots()

# 绘制黑色实心柱子
ax.bar(range(len(lst)), lst, width=1.0, color='black')

# 检查是否存在至少一个可以存水的区域
if len(lst) < 3 or max(lst) <= min(lst):
    print("No water can be stored.")
else:
    # 计算每个柱子上方的雨水高度
    left_walls = [0] * len(lst)
    right_walls = [0] * len(lst)
    left_wall = lst[0]
    for i in range(1, len(lst)):
        left_walls[i] = left_wall
        left_wall = max(left_wall, lst[i])
    right_wall = lst[-1]
    for i in range(len(lst)-2, -1, -1):
        right_walls[i] = right_wall
        right_wall = max(right_wall, lst[i])
    water_levels = []
    for i in range(1, len(lst)-1):
        level = min(left_walls[i], right_walls[i]) - lst[i]
        water_levels.append(max(0, level))

    # 绘制蓝色实心柱子
    ax.bar(range(1, len(lst)-1), water_levels, bottom=lst[1:len(lst)-1], width=1.0, color='blue')

    plt.show()

#开发人：xjq
import pandas


def read_tablemethod(filename):
    data = pandas.read_table(filename, header=None, delim_whitespace=True)
    data = data[0][0]
    return data

class Solution3(object):
    def __init__(self,path,txt_name):
        self.path=path
        self.txt_name=txt_name


    def rain_calculate(self):
        data = read_tablemethod(self.path + self.txt_name)
        data = data.strip('[]')
        data = data.split(',')
        print("txt读取的信息是：%s"%(data))
        data = [int(x) for x in data]
        y = np.array(data) ** 2 + 2
        # 计算雨水
        w = 0
        for i in range(1, max(y) + 1):
            index = []
            for j in range(len(y)):
                if y[j] >= i:
                    index.append(j)
            if len(index) > 1:
                for k in range(index[0], index[-1]):
                    if y[k] < i:
                        w = w + 1
        print("收集的水量为%d"%(w))
        y = str(y)
        with open(self.path + self.txt_name, 'w') as f:
            f.write(y + '\n')
            f.close()

path="C:\\Users\\86136\\Desktop\\"
name = "text4mission2.txt"
x3 = Solution3(path,name)
x3.rain_calculate()

# 开发人：zk
(1)
import numpy as np

# 读取文本数组
# with open('data.txt', 'r') as f:
#    data = f.read().splitlines()
data= [0,1,0,2,1,0,1,3,2,1,2,1]

# 映射函数
def map_func(x):
    return str(int(x)**2 + 2)

# 映射并覆写原txt
with open('data.txt', 'w') as f:
    for d in data:
        f.write(map_func(d) + '\n')

(2)
def max_rain_water(heights):
    n = len(heights)
    left_max_heights = [0] * n  # 左侧最高柱子高度
    right_max_heights = [0] * n  # 右侧最高柱子高度

    # 求每个柱子左侧最高柱子高度
    left_max = 0
    for i in range(n):
        left_max_heights[i] = left_max
        left_max = max(left_max, heights[i])

    # 求每个柱子右侧最高柱子高度
    right_max = 0
    for i in range(n-1, -1, -1):
        right_max_heights[i] = right_max
        right_max = max(right_max, heights[i])

    # 计算每个柱子能接多少雨水
    water = 0
    for i in range(n):
        h = min(left_max_heights[i], right_max_heights[i])
        if h > heights[i]:
            water += h - heights[i]

    return water

# 测试
heights = [0,1,0,2,1,0,1,3,2,1,2,1]
print(max_rain_water(heights))  # 输出：6

#开发人：cyf
import numpy as np
f = open("text4mission2.txt", 'r')
data = f.read()
print("data=",data)
# 转换变量类型
arr = np.array(eval(data))
print(arr)
def y(x):
  return x ** 2 + 2
rain = y(arr)
print("映射雨量为",rain)

# 寻找左右边界，删去两侧不积水元素
def cutl(h):
    while h[0] <= h[1] and len(h) >= 3:
     h = np.delete(h, 0)
    else:
     pass
    return h
def cutr(h):
    while h[-1] <= h[-2] and len(h) >= 3:
     h = np.delete(h,-1)
    else:
     pass
    return h
# 下移c个单位并保证最小值为-
def cutt(c, z):
    cuttnum = len(z)
    for k in range(0,cuttnum):
        if z[k] >= c:
           z[k] = z[k]-c
        else:
            z[k] = 0
    return z
#统计水位上升o高度的积雨量
def mount(o, p):
    global ans
    mountnum = len(p)
    for l in range(0, mountnum):
        if p[l] >= o:
            pass
        else:
            ans = ans+o-p[l]
    return ans
#统计总体积雨量
def rm(g):
    global ans
    g = cutl(g)
    g = cutr(g)
    n = len(g)
    while n >= 3:
       hm=min(g[0],g[-1])
       ans = mount(hm,g)
       g = cutt(hm,g)
       g = cutl(g)
       g = cutr(g)
       n = len(g)
    else:
       return ans

ans = 0
c = rm(rain)
print('可积雨量为',c)

#调整输出格式
rainlist = rain.tolist()
print("调整后的映射雨量为",rainlist)
f = open("text4mission2.txt", 'w')
f.write(str(rainlist))
print("保存完毕")

#开发人：lk
import matplotlib.pyplot as plt

ori_list = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]    # 原序列
new_list = []

# 元素映射
for i in ori_list:
    y = i*i+2
    new_list.append(y)
print('映射结果：', new_list)

# 计算可储存水量
water_list = new_list[:]
for i in range(1, len(ori_list)):
    for j in range(i+1, len(ori_list)):
        for k in range(0, i):
            if water_list[i] < water_list[j] and water_list[i] < water_list[k]:
                water_list[i] = min(water_list[j], water_list[k])

# 数据可视化
plt.figure('ori terrain')
x_list = [_ for _ in range(len(ori_list))]  # 构建横坐标
plt.bar(x_list, new_list, width=1, color='k')   # 原始地形

plt.figure('terrain with water')
plt.bar(x_list, new_list, width=1, color='k')   # 原始地形
plt.bar(x_list, water_list, width=1, color='b', alpha=0.5)  # 含水地形
plt.show()

# 计算水量输出
water_volume = []
for i in range(len(ori_list)):
    water_volume.append(water_list[i] - new_list[i])
print('可储存雨水量为：', sum(water_volume))