Reorder Data in Log Files - Practice Coding Problems

Reorder Data in Log Files - Problem

Reorder Data in Log Files is a classic string manipulation and sorting problem that simulates organizing server logs. You're given an array of log entries where each log is a space-delimited string. The first word is always the identifier, and the remaining words determine the log type:

Letter-logs: All words after the identifier contain only lowercase English letters
Digit-logs: All words after the identifier contain only digits

Your task is to reorder these logs according to specific rules:
1. All letter-logs must come before digit-logs
2. Letter-logs are sorted lexicographically by their content (words after identifier)
3. If content is identical, sort by identifier lexicographically
4. Digit-logs maintain their original relative order

This problem tests your understanding of custom sorting and stable sorting algorithms.

Input & Output

example_1.py — Basic Mixed Logs

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

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

💡 Note: Letter-logs are sorted: "art can" comes before "art zero" which comes before "own kit dig". Since "let1 art can" and "let3 art zero" both start with "art", we compare the full content: "art can" < "art zero". Digit-logs maintain their original relative order.

example_2.py — Identical Content

$ Input: logs = ["a1 9 2 3 1", "g1 act car", "zo4 4 7", "ab1 off key dog", "a8 act zoo", "a2 act car"]

› Output: ["a2 act car", "g1 act car", "a8 act zoo", "ab1 off key dog", "a1 9 2 3 1", "zo4 4 7"]

💡 Note: Letter-logs with identical content "act car" are sorted by identifier: "a2" comes before "g1". All letter-logs come before digit-logs which maintain their original order.

example_3.py — Edge Case

$ Input: logs = ["1 n u", "r 527", "j 893", "6 14", "6 82"]

› Output: ["1 n u", "r 527", "j 893", "6 14", "6 82"]

💡 Note: Only "1 n u" is a letter-log (contains letters), so it comes first. All others are digit-logs and maintain their original relative order.

Constraints

1 ≤ logs.length ≤ 100
3 ≤ logs[i].length ≤ 100
All the tokens of logs[i] are separated by a single space
logs[i] is guaranteed to have an identifier and at least one word after the identifier
The identifier consists of lowercase English letters and digits
Letter-logs contain only lowercase English letters in the content
Digit-logs contain only digits in the content

Visualization

Tap to expand

Understanding the Visualization

Identify Document Types

Separate research papers (letter-logs) from financial records (digit-logs) based on content type

Organize Research Papers

Sort research papers alphabetically by subject, then by document ID if subjects match

Maintain Financial Order

Keep financial records in their original chronological sequence for audit compliance

Combine Filing System

Place all organized research papers first, followed by financial records in original order

Key Takeaway

🎯 Key Insight: Custom sorting with comparators allows us to handle complex ordering requirements efficiently. By treating different data types with distinct sorting rules while maintaining stability for unchanged elements, we achieve optimal organization in O(n log n) time.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 18

The optimal solution uses a custom comparator with the built-in sorting algorithm. We parse each log to determine if it's a letter-log or digit-log, then apply specific sorting rules: letter-logs come first and are sorted lexicographically by content then identifier, while digit-logs maintain their relative order. This achieves O(n log n) time complexity with clean, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Bubble Sort with Custom Logic)	O(n² × m)	O(1)	Use bubble sort with custom comparison logic for each pair
Custom Sorting (Optimal)	O(n log n × m)	O(log n)	Use built-in sorting with custom comparator function

Brute Force (Bubble Sort with Custom Logic) — Algorithm Steps

For each position i from 0 to n-2
For each position j from 0 to n-2-i
Parse both logs[j] and logs[j+1] to determine type and content
Apply custom comparison logic and swap if needed
Repeat until no swaps occur in a complete pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Each Log

Split each log into identifier and content, determine if it's letter-log or digit-log

Compare Adjacent Pairs

Apply custom comparison: letter-logs before digit-logs, then sort letter-logs lexicographically

Bubble Up Correctly Ordered

Swap elements if they're in wrong order, continue until no swaps needed

Code -

solution.c — C

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

int compareLogs(const char* log1, const char* log2) {
    char id1[20], id2[20], content1[1000], content2[1000];
    sscanf(log1, "%s %[^\n]", id1, content1);
    sscanf(log2, "%s %[^\n]", id2, content2);
    
    int isLetter1 = isalpha(content1[0]);
    int isLetter2 = isalpha(content2[0]);
    
    if (isLetter1 && !isLetter2) return -1;
    if (!isLetter1 && isLetter2) return 1;
    if (!isLetter1 && !isLetter2) return 0;
    
    int contentCmp = strcmp(content1, content2);
    if (contentCmp != 0) return contentCmp;
    return strcmp(id1, id2);
}

char** reorderLogFiles(char** logs, int logsSize, int* returnSize) {
    *returnSize = logsSize;
    
    for (int i = 0; i < logsSize; i++) {
        for (int j = 0; j < logsSize - i - 1; j++) {
            if (compareLogs(logs[j], logs[j + 1]) > 0) {
                char* temp = logs[j];
                logs[j] = logs[j + 1];
                logs[j + 1] = temp;
            }
        }
    }
    return logs;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for bubble sort iterations, m for string comparison operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for swapping and parsing

✓ Linear Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Bubble Sort with Custom Logic) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler