leetcode 937. Reorder Log Files

Before the first AC, I was not quite sure if Arrays.sort is stable.

so I wrote something like this.

        static public String[] reorderLogFiles(String[] logs) {
            int i = logs.length;
            for (int j = logs.length - 1; j >= 0; --j) {
                if (isDigitLog(logs[j])) {
                    String tmp = logs[--i];
                    logs[i] = logs[j];
                    logs[j] = tmp;
                }
            }
            Arrays.sort(logs, 0, i , (a, b) -> {
                return reorder(a).compareTo(reorder(b));
            });
            return logs;
        }
    
        static public String reorder(String s) {
            int i = 0;
            for (; s.charAt(i) != ' '; ++i);
            return s.substring(i + 1, s.length()) + " " + s.substring(0, i);
        }
    
        static public boolean isDigitLog(String s) {
            int i = 0;
            for (; s.charAt(i) != ' '; ++i);
            return Character.isDigit(s.charAt(i + 1));
        }

After read Arrays.sort's doc. (Surely stable sort), we can do it like this

    class Solution {
        public String[] reorderLogFiles(String[] logs) {
            Arrays.sort(logs, (a, b) -> {
                String[] ac = a.split(" ", 2);
                String[] bc = b.split(" ", 2);
                boolean aDigit =  Character.isDigit(ac[1].charAt(0));
                boolean bDigit =  Character.isDigit(bc[1].charAt(0));
                if (aDigit && bDigit) return 0;
                else if (aDigit && !bDigit) return 1;
                else if (!aDigit && bDigit) return -1;
                else {
                    int cmp = ac[1].compareTo(bc[1]);
                    if (cmp == 0) {
                        return ac[0].compareTo(bc[0]);
                    }
                    else {
                        return cmp;
                    }
                }
            });
            return logs;
        }
    }