【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)