【2024华为OD-E卷-100分-日志排序】（（题目+思路+Java&C++&Python解析)

题目

日志排序

给定一个包含日志记录的字符串数组 logs，每个日志记录由时间戳（24小时制）、设备ID和日志内容组成，格式如下：

"{时间戳} {设备ID} {日志内容}"

例如：

"2023-10-01 12:00:01 1 device_start"
"2023-10-01 12:00:02 2 device_error"

要求：

将日志记录按时间戳从早到晚排序。
如果时间戳相同，则按设备ID从小到大排序。
如果时间戳和设备ID都相同，则按日志内容字典序从小到大排序。

输入：

一个字符串数组 logs，每个字符串表示一条日志记录。

输出：

排序后的字符串数组 logs。

示例：输入：

["2023-10-01 12:00:01 1 device_start", "2023-10-01 12:00:02 2 device_error", "2023-10-01 12:00:01 1 device_stop"]

输出：

["2023-10-01 12:00:01 1 device_start", "2023-10-01 12:00:01 1 device_stop", "2023-10-01 12:00:02 2 device_error"]

思路

解析日志记录：将每条日志记录拆分成时间戳、设备ID和日志内容。
自定义排序：使用自定义排序规则，先按时间戳排序，如果时间戳相同则按设备ID排序，如果设备ID也相同则按日志内容排序。
输出结果：将排序后的日志记录重新组合成字符串数组。

Java 编码解析

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;

public class LogSorter {
    public static String[] sortLogs(String[] logs) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Arrays.sort(logs, new Comparator<String>() {
            @Override
            public int compare(String log1, String log2) {
                String[] parts1 = log1.split(" ");
                String[] parts2 = log2.split(" ");

                try {
                    Date date1 = sdf.parse(parts1[0]);
                    Date date2 = sdf.parse(parts2[0]);

                    int timestampCompare = date1.compareTo(date2);
                    if (timestampCompare != 0) {
                        return timestampCompare;
                    }

                    int deviceIdCompare = Integer.parseInt(parts1[1]) - Integer.parseInt(parts2[1]);
                    if (deviceIdCompare != 0) {
                        return deviceIdCompare;
                    }

                    return parts1[2].compareTo(parts2[2]);
                } catch (ParseException e) {
                    throw new RuntimeException("Invalid log format", e);
                }
            }
        });

        return logs;
    }

    public static void main(String[] args) {
        String[] logs = {
            "2023-10-01 12:00:01 1 device_start",
            "2023-10-01 12:00:02 2 device_error",
            "2023-10-01 12:00:01 1 device_stop"
        };

        String[] sortedLogs = sortLogs(logs);

        for (String log : sortedLogs) {
            System.out.println(log);
        }
    }
}

C++ 编码解析

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

bool compareLogs(const std::string& log1, const std::string& log2) {
    std::istringstream ss1(log1), ss2(log2);
    std::string timestamp1, deviceId1, content1, timestamp2, deviceId2, content2;

    ss1 >> timestamp1 >> deviceId1 >> content1;
    ss2 >> timestamp2 >> deviceId2 >> content2;

    struct tm tm1 = {}, tm2 = {};
    std::istringstream(timestamp1) >> std::get_time(&tm1, "%Y-%m-%d %H:%M:%S");
    std::istringstream(timestamp2) >> std::get_time(&tm2, "%Y-%m-%d %H:%M:%S");

    std::time_t time1 = std::mktime(&tm1);
    std::time_t time2 = std::mktime(&tm2);

    if (time1 != time2) {
        return time1 < time2;
    }

    int devId1 = std::stoi(deviceId1);
    int devId2 = std::stoi(deviceId2);

    if (devId1 != devId2) {
        return devId1 < devId2;
    }

    return content1 < content2;
}

std::vector<std::string> sortLogs(const std::vector<std::string>& logs) {
    std::vector<std::string> sortedLogs = logs;
    std::sort(sortedLogs.begin(), sortedLogs.end(), compareLogs);
    return sortedLogs;
}

int main() {
    std::vector<std::string> logs = {
        "2023-10-01 12:00:01 1 device_start",
        "2023-10-01 12:00:02 2 device_error",
        "2023-10-01 12:00:01 1 device_stop"
    };

    std::vector<std::string> sortedLogs = sortLogs(logs);

    for (const auto& log : sortedLogs) {
        std::cout << log << std::endl;
    }

    return 0;
}

Python 编码解析

from datetime import datetime

def sort_logs(logs):
    def parse_log(log):
        timestamp, device_id, content = log.split()
        return datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"), int(device_id), content

    logs.sort(key=lambda log: parse_log(log))
    return logs

logs = [
    "2023-10-01 12:00:01 1 device_start",
    "2023-10-01 12:00:02 2 device_error",
    "2023-10-01 12:00:01 1 device_stop"
]

sorted_logs = sort_logs(logs)

for log in sorted_logs:
    print(log)