日常刷题(2)_如果匹配正确输出括号的对数,否则输出-1-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_46763548/article/details/140627540

1. 表达式括号匹配

1.1. 题目描述

(1+(2+3)*(3+(8+0))+1-2)这是一个简单的数学表达式,今天不是计算它的值,而是比较它的括号匹配是否正确。

前面这个式子可以简化为(()(()))这样的括号我们认为它是匹配正确的,

而((())这样的我们就说他是错误的。注意括号里面的表达式可能是错的,也可能有多个空格，对于这些我们是不用去管的，

我们只关心括号是否使用正确。

1.2. 输入描述

给出一行表达式(长度不超过 100)。

1.3. 输出描述

如果匹配正确输出括号的对数，否则输出-1。

1.4. 用例

输入 (1+(2+3)*(3+(8+0))+1-2)
输出 4

1.5. 代码

class MatchBrackets:
    def __call__(self, string: str):
        cnt = 0
        stack = []
        for c in string:
            if c not in '()':
                continue
            if c == '(':
                stack.append(c)

            if c == ')' and stack and stack[-1] == '(':
                stack.pop()
                cnt += 1
        if stack:
            return -1
        return cnt

2. 部门人力分配

2.1. 题目描述

部门在进行需求开发时需要进行人力安排。

当前部门需要完成 N 个需求，需求用 requirements 表述，requirements[i] 表示第 i 个需求的工作量大小，单位：人月。

这部分需求需要在 M 个月内完成开发，进行人力安排后每个月人力时固定的。

目前要求每个月最多有2个需求开发，并且每个月需要完成的需求不能超过部门人力。

请帮助部门评估在满足需求开发进度的情况下，每个月需要的最小人力是多少？

2.2. 输入描述

输入为 M 和 requirements，M 表示需求开发时间要求，requirements 表示每个需求工作量大小，N 为 requirements长度，

1 ≤ N/2 ≤ M ≤ N ≤ 10000
1 ≤ requirements[i] ≤ 10^9

2.3. 输出描述

对于每一组测试数据，输出部门需要人力需求，行末无多余的空格

2.4. 用例

输入
3
3 5 3 4
输出 6
说明
输入数据两行，
第一行输入数据3表示开发时间要求，
第二行输入数据表示需求工作量大小，
输出数据一行，表示部门人力需求。
当选择人力为6时，2个需求量为3的工作可以在1个月里完成，其他2个工作各需要1个月完成。可以在3个月内完成所有需求。
当选择人力为5时，4个工作各需要1个月完成，一共需要4个月才能完成所有需求。
因此6是部门最小的人力需求。

2.5. 思路

和上一期吃桃子的思路类似，二分法找刚好能满足的资源。判断是否能满足也比较容易，尽可能一个月内完成两个任务，也就是把人多的项目和人少的项目同时开展即可（双指针）

2.6. 代码

class ResourcesAllocation:
    def can_finish(self, hc: int, task_list: List[int], time_limit: int) -> bool:
        l, r = 0, len(task_list) - 1

        cost = 0
        while l <= r:
            if task_list[l] + task_list[r] <= hc:
                l += 1
            r -= 1
            cost += 1
            if cost > time_limit:
                return False
        return cost <= time_limit

    def __call__(self, time_limit: int, task_list: List[int]):
        task_list.sort()

        min_hc, max_hc = 1, sum(task_list)
        ans = max_hc

        while min_hc < max_hc:
            mid_hc = (min_hc + max_hc) // 2
            if self.can_finish(mid_hc, task_list, time_limit):
                ans = mid_hc
                max_hc = mid_hc - 1
            else:
                min_hc = mid_hc + 1
        return ans

3. 测试用例执行计划

3.1. 题目描述

某个产品当前迭代周期内有 N 个特性（F1,F2,…FN）需要进行覆盖测试，每个特性都被评估了对应的优先级，特性使用其 ID 作为下标进行标识。

设计了 M 个测试用例（T1,T2,…,TM），每个测试用例对应一个覆盖特性的集合，测试用例使用其 ID 作为下标进行标识，测试用例的优先级定义为其覆盖的特性的优先级之和。

在开展测试之前，需要制定测试用例的执行顺序，规则为：优先级大的用例先执行，如果存在优先级相同的用例，用例 ID 小的先执行。

输入描述
第一行输入为 N 和 M，

N 表示特性的数量，0 < N ≤ 100
M 表示测试用例的数量，0 < M ≤ 100
之后 N 行表示特性 ID=1 到特性 ID=N 的优先级，

再接下来 M 行表示测试用例 ID=1 到测试用例 ID=M 关联的特性的 ID 的列表。

3.2. 输出描述

按照执行顺序（优先级从大到小）输出测试用例的 ID，每行一个ID。

测试用例覆盖的 ID 不重复。

3.3. 用例

3.3.1. case1

输入
5 4
1
1
2
3
5
1 2 3
1 4
3 4 5
2 3 4
输出
3
4
1
2
说明
测试用例的优先级计算如下：
T1 = Pf1 + Pf2 + Pf3 = 1 + 1 + 2 = 4
T2 = Pf1 + Pf4 = 1 + 3 = 4
T3 = Pf3 + Pf4 + Pf5 = 2 + 3 + 5 = 10
T4 = Pf2 + Pf3 + Pf4 = 1 + 2 + 3 = 6
按照优先级从小到大，以及相同优先级，ID小的先执行的规则，执行顺序为T3,T4,T1,T2

3.4. 题目解析

题目没看懂，但是用例凑出来了规律，大概就是一个分值表，一个array，array里的分值越大排序越靠前。那sort就完事了

3.5. 代码

class Solution:
    def __call__(self, features: List[int], prior: List[List[int]]):
        prior_sum = []
        for i, _prior in enumerate(prior, start=1):
            _prior_sum = sum(map(lambda x: features[x-1], _prior))
            prior_sum.append((_prior_sum, -i, i))

        prior_sum.sort(reverse=True)
        return list(map(lambda x: x[-1], prior_sum))