zoukankan      html  css  js  c++  java
  • 937. Reorder Log Files

    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: ["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"]

    Note:

    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.

    Approach #1: Sort. [Java]

    class Solution {
        public String[] reorderLogFiles(String[] logs) {
            Comparator<String> myComp = new Comparator<String>() {
                @Override
                public int compare(String s1, String s2) {
                    int s1si = s1.indexOf(' ');
                    int s2si = s2.indexOf(' ');
                    char s1fc = s1.charAt(s1si+1);
                    char s2fc = s2.charAt(s2si+1);
                    if (s1fc <= '9') {
                        if (s2fc <= '9') return 0;
                        else return 1;
                    }
                    if (s2fc <= '9') return -1;
                    int preCompute = s1.substring(s1si+1).compareTo(s2.substring(s2si+1));
                    if (preCompute == 0) 
                        return s1.substring(0, s1si).compareTo(s2.substring(0, s2si));
                    return preCompute;
                }
            };
            
            Arrays.sort(logs, myComp);
            return logs;
        }
    }
    

      

    Analysis:

    This solution takes advantage of what we're guaranteed in the problem:

    1. guaranteed to have a word following an identifier (allows me to use indexOf(' ‘) freely.).

    2.letter logs need to be ordered lexicographically, so we can use built in compare function when we know we have two.

    3. number logs need to be sorted naturally, so we just say they are all "equal" to each other and trust java's built in sort feature to be stable.

    4. number logs need to be after letter logs, so once we find out they're differenct, we return one of the other and short-circuit.

    Reference:

    https://leetcode.com/problems/reorder-log-files/discuss/193872/Java-Nothing-Fancy-15-lines-5ms-all-clear.

    http://www.cnblogs.com/skywang12345/p/3324788.html

    永远渴望,大智若愚(stay hungry, stay foolish)
  • 相关阅读:
    IntelliJ IDEA 快捷键终极大全,速度收藏!
    49式!Python初级到高级招式都全了
    字节跳动三轮技术面_后端研发提前批
    这样让你的 IDEA 好用到飞起来!
    你 多久没有跳槽了?
    推荐几款能提升代码效率的笔记应用
    推荐 15 款编程游戏,从此谁都可以学编程!
    StackOverflow 创始人关于如何高效编程的清单
    11 条编程经验分享
    InnoDB和MyISAM存储引擎的区别
  • 原文地址:https://www.cnblogs.com/h-hkai/p/10799385.html
Copyright © 2011-2022 走看看