937. Reorder Data in Log Files

Problem Description

In this problem, we are dealing with an array of strings called logs, where each log entry is composed of an identifier followed by either a string of lowercase English letters (a letter-log) or a string of digits (a digit-log). The identifier and the log content are separated by a space. Our task is to reorder these logs based on certain rules:

  1. Letter-logs must be sorted and come before all digit-logs.
  2. Letter-logs should be ordered lexicographically (i.e., alphabetically) by their content. If two letter-logs have identical content, they should then be sorted by their identifiers in lexicographic order.
  3. Digit-logs should retain their original order as they appeared in the input.

The expected output is the reordered array of the logs following these rules.


To solve this, we need a way to differentiate between letter-logs and digit-logs and then sort them according to the given criteria. We can achieve this through a custom sorting function.

When we look at the identifier and the log content, we observe that letter-logs contain alphabetical characters while digit-logs contain numbers. We can exploit this characteristic to split logs into two categories by checking if the first character of the log content is a letter or a digit.

Given the sorting requirements, we know that all letter-logs should be sorted lexicographically by their content, and if these are equal, by their identifiers. Digit-logs do not need sorting among themselves, but they need to be placed after all letter-logs. To keep them in their original order, we can just ignore their content and identifiers during the sorting process.

With these observations, we craft a sorting function that:

  1. Splits each log into its identifier and content.
  2. Checks whether it's a letter-log or digit-log by inspecting the first character of the content.
  3. If it's a letter-log, the function returns a tuple (0, content, identifier). The zero indicates that it's a letter-log for sort precedence, and sorting by content and then identifier follows naturally.
  4. If it's a digit-log, the function returns a tuple (1,). The '1' ensures that all digit-logs are ordered after letter-logs, and since no other sorting keys follow, they maintain their relative input order.

Finally, by calling the sorted function and passing our custom comparison function, we obtain a sorted list that meets all the criteria outlined in the problem description. The sorted function rearranges the elements according to the tuples returned by our comparison function cmp, effectively pushing letter-logs to the front and sorting them while keeping digit-logs in their original order at the end of the resulting list.

Learn more about Sorting patterns.

Solution Approach

The implementation of the solution primarily revolves around the Python sorted function and a custom sorting key function, which is the cmp function in the reference solution. The sorted function is an efficient sorting algorithm that uses the TimSort algorithm, which is a hybrid sorting algorithm derived from merge sort and insertion sort.

The cmp function is where the distinction between letter-logs and digit-logs is made and the sorting logic is customized. It takes a log entry as an argument and uses the split method to divide it into two parts, the identifier and the content, with a space being the delimiter. Since we need both parts separately for the sorting criteria, splitting them does the job efficiently.

Here's the step-by-step approach within the cmp function:

  1. Split the log into identifier a and content b:

    1a, b = x.split(' ', 1)
  2. Check whether the log is a letter-log or a digit-log:

    1if b[0].isalpha():
    2    ...
    4    ...
  3. For letter-logs, return a tuple (0, b, a), where b is the content of the log without the identifier and a is the identifier. The leading 0 ensures these come before any digit-logs.

  4. For digit-logs, return a tuple (1,), which only has the digit 1. It ensures digit-logs are placed after letter-logs and since no other values are in the tuple, their original order (relative to other digit-logs) is maintained.

The sorted function uses this cmp key function to sort the entire list of logs. The logs are compared based on the tuples returned by cmp; if the first elements of these tuples are different (which differentiate between letter and digit logs), it sorts based on this. If they are the same (as with all letter-logs), it proceeds to sort based on the subsequent elements in the tuple, which are the content and, if necessary, the identifier.

To sum up, the algorithm utilizes a sorting key function to create sortable tuples for each log entry, which Python's sorted function then utilizes to sort the entire list accordingly. This approach does not require any additional data structures or complex algorithms, making it an efficient and elegant solution to the problem.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:

Which of the following problems can be solved with backtracking (select multiple)

Example Walkthrough

Let's walk through a small example to illustrate the solution approach. Consider the following logs array:

1logs = ["dig1 8 1 5 1", "let1 art can", "dig2 3 6", "let2 own kit dig", "let3 art zero"]

We are tasked with reordering these logs based on the rules provided in the problem description.

Step 1: Differentiating logs

Firstly, we want to differentiate the logs into letter-logs and digit-logs. We can see that "let1 art can", "let2 own kit dig", and "let3 art zero" are letter-logs because they contain letters after the first space. "dig1 8 1 5 1" and "dig2 3 6" are digit-logs because they contain numbers after the first space.

Step 2: Applying the custom sorting function

We implement a custom sorting key function, cmp, to sort the logs. This function will handle logs differently based on their type.


For letter-logs, cmp will return a tuple of the form (0, content, identifier). Here's how it will look for our letter-logs in python code:

1# "let1 art can" splits into identifier "let1" and content "art can"
2("let1 art can".split(" ", 1)) => ("let1", "art can") => (0, "art can", "let1")
4# "let2 own kit dig" splits into identifier "let2" and content "own kit dig"
5("let2 own kit dig".split(" ", 1)) => ("let2", "own kit dig") => (0, "own kit dig", "let2")
7# "let3 art zero" splits into identifier "let3" and content "art zero"
8("let3 art zero".split(" ", 1)) => ("let3", "art zero") => (0, "art zero", "let3")

For digit-logs, cmp will return a tuple just containing '1', which places all digit-logs after the letter-logs.

1# "dig1 8 1 5 1" splits but we only need to recognize it as a digit-log
2("dig1 8 1 5 1".split(" ", 1)) => ("dig1", "8 1 5 1") => (1,)
4# "dig2 3 6" also splits but we only need to mark it as a digit-log
5("dig2 3 6".split(" ", 1)) => ("dig2", "3 6") => (1,)

Step 3: Sorting logs

After applying the cmp function, the sorted function sorts the logs based on these tuples:

1# Letter-logs sorted by content and then by identifier if needed
2sorted_letter_logs = sorted(["let1 art can", "let2 own kit dig", "let3 art zero"], key=cmp)
4# Output for letter-logs is: ["let3 art zero", "let1 art can", "let2 own kit dig"]
6# Digit-logs maintain their original order
7# Therefore, after letter-logs they are just appended: ["dig1 8 1 5 1", "dig2 3 6"]
9# Combined sorted logs
10sorted_logs = sorted_letter_logs + ["dig1 8 1 5 1", "dig2 3 6"]
12# Final output: ["let3 art zero", "let1 art can", "let2 own kit dig", "dig1 8 1 5 1", "dig2 3 6"]

This final output respects all the sorting rules mentioned in the problem description and uses the power of Python's sorted function along with a custom comparison key to effectively reorder the logs.

Solution Implementation

1from typing import List
3class Solution:
4    def reorderLogFiles(self, logs: List[str]) -> List[str]:
5        def get_log_key(log: str) -> tuple:
6            # Split each log into two parts: identifier and content
7            identifier, content = log.split(' ', 1)
9            # We return a tuple that will help us sort the logs:
10            # If it's a letter-log (i.e., content starts with an alphabetic character),
11            # we want it sorted by (0, content, identifier) to ensure that it appears
12            # before any digit-logs and that letter-logs are sorted firstly by content
13            # and secondly by identifier if there's a tie in content.
14            # If it's a digit-log (i.e., content starts with a digit),
15            # we use (1,) so that it appears after all the letter-logs,
16            # and within the digit-logs subgroup, it maintains the original order
17            # (since we don't provide any further sorting keys for digit-logs).
18            return (0, content, identifier) if content[0].isalpha() else (1,)
20        # Sort logs using sort() function. The key parameter takes a function
21        # that extracts sorting keys from the log entries.
22        # The logs are sorted according to the keys provided by the get_log_key function.
23        return sorted(logs, key=get_log_key)
1class Solution {
2    public String[] reorderLogFiles(String[] logs) {
3        // Sort the given logs with specified ordering rules
4        Arrays.sort(logs, this::compareLogs);
5        return logs;
6    }
8    private int compareLogs(String log1, String log2) {
9        // Split the logs into two parts: identifier and content
10        String[] splitLog1 = log1.split(" ", 2);
11        String[] splitLog2 = log2.split(" ", 2);
13        // Check if log1 and log2 contents start with a digit
14        boolean isDigitLog1 = Character.isDigit(splitLog1[1].charAt(0));
15        boolean isDigitLog2 = Character.isDigit(splitLog2[1].charAt(0));
17        // Both logs are letter-logs
18        if (!isDigitLog1 && !isDigitLog2) {
19            // Compare the contents of the logs
20            int contentComparison = splitLog1[1].compareTo(splitLog2[1]);
21            if (contentComparison != 0) {
22                return contentComparison;
23            }
24            // If contents are identical, compare the identifiers
25            return splitLog1[0].compareTo(splitLog2[0]);
26        }
28        // Both logs are digit-logs, in which case we return 0 to retain their original order
29        if (isDigitLog1 && isDigitLog2) {
30            return 0;
31        }
33        // One log is a digit-log and the other is a letter-log
34        // Letter-logs should come before digit-logs, thus returning 1 if the first log is a digit-log, else -1
35        return isDigitLog1 ? 1 : -1;
36    }
1#include <vector>
2#include <string>
3#include <algorithm>
5// Function to reorder log files based on specified rules
6std::vector<std::string> reorderLogFiles(std::vector<std::string>& logs) {
7    // Lambda function to check if a character is a digit
8    auto isDigit = [](char c) { return c >= '0' && c <= '9'; };
10    // Custom sort function for log files
11    std::sort(logs.begin(), logs.end(), [&](const std::string& log1, const std::string& log2) {
12        // Find the first space in both logs to separate identifier from content
13        size_t firstSpaceLog1 = log1.find(' ');
14        size_t firstSpaceLog2 = log2.find(' ');
16        // Check if the first character of the content of log1 and log2 is a digit
17        bool isDigitLog1 = isDigit(log1[firstSpaceLog1 + 1]);
18        bool isDigitLog2 = isDigit(log2[firstSpaceLog2 + 1]);
20        // If both logs are digit logs, maintain their relative order
21        if (isDigitLog1 && isDigitLog2) {
22            return false;
23        }
25        // If log1 is a digit log, then it should come after log2 if log2 is a letter log
26        if (isDigitLog1) {
27            return false;
28        }
30        // If log2 is a digit log, then it should come after log1 if log1 is a letter log
31        if (isDigitLog2) {
32            return true;
33        }
35        // If both logs are letter logs, compare their contents excluding identifier
36        std::string contentLog1 = log1.substr(firstSpaceLog1 + 1);
37        std::string contentLog2 = log2.substr(firstSpaceLog2 + 1);
39        // If the contents are equal, sort based on the lexicographical order of the entire log
40        if (contentLog1 == contentLog2) {
41            return log1 < log2;
42        }
44        // Otherwise, sort based on the lexicographical order of just the contents
45        return contentLog1 < contentLog2;
46    });
48    // Return the reordered logs
49    return logs;
1function reorderLogFiles(logs: string[]): string[] {
2    // Function to check if a character is a digit
3    const isDigit = (char: string): boolean => char >= '0' && char <= '9';
5    // Custom sort function for log files
6    return logs.sort((log1, log2) => {
7        // Check last character of log1 and log2 to determine if they are digit logs
8        const lastCharLog1 = log1[log1.length - 1];
9        const lastCharLog2 = log2[log2.length - 1];
11        // If both logs are digit logs, maintain their relative order
12        if (isDigit(lastCharLog1) && isDigit(lastCharLog2)) {
13            return 0;
14        }
16        // If log1 is a digit log, it should come after log2 if log2 is a letter log
17        if (isDigit(lastCharLog1)) {
18            return 1;
19        }
21        // If log2 is a digit log, it should come after log1 if log1 is a letter log
22        if (isDigit(lastCharLog2)) {
23            return -1;
24        }
26        // If both logs are letter logs, compare based on content excluding identifier
27        const contentLog1 = log1.split(' ').slice(1).join(' ');
28        const contentLog2 = log2.split(' ').slice(1).join(' ');
30        // If contents are equal, sort based on lexicographical order of the entire log
31        if (contentLog1 === contentLog2) {
32            return log1.localeCompare(log2); // Changed to use standard localeCompare for string comparison
33        }
35        // Otherwise, sort based on the lexicographical order of just the content
36        return contentLog1.localeCompare(contentLog2); // Changed to use standard localeCompare for string comparison
37    });

Time and Space Complexity

The time complexity of the given code is O(NlogN), where N is the number of logs. This arises from the use of the sorted function, which typically has O(NlogN) time complexity for sorting an array. Specifically, every comparison between two logs requires string comparison, and in the worst case, each comparison can take O(M) time, where M is the maximum length of a log file. However, assuming M is relatively small and therefore the comparison time is constant, the overall time complexity still remains O(NlogN).

The space complexity of the code is O(N). This is because the sorting algorithm used in Python (Timsort) is a hybrid stable sorting algorithm derived from merge sort and insertion sort characterizes O(N) space complexity. This space is needed to hold the intermediate results for the sorted array. Furthermore, the extra space needed for the lambda function's return values is not significant compared to the space needed for these intermediate results as they do not depend on the number of logs N.

Learn more about how to find time and space complexity quickly using problem constraints.

Fast Track Your Learning with Our Quick Skills Quiz:

Which data structure is used to implement recursion?

Recommended Readings

Got a question? Ask the Monster Assistant anything you don't understand.

Still not clear? Ask in the Forum,  Discord or Submit the part you don't understand to our editors.

Tired of the LeetCode Grind?

Our structured approach teaches you the patterns behind problems, so you can confidently solve any challenge. Get started now to land your dream tech job.

Get Started