字节跳动：笔试题（20190908）

被看到最多次的机器人

设置一个全0的跟踪列表，依次遍历序列找出它当前可以看到的第一个机器人，在其对应的跟踪列表的元素值加1。

def most_see_count(n, seq):
    if not seq and len(seq) < 2:
        return 0
    res = [0] * n
    for si in range(1, n):
        for sj in range(si-1, -1, -1):
            if seq[sj] >= seq[si]:
                res[sj] += 1
                break
    # print(res)
    if max(res) == 0:
        return 0
    return seq[res.index(max(res))]


if __name__ == '__main__':
    n = int(input().strip())
    seq = list(map(int, input().strip().split()))
    res = most_see_count(n, seq)
    print(res)

'''
7
3 4 10 7 4 6 2
'''

水桶盛水

没思路。

def water(seq):
    pass


if __name__ == '__main__':
    seq = list(map(int, input().strip().split()))
    num = int(input().strip())
    res = water(seq)
    print(res)

'''
3 5 8
4
'''

小Q的方块游戏

双标志位法：第一个flag用来区别是向左还是向右，第二个标志位conf用来判断是否方向<或>是连续的。

def game_score(seq):
    if not seq:
        return 0
    values = seq[:]
    res = 0
    idx, flag = 0, True     # r
    conf = False
    while values:
        if idx < 0 or idx > len(values) - 1:
            break
        vu = values[idx]
        if vu == '<' or vu == '>':
            if conf:
                values[idx] = '*'
                values.remove('*')
                if not flag:
                    idx -= 1
            else:
                conf = True
                if vu == '<':
                    flag = False
                    idx -= 1
                else:
                    flag = True
                    idx += 1
        else:
            pre = idx
            if values[pre] == 0:
                values.remove(0)
                if not flag:
                    idx -= 1
            else:
                if flag:
                    res += vu
                    idx += 1
                else:
                    res += vu
                    idx -= 1
                conf = False
                values[pre] -= 1
        # print(idx, values, res)
    return res


if __name__ == '__main__':
    m, n, q = list(map(int, input().strip().split()))
    seq = list(input().strip().split())
    for si in range(m):
        su = seq[si]
        if su.isdigit():
            seq[si] = int(su)
    for _ in range(q):
        left, right = list(map(int, input().strip().split()))
        res = game_score(seq[left-1:right])
        print(res)

'''
6 10 3
> 2 2 < > 3
1 6
2 4
4 6
'''

解码问题

动态规划，每一次有两种可能：当前的值作为一个值或者与紧跟后面的一个值成为一个整体。为了设置一个全局变量作为接纳容器，选择建立类，在类的成员变量中定义。

import string


class Solution:
    def __init__(self):
        self.res = None
        self.values = {vk: vu for vk, vu in zip(range(1, 27), string.ascii_uppercase)}

    def decode_problem(self, seq):
        self.find(seq, [])
        return self.res

    def find(self, source, target):
        # print('find', source, target)
        if not source:
            if self.res is None:
                self.res = []
            self.res.append(''.join(target))
            return
        if source[0] != 0:
            tu = target[:]
            tu.append(self.values[source[0]])
            self.find(source[1:], tu)
        if len(source) > 1 and source[0] in [1, 2] and source[:2] < [2, 7]:
            tu = target[:]
            tu.append(self.values[source[0]*10+source[1]])
            self.find(source[2:], tu)


if __name__ == '__main__':
    seq = list(map(int, list(input().strip())))
    res = Solution().decode_problem(seq)
    res.sort()
    for ru in res:
        print(ru)

'''
12
'''

（最近更新：2019年09月14日）