题目
日志排序
给定一个包含日志记录的字符串数组 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)