RUST GYM Leetcode 937 Reorder Data in Log Files Rust Solution

937. Reorder Data in Log Files

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.

Rust Solution

struct Solution;

use std::cmp::Ordering::*;

impl Solution {
    fn reorder_log_files(mut logs: Vec<String>) -> Vec<String> {
        logs.sort_by(|a, b| {
            let i = a.find(' ').unwrap();
            let j = b.find(' ').unwrap();
            let ar = &a[i + 1..];
            let br = &b[j + 1..];
            let ac = a.chars().last().unwrap();
            let bc = b.chars().last().unwrap();
            match (char::is_digit(ac, 10), char::is_digit(bc, 10)) {
                (true, true) => Equal,
                (true, false) => Greater,
                (false, true) => Less,
                (false, false) => {
                    let ordering = ar.cmp(br);
                    if ordering == Equal {
                        a.cmp(b)
                    } else {
                        ordering
                    }
                }
            }
        });
        logs
    }
}

#[test]
fn test() {
    let input: Vec<String> = vec_string![
        "a1 9 2 3 1",
        "g1 act car",
        "zo4 4 7",
        "ab1 off key dog",
        "a8 act zoo"
    ];
    let output: Vec<String> = vec_string![
        "g1 act car",
        "a8 act zoo",
        "ab1 off key dog",
        "a1 9 2 3 1",
        "zo4 4 7"
    ];
    assert_eq!(Solution::reorder_log_files(input), output);
}

Having problems with this solution? Click here to submit an issue on github.