TLV 是一種簡單實用的數據組織方案，包括三個部分：類型（T）、長度（L）和值（V）。

TLV 是一種簡單實用的數據組織方案，包括三個部分：類型（T）、長度（L）和值（V）。

某業務某塊約定 TLV 規則如下：

• 碼流數據以字符串表達時，每字節用 2 位十六進制數字表達，其中 a-f 均小寫，單個空格分隔
• 碼流數據中，類型（T）佔 2 字節，長度（L）佔 4 字節，後續爲值（V）；類型與長度均爲大端序

解答要求

時間顯示：1000ms。內存限制：256MB

輸入

輸入爲單行字符串，包含若干單個空格分隔的 2 位十六進制數，如：

00 01 00 00 00 01 6f

• 用例涉及數據碼流字節長度範圍爲 [6,300]，即包含最多 300 個 2 位十六進制數
• 用例保證格式正確，無非法輸入

輸出

解碼後輸出成單行字符串，格式爲：

{T:<type>,L:<len>,V:<letter-cnt>}

其中：

• <type> 爲解析後的類型（T），十進制
• <len> 爲解析後的長度（L），十進制
• <letter-cnt> 爲 合法 內容（V）中，包含所有ascii碼爲英文字母的數量，忽略大小寫。

POWER_2_TO_8 = 256


def read_input():
    string_tlv = list(map(lambda x: int(x, 16), input().strip().split(" ")))
    return string_tlv


def tlv_output(tag, length, value):
    print("{T:%s,L:%s,V:%s}" % (tag, length, value))


def func():
    string_tlv = read_input()
    tag = string_tlv[0] * POWER_2_TO_8 + string_tlv[1]
    length = (string_tlv[5] + POWER_2_TO_8 * (
            string_tlv[4] + POWER_2_TO_8 * (string_tlv[3] + POWER_2_TO_8 * string_tlv[2])))
    value = 0
    index = 6
    if len(string_tlv) - 5 <= length:
        value = -1
    else:
        while index <= length + 5:
            if 65 <= string_tlv[index] <= 90 or 97 <= string_tlv[index] <= 122:
                value += 1
            index += 1

    tlv_output(tag, length, value)


if __name__ == "__main__":
    func()

 

我們不能把不相容的貨物裝在同一集裝箱裏運輸，如果氧化劑絕對不能跟易燃液體同箱，否則很容易造成爆炸或其他危險。現給一張不相容物品清單，及每一集裝箱貨物運輸清單。請你判斷每個集裝箱是否安全。

解答要求

時間限制：1000ms，內存限制：256MB

輸入

• 首航輸入兩個正整數：分別代表不相容貨物對的數量 N (0,10000]和集裝箱貨品清單的數量 M (0,100]
• 接下來 N 行每一行是一對不相容貨物編號；編號都是 5 位數，編號對之間是空格。
• 然後輸入 M 行，每一行包含一個集裝箱貨物總數[1,1000]與貨物編號明細。

輸出

對每箱貨物清單，判斷是否可以安全運輸；按照順序輸入，安全則輸出 Yes ，否則輸出No ，每行以換行結束。

def read_input():
    incompatible_num, container_num = map(int, input().strip().split(" "))
    incompatibility = list()
    containers = list()

    incompatible_num_temp = incompatible_num
    while incompatible_num_temp:
        __info = input().strip().split(" ")
        incompatibility.append(__info)
        incompatible_num_temp -= 1

    container_num_temp = container_num
    while container_num_temp:
        __info = input().strip().split(" ")
        containers.append(__info[1:])
        container_num_temp -= 1

    return incompatible_num, container_num, incompatibility, containers


def func():
    incompatible_num, container_num, incompatibility, containers = read_input()

    incompatibility_dict = {}

    for incompatibility_item in incompatibility:
        if not incompatibility_dict.get(incompatibility_item[0]):
            incompatibility_dict[incompatibility_item[0]] = []
        incompatibility_dict[incompatibility_item[0]].append(incompatibility_item[1])

    for container in containers:
        result = True
        for item in container:
            if not result:
                break

            if incompatibility_dict.get(item):
                for incompatibility_item in incompatibility_dict[item]:
                    if incompatibility_item in container:
                        result = False
                        break
        if result:
            print("Yes")
        else:
            print("No")


if __name__ == "__main__":
    func()

現有一樹形網絡，每個節點是一個設備，每個設備具有一個設備編號和一個管理容量值。

你的任務是：找出從根節點到葉節點的管理容量之和等於給定數值的所有路徑。

如下圖，橫線上的 2 位數是設備編號，橫線下的爲管理容量值。

 

 

解答要求

時間限制：1000ms，內存限制：256MB

輸入

• 第一行分別爲節點個數 N(<100)、非葉子節點的個數 M(<N)、給定的管理容量 S(<2^30)

• 第二行按節點編號順序給出 N 個節點的管理容量值；

• 最後 M 行，每行按以下格式給出

  ID K ID[1] ID[2] ... ID[K]

  其中 ID 是一個非葉節點的 2 位數編號，K 是其子節點的個數，後面 K 個數字是一系列子節點的編號

輸入中出現的數值均爲正整數

爲簡單起見，我們固定根節點的編號爲 00。

輸出

• 找出所有管理容量值爲 S 的路徑，並按非遞增序輸出。用例保證至少有一條路徑滿足要求
• 每條路徑佔一行，輸出從根節點到葉節點每個節點的管理容量。數字間以一個空格分隔。

行首尾不得有多餘空格

def read_input():
    node_num, non_leaf_node_num, target_capacity = map(int, input().split(" "))
    node_capacity = map(int, input().split(" "))

    node_relations = list()

    non_leaf_node_num_temp = non_leaf_node_num
    while non_leaf_node_num_temp:
        all_info = list(map(int, input().strip().split(" ")))
        __id = all_info[0]
        __childs = all_info[2:]
        __info = {'id': __id, 'childs': __childs}
        node_relations.append(__info)
        non_leaf_node_num_temp -= 1

    return node_num, non_leaf_node_num, target_capacity, node_capacity, node_relations


def find(node_id, node_capacity_list, node_relations_dict, target_capacity, path, path_result):
    path.append(node_capacity_list[node_id])
    new_path_result = path_result
    if not node_relations_dict.get(node_id) and sum(path) is target_capacity:
        new_path_result.append(path.copy())
    elif not node_relations_dict.get(node_id):
        pass
    else:
        for child_id in node_relations_dict.get(node_id):
            new_path_result = find(child_id, node_capacity_list, node_relations_dict, target_capacity, path, path_result)
    path.pop()
    return new_path_result


def func():
    node_num, non_leaf_node_num, target_capacity, node_capacity, node_relations = read_input()
    node_capacity_list = []
    for capacity in node_capacity:
        node_capacity_list.append(capacity)

    node_relations_dict = {}
    for relation in node_relations:
        node_relations_dict[relation.get("id")] = relation.get("childs")

    path_result = find(0, node_capacity_list, node_relations_dict, target_capacity, [], [])
    path_result.sort(reverse=True)

    for item in path_result:
        line_string = ""
        for sub_item in item:
            line_string += str(sub_item) + " "
        print(line_string[:-1])


if __name__ == "__main__":
    func()