Leetcode 937. Reorder Data in Log Files (字符串处理题)

937. Reorder Data in Log Files
     Medium

You are given an array of logs. Each log is a space-delimited string of words, where the first word is the identifier.

There are two types of logs:

Letter-logs: All words (except the identifier) consist of lowercase English letters.
Digit-logs: All words (except the identifier) consist of digits.
Reorder these logs so that:

The letter-logs come before all digit-logs.
The letter-logs are sorted lexicographically by their contents. If their contents are the same, then sort them lexicographically by their identifiers.
The digit-logs maintain their relative ordering.
Return the final order of the logs.

Example 1:

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”]
Explanation:
The letter-log contents are all different, so their ordering is “art can”, “art zero”, “own kit dig”.
The digit-logs have a relative order of “dig1 8 1 5 1”, “dig2 3 6”.
Example 2:

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

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.

解法1: 注意find()和find_first_of()的区别。这里两个应该都可以。
https://stackoverflow.com/questions/29424323/find-vs-find-first-of-when-searching-for-empty-string
s.find(t) finds the first occurrence of the substring t in s. If t is empty, then that occurrence is at the beginning of s, and s.find(t) will return 0.
s.find_first_of(t) finds the first occurrence of one of the characters in t. If t is the empty string, then there are no characters in t, so no occurrence can be found, and find_first_of will return npos.

class Solution {
public:
    vector<string> reorderLogFiles(vector<string>& logs) {
        vector<string> letterLogs;
        vector<string> digitLogs;
        int n = logs.size();
        for (int i = 0; i < n; i++) {
            string str = logs[i];
            int pos = str.find(" ");
            string identifier = str.substr(0, pos);
            string content = str.substr(pos + 1);
            if (isdigit(content[0])) digitLogs.push_back(str);
            else letterLogs.push_back(str);
        }
        sort(letterLogs.begin(), letterLogs.end(), [](const string &log1, const string &log2){
            int pos1 = log1.find(" ");
            int pos2 = log2.find(" ");
            string content1 = log1.substr(pos1 + 1);
            string content2 = log2.substr(pos2 + 1);
            //return content1 < content2 ? true : log1 < log2;
            return content1 == content2 ? log1 < log2 : content1 < content2;
        });
        vector<string> res;
        for (auto log : letterLogs) {
            res.push_back(log);
        }
        for (auto log : digitLogs) {
            res.push_back(log);
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32