Rust: codewars的prize draw算法

这道codewars的prize draw算法题，很有意思，能很好看看rust与众不同的用法。
一、prize draw
资料来源：https://www.codewars.com/kata/prize-draw/solutions/rust

1、26个字母字符按字母表的顺序分别有相应的值，比如A为1，B为2…..,一直到Z:26； 其中大小写不区分。
2、对一个由26个字母字符构成的字符串，字符串对应的值（value）由两部分决定：
（1）字母串的值(val)先由每个字母字符的值相加而得，再加上字符串本身的长度（length）得到字符串值。
（2）字母串最终值由字符串值（val）和赋给的权重(weight)相乘而得。

3、举例

names: COLIN,AMANDBA,AMANDAB,CAROL,PauL,JOSEPH
weights: [1, 4, 4, 5, 2, 1]
对于PauL：
val： = length of Paul + 16 + 1 + 21 + 12 = 4 + 50 -> 54 。
weight： 2；
value = 54 * 2 = 108.

4、对相关的字符对应的value进行降序排列；
5、如果两个字符的value相等，那么，则按字符串的字母顺序进行降序排序：
(1)’a’>’b’>’c’>’d’…….;
(2)如果第一个字母相同，就比第二个字母…..
即，若对于两个都是108的value的字符串进行降序排列的话，就应把第一个字母是’a’的排在是’b’的前面（值大）。

6、给定一个可用”,”切分的字符长串（st），以及对应切分后的字符串的相关weight,请返回按降序排列中第n位的字符。

函数格式：
rank(st: &str, we: Vec, n: usize) -> &str{//
}
其中参数：
st: 如”COLIN,AMANDBA,AMANDAB,CAROL,PauL,JOSEPH” //可以按”,”切分。
we: 如[1, 4, 4, 5, 2, 1]
n: 4

fn main() {
    let st = SystemTime::now();
    let dd = rank("Addison,Jayden,Sofia,Michael,Andrew,Lily,Benjamin",
                  vec![4, 2, 1, 4, 3, 1, 2],
                  4); //返回=>Benjamin
    println!("dd,rank:{}", dd);
    println!("_sort:{:?}   ", sort_str(vec!["aaa", "bbb", "abc"]));
    let d1 = rank("Elijah,Chloe,Elizabeth,Matthew,Natalie,Jayden",
                  vec![1, 3, 5, 5, 3, 6],
                  2); //返回=> "Matthew");
    println!("d1=>{:?}", d1);
    let d2 = rank("Aubrey,Olivai,Abigail,Chloe,Andrew,Elizabeth",
                  vec![3, 1, 4, 4, 3, 2],
                  4); //返回=>"Abigail");
    println!("d2 :{}", d2);
    let d3 = rank("Lagon,Lily", vec![1, 5], 2); // 返回=>"Lagon");
    println!("d3:{}", d3);
}

7、其它说明：

若st为空，则返回 “No participants”.
若 n> is 切分后字符串的数量，则返回 “Not enough participants”.

二、我的解法

use std::collections::HashMap;
fn rank(st: &str, we: Vec<i32>, n: usize) -> &str {
    if n > st.clone().len() {
        return "No participants";
    }
    let strs: Vec<&str> = st.split(',').collect();
    if n > strs.clone().len() {
        return "Not enough participants";
    }
    let scores: Vec<i32> = strs.clone().iter().map(|x| total(x)).collect();
    let scores: Vec<i32> = scores.into_iter()
        .zip(we.clone().into_iter())
        .collect::<Vec<_>>()
        .iter()
        .map(|x| x.0 * x.1)
        .collect();
    let mut copy_scores = scores.clone();
    copy_scores.sort_by(|a, b| b.cmp(a));
    let name_scores: HashMap<&str, i32> =
        strs.clone().into_iter().zip(scores.clone().into_iter()).collect();
    let len = copy_scores.len();
    let copy_strs = strs.clone();
    let mut sort_names: Vec<&str> = Vec::new();
    for i in 0..len {
        let score_i = &copy_scores[i];
        if i > 0 {
            if score_i == &copy_scores[i - 1] {
                continue;
            }
        }
        let score_i_names: Vec<&str> = copy_strs.clone()
            .into_iter()
            .filter(|x| name_scores.get(x).unwrap() == score_i)
            .collect();
        let score_sorted = sort_str(score_i_names);
        for sc in score_sorted {
            sort_names.push(sc);
        }
    }
    &sort_names[n - 1]
}
fn total(name: &str) -> i32 {
    let data: HashMap<char, i32> =
        "abcdefghijklmnopqrstuvwxyz".chars().enumerate().map(|(x, y)| (y, x as i32 + 1)).collect();
    name.to_lowercase().chars().fold(0, |total, x| total + data.get(&x).unwrap()) +
    name.len() as i32
}
fn sort_str<'a>(names: Vec<&'a str>) -> Vec<&'a str> {
    let n: usize = names.len();
    let mut _names = names.clone();
    for i in 0..n - 1 {
        for j in i + 1..n {

            let (na, _) = _sort_by(names.clone().get(i).unwrap(),
                                   names.clone().get(j).unwrap(),
                                   0);
            if &na != names.clone().get(i).unwrap() {
                _names = _sort(_names, i, j);
            }
        }
    }
    _names
}
fn _sort<'a>(names: Vec<&'a str>, n: usize, m: usize) -> Vec<&'a str> {

    let mut _names = names;
    let nval: &'a str = _names.clone().get(n).unwrap();
    let mval: &'a str = _names.clone().get(m).unwrap();

    if let Some(elem) = _names.get_mut(n) {
        *elem = mval;
    }
    if let Some(elem) = _names.get_mut(m) {
        *elem = nval;
    }
    _names
}

fn _sort_by<'a>(name1: &'a str, name2: &'a str, n: usize) -> (&'a str, &'a str) {
    let n1 = name1.len();
    let n2 = name2.len();
    let min_n = match n1 < n2 {
        true => n1,
        _ => n2,
    };
    if n > min_n - 1 {
        return (&name1, &name2);
    } else {
        if &name1.chars().nth(n) < &name2.chars().nth(n) {
            (&name1, &name2)
        } else if &name1.chars().nth(n) == &name2.chars().nth(n) {
            if n == min_n {
                return (&name1, &name2);
            }
            _sort_by(name1, name2, n + 1)
        } else {
            (&name2, &name1)
        }
    }
}

三、其它精彩的解法

1、

fn letter_values(value: &str) -> i32 {
    let charactor_total: i32 = value
        .chars()
        .map(|x| x.to_digit(36).unwrap_or(0) as i32)
        .map(|x| x - 9)
        .sum();
    charactor_total + (value.len() as i32)
}

fn rank_names(st: &str, we: Vec<i32>) -> Vec<(i32, &str)> {
    let names = st.split(',');
    let mut raffles = names
        .clone()
        .into_iter()
        .map(|x| String::from(x))
        .zip(we)
        .map(|(left, right)| letter_values(&left) * (right))
        .zip(names)
        .collect::<Vec<(i32, &str)>>();

    raffles.sort_by(|&(_, a), &(_, b)| a.cmp(&b));
    raffles.sort_by(|&(a, _), &(b, _)| b.cmp(&a));
    raffles

}

fn rank(st: &str, we: Vec<i32>, n: usize) -> &str {
    let raffles = rank_names(&st, we);
    if st.len() == 0 {
      return "No participants";
    }
    let (_, winning_name) = raffles.into_iter().nth(n - 1).unwrap_or((0, "Not enough participants"));
    &winning_name
}

2、

const A_BYTE: u16 = 'a' as u16;

fn rank(st: &str, we: Vec<i32>, n: usize) -> &str {
    if st.is_empty() { return "No participants"; }

    let participants = st.split(',').collect::<Vec<_>>();
    if n > participants.len() { return "Not enough participants"; }

    let mut winning_numbers_vec = participants.into_iter().zip(we).map(winning_number).collect::<Vec<_>>();
    let winning_numbers = winning_numbers_vec.as_mut_slice();
    winning_numbers.sort();
    let (_, name) = winning_numbers[n-1];
    name
}

fn winning_number(pair: (&str,i32)) -> (i32,&str) {
    let (name, weight) = pair;
    let n =
        name.to_lowercase()                                //Case insensitive
        .into_bytes()                                      //ASCII code
        .into_iter().map(|byte| byte as u16 - A_BYTE + 1)  //Alphabet order
        .fold(name.len() as u16, |n, value| n + value);    //Sum values
    (n as i32 * -weight, name)
}

3、

fn rank(st: &str, we: Vec<i32>, n: usize) -> &str {
    if st.len() == 0 {
        return "No participants";
    }
    let names = st
        .split(',')
        .collect::<Vec<&str>>()
    ;
    if n > names.len() {
        return "Not enough participants";
    }
    let mut sorted = names
        .iter()
        .map(|name| name
            .to_lowercase()
            .bytes()
            .map(|byte| byte as usize - 96)
            .collect::<Vec<usize>>()
        )
        .map(|vector| vector.len() + vector.iter().sum::<usize>())
        .zip(we)
        .map(|(number, weight)| number * weight as usize)
        .zip(names.clone())
        .collect::<Vec<(usize, &str)>>()
    ;
    sorted.sort_by_key(|&(_, n)| n.to_lowercase());
    sorted.sort_by_key(|&(w, _)| -(w as isize));
    sorted[n-1].1
}

4、

fn word_rank(w: &str) -> usize {
    w.len() + w.to_lowercase().chars().map(|c| c as usize - 96).sum::<usize>()
}

fn rank(st: &str, we: Vec<i32>, n: usize) -> &str {
    let ws: Vec<&str> = st.split(',').filter(|s| s.len() > 0).collect();
    if ws.len() == 0 {
        return "No participants";
    }
    if n > ws.len() {
        return "Not enough participants";
    }
    let vs: Vec<_> = ws.iter().map(|w| word_rank(w))
        .zip(we.iter()).map(|(a, &b)| a * (b as usize)).collect();
    let mut rk: Vec<_> = (0..ws.len()).collect();
    // rk.sort_by(|&i, &j| vs[j].cmp(&vs[i]).then(ws[i].cmp(ws[j])));
    rk.sort_by(|&i, &j| {
        let r = vs[j].cmp(&vs[i]);
        if r == std::cmp::Ordering::Equal {ws[i].cmp(ws[j])} else {r}
    });
    ws[rk[n-1]]
}

6、

static RANKS: &'static str = "abcdefghijklmnopqrstuvwxyz";

fn rank(st: &str, we: Vec<i32>, n: usize) -> &str {
    if st.is_empty() { return "No participants"; }
    let names: Vec<&str> = st.split(",").collect();
    if n > names.len() { return "Not enough participants"; }
    let mut name_ranks: Vec<(i32, &str)> = names.iter().zip(we).map(|(&name, weight)| {
        let winning_number = weight * name.to_lowercase().chars().fold(name.len(), |sum, x| sum + RANKS.chars().position(|y| y == x).unwrap() + 1) as i32;
        (-winning_number, name)
    }).collect();
    name_ranks.sort();
    name_ranks[n-1].1
}