1. 贪心的交易

商品价格每天都在变化，作为一个商人，需要低买高卖赚取利润，通常会根据历史数据，检验策略的收益。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
已知有一个商品历史价格变化列表。其中第 i 个元素是第 i 天该商品的价格。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
现在使用的贪心策略是在该过程中要求必须尽可能多的进行获利的交易，并且每次买入时都要先清仓（全部卖出上一次买入的商品），不能同时进行多笔交易。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
定义一个函数，计算你在这种策略下能获取的最大利润。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
比如价格列表为 [1,3,5,1,8]，利润最大为11元，‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
第1天买入，第2天卖出 获利3-1=2元‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
第2天买入，第3天卖出 获利5-3=2元‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
第4天价格跌落，所以第三天无交易‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
第4天买入，第5天卖出 获利8-1=7元‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
总利润为 2+2+7=11元‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
本题的编程模板会帮助你建立一个随机的价格列表（价格在1-100元的闭区间中），你需要在两行中各输入一个整数，第一行输入一个可交易的总天数（即列表中的价格个数），第二行输入一个整数做为随机种子。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输出时模板会在两行中分别输出生成的价格列表以及能获取的最大利润。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
提示：列表的索引使用方式与字符串相同。

  1. import random
  4. def f(prices):
  5.     print(prices)
  6.     s = 0
  7.     for i in range(len(prices) - 1):  # 此处注意不要越界
  8.         if prices[i] < prices[i + 1]:
  9.             s += prices[i + 1] - prices[i]
  10.     return s
  13. if __name__ == '__main__':
  14.     n = int(input())
  15.     random.seed(int(input()))
  16.     ls = [random.randint(1, 100) for i in range(0, n)]
  17.     print(f(ls))

2. 装箱问题

快递公司提供的集装箱规格都是6×6×h。为方便运输，提供的分装箱高度都是h，长和宽的规格有：1×1、2×2、3×3、4×4、5×5、6×6这6种。编写一个程序，输入6个数字，表示这批货中6种规格箱子的数量，输出所需最少的集装箱数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
6个整数，空格分隔‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
集装箱数

  1. # 输入切分后逆序，得到6*6，5*5，4*4，3*3，2*2，1*1的箱子数量
  2. ls = list(map(int, input().split()))
  3. box_66 = ls[5]  # 6*6，5*5，4*4的每个包裹各占一个集装箱
  4. box_55 = ls[4]
  5. box_44 = ls[3]
  6. box_33 = (ls[2] + 3) // 4  # 3*3 的每4个包裹占一个集装箱
  7. # 每个放6*6的箱子是满的
  8. # 每个放5*5的箱子里空11个单元，能装11个1*1
  9. # 每个放4*4的箱子里空20个单元，能装5个2*2，满
  10. # 每个放1个3*3的箱子里空27个单元，能装5个2*2，余7个1*1
  11. # 每个放2个3*3的箱子里空18个单元，能装3个2*2，余6个1*1
  12. # 每个放3个3*3的箱子里空9个单元，能装1个2*2，余5个1*1
  13. # 放3*3的集装箱的空闲单元数量(4 - ls[3] % 4) * 9 if ls[3] % 4 != 0 else 0
  14. # 放6*6，5*5，4*4，3*3的集装箱中能容纳2*2的箱子的数量box_22_capacity
  15. # box_22_capacity = 5 * ls[3] + ((4 - ls[2] % 4) * 9 if ls[2] % 4 != 0 else 0)
  16. box_22_capacity = 5 * ls[3] + (ls[2] % 4 == 1) * 5 + (ls[2] % 4 == 2) * 3 + (ls[2] % 4 == 3) * 1
  17. # print(box_22_capacity)
  19. if ls[1] < box_22_capacity:  # 如果前3种箱子空余位置多于2*2的数量，不需要单独占用新箱子
  20.     box_22 = 0               # 空闲1*1的单元为总空闲单元-ls[1]*4
  21.     # 5*5  4*4 3*3总空闲单元减2*2的箱子占用的单元数为剩余1*1的单元数
  22.     box_11_capacity = 11 * ls[4] + 20 * ls[3] + (ls[2] % 4 == 1) * 27 + (ls[2] % 4 == 2) * 18 + (ls[2] % 4 == 3) * 9 - ls[1] * 4
  23. #     print(box_11_capacity)
  24. else:
  25.     box_22 = (ls[1] - box_22_capacity + 8) // 9
  26.     box_22_left = (ls[1] - box_22_capacity) % 9  # 未满的2*2的箱子里的2*2的箱子数量
  27. #     print(box_22)
  28. #     print(box_22_left)
  29.     # 5*5  4*4 3*3总空闲单元减2*2的箱子占用的单元数为剩余1*1的单元数
  30.     box_11_capacity = 11 * ls[4] + 20 * ls[3] + (ls[2] % 4 == 1) * 27 + (ls[2] % 4 == 2) * 18 + (ls[2] % 4 == 3) * 9 - box_22_capacity * 4 + (36 - box_22_left * 4)
  31. #     print(box_11_capacity)
  33. # 放了box_22_left个2*2的箱子里能装36-box_22_left*4个1*1的箱子
  34. if ls[0] < box_11_capacity:
  35.     box_11 = 0
  36. else:
  37.     box_11 = (ls[0] - box_11_capacity + 35) // 36
  38. total = box_66 + box_55 + box_44 + box_33 + box_22 + box_11
  39. # print(box_11, box_22, box_33, box_44, box_55, box_66)
  40. print(total)