python(牛客)试题解析3 - 困难

导航

一、找到已经最大承重的背包内如何放入最大价值的物品的最优解

二、查找一个字符串中包含另外一个字符串(可打乱顺序)的次数
三、计算正整数数组从头走到最后一个成员所需的最小步骤
四、计算字符串非严格递增连续数字序列的长度
五、输出这个数列的第n项结果，数列中a[n+1]都是a[n]的描述
六、计算多维数组中最大子矩阵内所有数字的和
七、还原一个已经打乱顺序的喊7游戏的数组
八、计算满足GPU算力的一组任务组的最少耗时
九、计算字符串中连续出现次数第k多的字母的次数
十、计算一个整数可以由连续的自然数之和的各种情况
十一、给定一个正整数数组，计算满足 A = B + 2C的数组序列
十二、根据 Tag Length Value格式解码TLV编码

 

- - - - - 分割线 -  正文 - - - -

一、找到已经最大承重的背包内如何放入最大价值的物品的最优解

描述：有N件物品和一个容量为V的背包。第i件物品的重量是w[i]，价值是v[i]。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

输入说明：

第一行输入：可放的商品个数

第二行输入：背包的容量

第三行到第N行：分别放入每个商品的容量与价值,以空格隔开

输出说明：

第一行输出：可放入的商品的最大价值

示例：

第一行输入商品个数：4

第二行输入背包的容量：10

第三行输入第一个商品的容量与价值：5 6

第四行输入第一个商品的容量与价值：4 5

第五行输入第一个商品的容量与价值：3 4

第六行输入第一个商品的容量与价值：2 3

结果返回：商品的最大价值14，分别放入 5（5，6）（3，4）（2，3）后获得

解析：定义一些变量：Vi表示第 i 个物品的价值，Wi表示第 i 个物品的体积，定义V(i,j)：当前背包容量 j，前 i 个物品最佳组合对应的价值，同时背包问题抽象化（X1，X2，…，Xn，其中 Xi 取0或1，表示第 i 个物品选或不选）。

1、建立模型，即求max(V1X1+V2X2+…+VnXn)；
2、寻找约束条件，W1X1+W2X2+…+WnXn<capacity；
3、寻找递推关系式，面对当前商品有两种可能性：包的容量比该商品体积小，装不下，此时的价值与前i-1个的价值是一样的，即V(i,j)=V(i-1,j)；
还有足够的容量可以装该商品，但装了也不一定达到当前最优价值，所以在装与不装之间选择最优的一个，即V(i,j)=max｛V(i-1,j)，V(i-1,j-w(i))+v(i)｝。
其中V(i-1,j)表示不装，V(i-1,j-w(i))+v(i) 表示装了第i个商品，背包容量减少w(i)，但价值增加了v(i)；
由此可以得出递推关系式：
j<w(i) V(i,j)=V(i-1,j)
j>=w(i) V(i,j)=max｛V(i-1,j)，V(i-1,j-w(i))+v(i)｝

可参考详细说明：https://www.cnblogs.com/mrwhite2020/p/13097029.html

num=int(input("请输入可放的商品个数:"))
bag=int(input("请输入背包容量:"))
w=[]#容量表
v=[]#价值表
for i in range(num):
    str1=input("请分别输入每个商品的容量,与价值,以空格隔开:")
    w.append(int(str1.split(" ")[0]))
    v.append(int(str1.split(" ")[1]))
print("容量为",w)
print("体积为",v)
# 动态规划
#动态构建v模型(mum+1)*(bag+1),初始化全0
module=[[0 for i in range(bag+1)] for i in range(num+1)]
print("初始化:",module)
for i in range(1,num+1):
    for j in range(1,bag+1):
        if w[i-1]>j:#当第i次的物品容量小于背包容量,不拿,最大容量与上一次的相等
            module[i][j]=module[i-1][j]
        else:#否则,物品容量小于等于当年背包容量,可以选择放或不放,不放即上一次的背包
            module[i][j]=max(module[i-1][j],module[i-1][j-w[i-1]]+v[i-1])
for i in range(len(module)):
    print(module[i])
print("最大价值为:",module[num][bag])

 

二、查找一个字符串中包含另外一个字符串(可打乱顺序)的次数

描述：输入第一个字符串A，可包含26个字母的大小写，可重复，输入第二个字符串B，可包含26个字母的大小写，可重复，求A字符串中出现B字符串的次数，且B字符串内的字符顺序可以打乱

示例:

第一行输入字符串abcefdbacbe

第二行输入字符串B:abc

输出包含的次数：3，分别是包含abc，bac，acb

解析：使用迭代器工具itertools.permutations可编辑B的各种组合list，循环字符串A使用startwith方法根据位置匹配

import itertools

#A = "abcefdbacbe"
#B = "abc"
A = input()
B = input()
count = 0
count_list=[]
if len(A)<len(B):
    res = 0
else:
    for i in range(len(A)-len(B)+1):
        for j in itertools.permutations(B,3):
            B1 = ''.join(j)
            if A[i:].startswith(B1) is True:
                count += 1
                print(f"count:{count}")
            count_list.append(count)
    res = max(count_list)
print(res)

 

三、计算正整数数组从头走到最后一个成员所需的最小步骤
描述：给定一个正整数数组，设为nums，最大为100个成员，求从第一个成员开始，正好走到数组最后一个成员，所使用的最少步骤数。
要求：
1、第一步必须从第一元素开始，且1<=第一步的步长<len/2;（len为数组的长度，需要自行解析）。
2、从第二步开始，只能以所在成员的数字走相应的步数，不能多也不能少, 如果目标不可达返回-1，只输出最少的步骤数量。
3、只能向数组的尾部走，不能往回走。
输入描述:
由正整数组成的数组，以空格分隔，数组长度小于100，请自行解析数据数量。
输出描述:
正整数，表示最少的步数，如果不存在输出-1
示例：
输入
5 9 4 2 6 8 3 5 4 3 9
输出
2

解析：遍历数组，分别从第一步出发，将满足条件的数据记录并比较取最小值。

nums = list(map(int, input().split()))
length = len(nums)
min_step,move_step,flag = length,1,False
for first_step in range(1,int(length/2)):
    move_step = first_step
    step = 1
    while move_step < length - 1:
        step += 1
        move_step += nums[move_step]
    if move_step == length - 1:
        min_step = min(min_step,step)
        flag = True
print(min_step if flag else -1)

 

四、计算字符串非严格递增连续数字序列的长度

描述：输入一个字符串仅包含大小写字母和数字，求字符串中包含的最长的非严格递增连续数字序列的长度（比如12234属于非严格递增连续数字序列）。
输入描述：
输入一个字符串仅包含大小写字母和数字，输入的字符串最大不超过255个字符。
输出描述：
最长的非严格递增连续数字序列的长度
示例：
输入：
abc2234019A334bc
输出：
4

解析：定义上一个符合条件的数字，当满足非严格递增时记录最大的递增数

s = input()
length,max_length,last=0,0,'0'
for i in s:
    if '0'<=i<='9':
        if i >= last:
            length += 1
            max_length = max(max_length,length)
            last = i
        else:
            length = 1
            last = i
    else:
        length = 0
        last = '0'
print(max_length)

 

五、输出这个数列的第n项结果，数列中a[n+1]都是a[n]的描述

描述：一个数列a[N] (N=60)，从a[0]开始，每一项都是一个数字。数列中a[n+1]都是a[n]的描述。其中a[0]=1
规则如下：
a[0]:1
a[1]:11(含义:其前一项a[0]=1是1个1，即“11”表示a[0]从左到右，连续出现了1次“1”)
a[2]:21(含义:其前一项a[1]=11，从左到右:是由两个1组成，即21。表示a[1]从左到右，连续出现了两次“1＂)
a[3]:1211(含义:其前一项a[2]=21，从左到右:是由一个2和一个1组成，即“1211”。表示a[2]从左到右，连续出现了1次“2”，然后又连续出现了1次“1”)
a[4]:111221(含义:其前一项a[3]=1211，从左到右:是由一个1、一个2、两个1组成，即111221。表示a[3]从左到右，连续出现了1次“1”，连续出现了1次“2”，连续出现了两次“1”)
请输出这个数列的第n项结果(a[n]，0≤n≤59)。

示例：
输入描述
数列的第n项(0≤n≤59):
4
输出描述:
数列的内容:
111221

n = int(input())
lst = ["1"]
def solution(sr):
    sr2= sr+"A"
    sr=""
    count=0
    for i in range(len(sr2)-1):
        count +=1
        if sr2[i] != sr2[i+1]:
            sr = sr +str(count)+sr2[i]
            count = 0
    return sr
for i in range(n):
    lst.append(solution(lst[-1]))
print(lst[n])

 

六、计算多维数组中最大子矩阵内所有数字的和

描述：定一个二维整数矩阵，要在这个矩阵中选出一个子矩阵，使得这个子矩阵内所有的数字和尽量大，我们把这个子矩阵称为和最大矩阵，子矩阵的选取原则是原矩阵中一块连续的矩形区域，单独一行、单独一列、整个矩阵，都算子矩阵。
输入：
输入的第一行包含2个整数n,m(1<=n,m<=10),表示一个n行m列矩阵，下面有n行，每行m个整数，同一行中，每两个数字之间一个空格，最后一个数字后没有空格，所有数字的取值范围为**[-1000,1000]**

输出：
输出一行，一个数字，表示选出的和最大子矩阵内所有数字的和。

示例：
# input
3 3
951 589 39
-583 -710 473
-229 501 -594
# output
1579

a,b = list(map(int,input().split()))
res =[]
max_sub=0
for _ in range(a):
    res.append(list(map(int,input().split())))
for i in range(a+1):
    for k in range(i+1,a+1):
        for j in range(b+1):
            for s in range(j+1,b+1):
                temp_sub = sum([sum(temp[j:s]) for temp in res[i:k]])
                if temp_sub > max_sub:
                    max_sub = temp_sub
print(max_sub)

 

七、还原一个已经打乱顺序的喊7游戏的数组

描述：喊7是一个传统的聚会游戏，N个人围成一圈，按顺时针从1到N编号。编号为1的人从1开始喊数，下一个人喊的数字为上一个人的数字加1，但是当数字是7的倍数或者数字本身含有7的话，要喊"过"。现给定一个长度为N的数组，存储了打乱顺序的每个人喊"过"的次数，请把它还原成正确的顺序，即数组的第i个元素存储编号i的人喊"过"的次数。
输入
输入为一行，为空格分隔的喊"过"的次数

示例：
样例输入
0 1 0
样例输出
1 0 0
输入
0 0 0 2 1
输出
0 2 0 1 0

解析：记录喊7的总量后，初始化喊7的数字，并从头开始推算喊7 的数组

nums = list(map(int,input().split()))
k,index,count=0,1,0
n=len(nums)
out_list=[0]*n
for i in nums:
k += i
while count < k:
if str(index).find("7")!=-1 or index % 7 ==0:
i = (index%n)-1
count +=1
out_list[i]+=1
index +=1
print(" ".join([str(x) for x in out_list]))

 

八、计算满足GPU算力的一组任务组的最少耗时

描述:为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行现在有一个任务数组，数组元素表示在这1s内新增的任务个数，且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1s，在保证GPU不空闲的情况下，最少需要多长时间执行完成。

输入描述：
第一个参数为GPU最多执行的任务个数，取值范围1~10000
第二个参数为任务数组的长度，取值范围1~10000
第三个参数为任务数组，数字范围1~1000
输出描述：
执行完所有任务需要多少秒
示例:
输入：
3
5
1 2 3 4 5
输出：
6
说明：
一次最多执行3个任务 最少耗时6s
输入：
4
5
5 4 1 1 1
输出：
5

n = int(input())
len = int(input())
l = list(map(int,input().split()))
time,more=0,0
for i in l:
    if i+more > n:
        more = i+more-n
    else:
        more = 0
    time += 1
while more > 0:
    more -= n
    time += 1
print(time)

 

十一、计算字符串中连续出现次数第k多的字母的次数

描述：定一个字符串，只包含大写字母，求在包含同一字母的子串中，长度第 k 长的子串的长度，相同字母只取最长的那个子串。
输入描述: 第一行有一个子串(1<长度<=100)，只包含大写字母。 第二行为 k的值 输出描述: 输出连续出现次数第k多的字母的次数。
示例1
输入
AAAAHHHBBCDHHHH
3
输出
2 说明 :同一字母连续出现的最多的是A和H，四次；第二多的是H，3次，但是H已经存在4个连续的，故不考虑；下个最长子串是BB，所以最终答案应该输出2。
示例2
输入
AABAAA
2
输出
1 说明 同一字母连续出现的最多的是A，三次；第二多的还是A，两次，但A已经存在最大连续次数三次，故不考虑；下个最长子串是B，所以输出1
示例3
输入
ABC
4
输出
-1 说明 只含有3个包含同一字母的子串，小于k，输出-1
示例4
输入
ABC
2
输出
1

s, k, count, d = input(), int(input()), 1, {}
n = len(s)
if n != 1:
    for i in range(n - 1):
        if s[i] == s[i + 1]:
            count += 1
        else:
            d[s[i]] = max(d.get(s[i], 0), count)
            count = 1
        if i == n - 2:
            d[s[i + 1]] = max(d.get(s[i + 1], 0), count)
    a = sorted(d.items(), key=lambda x: x[1])
    print(-1 if k > len(a) else a[-k][1])
else:
    print(1 if k == 1 else -1)

 

十二、计算一个整数可以由连续的自然数之和的各种情况

描述：一个整数可以由连续的自然数之和来表示
给定一个整数
计算该整数有几种连续自然数之和的表达式
并打印出每一种表达式

输入描述
一个目标整数t 1<= t <=1000
输出描述
1.该整数的所有表达式和表达式的个数
如果有多种表达式，自然数个数最少的表达式优先输出
2.每个表达式中按自然数递增输出

具体的格式参见样例
在每个测试数据结束时，输出一行"Result:X"
其中X是最终的表达式个数

示例：

输入
9
输出
9=9
9=4+5
9=2+3+4
Result:3

n = int(input())
res = [[n]]
for i in list(range(n//2+1))[::-1]:
    i+=1
    if sum(range(n+1))<n:
        break
    else:
        sum_ = 0
        tmp = []
        for j in list(range(i))[::-1]:
            j+=1
            sum_+=j
            tmp.append(j)
            if sum_== n:
                res.append(tmp)
                break
            elif sum_ > n:
                break
for i in res:
    print(str(n)+"="+"+".join(map(str,sorted(i))))
print("Result:"+str(len(res)))

 

九、给定一个正整数数组，计算满足 A = B + 2C的数组序列

描述：定一个正整数数组，检查数组中是否存在满足规则的数字组合
规则： A = B + 2C
输入描述：

第一行输出数组的元素个数。
接下来一行输出所有数组元素，用空格隔开。
输出描述：
如果存在满足要求的数，在同一行里依次输出规则里A/B/C的取值，用空格隔开。
如果不存在，输出0。

示例：
4
2 7 3 0
输出：
7 3 2
说明
7 = 3 + 2 * 2
输入：
3
1 1 1
输出：
0

解析：使用itertools工具类permutations方法生成所有全长排列并直接用于计算

import itertools
n,nums,flag=int(input()),list(map(int,input().split())),True
for a,b,c in itertools.permutations(nums,3):
    if a == b + c * 2:
        print(a,b,c)
        flag = False
if flag:
    print(0)

 

十、根据 Tag Length Value格式解码TLV编码

描述：TLV编码是按 Tag Length Value格式进行编码的 一段码流中的信元用tag标识，tag在码流中唯一不重复 length表示信元value的长度 value表示信元的值
码流以某信元的tag开头 ，tag固定占一个字节，length固定占两个字节，字节序为小端序。

示例:

输入：
31
32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC
输出
32 33

k = input()
s = input().split()
n = len(s)
i = 0
while i < len(s):
    tag = s[i]
    length = int(s[i+2]+s[i+1],16)
    value = ""
    for j in range(length):
        value += s[i+3+j]+" "
    i += 3 + length
    if k == tag:
        print(value)