[求职笔试]20210703笔试

今天某司笔试，20道选择题，5道算法编程题

编程题

笔试题第一题：

复原IP地址

class Solution(object):
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        #划分4段
        SEG_COUNT = 4
        ans = list()
        segments = [0] * SEG_COUNT
        def dfs(segId, segStart):
            #如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
            if segId == SEG_COUNT:
                if segStart == len(s):
                    ipAdd = ".".join(str(seg) for seg in segments)
                    ans.append(ipAdd)
                return
            
            # 如果还没有找到 4 段 IP 地址就已经遍历完了字符串，那么提前回溯
            if segStart == len(s):
                return

            # 由于不能有前导零，如果当前数字为 0，那么这一段 IP 地址只能为 0
            if s[segStart] == "0":
                segments[segId] = 0
                dfs(segId + 1, segStart + 1)

            # 一般情况，枚举每一种可能性并递归
            addr = 0
            for segEnd in range(segStart, len(s)):
                addr = addr * 10 + (ord(s[segEnd]) - ord("0"))
                if 0 < addr <= 0xFF:
                    segments[segId] = addr
                    dfs(segId + 1, segEnd + 1)
                else:
                    break

        dfs(0, 0)
        return ans

接雨水

双指针

class Solution:
    def trap(self, height: List[int]) -> int:
        # 边界条件
        if not height: return 0
        n = len(height)

        left,right = 0, n - 1  # 分别位于输入数组的两端
        maxleft,maxright = height[0],height[n - 1]
        ans = 0

        while left <= right:
            maxleft = max(height[left],maxleft)
            maxright = max(height[right],maxright)
            if maxleft < maxright:
                ans += maxleft - height[left]
                left += 1
            else:
                ans += maxright - height[right]
                right -= 1

        return ans

搜索二维矩阵是否存在目标值

class Solution(object):
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        M, N = len(matrix), len(matrix[0])
        left, right = 0, M * N - 1
        #两次二分查找
        while left <= right:
            mid = left + (right - left) // 2
            cur = matrix[mid // N][mid % N]
            if cur == target:
                return True
            elif cur < target:
                left = mid + 1
            else:
                right = mid - 1
        return False

比较版本号

class Solution(object):
    def compareVersion(self, version1, version2):
        """
        :type version1: str
        :type version2: str
        :rtype: int
        """

        nums1 = version1.split('.')
        nums2 = version2.split('.')
        n1, n2 = len(nums1), len(nums2)
        
        # 比较版本号。
        for i in range(max(n1, n2)):
            #短的版本号用0填充
            #比如1.12与1.12.1比较
            #1.12->1.12.0
            i1 = int(nums1[i]) if i < n1 else 0
            i2 = int(nums2[i]) if i < n2 else 0
            if i1 != i2:
                return 1 if i1 > i2 else -1
        
        # 其余的版本号都相等
        return 0 

判断点到三角形最短距离

1. 判断点在三角形区域外
2. 计算到三条边的最短距离
   通过叉积可以判断点是否在三角形内。锐角叉积为正，钝角叉积为负，直角叉积为0。
   a · b = |a| × |b| × cos(θ)
   也可以写作
   $$a\cdot b=x_a\times x_b+y_a\times y_b$$
   
   PS：极其啰嗦

import math
triangle=[[1,2],[3,4],[4,6]]
p = [3,4.1]

def shortest(triangle, p):
    
    [A, B, C]=triangle
    P=p
    #判断是否在定点上,
    #顶点上距离为0
    for dot in triangle:
        if p==dot:
            return 0
    #判断是否在三角形内
    [ap, bp, cp]=[[A[0]-P[0], A[1]-P[1]],
                  [B[0]-P[0], B[1]-P[1]],
                  [C[0]-P[0], C[1]-P[1]]] 

    [ab, bc, ca]=[[A[0]-B[0], A[1]-B[1]],
                  [B[0]-C[0], B[1]-C[1]],
                  [C[0]-A[0], C[1]-A[1]]] 
    #判断APxAB，BPxBC， CPxCA三个叉积是否同向
    #直角叉积为0，舍去。判断剩下的叉积是否同向
    #在定点叉积也为0.
    summ = 1
    for io,ip in zip([ap, bp, cp], [ab, bc, ca]):
        product = io[0]*ip[0]+io[1]*ip[1]
        if product == 0:
            continue
        summ *= product

    #在三角形内
    if summ>0:
        return 0

    #在三角形外
    #计算距离
    #d = abs((Ax+By+C)/sqrt(A**2+B**2))
    def get_distance(a, b, p):
        k = (b[1]-a[1])/(b[0]-a[0])
        # kx-y+b = 0
        b0 = a[1] - k*a[0]

        d = abs((k*p[0]-p[1]+b0)/math.sqrt(k**2+1))
        return d
    d1 = get_distance(A, B, p)
    d2 = get_distance(B, C, p)
    d3 = get_distance(C, A, p)
    shortest_distance = 0
    #取最短距离
    for d in [d1, d2, d3]:
        if shortest_distance<d:
            shortest_distance=d
    return shortest_distance
shortest(triangle, p)  

选择题

1. 彩色图片占多少内存？
   现在假如有一个图片是600*800的，文件大小100KB。

   图片内存大小的计算公式是 ：图片高度 * 图片宽度 * 一个像素占用的字节数，也就是 600 * 800 * 4 byte = 1875KB = 1.83M

2. 提及了线程和进程的区别？
   其中的题点，同一进程的多个线程可以共享资源和内存。所以线程不具备独立的虚拟地址空间

3. 系统不发生死锁的最小资源数？

    	某系统中有3个并发进程，都需要同类资源4 个，试问该系统不会发生死锁的最少资源数是10个。
   

   三个进程，都需要同类资源四个，当有10个这样的资源的时候，无论你怎么分配都一定先有一个满足了需要4个资源的条件，他先跑完，就可以释放资源给其他进程了，如果少一个，也就是九个资源，有可能是（3，3，3）,这样就刚好这三个进程都跑不动。。

4. JSON的数据格式

5. Word2vec词向量
   题点在于Word2vec是无监督学习。