某公司自动化测试3面

仅供参阅，并不提供参考答案，上课的时候多数讲解过
算法题给了你一个参考，都是力扣上的

一面

1. 自我介绍
2. 关于自动化：怎么做的，目前的进展，效果如何，遇到的困难
3. 你的框架搭建，最初是考虑了哪些因素去设计的
4. 如何维护自动化case？
5. 有没有用mock去解决问题？
6. 说说你工作以来做过的这些业务，你觉得在保证质量工作中，存在的差异性
7. 你在工作中发现的问题，自己做了什么事情去推动
8. 沟通下来，觉得你们流程问题还是比较多的，纯靠手工去保证么？
9. 开发冒烟执行后，测试如何判断是否通过
10. 算法题：判断15张扑克牌，随机5张，大小王任意配，是否是顺子
11. 看你用python多，聊聊python的一些数据结构，常用方法等等，都可以说
12. python中浅拷贝、深拷贝
13. 测试的接口都是什么协议的，对http协议有进一步了解么
14. 问代码是怎么学的？

二面

1. 自我介绍
2. 平时如何做测试工作的
3. 流程，规范相关
4. 推进遇到的难点，分析，解决
5. 聊聊最近印象深刻的项目或者bug
6. 聊聊自动化如何实施的，使用场景。针对你回答，抓细节点深问
7. 关于QA如何验证开发冒烟测试通过的方式
8. 问了数据库，索引。 优点缺点、常见索引类型、索引最左前缀原理
9. Redis缓存击穿，雪崩
10. 问了java相关基础，多线程
11. sql题：数据库单表查询，主要考察group by用法
12. 算法题：合并有序数组
13. 反问环节

三面

1. 自我介绍
2. 算法题：给定一个数组，判断是否有重复数据，最少3种方法实现。
3. 聊平常的工作内容，具体哪些业务，系统架构，如何交互
4. 用到消息队列，跟接口交互有什么区别，优缺点
5. 抓住简历上的项目，和你回答的内容，继续深问
6. 问你之前XX项目的测试重点是什么
7. 涉及到性能测试的，如何进行测试，关注哪些点，指标
8. 用例设计题：一个新客、老客、转新购买活动商品减优惠的需求
9. 聊做了哪些工具，怎么做的，前后端用到了什么
10. 自动化 怎么做的，做了哪些，测试数据是放在哪里。
11. 多接口串联的场景，自动化要怎么做？

算法题

LeetCode 217存在重复元素

  • 题目

    给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。
 

示例 1：

输入：nums = [1,2,3,1]
输出：true
示例 2：

输入：nums = [1,2,3,4]
输出：false
示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true
 

提示：

1 <= nums.length <= 105
-109 <= nums[i] <= 109
    • 这道题有个变种，有的会让你返回重复的那个数的值，若存在多个，随便返回一个即可

  • 思路

    • 方案1：排重后看列表长度是否有变化

    • 方案2：哈希表，一个个放入，直到有重复

    • 方案3：排序后遍历，比较nums[n]和nums[n+1]

  • 题解1

    class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        return len(nums)!=len(set(nums))

  • 题解2

    class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        s = set()
        for num in nums:
            if num not in s:
                s.add(num)
            else:
                return True
        return False

  • 题解3

    class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        nums.sort()
        length = len(nums)
        for i in range(length-1):
            if nums[i]==nums[i+1]:
                return True
        else:
            return False

剑指 Offer 61. 扑克牌中的顺子

  • 题目

    从若干副扑克牌中随机抽 5 张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

 

示例 1:

输入: [1,2,3,4,5]
输出: True
 

示例 2:

输入: [0,0,1,2,5]
输出: True
 

限制：

数组长度为 5 

数组的数取值为 [0, 13]

  • 思路

    • 仔细读题(做了半天这里还有一个隐含条件，题目没有讲清楚)，5张牌中不应该出现超过2个大小王。

    • 所以无非是三种情况

      • 无大小王： 12345
      • 1个大小王，连续的4个数字+0或者跳开1个数字
      • 2个大小王，最复杂连续的3个+00，跳开1个数字+0，跳开2个数字+0 ......

    • 这样想的确容易被绕进去，组合非常多，而且没有太大的规律，难道要用递归？

    • 换个角度，有一种约束可以这样表达

      • 不应该出现重复的数字，除了0

      • 如果不重复，那除了0之外的，最大值和最小值的差<5

        01234
01235

00135
00123
00124

    • 题解

      class Solution:
    def isStraight(self,nums) -> bool:
        while True:
            try:
                nums.remove(0)
            except:
                break # 移除0 当然方法很多
        if len(nums) == len(set(nums)): # 看余下数字是否有重复，没有的话(长度不变)
            return max(nums) - min(nums) < 5 # 那最大值-最小值应该<5
        else:
            return False

88. 合并两个有序数组

  • 题目

    给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

 

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
 

提示：

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109
 

进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

  • 思路

    • 暴力的做法很简单，合并2个数组(注意nums1只需取前面m个数)
    • 然后对合并后的数组排序即可

  • 题解1

    class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        # nums1 = nums1[:m]+nums2
        nums1[m:] = nums2
        nums1.sort()

  • 题解2

    • 如果两个数组从开头向结尾（数字从小到大）进行比较，那么每次把比较之后的数字放置到 nums1 中的前面，则需要把 nums1 中后面的元素向后移动。移动次数比较多。

    • 如果两个数组从结尾向开头（数字从大到小）进行比较，那么每次把比较之后的数字放置到 nums1 中的后面，由于后面的数字本身就是提供出来的多余的位置，都是 0，因此不需要对 nums1 进行移动。

    • 如果nums1[m-1]比nums2[n-1]大，那么nums1[m+n-1]换为nums1[m-1]，m左移

      nums1   1,2,3,0,0,0  m=3
nums2   2,5,6        n=3
R1 比较 3(nums1[3-1]) 和 6  , 6 大 所以 nums1[5] = nums2[2]
	 m-- (此时m=2，n=3)
R2 比较 3 和 5 ， 5 大 ， 所以 nums1[4] = nums2[1]
	 m-- (此时m=1，n=3)
R3 比较 3 和 2，  3 大， 所以 nums1[3] = nums1[2]
     n-- (此时m=1，n=2)

    • 如果nums1[m-1]比nums2[n-1]小，那么nums1[m+n-1]换为nums2[n-1]，n左移

    • 当m或n为0的时候，循环就退出了，但要想清楚m为0的时候说明n可能不为0，说明nums2还有数据都小，那nums1还有n个位置，要用nums2[:n]来替换

    • 但当n为0的时候nums1余下的数不需要做任何处理的

    class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        # nums1 = nums1[:m]+nums2
        while m >0 and n > 0:
            if nums1[m-1]>nums2[n-1]:
                nums1[m+n-1] = nums1[m-1]
                m = m-1
            else:
                nums1[m+n-1] = nums2[n-1]
                n = n-1
        if m == 0:
            nums1[:n]=nums2[:n]