ms题集锦大汇总

zcx · 2023 年9 月 12 日 07:59

1.接口相关

2.python相关

2.1两种排序方法
sorted()
sort()

def move_zeros(num_list):
    # 方式1
    # reverse 降序
    # return  sorted(num_list,reverse=True,key=bool)
    # 方式2
    num_list.sort(reverse=True, key=bool) # 不能直接返回这个调用，直接打印这个返回None，得打印num_list
    return num_list

2.2随机函数

2.3 extend()和append()
list1.append(list2)直接把list2整体放在list1里面，做为一个元素
list1.extend(list2)是逐个把元素放在list1里面

3.性能测试

来源

4.UI自动化相关

如何判断页面元素是否存在
 元素定位不到的场景以及解决办法

5.linux相关命令

https://www.runoob.com/w3cnote/awk-arrays.html
https://ceshiren.com/t/topic/2754
https://blog.csdn.net/qq_41323475/article/details/127893816

6.概念

正向代理和反向代理

面经

https://ceshiren.com/t/topic/23121

zcx · 2023 年9 月 26 日 01:46

编程题

1.乱序匹配
https://ceshiren.com/t/topic/13957

# set(iterable) 集合 不重复
# str1.count(str2)  str2在str1出现的次数
def scramble(s1: str, s2: str):
    for s in s2:
        if (s not in s1) or s1.count(s) < s2.count(s):
            return False
    return True

2.完美列表
https://ceshiren.com/t/topic/14568

# all(iterable) 对可迭代对象所有的都为true才返回true
def is_nice(nums: list) -> bool:
    return all([ i-1 in nums or i+1 in nums for i in nums])

3.回文
https://ceshiren.com/t/topic/19787/13

def palindrome(num):
    pal_list = []
    str_num = str(num)
    for l in range(2,len(str_num)+1):
        for start in range(len(str_num)-l+1):
            temp_num = str_num[start:start+l]
            if temp_num == temp_num[::-1] and (int(temp_num) not in pal_list) and (temp_num[0] != '0'):
                pal_list.append(int(temp_num))
        pal_list.sort()
    return pal_list

 assert palindrome(1221) == [22, 1221]
 assert palindrome(34322122) == [22, 212, 343, 22122]
 assert palindrome(1001331) == [33, 1001, 1331]
 assert palindrome(13598) == []

4.列表中移动0到列表末尾
https://ceshiren.com/t/topic/12939

def move_zeros(num_list):
    # 方式1
    # reverse 降序
    # return  sorted(num_list,reverse=True,key=bool)
    # 方式2
    # num_list.sort(reverse=True, key=bool) # 不能直接返回这个调用，直接打印这个返回None，得打印num_list
    # return num_list
    # 方式3
    for i in range(len(num_list)):
        if num_list[i] == 0:
            num_list.pop(i)
            num_list.append(0)
    return num_list

5.交替位二进制
https://ceshiren.com/t/topic/21775
bin()是将数字转为二进制

# 方式1：因为是交替的，所有肯定不存在 11或者00在里面
def binary_num(num):
    bin_num = bin(num)[2:]
    if '00' not in bin_num and '11' not in bin_num:
        return True
    return  False
#方式2：逐个比较，前一位和后一位相同，那就返回False
def binary_num(num):
    bin_num = bin(num)[2:]
    for i in range(len(bin_num)-1):
        if bin_num[i] == bin_num[i+1]:
            return False
    return True

6.单词前缀
https://ceshiren.com/t/topic/16552
sentence.split(‘xx’) 使用xx分隔句子sentence
word.startswith(‘xx’) xx是word的前缀么

def word_prefix(sentence:str, word:str)-> int:
    word_list = sentence.split()
    for i in range(len(word_list)):
        if word_list[i].startswith(word):
            return i+1
    return 0

zcx · 2023 年10 月 11 日 09:51

leetcode 哈希-两数之和
解法1：暴力破解

def solution_target(nums,target):
    for i in range(len(nums)):
        if target >= nums[i]:
            temp = target - nums[i]
            if temp in nums[i+1:]:
                index_num = nums[i+1:].index(temp)+i+1
                return [i,index_num]

解法2：hash

def twonums_hash(nums,target):
    idx = {}  #创建空的哈希表
    for index,value in enumerate(nums):
        if target-value in idx: # 这种方式只能是反着找到对应的索引，因为只有期望的两个数都存储到对应的hash表中才行
            return  [index,idx[target-value]]
        else:
            idx[value]  = index # 存入hash表，value为key,索引为值

python哈希

涉及到的遍历方法 enumerate()
这个函数的基本应用就是用来遍历一个集合对象，它在遍历的同时还可以得到当前元素的索引位置。

for index,value in enumerate(list):
    print(f'{index}:{value}')

https://www.jb51.net/article/261309.htm

zcx · 2023 年11 月 6 日 14:09

链表

链表反转

class ListNode:
    def __init__(self,val,next=None):
        self.val = val
        self.next = next
class LinkList:
    def __init__(self, list_node):
        self.head = ListNode(list_node[0])
        cur = self.head
        for num in list_node[1:]:
            new_node = ListNode(num)
            cur.next = new_node
            cur = new_node

    # 重新父类object的方法__str__
    def __str__(self):
        out = "LinkList: "
        cur = self.head
        while cur:
            out += f"{cur.val}->"
            cur = cur.next
        out += "null"
        return out

    def returnHead(self):
        return self.head

class Soultion:

    #方式1： 把原头节点后节点一个一个挪到前边
    def reverseList1(self,head):
        if head == None:
            return None
        old_head = head # 标记原本的头
        # temp = head #当前的头节点
        while old_head.next:
            next_node = old_head.next# 标记下一个要移动节点
            old_head.next = next_node.next # 旧的头指向下下个节点
            next_node.next = head
            head = next_node
        return head

    # 方式2： 指针调转
    # def reverseList2(self, head):
    #     pre = None
    #     while head:
    #         temp = head.next
    #         head.next = pre
    #         pre = head
    #         head = temp
    #     return pre


if __name__ == '__main__':
    list_node = [23, 6, 15]
    obj = LinkList(list_node)
    print(obj)
    head = obj.returnHead()
    head = Soultion().reverseList1(head)
    print(head.val)
    print(head.next.val)
    print(head.next.next.val)

zcx · 2023 年11 月 8 日 14:05

链表移除

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        while head:
            temp = head.next
            head.next = pre
            pre = head
            head = temp
        return pre

   def removeElements(self, head: Optional[ListNode], value: int) -> Optional[ListNode]:
        if head.val == value:
            head =head.next
            return head
        pre = head
        cur = head.next
        while cur:
            if value == cur.val:
                pre.next = cur.next
                return head
            pre = cur
            cur = cur.next
if __name__ == '__main__':
    list_node = [23, 6, 15]
    obj = LinkList(list_node)
    print(obj)
    head = obj.returnHead()
    head =Soultion().removeElements(head,value=15)
    print(head.val)
    print(head.next.val)

zcx · 2023 年11 月 21 日 07:03

动态规划

https://blog.csdn.net/zy_dreamer/article/details/131109312

DP Dynamic Programming
一种求解多阶段决策过程最优化问题的方法
在动态规划中，通常把原问题分解为相对简单的子问题，先求解子问题，再由子问题的解求解原问题的解。

核心思想：

1.把【原问题】分解为【若干重叠子问题】，每个子问题的求解过程都构成【阶段】。在完成一个阶段的计算之后，动态规划方法才会执行下个阶段的计算。
2.求解子问题过程中，按照【自顶向上】的记忆化搜索方法或者【自底向上】的递推方法求解【子问题】的解。把结果储存在表格中，当再次求解时，直接从表格里查询子问题解，避免大量重复计算。

例子：爬楼梯
假设你在爬楼梯，需要n阶你才能到达楼顶，每次你可以爬1或2个台阶，请问有多少种不同的方法
方法1-递归法
思路：爬到第n个台阶，那么只能从n-1或者n-2爬上来，那么n个台阶的方法数就是n-1和n-2个方法构成的。

def f(n):
    if n == 1 or n == 2:
        return n
    if n >= 3:
        return f(n-1) + f(n-2)

例子：背包问题

ms题集锦 大汇总