Rust: Descending Order

算法，容易的要命。

如下：

Input: 21445 Output: 54421 # 排序输出

Input: 145263 Output: 654321

Input: 1254859723 Output: 9875543221

一、
1.0 ：六行大代码

fn descending_order(x: u64) -> u64 {
    let mut data: Vec<i64> = x.to_string()
        .chars()
        .map(|x| (x.to_string()).parse::<i64>().unwrap())
        .collect::<Vec<i64>>();
    data.sort_by(|a, b| b.cmp(a));
    let data2: Vec<String> = data.iter().map(|&x| x.to_string()).collect();
    let mut data3: String = "".to_string();
    data2
        .into_iter()
        .map(|x| data3.push_str(&x))
        .collect::<Vec<_>>();
    data3.parse::<u64>().unwrap()
}

2.0 ：四行大代码

fn descending_order(x: u64) -> u64 {
    let mut data: Vec<i64> = x.to_string()
        .chars()
        .map(|x| (x.to_string()).parse::<i64>().unwrap())
        .collect::<Vec<i64>>();
    data.sort_by(|a, b| b.cmp(a));
    let data2: Vec<String> = data.iter().map(|&x| x.to_string()).collect();
    data2
        .into_iter()
        .fold("".to_string(), |s, x| s + &x)
        .parse::<u64>()
        .unwrap()
}

3.0 : 三行大代码

fn descending_order(x: u64) -> u64 {
    let mut data: Vec<i64> = x.to_string()
        .chars()
        .map(|x| (x.to_string()).parse::<i64>().unwrap())
        .collect::<Vec<i64>>();
    data.sort_by(|a, b| b.cmp(a));
    data.iter()
        .fold("".to_string(), |s, x| s + &(x.to_string()))
        .parse::<u64>()
        .unwrap()
}

二、String::from_iter()

use std::iter::FromIterator;
fn descending_order(x: u64) -> u64 {
    let mut result = x.to_string().chars().collect::<Vec<char>>();
    result.sort_by(|a, b| b.cmp(a));
    String::from_iter(result).parse::<u64>().unwrap()
}

三、

fn descending_order(x: u64) -> u64 {
    let mut chars: Vec<char> = x.to_string().chars().collect();
    chars.sort_by(|a, b| b.cmp(a));
    chars.into_iter().collect::<String>().parse().unwrap()
}

四、u64::from_str

use std::str::FromStr;

fn descending_order(x: u64) -> u64 {
    let mut chars = x.to_string().chars().collect::<Vec<char>>();
    chars.sort_by(|a, b| b.cmp(a));
    u64::from_str(&chars.iter().cloned().collect::<String>()).unwrap()
}

五、

fn descending_order(x: u64) -> u64 {
    let mut v = x.to_string().chars().collect::<Vec<char>>();
    v.sort_by(|a,b| b.cmp(a));
    v.iter().cloned().collect::<String>().parse::<u64>().unwrap()
}

六、

fn descending_order(x: u64) -> u64 {
  let mut v = x.to_string().chars().collect::<Vec<char>>();
  v.sort_by(|&a, &b| a.cmp(&b).reverse());
  v.into_iter().collect::<String>().parse().unwrap()
}