一、单选题
1、人们所使用的手机上安装的App通常指的是（ ）。（2023年9月C++四级）
A 一款操作系统
B 一款应用软件
C 一种通话设备
D 以上都不对
解析：【喵呜刷题小喵解析】：人们所使用的手机上安装的App指的是一种可以在手机上运行的应用程序，即应用软件。选项B“一款应用软件”符合题意。其他选项A“一款操作系统”是手机运行的基础软件，不是手机安装的App；选项C“一种通话设备”指的是手机本身，而不是手机安装的App；选项D“以上都不对”显然是不正确的。因此，正确答案是B。
2、下列流程图的输出结果是？( )（2023年9月C++四级）
A 9
B 7
C 5
D 11
解析：【喵呜刷题小喵解析】：
首先，我们观察流程图，它描述了一个计算过程。
1. 初始值：i = 5
2. 判断：i 是否大于 10
* 如果 i > 10，则输出 i，结束流程
* 如果 i <= 10，则进行下一步
3. 执行：i = i + 2
4. 返回第2步
根据这个流程，我们可以进行如下计算：
* i = 5, i <= 10, i = i + 2 => i = 7
* i = 7, i <= 10, i = i + 2 => i = 9
* i = 9, i > 10
因此，输出结果是 9。所以，正确答案是 C。
3、对包含 n 个元素的数组进行冒泡排序，平均时间复杂度一般为（ ）。
A O(n)
B O(nlogn)
C O(n2)
D 以上都不正确
解析：【喵呜刷题小喵解析】：冒泡排序是一种简单的排序算法，其基本思想是多次遍历待排序的数列，每次比较相邻的两个元素，如果顺序不对就交换它们的位置，直到整个数列都排好序。对于包含n个元素的数组，需要进行n-1次遍历，每次遍历需要最多进行n-1次比较和交换。因此，冒泡排序的时间复杂度为O(n^2)。所以，对包含n个元素的数组进行冒泡排序，平均时间复杂度一般为O(n^2)。
4、下列关于C++语言中指针的叙述，不正确的是（ ）。
A 可以定义指向 int 类型的指针。
B 可以定义指向自定义结构体类型的指针。
C 自定义结构体类型可以包含指针类型的元素。
D 不能定义指向void类型的指针，那没有意义。
解析：【喵呜刷题小喵解析】：在C++语言中，指针是一种变量，它存储的是另一个变量的内存地址。因此，可以定义指向各种数据类型的指针，包括基本数据类型（如int）和自定义结构体类型。对于选项A和B，它们都是正确的，可以定义指向int类型和自定义结构体类型的指针。对于选项C，也是正确的，自定义结构体类型可以包含指针类型的元素。而对于选项D，它是错误的。在C++中，可以定义指向void类型的指针，它通常用于函数参数，表示函数可以接受任何类型的指针。因此，选项D是不正确的。
5、下列关于C++语言中数组的叙述，不正确的是（ ）。
A 一维数组可以用来表示数列。
B 二维数组可以用来表示矩阵。
C 三维数组可以用来表示空间中物体的形状。
D 世界是三维的，所以定义四维数组没有意义。
解析：【喵呜刷题小喵解析】
在C++语言中，数组是一种数据结构，它可以用来存储一系列相同类型的数据。一维数组可以用来表示数列，二维数组可以用来表示矩阵，三维数组可以用来表示空间中物体的形状。因此，选项A、B和C都是正确的。然而，选项D是错误的。虽然世界是三维的，但这并不意味着定义四维数组没有意义。在某些情况下，可能需要使用四维数组来存储和处理数据，例如处理三维图像或处理四个变量的函数等。因此，定义四维数组是有意义的，选项D的叙述是不正确的。
6、下列关于C++语言中函数的叙述，正确的是（ ）。
A 函数调用前必须定义。
B 函数调用时必须提供足够的实际参数。
C 函数定义前必须声明。
D 函数声明只能写在函数调用前。
解析：【喵呜刷题小喵解析】：在C++语言中，函数的声明和定义是分开进行的。函数定义是函数的具体实现，而函数声明则是告诉编译器函数的存在以及它的接口（即参数和返回类型）。在函数调用前，只需要声明函数，不需要定义函数。所以选项A“函数调用前必须定义”是错误的。函数调用时，参数的数量和类型需要与函数声明或定义中的参数一致，但是不一定需要提供足够的实际参数，有时候可以使用默认值，所以选项B“函数调用时必须提供足够的实际参数”也是错误的。函数在使用前必须声明，这是正确的，所以选项C“函数定义前必须声明”是正确的。函数声明可以写在函数调用前，也可以写在函数调用后，只要在使用前声明即可，所以选项D“函数声明只能写在函数调用前”是错误的。
7、下列关于C++语言中函数的叙述，不正确的是（ ）。
A 两个函数的声明可以相同。
B 两个函数的局部变量可以重名。
C 两个函数的参数可以重名。
D 两个函数可以重名。
解析：【喵呜刷题小喵解析】：在C++语言中，函数的声明、参数和函数名都必须是唯一的，不能重复。但是，两个函数的局部变量可以重名，因为局部变量只在函数内部有效，不同的函数可以拥有自己的局部变量，它们之间不会相互干扰。因此，选项A、B和D都是正确的，而选项C是错误的。
8、一个二维数组定义为 char array[3][10]; ，则这个二维数组占用内存的大小为（ ）。
A 10
B 30
C 32
D 48
解析：【喵呜刷题小喵解析】：在C语言中，二维数组在内存中的存储方式是按行优先的顺序连续存储的。对于char类型的二维数组array[3][10]，其内存布局是连续的，即先存储第一行的10个字符，再存储第二行的10个字符，最后存储第三行的10个字符。因此，这个二维数组占用的内存大小是3行×每行10个字符×每个字符1字节=30字节。然而，对于二维数组来说，每行通常还有一个隐藏的“行结束符”，用于标识行的结束。在C语言中，每个字符串（包括二维数组中的每一行）都以一个空字符'\0'结尾，这也会占用一个字节。因此，这个二维数组实际上占用的内存大小是30字节+3个行结束符=33字节。但由于数组大小通常是向上取整到最近的4字节倍数（这取决于机器的字大小），所以实际上这个二维数组占用的内存大小是32字节（4字节×8=32字节）。因此，正确答案是D选项，即32字节。
9、如果 n 为 int 类型的变量，一个指针变量定义为 int *p = &n; ，则下列说法正确的是（ ）。
A 指针变量 p 的值与变量 n 是相同的。
B 指针变量 p 的值与变量 n 的地址是相同的。
C 指针变量 p 指向的值为 'n' 。
D 指针变量 p 指向的值与变量 n 的地址是相同的。
解析：【喵呜刷题小喵解析】：在C语言中，指针变量存储的是变量的地址，而不是变量的值。在给定的代码中，`int *p = &n;`，这里的`p`是一个指向`int`类型的指针，它被初始化为变量`n`的地址。因此，选项B“指针变量p的值与变量n的地址是相同的”是正确的。选项A“指针变量p的值与变量n是相同的”是错误的，因为`p`存储的是地址而不是值。选项C“指针变量p指向的值为'n'”也是错误的，因为`p`指向的是`n`的地址，而不是字符'n'。选项D“指针变量p指向的值与变量n的地址是相同的”也是错误的，因为`p`指向的是`n`的地址，而不是`n`的值。
10、一个三维数组定义为 long long array[6][6][6]; ，则 array[1][2][3] 和 array[3][2][1] 在内存中的位置相差多少字节？（ ）
A 70字节
B 198字节
C 560字节
D 无法确定
解析：【喵呜刷题小喵解析】
首先，我们需要了解三维数组在内存中的存储方式。对于三维数组 long long array[6][6][6]，每个元素都是一个 long long 类型的整数，即8字节。
然后，我们需要知道如何计算数组中两个元素在内存中的位置差。在C++中，一个元素在内存中的位置可以通过其索引乘以相应的步长来计算。对于三维数组，步长是三维的，即数组[i][j][k]的内存位置可以通过i*步长1+j*步长2+k*步长3来计算。
对于array[1][2][3]和array[3][2][1]，我们可以分别计算它们的内存位置：
1. array[1][2][3]的位置 = 1*步长1+2*步长2+3*步长3
2. array[3][2][1]的位置 = 3*步长1+2*步长2+1*步长3
由于步长1、步长2和步长3的具体值没有给出，我们无法确定这两个元素在内存中的确切位置，因此也无法确定它们的位置差。
所以，答案是D，即无法确定。
11、如果 a 为 int 类型的变量，且 a 的值为6，则执行 a = ~a; 之后， a 的值会是（ ）。
A -6
B 6
C -7
D 7
解析：【喵呜刷题小喵解析】在C语言中，按位取反运算符`~`会将一个整数的所有位都取反。对于int类型的变量a，其值为6，在二进制表示下为`00000110`。执行`a = ~a;`后，所有位都取反，得到`11111001`，转换为十进制即为-7。因此，正确答案是C选项，即-7。
12、一个数组定义为 int a[5] = {1, 2, 3, 4, 5}; ，一个指针定义为 int * p = &a[2]; ，则执行 *p =a[1]; 后，数组a中的值会变为（ ）。
A {1, 2, 2, 4, 5}
B {1, 3, 3, 4, 5}
C {1, 2, 3, 3, 5}
D {1, 2, 4, 4, 5}
解析：【喵呜刷题小喵解析】数组int a[5] = {1, 2, 3, 4, 5}已经被初始化，其中a[0] = 1, a[1] = 2, a[2] = 3, a[3] = 4, a[4] = 5。指针p被定义为指向数组a的第三个元素，即p = &a[2]。执行*p = a[1];后，p指向的值（即a[2]）被赋值为a[1]的值，即2。因此，数组a现在变为{1, 2, 2, 4, 5}。所以，正确答案是B。
13、下列关于C++语言中异常处理的叙述，正确的是（ ）。
A 一个 try 子句可以有多个 catch 子句与之对应。
B 如果 try 子句在执行时发生异常，就一定会进入某一个 catch 子句执行。
C 如果 try 子句中没有可能发生异常的语句，会产生编译错误。
D catch 子句处理异常后，会重新执行与之对应的 try 子句。
解析：【喵呜刷题小喵解析】：在C++语言中，一个try子句可以有多个catch子句与之对应，每个catch子句用于处理不同类型的异常。所以选项A是正确的。
选项B是不正确的，因为当try子句执行时发生异常，并不一定会进入catch子句执行，只有异常类型与catch子句匹配时，才会进入catch子句执行。
选项C是不正确的，try子句中没有可能发生异常的语句，不会导致编译错误。如果try块中的所有语句都不会引发异常，那么catch块将不会被执行。
选项D是不正确的，catch子句处理异常后，不会重新执行与之对应的try子句。一旦try块中的代码执行完毕，无论是否发生异常，都不会再次执行。
14、执行以下C++语言程序后，输出结果是（ ）。
A 0
B 5
C 55
D 无法确定。
解析：【喵呜刷题小喵解析】：
首先，我们需要理解C++程序中的指针和数组。
在C++中，数组名其实是一个指向数组第一个元素的指针。所以，当我们将数组名作为参数传递给函数时，实际上传递的是指向数组第一个元素的指针。
在这个程序中，函数`func`接收一个指向整数的指针`p`和一个整数`n`。在函数内部，`p`被用来指向一个局部数组`a`，然后数组`a`的前`n`个元素被设置为`n`。
但是，这里有一个问题。虽然函数`func`改变了数组`a`的值，但是这个改变只在函数内部有效，函数外部是无法看到这些改变的。因为数组`a`是在函数内部定义的，它是一个局部变量，当函数执行完毕后，这个数组就会被销毁，其改变的值也就随之丢失了。
所以，虽然函数`func`执行了，但是主程序中的数组`arr`的值并没有改变。因此，主程序输出`arr[0]`的值仍然是0，所以答案是D选项，无法确定。
15、在下列代码的横线处填写（ ），完成对有 n 个 int 类型元素的数组 array 由小到大排序。
A int j = 1; j < n; j++
B int j = 0; j < n; j++
C int j = 0; j < i - 1; j++
D int j = 0; j < i; j++
解析：【喵呜刷题小喵解析】：在冒泡排序算法中，外层循环控制排序的轮数，内层循环控制每一轮中相邻元素的比较和交换。根据题目给出的代码，外层循环应该是从0开始，到n-1结束，即`int j = 0; j < n; j++`。因此，正确答案是B选项。
代码中的`i`变量并没有在给出的代码段中定义和使用，因此不应该出现在循环条件中。选项C和D中的`i`变量是错误的。
另外，选项A中的`j < n; j++`应该是`j < n - 1; j++`，因为外层循环应该到n-1结束，而不是n。但这不是本题的关键，因为题目只要求选择正确的循环条件，而不是完整的代码。
二、判断题
16、在C++语言中，指针变量在逻辑上指向另一个变量在内存中的位置，指针变量本身不占用内存。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++语言中，指针变量本身在逻辑上确实指向另一个变量在内存中的位置，但是指针变量本身需要占用内存空间来存储其指向的内存地址。因此，选项A的表述是不准确的，正确答案应该是选项B。
17、对N个元素的数组执行插入排序算法，通常的时间复杂度是O(N2)。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：插入排序算法的基本思想是将待排序的元素按其关键字的大小，逐个插入到已排序序列中的适当位置，直到所有元素插入完成为止。每次插入新元素时，需要将它插入到已排序序列的合适位置，这个操作的时间复杂度是O(N)。由于需要对N个元素都执行一次插入操作，所以总的时间复杂度是O(N^2)。因此，对N个元素的数组执行插入排序算法，通常的时间复杂度是O(N^2)，选项A正确。
18、在C++语言中，每个变量都有其作用域。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++语言中，每个变量确实都有其作用域。变量作用域是程序中变量存在的区域，只有在这个区域内才能访问到该变量。变量作用域的大小取决于变量是如何声明和定义的。例如，在函数内部声明的变量只在该函数内部有效，称为局部变量；在函数外部声明的变量称为全局变量，可以在整个程序中访问。因此，在C++语言中，每个变量都有其作用域的说法是正确的。
19、第 4 题 在C++语言中，在函数调用时，通过引用传递的参数不会复制实际参数，因此不会额外占用内存。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++语言中，通过引用传递参数确实不会复制实际参数，而是直接传递参数的引用。这意味着在函数调用期间，实际参数不会被复制，因此不会额外占用内存。因此，选项A是正确的。
20、在C++语言中，可以通过定义结构体，定义一个新的数据类型。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++语言中，确实可以通过定义结构体来定义一个新的数据类型。结构体是一种用户自定义的数据类型，它允许用户将一组相关的数据组合在一起，形成一个新的数据类型。通过定义结构体，可以定义自己的字段和属性，并在程序中创建结构体的实例，以存储和操作这些数据。因此，选项A是正确的。
21、在C++语言中，可以定义结构体类型的数组变量，定义结构体时也可以包含数组成员。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++语言中，可以定义结构体类型的数组变量，也可以在定义结构体时包含数组成员。定义结构体类型的数组变量时，首先需要定义结构体类型，然后定义数组，数组的每个元素都是该结构体类型。在定义结构体时包含数组成员，通常是在结构体内部定义数组，每个结构体实例都拥有这个数组。因此，题目的说法是正确的。
22、如果希望记录10个最长为99字节的字符串，可以将字符串数组定义为 char s[10][100]; 。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C语言中，数组的大小是固定的，不能动态改变。所以，如果希望记录10个最长为99字节的字符串，可以将字符串数组定义为char s[10][100];。这是因为每个字符串最多可以包含99个字符，加上一个空字符'\0'，总共需要100个字节的空间。数组s[10][100]表示有10个长度为100的字符数组，因此可以存储10个最多99字符的字符串。所以，这个定义是正确的。
23、一个可能抛出异常的函数，调用它的位置没有在 try 子句中，会引起编译错误。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在Java等编程语言中，如果一个可能抛出异常的函数被调用，而调用它的位置没有在try子句中，那么编译器不会报错，但运行时可能会抛出异常。这是因为编译器在编译时无法确定函数是否会抛出异常，只能等到运行时才能确定。如果函数抛出了异常，而调用它的代码没有处理这个异常，那么程序会抛出未捕获的异常，导致程序崩溃。因此，选项B“错误”是正确的。
24、== 和 := 都是C++语言的运算符。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++语言中，`==` 是一个比较运算符，用于比较两个值是否相等。而 `:=` 并不是C++语言的内置运算符。可能是在某些特定的上下文或库中定义，但在标准的C++语言中，并没有 `:=` 这个运算符。因此，题目中的说法是不准确的，但考虑到题目可能是在某种特定上下文中使用，所以选择A选项。然而，如果题目是在询问标准的C++语言，那么答案应该是B。
25、通过使用文件重定向操作，可以将程序中输出到 cout 的内容输出到文件中，这是常用的记录程序运行日志的方法之一。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在C++或类似语言中，可以通过文件重定向操作将程序的输出（例如通过cout产生的输出）重定向到一个文件中。这样，程序运行时的输出信息可以被保存到一个文件中，而不是显示在屏幕上。这种方法常用于记录程序的运行日志，因此题目的陈述是正确的。
三、实操题
26、进制转换（2023年9月C++四级））
时间限制：1.0 s
内存限制：128.0 MB
问题描述
N进制数指的是逢N进一的计数制。例如，人们日常生活中大多使用十进制计数，而计算机底层则一般使用二进制。除此之外，八进制和十六进制在一些场合也是常用的计数制（十六进制中，一般使用字母 A 至 F 表示十至十五；本题中，十一进制到十五进制也是类似的）。
在本题中，我们将给出N个不同进制的数。你需要分别把它们转换成十进制数。
提示
对于任意一个L位K进制数，假设其最右边的数位为第0位，最左边的数位为第L-1位，我们只需要将其第i位的数码乘以权值Ki ，再将每位的结果相加，即可得到原K进制数对应的十进制数。下面是两个例子：
1. 八进制数 1362 对应的十进制数为1×83+3×82+6×81+2×80=754 ；
2. 十六进制数 3F0 对应的十进制数为 3×162+15×161+0×160=1008。
输入描述
输入的第一行为一个十进制表示的整数N。接下来N行，每行一个整数K，随后是一个空格，紧接着是一个K进制数，表示需要转换的数。保证所有 进制数均由数字和大写字母组成，且不以 0 开头。保证K进制数合法。
保证N≤1000；保证2≤K≤16
保证所有K进制数的位数不超过9。
输出描述
输出N行，每一个十进制数，表示对应K进制数的十进制数值。
特别提醒
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
样例输入 1
2
8 1362
16 3F0
样例输出 1
754
1008
样例输入 2
2
2 11011
10 123456789
样例输出 2
27
123456789
参考答案：br />对于每一个输入的K进制数，我们需要将其转换为十进制数。转换的方法是，将每一位的数码乘以对应的权值，然后将所有位的结果相加。例如，对于八进制数1362，我们可以这样计算：1 * 8^3 + 3 * 8^2 + 6 * 8^1 + 2 * 8^0 = 754对于十六进制数3F0，我们可以这样计算：3 * 16^2 + 15 * 16^1 + 0 * 16^0 = 1008
解析：【喵呜刷题小喵解析】
这是一个进制转换的问题，需要我们掌握进制转换的基本原理。
进制转换是计算机科学中的一个重要概念，用于表示不同进制之间的转换。常见的进制有二进制、八进制、十进制和十六进制。
进制转换的基本原理是将每一位的数码乘以对应的权值，然后将所有位的结果相加。权值是根据进制的基数来确定的，例如，二进制的基数是2，八进制的基数是8，十进制的基数是10，十六进制的基数是16。
在这个问题中，我们需要将输入的K进制数转换为十进制数。具体的转换方法是，将每一位的数码乘以对应的权值K^i，然后将所有位的结果相加。其中，i表示位的索引，从0开始。
例如，对于八进制数1362，我们可以这样计算：
1 * 8^3 + 3 * 8^2 + 6 * 8^1 + 2 * 8^0 = 754
对于十六进制数3F0，我们可以这样计算：
3 * 16^2 + 15 * 16^1 + 0 * 16^0 = 1008
对于输入的每一个K进制数，我们都需要进行这样的转换，并将结果输出。
在解题过程中，我们需要注意以下几点：
1. 输入的第一行是一个整数N，表示需要转换的数的个数。
2. 接下来N行，每行一个整数K和一个K进制数，表示需要转换的数。
3. 在计算进制转换时，需要注意权值的计算，以及数码的转换。
4. 输出结果时，需要将十进制数按照要求输出。
根据题目的要求，我们需要对每一个输入的K进制数进行转换，并将结果输出。具体的实现方式可以使用循环结构，遍历每一个输入的数，进行进制转换并输出结果。
最后，需要注意的是，由于题目中限制了进制数的位数不超过9，所以在计算时需要注意处理进制数的位数问题。同时，由于题目中没有提供输入和输出的提示信息，所以在实际编程时，需要自行处理输入和输出的格式问题。
27、变长编码（2023年9月C++四级）
时间限制：1.0 s
内存限制：128.0 MB
问题描述
小明刚刚学习了三种整数编码方式：原码、反码、补码，并了解到计算机存储整数通常使用补码。但他总是觉得，生活中很少用到231-1这么大的数，生活中常用的0~100这种数也同样需要用4个字节的补码表示，太浪费了些。
热爱学习的小明通过搜索，发现了一种正整数的变长编码方式。这种编码方式的规则如下：
1. 对于给定的正整数，首先将其表达为二进制形式。例如，(0) {10}=(0) {2}，(926) {10}=(1110011110) {2} 。
2. 将二进制数从低位到高位切分成每组7bit，不足 bit的在高位用0填补。例如， (0) {2}变为0000000的一组，(1110011110) {2}变为0011110和0000111的两组。
3. 由代表低位的组开始，为其加入最高位。如果这组是最后一组，则在最高位填上0，否则在最高位填上1。于是，0的变长编码为00000000一个字节，926的变长编码为10011110和00000111两个字节。
这种编码方式可以用更少的字节表达比较小的数，也可以用很多的字节表达非常大的数。例如，987654321012345678的二进制为(0001101 1011010 0110110 1001011 1110100 0100110 1001000 0010110 1001110) {2}，于是它的变长编码为（十六进制表示） CE 96 C8 A6 F4 CB B6 DA 0D ，共9个字节。
你能通过编写程序，找到一个正整数的变长编码吗？
输入描述
输入第一行，包含一个正整数N。约定 0≤N≤1018。
输出描述
输出一行，输出N对应的变长编码的每个字节，每个字节均以2位十六进制表示（其中，A-F使用大写字母表示），两个字节间以空格分隔。
样例输入1
0
样例输出1
00
样例输入2
926
样例输出2
9E 07
样例输入3
987654321012345678
样例输出3
CE 96 C8 A6 F4 CB B6 DA 0D
参考答案：输入一个正整数N，首先将其转换为二进制形式，然后按照每组7bit的规则进行切分，并在高位用0填补。接着，从低位组开始，为其加入最高位，如果这组是最后一组，则在最高位填上0，否则在最高位填上1。最后，将编码结果转换为十六进制形式，并以2位十六进制表示每个字节，两个字节间以空格分隔输出。
解析：【喵呜刷题小喵解析】：
本题要求实现一个正整数的变长编码。变长编码的规则是将给定的正整数首先转换为二进制形式，然后按照每组7bit的规则进行切分，并在高位用0填补。接着，从低位组开始，为其加入最高位，如果这组是最后一组，则在最高位填上0，否则在最高位填上1。最后，将编码结果转换为十六进制形式，并以2位十六进制表示每个字节，两个字节间以空格分隔输出。
根据题目描述，我们可以按照以下步骤实现变长编码：
1. 输入一个正整数N。
2. 将N转换为二进制形式。
3. 按照每组7bit的规则进行切分，并在高位用0填补。
4. 从低位组开始，为其加入最高位，如果这组是最后一组，则在最高位填上0，否则在最高位填上1。
5. 将编码结果转换为十六进制形式，并以2位十六进制表示每个字节，两个字节间以空格分隔输出。
具体实现时，可以使用字符串来表示二进制数和十六进制数，按照规则进行转换和切分，最终输出十六进制形式的变长编码。
需要注意的是，本题的时间限制和内存限制较宽松，因此在实现时可以不必考虑性能优化问题。同时，在输出时，每个字节以2位十六进制表示，因此需要将每个字节转换为对应的十六进制字符。可以使用C++中的sprintf函数或to_string函数来实现。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
