Welcome to Subscribe On Youtube

937. Reorder Data in Log Files

Description

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:

1. The letter-logs come before all digit-logs.
2. The letter-logs are sorted lexicographically by their contents. If their contents are the same, then sort them lexicographically by their identifiers.
3. 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.

Solutions

• Java
• Python
• TypeScript
• RenderScript
• C++
• Go

• class Solution {
      public String[] reorderLogFiles(String[] logs) {
          Arrays.sort(logs, this::cmp);
          return logs;
      }
  
      private int cmp(String a, String b) {
          String[] t1 = a.split(" ", 2);
          String[] t2 = b.split(" ", 2);
          boolean d1 = Character.isDigit(t1[1].charAt(0));
          boolean d2 = Character.isDigit(t2[1].charAt(0));
          if (!d1 && !d2) {
              int v = t1[1].compareTo(t2[1]);
              return v == 0 ? t1[0].compareTo(t2[0]) : v;
          }
          if (d1 && d2) {
              return 0;
          }
          return d1 ? 1 : -1;
      }
  }
  

• class Solution:
      def reorderLogFiles(self, logs: List[str]) -> List[str]:
          def cmp(x):
              a, b = x.split(' ', 1)
              return (0, b, a) if b[0].isalpha() else (1,)
  
          return sorted(logs, key=cmp)
  
  

• function reorderLogFiles(logs: string[]): string[] {
      const isDigit = (c: string) => c >= '0' && c <= '9';
      return logs.sort((a, b) => {
          const end1 = a[a.length - 1];
          const end2 = b[b.length - 1];
          if (isDigit(end1) && isDigit(end2)) {
              return 0;
          }
          if (isDigit(end1)) {
              return 1;
          }
          if (isDigit(end2)) {
              return -1;
          }
          const content1 = a.split(' ').slice(1).join(' ');
          const content2 = b.split(' ').slice(1).join(' ');
          if (content1 === content2) {
              return a < b ? -1 : 1;
          }
          return content1 < content2 ? -1 : 1;
      });
  }
  
  

• impl Solution {
      pub fn reorder_log_files(mut logs: Vec<String>) -> Vec<String> {
          logs.sort_by(|s1, s2| {
              let (start1, content1) = s1.split_once(' ').unwrap();
              let (start2, content2) = s2.split_once(' ').unwrap();
              match
                  (
                      content1.chars().nth(0).unwrap().is_digit(10),
                      content2.chars().nth(0).unwrap().is_digit(10),
                  )
              {
                  (true, true) => std::cmp::Ordering::Equal,
                  (true, false) => std::cmp::Ordering::Greater,
                  (false, true) => std::cmp::Ordering::Less,
                  (false, false) => content1.cmp(&content2).then(start1.cmp(&start2)),
              }
          });
          logs
      }
  }
  
  

• class Solution {
  public:
      vector<string> reorderLogFiles(vector<string>& logs) {
          stable_sort(logs.begin(), logs.end(), [](const string& log1, const string& log2) {
              int idx1 = log1.find(' ');
              int idx2 = log2.find(' ');
              string id1 = log1.substr(0, idx1);
              string id2 = log2.substr(0, idx2);
              string content1 = log1.substr(idx1 + 1);
              string content2 = log2.substr(idx2 + 1);
  
              bool isLetter1 = isalpha(content1[0]);
              bool isLetter2 = isalpha(content2[0]);
  
              if (isLetter1 && isLetter2) {
                  if (content1 != content2) {
                      return content1 < content2;
                  }
                  return id1 < id2;
              }
  
              return isLetter1 > isLetter2;
          });
  
          return logs;
      }
  };
  
  

• func reorderLogFiles(logs []string) []string {
  	sort.SliceStable(logs, func(i, j int) bool {
  		log1, log2 := logs[i], logs[j]
  		idx1 := strings.IndexByte(log1, ' ')
  		idx2 := strings.IndexByte(log2, ' ')
  		id1, content1 := log1[:idx1], log1[idx1+1:]
  		id2, content2 := log2[:idx2], log2[idx2+1:]
  
  		isLetter1 := 'a' <= content1[0] && content1[0] <= 'z'
  		isLetter2 := 'a' <= content2[0] && content2[0] <= 'z'
  
  		if isLetter1 && isLetter2 {
  			if content1 != content2 {
  				return content1 < content2
  			}
  			return id1 < id2
  		}
  
  		return isLetter1 && !isLetter2
  	})
  
  	return logs
  }
  
  

All Problems

All Solutions