# 937 Reorder-Data-in-Log-Files

difficulty: Easy

&#x20;section pre{ background-color: #eee; border: 1px solid #ddd; padding:10px; border-radius: 5px; }&#x20;

You have an array of `logs`.  Each log is a space delimited string of words.

For each log, the first word in each log is an alphanumeric *identifier*.  Then, either:

* Each word after the identifier will consist only of lowercase letters, or;
* Each word after the identifier will consist only of digits.

We will call these two varieties of logs *letter-logs* and *digit-logs*.  It is guaranteed that each log has at least one word after its identifier.

Reorder the logs so that all of the letter-logs come before any digit-log.  The letter-logs are ordered lexicographically ignoring identifier, with the identifier used in case of ties.  The digit-logs should be put in their original order.

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"]
```

**Constraints:**

1. `0 <= logs.length <= 100`
2. `3 <= logs[i].length <= 100`
3. `logs[i]` is guaranteed to have an identifier, and a word after the identifier.

## Method One

```java
class Solution {
    public String[] reorderLogFiles(String[] logs) {
        Arrays.sort(logs, (a,b) -> {
            // 用空白分隔符给分成两段，第一段是identifier, 第二段是log内容
            String[] splitA = a.split(" ",2);
            String[] splitB = b.split(" ",2);

            //题目的描述不清楚。它的排序规则是，
            // 首先我们比较 log 的内容，letter 排在 digit 之前。
            // 都是digit 那么不排序，都是 letter 按 lexicographical 排序。
            // letter一样再给 identifier 按 lexicalgraphcial 排序
            String idenA = splitA[0];
            String idenB = splitB[0];
            String logA = splitA[1];
            String logB = splitB[1];
            boolean isADigit = Character.isDigit(logA.charAt(0));
            boolean isBDigit = Character.isDigit(logB.charAt(0));
            if(isADigit && isBDigit){
                return 0;
            }
            if(!isADigit && !isBDigit){
                int cmp = logA.compareTo(logB);
                if( cmp != 0){
                    return cmp;
                }
                return idenA.compareTo(idenB);
            }
            return isADigit ? 1 : -1;
        } );
        return logs;
    }
}​
```
