网易雷火笔试5题个人思路

其实我题刷的不多全靠底力2333，而且用的Python所以思路可能有些清奇。。最终100 100 70 50 92

第一题，模拟windows窗口点击，用链表的思想来做，不过我懒得定义链表类所以直接用列表表示了[窗口坐标信息, 下一窗口, 窗口id]；每次点击从链表头开始检查，当鼠标坐标在窗口范围内就把当前节点插入头节点中

def main():
    n, m = [int(num) for num in input().split()]

    # window node: [coord: list, next_window: window_node, id: int]
    head_window = [None, None, 0]
    for i in range(n):
        head_window[1] = [[int(coord) for coord in input().split()], head_window[1], i + 1]

    def move_top(prev, node):
        prev[1] = node[1]
        node[1] = head_window[1]
        head_window[1] = node

    def check_point(x, y, node):
        if node[0][0] <= x <= node[0][0] + node[0][2] and node[0][1] <= y <= node[0][1] + node[0][3]:
            return True
        return False

    for _ in range(m):
        x, y = [int(coord) for coord in input().split()]
        prev = head_window
        node = head_window[1]
        while node:
            if check_point(x, y, node):
                print(node[2])
                move_top(prev, node)
                break
            prev = node
            node = node[1]
        else:
            print(-1)

if __name__ == '__main__':
    main()

第二题，题目描述就不详细说了，我的做法是把每层的边界同样看成节点：
第一层[0/1, 1/1, 1/0]
第二层[0/1, 1/2, 1/1, 2/1, 1/0]
第三层[0/1, 1/3, 1/2, 2/3, 1/1, 3/2, 2/1, 3/1, 1/0]
实际存在的节点为每层奇数index的节点，而且偶数index节点就是上一层的index/2；所以直接用这么递推每一层下去就行，反正最多12层不超过10000节点，复杂度不会太大（当然也有优化方法，不过这样就能AC）

def main():
    p, q = [int(num) for num in input().split()]
    if p == 1 and q == 1:
        print(1, 1)
        return
    up_layer = [0, 1, 1]
    down_layer = [1, 1, 0]
    depth = 1

    while True:
        depth += 1
        new_up_layer = list()
        new_down_layer = list()
        for i in range(len(up_layer) * 2 - 1):
            if i % 2:
                up = up_layer[i // 2] + up_layer[i // 2 + 1]
                down = down_layer[i // 2] + down_layer[i // 2 + 1]
            else:
                up = up_layer[i // 2]
                down = down_layer[i // 2]
            if up == p and down == q:
                print(depth, (i + 1) // 2)
                return
            new_up_layer.append(up)
            new_down_layer.append(down)
        up_layer = new_up_layer
        down_layer = new_down_layer


if __name__ == '__main__':
    main()

第三题，就是转换字符串之后按部就班的去一个个检查就行，检查过程写的很丑就不发了，实际上按题意写就好，就写下十六进制utf8编码转字符串的过程：

code = input()
if len(code) % 2:
    code = '0' + code
words = bytes([int(code[i: i + 2], base=16) for i in range(0, len(code), 2)]).decode("utf-8")

另外，判断英文字符我是靠ord(character)<0x1000计算的，试了下实际上超过0x1000也有不少不是宽字符的，不过先这样吧。
ps：这题查错尼玛用了一个点，最后才发现是##没有考虑，改了之后最终70%

第四题，一道博弈题，没怎么考虑直接暴力dp，能50%，等待大佬给出最优解

    n = int(input())
    nums = [int(num) for num in input().split()]
    log = dict()

    def catch(o_last, last, start, end):
        '''
        计算自己和对手的最高得分
        :param o_last: 对手到目前决策为止的得分
        :param last: 自己到目前决策为止的得分
        :param start: 剩下nums的起始位置
        :param end: 结束位置
        :return: 自己的最高得分，对手的最高得分
        '''
        if start == end:
            return abs(nums[start] - last), 0
        if (o_last, last, start, end) in log:
            return log[(o_last, last, start, end)]

        # 如果此时取出起始位置的数字，计算自己的得分
        start_scores = catch(nums[start], o_last, start + 1, end)
        start_score = start_scores[1] + abs(nums[start] - last)

        # 去除最后位置的数字，计算自己得分
        end_scores = catch(nums[end], o_last, start, end - 1)
        end_score = end_scores[1] + abs(nums[end] - last)

        # 取最优解，存入log
        log[(o_last, last, start, end)] = (start_score, start_scores[0]) if start_score >= end_score else (end_score, end_scores[0])
        return log[(o_last, last, start, end)]

    result = catch(0, 0, 0, n - 1)
    print(result[0], result[1])


if __name__ == '__main__':
    main()

第五题，因为完全不会反编译，而且也忘了python怎么调可执行文件，而且只剩一刻钟时间，所以干脆直接取十个点用matplotlib画了张图看下图像啥样（有点像调和函数，并没啥卵用），然后直接用numpy多项式拟合算参数，不知道会不会被怼

>>> x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
>>> y = [3.061648, 2.914361, 2.534662, 1.943862, 1.260162, 0.698658, 0.571330, 1.287054, 3.351591]
>>> np.polyfit(x, y, deg=4)
array([ 40.37096445, -36.81894658,   0.37797503,  3.0520995 ])

然后直接代入，args就是刚才算出的参数，92%通过时真的惊了一下，本来还只是想死马当活马医的

def func(x, args):
    result = 0
    for i, arg in enumerate(args[::-1]):
        result += arg * (x ** i)
    return result

其实要是会os.system调用的话干脆直接从0-1生成x然后去存下对应的y值，反正也就六位数空间占用应该够用2333
哪位要是能把题目描述补全就万分感谢了。。