数组按二进制比特排序

2026 华为OD机试真题 6月17日华为OD上机新系统考试真题 200 分题型

点击查看华为 OD 机试真题完整目录：2026最新华为OD机试新系统卷 + 双机位C卷 真题题库目录｜全覆盖题库 + 逐点算法考点详解

题目描述

给定两个 int 数组，数据数组（一维）和操作数组（二维）：

• 数据数组：存放待操作的整数；
• 操作数组：每个元素为包含两个 int 的一维数组，这两个 int 数字指定当前需要操作的数据数组下标（从 0 开始）。

操作流程

1. 对数据数组排序：按整数二进制表示中 1 的个数升序排列（符号位中的 1 也计入）；1 的个数相同时，按数值升序排列。
2. 依次对操作数组中的每个元素执行以下操作： 2.1 读取两个下标，取当前数据数组中对应位置的元素，计算它们的二进制按位或，将结果追加到数据数组末尾，并删除原来的两个元素（元素下标允许相同，此时仅删除一个元素）。 2.2 对更新后的数据数组按步骤 1 的规则重新排序。
3. 输出最终排序后的数据数组。

注意

• 数据数组的长度范围为 [0,100]，元素值范围为 [−231,231−1]。
• 操作数组的长度范围为 [0,10]，每个元素中数组长度保证为 2，数值作为当前数据数组下标保证不会越界。
• 即使操作数组为空，最后输出的数据数组也需要按照描述的排序方式输出有序数据数组。

输入描述

两个 int 数组，数据数组（一维）和操作数组（二维）

输出描述

最终排序后的数据数组

示例1

输入

[3,2,1],[[0,1]]

输出

[3,3]

说明

排序后内容为 [1,2,3]，对 1 和 2 进行或操作得到 3，删除并插入重新排序后得到 [3,3]。

示例2

输入

[1024,512,256,128,64,32,16,8,4,2,1,0,-1],[[0,1],[0,1],[0,1],[1,2]]

输出

[16,128,256,512,1024,3,12,96,-1]

说明

排序后内容为 [0,1,2,4,8,16,32,64,128,256,512,1024,−1]，经过第一次操作结果为 [0,1,2,4,8,16,32,64,128,256,512,1024,−1]，第二次操作结果为 [4,8,16,32,64,128,256,512,1024,3,1024,−1]，第三次操作结果为 [16,32,64,128,256,512,1024,3,12,−1]，最后一次操作结果为 [16,128,256,512,1024,3,12,96,−1]。

示例3

输入

[2147483647,-2147483648,-1,0],[[1,2],[2,2]]

输出

[0,-1,-1]

说明

原始数组按照二进制表示为[01111111111111111111111111111111,10000000000000000000000000000000,11111111111111111111111111111111,00000000000000000000000000000000]，按照 1 的数量进行排序后数组顺序为： [0,−2147483648,2147483647,−1]。

接下来对 index 为 1 和 2 的元素即 −2147483648、2147483647 进行或操作获得结果 −1，将 [−2147483648,2147483647] 从数组中删除并插入 −1 后得到 [0,−1,−1]。

最后对 index 为 2 的元素自身进行或操作不会改变数据。最终返回 [0,−1,−1]。

解题思路

本题的核心在于按二进制中 1 的个数进行稳定排序，并模拟一个不断合并元素的动态过程。

关键算法点

1. 自定义排序规则：

   • 首先统计每个整数的二进制表示中 1 的个数（也称为 popcount 或汉明重量）。
   • 排序规则：第一关键字是 popcount 升序；第二关键字是数值本身升序。
   • 由于负数的二进制表示比较特殊（采用补码），我们需要将其与 32 位无符号整数范围 [0, 2^32-1] 对应起来进行 popcount 统计。具体做法是将负数与 0xFFFFFFFF 进行按位与操作后再统计。

2. 模拟合并操作：

   • 对于每一对下标 (i, j)，取出对应元素 a 和 b。
   • 如果下标相同，则 b 等于 a（只取一个元素）。
   • 计算合并结果 result = a | b（按位或）。
   • 从数组中删除被选中的元素。注意：由于删除元素会导致后续下标偏移，需要先删除下标较大的元素，再删除下标较小的元素。
   • 将合并结果 result 添加到数组末尾。
   • 再次对数组应用排序规则。

3. 输入输出处理：

   • 输入格式为两个数组：数据数组 和 操作数组。
   • 数据数组直接解析为整数列表。
   • 操作数组解析为包含两个整数的列表的列表。
   • 输出格式为数组的字符串表示，例如 [1,2,3]。

边界情况处理

• 空数组：即使数据数组为空，输出也应为 []。
• 空操作列表：即使没有操作，也需要输出排序后的数组。
• 相同下标操作：此时只删除一个元素，合并结果即为该元素自身按位或（不变）。
• 32 位边界值：需要正确处理 Integer.MAX_VALUE (2147483647) 和 Integer.MIN_VALUE (-2147483648) 的 popcount 计算。

复杂度分析

• 时间复杂度：设数据数组长度为 n，操作数组长度为 m。
  • 每次排序的时间复杂度为 O(n log n)。
  • 总共进行 m + 1 次排序（初始一次 + 每次操作后一次）。
  • 极端情况下总时间复杂度为 O((n + m) * n log n)，但由于 n <= 100, m <= 10，该复杂度完全在可接受范围内。
• 空间复杂度：O(n)，主要用于存储数组和辅助操作。

Java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static int countBits(int x) {
        return Integer.bitCount(x);
    }

    public static List<Integer> processData(List<Integer> dataList, List<List<Integer>> operationList) {
        List<Integer> arr = new ArrayList<>(dataList);

        sortArray(arr);

        for (List<Integer> op : operationList) {
            int i = op.get(0);
            int j = op.get(1);

            int a = arr.get(i);
            int b = i != j ? arr.get(j) : a;
            int mergedResult = a | b;

            if (i == j) {
                arr.remove(i);
            } else {
                int lo = Math.min(i, j);
                int hi = Math.max(i, j);
                arr.remove(hi);
                arr.remove(lo);
            }

            arr.add(mergedResult);
            sortArray(arr);
        }

        return arr;
    }

    public static void sortArray(List<Integer> arr) {
        Collections.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                int bitCompare = Integer.compare(countBits(a), countBits(b));
                if (bitCompare != 0) {
                    return bitCompare;
                }
                return Integer.compare(a, b);
            }
        });
    }

    public static String formatOutput(List<Integer> result) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < result.size(); i++) {
            if (i > 0) {
                sb.append(",");
            }
            sb.append(result.get(i));
        }
        sb.append("]");
        return sb.toString();
    }

    public static Object[] parseInput(String line) {
        line = line.trim();

        int depth = 0;
        int firstBracketEnd = -1;
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            if (c == '[') {
                depth++;
            } else if (c == ']') {
                depth--;
                if (depth == 0) {
                    firstBracketEnd = i;
                    break;
                }
            }
        }

        String dataPart = line.substring(0, firstBracketEnd + 1);
        String operationPart = line.substring(firstBracketEnd + 1);
        if (operationPart.startsWith(",")) {
            operationPart = operationPart.substring(1);
        }

        List<Integer> dataList = parseOneDimensionalArray(dataPart);
        List<List<Integer>> operationList = parseTwoDimensionalArray(operationPart);

        return new Object[]{dataList, operationList};
    }

    public static List<Integer> parseOneDimensionalArray(String s) {
        List<Integer> list = new ArrayList<>();
        s = s.trim();

        if (s.length() <= 2) {
            return list;
        }

        String content = s.substring(1, s.length() - 1).trim();
        if (content.isEmpty()) {
            return list;
        }

        String[] nums = content.split(",");
        for (String num : nums) {
            list.add(Integer.parseInt(num.trim()));
        }

        return list;
    }

    public static List<List<Integer>> parseTwoDimensionalArray(String s) {
        List<List<Integer>> result = new ArrayList<>();
        s = s.trim();

        if (s.isEmpty() || s.equals("[]")) {
            return result;
        }

        if (s.startsWith("[") && s.endsWith("]")) {
            s = s.substring(1, s.length() - 1).trim();
        }

        int i = 0;
        while (i < s.length()) {
            if (s.charAt(i) == '[') {
                int j = i + 1;
                while (j < s.length() && s.charAt(j) != ']') {
                    j++;
                }

                String part = s.substring(i, j + 1);
                List<Integer> op = parseOneDimensionalArray(part);
                if (!op.isEmpty()) {
                    result.add(op);
                }

                i = j + 1;
            } else {
                i++;
            }
        }

        return result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String inputLine = scanner.nextLine().trim();

        Object[] parsed = parseInput(inputLine);

        @SuppressWarnings("unchecked")
        List<Integer> dataList = (List<Integer>) parsed[0];

        @SuppressWarnings("unchecked")
        List<List<Integer>> operationList = (List<List<Integer>>) parsed[1];

        List<Integer> result = processData(dataList, operationList);
        System.out.println(formatOutput(result));

        scanner.close();
    }
}

Python

from typing import List


def 统计比特数(x: int) -> int:
    """按 32 位有符号整数统计 1 的个数"""
    return bin(x & 0xFFFFFFFF).count("1")


def 处理数据(数据列表: List[int], 操作列表: List[List[int]]) -> List[int]:
    """
    核心处理逻辑
    参数:
        数据列表: 待处理的整数数组
        操作列表: 操作数组，每个元素为 [下标i, 下标j]
    返回:
        最终排序后的数组
    """
    arr = list(数据列表)

    def 排序数组() -> None:
        # 按二进制中1的个数升序，个数相同则按数值升序
        arr.sort(key=lambda v: (统计比特数(v), v))

    # 初始排序
    排序数组()

    # 依次执行操作
    for op in 操作列表:
        i, j = op[0], op[1]
        a = arr[i]
        # 如果下标相同，只取一个元素
        b = arr[j] if i != j else a
        # 计算按位或结果
        合并结果 = a | b

        if i == j:
            # 同下标只删除一个元素
            arr.pop(i)
        else:
            lo, hi = min(i, j), max(i, j)
            # 先删高位再删低位，避免索引偏移
            arr.pop(hi)
            arr.pop(lo)

        # 追加合并结果并重新排序
        arr.append(合并结果)
        排序数组()

    return arr


def 格式化输出(结果: List[int]) -> str:
    """格式化输出为 [a,b,c] 形式"""
    return "[" + ",".join(str(x) for x in 结果) + "]"


def 解析输入(行: str) -> tuple:
    """解析输入行，格式如: [1,2,3],[[0,1],[1,2]]"""
    行 = 行.strip()
    first_bracket_end = 行.index("]")
    数据部分 = 行[:first_bracket_end + 1]
    操作部分 = 行[first_bracket_end + 1:].strip(",")

    数据列表 = eval(数据部分)
    if not 操作部分 or 操作部分 == "[]":
        操作列表 = []
    else:
        操作列表 = eval(操作部分)

    return 数据列表, 操作列表


def main():
    """主函数"""
    输入行 = input().strip()
    数据列表, 操作列表 = 解析输入(输入行)
    结果 = 处理数据(数据列表, 操作列表)
    print(格式化输出(结果))


if __name__ == "__main__":
    main()

JavaScript

// 统计 32 位整数二进制中 1 的个数
function 统计比特数(x) {
    // 将有符号整数转换为无符号 32 位整数
    const 无符号 = x >>> 0;
    return (无符号.toString(2).match(/1/g) || '').length;
}

// 格式化输出为 [a,b,c] 形式
function 格式化输出(arr) {
    return '[' + arr.join(',') + ']';
}

// 解析输入行
function 解析输入(行) {
    行 = 行.trim();
    // 找到第一个 ] 的位置
    const firstBracketEnd = 行.indexOf(']');
    const 数据部分 = 行.slice(0, firstBracketEnd + 1);
    const 操作部分 = 行.slice(firstBracketEnd + 1).replace(/^,/, '').trim();

    const 数据列表 = JSON.parse(数据部分);
    const 操作列表 = (操作部分 === '[]' || 操作部分 === '') ? [] : JSON.parse(操作部分);

    return [数据列表, 操作列表];
}

function 处理数据(数据列表, 操作列表) {
    let arr = [...数据列表];

    function 排序数组() {
        arr.sort((a, b) => {
            const popA = 统计比特数(a);
            const popB = 统计比特数(b);
            if (popA !== popB) return popA - popB;
            return a - b;
        });
    }

    // 初始排序
    排序数组();

    // 依次执行操作
    for (const op of 操作列表) {
        const i = op[0];
        const j = op[1];
        const a = arr[i];
        const b = (i === j) ? a : arr[j];
        const 合并结果 = a | b;

        if (i === j) {
            arr.splice(i, 1);
        } else {
            const lo = Math.min(i, j);
            const hi = Math.max(i, j);
            // 先删高位，再删低位，避免索引偏移
            arr.splice(hi, 1);
            arr.splice(lo, 1);
        }

        arr.push(合并结果);
        排序数组();
    }

    return arr;
}

// 主函数
function main() {
    const 输入行 = require('fs').readFileSync('/dev/stdin', 'utf-8').trim();
    const [数据列表, 操作列表] = 解析输入(输入行);
    const 结果 = 处理数据(数据列表, 操作列表);
    console.log(格式化输出(结果));
}

main();

C++

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <sstream>

using namespace std;

int countBits(int x) {
    return __builtin_popcount((unsigned int)x);
}

void sortArray(vector<int>& arr) {
    sort(arr.begin(), arr.end(), [](int a, int b) {
        int bitA = countBits(a);
        int bitB = countBits(b);
        if (bitA != bitB) {
            return bitA < bitB;
        }
        return a < b;
    });
}

vector<int> processData(vector<int> dataList, vector<vector<int>> operationList) {
    vector<int> arr = dataList;

    sortArray(arr);

    for (vector<int> op : operationList) {
        int i = op[0];
        int j = op[1];

        int a = arr[i];
        int b = i != j ? arr[j] : a;
        int mergedResult = a | b;

        if (i == j) {
            arr.erase(arr.begin() + i);
        } else {
            int lo = min(i, j);
            int hi = max(i, j);
            arr.erase(arr.begin() + hi);
            arr.erase(arr.begin() + lo);
        }

        arr.push_back(mergedResult);
        sortArray(arr);
    }

    return arr;
}

vector<int> parseOneDimensionalArray(string s) {
    vector<int> list;

    if (s.size() <= 2) {
        return list;
    }

    string content = s.substr(1, s.size() - 2);
    stringstream ss(content);
    string num;

    while (getline(ss, num, ',')) {
        if (!num.empty()) {
            list.push_back(stoi(num));
        }
    }

    return list;
}

vector<vector<int>> parseTwoDimensionalArray(string s) {
    vector<vector<int>> result;

    if (s.empty() || s == "[]") {
        return result;
    }

    if (s.front() == '[' && s.back() == ']') {
        s = s.substr(1, s.size() - 2);
    }

    int i = 0;
    while (i < (int)s.size()) {
        if (s[i] == '[') {
            int j = i + 1;
            while (j < (int)s.size() && s[j] != ']') {
                j++;
            }

            string part = s.substr(i, j - i + 1);
            vector<int> op = parseOneDimensionalArray(part);
            if (!op.empty()) {
                result.push_back(op);
            }

            i = j + 1;
        } else {
            i++;
        }
    }

    return result;
}

pair<vector<int>, vector<vector<int>>> parseInput(string line) {
    int depth = 0;
    int firstBracketEnd = -1;

    for (int i = 0; i < (int)line.size(); i++) {
        if (line[i] == '[') {
            depth++;
        } else if (line[i] == ']') {
            depth--;
            if (depth == 0) {
                firstBracketEnd = i;
                break;
            }
        }
    }

    string dataPart = line.substr(0, firstBracketEnd + 1);
    string operationPart = line.substr(firstBracketEnd + 1);

    if (!operationPart.empty() && operationPart[0] == ',') {
        operationPart = operationPart.substr(1);
    }

    vector<int> dataList = parseOneDimensionalArray(dataPart);
    vector<vector<int>> operationList = parseTwoDimensionalArray(operationPart);

    return {dataList, operationList};
}

string formatOutput(vector<int> result) {
    string res = "[";
    for (int i = 0; i < (int)result.size(); i++) {
        if (i > 0) {
            res += ",";
        }
        res += to_string(result[i]);
    }
    res += "]";
    return res;
}

int main() {
    string inputLine;
    getline(cin, inputLine);

    pair<vector<int>, vector<vector<int>>> parsed = parseInput(inputLine);
    vector<int> result = processData(parsed.first, parsed.second);

    cout << formatOutput(result) << endl;

    return 0;
}

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

// 统计 32 位整数二进制中 1 的个数
func 统计比特数(x int) int {
	// 将有符号整数转换为无符号整数进行 popcount 计算
	u := uint32(x)
	count := 0
	for u != 0 {
		count++
		u &= u - 1
	}
	return count
}

// 解析输入行
func 解析输入(行 string) ([]int, [][2]int) {
	行 = strings.TrimSpace(行)

	// 找到第一个 ] 的位置
	idx := strings.Index(行, "]")
	数据部分 := 行[:idx+1]
	操作部分 := strings.TrimPrefix(行[idx+1:], ",")

	// 解析数据数组
	数据列表 := parseIntArray(数据部分)

	// 解析操作数组
	var 操作列表 [][2]int
	if 操作部分 != "[]" && 操作部分 != "" {
		操作列表 = parseOpArray(操作部分)
	}

	return 数据列表, 操作列表
}

// 解析整数数组 [1,2,3]
func parseIntArray(s string) []int {
	s = strings.TrimSpace(s)
	s = strings.TrimPrefix(s, "[")
	s = strings.TrimSuffix(s, "]")
	if s == "" {
		return []int{}
	}

	parts := strings.Split(s, ",")
	result := make([]int, 0, len(parts))
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if v, err := strconv.Atoi(p); err == nil {
			result = append(result, v)
		}
	}
	return result
}

// 解析操作数组 [[0,1],[1,2]]
func parseOpArray(s string) [][2]int {
	s = strings.TrimSpace(s)
	// 去掉 [[ 和 ]]
	s = strings.TrimPrefix(s, "[[")
	s = strings.TrimSuffix(s, "]]")

	if s == "" {
		return [][2]int{}
	}

	// 按 ], [ 分割
	pairs := strings.Split(s, "],[")
	result := make([][2]int, 0, len(pairs))

	for _, pair := range pairs {
		pair = strings.Trim(pair, "[] ")
		nums := strings.Split(pair, ",")
		if len(nums) >= 2 {
			a, _ := strconv.Atoi(strings.TrimSpace(nums[0]))
			b, _ := strconv.Atoi(strings.TrimSpace(nums[1]))
			result = append(result, [2]int{a, b})
		}
	}
	return result
}

// 格式化输出为 [a,b,c]
func 格式化输出(arr []int) string {
	parts := make([]string, len(arr))
	for i, v := range arr {
		parts[i] = strconv.Itoa(v)
	}
	return "[" + strings.Join(parts, ",") + "]"
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	输入行 := scanner.Text()

	数据列表, 操作列表 := 解析输入(输入行)

	// 使用切片存储数据
	arr := make([]int, len(数据列表))
	copy(arr, 数据列表)

	// 排序函数：按 popcount 升序，数值相同时按数值升序
	sort.Slice(arr, func(i, j int) bool {
		popI := 统计比特数(arr[i])
		popJ := 统计比特数(arr[j])
		if popI != popJ {
			return popI < popJ
		}
		return arr[i] < arr[j]
	})

	// 依次执行操作
	for _, op := range 操作列表 {
		i, j := op[0], op[1]
		a := arr[i]
		b := a
		if i != j {
			b = arr[j]
		}
		合并结果 := a | b

		if i == j {
			// 同下标只删除一个
			arr = append(arr[:i], arr[i+1:]...)
		} else {
			lo, hi := i, j
			if lo > hi {
				lo, hi = hi, lo
			}
			// 先删高位，再删低位
			arr = append(arr[:hi], arr[hi+1:]...)
			arr = append(arr[:lo], arr[lo+1:]...)
		}

		arr = append(arr, 合并结果)

		// 重新排序
		sort.Slice(arr, func(p, q int) bool {
			popP := 统计比特数(arr[p])
			popQ := 统计比特数(arr[q])
			if popP != popQ {
				return popP < popQ
			}
			return arr[p] < arr[q]
		})
	}

	fmt.Println(格式化输出(arr))
}

C语言

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define MAX_DATA 200
#define MAX_OPS 20

int countBits(int x) {
    unsigned int v = (unsigned int)x;
    int count = 0;

    while (v) {
        count += v & 1U;
        v >>= 1;
    }

    return count;
}

int compareInt(const void *p1, const void *p2) {
    int a = *(const int *)p1;
    int b = *(const int *)p2;

    int bitA = countBits(a);
    int bitB = countBits(b);

    if (bitA != bitB) {
        return bitA - bitB;
    }

    if (a < b) {
        return -1;
    }
    if (a > b) {
        return 1;
    }
    return 0;
}

void sortArray(int arr[], int size) {
    qsort(arr, size, sizeof(int), compareInt);
}

void processData(int dataList[], int dataSize, int operationList[][2], int operationSize, int result[], int *resultSize) {
    int arr[MAX_DATA];
    int size = dataSize;

    for (int i = 0; i < dataSize; i++) {
        arr[i] = dataList[i];
    }

    sortArray(arr, size);

    for (int k = 0; k < operationSize; k++) {
        int i = operationList[k][0];
        int j = operationList[k][1];

        int a = arr[i];
        int b = i != j ? arr[j] : a;
        int mergedResult = a | b;

        if (i == j) {
            for (int p = i; p < size - 1; p++) {
                arr[p] = arr[p + 1];
            }
            size--;
        } else {
            int lo = i < j ? i : j;
            int hi = i > j ? i : j;

            for (int p = hi; p < size - 1; p++) {
                arr[p] = arr[p + 1];
            }
            size--;

            for (int p = lo; p < size - 1; p++) {
                arr[p] = arr[p + 1];
            }
            size--;
        }

        arr[size++] = mergedResult;
        sortArray(arr, size);
    }

    for (int i = 0; i < size; i++) {
        result[i] = arr[i];
    }
    *resultSize = size;
}

void parseOneDimensionalArray(const char *s, int list[], int *size) {
    *size = 0;

    const char *p = s;
    while (*p) {
        if (*p == '-' || isdigit(*p)) {
            char *end;
            int num = (int)strtol(p, &end, 10);
            list[(*size)++] = num;
            p = end;
        } else {
            p++;
        }
    }
}

void parseInput(char *line, int dataList[], int *dataSize, int operationList[][2], int *operationSize) {
    int depth = 0;
    int firstBracketEnd = -1;
    int len = strlen(line);

    for (int i = 0; i < len; i++) {
        if (line[i] == '[') {
            depth++;
        } else if (line[i] == ']') {
            depth--;
            if (depth == 0) {
                firstBracketEnd = i;
                break;
            }
        }
    }

    char dataPart[1024];
    strncpy(dataPart, line, firstBracketEnd + 1);
    dataPart[firstBracketEnd + 1] = '\0';

    parseOneDimensionalArray(dataPart, dataList, dataSize);

    *operationSize = 0;
    char *p = line + firstBracketEnd + 1;

    while (*p) {
        if (*p == '[') {
            int nums[2];
            int cnt = 0;

            p++;
            while (*p && *p != ']') {
                if (*p == '-' || isdigit(*p)) {
                    char *end;
                    int num = (int)strtol(p, &end, 10);
                    if (cnt < 2) {
                        nums[cnt++] = num;
                    }
                    p = end;
                } else {
                    p++;
                }
            }

            if (cnt == 2) {
                operationList[*operationSize][0] = nums[0];
                operationList[*operationSize][1] = nums[1];
                (*operationSize)++;
            }
        }

        if (*p) {
            p++;
        }
    }
}

void printResult(int result[], int resultSize) {
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) {
            printf(",");
        }
        printf("%d", result[i]);
    }
    printf("]\n");
}

int main() {
    char inputLine[2048];

    if (fgets(inputLine, sizeof(inputLine), stdin) == NULL) {
        return 0;
    }

    inputLine[strcspn(inputLine, "\n")] = '\0';

    int dataList[MAX_DATA];
    int dataSize;
    int operationList[MAX_OPS][2];
    int operationSize;
    int result[MAX_DATA];
    int resultSize;

    parseInput(inputLine, dataList, &dataSize, operationList, &operationSize);
    processData(dataList, dataSize, operationList, operationSize, result, &resultSize);
    printResult(result, resultSize);

    return 0;
}

完整用例

用例1

[3,2,1],[[0,1]]

用例2

[1024,512,256,128,64,32,16,8,4,2,1,0,-1],[[0,1],[0,1],[0,1],[1,2]]

用例3

[2147483647,-2147483648,-1,0],[[1,2],[2,2]]

用例4

[5,3,9,1],[[0,2],[1,1]]

用例5

[42],[]

用例6

[1,2,3],[[0,0],[2,2]]

用例7

[-5,-3,-1,-7],[[0,1]]

用例8

[1,-1,2,-2,3,-3],[[0,5],[1,4],[2,3]]

用例9

[1024,512,256,128,64,32,16,8,4,2,1,0,-1,-2,-4,-8,-16,-32,-64,-128],[[0,11],[1,12],[2,13]]

用例10

[1,2,3,4,5],[[0,4],[1,3],[0,1]]