深度解析华为OD机试——TLV编码的解析及其实现（C++/Java/Python/JavaScript）

最新推荐文章于 2024-11-03 17:10:59 发布

m0_57781768

最新推荐文章于 2024-11-03 17:10:59 发布

阅读量1.1k

点赞数 23

文章标签：华为od c++ java

本文链接：https://blog.csdn.net/m0_57781768/article/details/142702139

版权

深度解析华为OD机试——TLV编码的解析及其实现（C++/Java/Python/JavaScript）

在华为OD（Online Development）机试中，TLV编码问题是一个常见的考题。这种题目不仅考察考生对编码格式的理解，还对编程语言的灵活使用提出了要求。本文将结合C++、Java、Python和JavaScript的实际代码示例，详细讲解TLV编码的解码过程，深入分析每一行代码的实现细节，并提供优化建议和解题策略。同时，文章将关注如何避免代码查重和在实际机考中的常见问题，帮助考生更好地应对华为OD考试。

TLV编码解析详解

什么是TLV编码？

TLV编码是一种广泛用于通信协议和数据交换的编码方式。TLV的含义是 Tag（标签）、Length（长度） 和 Value（值），即一段码流是按照 Tag Length Value 的顺序进行排列的。

Tag：唯一标识某个信元，它是一个固定长度的字节（在本题中为1字节）。
Length：描述信元的值的长度，通常为固定长度的字节。在本题中，Length 是2个字节，采用 小端序 编码。
Value：信元的实际值，它的长度由 Length 字段指定。

问题描述

给定一个包含TLV编码的十六进制码流，以及需要解码的某个信元的Tag，要求解析出该信元的Value，并输出为十六进制格式。

输入描述

输入的第一行为待解码的信元Tag。
输入的第二行为一段十六进制格式的码流，字节之间以空格分隔。

输出描述

输出为十六进制字符串，表示待解码信元的Value，输出时字母需大写。

示例

输入：

31
32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC

输出：

32 33

题目分析

在解题前，我们需要理解以下几个关键点：

Tag 是1字节，表示信元的标识符。
Length 是2个字节，采用小端序（低字节在前），表示信元的Value长度。
Value 的长度是由 Length 字段指定的字节数。

在这道题中，给定了一段TLV格式的码流和一个待解码的Tag，目标是从码流中找到该Tag对应的Value。需要注意的是，Tag是唯一的，不会在同一段码流中重复出现。

ACM输入输出模式

华为OD机试使用的是ACM输入输出模式。不同于LeetCode等平台，ACM模式下需要手动编写输入输出函数。因此，提前熟悉这种输入输出模式是非常有必要的。在本题中，我们将在各个语言的实现中遵循这种模式。

代码实现与详细注释

接下来，我们将分别使用C++、JavaScript、Java和Python来实现该题，并对每一行代码进行详细的注释和分析。

C++ 实现与详细注释

C++是华为OD机试中常用的编程语言之一。我们首先来实现TLV解码的C++版本。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 输入待解码信元的Tag
    string tag;
    cin >> tag;

    // 输入16进制码流
    string tmp;
    vector<string> vec;
    
    // 将码流以空格分隔后存入数组
    while (cin >> tmp) {
        vec.push_back(tmp);  // 每个字节存储为字符串
        if (cin.get() == '\n') break;  // 读取到换行符时，停止输入
    }

    // 遍历整个码流，寻找匹配的Tag
    for (int i = 0; i < vec.size();) {
        string t = vec[i];  // 当前信元的Tag
        // 解析长度，注意小端序：低字节在前
        int len = stoi(vec[i + 1]) + 16 * stoi(vec[i + 2]);

        // 如果找到了匹配的Tag
        if (t == tag) {
            // 输出对应长度的Value
            for (int j = i + 3; j < i + 3 + len; j++) {
                cout << vec[j] << " ";
            }
            cout << endl;  // 输出结果后换行
            break;
        } else {
            // 如果Tag不匹配，则跳过当前信元
            i = i + 2 + len + 1;
        }
    }
    return 0;
}

C++代码解析

输入部分：首先，我们通过 cin >> tag 读取待解码的信元Tag。随后，将码流按字节读取并存储到一个 vector 容器中。读取时，我们通过 cin.get() 判断是否读取到了换行符，以结束输入。
解析码流：在主循环中，我们逐一检查每个信元的Tag。对于每个信元，首先从 vec[i] 获取当前的Tag，然后从 vec[i+1] 和 vec[i+2] 解析Length字段，注意这是小端序格式，需要进行字节顺序的调整。
匹配Tag并输出Value：如果找到了匹配的Tag，则根据解析出的长度字段输出对应的Value部分。如果Tag不匹配，则跳过当前信元，继续检查下一个信元。

JavaScript 实现与详细注释

JavaScript在前端开发中十分流行，但也常用于机试中。接下来是JavaScript的实现。

const readline = require('readline');

// 创建接口读取输入输出
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// 读取输入的Tag
rl.on('line', (tag) => {
  rl.on('line', (line) => {
    // 将码流按空格分割
    const hexArray = line.split(" ");
    
    let index = 0;
    while (index < hexArray.length) {
      // 解析Length字段（小端序）
      const length = parseInt(hexArray[index + 2] + hexArray[index + 1], 16);
      
      // 如果找到匹配的Tag
      if (hexArray[index] === tag) {
        const sb = [];
        
        // 提取对应长度的Value
        for (let i = index + 3; i < index + 3 + length; i++) {
          sb.push(hexArray[i]);
        }
        
        // 输出Value，并转换为大写
        console.log(sb.join(" ").toUpperCase().trim());
        break;
      } else {
        // 跳过当前信元
        index += (2 + length + 1);
      }
    }
    
    rl.close();  // 关闭输入输出流
  });
});

JavaScript代码解析

输入部分：通过 readline 接口创建输入输出流，用于读取用户的输入。在这里，首先读取待解码的Tag，然后读取十六进制码流，并将码流按照空格分割成数组。
解析码流：使用 parseInt 将 Length 字段从小端序的两个字节组合并解析为十六进制数。
匹配Tag并输出Value：通过 join() 方法将数组中的Value部分拼接成字符串，并使用 toUpperCase() 将其转换为大写输出。

Java 实现与详细注释

Java作为一门高效且安全的编程语言，在机试中也经常被使用。下面是Java的实现。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        // 输入待解码信元的Tag
        String tag = sc.nextLine();
        
        // 输入16进制码流
        String line = sc.nextLine();
        
        // 将16进制码流按空格分割成字符串数组
        String[] hexArray = line.split(" ");
        
        int index = 0;
        while (index < hexArray.length) {
            // 获取当前信元的长度
            int length = Integer.parseInt(hexArray[index + 2] + hexArray[index + 1], 16);
            
            // 如果当前信元的Tag与待解码信元的Tag相同
            if (hexArray[index].equals(tag)) {
                StringBuilder sb = new StringBuilder();
                
                // 将当前信元的Value拼接到StringBuilder中
                for (int i = index + 3; i

 < index + 3 + length; i++) {
                    sb.append(hexArray[i]).append(" ");
                }
                
                // 输出待解码信元的Value，转换为大写并去除首尾空格
                System.out.println(sb.toString().toUpperCase().trim());
                break;
            } else {
                // 跳过当前信元
                index += (2 + length + 1);
            }
        }
    }
}

Java代码解析

输入部分：通过 Scanner 类读取输入，首先获取待解码的Tag，然后读取码流并将其按空格分割为字符串数组。
解析码流：使用 Integer.parseInt() 解析小端序的 Length 字段，得到信元的长度。
匹配Tag并输出Value：如果找到匹配的Tag，将对应的Value部分拼接成字符串，并输出为大写。

Python 实现与详细注释

Python是一门非常适合快速开发和算法题解的语言，代码简洁易读。以下是Python的实现。

def get_length(length_str):
    # 将16进制的长度字符串转换为整数
    return int(length_str, 16)

def main():
    # 输入待解码的Tag
    tag = input().strip()
    # 输入16进制码流
    line = input().strip()
    
    # 将码流按空格分割为数组
    hex_array = line.split(" ")

    index = 0
    # 遍历码流数组
    while index < len(hex_array):
        # 解析当前信元的长度（小端序）
        length = get_length(hex_array[index + 2] + hex_array[index + 1])

        # 匹配Tag
        if hex_array[index] == tag:
            sb = []
            # 将对应长度的Value加入列表
            for i in range(index + 3, index + 3 + length):
                sb.append(hex_array[i])
            # 输出结果，并转换为大写
            print(" ".join(sb).upper().strip())
            break
        else:
            # 跳过当前信元
            index += (2 + length + 1)

if __name__ == "__main__":
    main()